# Learn NEAR Club

> Learn and Earn NEAR


## Posts

### Как запустить узел валидатора NEAR с помощью Node Studio

Node Studio - это программная платформа, разработанная для упрощения запуска узла валидатора NEAR и доступного для всех. Не требуется технических знаний - любой может настроить и запустить узел валидатора всего в несколько кликов. Node Studio также обрабатывает обслуживание и обновления, позволяя валидаторам сосредоточиться на участии в сети, не беспокоясь о сложных технических задачах. Узнайте больше и начните здесь:  https://nodestudio.metapool.app/
✨ Почему использовать Node Studio?

 	Низкая стоимость: ~$20 в месяц за VPS + 5 NEAR в месяц за Node Studio (обслуживание + поддержка + обновления). Обратите внимание, что цены на VPS устанавливаются непосредственно поставщиком инфраструктуры и могут изменяться со временем.
 	Обновления в один клик: Установите новые версии NEAR просто нажав кнопку.
 	Высокое время работы: 97–99% среднее время работы (гарантировано выше 90%).
 	Полная панель управления: отслеживание журналов, состояния узла, комиссии валидатора; доступно 24/7.
 	Полностью самостоятельное и безопасное управление: Node Studio автоматизирует большую часть процесса, но вы сохраняете полный контроль.

 	Никто из Meta Pool, Openmesh или любой внешней стороны не может получить доступ к вашим закрытым ключам или VPS. Ваши закрытые ключи остаются полностью под вашим контролем в любое время.
 	Ваш валидатор и вся связанная с ним информация полностью принадлежат вам.



⚠️ Обязанности управляющего узлом
Даже с автоматизацией большинства задач Node Studio, вам необходимо периодически проверять вашу панель управления, чтобы убедиться, что ваш валидатор работает без сбоев.

 	Отслеживание журналов: регулярно проверяйте на наличие ошибок или предупреждений.
 	Отслеживание использования диска: при достижении 80–85%, нажмите “Удалить данные цепочки NEAR”, чтобы освободить место и выполнить повторную синхронизацию.

 	Этот процесс занимает 25–75 минут; валидатор не будет производить эндорсменты в это время.
 	Время простоя не снижает время работы ниже 70% (минимальное для активного набора).


 	Проверка производительности валидатора: убедитесь, что производительность вашего валидатора остается выше 90% и никогда не падает ниже 70%, чтобы оставаться пригодным для активного набора.

⚠️ Важно: Периодически заходите в свою панель управления. Регулярное отслеживание необходимо для поддержания здоровья валидатора и оставания пригодным для программы Meta Pool.
🛠️ Шаг 1: Подготовка учетной записи Hivelocity

 	Создайте учетную запись Hivelocity:  Hivelocity.
 	Добавьте действующий способ оплаты и подтвердите его. https://my.hivelocity.net/billing/payment-methods
 	Сгенерируйте API-ключ в разделе Пользователь > Настройки > API-ключ. Сохраните его надежно. https://my.hivelocity.net/settings/api-keys

⚠️ Важно:
    Не покупайте или не арендуйте VPS-серверы напрямую у Hivelocity. Если вы уже это сделали, обратитесь к команде Meta Pool.
    Node Studio использует ваш API-ключ для автоматической аренды VPS.

Отказ от ответственности: Meta Pool не имеет партнерства, аффилиации или коммерческих отношений с Hivelocity. Рекомендация Hivelocity в качестве поставщика VPS основана исключительно на его доказанной надежности и балансе цены и качества. Любая покупка, аренда или контракт заключается непосредственно между пользователем и Hivelocity, без участия Meta Pool.
🛠️ Шаг 2: Подключение к Node Studio

    Перейдите на домашнюю страницу Node Studio. https://near.xnode.openmesh.network/
    Войдите, используя либо:
        
            Кошелек, совместимый с EVM (например, MetaMask) или
            Ваш аккаунт Google.
        
    
    Подпишите запрос на аутентификацию.

📸 [Рисунок 1: Экран входа в Node Studio]



🛠️ Шаг 3: Развертывание вашего VPS

    На домашней странице Node Studio нажмите Развернуть.
    Node Studio автоматически:
        
            Арендует VPS, используя ваш API-ключ Hivelocity.
            Устанавливает операционную систему.
            Настроит все необходимые пакеты для валидатора NEAR.
        
    

⚠️ Этот процесс обычно занимает ~10 минут.

В это время:

    Ваш VPS появится в списке на домашней странице.
    Как только он станет видимым, нажмите на него, чтобы перейти в Панель управления, где вы продолжите установку валидатора.

📸 [Рисунок 2: Экран развертывания с выбором VPS и полем для API-ключа]


 📸 [Рисунок 3: Домашняя страница с перечисленными VPS]



🛠️ Шаг 4: Установка вашего поддомена
После входа в Панель управления первым шагом будет установка поддомена. Это повышает безопасность и обеспечивает зашифрованное взаимодействие между вашим VPS, валидатором и Node Studio.

    Найдите поле Поддомен в Панели управления.
    Введите желаемое имя для вашего поддомена.
    Нажмите Заявить, чтобы сохранить его.

⚠️ Важно:

    Процесс может занять несколько минут.
    Не закрывайте и не обновляйте страницу, пока поддомен не будет полностью установлен.

📸 [Рисунок 4: Поле настройки поддомена в Панели управления]


🛠️ Шаг 5: Настройка вашего пула
 	Введите ваш Идентификатор пула (имя валидатора).

 	Должен быть уникальным и соответствовать:

 	Не использовать “Мета Пул”, оскорбительные термины или бренды.
 	Разрешены только следующие специальные символы: - (тире) и _ (подчеркивание).
 	Не использовать точки (.) или другие специальные символы.




 	Выберите тип пула:

 	poolv1.near → устаревший контракт, более высокая стоимость.
 	pool.near → обновляемая версия, более низкая стоимость; рекомендуется.


 	Опционально: Включить Pinger (отправляет автоматический пинг каждую эпоху, ~7.3 ч).

 	Требует небольшие затраты NEAR из вашего кошелька.
 	Не обязательно; Мета Пул предоставляет бесплатные автоматические пинги. Рекомендуется: не включать.


 	Установите Комиссию вознаграждения (комиссия валидатора).

 	⚠️ Максимально допустимая для программы Мета Пул: 7%.



📸 [Рисунок 5: Раздел Настройка пула с полями Идентификатор пула, версия пула, пингер и комиссия]


🛠️ Шаг 6: Управление вашим узлом

 	Нажмите Обновить ОС для настройки системы.
 	Нажмите Развернуть приложение NEAR, чтобы установить программное обеспечение валидатора.

📸 [Рисунок 6: Раздел Управление узлом с кнопками Обновить ОС и Развернуть]


🛠️ Шаг 7: Развертывание вашего стейкинг-пула

 	Перейдите к Управлению пулом.
 	Подключите ваш кошелек NEAR.
 	Убедитесь, что на кошельке есть как минимум 5 NEAR.
 	Нажмите Развернуть пул.

⚠️ Важно:

 	Этот кошелек становится владельцем контракта: только он может изменять стейкинг-пул или получать комиссии. Обезопасьте свою секретную фразу.
 	Данные из Настройки пула используются для создания контракта стейкинга.

 	Идентификатор пула и тип пула нельзя будет изменить позже.
 	Комиссия вознаграждения может быть обновлена.



📸 [Рисунок 7: Раздел Управление пулом с подключением кошелька и кнопкой Развернуть]


🛠️ Шаг 8: Синхронизация вашего валидатора

 	Проверьте панель журналов внизу панели инструментов.
 	Node Studio загрузит снимок и синхронизирует ваш валидатор.
 	Ожидаемое время синхронизации: ~1–2 часа.

📸 [Рисунок 8: Панель журналов, показывающая синхронизацию]


🛠️ Шаг 9: Подтвердите с Мета Пулом (Только для пользователей программы)
 	После запуска валидатора отправьте снимок логов команде Meta Pool.
 	Команда имеет 10 дней для делегирования цены места.
 	После делегирования ваш валидатор входит в активный набор на NEAR.

📸 [Рисунок 9: Пример синхронизированного журнала узла]


✅ Готово!
Ваш валидатор NEAR теперь активен.

 	Участники программы → ждите делегирования.
 	Независимые пользователи → начните стейкинг или принимайте делегаторов немедленно.
 	Начните свой путь валидатора и получайте вознаграждение за комиссии

ℹ️ Устранение неполадок

 	Узел не появляется? Проверьте подключение кошелька; подождите до 30 минут. Также проверьте Hivelocity, возможно, проблема с их стороны (например, проблема с верификацией, нельзя арендовать серверы)
 	Узел не синхронизируется? Убедитесь, что ОС обновлена и развертывание приложения NEAR завершено.
 	Не удалось развернуть пул? Убедитесь, что в кошельке NEAR есть ≥5 NEAR.

👉 Программа валидаторов Meta Pool:

Программа Node Studio - это инициатива поддержки, разработанная для помощи новым валидаторам начать работу на протоколе NEAR. Следующее издание начнется 1 октября 2025 года и будет доступно 63 слота.

Для участия в программе заявители должны сначала зарегистрироваться через Форму регистрации Node Studio и дождаться контакта и подтверждения от Meta Pool. Форма останется открытой для будущих изданий, о которых скоро будет объявлено, поэтому мы призываем вас зарегистрироваться даже если вы не получите слот в этом раунде.

Присоединившись к программе, валидаторы могут получить делегирование цены места и начать зарабатывать вознаграждения за комиссии, как только их валидатор войдет в активный набор на NEAR. Существующие валидаторы, у которых уже есть своя цена места, могут свободно использовать Node Studio. Участники программы также должны выполнять минимальные маркетинговые мероприятия, чтобы оставаться активными.

📢 Официальные объявления и обновления для программы Node Studio и программы валидаторов NEAR публикуются в:

 	[Телеграм-канал валидаторов Meta Pool] https://t.me/+nfNA4US6NHAyMTYx
 	[Дискорд-канал валидаторов Meta Pool] https://discord.gg/URYQ6Cyc9b

👉 Станьте частью будущего стейкинга NEAR - зарегистрируйтесь в программе Node Studio сегодня и упростите свой путь валидатора.

🔗 Зарегистрируйтесь здесь: Форма регистрации Node Studio

 
📞 Поддержка

 	[Телеграм-чат валидаторов Meta Pool] https://t.me/+nfNA4US6NHAyMTYx
 	[Дискорд-чат валидаторов Meta Pool] https://discord.gg/URYQ6Cyc9b

 

### Understanding Verification: From Simple File Checks to Securing TEEs

How do you know a download wasn’t corrupted, a software update wasn’t swapped, or a cloud machine is really running the code you trust? The answer is verification - methods that prove data and software are authentic and unchanged. We’ll start with everyday tools like file checksums and then move to Trusted Execution Environments (TEEs), a hardware-backed “safe room” for sensitive code and data. Along the way, you’ll see how remote attestation lets you trust a computer you don’t control, and how developers link open source code to what actually runs. We’ll use simple metaphors - sealed packages and verified couriers—to make each step clear.

Why Verification Matters
Everyday metaphor: a sealed package.When a parcel arrives, you check two things: the tamper-evident seal and the tracking number. If the seal is intact and the tracking number matches the seller’s record, you trust the contents. In computing, verification plays the same role: it tells you whether data or code has stayed the same from sender to receiver.


Hashes: Digital Fingerprints for Integrity
A cryptographic hash function takes any input (a file, message, or program) and produces a fixed-length output called a hash or checksum. Treat it like the package’s tracking number or a digital fingerprint.
Good cryptographic hashes have four key properties:


 	
Deterministic: The same input always gives the same hash.

 	
One-way: You can’t recover the input from the hash.

 	
Avalanche effect: Tiny changes make the hash look totally different.

 	
Collision-resistant: It’s infeasible to find two different inputs with the same hash.



Modern choices include SHA-256 and SHA-512. Older hashes like MD5 and SHA-1 are weak for security, but still useful to catch accidental corruption when copying files. Typical workflow: a project publishes a file and its SHA-256. After downloading, you compute the hash locally. If it matches, the file is very likely intact - like a tracking number that lines up.
        
            
                
                    Test SHA-256 in action
                    
                
                
                
                    SHA256:
                    
                
            
        
        

 
What Is a TEE?
A Trusted Execution Environment (TEE) is a secure, isolated area inside a processor. Think of it as a locked safe room inside a building. Sensitive code runs inside; sensitive data is processed inside. Even if the rest of the building (the operating system or cloud admin) is noisy or untrusted, the safe room keeps secrets protected.
Hardware enforces three promises:


 	
Data confidentiality: Outsiders cannot read the data while it’s in use.

 	
Data integrity: Outsiders cannot change that data while it’s in use.

 	
Code integrity: Outsiders cannot alter the code running in the TEE.



This makes TEEs useful for confidential cloud computing, privacy-preserving AI, and scenarios where you need results from machines you do not own.

Attestation: “Show Your ID Before I Hand Over Secrets”
Everyday metaphor: the verified courier.The sealed box (integrity) is not enough—you also want to know the courier is genuine. A real courier shows a badge issued by headquarters and may ask you to confirm a one-time pickup code. Only then do you hand over valuable items.
Remote attestation works the same way at a distance:


 	
State measurement (the parcel details): The TEE creates a report with measurements—hashes of the app code, configuration, and the TEE’s hardware/firmware versions.

 	
Cryptographic signing (the official badge): The TEE signs this report with a hardware-rooted private key fused into the chip—like a badge issued by the manufacturer.

 	
Delivery (handing over the ID): The signed report goes to the remote verifier.

 	
Verification (call HQ): The verifier checks the signature through a trusted chain back to the chip maker and compares the reported hashes to known-good values. It also includes a nonce (a random challenge) - like today’s unique pickup code—to prevent replays.

 	
Secure channel (step inside to talk in private): If all checks pass, the verifier opens an encrypted line directly to the app inside the TEE and can safely send secrets.


Real-world example: Before a hospital uploads patient data to a cloud AI, it verifies - via attestation—that the exact audited model binary is running inside a genuine TEE. Only then does it share the data.

https://learnnear.club/wp-content/uploads/2025/09/learn-about-attestion-with-ai.mp4
Closing the “Verification Gap”: From Source to Runtime
A sealed box delivered by a verified courier still leaves one question: Who packed the box, and did they use the public recipe? In software, attestation proves which binary is running, not that it was built from the public, audited source code you trust. That’s the verification gap.
End-to-end chain (the recipe, the kitchen, the seal):


 	
Source code verification (the public recipe): The source is open for review and audit.

 	
Build process integrity (the trustworthy kitchen):


 	
Reproducible build: Anyone can follow the recipe and produce the same jar with the same label (identical binary hash).

 	
Attested build: If reproducibility is hard, do the cooking inside a monitored kitchen (a TEE) that signs a log binding the recipe version (commit) to the finished jar’s label (binary hash).



 	
Runtime attestation (the courier + seal): Prove that the verified jar is exactly what’s being delivered and opened now.


With these stages linked, users gain high confidence that “the code we audited is the code that handled our data.”

Bringing It Together
Verification scales from quick file checks with SHA-256 to hardware-backed attestation in TEEs. Hashes are the tracking numbers. TEEs are the safe room. Attestation is the courier showing a badge and a fresh pickup code. And the recipe-to-jar link (reproducible or attested builds) closes the loop between open source and running software. Together, these layers turn “hope it’s fine” into “we can prove it.”

Takeaway
Trust should be earned, not assumed. Start with hashes for file integrity. Use TEEs to protect code and data in use. Require remote attestation before sharing secrets with the cloud. And insist on a verifiable link from source → build → runtime to close the gap.

Reflective Questions

 	
Where could simple hash checks prevent mistakes or attacks in your current workflows?

 	
Which tasks in your team would benefit most from running inside a TEE?

 	
Can you link your source code to deployed binaries (reproducible or attested builds)?

 	
What “known-good” reference values and policies will you use to validate attestation reports?



                
                        
                            Do you understand how verification works?
                         
 
                        Do you understand verification works?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### How to Run a NEAR Validator Node with Node Studio

Node Studio is a software platform designed to make running a NEAR validator node easy and accessible for everyone. No technical knowledge is required—anyone can set up and launch a validator node with just a few clicks. Node Studio also handles maintenance and updates, allowing validators to focus on participating in the network without worrying about complex technical tasks. Learn more and get started here: https://nodestudio.metapool.app/
✨ Why Use Node Studio?

 	Low cost: ~$20/month for VPS + 5 NEAR/month for Node Studio (maintenance + support + updates). Please note that VPS prices are set directly by the infrastructure provider and may change over time.
 	One-click Updates: Install new NEAR releases simply by pressing a button.
 	High Uptime: 97–99% average uptime (guaranteed above 90%).
 	Full Dashboard: monitor logs, node health, validator fee; available 24/7.
 	Fully self-managed and secure: Node Studio automates most of the process, but you retain full control.

 	No one from Meta Pool, Openmesh, or any external party can access your private keys or VPS. Your private keys remain fully under your control at all times.
 	Your validator and all associated data are completely owned by you.



⚠️ Responsibilities of the Node Runner
Even with Node Studio automating most tasks, you must check your Dashboard periodically to ensure your validator is running smoothly.

 	Monitor logs: check for errors or warnings regularly.
 	Monitor disk usage: when reaching 80–85%, click “Delete NEAR Chain Data” to free space and resync.

 	This process takes 25–75 minutes; the validator won’t produce endorsements during this time.
 	Downtime does not drop uptime below 70% (minimum for active set).


 	Check validator performance: ensure your validator’s production stays above 90% and never drops below 70% to remain eligible for the active set.

⚠️ Important: Enter your Dashboard periodically. Regular monitoring is essential to maintain validator health and stay eligible in the Meta Pool program.
🛠️ Step 1: Prepare Hivelocity Account

 	Create a Hivelocity account: Hivelocity.
 	Add a valid payment method and verify it. https://my.hivelocity.net/billing/payment-methods
 	Generate an API key under User > Settings > API Key. Save it securely. https://my.hivelocity.net/settings/api-keys

⚠️ Important:

 	Do not buy or rent VPS servers directly from Hivelocity. If you already did, please contact the Meta Pool team.

 	Node Studio uses your API key to rent the VPS automatically.

Disclaimer: Meta Pool has no partnership, affiliation, or commercial relationship with Hivelocity. The recommendation of Hivelocity as a VPS provider is based solely on its proven reliability and cost–quality balance. Any purchase, rental, or contract is made directly between the user and Hivelocity, without Meta Pool’s involvement.
🛠️ Step 2: Connect to Node Studio

 	Go to the Node Studio Home page. https://near.xnode.openmesh.network/
 	Log in using either:

 	An EVM-compatible wallet (e.g., MetaMask) or
 	Your Google account.


 	Sign the authentication request.

📸 [Figure 1: Node Studio login screen]



🛠️ Step 3: Deploy Your VPS

 	On the Home page of Node Studio, click Deploy.
 	Node Studio will automatically:

 	Rent the VPS using your Hivelocity API key.
 	Install the operating system.
 	Set up all packages needed for the NEAR validator.



⚠️ This process usually takes ~10 minutes.

During this time:

 	Your VPS will appear listed on the Home page.
 	Once visible, click on it to enter the Dashboard, where you continue the validator installation.

📸 [Figure 2: Deploy screen with VPS selection and API key field]


 📸 [Figure 3: Home page showing VPS listed]



🛠️ Step 4: Set Your Subdomain
Once in the Dashboard, the first step is to set a subdomain. This improves security and ensures encrypted communication between your VPS, the validator, and Node Studio.

 	Locate the Subdomain field in the Dashboard.
 	Enter the name you want for your subdomain.
 	Click Claim to save it.

⚠️ Important:

 	The process may take a few minutes to complete.
 	Do not close or refresh the page until the subdomain is fully set.

📸 [Figure 4: Subdomain setup field in Dashboard]


🛠️ Step 5: Configure Your Pool

 	Enter your Pool ID (validator name).

 	Must be unique and appropriate:

 	Do not use “Meta Pool,” offensive terms, or brand names.
 	Only the following special characters are allowed: - (dash) and _ (underscore).
 	Do not use dots (.) or any other special characters.




 	Select pool type:

 	poolv1.near → legacy contract, higher cost.
 	pool.near → upgradeable version, lower cost; recommended.


 	Optional: Enable Pinger (sends automatic ping every epoch, ~7.3h).

 	Has a small NEAR cost from your wallet.
 	Not required; Meta Pool provides free automated pings. Recommended: do not enable.


 	Set Reward Fee (validator commission).

 	⚠️ Maximum allowed for Meta Pool program: 7%.



📸 [Figure 5: Configure Pool section with Pool ID, pool version, pinger, and fee fields]


🛠️ Step 6: Manage Your Node

 	Click Update OS to configure the system.
 	Click Deploy NEAR App to install the validator software.

📸 [Figure 6: Manage Node section with Patch OS and Deploy buttons]


🛠️ Step 7: Deploy Your Staking Pool

 	Go to Manage Pool.
 	Connect your NEAR wallet.
 	Ensure the wallet has at least 5 NEAR.
 	Click Deploy Pool.

⚠️ Important:

 	This wallet becomes the contract owner: only it can modify the staking pool or receive fees. Secure your seed phrase.
 	Data from Configure Pool is used to create the staking contract.

 	Pool ID and pool type cannot be changed later.
 	Reward fee can be updated.



📸 [Figure 7: Manage Pool section with wallet connection and Deploy button]


🛠️ Step 8: Sync Your Validator

 	Check the logs panel at the bottom of the Dashboard.
 	Node Studio will download the snapshot and sync your validator.
 	Expected sync time: ~1–2 hours.

📸 [Figure 8: Logs panel showing syncing]


🛠️ Step 9: Confirm With Meta Pool (Program Users Only)

 	Once the validator is running, send a screenshot of the logs to the Meta Pool team.
 	The team has 10 days to delegate the seat price.
 	Once delegated, your validator enters the active set on NEAR.

📸 [Figure 9: Example of synced node log]


✅ Done!
Your NEAR validator is now active.

 	Program participants → wait for delegation.
 	Independent users → start staking or accepting delegators immediately.
 	Start your validator journey and claiming fee rewards

ℹ️ Troubleshooting

 	Node doesn’t appear? Check wallet connection; wait up to 30 minutes. Also check Hivelocity, might be an issue from their side (e.g. verification issue, not allowed to rent servers)
 	Node not syncing? Make sure the OS is updated and NEAR app deployment is completed.
 	Pool deployment failed? Ensure the NEAR wallet has ≥5 NEAR.

👉 Meta Pool Validators Program:

The Node Studio Program is a support initiative designed to help new validators get onboarded to the NEAR Protocol. The upcoming edition will start on October 1st, 2025, and will have 63 slots available.

To join the program, applicants must first register through the Node Studio Sign-up Form form and wait for Meta Pool’s contact and confirmation. The form will remain open for future editions that will be announced soon, so we encourage you to register even if you do not secure a slot in this round.

By joining the program, validators can receive the seat price delegation and begin earning fee rewards once their validator enters the active set on NEAR. Existing validators who already have their own seat price can use Node Studio freely. Program participants must also complete minimal marketing activities to remain active.

📢 Official announcements and updates for Node Studio and the NEAR validator program are posted in:

 	[Meta Pool Validators Telegram Channel] https://t.me/+nfNA4US6NHAyMTYx
 	[Meta Pool Validators Discord Channel] https://discord.gg/URYQ6Cyc9b

👉 Be part of the future of NEAR staking — register to Node Studio Program today and simplify your validator journey.

🔗 Register here: Node Studio Sign-up Form

 
📞 Support

 	[Meta Pool Validators Telegram] https://t.me/+nfNA4US6NHAyMTYx
 	[Meta Pool Validators Discord] https://discord.gg/URYQ6Cyc9b

 

### NEAR for Backend Developers: Your Skills, Decentralized

IntroductionIf you build backends today, you already know how to design APIs, store state, and manage users. NEAR Protocol lets you use the same instincts—just on a decentralized network instead of your own servers. Think of NEAR as “a backend you don’t have to host.” Your business logic runs as smart contracts (mini programs), your data lives in a replicated store managed by the network, and user identity is verified by cryptography, not passwords. In this lesson, we’ll map familiar backend ideas to NEAR concepts, walk through a simple Twitter-style example, and show how reads and writes work. By the end, you’ll see that moving from web2 to NEAR is an adaptation—not a reinvention.




NEAR as a Decentralized Backend
Imagine deploying a service that runs on a global cluster you don’t maintain. That’s NEAR. Your application is an account (e.g., twitter-app.yourname.near) with its own code and data. Independent validators (network nodes) keep that data replicated and available. When users interact, the network reaches finality—undisputed agreement on the result—usually in ~1–2 seconds.
Jargon check


 	
Validator: a node that runs NEAR software, executes contracts, and participates in consensus.

 	
Finality: the point a change is locked in and cannot be reversed.





Application State: Namespaced and Replicated
On NEAR, each app’s data is scoped to its account—like a dedicated database schema or namespace.


 	
Isolated state: Only your contract code can modify your app’s key-value storage.

 	
Audit trail: Every change is recorded on-chain, creating an immutable, verifiable history.

 	
High availability: Many validators store and serve your state. If some go offline, your app remains accessible.

 	
Fast eventual consistency: Requests are processed, consensus runs, and within ~1–2 seconds the new state is final across the network.


Analogy: Think of a cloud database with multi-region write replication and a built-in audit log you can’t turn off.




Backend Logic: Smart Contracts (Wasm)
Your business rules live in a smart contract—a small program compiled to WebAssembly (Wasm) and stored under your app’s account.


 	
Language options: Rust is the most common choice for performance and safety. JavaScript/TypeScript are also used via NEAR’s tooling that compiles to Wasm. [clarify: confirm if you want to emphasize Rust-only or include near-sdk-js/TypeScript explicitly.]

 	
Sandboxed execution: Wasm is efficient and runs in a safe, deterministic environment on validators.

 	
Clear boundaries: Each contract manages its own state and exposes functions that clients call.


Jargon check


 	
Smart contract: backend code that runs on the blockchain.

 	
WebAssembly (Wasm): a binary format for fast, portable execution.





Identity and Authorization: Cryptographic by Default
Instead of passwords, NEAR uses accounts and digital signatures.


 	
Transactions: Any write (state change) is a signed transaction from a NEAR account.

 	
Who called me?: In the contract, predecessor_account_id tells you which account triggered the function—like reading the user from a verified token, but backed by cryptography.

 	
Access control: Build checks like “only this account can delete its tweet” using the caller’s account ID.


Analogy: It’s like JWTs without a login server—identity is baked into the platform.




A Simple Twitter-Style Example (Conceptual)
Suppose you model Tweet { id, author, text, timestamp, likes }.


 	
Write methods (state-changing):


 	
post_tweet(text): creates a tweet, author = predecessor_account_id.

 	
like_tweet(id): increments the like counter.

 	
delete_tweet(id): only the tweet’s author can delete.



 	
Read methods (view):


 	
get_tweet_by_id(id)

 	
get_all_tweets(from, limit)

 	
get_tweets_by_author(author, from, limit)




Design-wise, think “simple, indexed access patterns.” Complex ad-hoc queries (e.g., joins) don’t exist in-contract, so you plan your data structures and iterators with that in mind.




How Clients Call Your Contract
There are two kinds of calls, mirroring REST:


 	
State-changing calls (like POST/PUT/DELETE)


 	
Sent as transactions: include receiver_id (your contract), method_name, args (JSON), gas (fee budget), optional deposit, and the signature from the caller’s account.

 	
Tools: NEAR CLI for scripts/ops; near-api-js for web and mobile frontends (wallet handles signing).



 	
View calls (like GET)


 	
Read-only and free at the contract level.

 	
Sent to an RPC endpoint; no signature or gas from the user is needed (providers may rate-limit).




Analogy: Writes are like paid, signed POSTs that go through a global queue and get confirmed. Reads are lightweight RPC lookups.




Why Backend Developers Care

 	
Built-in auditability: Every write is a timestamped, immutable record. Great for provenance and compliance needs.

 	
Less trust, more guarantees: Users don’t need to trust your server. They can trust the neutral execution of the network and your published code.

 	
Identity included: Accounts and signatures replace home-grown auth stacks for core identity flows.

 	
Resilience out of the box: No single point of failure; validators replicate your state and logic.

 	
Fast confirmations: ~1–2 second finality gives a responsive UX for decentralized apps.

 	
Composability: Contracts can call other contracts, enabling modular, Lego-style architectures.


Trade-offs to plan for:


 	
Gas & storage costs: Writes and on-chain storage are metered. Design for efficient data models and minimal writes.

 	
Query patterns: Prefer simple retrieval and pagination; push complex analytics off-chain or pre-index.

 	
Upgrades: Contracts are immutable after deployment unless you implement upgrade patterns (governed by clear rules).





Takeaway
NEAR maps cleanly to backend mental models: contracts are your services, account-scoped storage is your database, and signatures replace sessions. With fast finality and a global validator set, you get high availability, strong integrity, and a built-in audit trail. If your app benefits from verifiable state, shared rules between many parties, or user-controlled identities, NEAR offers a compelling backend you don’t have to run yourself.
Reflective questions


 	
Which parts of your current backend (auth, audit logs, multi-region replication) could NEAR’s built-in features replace or simplify?

 	
For your main data entities, how would you model storage and retrieval to avoid complex on-chain queries?

 	
What write paths in your app truly need on-chain finality, and which reads could stay off-chain via caching or indexing?

 	
What upgrade and access-control rules would you define before deploying your first contract?

### NEAR for Backend Devs: A Familiar Frontier

Source: NEAR Docs
Simplified version for beginners

As an backend developer you are adept at building robust services, managing databases, and ensuring system reliability. When you hear “blockchain” it might sound like a completely different paradigm. However, platforms like NEAR Protocol are designed to be surprisingly accessible, offering a new kind of backend infrastructure that leverages many concepts you are already familiar with.

In this article will guide you through understanding NEAR from a backend perspective, exploring how NEAR is a platform where:

 	The Backend Logic lives in small programs know as “smart contracts” which you can write in languages that compile to WebAssembly like Rust or Javascript
 	The Application State is managed per program, with global availability and data integrity ensure by the network
 	User Identity and Permissions are cryptographically secured and can be reliably checked within your application logic using Accounts
 	Data Replication is handled by the network, providing something akin to a master-master replication setup with eventual consistency, typically reaching finality (undisputed agreement) in about 1-2 seconds

We will build a simplified Twitter-like application using Rust to demonstrate these concepts in action. Let’s explore how your backend skills translate to this decentralized frontier.
NEAR as Your Decentralized Backend Platform
Imagine building a backend service that doesn’t run on a specific server you manage, but on a global network of computers. This is the essence of NEAR. Let’s break down how familiar backend concepts map to NEAR.

1. Application State: Your Own Namespace, Globally Replicated

On NEAR, each application lives on its own account Account (e.g., your-app.near, twitter-clone.your-account.near). Think of this Account as a namespace for your application’s dedicated state.

 	Isolated State: All data for your application is stored within the context of its Account using a dedicated key-value store database. Only the account’s program can change its stored data.
 	Auditable changes: The history of changes to your application’s state is securely stored in the blockchain, making it immutable and cryptographically verifiable.
 	Data Replication & Availability: This application state isn’t just on one machine. The NEAR network, composed of many independent “validators”, replicates this state. This is analogous to a distributed database system with master-master replication. If some nodes go offline, the network continues to operate, and your application’s state remains available.
 	Eventual Consistency with Fast Finality: When a user interacts with your application validators process the request. Within 1-2 seconds the network reaches consensus and the change is final. After this, the new state is an undisputed part of the global record. This is a form of eventual consistency, but with a very short window to reach that consistent, final state.

2. Backend Logic: Smart Contracts

The code that defines how the account’s state can be read and modified is known as a “smart contract“.

 	Your Business Logic: This is where you write your application’s rules. For our Twitter example, this logic will define how a tweet is created, who can post it, how tweets are retrieved, etc.
 	Execution Environment: Contracts are compiled into WebAssembly (Wasm), a highly efficient and sandboxed binary format. This binary is stored in the NEAR platform under your application’s Account and executed by the validator nodes.
 	Multiple Languages: The use of Wasm means you can write this logic in several familiar languages, with Rust being a primary and robust choice offering strong safety and performance.
 	Millions of Contracts: The NEAR blockchain can host millions of contracts, each operating within its own account namespace, managing its own state, and exposing its own set of functions.

3. User Identity and Authorization: Cryptographic Certainty

In traditional backends, you manage user authentication (e.g., passwords, OAuth) and then use sessions or tokens to identify users for subsequent requests. NEAR has a built-in, cryptographically secure way to identify who is initiating an action

 	Transactions and Signatures: Every interaction that attempts to change your application’s state must be initiated as a “transaction” signed by a NEAR account. This signature proves ownership of that account
 	predecessor_account_id: When your smart contract code is executed, it has access to env::predecessor_account_id(), which reliably tells which NEAR account triggered the current function call
 	Built-in Access Control: You can use predecessor_account_id to implement powerful access control (e.g. assert that only specific accounts call certain functions). This is like having @isAuthenticated and @hasPermission checks, but grounded in cryptographic proof tied to the user’s account, not just a session token your server issued

By combining these elements – namespaced and replicated state, Wasm-compiled business logic (smart contracts), and cryptographic user identity – NEAR provides a robust platform for building decentralized applications with familiar backend engineering principles.
Smart Contracts in Rust: The Twitter Example
Now, lets see how this translates into code. Your backend logic on NEAR is encapsulated in a smart contract. As mentioned, these contracts are compiled to WebAssembly (Wasm), allowing you to use languages like Rust. Rust is a popular choice due to its performance, safety features, and strong tooling support within the NEAR ecosystem.

We will build a simplified Twitter-like application. Users will be able to post tweets, view all tweets, view tweets by a specific author, and like tweets. The core idea is that each tweet is undeniably linked to its author via their NEAR account ID.

Here’s the Rust code for our contract:


// ================================================================================================
// NEAR SMART CONTRACT: Twitter-like Social Media Platform
// ================================================================================================
//
// This smart contract implements a Twitter-like platform on the NEAR blockchain.
// For backend engineers new to blockchain, think of this as a REST API service that:
// - Stores data permanently on a distributed database (the blockchain)
// - Has no central server - it runs on hundreds of nodes worldwide
// - Charges small fees (gas) for write operations to prevent spam
// - Is immutable once deployed (like deploying code that can't be changed)
//
// Key NEAR/Blockchain Concepts for Backend Engineers:
// - Smart Contract = Your backend service logic that runs on blockchain
// - Account ID = User identifier (like username, but globally unique)
// - Gas = Computational cost (like AWS Lambda pricing, but for blockchain operations)
// - Storage = Persistent data (like a database, but decentralized and permanent)
// - View Methods = Read operations (free, like GET requests)
// - Call Methods = Write operations (cost gas, like POST/PUT/DELETE requests)

// Import NEAR SDK components - think of this as importing your web framework
use near_sdk::store::IterableMap; // Like HashMap but optimized for blockchain storage
use near_sdk::{env, near, AccountId, PanicOnDefault, Timestamp};

// ================================================================================================
// DATA STRUCTURES
// ================================================================================================

// Tweet represents a single tweet in our social media platform
// The #[near] attribute automatically handles serialization/deserialization
// Think of this as your API response/request DTOs, but for blockchain
#[near(serializers = [borsh, json])]
#[derive(Clone, Debug, PartialEq)]
pub struct Tweet {
    // Unique identifier for this tweet (like auto-increment ID in SQL)
    pub id: u64,

    // NEAR account that created this tweet (like user_id in traditional apps)
    // AccountId is NEAR's version of a username/user identifier
    pub author: AccountId,

    // The actual tweet content (like message body)
    pub text: String,

    // When this tweet was created (NEAR provides nanoseconds since Unix epoch)
    // Think of this as created_at timestamp in your database
    pub timestamp: Timestamp,

    // Number of likes this tweet has received (like a counter field)
    pub likes: u64,
}

// ================================================================================================
// SMART CONTRACT STATE
// ================================================================================================

// TwitterContract is the main contract state - think of this as your application's
// in-memory state that persists between requests (like instance variables in a service class)
//
// In traditional backend:
// - You'd have a database to store tweets
// - You'd have application state in memory/cache
//
// In NEAR:
// - Contract state IS your database (stored on blockchain)
// - State persists between function calls
// - State is automatically loaded/saved by NEAR runtime
#[near(contract_state)]
#[derive(PanicOnDefault)] // Prevents accidental initialization without proper setup
pub struct TwitterContract {
    // Storage for all tweets - like your main tweets table
    // IterableMap is NEAR's version of HashMap optimized for blockchain storage
    // Key: tweet_id, Value: Tweet object
    tweets: IterableMap<u64, Tweet>,

    // Counter for generating unique tweet IDs (like auto-increment in SQL)
    // This ensures each tweet gets a unique identifier
    next_tweet_id: u64,
}

// ================================================================================================
// CONTRACT IMPLEMENTATION
// ================================================================================================

// The #[near] attribute marks this implementation block as containing contract methods
// Think of these as your REST API endpoints, but they run on the blockchain
#[near]
impl TwitterContract {
    // ============================================================================================
    // INITIALIZATION METHOD
    // ============================================================================================

    // Contract constructor - called once when the contract is first deployed
    // Similar to database migrations or initial setup in traditional backends
    // The #[init] attribute marks this as the initialization method
    #[init]
    pub fn new() -> Self {
        Self {
            // Initialize tweet storage with a unique storage prefix
            // "b't'" is a byte string prefix to avoid storage conflicts
            // Think of this as creating a table in your database
            tweets: IterableMap::new(b"t"),

            // Start tweet IDs from 0
            next_tweet_id: 0,
        }
    }

    // ============================================================================================
    // WRITE METHODS (Cost gas, modify state)
    // ============================================================================================

    // Post a new tweet - equivalent to POST /tweets endpoint
    // This is a "call" method that modifies state and costs gas
    pub fn post_tweet(&mut self, text: String) -> Tweet {
        // Get the account that called this method (like extracting user from JWT token)
        // env::predecessor_account_id() returns who made the transaction
        let author = env::predecessor_account_id();

        // Get current blockchain timestamp (like System.currentTimeMillis() in Java)
        // NEAR provides nanoseconds since Unix epoch
        let timestamp = env::block_timestamp();

        // Generate unique ID for this tweet (like auto-increment primary key)
        let tweet_id = self.next_tweet_id;

        // Create the tweet object (like building your entity/model)
        let new_tweet = Tweet {
            id: tweet_id,
            author: author.clone(),
            text,
            timestamp,
            likes: 0, // New tweets start with 0 likes
        };

        // Store the tweet in our "database" (contract storage)
        // This is like INSERT INTO tweets (...) VALUES (...)
        self.tweets.insert(tweet_id, new_tweet.clone());

        // Increment ID counter for next tweet (like auto-increment)
        self.next_tweet_id += 1;

        // Log the action - similar to application logging
        // These logs are stored on blockchain and can be queried
        env::log_str(&format!(
            "Tweet #{} posted by @{} at {}",
            tweet_id, author, timestamp
        ));

        // Return the created tweet (like returning the entity in REST API)
        new_tweet
    }

    // Like a tweet - equivalent to POST /tweets/{id}/like endpoint
    // This modifies state (increments like counter) so it costs gas
    pub fn like_tweet(&mut self, tweet_id: u64) -> Option<Tweet> {
        // Try to get a mutable reference to the tweet
        // This is like: SELECT * FROM tweets WHERE id = ? FOR UPDATE
        if let Some(tweet) = self.tweets.get_mut(&tweet_id) {
            // Increment the like counter (like UPDATE tweets SET likes = likes + 1)
            tweet.likes += 1;

            // Log the like action for transparency/debugging
            env::log_str(&format!(
                "Tweet #{} liked by @{}. Total likes: {}",
                tweet_id,
                env::predecessor_account_id(), // Who liked the tweet
                tweet.likes
            ));

            // Return the updated tweet (clone because we need to return owned data)
            Some(tweet.clone())
        } else {
            // Tweet doesn't exist - log the attempt
            // In REST API, this would be a 404 Not Found
            env::log_str(&format!(
                "Attempt to like non-existent tweet #{} by @{}",
                tweet_id,
                env::predecessor_account_id()
            ));
            None
        }
    }

    // Delete a tweet - equivalent to DELETE /tweets/{id} endpoint
    // Only the tweet author can delete their own tweets (authorization check)
    pub fn delete_tweet(&mut self, tweet_id: u64) {
        // Get who's trying to delete the tweet (like checking JWT/session)
        let caller = env::predecessor_account_id();

        // Check if tweet exists and verify ownership
        // This is like: SELECT author FROM tweets WHERE id = ?
        if let Some(tweet) = self.tweets.get(&tweet_id) {
            // Authorization check - only author can delete their tweet
            // Similar to checking if user owns the resource in REST API
            if tweet.author == caller {
                // Delete the tweet from storage
                // Like: DELETE FROM tweets WHERE id = ?
                self.tweets.remove(&tweet_id);
                env::log_str(&format!("Tweet #{} deleted by @{}", tweet_id, caller));
            } else {
                // Unauthorized deletion attempt - log security event
                // In REST API, this would be 403 Forbidden
                env::log_str(&format!(
                    "User @{} attempted to delete tweet #{} but is not the author.",
                    caller, tweet_id
                ));
            }
        } else {
            // Tweet doesn't exist - log the attempt
            // In REST API, this would be 404 Not Found
            env::log_str(&format!(
                "Attempt to delete non-existent tweet #{} by @{}",
                tweet_id, caller
            ));
        }
    }

    // ============================================================================================
    // READ METHODS (Free, don't modify state)
    // ============================================================================================
    // These are "view" methods - they don't cost gas and don't modify contract state
    // Think of these as GET endpoints in your REST API

    // Get all tweets with pagination - like GET /tweets?offset=0&limit=10
    // from_index: starting position (like OFFSET in SQL)
    // limit: maximum number of tweets to return (like LIMIT in SQL)
    pub fn get_all_tweets(&self, from_index: Option<u64>, limit: Option<u64>) -> Vec<Tweet> {
        // Set default values if not provided (common REST API pattern)
        let start = from_index.unwrap_or(0);
        let limit_val = limit.unwrap_or(10);

        // Query tweets with pagination (like SELECT * FROM tweets LIMIT x OFFSET y)
        self.tweets
            .iter() // Iterate over all tweets
            .skip(start as usize) // Skip 'start' number of tweets (OFFSET)
            .take(limit_val as usize) // Take only 'limit_val' tweets (LIMIT)
            .map(|(_key, tweet)| tweet.clone()) // Extract tweet objects (ignore keys)
            .collect() // Collect into Vector to return
    }

    // Get specific tweet by ID - like GET /tweets/{id}
    pub fn get_tweet_by_id(&self, tweet_id: u64) -> Option<Tweet> {
        // Simple lookup by primary key
        // Like: SELECT * FROM tweets WHERE id = ?
        self.tweets.get(&tweet_id).cloned()
    }

    // Get tweets by specific author with pagination - like GET /users/{id}/tweets
    // This demonstrates filtering in blockchain storage (no SQL WHERE clause available)
    pub fn get_tweets_by_author(
        &self,
        author_id: AccountId,
        from_index: Option<u64>,
        limit: Option<u64>,
    ) -> Vec<Tweet> {
        let start = from_index.unwrap_or(0);
        let limit_val = limit.unwrap_or(10);

        // We need to manually filter since blockchain storage doesn't have SQL-like queries
        // This is like doing: SELECT * FROM tweets WHERE author = ? LIMIT x OFFSET y
        // But we have to iterate through all tweets and filter manually
        let mut author_tweets = Vec::new();
        let mut count = 0;
        let mut current_index = 0;

        // Iterate through all tweets to find matches
        for (_id, tweet) in self.tweets.iter() {
            // Check if this tweet belongs to the requested author
            if tweet.author == author_id {
                // Apply pagination logic
                if current_index >= start && count < limit_val {
                    author_tweets.push(tweet.clone());
                    count += 1;
                }
                current_index += 1;
            }

            // Optimization: stop early if we've found enough tweets
            if count >= limit_val && current_index > start {
                break;
            }
        }

        author_tweets
    }
}

// ================================================================================================
// KEY DIFFERENCES FROM TRADITIONAL BACKEND:
// ================================================================================================
//
// 1. STATE PERSISTENCE:
//    - Traditional: Use database, cache, session storage
//    - NEAR: Contract state IS your database, automatically persisted
//
// 2. USER AUTHENTICATION:
//    - Traditional: JWT tokens, sessions, OAuth
//    - NEAR: Cryptographic signatures, account-based auth built-in
//
// 3. SCALABILITY:
//    - Traditional: Horizontal scaling, load balancers, microservices
//    - NEAR: Automatic scaling across blockchain network
//
// 4. COSTS:
//    - Traditional: Server costs, database costs, bandwidth
//    - NEAR: Gas fees for computations, storage costs per byte
//
// 5. DEPLOYMENT:
//    - Traditional: CI/CD pipelines, blue-green deployments
//    - NEAR: Deploy once, immutable (or upgradeable with special patterns)
//
// 6. DATA CONSISTENCY:
//    - Traditional: ACID transactions, eventual consistency
//    - NEAR: Atomic transactions guaranteed by blockchain consensus
//
// 7. QUERYING DATA:
//    - Traditional: SQL, NoSQL query languages
//    - NEAR: Manual iteration, no complex queries (design for simple access patterns)




This Rust smart contract (here is the full version) acts as the backend for our Twitter application. It defines the data structures, the initial state, and the functions that users can call to interact with the application. The use of predecessor_account_id is central to associating tweets with their authors.
Interacting with Your NEAR Backend (Smart Contract)
Once your Rust smart contract is compiled to Wasm and deployed to a NEAR account (e.g., twitter-app.your-account.near), it’s live and ready for interaction. So, how do you or your users “call” these backend functions?

Think of it like interacting with a standard web API, but instead of HTTP requests to a server you own, you are sending transactions or making RPC calls to the NEAR network, targeting your specific contract account and method.

1. Calling Methods that Change State (e.g., post_tweet, like_tweet):

These are “call” methods (marked &mut self in Rust) because they modify the contract’s state.

 	Transactions: To execute these, a user (or an application acting on their behalf) constructs a transaction. This transaction specifies:

 	The receiver_id: Your contract’s account ID (e.g., twitter-app.your-account.near).
 	The method_name: The function to call (e.g., "post_tweet").
 	args: The arguments for the function, typically as a JSON string (e.g., {"text": "My first NEAR tweet!"}).
 	signer_id: The NEAR account ID of the user initiating the action. The transaction must be signed with this account’s private key. This signature is how env::predecessor_account_id() in your contract gets populated.
 	attached_deposit: If the method is #[payable], users can attach NEAR tokens to the call. (Not used in our Twitter example’s post_tweet).
 	gas: An amount of “gas” to pay for the computation and storage resources used by the transaction. Gas is a fee mechanism on the network.


 	Tools:

 	NEAR CLI: A command-line interface for interacting with NEAR. Example:


near call twitter-app.your-account.near post_tweet '{"text": "Hello from CLI!"}' --accountId user1.near




 	NEAR SDKs (JavaScript, etc.): For web or mobile frontends, you’d use a JavaScript library (like near-api-js) to construct and send these transactions through a user’s NEAR Wallet (which handles the signing).



2. Calling Methods that Only Read State (e.g., get_all_tweets, get_tweet_by_id):

These are “view” methods (marked &self in Rust) because they only read state and don’t modify it.

 	RPC Calls: These can be made directly to a NEAR RPC node without needing to send a full transaction and without requiring gas from the caller (though the RPC provider might have its own rate limits or fees for heavy usage).
 	Tools:

 	NEAR CLI:


near view twitter-app.your-account.near get_all_tweets '{"from_index": 0, "limit": 5}'




 	NEAR SDKs (JavaScript, etc.): Libraries like near-api-js provide straightforward ways to make these view calls.



In essence:

 	Modifying state: Requires a signed transaction, costs gas, involves the whole network consensus. This is your POST, PUT, DELETE equivalent.
 	Reading state: Can be done with a lighter-weight RPC view call, generally free at the contract level. This is your GET equivalent.

Your frontend application (web, mobile) or other backend services would use these mechanisms to interact with the smart contract, which acts as the secure, decentralized backend logic and data store. The key is that the user always initiates and authorizes state-changing actions via their own NEAR account and cryptographic signatures.
Benefits for Backend Developers: Why Consider NEAR?
As an experienced backend developer, you might be wondering what advantages building on a platform like NEAR offers compared to your traditional stacks. Here are a few key benefits:

 	Enhanced Data Integrity and Auditability:

 	Every state change is a transaction recorded on an immutable ledger. This provides an automatic, transparent audit trail. For applications where provenance, history, or verifiability is critical, this is a built-in feature, not something you need to painstakingly architect.
 	The rules for state changes are defined in the smart contract code, which is itself auditable on the blockchain.


 	Reduced Need for Trust / Trustless Interactions:

 	Because the backend logic (smart contract) and state are managed by a decentralized network with consensus, users (and other services) don’t need to trust a single central operator to execute logic correctly or maintain data integrity. The “code is law” principle reduces counterparty risk.
 	This is powerful for multi-party applications where participants might not fully trust each other but can trust the neutral execution environment of the blockchain.


 	Built-in User Account System and Cryptographic Security:

 	NEAR’s account model provides a ready-made, secure user identity system. You don’t need to build and maintain your own user database, password hashing, or session management for core identity.
 	The use of predecessor_account_id based on cryptographic signatures provides strong guarantees about who initiated an action, simplifying authorization logic within your contract.


 	High Availability and Resilience:

 	Being a decentralized network, NEAR is inherently resilient to single points of failure. Your application’s backend logic and state remain accessible as long as the NEAR network itself is operational, which is designed for high uptime. This is like getting a globally distributed, fault-tolerant deployment out of the box.


 	Censorship Resistance:

 	Once deployed, your smart contract logic cannot be easily shut down or tampered with by a single entity, including the original developer (unless specific upgrade mechanisms are built in and governed by clear rules). This provides a degree of censorship resistance for applications and their data.


 	Fast Finality and Scalable by Design:

 	NEAR’s ~1-2 second finality means transactions are quickly confirmed and irreversible, providing a responsive user experience for a decentralized system.
 	The sharding architecture (Nightshade) is designed for scalability, allowing the network to handle an increasing number of transactions as more applications and users join the ecosystem. This addresses a common concern with older blockchain technologies.


 	Interoperability and Composability (Advanced):

 	Smart contracts on NEAR can call each other, allowing for complex applications to be built by composing functionalities from different contracts. This opens up possibilities for creating ecosystems of interconnected services.



While NEAR (and blockchain in general) introduces new considerations like gas fees for transactions and on-chain storage costs, it offers a unique set of benefits for specific types of applications. If your application requires high degrees of transparency, user control over their data, verifiable logic, or interactions between multiple distrusting parties, NEAR provides a compelling backend infrastructure that complements your existing skillset.
Conclusion: Your Backend Skills, Decentralized on NEAR
Transitioning from traditional web2 backend development to building on NEAR isn’t about discarding your expertise; it’s about applying it in a new context. We’ve seen how NEAR can be understood as a decentralized backend platform where:

 	Application-specific state is managed securely and replicated globally, akin to a highly available, namespaced database.
 	Smart contracts, written in languages like Rust, serve as your backend logic, defining all rules for state interaction.
 	User identity is cryptographically enforced, with predecessor_account_id offering a reliable way to manage permissions and ownership.
 	The platform provides fast finality (~1-2 seconds) and is designed for scalability.

The Twitter example, though simplified, illustrates how you can build applications where data ownership and control are transparently handled by the logic you deploy. Concepts like managing state, defining APIs (contract methods), and ensuring data integrity are all directly transferable.

NEAR offers a robust environment for building applications that benefit from decentralization – whether for enhanced transparency, user empowerment, or creating new forms of multi-party collaboration. With your existing backend development skills, you are well-equipped to explore this powerful platform and build the next generation of applications. The learning curve is more about understanding the decentralized paradigm and NEAR’s specific APIs rather than learning programming from scratch.

Ready to dive deeper? Check out the NEAR Documentation and the Rust SDK examples to start your journey.

### Do you understand what is TEE?

Learn about TEE

                 
 
                        Do you understand what is TEE?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Trusted Execution Environments (TEEs): your digital safe room

More of our lives now run on phones, laptops, and the cloud. That makes protecting secrets harder. A Trusted Execution Environment (TEE) helps by acting like a small safe room inside a computer chip. Only approved code gets in. What happens inside stays private and intact. In three minutes, this guide explains what a TEE is, why it is trusted, where it is used, and how to use it wisely.

What is a TEE?
Think of a locked, soundproof room inside the processor. That room is the TEE. It gives two strong promises:


 	
Confidentiality: outsiders cannot read the data.

 	
Integrity: outsiders cannot change the code or data.


“Outsiders” includes the operating system, other apps, and cloud management tools. Hardware isolation enforces these rules, so normal software attacks have a hard time getting in.
Quick scenario: your app needs to check a private key and sign a message. Inside the TEE, the key never leaves the room. The signature is produced, but the key stays hidden.


Why you can trust it
TEEs layer several controls:


 	
Secure boot: at startup, the TEE verifies digital signatures on its own code and its tiny secure OS. If checks fail, it does not run.

 	
Approved apps only: the TEE verifies that an app is authorized before it starts.

 	
Strong isolation: multiple trusted apps can share the host, yet each sees only its own data.

 	
Confidential memory: TEE memory is encrypted and hidden from the main OS and hypervisor.

 	
Remote attestation: the TEE can produce a cryptographic proof of the exact software that is running so a remote user can verify it.


Where TEEs show up
TEEs power confidential computing, which keeps data protected even while it is being processed.


 	
Mobile security: store biometrics and payment keys in a protected zone.

 	
Cloud computing: run workloads in confidential virtual machines. For example, Azure confidential computing uses AMD SEV-SNP and Intel TDX to encrypt VM memory, and Intel SGX for enclave-style apps that need strong isolation without large code changes.

 	
IoT devices: protect firmware updates and secrets across fleets of sensors.

 	
Blockchain systems: process private orders, healthcare, or finance data without exposing it to node operators. This enables private order books and private AI agent runs.

 	
Cryptocurrency wallets: keep private keys and signing logic inside the TEE so keys never leave the secure boundary.

 	
Trustworthy AI: newer GPUs add TEE-like features; combined with CPU confidential VMs, they help keep models and data private during training and inference.


Why not only cryptography? Pure cryptographic methods like Fully Homomorphic Encryption (FHE) and Secure Multiparty Computation (MPC) protect data too, but often with high cost or big changes to code. TEEs usually run today’s software faster and with fewer changes while still improving privacy.

Important limits
No tool is perfect. Know these limits up front:


 	
Not a silver bullet: a TEE protects what happens inside. If malware changes inputs before they enter, or tampers with outputs after they leave, the TEE cannot detect it. A TEE could sign the wrong transaction if the data was altered upstream.

 	
Physical attacks: very skilled attackers with hands-on access to the chip can still try invasive methods.

 	
Side-channels: CPU flaws like Spectre and Meltdown showed that timing and cache patterns can leak hints. Vendors add defenses, but risk is not zero.

 	
Vendor trust: designs come from Intel (SGX, TDX), AMD (SEV), and ARM (CCA). You must trust their hardware and updates.

 	
Verification gap: attestation proves “this binary is running,” but not that it matches the public source code without extra steps.


How to reduce risk
Use TEEs as part of a layered plan:


 	
Design for failure: assume a breach is possible. Prefer TEEs to protect privacy and limit damage, not as your only guard for system integrity.

 	
Protect access patterns: use Oblivious RAM (ORAM) to hide which memory locations are touched, reducing what observers can infer.

 	
Rotate keys: use short-lived session keys and regular rotation so any leak has a small blast radius.

 	
Close the build gap: build and verify software inside a TEE so you can link public source to the exact binary that later runs. Example: dstack’s “In-ConfidentialContainer (In-CC) Build” claims to provide this end-to-end path [clarify: confirm vendor name and feature name].


Takeaway
A TEE brings a safe room to your device or cloud VM. It keeps data private and code intact during execution. It does not remove the need for secure inputs, careful outputs, and good key hygiene. Combined with layered defenses and clear verification, TEEs are a practical foundation for confidential computing across phones, clouds, IoT, blockchains, wallets, and AI workloads.

                 
 
                        Do you understand what is TEE?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Unlocking the next Revolution of DeFi: RHEA x NEAR Intent

Source: Rhea Medium
How abstraction and intent power the first truly chain-abstracted lending platform
Liquidity fragmentation has long been DeFi’s greatest bottleneck. Each chain operates in isolation, forcing users to bridge assets, juggle multiple wallets, and manage gas in different ecosystems. This fractured experience drains capital efficiency and limits adoption.
RHEA, as part of the NEAR ecosystem, was built to solve this problem: consolidating liquidity and abstracting away complexity through chain signatures and intent-based infrastructure. Earlier milestones — like enabling chain-abstracted staking from BSC to NEAR via Wormhole, and providing BTC holders with access to lending and swaps through Satoshi Ramp — laid the groundwork.
Now, in collaboration with the Near Intent team, RHEA is taking the leap forward: launching the first true multichain money market — designed for both everyday users and professional on-chain market makers.

RHEA Lending with Near Intent
User flow




Press enter or click to view image in full size



 	Users on Ethereum, Bitcoin, Solana, Sui, or XRP sign a Near Intent from their native wallet.
 	Near Intent auto-provisions a NEAR account controlled by the user’s original wallet and routes deposits directly into RHEA Lending.
 	Deposits consolidate into a unified liquidity pool on NEAR, solving fragmentation and maximizing efficiency.
 	Borrowers access the pool by posting collateral and paying fees on their loans.

This flow ensures users enjoy simple, native deposits while liquidity consolidates into one efficient pool that powers lending, borrowing, and liquidations.

Part 1: Chain Abstraction with NEAR Intent
RHEA is designed to make lending across chains as simple as possible. Powered by NEAR Intent, it gives users from Ethereum, Bitcoin, Solana, Sui, and XRP the ability to deposit their assets seamlessly into RHEA Lending.
There’s no need to manually bridge assets, manage multiple wallets, or worry about gas across different ecosystems — everything is handled through a single, unified platform.
From this foundation, RHEA introduces key layers of abstraction and consolidation:


 	Cross-Chain Lending: Users can deposit stablecoins, ERC-20s, BTC, SPL tokens, and more directly from their home chains. Near Intent auto-generates a NEAR account controlled by the user’s original wallet to manage supply and lending.
 	Wallet & Gas Abstraction: No NEAR wallet setup. No NEAR gas tokens required. Users interact directly from their native wallets, with the same familiar UX.
 	Unified Liquidity: All supply and borrowing occurs on NEAR, creating one deep liquidity pool that eliminates fragmentation.
 	Simplified Liquidation: Liquidations are executed in one place on NEAR, with rewards withdrawable to any chain.
 	Incentive Boosts: Locking xRHEA amplifies supply and borrow rewards for long-term users.

Together, these abstractions make RHEA the first truly user-centric multichain money market.

Part 2: Solvers and Market Makers in Action
Beyond retail users, RHEA empowers Solvers and Market Makers (MMs) — the liquidity engines behind intent settlement. By plugging into RHEA Lending and Near Intent, they gain not only operational efficiency but also greater capital utilization and higher yield opportunities.




Press enter or click to view image in full size



 	Collateralize Assets: Solvers/MMs lock a single asset into RHEA Lending, earning fees and strengthening the pool.
 	Escrow Intent: Near Intent temporarily locks user orders, enabling Solvers/MMs to step in.
 	Borrow Bridging Assets: To fulfill orders, Solvers/MMs borrow bridging assets from RHEA Lending.

- They pay a fee to RHEA Lending for borrowed liquidity.
- They earn a fee from Near Intent for fulfilling user orders.


 	Rebalance: After completing orders, Solvers/MMs rebalance to close borrowing positions.

This dual-layer model ensures Solvers/MMs both contribute to the liquidity backbone (via collateral) and act as infrastructure (via intent fulfillment).

Part 3: RHEA tapping into the next DeFi Revolution
Throughout the years, Finance itself has undergone many revolutions, each time reshaping how humans interact with money. DeFi is also under that very same umbrella. It is new, full of potential, and still waiting for its defining breakthrough. That said, what can we learn throughout the long history of finance?

The Card Revolution: When Finance became invisible
Up until mid-20th century, payments are a manual act. Everyone carried cash, counted change, and piggy banks are still a thing! Also, when you are travelling across borders, it is almost mandatory to find a store/booth/counter to swap money into another currency to spent it elsewhere. Sound familiar to DeFi’s cross-chain UX today? Let’s continue.
Then came the card revolution. At first, it was just plastic with a chip. But what it really did was consolidate liquidity from banks into one global network. Instead of managing cash in different forms, people suddenly had one card that “just worked.”
The fascination is, behind the scenes, the system was complex. Authorizations, clearing, settlements, cross borders…. Yet none of that mattered to the end user. With every swipe, Visa or Mastercard quietly moved money across borders. Over time, the experience became so seamless that the “act of payment” became invisible.
Fast forward today, tapping a card does not even feel like spending. Money simply flows. That was the breakthrough: finance became invisible, and then adoption skyrocketed.

Parallel in the current DeFi State
DeFi today mirrors a lot like finance before the card revolution. It is fragmented, siloed, burdened with friction. Manual tasks such as bridging assets, juggling between wallets, and paying gas feels like the cash-and-exchange-counter era all over again…
DeFi needs its own “It moment”, one that allows liquidity to flow seamlessly across chains, abstracting complications to behind the scenes. This is the role RHEA is building towards, to launch the first true multi-chain money market designed for both everyday users and professional on-chain market makers.

Why RHEA Matters

 	For Users: A seamless, native lending experience across chains — no bridges, no new wallets, no gas juggling.
 	For Liquidity: Fragmented capital is unified into one deep pool.
 	For Solvers/MMs: A dual revenue model — fees from Near Intent and participation in RHEA Lending.
 	For Ecosystems: A liquidity backbone that spans Ethereum, Bitcoin, Solana, Sui, XRP, and beyond.

Over the years, RHEA has already shipped multiple products that drives chain-abstraction forward, including the latest breakthrough in Multi-chain lending:




Press enter or click to view image in full size


Conclusion
Just like the card revolution turned payments from a clunky, manual process into something invisible, RHEA’s abstraction layers turn DeFi from fragmented steps into a seamless experience. Users won’t need to think which chain they are on — they’ll just lend, borrow, and trade. When the mechanics fade into the background and only the utility remains, that’s when the next DeFi revolution begins.

### NEAR Protocol Scales Up: 9 Shards Now Live with 12.5% Performance Boost

Summary





Feature
Details




Shard Increase
From 8 to 9 shards


Performance Gain
Approx. 12.5% throughput improvement


Upgrade Type
Seamless live resharding upgrade


Why It Happened
One shard's state was growing too large for typical chunk producers


Future Path
Clear roadmap to continue increasing shards and capacity








NEAR Protocol Hits 9 Shards
On August 19 2025, NEAR Protocol completed a successful upgrade from 8 to 9 shards on mainnet, delivering a 12.5% throughput improvement. This was achieved through a live upgrade, with no network downtime or user disruption.
This marks another step forward in NEAR’s long-term vision for sustainable, scalable blockchain infrastructure.




Why This Matters
Addresses State Growth
One shard’s state was getting too large, which could eventually require chunk producers to run higher-memory machines. Rather than increase hardware demands, NEAR splits shard state via resharding, keeping node requirements low.

Elegant Resharding
NEAR’s architecture allows shards to be split without requiring full validator rebooting or state duplication. Resharding enables the network to scale horizontally, instead of vertically scaling each node.

No Downtime
The upgrade was executed live, showing the maturity of NEAR’s protocol engineering. Most blockchains require planned halts or downtime for state reconfiguration. NEAR does it live.




Highlights from NEAR Core v2.7.0
From the official release notes:


 	
Shard Increase: Upgrade from 8 to 9 shards using stateless resharding

 	
Protocol Upgrade: Introduces a new protocol version to support the new sharding layout

 	
Performance Gains: Optimizations in chunk processing, chunk-only producer logic, and state handling

 	
Network Stability: Enhancements to chunk verification and data propagation to ensure continued liveness





What's Next for NEAR?
Linear Scaling
Every new shard adds ~12.5% capacity. The roadmap to 10, 12, or even 16 shards is now straightforward and modular.

dApp Benefits
More shards mean reduced state contention, which leads to faster transaction finality, lower latency, and better user experience for dApps and wallets.

Competitive Advantage
While many chains (like Ethereum) are still planning full sharding or modular execution layers, NEAR is already running scalable, production-grade sharding. This means it can support real-world app growth today.




NEAR vs. the Competition





Chain
Scaling Model
Current Status




NEAR
Live dynamic sharding
9 shards live, scalable


Ethereum
Proto-danksharding in dev
Partial rollup scaling


Solana
Monolithic high throughput
Vertical scale, no sharding


Celestia
Modular data availability
Early mainnet








Conclusion
NEAR’s live upgrade to 9 shards shows it's possible to scale without breaking things. Unlike theoretical solutions still in development, NEAR has working sharding in production, with live resharding, stateless validation, and chunk-only producers all running today.
If you're building a dApp or platform and need reliable scaling, NEAR is proving to be the most technically mature and developer-friendly option out there.




Further Reading

 	NEAR’s stateless validation is an innovative approach that allows validators to verify transactions and blocks without needing access to the entire blockchain state. Instead of storing all account balances and contract data, validators use cryptographic proofs—called state witnesses—that are bundled with each block or transaction. This means that, for actions like transferring fungible tokens (FT), validators can confirm the sender’s balance and permissions using only the provided proofs, making the process much lighter and more scalable. Stateless validation helps NEAR achieve greater decentralization and efficiency, enabling lightweight nodes and improving the overall speed and security of the network—an exciting advancement for anyone interested in Web3 infrastructure.
 	
NEAR Core v2.7.0 Release Notes

 	
Nightshade: NEAR’s Sharding Architecture

 	
Chunk-Only Producer Overview

### Hotcraft: The Cross-Chain NFT Marketplace on NEAR

Who this guide is for
This guide is for curious collectors, creators, and Learn NEAR Club readers who want a simple, practical intro to Hotcraft - a new NFT marketplace built on NEAR that works across multiple blockchains.




1) What is Hotcraft (in plain English)?
Hotcraft is an NFT marketplace that lets you explore, mint, buy, and sell collections across different blockchains from one interface. Instead of juggling separate wallets, gas tokens, and websites for each chain, Hotcraft hides the complexity and makes it feel like a single smooth experience.
Think of it as a “universal gallery” for NFTs:


 	
You browse and trade like normal.

 	
Behind the scenes, Hotcraft handles the cross-chain steps for you.

 	
You don’t need to worry about bridges or “wrapped” assets.





2) Why build it on NEAR?
Hotcraft runs on NEAR because NEAR is fast, inexpensive, and designed for great user experience:


 	
Low fees: actions like listing and buying usually cost a tiny fraction of a cent.

 	
Speed: confirmations are near-instant, so cross-chain actions don’t feel sluggish.

 	
Account abstraction: your single account can trigger actions on other chains without you manually switching networks or paying separate gas there.


In short: NEAR provides the speed and “intent” plumbing. Hotcraft uses that to coordinate actions across networks on your behalf.




3) What does “cross-chain” actually mean here?
Traditionally, each NFT chain is its own island. If a collection lives on Chain A, buyers on Chain B often miss it. That fragments communities and liquidity.
Hotcraft’s cross-chain approach helps to:


 	
Grow audiences: creators get exposure beyond a single chain.

 	
Improve liquidity: more potential buyers in one place can mean healthier markets.

 	
Simplify UX: collectors don’t need multiple wallets and tabs to participate.


In practice, Hotcraft supports connecting NEAR, Solana, and EVM wallets for minting and trading experiences, while the collection itself can still be native to one chain (for example, NEAR).




4) Key ideas that make Hotcraft work

 	
NEAR Intents: you approve the outcome you want (for example, “buy this NFT”), and the system figures out the steps, even if those steps touch other chains.

 	
Gas abstraction: the platform can cover or streamline gas on the target chain, so you’re not stopped by “wrong network” or “need different gas token.”

 	
Chain abstraction: one interface, multiple chains - without manual bridging or wrapping.

 	
One marketplace feel: you discover and trade across ecosystems in a single place.





5) Getting started (step-by-step)

 	
Set up a wallet. If you already have NEAR, Solana, or an EVM wallet, you’re good.

 	
Connect in the marketplace UI. Pick the wallet you prefer.

 	
Explore collections. Use search, categories, and activity feeds to find what’s trending.

 	
Buy or mint. When you confirm, Hotcraft coordinates any cross-chain details for you.

 	
Review your profile. Track your purchases, offers, and listings in one place.


Tip: Keep a small balance on NEAR for snappy interactions and fees on the NEAR side.




6) Trending collections to know
PublicAI “DataBabies”

 	
A 10,000-piece, pixel-chibi collection that sold out during the July 14–15 public mint, with distribution across 4,000+ wallets.

 	
The drop showcased chain-abstracted UX: collectors could mint and trade using NEAR, Solana, or EVM wallets while the collection is issued on NEAR.

 	
After the mint, secondary trading saw the floor jump from roughly the mid-single-digit NEAR range to a peak in the mid-20s NEAR before cooling.


Why it matters: DataBabies proved that cross-chain minting and trading can feel simple for everyday users, and that a NEAR-native collection can reach a much wider audience.

Learn NEAR Club (LNC) collections

 	
LNCer and (L)Earner NFTs are community-driven collectibles that celebrate NEAR learners and creators.

 	
They’re designed to be approachable for newcomers, with straightforward minting and an emphasis on creativity and participation.

 	
Featuring LNC collections on a cross-chain marketplace helps bring educational NFTs in front of broader crypto audiences.


Why it matters: Community NFTs aren’t just “nice to have” - they’re a welcoming on-ramp for new users, consistently active, and easy to understand.

Harvest MOON Relics (NEAR gaming)

 	
Relics from the NEAR gaming ecosystem have been listed and traded on Hotcraft.

 	
For players, that means an easy path to buy, sell, and discover in-game items on the same marketplace used by major collections.


Why it matters: Gaming assets often kick-start activity. Listing them next to mainstream collections helps gamers and collectors find each other.




7) For creators: why launch here?

 	
Bigger reach: tap into collectors from multiple chains without rebuilding your audience on each one.

 	
Lower friction: fewer “how do I bridge?” questions; fewer lost mints due to wallet or gas issues.

 	
Faster iteration: NEAR’s low fees make testing pricing, editions, and drops inexpensive.


Tips:


 	
Keep art and metadata lightweight and polished (fast loads = better conversions).

 	
Offer clear utility or community hooks (holder roles, events, or content).

 	
Time your reveal and secondary-market plan - momentum matters.





8) Safety checklist (for everyone)

 	
Double-check collection names and contract details before buying.

 	
Be cautious with approvals and signing actions - read prompts carefully.

 	
Keep wallets and seed phrases secure; use hardware wallets for larger holdings.

 	
Start small on new drops until you’re comfortable with the flow.





9) Quick FAQ
Is Hotcraft only for NEAR?It runs on NEAR, but it’s built to work across chains so you can interact using NEAR, Solana, and EVM wallets.
If an NFT is on NEAR, can non-NEAR users still participate?Yes. That’s the point of chain abstraction - users from other ecosystems can mint or trade without manual bridging.
Do I need multiple gas tokens?No. One of the benefits here is gas abstraction, which reduces the “I’m on the wrong network” headaches.
What if I’m brand new to NFTs?Start with community collections like LNC’s and small purchases. The experience is designed to be beginner-friendly.




10) The big picture
Hotcraft brings the NFT world closer together. By using NEAR’s speed, low fees, and intent-based tech under the hood, it turns a mess of bridges, tokens, and tabs into one clean experience. For collectors, that means more choice with less friction. For creators, it means larger audiences and better liquidity. As more projects plug in, “which chain?” will matter less - and the art and utility will matter more.

### Do you understand how NEAR Intents work?

Learn more about NEAR Intents here

                 
 
                        Do you understand how NEAR Intents work?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### How to read any NEAR Intents transaction (step-by-step)

With NEAR Intents, you say what outcome you want (e.g., “swap my NEAR for USDC”) and a network of solvers competes to do it for you. A Verifier smart contract called intents.near checks the plan and executes it atomically on-chain—so you just get the result.
The sample transaction at a glance
Transaction: 34z1kKJS5SKiFoCNxzHhE956mFiTNpBYJd9wEtRCCvns (Execution tab)What happened (net):


 	
User 2in1.near swapped ~0.04995 wNEAR for ~0.131649 USDC.

 	
An app fee of 0.05 wNEAR was paid to app-fee.near, plus tiny ops fees (≈ 0.00004995 wNEAR and 0.000001 USDC).

 	
A small USDC top-up (0.001170 USDC) with memo “better quote was found” was added to the user—meaning a solver improved the price during execution.


Why this matches the chain data:


 	
You’ll see the method execute_intents called on intents.near (that’s the Verifier).

 	
The token_diff and transfer events show:


 	
2in1.near: wrap.near: -49950000000000000000000 (-0.04995 wNEAR) and USDC: +130479 (+0.130479 USDC), plus a separate transfer of 0.0005 wNEAR to app-fee.near.

 	
Refund/top-up: defuse-relay.near → 2in1.near of 1170 USDC units (+0.001170 USDC) with memo “better quote was found.”

 	
Solver side: solver-priv-liq.near sends USDC and receives wNEAR, with tiny ops dust fees also logged.





Decimal cheat-sheet:• NEAR/wNEAR use 24 decimals (divide by 10²⁴).• USDC on NEAR uses 6 decimals (divide by 10⁶).In this tx: 130479 → 0.130479 USDC, 1170 → 0.001170 USDC.

How to read any NEAR Intents transaction (step-by-step)

 	
Confirm it’s an Intents txOn Nearblocks → Execution tab:


 	
To / contract: intents.near

 	
Method: execute_intentsThat tells you the Verifier executed an Intent.



 	
Find the user’s net in/out (“what changed for me?”)In Logs → token_diff for your account (e.g., 2in1.near):


 	
Negative number = you spent that token

 	
Positive number = you received that tokenConvert using decimals (NEAR 24, USDC 6). In our sample: -0.04995 wNEAR and +0.130479 USDC.



 	
Add any fees or refundsStill in Logs:


 	
Look for transfer with memo APP_FEE (that’s an app fee you paid—in our sample 0.0005 wNEAR).

 	
Look for a “better quote was found” transfer (that’s a top-up to you—in our sample 0.001170 USDC).

 	
Tiny ops/housekeeping fees also appear (e.g., 0.00004995 wNEAR, 0.000001 USDC).Sum them with your token_diff to get the true total.



 	
Identify the solver & route (optional)You’ll see a token_diff for an account like solver-priv-liq.near. That’s the market maker who fulfilled your intent (they receive what you spent and send what you got).

 	
Sanity-check the price (optional)Divide USDC received by NEAR swapped. In the sample:0.131649 ÷ 0.04995 ≈ 2.636 USDC/NEAR (after the tiny top-up). Exact price will depend on the solver’s route/liquidity at execution time.





Mini glossary (super short)

 	
Intent: Your requested outcome (e.g., “swap X for Y”). The Verifier executes it atomically on-chain.

 	
Verifier (intents.near): The on-chain contract that checks and settles intents.

 	
Solver: A market maker/agent competing to fulfill your intent at a good price.

 	
wNEAR vs NEAR: The same asset; wNEAR is the token format that smart contracts use. (24 decimals.)

 	
USDC on NEAR: NEP-141 token (eth-0xa0b8…omft.near), 6 decimals.





TL;DR of the sample

 	
You swapped: ~0.04995 wNEAR → ~0.131649 USDC

 	
You also paid: 0.0005 wNEAR app fee (+ tiny ops dust), so ~0.1 NEAR total left your wallet—which matches your original “swap 0.1 NEAR” expectation once fees are included.

 	
Executed by: intents.near using execute_intents; solver: solver-priv-liq.near; refund memo: “better quote was found.



                 
 
                        Do you understand how NEAR Intents work?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Cơ hội Khuyến khích NEAR Q3 2025

Giao thức NEAR đang cung cấp nhiều cơ hội khuyến khích hấp dẫn, từ việc airdrop NEAR cho người dùng trung thành, phần thưởng hậu quả từ các dự án DeFi mới, đến các chương trình thử nghiệm AI với phần thưởng token, hoặc đơn giản là đặt cược NEAR để nhận token miễn phí. Dưới đây là tổng hợp các cơ hội farming, airdrop và khuyến khích nổi bật trên NEAR có thể giúp bạn kiếm được nhiều hơn!

Cơ hội Farming trên NEAR trong Q2 2025
Rhea Finance: Trade Mining – 10,000 NEAR Mỗi Tháng
Rhea Finance là một trung tâm DeFi hàng đầu trên NEAR với một DEX, cho vay, giao dịch đòn bẩy và một loạt các tính năng DeFi Bitcoin khác. Rhea hiện đang triển khai chương trình trade mining khuyến khích người dùng giao dịch để kiếm phần thưởng lên đến 10,000 NEAR mỗi tháng (phân phối dưới dạng 2,500 NEAR mỗi tuần). Cơ chế hoạt động dựa trên hệ thống tích lũy "vé": mỗi lần swap token hợp lệ trên Rhea sẽ thưởng cho bạn một số vé, và bạn có thể sử dụng các vé này để đổi phần thưởng NEAR theo các cấp độ hàng tuần.

Rhea Finance trade mining 10k NEAR mỗi tháng.

Hướng dẫn tích lũy điểm (vé): Giao dịch các token được chỉ định trên Rhea (bao gồm các tài sản blue-chip như BTC, ETH, NEAR, SOL và các token meme như SHITZU, BLACKDRAGON, NEKO, MINEMINEMINE...) để tích lũy vé. Chỉ giao dịch mua của các token này mới tính vé - bán không tính. Càng lớn khối lượng giao dịch, bạn sẽ kiếm được càng nhiều vé, số vé mỗi khối lượng:

 	$2 → 2 Vé
 	$4 → 4 Vé
 	$8 → 6 Vé
 	$16 → 8 Vé
 	…
 	$1024 → 20 Vé (và tương tự, gấp đôi khối lượng → +2 vé)

Phần thưởng và Chiến lược: Mỗi thứ Ba, Rhea mở phân phối lên đến 2,500 NEAR cho tuần đó, chia thành các cấp độ thưởng. Bạn sử dụng vé của mình để đổi NEAR - càng nhiều vé bạn có, càng cao cấp độ thưởng bạn có thể yêu cầu. Lưu ý rằng mỗi vé chỉ có thể sử dụng một lần, vì vậy bạn cần xem xét khi nào đổi phần thưởng để tối đa hóa tổng lượng NEAR bạn nhận được. Chương trình được "gamified" - càng nhiều người tham gia giao dịch, khả năng trả đủ 2,500 NEAR hàng tuần sẽ cao hơn.

Bắt đầu: Truy cập trang Cuộc thi Giao dịch của Rhea Finance, kết nối ví NEAR của bạn, và liên kết tài khoản X của bạn. Sau đó bắt đầu swap các token được hỗ trợ để tích lũy vé. Ban đầu bạn sẽ nhận được 150 vé; số vé này sẽ tự động giảm đi 10 vé mỗi ngày. Mỗi thứ Ba, hãy truy cập trang thưởng để đổi vé của bạn thành NEAR. (Số vé cần thiết cho mỗi cấp độ đổi hàng tuần sẽ được thông báo vào thứ Ba.) Với 10,000 NEAR trong phần thưởng mỗi tháng, đây là cơ hội để cả "farm NEAR" và farm token $RHEA cho những người giao dịch tích cực trên NEAR.

Mẹo chuyên môn: NEAR <> USDT / NEAR <> USDC có phí thấp nhất, vì vậy hãy xem xét swap giữa các cặp này



Ngoài ra, RHEA Lending đang cung cấp lãi suất 9-15% APY với cho vay stablecoin (USDT/USDC). Đây là một lãi suất APR rất hấp dẫn cho stablecoins, đặc biệt trên một nền tảng an toàn như RHEA Lending.

$RHEA token sẽ TGE sớm, và sẽ có nhiều hoạt động hơn để sử dụng/đóng góp vào Rhea Finance!
Delta Trade: Đặt Lệnh Giới Hạn để Săn Airdrops Trước TGE
Delta Trade là một nền tảng bot giao dịch phi tập trung cho phép người dùng chạy các chiến lược như lưới, swing, DCA, và lệnh giới hạn. Delta Trade tích hợp chặt chẽ với Rhea Finance: các lệnh từ bot của Delta được bảo hiểm thông qua thanh khoản DEX của Rhea. Kết quả là, người dùng của Delta gián tiếp đóng góp khối lượng vào Rhea và sẽ được hưởng airdrop token $RHEA sau khi Rhea TGE. Delta Trade cũng đang chuẩn bị ra mắt token riêng ($DELTA), và đã mở chương trình để farm điểm để thưởng cho người dùng sớm.


Delta Trade đang tổ chức một chiến dịch để tích lũy Delta Points - người dùng tham gia bot giao dịch sẽ nhận điểm thưởng, và những điểm này sẽ xác định phân bổ của họ trong airdrop token sắp tới. Bạn có thể kiếm điểm bằng cách chạy bot lưới (đặt lệnh mua/bán tự động trong một phạm vi giá), tham gia cuộc thi xếp hạng PnL, hoặc hoàn thành nhiệm vụ hàng ngày trên nền tảng.

Nếu bạn sở hữu NFT DeltaDisk của dự án, bạn sẽ nhận được một bội số điểm cao hơn trên mỗi giao dịch. Hiện tại, Delta Trade chưa ra mắt token, vì vậy tất cả điểm bạn tích lũy mang giá trị tiềm năng rất cao (một loại phần thưởng NEAR ngược lại).

Khi $DELTA có TGE, người dùng có tổng điểm cao sẽ nhận một lượng token tương ứng. Ngoài ra, vì Delta đóng góp vào thanh khoản của Rhea, người dùng Delta cũng sẽ nhận airdrop $RHEA khi Rhea ra mắt token của mình - một nỗ lực mang lại hai airdrop token.

Làm thế nào để tham gia: Truy cập trang chủ DeltaTrade.ai và kết nối ví NEAR của bạn. Chuẩn bị một số USDC hoặc NEAR để bot giao dịch (bạn có thể mua trên sàn giao dịch và gửi vào ví của bạn). Tiếp theo, tạo một bot giao dịch (chọn chiến lược lưới, swing, hoặc DCA và cặp giao dịch bạn muốn, ví dụ NEAR/USDC). Kích hoạt bot Delta Trade để bắt đầu giao dịch tự động 24/7.

https://x.com/DeltaBotTeam/status/1946267093978267797
Kaito Yap-to-Earn và $100k Thưởng từ NEAR
Kaito là một nền tảng kết hợp trí tuệ nhân tạo và Web3 để giải quyết vấn đề thông tin phân mảnh trong tiền điện tử. NEAR hợp tác với Kaito để ra mắt chương trình khuyến khích mang tên Yap-to-Earn - người dùng sẽ được thưởng điểm Yap khi chia sẻ thông tin hữu ích về NEAR trên Twitter.

Làm thế nào để tham gia và kiếm điểm (và $$$): Đi tới Kaito Yap cho NEAR → đăng nhập bằng tài khoản X (Twitter) của bạn để đăng ký. Sau đó, thường xuyên đăng tweet chia sẻ kiến thức, phân tích dự án, hoặc meme chất lượng về NEAR. Nếu nội dung của bạn thu hút sự tương tác cộng đồng đáng kể và được Kaito đánh giá có giá trị, bạn sẽ nhận được một phần của hồ bơi thưởng $100,000 của NEAR.

Bạn có thể viết nội dung bằng bất kỳ ngôn ngữ nào! không nhất thiết phải bằng tiếng Anh. NEAR đã đưa ra một hồ bơi thưởng $100k cho người dùng trên bảng điều khiển Kaito từ tháng 7 đến tháng 10 năm 2025,Bạn sẽ nhận được điểm Yap miễn là bài viết của bạn nhận được sự tương tác tốt và Kaito đánh giá chúng là có giá trị.



https://x.com/KaitoAI/status/1912879154942320722

Mẹo: Sử dụng Kaito Yap Tracker & Scanner bot để theo dõi điểm Yap của bạn theo thời gian thực. Điều này giúp bạn xem nội dung nào mà Kaito coi là hữu ích dựa trên điểm Yap bạn đã kiếm được.
Infinex: Phần thưởng hậu thuẫn cho người dùng NEAR
Infinex là một nền tảng trao đổi phi tập trung (thực ra, một ví tiền điện tử) được thành lập bởi đội ngũ Synthetix, nhằm mục tiêu mang lại trải nghiệm mượt mà hơn so với CEXs. Đáng chú ý, Infinex đã tích hợp Các Chữ Ký Chuỗi NEAR và Công nghệ Ý Định NEAR để hỗ trợ tài sản không nằm trên các nền tảng hợp đồng thông minh (như BTC, XRP).

Infinex đã huy động hơn 65 triệu đô la từ một loạt các nhà sáng lập hàng đầu và cộng đồng. Điều đầu tiên bạn nên làm là tạo một tài khoản trên app.infinex.xyz, đăng nhập với X, và bắt đầu sử dụng Infinex: tham gia trò chơi Bull Run, đăng nội dung về Infinex trên X để tăng điểm Yap của bạn, và đặc biệt là trao đổi/sử dụng Infinex hàng ngày như một người dùng thực sự...

Lưu ý: Gửi ít nhất tổng cộng 200 đô la tài sản vào ví để có thể truy cập tất cả tính năng của Infinex. Infinex đã từng phát triển sớm cho người dùng đầu tiên của mình $Pengu, $uPatron và nhiều mã thông báo khác... và nó có xu hướng ưu ái người dùng NEAR (Quỹ NEAR đã tham gia vòng đầu tư của Infinex), vì vậy bạn sẽ có một ƯU THẾ LỚN khi là người dùng NEAR!


PublicAI: Đóng góp Dữ liệu AI, Kiếm Phần Thưởng Token
PublicAI là một dự án Web3 kết hợp AI, xây dựng cơ sở hạ tầng dữ liệu phi tập trung cho AI (thu thập và gán nhãn dữ liệu đa phương tiện: văn bản, âm thanh, video, bản đồ... bởi cộng đồng). PublicAI đã huy động 10 triệu đô la (với sự tham gia từ Quỹ NEAR, Solana và các quỹ lớn khác) để phát triển một mô hình Train-To-Earn, nơi bất kỳ ai cũng có thể kiếm tiền bằng cách huấn luyện AI. Dự án đã ra mắt nền tảng beta DataHub, với dữ liệu đóng góp bởi người dùng đạt hơn 100 TB, 300.000 người tham gia xác nhận dữ liệu, và 500.000 người đóng góp cung cấp dữ liệu đã được xác minh cho nền tảng.

https://x.com/PublicAI_/status/1934971113286545467

Làm thế nào để kiếm điểm PublicAI: PublicAI sử dụng hệ thống điểm thưởng cho người đóng góp, gọi là Điểm PublicAI. Người tham gia có thể kiếm điểm bằng cách hoàn thành các nhiệm vụ dữ liệu trên nền tảng DataHub của PublicAI, và còn có một chiến dịch truyền thông xã hội: cài đặt tiện ích mở rộng PublicAI trong trình duyệt của bạn, sau đó sử dụng tính năng "AI Reply" trên Twitter để trả lời các tweet phổ biến — mỗi lần bạn làm điều này, bạn sẽ kiếm điểm.

Tham gia DataHubĐể bắt đầu, truy cập beta.publicai.io và tạo tài khoản (bạn có thể đăng ký bằng email hoặc đăng nhập bằng ví). Sau đó liên kết tài khoản mạng xã hội của bạn (Twitter, Discord) và liên kết 3 địa chỉ ví (bao gồm một ví NEAR - điều này yêu cầu ~0.1 NEAR để liên kết). Việc liên kết một ví NEAR sẽ khiến bạn đủ điều kiện nhận phần thưởng trên NEAR và cho phép bạn sử dụng NEAR để thanh toán khi cần. Tiếp theo, đi đến phần Nhiệm vụ trên DataHub để xem các nhiệm vụ có sẵn. Chọn một nhiệm vụ phù hợp với bạn (ví dụ: gắn nhãn cho 100 hình ảnh của mèo so với chó, dịch một đoạn văn...), hoàn thành và nộp kết quả để kiếm điểm.

Cài đặt Data Hunter Extension: Tăng điểm của bạn bằng cách cài đặt tiện ích mở rộng PublicAI Data Hunter - một tiện ích mở rộng trình duyệt cho phép bạn kiếm điểm từ hoạt động node và tăng cường tương tác xã hội của bạn. Sau khi cài đặt, đơn giản đăng nhập bằng tài khoản đã liên kết của bạn và kích hoạt hoạt động node. Ngoài ra, bạn có thể đến phần “Kiếm thêm” để xem các bài đăng phổ biến trên X và sử dụng tính năng “Trả lời AI” để tự động tạo câu trả lời. Đăng các câu trả lời này trên Twitter với một liên kết giới thiệu hợp lệ để kiếm thêm điểm mỗi ngày. Cài đặt tại đây.

Kiếm hàng ngày! Tiếp tục đóng góp!

https://x.com/_fiatisabubble/status/1949181000224788726
Gửi cọc và sử dụng Ví Di Động NEAR, nhận $NPRO
Ví Di Động NEAR là một trong nhiều ứng dụng ví trên NEAR, được phát triển bởi một bên thứ ba (PeerSyst) và được hỗ trợ bởi NEAR Foundation. Ví Di Động NEAR có giao diện đơn giản, thân thiện với người dùng, là một lựa chọn đáng tin cậy bên cạnh các ví như Meteor, Intear Wallet, HOT Wallet… Đội ngũ vừa thông báo về việc phát hành token $NPRO sắp tới, và sẽ có một chương trình airdrop cho người dùng và những người gửi cọc NEAR vào node của họ!

Đến lúc tải ứng dụng Ví Di Động NEAR xuống (có sẵn trên cả iOS và Android), bắt đầu sử dụng nó và gửi cọc một phần của NEAR của bạn vào ví để nhận các token $NPRO!

https://x.com/NEARMobile_app/status/1942178602604278221

Ví Di Động NEAR cũng đang ra mắt một chương trình đại sứ trị giá 100k $NRPO, hãy kiểm tra nó!

https://x.com/NEARMobile_app/status/1949743354738286857
Gửi cọc NEAR qua Nansen - Kiếm điểm Nansen
Nansen là một nền tảng phân tích on-chain Web3 nổi tiếng; đội ngũ đang chạy chương trình Nansen Points để chuẩn bị cho việc phát hành token sắp tới. Người dùng có thể tích lũy điểm theo nhiều cách, nhưng đơn giản nhất là gửi cọc NEAR qua Nansen để vừa kiếm lợi nhuận từ việc gửi cọc (~7% APY trên node của Nansen) vừa tích lũy điểm. Quy trình rất đơn giản: truy cập https://app.nansen.ai/stake/near, kết nối ví của bạn (Nansen hiện đang hỗ trợ ví Sender trên NEAR), và chọn gửi cọc NEAR với validator của Nansen.

Ví dụ, gửi cọc $100 trong NEAR sẽ tạo ra ~15 điểm. Điểm tích lũy theo thời gian và có thể sẽ được chuyển đổi thành token khi một chương trình airdrop diễn ra. Tài sản đã gửi cọc vẫn nằm trong một hợp đồng thông minh phi tập trung và có thể rút cọc bất kỳ lúc nào. Bạn cũng có thể gửi cọc các token khác (SOL, ETH, MATIC...) để tích lũy thêm điểm. Gửi cọc NEAR qua Nansen ngay hôm nay để tích lũy điểm Nansen và đảm bảo một vé airdrop cho token $NSP trong tương lai.https://x.com/nansen_ai/status/1949687763105902949
Các Dự Án Khác Cần Theo Dõi
Ngoài các cơ hội chính về farming và staking, NEAR là nơi đang phát triển mạnh mẽ với một loạt các dự án giai đoạn sớm đang quietly xây dựng từ ví dễ sử dụng như HOT, tới cơ sở dữ liệu mới nổi như ConsumerFi, hoặc DeFi thử nghiệm như VIBES và MoreMarkets. Hầu hết chúng vẫn chưa phát hành token - điều đó có nghĩa là bây giờ là thời điểm hoàn hảo để tham gia, farming điểm, và định vị sớm cho các airdrop trong tương lai.

Dưới đây là một số dự án NEAR-native hoặc NEAR-integrated mà bạn nên theo dõi:

Giao Thức HOT



HOT là một "ví Telegram / trò chơi clicker Telegram" rất nổi tiếng, nhưng thực sự HOT là một cơ sở hạ tầng ví dựa trên MPC (Multi-Party Computation) nhằm mục đích đơn giản hóa và thống nhất trải nghiệm người dùng Web3 trên nhiều blockchain và tài sản sử dụng omnibridge và ngăn xếp công nghệ mới của riêng mình.

$HOT là token khuyến khích cơ bản của ví, và đã được sử dụng để phát triển $HOT thành một trong những ví được sử dụng rộng rãi nhất trong toàn bộ ngành tiền điện tử.

Để bắt đầu đào HOT ngay lập tức, hãy làm theo những bước đơn giản sau:

 	Mở hoặc cài đặt HOT Wallet qua liên kết này: https://hot-labs.org/
 	Chạm "Tạo tài khoản mới" để tạo ví của bạn
 	QUAN TRỌNG: Lưu seedphrase 12 từ của bạn một cách an toàn - đây là cách duy nhất để khôi phục ví của bạn
 	Khi hoàn tất, ví của bạn sẽ được tạo ra - bạn sẽ thấy giao diện ứng dụng
 	Chạm "Nhận HOT Đầu Tiên của Bạn!", làm theo các bước, và cuối cùng chọn "Bắt đầu đào!", sau đó chọn "Nhận" để nhận 0.01 HOT đầu tiên của bạn
 	Hãy chắc chắn thực hành càng nhiều hoạt động từ HOT càng tốt!

HOT là một trong những ứng dụng web3 phổ biến nhất trong toàn bộ không gian tiền điện tử, hãy bắt đầu sử dụng ngay hôm nay và kiếm một số token $HOT!

ConsumerFi

ConsumerFi thống nhất các nhiệm vụ nhỏ, một thị trường dữ liệu cao cấp, và một nền tảng ra mắt agent trên chuỗi, để những người làm việc và tạo ra được xác minh có thể giữ giá trị trong thị trường dữ liệu AI 4.9 tỷ đô la. ConsumerFi là một nền tảng tập trung vào việc cải thiện chất lượng của các agent, dựa trên các nhiệm vụ nhỏ hoàn thành bởi những người làm việc được xác minh. Token sẽ được phát hành và bán lần đầu tiên.

Đăng ký và đóng góp sớm!

https://x.com/ConsumerFi/status/1950215156752875852
MoreMarkets: Gửi XRP, BTC để Kiếm Lãi Suất
MoreMarkets là một nền tảng lợi suất xuyên chuỗi cho phép bạn kiếm lãi suất từ XRP, BTC và các tài sản lớn khác không có hợp đồng thông minh để tham gia vào DeFi. Nó cho phép bạn nhận lãi suất mà không cần "bridge" tài sản của mình, nhờ vào NEAR Chain Abstraction, vì vậy người dùng kiếm lãi suất trong khi tài sản của họ vẫn "ở đúng chỗ". MoreMarkets đã huy động hơn 13 triệu đô la từ nhiều VCs lớn và dự kiến sẽ có một airdrop. MoreMarkets hiện đang mở danh sách chờ Truy Cập Sớm cho người dùng XRP, và dự kiến sẽ hỗ trợ BTC và các đồng tiền Layer-1 lớn khác thiếu hợp đồng thông minh (DOGE, LTC...).

Dự án sẽ ưu tiên thưởng cho những người tham gia sớm và có khả năng cao sẽ có một airdrop token sắp tới, vì vậy hãy thử MoreMarket ngay bây giờ!VIBES

VIBES là một nền tảng NEAR Native cho phép bạn giao dịch bất cứ điều gì mà thế giới đang nói về thông qua hợp đồng tương lai dữ liệu tổng hợp. VIBES chuyển đổi tiếng ồn xã hội về tiền điện tử thành một chỉ số tâm trạng với độ trễ thấp và thị trường tương lai vĩnh viễn, cho bạn một cách đòn bẩy để mua vào sự hào hứng hoặc bán ra nỗi sợ hãi về bất kỳ câu chuyện nào giờ trước khi giá chuyển động - dữ liệu thay thế, nơi thực hiện và động lực mã thông báo trong một ngăn xếp. Token $VIBES là nền tảng của thị trường này, được sử dụng cả làm tài sản thế chấp và phần thưởng.

Bắt đầu khám phá Vibes ngay bây giờ:

https://x.com/vibesdotfun/status/1944779252764987643
Giao thức Templar
Giao thức Templar là một nền tảng DeFi dành riêng cho Bitcoin, sử dụng NEAR Chain Abstraction. Nó đã huy động được 4 triệu đô la và hiện đang trong giai đoạn thử nghiệm alpha, ý tưởng rất thú vị, đáng để theo dõi!.

https://x.com/TemplarProtocol/status/1894839970730516701
Động lực cho các Validator - Chạy một Node NEAR với Meta Pool
Meta Pool, một giao thức staking lỏng lẻo trên NEAR, đang triển khai một chương trình để hỗ trợ các validator mới thông qua nền tảng Node Studio của mình. Với Node Studio của Meta Pool, các validator mới có thể chạy một node NEAR trên nền tảng mà không cần kỹ năng quản lý máy chủ và chi phí chỉ khoảng 29 đô la/tháng nhờ vào hiệu quả của thiết kế chia nhỏ của NEAR.

Hơn nữa, Meta Pool sẽ ủy quyền ít nhất 40.000 NEAR cho mỗi node validator mới đủ điều kiện, giúp bạn bắt đầu kiếm phần thưởng mà không cần vốn riêng của mình. Hơn nữa, người ủy quyền có thể nhận được token META và tăng lợi suất APY lên đến 59% nếu họ tham gia vào staking khóa trên các node trong chương trình này. Đó là một mô hình win-win: các nhà điều hành node tăng thu nhập của họ, và người staker kiếm lợi nhuận cao cộng với token META (có thể được sử dụng cho quản trị hoặc giao dịch).

Người dùng nhỏ có thể chạy node NEAR!

https://x.com/huangxiaohu321/status/1947648955103285269
Học & Kiếm với LearnNEARClub
Learn NEAR Club là một nền tảng toàn diện được thiết kế để giới thiệu cá nhân vào NEAR Protocol. Nó tập trung vào cung cấp trải nghiệm học tập thực tế và kết nối các thành viên cộng đồng với các dự án sinh thái NEAR. Nền tảng sử dụng phương pháp "L(earn)" - cho phép người dùng KIẾM khi họ HỌC về NEAR.

Bạn có thể kiếm điểm nLEARN hàng ngày bằng cách đọc bài viết, hoàn thành khóa học và nhiều hơn nữa, sau đó đổi chúng lấy $NEAR như một động lực cho việc học tập. Đây là một bức ảnh chụp màn hình của các cửa sổ đổi điểm trong quá khứ.

Bắt đầu tại đây: https://learnnear.club/courses/near-101/


Làm việc để Kiếm trên Thị trường Giao dịch NEARN Gig
NEARN là một thị trường gig toàn diện được xây dựng đặc biệt cho cộng đồng blockchain NEAR. Nó kết nối các dự án cần tài năng với một cộng đồng toàn cầu các đóng góp viên tìm kiếm để Làm việc để Kiếm - nhận tiền cho công việc trên chuỗi với NEAR.

Với ba loại danh sách linh hoạt (tiền thưởng, dự án và tài trợ) và thanh toán tiền điện tử, NEARN mang ngành kinh doanh tự do đang phát triển vào Web3 và củng cố lối vào của NEAR.

Bắt đầu hành trình Làm việc để Kiếm ngay bây giờ trên NEARN: https://nearn.io/bounties/

Kết luận
Nếu bạn là người dùng tiền điện tử đã quen thuộc với DeFi, đây là thời điểm để tận dụng kinh nghiệm của bạn để tối đa hóa lợi nhuận trên NEAR. Chọn một vài nền tảng phù hợp với phong cách của bạn - giao dịch, đặt cược hoặc đóng góp dữ liệu - và bắt đầu. Chúc may mắn!

### NEAR Q3 2025 Incentive Opportunities

NEAR Protocol is offering many attractive incentive opportunities, from airdropping NEAR to loyal users, retroactive rewards from new DeFi projects, to AI testnet programs with token rewards, or simply staking NEAR to receive free tokens. Below is a compilation of outstanding farming, airdrop, and incentive opportunities on NEAR that could help you earn more!

Farming Opportunities on NEAR in Q2 2025
Rhea Finance: Trade Mining – 10,000 NEAR Each Month
Rhea Finance is a leading DeFi hub on NEAR with a DEX, lending, margin trading, and a host of other Bitcoin DeFi features. Rhea is currently running a trade mining program that encourages users to trade to earn rewards up to 10,000 NEAR each month (distributed as 2,500 NEAR each week). The mechanism works on a “ticket” accumulation system: each eligible token swap on Rhea rewards you with some tickets, and you can use these tickets to redeem NEAR rewards at weekly tiers.

Rhea Finance trade mining 10k NEAR per month.

Guide to accumulating points (tickets): Trade the designated tokens on Rhea (including blue-chip assets like BTC, ETH, NEAR, SOL and meme tokens like SHITZU, BLACKDRAGON, NEKO, MINEMINEMINE...) to accumulate tickets. Only buy transactions of these tokens count for tickets – selling doesn’t count. The larger your trading volume, the more tickets you earn, number of tickets per volume:

 	$2 → 2 Tickets
 	$4 → 4 Tickets
 	$8 → 6 Tickets
 	$16 → 8 Tickets
 	…
 	$1024 → 20 Tickets (and similarly, doubling volume → +2 tickets)

Rewards and Strategy: Every Tuesday, Rhea opens the distribution of up to 2,500 NEAR for that week, divided into reward tiers. You use your tickets to redeem NEAR – the more tickets you have, the higher reward tier you can claim. Note that each ticket can only be used once, so you need to consider when to redeem rewards to maximize the total NEAR you receive. The program is gamified – the more people participate in trading, the more likely the full 2,500 NEAR weekly pool will be paid out.

Getting started: Visit the Trade Competition page of Rhea Finance, connect your NEAR wallet, and link your X account. Then start swapping the supported tokens to accumulate tickets. Initially you’ll receive 150 tickets; these will automatically decrease by 10 tickets each day. Every Tuesday, go to the rewards page to redeem your tickets for NEAR. (The number of tickets required for each week’s redemption tier will be announced on Tuesday.) With 10,000 NEAR in rewards each month, this is an opportunity to both farm NEAR and farm the $RHEA token for active traders on NEAR.

Pro tips: NEAR <> USDT / NEAR <> USDC has the lowest fee, so consider swapping between these pairs



Additionally, RHEA Lending is offering 9–15% APY with stablecoin lending (USDT/USDC). This is a very attractive APR for stablecoins, especially on a secure platform like RHEA Lending.



$RHEA token will TGE soon, and there will be even more activity for using/contributing to Rhea Finance!
Delta Trade: Limit Orders to Hunt Airdrops Before TGE
Delta Trade is a decentralized trading bot platform that allows users to run strategies like grid, swing, DCA, and limit orders. Delta Trade integrates closely with Rhea Finance: orders from Delta’s bots are hedged through Rhea’s DEX liquidity. As a result, Delta users are indirectly contributing volume to Rhea and will be eligible for the $RHEA token airdrop after Rhea’s TGE. Delta Trade is also preparing to launch its own token ($DELTA), and has opened a program to farm points for an airdrop to reward early users.


Delta Trade is running a campaign to accumulate Delta Points – users who participate in the trading bot will receive reward points, and these points will determine their allocation in the upcoming token airdrop. You can earn points by running a grid bot (placing automated buy/sell orders within a price range), joining the PnL ranking competition, or completing daily missions on the platform.

If you own the project’s DeltaDisk NFT, you get a higher point multiplier on each trade. Currently, Delta Trade has not launched a token yet, so all points you accumulate carry very high potential value (a kind of retroactive NEAR reward).

Once $DELTA has its TGE, users with high point totals will receive a corresponding amount of tokens. Additionally, since Delta contributes to Rhea’s liquidity, Delta users will also get a $RHEA airdrop when Rhea launches its token – one effort yields two token airdrops.

How to participate: Visit the DeltaTrade.ai homepage and connect your NEAR wallet. Prepare some USDC or NEAR for the bot to trade (you can buy some on an exchange and deposit into your wallet). Next, create a trading bot (choose a grid, swing, or DCA strategy and the trading pair you want, e.g. NEAR/USDC). Activate the Delta Trade bot to start 24/7 automated trading.

https://x.com/DeltaBotTeam/status/1946267093978267797
Kaito Yap-to-Earn and $100k in Rewards from NEAR
Kaito is a platform that combines AI and Web3 to solve the problem of fragmented information in crypto. NEAR partnered with Kaito to launch an incentive program called Yap-to-Earn – users are rewarded Yap points when they share useful information about NEAR on Twitter.

How to participate and earn points (and $$$): Go to Kaito Yap for NEAR → log in with your X (Twitter) account to register. After that, regularly post tweets sharing knowledge, project analysis, or quality memes about NEAR. If your content gains significant community engagement and is deemed valuable by Kaito, you will earn a portion of NEAR’s $100,000 reward pool.

You can write content in any language! it doesn’t have to be in English. NEAR has put up a $100k reward pool for users on the Kaito dashboard from July to October 2025, you will receive Yap points as long as your posts get good engagement and Kaito evaluates them as valuable.



https://x.com/KaitoAI/status/1912879154942320722

Tip: Use the Kaito Yap Tracker & Scanner bot to track your Yap points in real time. This way you can see which of your content Kaito considers useful based on the Yap points you’ve earned.
Infinex: Retroactive Rewards for NEAR Users
Infinex is a decentralized exchange platform (in fact, a crypto wallet) founded by the Synthetix team, aiming to deliver a smoother experience than CEXs. Notably, Infinex has integrated NEAR Chain Signatures and NEAR Intents technology to support assets that aren’t on smart contract platforms (like BTC, XRP).

Infinex raised over $65 million from a host of top founders and communities. The first thing you should do is create an account on app.infinex.xyz, log in with X, and start using Infinex: join the Bull Run mini-game, post content about Infinex on X to boost your Kaito Yap points, and especially swap/use Infinex daily like a real user…

Note: Deposit at least a total of $200 in assets into the wallet to be able to access all features of Infinex. Infinex has previously airdropped its early users $Pengu, $uPatron and many other tokens… and it tends to favor NEAR users (the NEAR Foundation was part of Infinex’s investor round), so you will have a HUGE advantage as NEAR users!


PublicAI: Contribute AI Data, Earn Token Rewards
PublicAI is a Web3 project combining AI, building a decentralized data infrastructure for AI (collecting and labeling multimedia data: text, audio, video, maps... by the community). PublicAI raised $10 million (with participation from NEAR Foundation, Solana and other major funds) to develop a Train-To-Earn model, where anyone can earn money by training AI. The project has launched the DataHub beta platform, with user-contributed data reaching over 100 TB, 300,000 participants validating data, and 500,000 contributors providing verified data to the platform.

https://x.com/PublicAI_/status/1934971113286545467

How to earn PublicAI Points: PublicAI uses a reward point system for contributors, called PublicAI Points. Participants can earn points by completing data tasks on the PublicAI DataHub platform, and there’s also a social media campaign: install the PublicAI extension in your browser, then use the “AI Reply” feature on Twitter to reply to popular tweets — each time you do this, you earn points.

Join the DataHub: To start, visit beta.publicai.io and create an account (you can sign up with email or log in with a wallet). Then link your social accounts (Twitter, Discord) and link 3 wallet addresses (including a NEAR wallet – this requires ~0.1 NEAR to link). Linking a NEAR wallet makes you eligible for rewards on NEAR and lets you use NEAR for payments if needed. Next, go to the Tasks section on DataHub to see available tasks. Choose a task that suits you (for example: labeling 100 images of cats vs. dogs, translating a text passage…), complete it and submit the results to earn points.

Install the Data Hunter Extension: Increase your points by installing the PublicAI Data Hunter extension – a browser addon that lets you earn passive points from node activity and boost your social engagement. After installing, simply log in with your linked account and enable the node activity. Additionally, you can go to the “Earn more” section to see trending posts on X and use the “AI Reply” feature to auto-generate responses. Post these replies on Twitter with a valid referral link to earn extra points daily. Install it here.

Earn daily! Keep contributing!

https://x.com/_fiatisabubble/status/1949181000224788726
Stake and use NEAR Mobile Wallet, receive $NPRO
NEAR Mobile Wallet is one of many wallet apps on NEAR, developed by a third party (PeerSyst) and supported by NEAR Foundation. NEAR Mobile Wallet has a simple, user-friendly interface, making it a solid choice alongside wallets like Meteor, Intear Wallet, HOT Wallet… The team has just announced the upcoming token $NPRO, and there will be an airdrop for users and those who stake NEAR to their node!

Time to download the NEAR Mobile Wallet app (available on both iOS and Android), start using it, and stake a portion of your NEAR in the wallet to receive the $NPRO tokens!

https://x.com/NEARMobile_app/status/1942178602604278221

NEAR Mobile Wallet is also launching an ambassador program worth 100k $NRPO, check it out!

https://x.com/NEARMobile_app/status/1949743354738286857
Stake NEAR via Nansen – Earn Nansen Points
Nansen is a well-known Web3 on-chain analytics platform; the team is running a Nansen Points program in preparation for an upcoming token launch. Users can accrue points in many ways, but the simplest is to stake NEAR via Nansen to both earn staking yield (~7% APY on Nansen’s node) and accumulate points. The process is very simple: visit https://app.nansen.ai/stake/near, connect your wallet (Nansen currently supports the Sender wallet on NEAR), and choose to stake NEAR with Nansen’s validator.

For example, staking $100 in NEAR will yield ~15 points. Points add up over time and will most likely be converted into tokens when an airdrop takes place. Staked assets remain in a decentralized smart contract and can be unstaked at any time. You can also stake other tokens (SOL, ETH, MATIC...) to collect additional points. Stake NEAR via Nansen today to accumulate Nansen Points and secure a future airdrop ticket for the $NSP token.

https://x.com/nansen_ai/status/1949687763105902949
Other Projects to Watch
Beyond the major farming and staking opportunities, NEAR is home to a growing wave of early-stage projects that are quietly building from the user-friendly wallet like HOT, to emerging data infra like ConsumerFi, or experimental DeFi like VIBES and MoreMarkets. Most of them haven’t launched tokens yet — meaning now is the perfect time to get involved, farm points, and position early for future airdrops.

Here are a few promising NEAR-native or NEAR-integrated projects you should keep an eye on:

HOT Protocol 



HOT is a super well-known “Telegram wallet / Telegram clicker game”, but actually HOT is an MPC-based (Multi-Party Computation) wallet infrastructure aiming to simplify and unify Web3 user experience across multiple blockchains and assets using omnibridge and its own novel tech stack.

$HOT is the base incentive token of the wallet, and has been utilized to grow $HOT into one of the most widely used wallets in all of crypto.

To start mining HOT right away, follow these few simple steps:

 	Open or install the HOT Wallet via this link: https://hot-labs.org/
 	Tap “Create new account” to generate your wallet
 	IMPORTANT: Save your 12-word seedphrase securely – this is the only way to recover your wallet
 	Once done, your wallet will be created – you’ll see the app interface
 	Tap “Claim your First HOT!”, follow the steps, and finally click “Start mining!”, then “Claim” to receive your first 0.01 HOT
 	Make sure to practice as much as activities from HOT as you can!

HOT is one of the most popular web3 app in the whole crypto space, start using today and earn some $HOT token!

ConsumerFi

ConsumerFi unifies micro-tasks, a premium data marketplace, and an on-chain agent launchpad, so verified workers and creators can retain value in the $4.9 billion dollar AI data market. ConsumerFi is a platform that is focused on improving the quality of agents, based on micro-tasks completed by verified workers. The token will be launched and sold for the first time.

Signup and contribute early!

https://x.com/ConsumerFi/status/1950215156752875852
MoreMarkets: Deposit XRP, BTC to Earn Yield
MoreMarkets is a cross-chain yield platform that lets you earn yield from XRP, BTC and other large assets that don’t have smart contracts to participate in DeFi. It allows you to receive yield without having to “bridge” your assets, thanks to NEAR Chain Abstraction, so users earn interest while their assets remain “in place.” MoreMarkets has raised over $13 million from many major VCs and is expected to have an airdrop. MoreMarkets is currently opening an Early Access waitlist for XRP users, and it’s expected to support BTC and other large-cap Layer-1 coins that lack smart contracts (DOGE, LTC...).

The project will prioritize rewarding early participants and there’s a good chance of a token airdrop coming up, so time to try MoreMarket!

https://x.com/moremarketsxyz/status/1948414996938936395

VIBES

VIBES is a NEAR Native platform that allows you to trade whatever the world talks about through synthetic data perpetuals.VIBES converts crypto social chatter into a low‑latency sentiment index and perpetual futures market, giving you a leveraged way to long hype or short fear on any narrative hours before spot moves—alt‑data, execution venue and token incentives in one stack. The $VIBES token is the foundation of this perps market, used both as collateral and rewards.

Start exploring Vibes now:

https://x.com/vibesdotfun/status/1944779252764987643
Templar Protocol
Templar Protocol is a DeFi platform dedicated to Bitcoin, using NEAR Chain Abstraction. It has raised $4 million and is currently in alpha testing, the concept is very interesting, worth watching!.

https://x.com/TemplarProtocol/status/1894839970730516701
Incentives for Validators – Run a NEAR Node with Meta Pool
Meta Pool, a liquid staking protocol on NEAR, is running a program to support new validators through its Node Studio platform. With Meta Pool’s Node Studio, new validators can run a NEAR node on the platform with almost no server management skills needed and cost just about 29$/month thanks to the effective of NEAR’s sharding design.

Moreover, Meta Pool will delegate at least 40,000 NEAR to each qualifying new validator’s node, helping you start earning rewards without needing your own capital. Furthermore, delegators can receive META tokens and boost their APY up to 59% if they participate in locked staking on the nodes in this program. It’s a win-win model: node operators increase their income, and stakers earn high yields plus META tokens (which can be used for governance or trading).

Small users can run NEAR node!

https://x.com/huangxiaohu321/status/1947648955103285269
Learn & Earn with LearnNEARClub
Learn NEAR Club is an all-inclusive platform designed to onboard individuals to the NEAR Protocol. It focuses on providing hands-on learning experiences and connecting community members with NEAR Ecosystem projects. The platform uses a "L(earn)" method - allowing users to EARN while they LEARN about NEAR.

You can earn nLEARN points daily by reading posts, completing courses, and more, then redeem them for $NEAR as an incentive for learning. Here's a screenshot of the past redemption windows.

Getting started here: https://learnnear.club/courses/near-101/


Work To Earn on NEARN Gig Marketplace
 

NEARN is a one-stop gig marketplace built exclusively for the NEAR blockchain community. It connects projects in need of talent with a global pool of contributors looking to Work 2 Earn - getting paid for on-chain work with NEAR.

With three flexible listing types (bounties, projects, and sponsorships) and crypto-native payouts, NEARN brings the booming gig economy into Web3 and strengthens NEAR’s builder funnel.

Start your Work 2 Earn journey now on NEARN: https://nearn.io/bounties/

Conclusion
If you are a crypto user already familiar with DeFi, now is the time to leverage your experience to maximize profits on NEAR. Pick a few platforms that suit your style – trading, staking, or data contribution – and get started. Good luck!

 

### NEAR Protocol: Một Blockchain được xây dựng cho trí tuệ nhân tạo

Chào mừng đến với Agentic Web
Internet đang thay đổi một lần nữa. Lần này, không chỉ là về trang web hoặc ứng dụng - mà là về các đại lý tự động. Đây là các chương trình thông minh có thể ra quyết định, thực hiện nhiệm vụ và giao dịch với người khác, tất cả mà không cần con người theo dõi liên tục. Hãy nghĩ về trợ lý trí tuệ nhân tạo đặt vé máy bay, bot xử lý dịch vụ khách hàng hoặc các đại lý tài chính quản lý giao dịch - tất cả đều hoạt động liên tục, hoàn toàn tự động.
Các chuyên gia dự đoán rằng sự chuyển đổi này có thể thêm hơn 15 nghìn tỷ đô la vào nền kinh tế toàn cầu vào năm 2030. Một số gọi đó là "Agentic Web" - một tương lai nơi các đại lý trí tuệ nhân tạo xử lý một phần lớn công việc kỹ thuật số. Nhưng để tương lai này hoạt động, các đại lý cần nhiều hơn chỉ trí tuệ. Họ cần một hạ tầng phi tín nhiệm, phân cấp - điều mà web hiện tại đơn giản không cung cấp.




Tại sao Web2 không đáp ứng được cho các Đại lý AI
Internet hiện nay được xây dựng xung quanh các nền tảng trung tâm. Các ông lớn công nghệ kiểm soát quyền truy cập vào dữ liệu, công cụ và thanh toán. Điều đó tốt cho con người, nhưng là một ác mộng đối với các đại lý AI độc lập. Dưới đây là lý do:


 	
Dữ liệu Silos: Rất nhiều dữ liệu trên internet bị khóa sau các API riêng. Các đại lý cần truy cập mở, không cần phép để hoạt động tốt.

 	
Không có Hệ thống Định danh Chia sẻ: Không có cách nào để một đại lý AI xác minh uy tín của một đại lý khác mà không phải dựa vào một trung gian.

 	
Thanh toán Rườm rà: Thanh toán nhỏ giữa các chương trình không khả thi do phí cao và trung gian phức tạp.

 	
Xác minh Khó khăn: Làm thế nào để chúng ta chứng minh rằng một đại lý thực sự đã làm những gì nó tuyên bố? Các bằng chứng mật mã học giúp ích, nhưng chúng không phải là cốt lõi của Web2.

 	
Rủi ro Bảo mật: Các máy chủ trung tâm dễ bị hack và giám sát - các đại lý cần cách an toàn hơn để xử lý dữ liệu.


Để hỗ trợ một tương lai được trang bị trí tuệ nhân tạo, chúng ta cần các hệ thống mở nơi các đại lý có thể tương tác, xác minh lẫn nhau, thực hiện thanh toán và truy cập dịch vụ một cách tự do. Đó là nơi mà blockchain - và cụ thể là, NEAR Protocol - đến.




NEAR Protocol: Sinh ra từ Nguồn Gốc AINEAR không bắt đầu như một dự án tiền điện tử khác. Nó bắt đầu như một công ty khởi nghiệp trí tuệ nhân tạo mang tên NEAR.ai vào năm 2017, do Illia Polosukhin (đồng tác giả của bài báo Transformer nổi tiếng đã truyền cảm hứng cho ChatGPT) và Alex Skidanov (cựu nhân viên Microsoft và vô địch lập trình) sáng lập.
Ban đầu, họ nhằm mục tiêu huấn luyện trí tuệ nhân tạo để viết mã. Nhưng sau khi nhận ra rằng công nghệ chưa sẵn sàng, họ đã chuyển hướng sang xây dựng một cái gì đó có thể kích hoạt tự động hóa: một chuỗi khối có khả năng mở rộng. Do đó, NEAR Protocol ra đời - được thiết kế từ đầu để hỗ trợ ứng dụng phân cấp, an toàn, phi tập trung có thể một ngày nào đó cung cấp năng lượng cho các đại lý trí tuệ nhân tạo.



Những Điểm Khác Biệt của NEAR là Gì?
Phân mảnh để Mở RộngNEAR sử dụng một phương pháp gọi là phân mảnh để chia công việc của mình qua nhiều làn đường - giống như có nhiều dòng hàng thanh toán thay vì chỉ một. Điều này cho phép NEAR xử lý hàng triệu giao dịch một cách nhanh chóng và rẻ tiền.
Tài Khoản Dễ Đọc cho Con NgườiThay vì địa chỉ ví mật mã, NEAR sử dụng tên người dùng như alice.near. Những tài khoản này có thể có quyền hạn linh hoạt, làm cho việc vận hành của các đại lý trí tuệ nhân tạo dễ dàng và an toàn hơn.
Công Cụ Phối Hợp Tích Hợp SẵnNEAR cho phép hợp đồng thông minh và ứng dụng gọi nhau một cách không đồng bộ, ngay cả qua các phân mảnh khác nhau. Điều này quan trọng cho các đại lý phối hợp các hành động phức tạp.



Các Tính Năng Thân Thiện với Đại Lý của NEAR
NEAR không chỉ có khả năng mở rộng - nó đang được xây dựng tích cực để hỗ trợ các đại lý tự động:
	
NEAR Ý Định: Thay vì viết ra từng bước chuỗi khối, người dùng (hoặc đại lý) có thể đơn giản chỉ định một ý định (như "đổi USDC thành BTC") và để các giải quyết viên tìm hiểu. Đó giống như nói ra điều bạn muốn, và hệ thống xử lý phần còn lại - hoàn hảo cho tự động hóa.

	
Chữ Ký Chuỗi: NEAR cho phép một tài khoản kiểm soát tài sản trên các chuỗi khối khác như Ethereum và Bitcoin. Điều đó có nghĩa là một đại lý AI có thể quản lý quỹ trên các chuỗi bằng cách sử dụng một danh tính dựa trên NEAR duy nhất.

	
Tính Toán Bảo Mật: Các nhiệm vụ nhạy cảm như phân tích dữ liệu y tế có thể được thực hiện một cách riêng tư bằng cách sử dụng môi trường thực thi đáng tin cậy. NEAR đang phát triển các công cụ để hỗ trợ các mô hình AI có thể chạy trên dữ liệu được mã hóa mà không tiết lộ cho bất kỳ ai - ngay cả máy chạy nó.

	
Monetization Tự Nhiên: Nhà phát triển có thể kiếm tiền trực tiếp từ hợp đồng thông minh hoặc đại lý AI của họ. Ví dụ, một trình tạo hình ảnh AI có thể tính phí nhỏ trong token NEAR mỗi khi được sử dụng - không cần trung gian.





Tầm Nhìn của NEAR: Lớp Tin Cậy cho Thời Đại AI
Nhóm phát triển NEAR tưởng tượng một tương lai nơi các đại lý kỹ thuật số, không chỉ con người, là người dùng chính của internet. Những đại lý này sẽ cần cơ sở hạ tầng an toàn để giao tiếp, giao dịch và xác minh hành động. NEAR nhắm đến việc trở thành lớp cơ sở tin cậy đó - mở, có khả năng mở rộng và được xây dựng cho tự động hóa.
Đó không chỉ là một chuỗi khối. Đó là một hệ thống phối hợp cho các đại lý AI.
Với các mô hình AI cải thiện nhanh chóng và tự động hóa lan rộng vào mọi góc của thế giới kỹ thuật số, một loại internet mới đang nổi lên - nơi máy móc làm việc cùng con người, đưa ra quyết định và thực hiện nhiệm vụ. NEAR đang định vị mình ở trung tâm của sự thay đổi này, cung cấp các công cụ cần thiết để biến web đại lý trở thành hiện thực.




Nhận Điểm Chính
 	
Các đại lý trí tuệ nhân tạo tự động được thiết lập để biến đổi internet.

 	
Cơ sở hạ tầng tập trung hiện nay không được thiết kế cho những đại lý này.

 	
Giao thức NEAR cung cấp khả năng mở rộng, sự tin cậy và các công cụ được xây dựng cho tự động hóa.

 	
Các tính năng như Ý định, Chữ ký Chuỗi và Tính toán Bảo mật khiến NEAR trở thành một blockchain "sẵn sàng cho AI".

 	
NEAR có thể trở thành hệ điều hành cho internet được điều khiển bởi đại lý.





Phản chiếu & Khám phá

 	
Bạn tin tưởng đại lý AI xử lý những nhiệm vụ hàng ngày nào?

 	
Tại sao phân cấp quan trọng đối với các hệ thống AI?

 	
Làm thế nào các tính năng của NEAR có thể thay đổi cách hoạt động của ứng dụng và dịch vụ trực tuyến?

 	
Bạn có cảm thấy thoải mái để để một đại lý số quản lý tài chính hoặc đặt vé cho chuyến đi của bạn không?


Đây chỉ là bước đầu của cuộc cách mạng đại lý - và NEAR đang nhắm tới việc trở thành cột sống để làm cho nó hoạt động.

### NEAR Protocol: A Blockchain Built for the AI

Welcome to the Agentic Web
The internet is changing again. This time, it’s not just about websites or apps - it’s about autonomous agents. These are smart programs that can make decisions, carry out tasks, and transact with others, all without a human constantly watching. Think AI assistants booking flights, bots handling customer service, or financial agents managing trades - all working nonstop, all by themselves.
Experts predict this shift could add over $15 trillion to the global economy by 2030. Some call it the “Agentic Web” - a future where AI agents handle much of the digital workload. But for this future to work, agents need more than just brainpower. They need a trustworthy, decentralized infrastructure - something today’s web simply doesn’t offer.




Why Web2 Falls Short for AI Agents
Today’s internet is built around centralized platforms. Tech giants control access to data, tools, and payments. That’s fine for humans, but a nightmare for independent AI agents. Here’s why:


 	
Data Silos: Much of the internet’s data is locked behind private APIs. Agents need open, permissionless access to function well.

 	
No Shared Identity System: There's no way for one AI agent to verify the reputation of another without relying on a middleman.

 	
Payments Are Clunky: Micropayments between programs aren’t feasible due to high fees and complex intermediaries.

 	
Verification Is Hard: How can we prove that an agent really did what it claimed? Cryptographic proofs help, but they’re not native to Web2.

 	
Security Risks: Centralized servers are vulnerable to hacks and surveillance - agents need more secure ways to handle data.


To support an AI-powered future, we need open systems where agents can interact, verify each other, make payments, and access services freely. That’s where blockchain - and specifically, NEAR Protocol - comes in.




NEAR Protocol: Born from AI Roots
NEAR didn’t start as just another crypto project. It began as an AI startup called NEAR.ai in 2017, founded by Illia Polosukhin (co-author of the seminal Transformer paper that inspired ChatGPT) and Alex Skidanov (a Microsoft alum and programming champion).
Originally, they aimed to train AI to write code. But after realizing that the tech wasn’t quite ready, they pivoted to building something that could enable automation: a scalable blockchain. Thus, NEAR Protocol was born - designed from the ground up to support fast, secure, decentralized applications that could one day power AI agents.




What Makes NEAR Different?
Sharding for ScalabilityNEAR uses a method called sharding to split its workload across multiple lanes - like having many checkout lines instead of one. This allows NEAR to process millions of transactions quickly and cheaply.
Human-Readable AccountsInstead of cryptic wallet addresses, NEAR uses usernames like alice.near. These accounts can have flexible permissions, making it easier and safer for AI agents to operate.
Built-In Coordination ToolsNEAR allows smart contracts and apps to call each other asynchronously, even across different shards. That’s crucial for agents coordinating complex actions.




NEAR’s Agent-Friendly Features
NEAR is not just scalable - it’s being actively built to support autonomous agents:


 	
NEAR Intents: Instead of writing out every blockchain step, users (or agents) can simply declare an intent (like “swap USDC for BTC”) and let solvers figure it out. It’s like saying what you want, and the system handles the rest - perfect for automation.

 	
Chain Signatures: NEAR lets one account control assets across other blockchains like Ethereum and Bitcoin. That means an AI agent could manage funds across chains using a single NEAR-based identity.

 	
Confidential Computing: Sensitive tasks like medical data analysis can be done privately using trusted execution environments. NEAR is developing tools to support AI models that can run on encrypted data without exposing it to anyone - even the machine running it.

 	
Native Monetization: Developers can earn directly from their smart contracts or AI agents. For instance, an AI image generator could charge micro-fees in NEAR tokens every time it's used - no middlemen needed.





NEAR’s Vision: The Trust Layer for the AI Era
The team behind NEAR envisions a future where digital agents, not just humans, are the main users of the internet. These agents will need secure infrastructure to communicate, transact, and verify actions. NEAR aims to be that base layer of trust - open, scalable, and built for automation.
It’s more than a blockchain. It’s a coordination system for AI agents.
With AI models improving rapidly and automation creeping into every corner of the digital world, a new kind of internet is emerging - one where machines work alongside humans, making decisions and executing tasks. NEAR is positioning itself at the heart of this shift, offering the tools needed to make the agentic web real.




Key Takeaways

 	
Autonomous AI agents are set to transform the internet.

 	
Today’s centralized infrastructure isn’t designed for these agents.

 	
NEAR Protocol offers scalability, trust, and tools built for automation.

 	
Features like Intents, Chain Signatures, and Confidential Computing make NEAR an “AI-ready” blockchain.

 	
NEAR could become the operating system for the agent-driven internet.





Reflect & Explore

 	
What are some everyday tasks you’d trust an AI agent to handle?

 	
Why is decentralization important for AI systems?

 	
How could NEAR's features change how apps and services work online?

 	
Would you feel comfortable letting a digital agent manage your finances or travel bookings?


This is just the beginning of the agentic revolution - and NEAR is aiming to be the backbone that makes it work.

### How to run a NEAR validator node in 2025

Introduction
Now is the good time to learn how to run validator on NEAR!

We care a lot about decentralization @NEARProtocol . In the most recent release (2.2.1), the stake threshold of becoming a validator is lowered to ~11k NEAR, less than half of what it used to be. If you are a validator, it is a good time to join!

what do you think of a program to bring way more validators on board? Get NEAR to 1k in the next few months?

Sooo, In this guide, I’ll show you how to run a validator on the NEAR mainnet. This easy, step-by-step guide will help you quickly join and validate the NEAR network, contribute to its decentralization and resilience, and earn validator rewards along the way!

As a NEAR community member, I’ve been running a NEAR node for over two years, starting with Stake Wars 3 (2022). In this guide, I’ll provide you with a detailed, step-by-step tutorial so you can set up your own NEAR full node based on my experience all these years! 

I’m excited to share everything I’ve learned, offering clear, detailed instructions to guide you through the process of setting up your own validator node on NEAR! Let’s reach 1000 active validators on NEAR!  


Why should you run a NEAR node?
NEAR is the blockchain with a huge amount of activities in web3 space but the minimum requirement for running a node is relatively lightweight, cheap to run, and much easier to maintain compared to other networks.

Top blockchains by activities, source: Artemis.


And here is the minimum hardware requirement for running a node on some popular chains (by network activities)

NEAR Validators requirements

Basically the requirement for NEAR node is like a consumer laptop that you can find in pretty much anywhere (it's would better to run on a gaming laptop IMHO 😆).

The cool thing about NEAR is that you don't need a mainframe (> 512GB ram, 300TB disk space) or even have to set up a whole database center to run and you actually can be profitable without the Foundation cover basis cost, unlike other chains!

Of course, for the node, the powerful machine, the better it performs!
I personally run my node in a machine with 32gb of RAM and < 1TB NVME SSD on 12 CPU cores, which costs around 60$/month.

Other reasons are when you need to run applications that heavily depend on RPC performance and/or availability, develop and deploy contracts on a local (independent and isolated) node (sometimes called "localnet") or quickly extract blockchain data that can be used for chain analytics, block explorer, etc...

That's pretty much reason to be bullish 🐂 on running a NEAR node, so we start now!
Installation
Requirements

 	You can use any Linux distribution but for this guide I will use Ubuntu, the requirement for Ubuntu version is 20.04 or newer, mine is running 22.04
 	Minimum hardware requirement:

 	8GB of RAM (recommended 16gb+)
 	~100 GB of NVME SSD, must be fast SSD like NVME ones (recommended ~300GB)
 	CPU with 8 cores, CPU features: CMPXCHG16B, POPCNT, SSE4.1, SSE4.2, AVX, SHA-NI
 	1Gbit network bandwidth.



Setup
Setup NEAR mainnet
You will need a NEAR address for running the node, this address will also get network rewards for running an active validator.

 	Create a FREE named NEAR address here: https://wallet.meteorwallet.app I created lncvalidator.near for this guide

 	Deposit around 31 NEAR to the address, 30 NEAR needed for creating the staking pool and will be locked for storage
 	Import the account to https://app.mynearwallet.com/

Install libraries and Nearcore
Now is the fun part, let's setup the NEAR node, login to your server and run the following commands first to update OS, install tools and libraries (near-cli, node, Python, Git...).

Please note: All commands in this guide will be needed to run under root user!
sudo apt update && sudo apt upgrade -y && sudo apt install -y \
git binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev \
cmake gcc g++ python3 protobuf-compiler libssl-dev pkg-config clang llvm \
docker.io awscli tmux jq ccze rclone build-essential make curl wget unzip
Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
rustup -V
During the installation, if asked, just press Yes and default for everything!

Install NEAR Rust CLI and NEAR-Validator extension
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh &&
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near-cli-rs/near-validator-cli-rs/releases/latest/download/near-validator-installer.sh | sh && 
source $HOME/.cargo/env
Clone the nearcore repo, choose the latest stable branch for mainnet and build the nearcore from source
cd ~ && git clone https://github.com/near/nearcore && cd nearcore/ && git checkout <VERSION>
make release
echo 'export NEAR_ENV=mainnet' >> ~/.bashrc
source ~/.bashrc
for the <VERSION>, get the latest mainnet release version here: https://github.com/near/nearcore/releases, for example, the current version is 2.4.0, so the checkout command will become git checkout 2.4.0

This build process (make release) will take around 15 minutes, you need to wait for it before going to next commands.
Authorize wallet
near login
Note: This command launches a web browser allowing for the authorization of a full access key to be copied locally.

1 – Copy the link in your browser


2 – Grant Access to Near CLI, choose "Store the access key in my keychain" from the CLI command.


3 – After Grant, fill your validator address (lncvalidator.near in this case) and press Enter
Initialize & Start the Node
Definitions:

 	<pool_id> or pool_id - your pool name, for example lncvalidator
 	<full_pool_id> or full_pool_id - xxx.poolv1.near, where xxx is your pool_id
 	<accountId> or accountId - xxx.near where xxx your account name, for example lncvalidator.near

cd ~/nearcore && target/release/neard init --chain-id="mainnet" --account-id=<full_pool_id>
Set your <full_pool_id>, example: xxx.poolv1.near, where xxx is your pool_id, for example: lncvalidator.poolv1.near



validator_key.json generated after the above command in ~/.near/ folder must be something like this:



The account_id must match the staking pool contract id  or you will not be able to sign/verify blocks.

Note: If your node has less than 1TB of disk space, you will need to lower “epoch data to keep” to avoid disk full issue (mostly wont happens but just in case) .

update ~/.near/config.json and reduce "gc_num_epochs_to_keep" to 3 instead of default 5:



Setup Systemd so the node will always run with the system
sudo nano /etc/systemd/system/neard.service
Paste:
Description=NEARd Daemon Service
[Service]
Type=simple
User=root
WorkingDirectory=/root/.near
ExecStart=/root/nearcore/target/release/neard run
Restart=on-failure
RestartSec=30
KillSignal=SIGINT
TimeoutStopSec=45
KillMode=mixed
[Install]
WantedBy=multi-user.target
After that, enable the service:
sudo systemctl enable neard
Sync data using NEAR Peer-to-peers state sync:

NEAR has decentralized state sync, a torrent like protocol for nodes to sync data with each others without relies on snapshot providers, to sync with p2p state sync, you would need to get the latest boot nodes list from the NEAR network and update to config.json file and then start the neard service, here is the command:
curl -s -X POST https://rpc.mainnet.near.org -H "Content-Type: application/json" -d '{
        "jsonrpc": "2.0",
        "method": "network_info",
        "params": [],
        "id": "dontcare"
      }' | \
jq --arg newBootNodes "$(curl -s -X POST https://rpc.mainnet.near.org -H "Content-Type: application/json" -d '{
        "jsonrpc": "2.0",
        "method": "network_info",
        "params": [],
        "id": "dontcare"
      }' | jq -r '.result.active_peers as $list1 | .result.known_producers as $list2 |
          $list1[] as $active_peer | $list2[] |
          select(.peer_id == $active_peer.id) |
          "\(.peer_id)@\($active_peer.addr)"' | paste -sd "," -)" \
   '.network.boot_nodes = $newBootNodes' ~/.near/config.json > ~/.near/config.tmp && mv ~/.near/config.json ~/.near/config.json.backup && mv ~/.near/config.tmp ~/.near/config.json
after that, just restart the node ( sudo systemctl restart neard) and you will see something like this:



Wait for sometime (usually less than 2hours, mine is usually 15mins ) and you are done, follow the next step to become an active validator!

 

Sync data with snapshot:

As an alternative method, we can download the snapshot of recent NEAR epochs instead of waiting for node sync with other peers, This process will take a few hours, and the expected data size will be around 580GB.

Run this to download snapshot and start the node (huge thanks FastNEAR for maintaining this):
curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/fastnear/static/refs/heads/main/down_rclone.sh | DATA_PATH=~/.near/data CHAIN_ID=mainnet RPC_TYPE=fast-rpc bash && sudo systemctl restart neard

The command will sync data and restart the neard!

If you need to make a change to service in the config.json file, the node also need to be reloaded:
sudo systemctl restart neard
Watch logs

Command:
journalctl -n 100 -f -u neard | ccze -A


Check the running status of the validator node. If you see something like the image above, it means the node is fully synced, and you are ready to become an active validator!
Becoming an active Validator
In order to become a validator and enter the validator set to help secure the network and earn rewards, a minimum set of success criteria must be met:

 	The node must be fully synced
 	The validator_key.json must be in place
 	The contract must be initialized with the public_key in validator_key.json
 	The account_id must be set to the staking pool contract id
 	There must be enough delegations to meet the minimum seat price. See the seat price here or just run this command
near-validator validators network-config mainnet next
 	A proposal must be submitted by pinging the contract
 	Once a proposal is accepted a validator must wait 2-3 epoch to enter the validator set
 	Once in the validator set the validator must produce great than 90% of assigned blocks or your node will be kick out

Check the running status of the validator node. If “Validator” is showing up, your pool is selected in the current validators list.
Deploy your staking pool contract
NEAR uses a staking pool factory with a whitelisted staking contract to ensure delegators’ funds are safe. In order to run a validator on NEAR, a staking pool must be deployed to a NEAR account and integrated into a NEAR validator node. Delegators must use a UI or the command line to stake to the pool. A staking pool is a smart contract that is deployed to a NEAR account.

Note: STAKING POOL CONTRACT WONT HAVE WRITE ACCESS TO ALL SUB ACCOUNTS FUNDS OR DATA, this also applies for any sub accounts on NEAR, that means your staking balance is SAFU!

Deploy a Staking Pool Contract

Calls the staking pool factory, creates a new staking pool with the specified name, and deploys it to the indicated accountId.

For Mainnet
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "<pool_id>", "owner_id": "<accountId>", "stake_public_key": "<public_key>", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
From the example above, you need to replace:

 	pool_id: Staking pool name
example "lncvalidator"
 	owner_id:: The NEAR account that will manage the staking pool. Usually your main NEAR account.
 	public_key: The public key in your validator_key.json file.
 	5: The fee the pool will charge (e.g. in this case 5 over 100 is 5% of fees), usually validators take 5% fee, if you set the fee so high, no one will stake to your node ;) 
 	accountId: The NEAR account deploying the staking pool.

Be sure to have at least 30 NEAR available, it is the minimum required for storage.

Final command will look something like this:
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "lncvalidator", "owner_id": "lncvalidator.near", "stake_public_key": "ed25519:A9RdmNFxxx", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as lncvalidator.near network-config mainnet sign-with-keychain
To change the pool parameters, such as changing the amount of commission charged to 1% in the example below, use this command:
near contract call-function as-transaction <full_pool_id> update_reward_fee_fraction json-args '{"reward_fee_fraction": {"numerator": 1, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <account_id> network-config mainnet sign-with-keychain
Note: full_pool_id: <pool_id>.poolv1.near , it’s lncvalidator.poolv1.near in this case

You will see something like this:


If there is a “True” at the End. Your pool is created.

Congrats! You have now configure your Staking pool up and running 🚀🚀🚀🚀
Manage your staking pool contract
Few useful commands you should know:

Retrieve the owner ID of the staking pool
near contract call-function as-read-only <full_pool_id> get_owner_id json-args {} network-config mainnet now
Issue this command to retrieve the public key the network has for your validator
near contract call-function as-read-only <full_pool_id> get_staking_key json-args {} network-config mainnet now
If the public key does not match you can update the staking key like this (replace the pubkey below with the key in your validator.json file)
near contract call-function as-transaction <full_pool_id> update_staking_key json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
Working with Staking Pools
NOTE: Your validator must be fully synced before issuing a proposal or depositing funds.
Proposals and Pings
In order to get a validator seat you must first submit a proposal with an appropriate amount of stake. Proposals are sent for epoch +2. Meaning if you send a proposal now, if approved, you would get the seat in 3 epochs. You should submit a proposal every epoch to ensure your seat. To send a proposal we use the ping command. A proposal is also sent if a stake or unstake command is sent to the staking pool contract.

To note, a ping also updates the staking balances for your delegators. A ping should be issued each epoch to keep reported rewards current on the pool contract. You could set up a ping using a cron job with a ping script here.

Create a new file on /home/root/scripts/ping.sh and fill this:
#!/bin/sh
# Ping call to renew Proposal added to crontab

export NEAR_ENV=mainnet
export LOGS=/home/root/logs
export POOLID=<full_pool_id>
export ACCOUNTID=<account_id>

echo "---" >> $LOGS/all.log
date >> $LOGS/all.log

near contract call-function as-transaction $POOLID ping json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $ACCOUNTID network-config mainnet sign-with-keychain >> $LOGS/all.log


Create logs folder:
mkdir $HOME/logs
Change execute permission for ping.sh file:
chmod +x $HOME/scripts/ping.sh
Create a new crontab, I personally setup it to run running every 8 hours:
crontab -e
Fill this and save
0 */8 * * * sh /home/root/scripts/ping.sh
List crontab to see it is running:
crontab -l
Review your logs
cat $HOME/logs/all.log
That is it, now you need to have enough delegated tokens to be an active validator, welcome to decentralized NEAR Protocol and earning rewards along the way 🚀🚀🚀🚀 💪💪💪💪 🛳️🛳️🛳️👽👽👽🛸🛸🛸
Network optimizations
To optimize the network settings for better validator performance, execute the following commands:
MaxExpectedPathBDP=8388608
sudo sysctl -w net.core.rmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.core.wmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.ipv4.tcp_rmem="4096 87380 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_wmem="4096 16384 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_slow_start_after_idle=0

These changes do not persist across system restarts. To apply them automatically on boot, add the following in /etc/sysctl.d/local.conf:
net.core.rmem_max = 8388608
net.core.wmem_max = 8388608
net.ipv4.tcp_rmem = 4096 87380 8388608
net.ipv4.tcp_wmem = 4096 16384 8388608
net.ipv4.tcp_slow_start_after_idle = 0
Optional: Submitting Pool Information
Adding pool information helps delegators and also helps with outreach for upgrades and other important announcements: https://github.com/zavodil/near-pool-details.

The available fields to add are: https://github.com/zavodil/near-pool-details/blob/master/FIELDS.md.

The identifying information that validators need to provide are: name, description, url, telegram, twitter,...

Example commands:

Change validator name and description: 

 	Replace <full_pool_id> with your pool address, for example: lncvalidator.poolv1.near
 	Replace <accountId> with your authenticated wallet address, lncvalidator.near for this case

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "name", "value": "LearnNEARClub"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "description", "value": "LearnNEARClub Validator!"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain


View your validator infos from CLI:
near contract call-function as-read-only pool-details.near get_fields_by_pool json-args '{"pool_id":"<full_pool_id>"}' network-config mainnet now
 

View validator infos on NEARScope or NEARBlocks:

The info will show like this: (source: NearScope)

Maintaining the node
it's important to maintain your node and keep it running stable, here is a few important things you need to know
Node status codes

 	RED: update your node ASAP!!1!!!, something critical happended, I repeat, update-it-AS-SOON-AS-POSSIBLE!!
 	YELLOW: you need to update the node, but it is not too urgent for now.
Find our more here: https://near-nodes.io/maintenance/maintenance#runtime-alerts

NEAR Validator community on Telegram
Join the group to get node update, supports and mores, please use this group for questions and discussions related to running a validator on NEAR
https://t.me/near_validators
Update new node version
When there is a new node version, you will get a notification on the Telegram Validator group, run this command to update the node.
cd ~/nearcore && git fetch && export NEAR_RELEASE_VERSION=<node_version> && git checkout $NEAR_RELEASE_VERSION && make release && sudo systemctl stop neard && sudo systemctl start neard
Replace <node_version> with the correct nearcore release version.
Monitor the node performance
Monitor the node in a Pro way:
https://near-nodes.io/validator/validator-bootcamp#grafana

Monitor the node in a degen way:
 I created a small bot to help you quickly monitor the validator uptime here, you can take a look:
https://x.com/cuongdc_real/status/1839769081723138239

Withdraw your rewards
Basically just login to any wallet on NEAR and claim your validator rewards at the wallet staking section.
Useful commands
Few other useful commands you should know:

 	Get list of active validators and the current seat price, their current performance: near-validator validators network-config mainnet now
 	Next validators list: near-validator validators network-config mainnet next
 	View validator staked balance: near-validator staking view-stake <full_pool_id> network-config mainnet now

Basically just login to any wallet on NEAR and claim your validator rewards at the wallet staking section.
Resources

 	NEAR Validators concept: https://docs.near.org/concepts/basics/validators
 	NEAR Nodes - The official NEAR Validator docs that every validators should take a look: https://near-nodes.io/
 	Calculate NEAR staking rewards: https://www.stakingrewards.com/asset/near-protocol
 	NEAR Chain Status Twitter: https://x.com/NEARChainStatus 
 	View validators info on these websites

 	https://near-staking.com/
 	https://nearblocks.io/node-explorer



Conclusion
Thank you so much for reading this far! That’s everything I wanted to share about running a validator on NEAR.
In my experience, running a NEAR node is straightforward and almost bug-free, with far fewer issues compared to other high-activity chains. NEAR requires significantly fewer server resources due to its sharding with Nightshade. Plus, you earn rewards along the way!

Speaking of rewards, soon, NEAR validators will also have the opportunity to earn rewards for running the MPC network, which contributes to NEAR's Chain Abstraction service for the broader Web3 ecosystem. With its vision of building the Open Web through Chain Abstraction and User-Owned AI, NEAR is poised to see even more network activity, giving validators the chance to earn additional rewards.

As a validator, your role is crucial in securing a high-performance network like NEAR. By safeguarding NEAR, you are also supporting many applications built on the network, such as Kaiching (a cashback app used by millions in Singapore), Sweatcoin (a health and fitness app with 100 million users worldwide), HOT (a Web3 wallet that serves as a gateway for new crypto users), and Ref Finance (a decentralized exchange on NEAR).

These apps serve millions of users daily, and as a validator, you're essential in helping them maintain their services and grow!

### One Protocol, Unified Power — The New RHEA Finance

We’re excited to unveil a major leap forward for RHEA Finance — the integration of our DEX and Lending products into a single, seamless UI experience.
This marks a pivotal milestone: the convergence of deep liquidity, capital-efficient lending, and AI-driven optimization — now unified under one powerful interface.
Same Vision. Unified UX. One UI for Everything DeFi and Yield Optimization.





🚀 What’s New
🔹 A Unified Dashboard
Bridge, trade, access NEAR LSTs, lend, borrow, margin trade, or deploy liquidity — all from one streamlined interface.Interact with every RHEA product in a single click — making capital deployment faster, simpler, and smarter.
📸 (Zoomable image display here)





🔹 Cleaner, Smarter UI
We’ve redesigned the front end from scratch — making navigation intuitive for both experienced DeFi users and newcomers.RHEA now serves as the Liquidity Hub, powered by NEAR’s Chain Signature solution.Currently supporting NEAR, BTC, ZEC — with XRP and more coming soon.

🔹 Intelligent Portfolio Data Tracking
Whether swapping, earning yield, or managing leverage, your data flows through one backend:


 	
Real-time position visibility

 	
Streamlined portfolio actions

 	
Fully connected liquidity flow — all on your dashboard




💡 Why It Matters
RHEA was born from the merger of two leading NEAR DeFi protocols — Ref and BRRR — with one shared mission:To build a chain-abstracted liquidity layer for cross-chain DeFi.
This new unified experience is more than a facelift.It redefines RHEA as the capital engine of on-chain finance.
We're merging design and functionality — removing friction between user intent and protocol performance.
This isn’t DeFi with friction.This is DeFi that flows.




🔮 What’s Next
Here’s what’s coming soon:


 	
⚙️ AI-Optimized Vaults → One-click deposits into multi-chain yield strategies

 	
🌐 Cross-Chain Support → Abstracted UX for BNB Chain & more

 	
🪙 RHEA Token Ecosystem → Including xRHEA for utility and oRHEA as the incentive layer

 	
🧠 Advanced Cross-Chain Trading → Powered by exotic optimization algorithms





🛠 The Infrastructure Is Evolving
🧩 The Experience Is Unified
🎯 The Mission Continues
To build the most efficient, intelligent, and composable liquidity system across chains.And we’re building it — with you.

### Protocolo NEAR: Haciendo que la IA sea Transparente y Verificable

La Inteligencia Artificial (IA) ha traído importantes avances, cambiando la forma en que trabajamos, aprendemos e interactuamos con la tecnología. Pero a medida que la IA se vuelve más avanzada, también lo hacen las preocupaciones en torno a la confianza, transparencia y control. La mayoría de las personas confían en sistemas cerrados administrados por grandes empresas, con poco conocimiento sobre cómo se toman las decisiones o cómo se manejan los datos personales. Esa falta de visibilidad plantea importantes preguntas sobre precisión, responsabilidad y privacidad.
NEAR Protocol toma un camino diferente, combinando la IA con la transparencia de la cadena de bloques. El resultado es una IA que no solo es poderosa, sino también abierta, auditiva y construida en torno al control del usuario. Veamos más de cerca cómo NEAR está haciendo esto posible.

Por qué es importante la IA verificable
Muchas de las herramientas de IA más populares de hoy en día, como GPT-4 o Claude, funcionan como cajas negras. Les das una indicación y te dan una respuesta, pero no puedes ver cómo llegaron a esa conclusión. No sabes qué datos utilizaron, cómo se procesaron o si puedes confiar en el resultado. Aquí es donde entra en juego el concepto de IA verificable: sistemas que son abiertos sobre cómo funcionan y que permiten a cualquiera verificar y confirmar sus resultados.
La misión de NEAR es construir una IA en la que los usuarios puedan confiar, una IA que sea abierta por diseño y donde tanto los procesos como los resultados puedan ser verificados de forma independiente.

Construyendo una IA transparente en NEAR
Una parte clave de este esfuerzo es el centro de IA descentralizado de NEAR, disponible en NEAR.ai. Aquí, cada agente de IA está vinculado a una cuenta NEAR. Esto hace que cada interacción sea rastreable y que cada decisión esté abierta a inspección.
Tomemos como ejemplo al asistente de IA de Learn NEAR Club, llamado (L)Earn AI🕺. No solo da respuestas, sino que muestra cómo funciona. Los usuarios pueden verificar su código fuente, indicaciones, filtros y el modelo exacto que está ejecutando. Nada está oculto. Ese nivel de transparencia permite a las personas confiar en la herramienta o incluso personalizarla para que se adapte mejor a sus necesidades.
NEAR también apoya modelos de IA de código abierto, lo que significa que cualquiera puede verificar qué modelo está utilizando un agente y asegurarse de que no haya sido cambiado secretamente.

Ejemplo: IA de verificación de hechos en Learn NEAR ClubUn caso de uso destacado es el Agente de Verificación de Hechos desarrollado por Learn NEAR Club (LNC). Esta herramienta ayuda a los usuarios a verificar afirmaciones, como las que se encuentran en las redes sociales, accediendo a una base de conocimientos verificada respaldada por NEAR.

Así es como funciona:

- Entrada del usuario: Envías una afirmación y de dónde proviene.
- Verificación: El agente utiliza RAG (Generación Aumentada por Recuperación) para buscar información confiable en la base de datos de LNC alimentada por XTrace.
- Resultado: Responde con un juicio claro (válido o inválido), respaldado por referencias (próximamente).
- Retroalimentación: Puedes estar de acuerdo, señalar un error o sugerir mejoras, ganando tokens nLEARN cuando ayudas a identificar información faltante.

Esto crea un ciclo donde la IA se vuelve más inteligente y la comunidad ayuda a mantenerla responsable.

nStamp: Prueba en la cadena de bloques

Para hacer las cosas aún más verificables, NEAR ofrece nStamp, una forma de anclar las salidas de la IA en la cadena. Cuando un agente da una respuesta, puedes "estamparla" en la cadena de bloques. Esto crea un hash (una huella digital) vinculado a la cuenta de NEAR que lo produjo, junto con una marca de tiempo.

Más tarde, cualquiera puede verificar ese sello para confirmar que la salida no ha sido modificada. Si los datos coinciden, el resultado se prueba auténtico, hasta el segundo en que se verificó.

Por qué es importante

En un mundo en línea lleno de desinformación, estas herramientas marcan una diferencia real. Ya sea que seas un estudiante, investigador o simplemente alguien que intenta verificar una publicación viral, NEAR te brinda el poder de validar hechos rápidamente y confiar en los resultados. Este modelo de "IA verificable" pone a los usuarios en primer lugar al hacer que cada paso del proceso sea transparente.

Regla de Karpathy: "Mantén la IA bajo control".En la Escuela de Startups de IA de YC en junio de 2025, el experto en IA Andrej Karpathy lo dijo claramente: "Mantén la IA bajo estricto control". Argumentó que los productos de IA del mundo real necesitan verificación constante, no solo demostraciones impresionantes. Para él, un sistema confiable es aquel en el que cada respuesta se combina con una verificación rápida, a menudo por un segundo modelo o humano.
El enfoque de NEAR sigue al pie de la letra ese consejo. Con Fact-Check de LNC y nStamp, cada resultado generado por IA recibe una verificación de seguimiento y una oportunidad de ser bloqueado en la cadena de bloques. Esa es la "bucle de generación-verificación" en acción.


Pruébalo por ti mismo
Esto no es un concepto futuro, está en vivo ahora. Puedes probar la IA de Fact-Check en el sitio web de LNC, enviar una reclamación, verificar un resultado y sellarlo en la cadena. Es una forma práctica de ver cómo la cadena de bloques y la IA pueden trabajar juntas para construir confianza, una hecho verificado a la vez.

### NEAR Wallets in 2025

The 2025 World of NEAR Wallets: Simple, Secure, and Full of Choice
When NEAR launched in 2020 it had one “official” web wallet. Five years later, that single gate has become a bustling marketplace. The original wallet was shut down in December 2023, and dozens of community-built wallets rushed in to serve different tastes—mobile, web, chat-based, even hardware. For newcomers this variety can feel confusing, but it is good news: more wallets mean more innovation, better security, and true decentralization. This article walks you through why the change happened, what the most popular wallets offer, and how to pick the one that fits you best.

Meet the Best NEAR Wallets



NEAR Wallet
Where You Use It
What Makes It Special
NEAR Intents Integration
Best For




MyNEARWallet
Web browser
Same look-and-feel as the old official wallet, Ledger support
No
General NEAR holders, stakers, and newcomers who want the “default” NEAR web wallet with Ledger safety


HERE Wallet
Android & iOS app
Mobile‑first NEAR wallet; swap, bridge (incl. Binance), stake (liquid/non‑blocking), gas‑free USDT transfers; connect Ledger/hardware; strong on-device security (PIN, biometrics) and audit history
No
Mobile users who want easy staking + transfers, low fees, and hardware connect on the go


Meteor Wallet
Web, browser extension, mobile
Zero-fee token swaps and built-in bridge, gamified quests
No
NEAR DeFi fans and NFT traders who enjoy a playful UI


NEAR Mobile
Android & iOS app
One-tap swaps of BTC, ETH, SOL to NEAR using Intents, password-less FastAuth
Yes
Newcomers who need simple cross-chain actions without jargon


HOT Wallet
Telegram mini‑app + Mobile/Web/Extension
MPC non‑custodial multi‑chain wallet (NEAR, TON, Solana, Tron, EVM + more) with optional 2FA; in‑chat swaps/bridges/staking; NEAR side supports Rhea + Intents swaps, liquid & native NEAR staking, Burrow yields; robust recovery + chain abstraction via HOT Protocol.
Yes
Telegram‑centric users & multi‑chain power users who want one tap trading, staking, and cross‑chain actions from chat.


Intear Wallet
Web (mobile coming)
Fastest NEAR wallet that has DEX Aggregator (9 providers in one swap interface), Smart Wallet (recovery via different methods, without seed phrase), Ledger support, Open Sourced
Yes
Memecoin traders, NFT collectors, people who interact with dapps daily






How Wallet Selector Ties It All Together
Opening a dApp and wondering which wallet button to press? NEAR Wallet Selector solves that. It is a pop-up every dApp can add. When you click “Connect,” a list of compatible wallets appears—just choose yours.
The result: you keep your favorite wallet and still enjoy any NEAR application.




Key Takeaways

 	
The closure of the old NEAR wallet sparked a competitive, community-led wallet scene.

 	
Today’s wallets cover every style: web, mobile, extension, chat, and hardware.

 	
Wallet Selector acts as the glue, letting any wallet talk to any dApp

 	
Your best wallet depends on where you spend your time (browser, phone, Telegram) and what features you value most (staking, swaps, multichain, security).

 	
Diversity brings resilience: should one wallet falter, your assets remain safe and movable to another.



                
                        
                            qVote for the best NEAR wallet 2025
                         
 
                        What is the best NEAR wallet?(Required)
			
					
					HOT wallet
			
			
					
					INTEAR wallet
			
			
					
					Meteor wallet
			
			
					
					My NEAR Wallet
			
			
					
					HERE Wallet
			
			
					
					Ethereum wallet
			
			
					
					Bitte wallet
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                

Frequently Asked Questions

 	
Which NEAR wallets already support NEAR Intents?NEAR Mobile, HOT Wallet, and Intear Wallet all advertise built-in Intents for one-tap, cross-chain swaps, whereas MyNEARWallet, HERE Wallet, and Meteor Wallet do not yet integrate Intents.

 	
I’m on my phone - what’s the most mobile-friendly wallet?HERE Wallet is designed “mobile-first” for Android & iOS and even lets you send gas-free USDT on NEAR.NEAR Mobile (also Android & iOS) focuses on one-tap Intents swaps plus password-less FastAuth log-ins.

 	
Is there a Telegram-native wallet for NEAR?Yes - HOT Wallet runs as a Telegram mini-app (and as a standalone web/mobile extension). It offers Intents swaps, staking, and multi-chain bridges right inside chat.

 	
Which wallet feels closest to the “old” official NEAR web wallet?MyNEARWallet keeps the same look and feel as the former wallet.near.org but adds Ledger hardware-wallet support for extra security.

 	
Where can I get zero-fee token swaps and a built-in bridge?Meteor Wallet includes a swap aggregator that routes trades through the cheapest path and charges no in-wallet fee, plus an embedded bridge for cross-chain transfers.

 	
I want hardware-wallet (Ledger) compatibility—who supports it?Both MyNEARWallet and HERE Wallet can connect to a Ledger device, and Intear Wallet lists Ledger as well.

 	
Which wallet lets me send USDT without paying gas?HERE Wallet’s mobile app advertises “gas-free USDT transfers on NEAR,” making it the go-to for fee-less stable-coin moves.

 	
Is there a wallet with a nine-provider DEX aggregator?Yes - Intear Wallet touts “the fastest NEAR wallet” and a DEX aggregator pulling quotes from nine liquidity sources in a single swap interface.

 	
Which wallet offers password-less FastAuth logins?NEAR Mobile bakes in FastAuth so you can create or restore an account with just a biometric or passkey—no seed phrase needed.

 	
I’m a memecoin/NFT degen - what’s the best fit?Intear Wallet positions itself for “memecoin traders, NFT collectors, and daily dApp users” with seed-phrase-free account recovery, while Meteor Wallet’s gamified quests and zero-fee swaps also appeal to active traders.

### NEAR Intents Powers Instant Cross‑Chain Swaps on Sui

July 17, 2025 – The Sui Foundation and NEAR Protocol have announced a strategic integration: NEAR Intents now supports the Sui blockchain, enabling instant, intent-driven asset swaps across more than 20 major blockchains directly into Sui—no bridges, no wallets, no gas headaches.

🚀 Key Highlights:

 	
One-click cross-chain swaps: Users can seamlessly convert assets like BTC, ETH, SOL, XRP, DOGE, and ZEC into native SUI, with no manual bridging or token wrapping.

 	
Intent-based UX: The integration leverages NEAR’s unique "intents" model—users specify what they want (e.g., “swap 1 ETH to SUI”), and the network finds the best path and executes the trade on their behalf.

 	
Frictionless experience: No need to manage gas across chains, approve smart contracts, or interact with multiple UIs. Everything completes within seconds.

 	
Composability: Developers can now embed peer-to-peer swaps, gifting via links, and other cross-chain features directly into Sui-based dApps.


💬 Industry Commentary:

 	
Illia Polosukhin, NEAR co-founder: “Swapping native assets in one click brings true interoperability to all of Web3 and unlocks powerful new DeFi and AI use cases.”

 	
Christian Thompson, Sui Foundation Managing Director: “This integration gives users control over value exchange—fast, private, and intuitive.”

 	
Alex Shevchenko, Aurora Labs CEO: “Now anyone can swap across 20+ chains into Sui in seconds, all on-chain and without losing composability.”


📈 Strategic Implications:

 	
DeFi growth on Sui: With over $1.7 billion in total value locked and more than $8.1 billion in monthly DEX volume, Sui is rapidly becoming a key player in the cross-chain economy.

 	
Developer enablement: This integration reduces the complexity of building multi-chain apps. No need for custom bridges or third-party aggregators—just plug in NEAR Intents and go.


NEAR Intents is live on Sui now, with more token support and advanced features coming soon.

### NEAR Protocol: Making AI Transparent and Verifiable

Artificial Intelligence (AI) has brought major breakthroughs, changing how we work, learn, and interact with technology. But as AI becomes more advanced, so do the concerns around trust, transparency, and control. Most people rely on closed systems run by big companies, with little insight into how decisions are made or how personal data is handled. That lack of visibility raises important questions about accuracy, accountability, and privacy.
NEAR Protocol takes a different path - one that combines AI with the transparency of blockchain. The result is AI that’s not only powerful but also open, auditable, and built around user control. Let’s take a closer look at how NEAR is making this possible.

Why Verifiable AI Matters
Many of today’s most popular AI tools - like GPT-4 or Claude - work like black boxes. You give them a prompt, and they give you an answer, but you can’t see how they reached that conclusion. You don’t know what data they used, how it was processed, or whether you can trust the result. This is where the concept of verifiable AI comes in: systems that are open about how they work and that allow anyone to check and confirm their outputs.
NEAR’s mission is to build AI that users can trust - AI that’s open by design, and where both processes and results can be independently verified.

Building Transparent AI on NEAR
A key part of this effort is NEAR’s decentralized AI hub, available at NEAR.ai. Here, every AI agent is tied to a NEAR account. This makes every interaction traceable, and every decision open to inspection.
Take Learn NEAR Club’s AI assistant, for example - called (L)Earn AI🕺. It doesn’t just give answers; it shows how it works. Users can check its source code, prompts, filters, and the exact model it’s running. Nothing is hidden. That level of openness allows people to trust the tool - or even customize it to better suit their needs.
NEAR also supports open-source AI models, meaning anyone can verify which model an agent is using and ensure that it hasn’t been secretly changed.
To get more details on how transparent and verifiable AI works on NEAR please refer to this Guide

Example: Fact-Check AI at Learn NEAR Club
One standout use case is the Fact-Check Agent developed by Learn NEAR Club (LNC). This tool helps users fact-check claims - like those found on social media - by tapping into a vetted knowledge base backed by NEAR.
Here’s how it works:


 	
User Input: You submit a claim and where it came from

 	
Verification: The agent uses RAG (Retrieval-Augmented Generation) to look up trustworthy information from the LNC database powered by XTrace

 	
Result: It responds with a clear judgment (valid or invalid), backed by references (coming soon)

 	
Feedback: You can agree, flag a mistake, or suggest improvements - earning nLEARN tokens when you help identify missing info. This creates a cycle where the AI gets smarter and the community helps keep it accountable.
You saw a post on Z and you want to make it sure it is legit to interact with.
 
Paste the fact and source URL into the agent


AI agent responded:

Cool, seems about right!
Now let's protect ourselves and make (L)Earn AI responsible for the response!

nStamp: Proof on the Blockchain
To make things even more verifiable, NEAR offers nStamp - a way to anchor AI outputs on-chain. When an agent gives an answer, you can “stamp” it to the blockchain.
This creates a hash of trace, along with a timestamp. The trace contains details of the actual request sent to the agent, along with the original response and HTTP status code.


Anyone can verify the origin account, timestamp and the hash at NEAR explorer of their choice.

Now let's check if nStamp actually did what it promised to do! Let's verify the nstamped data:

Copy and paste the AI interaction trace into verification tool:

Hashes matched - we are all good!

Later, anyone can check that stamp to confirm the output hasn’t been changed. If the data matches, the result is proven authentic - right down to the second it was verified.
If any actor - user, agent or model tries to tweak the data for some reason - verification fails.

Why It Matters
In an online world filled with misinformation, these tools make a real difference. Whether you're a student, researcher, or just someone trying to check a viral post, NEAR gives you the power to validate facts quickly - and trust the results. This “verifiable AI” model puts users first by making every step in the process transparent.
Karpathy’s Rule: “Keep the AI on a tight leash.”
At YC’s AI Startup School in June 2025, AI expert Andrej Karpathy said it best: “Keep the AI on a tight leash.” He argued that real-world AI products need constant verification - not just impressive demos. For him, a reliable system is one where every answer is paired with a fast check, often by a second model or human.
NEAR’s approach follows that advice to the letter. With LNC’s Fact-Check and nStamp, every AI-generated result gets a follow-up check and a chance to be locked into the blockchain. That’s the “generation-verification loop” in action.



Try It for Yourself
This isn’t a future concept -it’s live now. You can try the Fact-Check AI at LNC website, submit a claim, verify a result, and stamp it on-chain. It’s a hands-on way to see how blockchain and AI can work together to build trust - one verified fact at a time.

### Introducing ASIMOV: A Platform for Trustworthy Neurosymbolic AI

Today we are beginning the rollout of the first phase of the ASIMOV platform, a state-of-the-art polyglot development platform for trustworthy, neurosymbolic AI. The platform in this first public release is capable of turning any URL into a semantic knowledge graph for use with large language models—"neurosymbolic" here meaning exactly the combination of neural networks with symbolic AI—while preserving and providing cryptographic attestations regarding the provenance of the information.



The platform is fully modular, enabling anybody to develop ASIMOV modules to unlock and utilize any particular data source, whether private or public, local or remote. The platform is implemented using the safe Rust programming language, and we will be making available extensive command-line tooling as well as initial software development kits for Python, Ruby, Rust, and TypeScript—these languages combined covering about 80% of the software engineering market. Many aspects of the platform, including its software architecture, are novel and without precedent in open-source form. Read on for a brief overview!
The Name for Trustworthy AI
It goes without saying that a project named ASIMOV could not discuss trustworthy machine intelligence without a mention and homage to Isaac Asimov's pioneering Three Laws of Robotics:


 	A robot may not injure a human being or, through inaction, allow a human being to come to harm
 	A robot must obey the orders given it by human beings except where such orders would conflict with the First Law
 	A robot must protect its own existence as long as such protection does not conflict with the First or Second Law


Isaac Asimov not only invented robotics and shaped robots as we know them, but his substantial body of work created path dependence that implicitly and ultimately frames all modern thinking on robots, especially humanoid robots. He also did some of the earliest systematic thinking on the safety and steerability of robots and artificial intelligence, with his work thus laying conceptual groundwork for what later developed into AI safety and alignment research.

In honor of Isaac Asimov's legacy, we mean to establish ASIMOV as a global brand synonymous with trustworthy machine intelligence. There truly could not be any better name for trustworthy AI.

What is Trustworthy AI?
What would it mean for an AI system to be trustworthy? For all their other utility, certainly none of the incumbents today could be said to have reached such a high watermark: current AI systems are fundamentally afflicted by confabulations (aka hallucinations) and frequently go off the rails even in casual daily use. Current AI systems are quite unable to provide genuine rationale for the answers they give—any ostensible rationale will but itself be a confabulation. They are unable to attest, much less prove, the provenance of any clump of unstructured data in the static knowledge soup encoded into the bulk of the model's weights.

Indeed, current AI systems are black boxes in the worst sense, neither introspectable nor auditable. We may derive some benefit from them, but we all as users of the current generation of systems have certainly already long since learned that it is also necessary to double-check factual answers provided by the model; and this introduces significant friction and risk into scenarios where otherwise such models could be deployed to automate some process. Moreover, current AI systems lack any means to automatically and reliably fact-check a model's answers beyond haphazardly crawling and scraping random web pages.

To make matters worse, most users of AI today are also beholden to cloud-based AI vendors that are incompatible with privacy and have—unsurprisingly—already been known to have leaked private and confidential conversations to third parties.


A Platform for Trustworthy AI
The aforementioned challenges point the way to a few cornerstones of what trustworthy AI could mean: for starters, certainly trustworthy machine intelligence ought to be based on an explicit, symbolic knowledge base instead of the current implicit, unstructured knowledge soup. All we really require from a large language model itself is human-like language understanding and reasoning combined with just enough tacit knowledge so as to solve the commonsense problem that plagued AI systems of previous eras. (That is, proper language understanding necessarily requires some amount of commonsense knowledge.) Anything much beyond these features is dead weight that is both immediately outdated as well as tremendously expensive to update.

It follows that trustworthy AI systems ought to have some introspective ability to access and manipulate their knowledge base. They ought to be able to explain their answers and reasoning with reference to this knowledge base, grounding any claims in cryptographically-verified provenance metadata stored alongside every assertion in said knowledge base. And this knowledge base ought to be bitemporally revisioned—supporting both validity time and transaction time—so as to guarantee retrospective auditability. All of these challenges and concerns are matters we are tackling within the scope of ASIMOV.
An Algebra for Knowledge
What concrete form might such a knowledge base take? The current prevalent approaches mirror the contemporary plain-text input/output characteristics of large language models, as well as the practices of the context-engineering community around them: projects are most typically representing knowledge just using natural language in Markdown documents.

But where else in computer science do we deal with plain text in and plain text out? Even parsers map input bytes to tokens (lexical analysis) and then to concepts (syntactic and semantic analysis); they didn't stop at mere tokens. Much in the same vein, we believe that it is still early days for LLMs and current practice will evolve to marry a token-based frontend with a concept-based backend. (It will be preferable to reason in concepts instead of tokens.)


Unfamiliar though it may as yet be to many practitioners today, knowledge representation & reasoning (KR&R) is a long-established discipline and there indeed exists an excellent way to represent AIs' knowledge bases using concepts instead of tokens. This approach is centered around knowledge graphs.

Knowledge graphs are a universal data model—meaning they subsume and are able to represent any other data model—with an extensive research literature going back decades and with well-defined international standards that codify and guarantee their interoperability. In the form of JSON-LD, it is easy to retrofit any existing system to import or export semantically-rich structured data that represent a knowledge graph.

In short, one of the remarkable aspects of knowledge graphs is that a graph plus a graph is still a graph. This is a tremendously desirable quality for breaking open the data silos that characterize our splintered, captive digital identities and digital lives today. One of the use cases for ASIMOV that we're really passionate about supporting is the building of a personal intelligence layer that brings into conjunction all the information in your life, enabling actionable insights that would otherwise be impossible. In a sense, a secure personal data warehouse accessible to your personal AI.

A High-Assurance Language
Another aspect of the trustworthiness of AI systems concerns the programming languages those systems are implemented in. We have chosen to build using the high-assurance, memory-safe systems programming language Rust. This deliberately bucks a trend that has seen most AI developer frameworks to date implemented in Python and/or TypeScript, and lower-level layers (including inference engines) implemented in C++.

Building with Rust instead of C++ means that ASIMOV is invulnerable to whole classes of severe software defects and security vulnerabilities that plague software systems implemented in other languages (see CVE-2024-42479 for just one representative example.)

Beyond the top-notch safety characteristics of Rust, the language has several other notable things going for it. For one, it has topped "the most admired programming language" for now a consecutive 9 years in a row in Stack Overflow's annual developer survey, which is an unprecedented feat that also means Rust developers are rather passionate about programming specifically in Rust. For another, the Rust compiler produces high-performance static executables; more on the implications of that below.


A Platform for Polyglots, by Polyglots
Our aim is to have ASIMOV become standard tooling available on every operating system and ultimately accessible from every programming language. This means we are going full polyglot, supporting a wide variety of programming languages instead of just one or two (typically these days, Python and/or TypeScript). Instead of forced adherence to the monoculture du jour, we will enable everyone to be able to use their programming language of choice in building their own AI systems.

This ambition is facilitated by Rust's tremendously good cross-compilation toolchain which empowers us to produce turnkey static binaries that simply work everywhere (and which will keep on working for decades to come) without the usual dependency hell that characterizes building large C++ systems in particular.
Free and Unencumbered Software
ASIMOV is the first AI platform that is 100% free and unencumbered software placed into the public domain with no strings attached. This means you may copy, reuse, and remix our code without any legal requirement for even attribution. We believe this will tremendously aid in the distribution and mindshare of the platform, quickly enough making ASIMOV the standard reference implementation—both in industry and academia, not to mention for code generation by AI—for any future project building along similar lines.
Follow Us on the Journey!
If all the preceding sounds intriguing, follow our platform updates at @ASIMOV_Platform on X and @asimov-platform on GitHub, and subscribe to this blog to be notified about upcoming in-depth technical material in the coming weeks!

### Heads-up for NEAR devs - Migrate Your NEAR RPC to Lava

NEAR is phasing out its free public RPCs at https://rpc.mainnet.near.org and pagoda.co. All apps that still point there need to migrate before the endpoints go read-only.
Why switch to Lava?


 	
Official option – Lava’s NEAR mainnet & testnet RPCs are on NEAR’s recommended list.

 	
Drop-in replacement – same API, full archival data, no setup.

 	
Free & generous – no fees and no rate-limits below ~30 RPS for public endpoints.

 	
Decentralised & monitored – powered by multiple node providers and 24/7 metrics.


Quick migration:



# .env or config.js
NEAR_RPC=https://near.lava.build/rpc  # Lava mainnet
NEAR_TESTNET_RPC=https://near-testnet.lava.build/rpc

That’s it—swap the URL, redeploy, and you’re back on chain. Need higher throughput later? Upgrade to Lava Gateway when you outgrow the free tier.



Questions? Hop into Lava’s Discord for live help. Keep shipping!

### Bitte.ai: Chatting Your Way Through NEAR dApps

Introduction
Web3 apps can be intimidating for newcomers. Complex interfaces, multiple steps, and technical jargon often create a steep learning curve. Imagine instead if you could simply chat with a dApp, asking questions in plain English (or any language) and tell it what you want to do. That’s exactly what Bitte.ai enables. Bitte.ai is an AI-powered platform that lets developers embed natural language chat assistants directly into decentralized apps. The result: users can manage crypto tasks by conversing naturally, as if talking to a helpful guide, rather than wrestling with complicated UIs. It’s a friendly, intuitive approach that makes blockchain feel accessible from day one.




What is Bitte.ai
Bitte.ai (sometimes called Bitte Protocol) is essentially a bridge between human language and blockchain actions. It provides an embeddable chat component that supports both NEAR Protocol and EVM blockchains. In practice, this means a dApp can have a chat box where you, the user, can type something like “I want to swap 50 NEAR for ETH” or “How do I stake my tokens?”, and the AI agent will understand and help execute it. Key benefits of this AI-chat approach include:

Simplified Onboarding
New users can ask basic questions (“What is a liquidity pool?”) and get guidance within the app. This real-time help lowers the barrier to entry, so the crypto-curious aren’t immediately lost or frustrated. As the Bitte team says, the agent is always “ready to talk to users, simplify onboarding, and execute real transactions” – essentially letting the app’s UI talk.

Natural Language Transactions
Users don’t need to know the precise steps or navigate multiple menus. They just state what they want. The AI parses your intent and calls the necessary smart contracts or APIs behind the scenes. You get things done by simply chatting, which dramatically improves the user experience for both newcomers and power users.

Reduced Complexity
No more juggling tabs or forms for a multi-step DeFi action. Whether it’s swapping tokens, lending, or bridging assets, the AI agent can handle the heavy lifting. One prompt could replace what used to be several manual steps, all executed securely in the background.

Multichain and Scalable
Bitte.ai comes with a library of 100+ integrated tools and supports many chains (NEAR, Ethereum, and more). The same chat interface can help users across different blockchain ecosystems without needing separate wallets or UIs for each. This unification further smoothens the experience (one chat to rule them all!).
Developers love that Bitte’s chat agent is easy to add through a simple API, but the real winners are the users who get a conversational UI. Since every chat agent is customizable, it can be tailored for exactly the use cases of the dApp it supports. By meeting users in their comfort zone (natural language) and hiding the blockchain complexity, Bitte.ai significantly reduces the learning curve for dApps.




Case Study: Rhea Finance’s AI Chat Assistant
A great real-world example of Bitte.ai in action is Rhea Finance (Rhea). Rhea is a DeFi platform on NEAR that offers a DEX and lending markets and integrated a Bitte.ai powered chat agent directly into their application. Now, when users log into Rhea, they can do things like:

Lending/Borrowing
“Supply 100 USDC to my account.” The agent will initiate a supply transaction. Or “Borrow 50 NEAR using my USDC as collateral” the agent handles the borrowing steps. It can also help adjust collateral or repay loans, all via chat prompts.

Trading on the DEX
“Swap 20 NEAR for wETH”: The AI finds the best route on Rhea’s DEX and executes the swap for you. You could even say, “Provide liquidity to NEAR-USDC pool,” and the agent guides you through it.
https://learnnear.club/wp-content/uploads/2025/06/bitte-at-learn-near-club.mp4
General Support
You can ask questions like “What’s my current loan health?” or “How do I stake RHEA tokens?”. The assistant is there to answer, pulling info from Rhea’s contracts or documentation as needed.
This embedded AI assistant means you’re not clicking through multiple pages or forms to lend, borrow, or trade. You’re simply having a conversation. As the Bitte team highlighted about Rhea’s integration: “Borrow, lend, swap, or ask a question. No tabs. No forms. Just talk to DeFi.” The agent is built into Rhea’s interface, so users don’t leave the app or deal with external bots.
Early feedback from the community has been positive. It’s not just a cool demo; it’s a practical upgrade to UX. Users report that it feels like chatting with an expert DeFi assistant inside Rhea. This boosts confidence; if you’re unsure how to do something, you can just ask. It also keeps users engaged: instead of bouncing off due to confusion, they can accomplish tasks with guidance. Rhea’s team even tied the AI agent into their user engagement efforts (like rewarding users for volume done via the agent), showing how confident they are that this “agent-native UX” can drive growth. Expect more of this in the future!




What’s Next for Bitte.ai: NEAR Intents and the Future of Chat UX
The journey doesn’t stop at basic transactions. The next big thing for Bitte.ai is leveraging NEAR Intents – an innovative feature of the NEAR Protocol – to supercharge what these chat agents can do. NEAR Intents allow users (or AI agents) to specify a desired outcome, and let the blockchain figure out the how. It’s like saying “I want to swap my tokens and bridge them to chain X for the best rate” in one go, instead of manually doing each step. This is perfectly aligned with Bitte’s natural language approach.
By integrating NEAR Intents, Bitte.ai agents will be able to execute cross-chain actions from simple prompts. In the coming weeks, you will be able to type: “Bridge my 100 USDC from Ethereum to NEAR and stake it for yield,” and the agent will parse that intent and coordinate all required steps automatically. Under the hood, NEAR Intents’ solver network finds the best path (e.g., which bridge or exchange to use), and the transactions on each chain are handled for you.
So, what’s next? We’ll likely see Bitte.ai rolling out more Intents-enabled chat capabilities in the coming months for more. This might start with specific use cases (like bridging tokens through a conversation, as described) and expand as Intents infrastructure matures. The end goal is that performing any action, no matter how many contracts or chains are involved, is as easy as telling your dApp “Here’s what I want to do…” and confirming the plan it proposes.
As NEAR’s tech stack evolves with features like Intents, Bitte.ai is positioned to ride that wave and deliver even more powerful experiences. The prospect of bridging tokens or executing multi-chain strategies via a quick chat is no longer science fiction; it’s on the horizon. For NEAR-native users, this means their favorite apps can become smarter and easier to use. For the crypto-curious, it means the door to Web3 just got a lot less scary.

### NEARN: The NEAR Talent Platform

What is NEARN?
NEARN brands itself as “the world’s best NEAR talent platform,” connecting sponsors with skilled contributors for everything from quick meme bounties to multi-month engineering contracts. Unlike generic freelancing sites, every opportunity targets a need inside the NEAR ecosystem—marketing, design, dev tooling, community growth, and more—so contributors up-skill while sponsors get domain-savvy help.



How the Platform Works
Listing Types

 	Bounties – Many people deliver the same task and share a prize pool.
 	Projects – Classic one-off freelance engagements with a single winner.
 	Sponsorships – Open-ended funding for ongoing or exploratory work.

Contributor Flow

 	Sign up with Google or email.
 	Browse opportunities by category or type.
 	Submit work or proposals.
 	Get paid in NEAR, USDC, or another token once approved.

Sponsor Flow

 	Create a profile and click “Create New Listing.”
 	Define scope, rewards, skills, deadline, and visibility.
 	Review submissions in a unified dashboard.
 	Release payment on-chain once satisfied.




Key Features & Differentiators

 	NEAR-only focus ensures tasks are natively relevant and discoverable.
 	Global talent pool with dual-role accounts—contributors can also sponsor.
 	Reputation signals and token-based payouts build trust.
 	Flexible scope control supports bounties, projects, and sponsorships.




Strategic Role in the NEAR Ecosystem
NEARN builds on earlier initiatives like NEAR Crowd and NEAR Tasks, expanding the “earn-on-NEAR” narrative from micro-tasks to full-scale freelance work. It leverages NEAR’s fast finality and low fees and feeds talent into key programs like DevHub and community DAOs—creating a virtuous cycle of contribution, visibility, and funding.



Why It Matters
The global gig economy is projected to reach $646 billion by 2025, growing over 16% annually. NEARN positions NEAR to capture this momentum by making on-chain, cross-border work as seamless as Web2 freelancing—while benefiting from crypto’s incentives and transparency. For contributors, it’s a gateway to paid blockchain experience. For sponsors, it’s a cost-efficient way to find talent within the NEAR ecosystem.



Conclusion
NEARN transforms the gig economy into a NEAR-powered workforce network—helping projects ship faster and contributors earn crypto for real impact. As NEAR evolves into an AI-driven blockchain operating system, NEARN ensures the community has the human power to build it.

Whether you're a builder looking for real work or a project in need of top-tier talent—NEARN is where the NEAR ecosystem connects, creates, and gets rewarded.Join now, start earning, and help shape the future on NEAR.

### BOS on NEAR: From Ambitious OS to Archived Proof-of-Concept

NEAR’s Blockchain Operating System (BOS) debuted in 2023 as a “universal app layer” where on-chain user interfaces and social data could live side by side, giving Web3 a Web2-like user experience.
By mid-2024, core development stopped: the BOS web engine struggled with common JavaScript libraries, security hardening proved costly, and the NEAR team formally marked the project deprecated. Existing portals remain in read-only mode, but no new features are planned.
Builders are now shipping front-ends with familiar frameworks and hosting them on decentralized storage such as IPFS or Arweave, or experimenting with NEAR’s newer Web4 pattern. In practice, BOS has become a historical proof-of-concept, while active innovation has moved on to more flexible and well-supported tooling.

### What is PublicAI?

PublicAI is a community-driven platform that lets everyday people help train and improve AI systems—and get paid for it. Picture a marketplace for AI training data: companies and researchers need high-quality information, while regular folks around the world have unique knowledge, voices, and insights AI can learn from. PublicAI connects the two, turning human expertise into a new source of income.
Founded in 2023 by a mix of AI researchers and Web3 builders, PublicAI is sometimes called a “decentralized alternative to traditional data-labeling firms.” Its mission is simple: if your contribution makes an AI model smarter, you deserve a fair share of the value created. With nearly a million contributors already onboard, the platform is proving that a crowd can supply reliable data at a scale and diversity no single company could achieve alone.

Why PublicAI Is Needed

 	
High Costs & Limited AccessTraditional AI data gathering is expensive and centralized. By opening tasks to a global community and rewarding them with crypto, PublicAI slashes costs and broadens participation.

 	
Quality & TrustCrowdsourced data can be messy. PublicAI uses blockchain-based staking and peer voting to keep contributors honest. Bad submissions hurt a worker’s reputation and cost them a small staked deposit, so quality stays high.

 	
AI Bias & “Model Collapse”AIs trained mainly on AI-generated content can drift off-course. PublicAI’s human-sourced data keeps models anchored in real-world knowledge, languages, and cultural contexts.

 	
Job Displacement FearsInstead of watching AI take jobs, PublicAI lets people earn by supplying the very data AI needs. It’s a path toward “data basic income” in an AI-heavy economy.


How PublicAI Works

 	
Clients Post Data NeedsAn AI team might request 10 000 voice clips in Swahili or a set of images labeled by dog breed.

 	
Contributors Pick TasksPublicAI’s dashboard lists tasks for data builders (collecting or generating data), labelers (tagging data), and validators (double-checking others’ work).

 	
Skill Checks & AI AssistanceQuick quizzes route specialized tasks to qualified people. Browser plug-ins and AI helpers make repetitive work faster and easier.

 	
Consensus & Quality ControlMultiple validators vote on each submission. If the majority approves, the contributor is rewarded. Repeated poor work means losing staked tokens and reputation.

 	
Rewards & PayoutsContributors earn points convertible to tokens plus direct stablecoin payouts. A linked crypto wallet—NEAR, Solana, BNB, or another chain—handles the money, so anyone with internet can participate. Leaderboards and milestone bonuses add a game-like twist.

 	
Delivery to ClientsCompanies receive vetted, high-quality datasets ready for model training—cheaper, faster, and more diverse than traditional pipelines.


What’s in It for Everyday Users?

 	
Earn While You Browse or SpeakRecord your native language, answer trivia, tag images—get paid for each approved task.

 	
Global InclusionNo bank account? No problem. Crypto payouts make it easy for anyone, anywhere, to participate.

 	
Skill RecognitionHigh quiz scores and good task performance build a public reputation, unlocking higher-paid work and verifiable credentials.

 	
Shape AI EthicallyYour input influences how future AI systems understand language, culture, and fairness.

 	
Transparent, Rule-Based PaySmart contracts guarantee you’re rewarded the moment your work is approved.


PublicAI × NEAR Protocol: A Web3 Partnership
The NEAR Foundation is both an investor and strategic ally of PublicAI. NEAR’s fast, low-fee blockchain lets PublicAI process thousands of micro-rewards smoothly. Contributors can connect a NEAR wallet, receive earnings in stablecoins on NEAR, and later claim the upcoming PUBLIC token.
Beyond payments, the two projects collaborate on campaigns. For instance, NEAR co-sponsored PublicAI’s “Mother Tongue” challenge, which paid speakers of twelve languages to record voice samples. The initiative not only enriched AI speech models but also showcased NEAR’s commitment to user-owned AI and inclusive tech.
PublicAI, in turn, demonstrates a real-world use case that drives traffic and transactions on NEAR. It’s a symbiotic relationship: NEAR supplies the blockchain muscle; PublicAI supplies a mission that resonates with everyday people.

Real-World Example: The “Mother Tongue” Voice Campaign
The Challenge: AI companies needed authentic voice data in many languages.The PublicAI Solution: Thousands of volunteers read short phrases in their native tongues via an in-browser recorder. Validators checked clarity and pronunciation. Contributors earned crypto for recordings and for voting accurately on others. In weeks, the campaign gathered hours of quality audio across a dozen languages—at a fraction of traditional costs and with shared rewards for every participant.

The Big Picture
PublicAI flips the usual AI narrative. Rather than a black box controlled by giant corporations, AI becomes a community project where human knowledge is valued and compensated. Blockchain ensures fairness, while partnerships like the one with NEAR make onboarding and payouts seamless.
If you’ve ever wondered how to stay relevant—and even profit—in an AI-centric future, PublicAI offers a friendly door in: contribute what you know, earn crypto, and watch your work power the next generation of intelligent tools. In this model, AI doesn’t replace humans; it learns from us, pays us, and grows with us.
PublicAI turns the AI revolution into a global team effort—and everyone is invited.

### AI Verificable y Responsable, en un lenguaje sencillo

La inteligencia artificial ahora escribe ensayos, predice enfermedades y aprueba préstamos bancarios. Eso es asombroso—hasta que un modelo alucina o alguien manipula los datos para alterar el resultado. Cuando no podemos auditar cómo un IA llegó a su respuesta, la confianza se evapora. IA Verificable y Responsable cambia ese guion: cada predicción se envía con una prueba criptográfica de que fue producida por el modelo aprobado, en datos auténticos, en un entorno a prueba de manipulaciones.



Problemas Cotidianos que Puede Resolver

 	
Salud – Una IA de radiología dice "no hay tumor". La IA verificable permite a los médicos (y reguladores) verificar un recibo criptográfico que muestra el modelo, la versión y la imagen sin modificar utilizada.

 	
Educación – Las puntuaciones de exámenes generadas por un corrector de IA vienen con una prueba verificable de criterios de calificación justos, poniendo fin a las quejas de "caja negra".

 	
Integridad de Datos – Los proveedores envían métricas a una IA de adquisiciones; los compradores obtienen una prueba de que nadie cambió los números después del hecho.





Cómo NEAR lo Hace Funcionar
 	
SDK de ML Privado - El kit de herramientas de código abierto de NEAR ejecuta modelos dentro de CPUs Intel TDX y TEEs de NVIDIA, protegiendo los datos crudos de miradas curiosas.

 	
Pruebas On-Chain - Después de la inferencia, el enclave emite una certificación criptográfica. Esa prueba, y solo la prueba mínima, puede ser anclada en la cadena de bloques de NEAR para que cualquiera pueda auditar la integridad más tarde.

 	
Sistema de Cuenta NEAR - Cada acción (subir datos, llamar al modelo, publicar un resultado) está firmada por una cuenta NEAR legible por humanos como alice.near. Estas firmas, junto con los permisos de clave de acceso, crean un rastro de procedencia inmutable que vincula quién hizo qué a cada decisión de IA.





¿Por qué "Responsable" también?
Privacidad y responsabilidad son dos caras de la misma moneda. Al bloquear los datos en TEEs, los usuarios mantienen la propiedad. Al publicar pruebas en la cadena, la sociedad obtiene transparencia. Y al vincular acciones a cuentas NEAR, sabemos qué humano o servicio es responsable si algo sale mal.



La Conclusión
La IA Verificable y Responsable no te pide que "solo confíes en el algoritmo". Demuestra su trabajo, de forma privada, criptográfica e inmutable, gracias al SDK de ML Privado de NEAR y a la procedencia basada en cuentas. Esa es la base que necesitamos para una IA segura en medicina, aprendizaje y en cada decisión impulsada por datos que realmente importa.

### AI có thể được xác minh và đáng tin cậy, bằng cách sử dụng NEAR Protocol.

Trí tuệ nhân tạo hiện tại viết bài luận, dự đoán các bệnh và chấp thuận các khoản vay ngân hàng. Điều đó thật tuyệt vời—cho đến khi một mô hình bắt đầu mơ mộng hoặc ai đó chỉnh sửa dữ liệu để gian lận kết quả. Khi chúng ta không thể kiểm tra cách một AI đạt được câu trả lời của mình, sự tin tưởng biến mất. Trí tuệ nhân tạo có thể xác minh và có trách nhiệm thay đổi kịch bản đó: mỗi dự đoán đi kèm với bằng chứng mật mã học cho thấy nó được tạo ra bởi mô hình đã được phê duyệt, trên dữ liệu xác thực, trong môi trường không thể can thiệp.



Vấn đề Hàng Ngày Mà Nó Có Thể Giải Quyết

 	
Chăm sóc sức khỏe – Một trí tuệ nhân tạo về chẩn đoán hình ảnh nói "không có khối u." Trí tuệ nhân tạo có thể xác minh cho phép bác sĩ (và cơ quan quản lý) kiểm tra một biên nhận mật mã học cho thấy mô hình, phiên bản và hình ảnh quét không bị thay đổi.

 	
Giáo dục – Điểm thi được tạo ra bởi một trí tuệ nhân tạo đánh giá đi kèm với bằng chứng xác minh về tiêu chí đánh giá công bằng, kết thúc các phàn nàn về "hộp đen".

 	
Chất lượng Dữ liệu – Các nhà cung cấp gửi các chỉ số cho một trí tuệ nhân tạo về mua sắm; người mua nhận được bằng chứng cho thấy không ai đổi số sau sự kiện.





Làm Thế Nào NEAR Thực Hiện Nó
 	
SDK Machine Learning Riêng Tư - Bộ công cụ mã nguồn mở của NEAR chạy các mô hình bên trong CPU Intel TDX và NVIDIA TEEs, bảo vệ dữ liệu gốc khỏi ánh mắt tò mò.

 	
Chứng minh trên chuỗi - Sau khi suy luận, khu vực an toàn phát ra một chứng minh mật mã. Chứng minh đó - và chỉ chứng minh tối thiểu - có thể được gắn vào chuỗi khối của NEAR để bất kỳ ai cũng có thể kiểm tra tính toàn vẹn sau này.

 	
Hệ thống Tài khoản NEAR - Mỗi hành động (tải lên dữ liệu, gọi mô hình, xuất bản kết quả) được ký bởi một tài khoản NEAR có thể đọc được như alice.near. Những chữ ký này, cùng với quyền truy cập khóa, tạo ra một dấu vết không thể thay đổi liên kết ai đã làm gì với mỗi quyết định trí tuệ nhân tạo.





Tại sao cũng "Trách nhiệm"?
Sự riêng tư và trách nhiệm là hai mặt của cùng một đồng xu. Bằng cách khóa dữ liệu trong TEEs, người dùng giữ quyền sở hữu. Bằng cách xuất bằng chứng trên chuỗi, xã hội có được tính minh bạch. Và bằng cách liên kết hành động với tài khoản NEAR, chúng ta biết người hoặc dịch vụ nào chịu trách nhiệm nếu có điều gì không ổn.




Nhận điểm
Trí tuệ nhân tạo có thể xác minh và có trách nhiệm không yêu cầu bạn "chỉ tin vào thuật toán." Nó chứng minh công việc của mình - riêng tư, mật mã, và không thể thay đổi - nhờ vào SDK Machine Learning Riêng Tư của NEAR và dấu vết dựa trên tài khoản. Đó là nền tảng chúng ta cần cho trí tuệ nhân tạo an toàn trong y học, học tập, và mọi quyết định dựa trên dữ liệu thực sự quan trọng.

### NEAR Intents: Masa Depan Web3 adalah Intent-Driven

Pengantar
Lanskap Web3 berkembang dengan cepat, dengan NEAR Protocol berada di garis depan inovasi. Salah satu kemajuan revolusioner adalah NEAR Intents, dirancang untuk menyederhanakan interaksi blockchain dengan memungkinkan pengguna untuk menentukan tujuan daripada mendetailkan langkah-langkah transaksi kompleks. Dengan mengabstraksi kompleksitas ini, NEAR Intents sedang mendefinisikan kembali kegunaan blockchain dan membuat keuangan terdesentralisasi (DeFi) dapat diakses oleh semua orang.
Apa Itu NEAR Intents?
Sebuah intent di NEAR mewakili deklarasi tingkat tinggi dari hasil yang diinginkan. Daripada menjalankan setiap langkah transaksi secara manual, pengguna menentukan dengan jelas apa yang ingin mereka capai—seperti "menukar Token A dengan Token B dengan harga terbaik"—sementara sistem mengelola proses detail untuk memenuhi permintaan ini. Pendekatan ini membuat interaksi blockchain menjadi intuitif dan dapat diakses secara luas.
Bagaimana NEAR Intents Bekerja
NEAR Intents beroperasi melalui proses terstruktur dan terdesentralisasi yang melibatkan:

 	Penciptaan Intent: Pengguna atau agen AI mendefinisikan hasil yang diinginkan, menyiarkan intent mereka ke jaringan solver.
 	Kompetisi Solver: Layanan khusus di luar rantai (solver) menganalisis intent, bersaing untuk memenuhinya secara efisien dan biaya efektif. Solver ini memberikan solusi yang diusulkan sebagai penawaran untuk persetujuan pengguna.
 	Eksekusi Intent: Setelah solusi disetujui, solver yang dipilih menjalankan intent melalui kontrak cerdas NEAR Intents. Kontrak ini memastikan perubahan status yang benar, menyelesaikan dan melaporkan hasilnya secara aman kepada pengguna.

Model ini menyederhanakan interaksi blockchain sambil secara signifikan meningkatkan efisiensi operasional.
Fitur Utama NEAR Intents

 	Berorientasi pada Hasil: Pengguna fokus pada hasil yang diinginkan, meninggalkan detail eksekusi kepada sistem.
 	Lintas Rantai yang Lancar: Memungkinkan interaksi yang lancar di sejumlah jaringan blockchain tanpa jembatan kompleks.
 	Aman dan Tanpa Izin: Memberikan keamanan dan desentralisasi yang ditingkatkan, memungkinkan setiap pengembang untuk membangun dan meluncurkan produk keuangan tanpa batasan.
 	Integrasi AI: Mudah diintegrasikan dengan agen AI, meningkatkan proses pengambilan keputusan cerdas dan memungkinkan interaksi blockchain otomatis.

Blockchain yang Didukung dan Jenis Alamat
NEAR Intents memfasilitasi interaksi lintas rantai yang lancar dengan mendukung berbagai jaringan blockchain dan format alamat mereka masing-masing. Berikut adalah daftar terorganisir yang mengkategorikan rantai yang didukung ini:

Rantai yang Kompatibel dengan EVM
Rantai-rantai ini menggunakan arsitektur Ethereum Virtual Machine (EVM), memungkinkan kompatibilitas dengan alat dan aplikasi berbasis Ethereum.
 	
Ethereum: Alamat heksadesimal 42 karakter yang diawali dengan 0x.

 	
Gnosis: Alamat yang kompatibel dengan EVM.

 	
Bera: Alamat yang kompatibel dengan EVM.

 	
Base: Alamat yang kompatibel dengan EVM.

 	
Arbitrum: Alamat yang kompatibel dengan EVM.

 	
Aurora: Alamat yang kompatibel dengan EVM.DeepNewz


Rantai Berbasis UTXO
Rantai-rantai ini mengikuti model Unspent Transaction Output (UTXO), yang umum digunakan dalam kriptokurensi seperti Bitcoin.
 	
Bitcoin: Mendukung beberapa format alamat termasuk Legacy (1), P2SH (3), Bech32 (bc1), dan Taproot (bc1p).

 	
Dogecoin: Mendukung alamat P2PKH/Legacy yang dimulai dengan D.

 	
ZCash: Mendukung alamat Transparent yang dimulai dengan t1 atau t3.reflexivityresearch.com+5Messari+5GitHub+5


Rantai Lain yang Didukung
Rantai-rantai ini memiliki arsitektur dan format alamat yang unik:
 	
NEAR: Mendukung kedua alamat Bernama (misalnya, example.near) dan alamat Implisit (hexadesimal 64 karakter).

 	
Solana: Menggunakan kunci publik Ed25519 yang dienkripsi Base58.

 	
Tron: Memanfaatkan alamat yang dienkripsi Base58Check yang dimulai dengan T.

 	
XRP: Mendukung alamat Klasik yang dimulai dengan r.


Catatan: Meskipun NEAR Intents mendukung berbagai rantai, beberapa jenis alamat, terutama pada rantai seperti ZCash, Dogecoin, dan XRP, mungkin memiliki dukungan parsial dengan beberapa batasan operasional.
Dukungan yang luas ini memungkinkan NEAR Intents untuk menawarkan fungsionalitas lintas-rantai yang kuat, menyederhanakan pengalaman pengguna di berbagai ekosistem blockchain.

Aplikasi Dunia Nyata
NEAR Intents membuka banyak kasus penggunaan praktis di luar DeFi tradisional:

 	Infrastruktur Keuangan Terdesentralisasi: Memungkinkan perdagangan lintas-rantai dan instrumen keuangan yang beragam.
 	Abstraksi Multirantai: Menyederhanakan integrasi di berbagai rantai, mengurangi kompleksitas operasional dan biaya.
 	Arsitektur Berbasis Niat: Menggantikan model pembuat pasar otomatis (AMM) tradisional, memberikan akses likuiditas yang lebih baik dan penetapan harga yang kompetitif.
 	AccountFi: Memungkinkan pengguna untuk melakukan perdagangan, meminjam, dan mengelola berbagai jenis aset—termasuk NFT, token yang dapat dipindahtangankan, dan aset non-transferable seperti Soulbound Tokens (SBTs). Misalnya, mengelola keanggotaan berbasis NFT atau portofolio aset lintas-rantai yang terdiversifikasi.

Peran Kecerdasan Buatan dalam NEAR Intents
Agen kecerdasan buatan secara signifikan meningkatkan NEAR Intents dengan secara otomatis mengoptimalkan transaksi, menyeimbangkan portofolio aset lintas-rantai, dan secara efisien menavigasi lingkungan multi-rantai. Kemampuan ini membuka pintu untuk aplikasi inovatif seperti perdagangan yang didorong oleh kecerdasan buatan, manajemen likuiditas lintas-rantai otomatis, dan pasar gig terdesentralisasi.Mulai dengan NEAR Intents
Pengembang dan pengguna yang ingin menjelajahi NEAR Intents dapat menggunakan sumber daya komprehensif berikut:

 	Dokumentasi Resmi: Penjelasan detail, tutorial, dan wawasan arsitektural (Dokumentasi NEAR Intents).
 	Repositori GitHub: Alat, kontrak pintar, dan contoh untuk mengintegrasikan dan membangun (GitHub NEAR Intents).
 	Contoh Memulai Cepat: Implementasi agen Python sederhana tersedia di sini.

Kesimpulan
NEAR Intents sedang merevolusi interaksi blockchain melalui kesederhanaan, desain berbasis pengguna, dan integrasi kecerdasan buatan yang canggih. Dengan mengabstraksi kompleksitas dan meningkatkan efisiensi operasional, NEAR Intents sedang membuka jalan bagi ekosistem Web3 yang dapat diakses dan cerdas.

Mulailah menjelajahi masa depan interaksi blockchain yang disederhanakan hari ini—kunjungi Dokumentasi NEAR Intents untuk mempelajari lebih lanjut.

### AI Yang Mengendalikan Uang Anda (Dan Mengapa Itu Sebenarnya Luar Biasa)

Silakan ikuti langkah-langkah di bawah ini untuk mendapatkan BRR dan stNEAR Anda:

1. Masuk ke dompet NEAR Anda.
2. Pilih NEAR dari menu dropdown di bagian atas.
3. Pilih "Bridges" dari menu di sebelah kiri.
4. Pilih "NEAR Bridge" dari daftar Bridges.
5. Masukkan jumlah NEAR yang ingin Anda konversi ke BRR atau stNEAR.
6. Ikuti instruksi selanjutnya untuk menyelesaikan konversi.

Apa jadinya jika uang Anda bisa berpikir sendiri dan membuat keputusan cerdas saat Anda tidur?

Masalah yang Tidak Anda Ketahui
Sarah memiliki uang di 5 aplikasi berbeda: Venmo, Cash App, tabungan banknya, Robinhood, dan beberapa Bitcoin di Coinbase. Ketika temannya Jake perlu membagi tagihan makan malam $200 di Tokyo, dia menghadapi mimpi buruk:


 	Venmo-nya tidak berfungsi secara internasional
 	Banknya mengenakan biaya $25 untuk transfer kawat
 	Mengonversi Bitcoin membutuhkan 3 hari
 	Dia harus memeriksa 5 aplikasi secara manual untuk melihat di mana dia memiliki uang

Sementara itu, uangnya hanya duduk di sana tanpa melakukan apa-apa daripada mendapatkan bunga, dan dia melewatkan peluang investasi karena dia sedang bekerja ketika pasar bergerak.
Apa jadinya jika satu asisten pintar bisa mengelola semua ini secara otomatis?

Masuk Shade Agents: Manajer Uang AI Anda
Shade Agents dari NEAR Protocol seperti memiliki penasihat keuangan, akuntan, dan asisten pribadi digabungkan menjadi satu AI yang:


 	Mengendalikan akun di berbagai platform (bank, kripto, aplikasi)
 	Mengambil keputusan cerdas tentang uang Anda 24/7
 	Menggerakkan dana secara otomatis untuk mendapatkan penawaran terbaik untuk Anda
 	Tidak benar-benar mencuri uang Anda (kami akan menjelaskan trik keamanan cerdasnya)

Bayangkan itu sebagai Siri untuk keuangan Anda, tetapi yang benar-benar dapat mengambil tindakan, bukan hanya memberi tahu cuaca.

"Tunggu, Bagaimana Saya Tahu Itu Tidak Akan Merampok Saya?"
Pertanyaan bagus. Inilah trik keamanan cerdas yang membuat ini menjadi kenyataan:
Masalah dengan Aplikasi Uang AI Saat Ini:


 	Entah AI sebenarnya tidak dapat mengendalikan uang Anda (tidak berguna)
 	Atau beberapa perusahaan menyimpan kata sandi Anda (mereka bisa mencuri segalanya)

Solusi Shade Agent: Bayangkan uang Anda berada di brankas yang memerlukan DUA kunci untuk dibuka:


 	Kunci 1: Dipegang oleh AI yang berjalan di perangkat keras ultra-aman (seperti brankas bank)
 	Kunci 2: Dikendalikan oleh kode yang dapat dilihat dan diverifikasi oleh semua orang

AI hanya dapat mengakses uang Anda jika:


 	Menjalankan kode yang persis seperti yang disepakati oleh semua orang
 	Perangkat keras aman mengonfirmasi bahwa itu tidak diretas
 	Transaksi mengikuti aturan yang Anda setujui sebelumnya

Jika AI mencoba melakukan sesuatu yang mencurigakan, brankas secara otomatis terkunci. Jika perangkat keras aman rusak, Anda dapat memulai instansi AI baru dengan akses yang sama (uang Anda tidak hilang).

Contoh Nyata yang Benar-benar Penting
1. Pembagian Tagihan Otomatis Antar Negara
Agen AI Anda secara otomatis:


 	Membagi tagihan restoran dengan teman secara internasional
 	Mencari cara termurah untuk mengirim uang (mungkin melalui kripto, mungkin transfer tradisional)
 	Menangani konversi mata uang dengan tingkat terbaik
 	Mengirim konfirmasi pembayaran kepada semua orang

2. Tabungan Cerdas yang Benar-benar Bekerja
Saat Anda tidur, AI Anda:


 	Memindahkan uang tunai dari cek ke tabungan berbunga tinggi
 	Menemukan suku bunga yang lebih baik di berbagai bank
 	Menginvestasikan jumlah kecil saat kondisi pasar baik
 	Tidak pernah menyentuh uang yang Anda tandai sebagai "hanya untuk keadaan darurat"

3. Pedagang Twitter
Tweet: "Saya bertaruh $50 bahwa akan hujan di NYC besok" Agen AI Anda:


 	Membuat pasar prediksi secara otomatis
 	Menahan uang semua orang dengan aman
 	Memeriksa data cuaca besok
 	Membayar kemenangan secara instan

Tidak perlu mengunduh aplikasi, tidak perlu membuat akun, tidak ada antarmuka yang rumit.

Kekhawatiran "Tapi Bagaimana Jika..."
"Bagaimana jika AI membuat keputusan buruk?" Anda menetapkan aturan ketat: "Jangan pernah berinvestasi lebih dari $100 per hari" atau "Hanya memindahkan uang antara akun yang saya setujui." AI tidak dapat melanggar aturan ini, bahkan jika ingin melakukannya.
"Bagaimana jika perusahaan di balik ini bangkrut?" Berbeda dengan aplikasi tradisional, tidak ada satu perusahaan yang mengendalikan uang Anda. Sistem ini berjalan di jaringan terdesentralisasi, jadi bahkan jika NEAR Protocol menghilang besok, agen AI Anda akan tetap berfungsi.
"Bagaimana jika ada bug dalam kode?" Semua kode bersifat publik dan diverifikasi oleh ahli keamanan. Selain itu, Anda dapat menetapkan batasan konservatif saat teknologi tersebut matang.
"Berapa biaya ini?" Operasinya hanya beberapa sen daripada dolar karena AI tidak membayar biaya blockchain tradisional untuk berpikir—hanya untuk transaksi akhir.

Mengapa Ini Mengubah Segalanya
Untuk pertama kalinya, kita bisa memiliki perangkat lunak yang:


 	Berpikir (menggunakan AI nyata, bukan hanya aturan sederhana)
 	Bertindak (benar-benar mengendalikan uang dan akun)
 	Tetap dapat dipercaya (tidak dapat dikorupsi oleh entitas tunggal apa pun)

Ini memecahkan masalah yang telah ada sejak internet dimulai: Bagaimana memberikan kekuatan yang cukup kepada perangkat lunak untuk benar-benar membantu tanpa memberikannya kekuatan yang cukup untuk merugikan Anda?

Realitas Saat Ini
Apa yang tersedia sekarang: Pengembang sedang membangun Shade Agents pertama. Versi awal fokus pada tugas-tugas sederhana seperti perdagangan otomatis dan pergerakan uang lintas rantai.
Jadwal waktu: Harap aplikasi konsumen sederhana dalam 6-12 bulan, dengan kemampuan AI yang lebih canggih diluncurkan dalam 2-3 tahun mendatang.
Biaya penggunaan: Masih ditentukan, tetapi kemungkinan mirip dengan biaya langganan aplikasi saat ini ($5-20/bulan) ditambah biaya transaksi kecil.

Langkah Selanjutnya yang Sederhana
Jika ini terdengar menarik, inilah yang harus dilakukan:
Bergabunglah dengan daftar tunggu untuk aplikasi Shade Agent awal dengan mengikuti @NEARProtocol di Twitter. Mereka mengumumkan aplikasi baru dan kesempatan pengujian di sana terlebih dahulu.
Itu saja. Tidak perlu belajar pemrograman blockchain atau memahami kriptografi. Sama seperti Anda tidak perlu memahami protokol HTTP untuk menggunakan internet.

Inti Masalah
Shade Agents mewakili pertama kalinya AI dapat benar-benar membantu dengan uang Anda tanpa memerlukan kepercayaan buta. Alih-alih memilih antara "kuat namun berisiko" atau "aman namun tidak berguna," kita akhirnya mendapatkan keduanya.
Uang Anda bisa bekerja sekeras Anda, membuat keputusan cerdas sepanjang waktu saat Anda fokus pada segala hal lain dalam hidup.
Pertanyaannya bukan apakah AI akan mengelola keuangan kita—tetapi apakah AI itu akan dikendalikan oleh raksasa teknologi atau bekerja langsung untuk Anda.



Ingin lebih mendalami detail teknisnya? Periksa dokumentasi lengkap NEAR Protocol. Tapi sejujurnya, Anda tidak perlu memahami mesin untuk mengemudikan mobil.


 ->

### Искусственный интеллект, который контролирует ваши деньги (и почему это действительно удивительно)

NEAR Protocol Overview
NEAR Protocol is a decentralized application platform designed to make it easier for developers to build and deploy applications on the blockchain. NEAR uses a unique sharding mechanism called Nightshade to improve scalability and performance.

NEAR Wallet
The NEAR Wallet is a secure and user-friendly tool that allows users to interact with NEAR Protocol. Users can create accounts, send and receive tokens, and access decentralized applications using the NEAR Wallet.

NEAR Token
The NEAR Token is the native cryptocurrency of the NEAR Protocol. It is used for staking, transaction fees, and participating in governance decisions on the network.

Что, если ваша денежная сумма могла бы думать самостоятельно и принимать умные решения, пока вы спите?

Проблема, о которой вы не знали
У Сары есть деньги в 5 различных приложениях: Venmo, Cash App, ее банковском сбережении, Robinhood и некоторые биткоины на Coinbase. Когда ее друг Джейку нужно разделить счет за ужин на $200 в Токио, она сталкивается с кошмаром:


 	Ее Venmo не работает за границей
 	Ее банк берет $25 за банковские переводы
 	Преобразование биткоина занимает 3 дня
 	Ей приходится вручную проверять 5 приложений, чтобы узнать, где у нее вообще есть деньги

Тем временем ее деньги просто лежат там, ничего не делая, вместо того чтобы приносить проценты, и она упускает возможности для инвестирования, потому что она на работе, когда рынок движется.
Что, если один умный помощник мог бы управлять всем этим автоматически?

Вход Shade Agents: ваш менеджер денег на основе ИИ
Агенты Shade Protocol NEAR похожи на финансового советника, бухгалтера и личного помощника, объединенных в одного ИИ, который:


 	Управляет счетами на разных платформах (банки, криптовалюты, приложения)
 	Принимает умные решения о ваших деньгах 24/7
 	Автоматически перемещает средства, чтобы получить лучшие сделки
 	Фактически никогда не крадет ваши деньги (мы объясним хитрый трюк безопасности)

Представьте себе это как Siri для ваших финансов, но такой, который действительно может действовать, а не просто сообщать вам о погоде.

"Подождите, как я знаю, что он не обобьет меня?"
Отличный вопрос. Вот хитрый трюк безопасности, который делает это возможным:
Проблема с текущими приложениями для управления деньгами на основе ИИ:


 	Либо ИИ фактически не может управлять вашими деньгами (бесполезно)
 	Либо какая-то компания хранит ваши пароли (они могут украсть все)

Решение Shade Agent: Представьте, что ваши деньги находятся в сейфе, который требует ДВУХ ключей для открытия:


 	Ключ 1: Удерживается ИИ, работающим на ультра-безопасном оборудовании (как сейф банка)
 	Ключ 2: Управляется кодом, который все могут видеть и проверить

ИИ может получить доступ к вашим деньгам только если:


 	Он запускает точно тот же код, на который все согласились
 	Безопасное оборудование подтверждает, что его не взломали
 	Транзакция соответствует правилам, которые вы предварительно утвердили

Если ИИ пытается сделать что-то подозрительное, сейф автоматически блокируется. Если безопасное оборудование сломается, вы можете запустить новый экземпляр ИИ с тем же доступом (ваши деньги не потеряны).

Реальные примеры, которые действительно имеют значение
1. Автоматическое разделение счетов за границами
Ваш ИИ-агент автоматически:


 	Разделяет счета в ресторанах с друзьями за границей
 	Находит самый дешевый способ отправить деньги (возможно, через криптовалюту, возможно, традиционный перевод)
 	Обрабатывает конвертацию валют по лучшим курсам
 	Отправляет подтверждения платежей всем

2. Умное сбережение, которое действительно работает
Пока вы спите, ваш ИИ:


 	Перемещает лишние деньги с текущего счета на счет с высокими процентами
 	Находит лучшие процентные ставки в разных банках
 	Инвестирует небольшие суммы, когда рыночные условия хороши
 	Никогда не трогает деньги, которые вы отметили как "только для чрезвычайных ситуаций"

3. Твиттер-трейдер
Твит: "Я ставлю $50, что завтра будет дождь в Нью-Йорке" Ваш ИИ-агент:


 	Автоматически создает рынок прогнозов
 	Безопасно хранит деньги всех
 	Проверяет данные о погоде завтра
 	Моментально выплачивает выигрыши

Нет необходимости загружать приложения, создавать учетные записи, сложные интерфейсы.

"Но что, если..." Опасения
"Что, если ИИ примет ужасное решение?" Вы устанавливаете строгие правила: "Никогда не инвестируйте более $100 в день" или "Перемещайте деньги только между моими утвержденными счетами." ИИ не может нарушить эти правила, даже если захочет.
"Что, если компания, стоящая за этим, обанкротится?" В отличие от традиционных приложений, ни одна компания не контролирует ваши деньги. Система работает на децентрализованной сети, поэтому даже если протокол NEAR исчезнет завтра, ваш ИИ-агент будет продолжать работать.
"Что, если в коде есть ошибка?" Весь код общедоступен и проверен экспертами по безопасности. Кроме того, вы можете установить консервативные ограничения, пока технология не созреет.
"Сколько это стоит?" Операции стоят копейки вместо долларов, потому что ИИ не платит традиционные комиссии блокчейна за размышления — только за конечные транзакции.

Почему это меняет все
Впервые у нас есть программное обеспечение, которое:


 	Думает (использует настоящий ИИ, а не простые правила)
 	Действует (фактически управляет деньгами и счетами)
 	Остается надежным (не может быть скоромпрометирован ни одной отдельной сущностью)

Это решает проблемы, которые существуют с момента появления интернета: Как дать программному обеспечению достаточно мощи, чтобы быть действительно полезным, не давая ему достаточно мощи, чтобы причинить вам вред?

Текущая реальность
Что доступно сейчас: Разработчики создают первых Shade Agents. Ранние версии сосредотачиваются на простых задачах, таких как автоматизированная торговля и перемещение денег между цепями.
Временной график: Ожидайте простые потребительские приложения в течение 6-12 месяцев, с более сложными возможностями ИИ, которые будут внедрены в течение следующих 2-3 лет.
Стоимость использования: Пока еще не определена, но вероятно, будет аналогична текущим платным подпискам на приложения ($5-20 в месяц), плюс крошечные транзакционные издержки.

Один простой следующий шаг
Если это звучит интер

### NEAR Intenções: O Futuro do Web3 é Orientado por Intenções

Introdução
O cenário Web3 está evoluindo rapidamente, com o Protocolo NEAR na vanguarda da inovação. Um avanço inovador é NEAR Intents, projetado para simplificar as interações com blockchain, permitindo que os usuários especifiquem objetivos em vez de detalhar etapas complexas de transação. Ao abstrair essas complexidades, NEAR Intents está redefinindo a usabilidade de blockchain e tornando as finanças descentralizadas (DeFi) acessíveis a todos.
O Que São NEAR Intents?
Um intento na NEAR representa uma declaração de alto nível de um resultado desejado. Em vez de executar manualmente cada etapa da transação, os usuários especificam claramente o que desejam alcançar - como "trocar Token A por Token B pelo melhor preço" - enquanto o sistema gerencia os processos detalhados para cumprir essa solicitação. Esse método torna as interações com blockchain intuitivas e amplamente acessíveis.
Como Funcionam os NEAR Intents
Os NEAR Intents operam por meio de um processo estruturado e descentralizado envolvendo:

 	Criação de Intento: Usuários ou agentes de IA definem um resultado desejado, transmitindo seu intento a uma rede de solucionadores.
 	Competição de Solucionadores: Serviços especializados off-chain (solucionadores) analisam o intento, competindo para cumpri-lo de forma eficiente e econômica. Esses solucionadores fornecem soluções propostas como cotações para aprovação do usuário.
 	Execução de Intento: Uma vez que uma solução é aprovada, o solucionador escolhido executa o intento por meio do contrato inteligente NEAR Intents. Este contrato garante mudanças de estado corretas, liquidando e relatando o resultado de forma segura ao usuário.

Esse modelo simplifica as interações com blockchain, melhorando significativamente a eficiência operacional.
Recursos Principais dos NEAR Intents

 	Baseado em Resultados: Os usuários focam no resultado desejado, deixando os detalhes de execução para o sistema.
 	Interação sem Costura entre Cadeias: Permite interações suaves entre várias redes de blockchain sem pontes complexas.
 	Seguro e Sem Permissão: Fornece segurança aprimorada e descentralização, permitindo que qualquer desenvolvedor construa e lance produtos financeiros sem restrições.
 	Integração de IA: Integra facilmente com agentes de IA, aprimorando processos de tomada de decisão inteligentes e possibilitando interações automatizadas com blockchain.

Cadeias de Blocos e Tipos de Endereço Suportados
NEAR Intents facilita interações sem costura entre cadeias de blocos, suportando uma ampla gama de blocos e seus formatos de endereço respectivos. Abaixo está uma lista organizada categorizando essas cadeias suportadas:

Cadeias Compatíveis com EVM
Essas cadeias utilizam a arquitetura Ethereum Virtual Machine (EVM), permitindo compatibilidade com ferramentas e aplicativos baseados em Ethereum.
 	
Ethereum: Endereços hexadecimais de 42 caracteres padronizados com prefixo 0x.

 	
Gnosis: Endereços compatíveis com EVM.

 	
Bera: Endereços compatíveis com EVM.

 	
Base: Endereços compatíveis com EVM.

 	
Arbitrum: Endereços compatíveis com EVM.

 	
Aurora: Endereços compatíveis com EVM.DeepNewz


Cadeias Baseadas em UTXO
Essas cadeias seguem o modelo de Saída de Transação Não Gasta (UTXO), comumente usado em criptomoedas como o Bitcoin.
 	
Bitcoin: Suporta vários formatos de endereço, incluindo Legacy (1), P2SH (3), Bech32 (bc1), e Taproot (bc1p).

 	
Dogecoin: Suporta endereços P2PKH/Legacy que começam com D.

 	
ZCash: Suporta endereços Transparentes que começam com t1 ou t3.reflexivityresearch.com+5Messari+5GitHub+5


Outras Cadeias Suportadas
Essas cadeias têm arquiteturas e formatos de endereço únicos:
 	
NEAR: Suporta tanto endereços Nomeados (por exemplo, example.near) quanto endereços Implícitos (hexadecimais de 64 caracteres).

 	
Solana: Utiliza chaves públicas Ed25519 codificadas em Base58.

 	
Tron: Utiliza endereços codificados em Base58Check começando com T.

 	
XRP: Suporta endereços Clássicos começando com r.


Nota: Embora NEAR Intents suporte uma ampla gama de blockchains, alguns tipos de endereços, especialmente em blockchains como ZCash, Dogecoin e XRP, podem ter suporte parcial com certas limitações operacionais.
Esse amplo suporte permite que NEAR Intents ofereça funcionalidades robustas de interconexão entre blockchains, simplificando as experiências dos usuários em diversos ecossistemas de blockchain.

Aplicações do Mundo Real
NEAR Intents desbloqueiam inúmeros casos de uso práticos além do DeFi tradicional:

 	Infraestrutura de Finanças Descentralizadas: Possibilita a negociação entre blockchains e diversos instrumentos financeiros.
 	Abstração Multichain: Simplifica a integração entre múltiplos blockchains, reduzindo a complexidade operacional e os custos.
 	Arquitetura Baseada em Intenções: Substitui os modelos tradicionais de criador de mercado automatizado (AMM), proporcionando acesso a liquidez aprimorada e preços competitivos.
 	AccountFi: Permite que os usuários negociem, emprestem e gerenciem diversos tipos de ativos—incluindo NFTs, tokens fungíveis e ativos não transferíveis como Tokens Soulbound (SBTs). Por exemplo, gerenciando associações baseadas em NFTs ou portfólios de ativos diversificados entre blockchains.

O Papel da IA em NEAR Intents
Agentes de IA melhoram significativamente NEAR Intents ao otimizarem transações de forma autônoma, equilibrarem portfólios de ativos entre blockchains e navegarem de forma eficiente em ambientes multichain. Essas capacidades abrem portas para aplicações inovadoras, como comércio impulsionado por IA, gerenciamento automatizado de liquidez entre blockchains e mercados de trabalho gig descentralizados.Começando com NEAR Intents
Desenvolvedores e usuários ansiosos para mergulhar em NEAR Intents podem usar esses recursos abrangentes:

	Documentação Oficial: Explicações detalhadas, tutoriais e insights arquiteturais (Documentação NEAR Intents).
	Repositório GitHub: Ferramentas, contratos inteligentes e exemplos para integrar e construir (GitHub NEAR Intents).
	Exemplo de Início Rápido: Uma implementação simples de agente Python disponível aqui.

Conclusão
NEAR Intents está revolucionando as interações em blockchain através da simplicidade, design centrado no usuário e integração avançada de IA. Ao abstrair a complexidade e aprimorar a eficiência operacional, NEAR Intents estão abrindo caminho para um ecossistema Web3 acessível e inteligente.

Comece a explorar o futuro de interações simplificadas em blockchain hoje - visite a Documentação NEAR Intents para saber mais.

### お金を管理するAI（それが実際に素晴らしい理由）

NEAR Protocol is a decentralized application platform that is secure, scalable, and developer-friendly. It allows developers to build applications on the blockchain using smart contracts. NEAR Protocol uses sharding to improve scalability and reduce transaction costs. Developers can use Rust and AssemblyScript to write smart contracts on NEAR Protocol. The native token of NEAR Protocol is NEAR, which is used for staking and gas fees. Users can also earn rewards by staking NEAR tokens.

### NEAR 의도: Web3의 미래는 의도 중심입니다

소개
Web3 랜드스케이프는 NEAR Protocol이 혁신의 선두에 서 있으며 빠르게 진화하고 있습니다. 한 가지 혁신적인 발전은 NEAR Intents로, 사용자가 복잡한 트랜잭션 단계를 상세히 설명하는 대신 목표를 지정하여 블록체인 상호작용을 간단하게 만드는 것을 목표로 합니다. 이러한 복잡성을 추상화함으로써 NEAR Intents는 블록체인의 사용성을 재정의하고 탈중앙화 금융(DeFi)를 모두에게 접근 가능하게 만들고 있습니다.
NEAR Intents란 무엇인가요?
NEAR에서의 intent는 원하는 결과의 고수준 선언을 나타냅니다. 사용자는 각 트랜잭션 단계를 수동으로 실행하는 대신 "최상의 가격으로 토큰 A를 토큰 B로 교환"과 같이 명확하게 원하는 것을 명시하고, 시스템이 이 요청을 충족시키기 위한 세부 프로세스를 관리합니다. 이 접근 방식은 블록체인 상호작용을 직관적이고 널리 접근 가능하게 만듭니다.
NEAR Intents의 작동 방식
NEAR Intents는 다음과 같은 구조화된 분산 프로세스를 통해 작동합니다:

 	Intent Creation: 사용자 또는 AI 에이전트는 원하는 결과를 정의하고, 이를 해결자 네트워크에 방송합니다.
 	Solver Competition: 특수화된 오프체인 서비스(해결자)가 intent를 분석하고, 효율적이고 비용 효율적으로 이를 충족하기 위해 경쟁합니다. 이러한 해결자는 사용자 승인을 위한 제안된 솔루션을 제공합니다.
 	Intent Execution: 솔루션이 승인되면 선택된 해결자가 NEAR Intents 스마트 계약을 통해 intent를 실행합니다. 이 계약은 올바른 상태 변경을 보장하고, 결과를 안전하게 사용자에게 보고하고 결제합니다.

이 모델은 블록체인 상호작용을 간단하게 만들면서 운영 효율을 크게 향상시킵니다.
NEAR Intents의 주요 기능

 	결과 중심: 사용자는 원하는 결과에 집중하고, 실행 세부 사항을 시스템에 맡깁니다.
 	원활한 크로스체인: 복잡한 브릿지 없이 여러 블록체인 네트워크 간의 원활한 상호작용을 가능하게 합니다.
 	안전하고 허가 없음: 향상된 보안과 탈중앙화를 제공하며, 어떤 개발자도 제한 없이 금융 제품을 구축하고 출시할 수 있습니다.
 	AI 통합: AI 에이전트와 쉽게 통합되어 지능적인 의사 결정 프로세스를 향상시키고 자동화된 블록체인 상호작용을 가능하게 합니다.

지원되는 블록체인 및 주소 유형
NEAR Intents는 다양한 블록체인과 해당 주소 형식을 지원하여 원활한 크로스체인 상호작용을 용이하게 합니다. 아래는 이러한 지원되는 체인을 분류한 정리된 목록입니다:

EVM 호환 체인
이러한 체인은 이더리움 가상 머신(EVM) 아키텍처를 활용하여 이더리움 기반 도구 및 응용프로그램과 호환됩니다.
 	
이더리움: 표준 0x 접두사가 붙은 42자리 16진수 주소.

 	
Gnosis: EVM 호환 주소.

 	
Bera: EVM 호환 주소.

 	
Base: EVM 호환 주소.

 	
Arbitrum: EVM 호환 주소.

 	
Aurora: EVM 호환 주소.DeepNewz


UTXO 기반 체인
이러한 체인은 비트코인과 같은 암호화폐에서 일반적으로 사용되는 미사용 트랜잭션 출력 (UTXO) 모델을 따릅니다.
 	
Bitcoin: 레거시(1), P2SH(3), Bech32(bc1), Taproot(bc1p)을 포함한 여러 주소 형식을 지원합니다.

 	
Dogecoin: D로 시작하는 P2PKH/Legacy 주소를 지원합니다.

 	
ZCash: t1 또는 t3으로 시작하는 투명 주소를 지원합니다.reflexivityresearch.com+5Messari+5GitHub+5


기타 지원되는 체인
이러한 체인은 고유한 아키텍처와 주소 형식을 가지고 있습니다.
 	
NEAR: Named 주소 (예: example.near) 및 암시적 주소 (64자리 16진수)를 모두 지원합니다.

 	
Solana: Base58로 인코딩된 Ed25519 공개 키를 사용합니다.

 	
Tron: T로 시작하는 Base58Check로 인코딩된 주소를 활용합니다.

 	
XRP: r로 시작하는 Classic 주소를 지원합니다.


참고: NEAR Intents는 다양한 체인을 지원하지만 ZCash, Dogecoin, XRP와 같은 일부 주소 유형은 특정 운영 제한으로 일부 지원될 수 있습니다.
이러한 광범위한 지원으로 NEAR Intents는 다양한 블록체인 생태계에서 사용자 경험을 간소화하는 강력한 크로스체인 기능을 제공합니다.

실제 응용 프로그램
NEAR Intents는 전통적인 DeFi를 넘어 다양한 실용적인 사용 사례를 제공합니다:

 	탈중앙화 금융 인프라: 크로스체인 거래 및 다양한 금융 상품을 가능하게 합니다.
 	멀티체인 추상화: 여러 체인 간 통합을 간소화하여 운영 복잡성과 비용을 줄입니다.
 	의도 기반 아키텍처: 전통적인 자동화된 시장 메이커 (AMM) 모델을 대체하여 개선된 유동성 접근 및 경쟁 가격을 제공합니다.
 	AccountFi: 사용자가 NFT, 가치토큰, Soulbound Tokens (SBTs)와 같은 다양한 자산 유형을 거래, 대출 및 관리할 수 있습니다. 예를 들어, NFT 기반 멤버십 또는 다양한 크로스체인 자산 포트폴리오 관리.

NEAR Intents에서 AI의 역할
AI 에이전트는 거래를 자동으로 최적화하고 크로스체인 자산 포트폴리오를 균형있게 조정하며 다중체인 환경을 효율적으로 탐색하여 NEAR Intents를 크게 향상시킵니다. 이러한 능력은 AI 기반 상거래, 자동화된 크로스체인 유동성 관리, 탈중앙화된 기가 시장과 같은 혁신적인 응용 프로그램으로 이어집니다.NEAR 인텐트로 시작하기
NEAR 인텐트에 뛰어들고 싶은 개발자와 사용자들은 다음 포괄적인 자료를 활용할 수 있습니다:

 	공식 문서: 자세한 설명, 튜토리얼 및 아키텍처 통찰 (NEAR 인텐트 문서).
 	GitHub 저장소: 통합 및 빌드를 위한 도구, 스마트 계약 및 예제 (NEAR 인텐트 GitHub).
 	빠른 시작 예제: 여기에서 사용 가능한 간단한 Python 에이전트 구현 (여기).

결론
NEAR 인텐트는 간소화, 사용자 중심 설계 및 고급 AI 통합을 통해 블록체인 상호작용을 혁신하고 있습니다. 복잡성을 추상화하고 운영 효율성을 향상시킴으로써, NEAR 인텐트는 접근 가능하고 지능적인 Web3 생태계를 열어가고 있습니다.

간소화된 블록체인 상호작용의 미래를 탐색하기 시작하세요—더 많은 정보를 알아보려면 NEAR 인텐트 문서를 방문하세요.

### IA Que Controla Seu Dinheiro (E Por Que Isso é Realmente Incrível)

Para interagir com contratos inteligentes na NEAR Protocol, você pode usar a biblioteca NEAR API JS. Esta biblioteca permite que você se conecte a um nó NEAR, envie transações assinadas e interaja com contratos inteligentes. Você também pode usar a NEAR CLI para interagir com a NEAR Protocol a partir da linha de comando.

E se o seu dinheiro pudesse pensar por si mesmo e tomar decisões inteligentes enquanto você dorme?

O Problema que Você Não Sabia que Tinha
Sarah tem dinheiro em 5 aplicativos diferentes: Venmo, Cash App, sua poupança bancária, Robinhood e alguns Bitcoins na Coinbase. Quando seu amigo Jake precisa dividir uma conta de jantar de $200 em Tóquio, ela enfrenta um pesadelo:


 	Seu Venmo não funciona internacionalmente
 	Seu banco cobra $25 por transferências bancárias
 	Converter Bitcoin leva 3 dias
 	Ela tem que verificar manualmente 5 aplicativos para ver onde ela tem dinheiro

Enquanto isso, seu dinheiro apenas fica lá sem fazer nada, em vez de render juros, e ela perde oportunidades de investimento porque está no trabalho quando o mercado se movimenta.
E se um assistente inteligente pudesse gerenciar tudo isso automaticamente?

Conheça os Agentes Shade: Seu Gerente de Dinheiro de IA
Os Agentes Shade do NEAR Protocol são como ter um consultor financeiro, contador e assistente pessoal em um único IA que:


 	Controla contas em diferentes plataformas (bancos, criptomoedas, aplicativos)
 	Toma decisões inteligentes sobre seu dinheiro 24/7
 	Move fundos automaticamente para obter as melhores ofertas
 	Nunca realmente rouba seu dinheiro (explicaremos o truque de segurança inteligente)

Pense nele como a Siri para suas finanças, mas um que pode realmente agir, não apenas dizer o clima.

"Espera, Como Eu Sei que Não Vai me Roubar?"
Ótima pergunta. Aqui está o truque de segurança inteligente que torna isso possível:
O Problema com os Atuais Aplicativos de Dinheiro de IA:


 	Ou o IA não pode realmente controlar seu dinheiro (inútil)
 	Ou alguma empresa detém suas senhas (eles poderiam roubar tudo)

A Solução do Agente Shade: Imagine que seu dinheiro está em um cofre que requer DUAS chaves para abrir:


 	Chave 1: Mantida pelo IA em hardware ultra-seguro (como um cofre de banco)
 	Chave 2: Controlada por um código que todos podem ver e verificar

O IA só pode acessar seu dinheiro se:


 	Estiver executando o código exato com o qual todos concordaram
 	O hardware seguro confirmar que não foi hackeado
 	A transação seguir regras que você pré-aprovou

Se o IA tentar fazer algo suspeito, o cofre se fecha automaticamente. Se o hardware seguro falhar, você pode iniciar uma nova instância do IA com o mesmo acesso (seu dinheiro não está perdido).

Exemplos Reais que Realmente Importam
1. Divisão Automática de Contas entre Países
Seu agente de IA automaticamente:


 	Divide contas de restaurantes com amigos internacionalmente
 	Encontra a maneira mais barata de enviar dinheiro (talvez através de criptomoedas, talvez transferência tradicional)
 	Lida com a conversão de moedas nas melhores taxas
 	Envia confirmações de pagamento para todos

2. Economias Inteligentes que Realmente Funcionam
Enquanto você dorme, seu IA:


 	Move dinheiro extra da conta corrente para a poupança com alto rendimento
 	Encontra melhores taxas de juros em diferentes bancos
 	Investe pequenas quantias quando as condições de mercado são boas
 	Nunca toca no dinheiro marcado como "apenas para emergências"

3. O Trader do Twitter
Tweet: "Aposto $50 que vai chover em NYC amanhã" Seu agente de IA:


 	Cria o mercado de previsão automaticamente
 	Mantém o dinheiro de todos de forma segura
 	Verifica os dados meteorológicos amanhã
 	Paga os ganhos instantaneamente

Sem aplicativos para baixar, sem contas para criar, sem interfaces complicadas.

As Preocupações "E Se..."
"E se o IA tomar uma decisão terrível?" Você define regras estritas: "Nunca investir mais de $100 por dia" ou "Apenas mover dinheiro entre minhas contas aprovadas." O IA não pode quebrar essas regras, mesmo que quisesse.
"E se a empresa por trás disso falir?" Ao contrário dos aplicativos tradicionais, nenhuma empresa única controla seu dinheiro. O sistema funciona em uma rede descentralizada, então mesmo se o Protocolo NEAR desaparecesse amanhã, seu agente de IA continuaria funcionando.
"E se houver um bug no código?" Todo o código é público e verificado por especialistas em segurança. Além disso, você pode definir limites conservadores enquanto a tecnologia amadurece.
"Quanto isso custa?" As operações custam centavos em vez de dólares porque o IA não paga taxas tradicionais de blockchain para pensar - apenas para transações finais.

Por Que Isso Muda Tudo
Pela primeira vez, podemos ter um software que:


 	Pensa (usa IA real, não apenas regras simples)
 	Age (realmente controla dinheiro e contas)
 	Permanece confiável (não pode ser corrompido por nenhuma entidade única)

Isso resolve problemas que existem desde o início da internet: Como dar poder suficiente ao software para ser verdadeiramente útil sem dar poder suficiente para prejudicá-lo?

Realidade Atual
O que está disponível agora: Os desenvolvedores estão construindo os primeiros Agentes Shade. As versões iniciais se concentram em tarefas simples como negociação automatizada e movimentação de dinheiro entre cadeias.
Cronograma: Espere aplicativos de consumo simples dentro de 6-12 meses, com capacidades de IA mais sofisticadas sendo lançadas nos próximos 2-3 anos.
Custo de uso: Ainda está sendo determinado, mas provavelmente será semelhante às taxas de assinatura de aplicativos atuais ($5-20/mês) mais custos de transação mínimos.

Próximo Passo Simples
Se isso parece interessante, aqui está o que fazer:
Inscreva-se na lista de espera para aplicativos de Agentes Shade antecipados seguindo @NEARProtocol no Twitter. Eles anunciam novos aplicativos e oportunidades de teste lá primeiro.
É isso. Não é necessário aprender programação de blockchain ou entender criptografia. Assim como você não precisava entender os protocolos HTTP para usar a internet.

A Conclusão
Os Agentes Shade representam a primeira vez que a IA pode ser verdadeiramente útil com seu dinheiro sem exigir confiança cega. Em vez de escolher entre "poderoso mas arriscado" ou "seguro mas inútil", finalmente obtemos ambos.
Seu dinheiro poderia trabalhar tão duro quanto você, tomando decisões inteligentes o tempo todo enquanto você se concentra em tudo o mais na vida.
A questão não é se a IA gerenciará nossas finanças - é se essa IA será controlada por gigantes da tecnologia ou trabalhará diretamente para você.



Quer mergulhar mais fundo nos detalhes técnicos? Confira a documentação completa do Protocolo NEAR. Mas honestamente, você não precisa entender o motor para dirigir o carro.

### NEAR Intents: El Futuro de Web3 es impulsado por Intenciones

Introducción
El panorama de Web3 está evolucionando rápidamente, con NEAR Protocol a la vanguardia de la innovación. Un avance revolucionario es NEAR Intents, diseñado para simplificar las interacciones en blockchain al permitir a los usuarios especificar objetivos en lugar de detallar pasos de transacción complejos. Al abstraer estas complejidades, NEAR Intents está redefiniendo la usabilidad de blockchain y haciendo que las finanzas descentralizadas (DeFi) sean accesibles para todos.
¿Qué son NEAR Intents?
Un intento en NEAR representa una declaración de alto nivel de un resultado deseado. En lugar de ejecutar manualmente cada paso de la transacción, los usuarios especifican claramente lo que desean lograr, como "intercambiar Token A por Token B al mejor precio", mientras que el sistema gestiona los procesos detallados para cumplir con esta solicitud. Este enfoque hace que las interacciones en blockchain sean intuitivas y ampliamente accesibles.
¿Cómo funcionan los NEAR Intents?
Los NEAR Intents operan a través de un proceso estructurado y descentralizado que involucra:

 	Creación de Intención: Los usuarios o agentes de IA definen un resultado deseado, transmitiendo su intención a una red de solucionadores.
 	Competencia de Solucionadores: Servicios especializados fuera de la cadena (solucionadores) analizan la intención, compitiendo para cumplirla de manera eficiente y rentable. Estos solucionadores proporcionan soluciones propuestas como cotizaciones para la aprobación del usuario.
 	Ejecución de Intención: Una vez que se aprueba una solución, el solucionador elegido ejecuta la intención a través del contrato inteligente de NEAR Intents. Este contrato garantiza cambios de estado correctos, liquidando e informando de manera segura el resultado al usuario.

Este modelo simplifica las interacciones en blockchain y mejora significativamente la eficiencia operativa.
Características clave de NEAR Intents

 	Centrado en el Resultado: Los usuarios se centran en el resultado deseado, dejando los detalles de ejecución al sistema.
 	Interoperabilidad sin problemas: Permite interacciones fluidas en múltiples redes blockchain sin puentes complejos.
 	Seguro y sin permisos: Proporciona seguridad mejorada y descentralización, permitiendo a cualquier desarrollador construir y lanzar productos financieros sin restricciones.
 	Integración de IA: Se integra fácilmente con agentes de IA, mejorando los procesos de toma de decisiones inteligentes y permitiendo interacciones automatizadas en blockchain.

Cadenas de Bloques y Tipos de Direcciones Soportados
NEAR Intents facilita interacciones sin problemas entre cadenas de bloques al admitir una amplia gama de cadenas de bloques y sus formatos de dirección respectivos. A continuación se muestra una lista organizada que categoriza estas cadenas admitidas:

Cadenas Compatibles con EVM
Estas cadenas utilizan la arquitectura de Ethereum Virtual Machine (EVM), lo que permite la compatibilidad con herramientas y aplicaciones basadas en Ethereum.
 	
Ethereum: Direcciones hexadecimales de 42 caracteres con prefijo estándar 0x.

 	
Gnosis: Direcciones compatibles con EVM.

 	
Bera: Direcciones compatibles con EVM.

 	
Base: Direcciones compatibles con EVM.

 	
Arbitrum: Direcciones compatibles con EVM.

 	
Aurora: Direcciones compatibles con EVM.DeepNewz


Cadenas basadas en UTXO
Estas cadenas siguen el modelo de Salida de Transacción No Gastada (UTXO), comúnmente utilizado en criptomonedas como Bitcoin.
 	
Bitcoin: Admite múltiples formatos de dirección, incluidos Legacy (1), P2SH (3), Bech32 (bc1) y Taproot (bc1p).

 	
Dogecoin: Admite direcciones P2PKH/Legacy que comienzan con D.

 	
ZCash: Admite direcciones transparentes que comienzan con t1 o t3.reflexivityresearch.com+5Messari+5GitHub+5


Otras Cadenas Compatibles
Estas cadenas tienen arquitecturas y formatos de dirección únicos:
 	
NEAR: Admite tanto direcciones con nombre (por ejemplo, example.near) como direcciones implícitas (hexadecimales de 64 caracteres).

 	
Solana: Utiliza claves públicas Ed25519 codificadas en Base58.

 	
Tron: Utiliza direcciones codificadas en Base58Check que comienzan con T.

 	
XRP: Admite direcciones clásicas que comienzan con r.


Nota: Si bien NEAR Intents admite una amplia gama de cadenas, algunos tipos de direcciones, especialmente en cadenas como ZCash, Dogecoin y XRP, pueden tener un soporte parcial con ciertas limitaciones operativas.
Este amplio soporte permite a NEAR Intents ofrecer robustas funcionalidades de intercambio entre cadenas, simplificando las experiencias de usuario en diversos ecosistemas blockchain.

Aplicaciones del Mundo Real
NEAR Intents desbloquea numerosos casos de uso prácticos más allá de las finanzas descentralizadas tradicionales:

 	Infraestructura Financiera Descentralizada: Permite el comercio entre cadenas y diversos instrumentos financieros.
 	Abstracción Multicadena: Simplifica la integración entre múltiples cadenas, reduciendo la complejidad operativa y los costos.
 	Arquitectura Basada en Intenciones: Reemplaza los modelos tradicionales de creador de mercado automatizado (AMM), proporcionando un mejor acceso a liquidez y precios competitivos.
 	AccountFi: Permite a los usuarios comerciar, prestar y gestionar diversos tipos de activos, incluidos NFT, tokens fungibles y activos no transferibles como Tokens Soulbound (SBTs). Por ejemplo, gestionar membresías basadas en NFT o carteras de activos diversificados entre cadenas.

El Papel de la IA en NEAR Intents
Los agentes de IA mejoran significativamente NEAR Intents al optimizar transacciones de forma autónoma, equilibrar carteras de activos entre cadenas y navegar eficientemente por entornos multicadena. Estas capacidades abren la puerta a aplicaciones innovadoras como el comercio impulsado por IA, la gestión automatizada de liquidez entre cadenas y los mercados de trabajos gigantes descentralizados.Comenzando con NEAR Intents
Los desarrolladores y usuarios ansiosos por sumergirse en NEAR Intents pueden utilizar estos recursos completos:

 	Documentación Oficial: Explicaciones detalladas, tutoriales y conocimientos arquitectónicos (Documentación de NEAR Intents).
 	Repositorio en GitHub: Herramientas, contratos inteligentes y ejemplos para integrar y construir (GitHub de NEAR Intents).
 	Ejemplo de Inicio Rápido: Una implementación simple de agente Python disponible aquí.

Conclusión
NEAR Intents está revolucionando las interacciones en blockchain a través de la simplicidad, el diseño centrado en el usuario y la integración avanzada de IA. Al abstraer la complejidad y mejorar la eficiencia operativa, NEAR Intents están allanando el camino para un ecosistema de Web3 accesible e inteligente.

Comienza a explorar el futuro de las interacciones simplificadas en blockchain hoy mismo: visita la Documentación de NEAR Intents para obtener más información.

### NEAR Ý định: Tương lai của Web3 là dựa trên ý định

Giới thiệu
Cảnh quan Web3 đang phát triển nhanh chóng, với NEAR Protocol đứng đầu trong sự đổi mới. Một tiến bộ đột phá là NEAR Intents, được thiết kế để đơn giản hóa tương tác blockchain bằng cách cho phép người dùng chỉ định mục tiêu thay vì chi tiết các bước giao dịch phức tạp. Bằng cách trừu tượng hóa những phức tạp này, NEAR Intents đang tái định nghĩa tính khả dụng của blockchain và làm cho tài chính phi tập trung (DeFi) trở nên dễ tiếp cận với mọi người.
NEAR Intents Là Gì?
Một intent trong NEAR đại diện cho một tuyên bố cấp cao về kết quả mong muốn. Thay vì thực hiện từng bước giao dịch một cách thủ công, người dùng chỉ định rõ ràng những gì họ muốn đạt được—như "đổi Token A thành Token B với giá tốt nhất"—trong khi hệ thống quản lý các quy trình chi tiết để thực hiện yêu cầu này. Cách tiếp cận này làm cho tương tác blockchain trở nên trực quan và rộng rãi tiếp cận.
Cách NEAR Intents Hoạt Động
NEAR Intents hoạt động thông qua một quy trình cấu trúc, phi tập trung bao gồm:

 	Tạo Intent: Người dùng hoặc các đại lý trí tuệ nhân tạo xác định một kết quả mong muốn, phát sóng ý định của họ đến một mạng lưới các người giải quyết.
 	Cạnh tranh Giải Quyết: Các dịch vụ ngoại chuỗi chuyên biệt (người giải quyết) phân tích ý định, cạnh tranh để thực hiện một cách hiệu quả và tiết kiệm chi phí. Những người giải quyết này cung cấp các giải pháp đề xuất như báo giá để người dùng phê duyệt.
 	Thực Hiện Intent: Khi một giải pháp được phê duyệt, người giải quyết được chọn thực hiện ý định thông qua hợp đồng thông minh NEAR Intents. Hợp đồng này đảm bảo các thay đổi trạng thái chính xác, giải quyết và báo cáo kết quả một cách an toàn cho người dùng.

Mô hình này đơn giản hóa tương tác blockchain trong khi cải thiện đáng kể hiệu quả hoạt động.
Các Tính Năng Chính của NEAR Intents

 	Định Hướng Theo Kết Quả: Người dùng tập trung vào kết quả mong muốn, để lại chi tiết thực hiện cho hệ thống.
 	Tương Tác Mượt Mà Trên Nhiều Chuỗi: Cho phép tương tác mượt mà trên nhiều mạng blockchain mà không cần cầu nối phức tạp.
 	Bảo Mật và Phi Cấp Quyền: Cung cấp bảo mật nâng cao và phi tập trung, cho phép bất kỳ nhà phát triển nào xây dựng và triển khai sản phẩm tài chính mà không bị hạn chế.
 	Tích Hợp Trí Tuệ Nhân Tạo: Dễ dàng tích hợp với các đại lý trí tuệ nhân tạo, nâng cao quyết định thông minh và cho phép tương tác blockchain tự động.

Các Mạng Blockchain và Loại Địa Chỉ Được Hỗ Trợ
NEAR Intents tạo điều kiện cho tương tác mượt mà giữa các chuỗi bằng cách hỗ trợ một loạt mạng blockchain đa dạng và các định dạng địa chỉ tương ứng của chúng. Dưới đây là một danh sách được tổ chức phân loại các chuỗi được hỗ trợ:

Các Chuỗi Tương Thích EVM
Những chuỗi này sử dụng kiến trúc Ethereum Virtual Machine (EVM), cho phép tương thích với các công cụ và ứng dụng dựa trên Ethereum.
 	
Ethereum: Địa chỉ hexa 42 ký tự với tiền tố chuẩn 0x.

 	
Gnosis: Địa chỉ tương thích với EVM.

 	
Bera: Địa chỉ tương thích với EVM.

 	
Base: Địa chỉ tương thích với EVM.

 	
Arbitrum: Địa chỉ tương thích với EVM.

 	
Aurora: Địa chỉ tương thích với EVM.DeepNewz


Các Chuỗi Dựa Trên UTXO
Những chuỗi này tuân theo mô hình Unspent Transaction Output (UTXO), thường được sử dụng trong các loại tiền điện tử như Bitcoin.
 	
Bitcoin: Hỗ trợ nhiều định dạng địa chỉ bao gồm Legacy (1), P2SH (3), Bech32 (bc1), và Taproot (bc1p).

 	
Dogecoin: Hỗ trợ địa chỉ P2PKH/Legacy bắt đầu bằng D.

 	
ZCash: Hỗ trợ địa chỉ Transparent bắt đầu bằng t1 hoặc t3.reflexivityresearch.com+5Messari+5GitHub+5


Các Chuỗi Khác Được Hỗ Trợ
Những chuỗi này có kiến trúc và định dạng địa chỉ độc đáo:
 	
NEAR: Hỗ trợ cả địa chỉ có tên (ví dụ, example.near) và địa chỉ ngầm (64 ký tự hex).

 	
Solana: Sử dụng khóa công khai Ed25519 mã hóa Base58.

 	
Tron: Sử dụng địa chỉ mã hóa Base58Check bắt đầu bằng T.

 	
XRP: Hỗ trợ địa chỉ cổ điển bắt đầu bằng r.


Lưu ý: Mặc dù NEAR Intents hỗ trợ một loạt các chuỗi, một số loại địa chỉ, đặc biệt trên chuỗi như ZCash, Dogecoin và XRP, có thể có hỗ trợ một phần với một số giới hạn vận hành.
Hỗ trợ toàn diện này cho phép NEAR Intents cung cấp các chức năng giao cắt mạnh mẽ, tối ưu hóa trải nghiệm người dùng trên các hệ sinh thái blockchain khác nhau.

Các Ứng Dụng Thực Tế
NEAR Intents mở khóa nhiều trường hợp sử dụng thực tế vượt ra ngoài DeFi truyền thống:

 	Cơ Sở Hạ Tầng Tài Chính Phi Tập Trung: Cho phép giao dịch giao cắt chuỗi và các công cụ tài chính đa dạng.
 	Tóm Lược Đa Chuỗi: Đơn giản hóa tích hợp trên nhiều chuỗi, giảm thiểu phức tạp vận hành và chi phí.
 	Cấu Trúc Dựa Trên Ý Định: Thay thế mô hình tạo thị trường tự động truyền thống (AMM), cung cấp quyền truy cập thanh khoản cải thiện và giá cạnh tranh.
 	AccountFi: Cho phép người dùng giao dịch, cho vay và quản lý nhiều loại tài sản khác nhau—bao gồm NFTs, token có thể chuyển đổi và tài sản không thể chuyển như Soulbound Tokens (SBTs). Ví dụ, quản lý các hội viên dựa trên NFT hoặc các danh mục tài sản giao cắt đa chuỗi đa dạng.

Vai Trò của Trí Tuệ Nhân Tạo trong NEAR Intents
Các đại lý trí tuệ nhân tạo cải thiện đáng kể NEAR Intents bằng cách tối ưu hóa giao dịch tự động, cân bằng danh mục tài sản giao cắt chuỗi và điều hướng hiệu quả trong môi trường đa chuỗi. Những khả năng này mở ra cánh cửa cho các ứng dụng sáng tạo như thương mại dựa trên trí tuệ nhân tạo, quản lý thanh khoản giao cắt chuỗi tự động và các thị trường gig phi tập trung.Bắt đầu với NEAR Intents
Nhà phát triển và người dùng háo hức muốn tìm hiểu về NEAR Intents có thể sử dụng các tài nguyên toàn diện sau:

	Tài liệu chính thức: Giải thích chi tiết, hướng dẫn và cái nhìn kiến trúc (Tài liệu NEAR Intents).
	Kho GitHub: Công cụ, hợp đồng thông minh và ví dụ để tích hợp và xây dựng (GitHub NEAR Intents).
	Ví dụ Khởi đầu Nhanh: Một cài đặt đơn giản của Python có sẵn tại đây.

Kết luận
NEAR Intents đang cách mạng hóa tương tác blockchain thông qua sự đơn giản, thiết kế tập trung vào người dùng và tích hợp trí tuệ nhân tạo tiên tiến. Bằng cách trừu tượng hóa sự phức tạp và tăng cường hiệu quả vận hành, NEAR Intents đang mở đường cho một hệ sinh thái Web3 dễ tiếp cận và thông minh.

Bắt đầu khám phá tương lai của tương tác blockchain đơn giản hóa ngay hôm nay - truy cập Tài liệu NEAR Intents để biết thêm thông tin.

### AI Que Controla Tu Dinero (Y Por Qué Eso Es Realmente Asombroso)

NEAR Protocol is a decentralized application platform that is secure, scalable, and developer-friendly. It uses sharding to improve scalability and reduce fees. NEAR Protocol also features a unique consensus mechanism called Nightshade, which allows for fast finality and high throughput. Developers can build smart contracts on NEAR Protocol using Rust or AssemblyScript. The native token of NEAR Protocol is NEAR, which is used for staking, transaction fees, and governance. Stake NEAR to earn rewards and support the network. Join the NEAR community and start building decentralized applications today!

### NEAR Намерения: Будущее Web3 - это управляемое намерениями.

Введение
Ландшафт Web3 стремительно развивается, и NEAR Protocol стоит на передовых позициях инноваций. Одним из революционных достижений является NEAR Intents, разработанный для упрощения взаимодействия с блокчейном, позволяя пользователям указывать цели вместо детального описания сложных шагов транзакции. Абстрагируясь от этих сложностей, NEAR Intents переопределяет удобство использования блокчейна и делает децентрализованную финансовую систему (DeFi) доступной для всех.
Что такое NEAR Intents?
Intent в NEAR представляет собой высокоуровневое заявление о желаемом результате. Вместо ручного выполнения каждого шага транзакции пользователи четко указывают, что они хотят достичь, например, "обменять токен A на токен B по лучшей цене", в то время как система управляет детальными процессами для выполнения этого запроса. Такой подход делает взаимодействие с блокчейном интуитивным и широко доступным.
Как работают NEAR Intents
NEAR Intents работают через структурированный, децентрализованный процесс, включающий:

 	Создание Intent: Пользователи или искусственные интеллектуальные агенты определяют желаемый результат, транслируя свой intent в сеть решателей.
 	Конкуренция решателей: Специализированные внебиржевые сервисы (решатели) анализируют intent, соревнуясь в эффективном и экономичном выполнении его. Эти решатели предоставляют предложенные решения в виде котировок для утверждения пользователем.
 	Выполнение Intent: После утверждения решения выбранный решатель выполняет intent через смарт-контракт NEAR Intents. Этот контракт обеспечивает корректные изменения состояния, урегулирование и безопасное сообщение о результате пользователю.

Эта модель упрощает взаимодействие с блокчейном, значительно повышая операционную эффективность.
Основные особенности NEAR Intents

 	Ориентированный на результат: Пользователи сосредотачиваются на желаемом результате, оставляя детали выполнения системе.
 	Плавное взаимодействие между цепями: Обеспечивает плавное взаимодействие между несколькими сетями блокчейнов без сложных мостов.
 	Безопасный и безразрешительный: Обеспечивает улучшенную безопасность и децентрализацию, позволяя любому разработчику создавать и запускать финансовые продукты без ограничений.
 	Интеграция с искусственным интеллектом: Легко интегрируется с искусственными интеллектуальными агентами, улучшая процессы принятия интеллектуальных решений и позволяя автоматизировать взаимодействие с блокчейном.

Поддерживаемые блокчейны и типы адресов
NEAR Intents облегчает плавное взаимодействие между цепями, поддерживая разнообразный спектр блокчейнов и их соответствующие форматы адресов. Ниже приведен организованный список, классифицирующий эти поддерживаемые цепи:

Цепи, совместимые с EVM
Эти цепи используют архитектуру Ethereum Virtual Machine (EVM), что позволяет совместимость с инструментами и приложениями, основанными на Ethereum.
 	
Ethereum: Стандартные адреса из 42 символов в шестнадцатеричном формате с префиксом 0x.

 	
Gnosis: Адреса, совместимые с EVM.

 	
Bera: Адреса, совместимые с EVM.

 	
Base: Адреса, совместимые с EVM.

 	
Arbitrum: Адреса, совместимые с EVM.

 	
Aurora: Адреса, совместимые с EVM.DeepNewz


Цепи на основе UTXO
Эти цепи следуют модели Unspent Transaction Output (UTXO), которая часто используется в криптовалютах, таких как Bitcoin.
 	
Bitcoin: Поддерживает несколько форматов адресов, включая Legacy (1), P2SH (3), Bech32 (bc1) и Taproot (bc1p).

 	
Dogecoin: Поддерживает адреса P2PKH/Legacy, начинающиеся с D.

 	
ZCash: Поддерживает прозрачные адреса, начинающиеся с t1 или t3.reflexivityresearch.com+5Messari+5GitHub+5


Другие поддерживаемые цепочки
Эти цепочки имеют уникальные архитектуры и форматы адресов:
 	
NEAR: Поддерживает именованные адреса (например, example.near) и неявные адреса (64-значные шестнадцатеричные).

 	
Solana: Использует Base58-кодированные открытые ключи Ed25519.

 	
Tron: Использует Base58Check-кодированные адреса, начинающиеся с T.

 	
XRP: Поддерживает классические адреса, начинающиеся с r.


Примечание: Хотя NEAR Intents поддерживает широкий спектр цепочек, некоторые типы адресов, особенно на цепочках типа ZCash, Dogecoin и XRP, могут иметь частичную поддержку с определенными операционными ограничениями.
Эта обширная поддержка позволяет NEAR Intents предлагать надежные функциональности межцепочечных операций, оптимизируя опыт пользователей в различных блокчейн-экосистемах.

Прикладные программы в реальном мире
NEAR Intents открывают множество практических применений за пределами традиционного DeFi:

 	Инфраструктура децентрализованных финансов: Позволяет межцепочечную торговлю и разнообразные финансовые инструменты.
 	Абстракция межцепочечных операций: Упрощает интеграцию между несколькими цепочками, снижая операционную сложность и стоимость.
 	Архитектура на основе намерений: Заменяет традиционные модели автоматизированных рыночных сделок (AMM), обеспечивая улучшенный доступ к ликвидности и конкурентоспособные цены.
 	AccountFi: Позволяет пользователям торговать, давать взаймы и управлять разнообразными типами активов, включая NFT, обращаемые токены и необоротные активы, такие как Soulbound Tokens (SBTs). Например, управление членствами на основе NFT или диверсифицированными портфелями активов между цепочками.

Роль искусственного интеллекта в NEAR Intents
Искусственные интеллектуальные агенты значительно улучшают NEAR Intents, автономно оптимизируя транзакции, балансируя межцепочечные портфели активов и эффективно навигируя в многоцепочечных средах. Эти возможности открывают дверь к инновационным приложениям, таким как торговля, управление ликвидностью между цепочками, автоматизированные рынки услуг.Начало работы с NEAR Intents
Разработчики и пользователи, желающие погрузиться в NEAR Intents, могут использовать эти всеобъемлющие ресурсы:

 	Официальная документация: Подробные объяснения, учебные пособия и архитектурные идеи (Документация NEAR Intents).
 	Репозиторий GitHub: Инструменты, смарт-контракты и примеры для интеграции и создания (NEAR Intents GitHub).
 	Пример быстрого запуска: Простая реализация Python-агента доступна здесь.

Заключение
NEAR Intents революционизируют взаимодействие с блокчейном благодаря простоте, ориентированности на пользователя и интеграции передовых технологий искусственного интеллекта. Абстрагируя сложность и улучшая операционную эффективность, NEAR Intents готовят почву для доступной и интеллектуальной экосистемы Web3.

Начните исследовать будущее упрощенного взаимодействия с блокчейном уже сегодня — посетите Документацию NEAR Intents, чтобы узнать больше.

### Trí tuệ nhân tạo kiểm soát tiền của bạn (Và Tại sao Điều đó Thực sự Tuyệt vời)

Ví dụ về cách sử dụng NEAR SDK để tạo một ứng dụng phi tập trung trên NEAR Protocol.

Điều gì sẽ xảy ra nếu tiền của bạn có thể tự suy nghĩ và ra quyết định thông minh trong khi bạn ngủ?

Vấn đề mà bạn không biết mình đang gặp phải
Sarah có tiền trong 5 ứng dụng khác nhau: Venmo, Cash App, tiết kiệm ngân hàng, Robinhood và một số Bitcoin trên Coinbase. Khi bạn Jake cần chia sẻ hóa đơn ăn tối 200 đô la ở Tokyo, cô ấy đối mặt với một cơn ác mộng:


 	Venmo của cô ấy không hoạt động quốc tế
 	Ngân hàng của cô ấy tính phí 25 đô la cho chuyển khoản
 	Chuyển đổi Bitcoin mất 3 ngày
 	Cô ấy phải kiểm tra thủ công 5 ứng dụng để xem cô ấy có tiền ở đâu

Trong khi đó, tiền của cô ấy chỉ đứng đó không làm gì thay vì kiếm lãi, và cô ấy bỏ lỡ cơ hội đầu tư vì cô ấy đang làm việc khi thị trường di chuyển.
Điều gì nếu một trợ lý thông minh có thể quản lý tất cả điều này một cách tự động?

Nhập Shade Agents: Người quản lý tiền AI của bạn
Shade Agents của NEAR Protocol giống như có một cố vấn tài chính, kế toán và trợ lý cá nhân được kết hợp thành một AI mà:


 	Kiểm soát tài khoản trên các nền tảng khác nhau (ngân hàng, tiền điện tử, ứng dụng)
 	Ra quyết định thông minh về tiền của bạn 24/7
 	Di chuyển tiền tự động để có được những ưu đãi tốt nhất cho bạn
 	Không bao giờ thực sự lấy cắp tiền của bạn (chúng tôi sẽ giải thích mẹo bảo mật thông minh)

Hãy tưởng tượng đó như Siri cho tài chính của bạn, nhưng một cái có thể thực sự hành động, không chỉ nói cho bạn biết thời tiết.

"Chờ đã, Làm sao tôi biết nó sẽ không lấy cắp tiền của tôi?"
Câu hỏi tuyệt vời. Đây là mẹo bảo mật thông minh làm cho điều này trở nên khả thi:
Vấn đề với Ứng dụng Tiền AI Hiện tại:


 	Hoặc AI không thể thực sự kiểm soát tiền của bạn (vô dụng)
 	Hoặc một số công ty giữ mật khẩu của bạn (họ có thể lấy cắp tất cả)

Giải pháp Shade Agent: Hãy tưởng tượng tiền của bạn đang ở trong một két yêu cầu CẦN HAI chìa khóa để mở:


 	Chìa khóa 1: Được giữ bởi AI chạy trên phần cứng cực kỳ an toàn (như két của ngân hàng)
 	Chìa khóa 2: Được kiểm soát bởi mã mà mọi người có thể thấy và xác minh

AI chỉ có thể truy cập tiền của bạn nếu:


 	Nó đang chạy mã chính xác mà mọi người đã đồng ý
 	Phần cứng an toàn xác nhận nó chưa bị hack
 	Giao dịch tuân theo các quy tắc bạn đã phê duyệt trước

Nếu AI cố gắng làm điều gì đó không chính đáng, két sẽ tự động khóa. Nếu phần cứng an toàn bị hỏng, bạn có thể bắt đầu một phiên bản AI mới với cùng quyền truy cập (tiền của bạn không bị mất).

Các Ví dụ Thực Sự Quan Trọng
1. Chia sẻ Hóa Đơn Tự Động Qua Các Quốc Gia
Đại lý AI của bạn tự động:


 	Chia sẻ hóa đơn nhà hàng với bạn bè quốc tế
 	Tìm cách gửi tiền rẻ nhất (có thể thông qua tiền điện tử, có thể qua chuyển khoản truyền thống)
 	Xử lý chuyển đổi tiền tệ với tỷ lệ tốt nhất
 	Gửi xác nhận thanh toán cho mọi người

2. Tiết Kiệm Thông Minh Thực Sự
Khi bạn ngủ, AI của bạn:


 	Chuyển tiền dư từ tài khoản thanh toán sang tài khoản tiết kiệm có lợi suất cao
 	Tìm kiếm lãi suất tốt hơn trên các ngân hàng khác nhau
 	Đầu tư số tiền nhỏ khi điều kiện thị trường tốt
 	Không bao giờ chạm vào tiền bạn đánh dấu là "chỉ khẩn cấp"

3. Người Giao Dịch Twitter
Tweet: "Tôi đặt cược 50 đô la rằng ngày mai sẽ mưa ở NYC" Đại lý AI của bạn:


 	Tự động tạo thị trường dự đoán
 	Giữ tiền của mọi người một cách an toàn
 	Kiểm tra dữ liệu thời tiết vào ngày mai
 	Thanh toán thắng lợi ngay lập tức

Không cần tải ứng dụng, không cần tạo tài khoản, không cần giao diện phức tạp.

Những Lo Lắng "Nhưng Nếu..."
"Nếu AI ra quyết định tồi tệ?" Bạn đặt ra quy tắc nghiêm ngặt: "Không bao giờ đầu tư hơn 100 đô la mỗi ngày" hoặc "Chỉ chuyển tiền giữa các tài khoản đã được phê duyệt của tôi." AI không thể vi phạm những quy tắc này, ngay cả khi muốn.
"Nếu công ty đứng sau điều này phá sản?" Không giống như các ứng dụng truyền thống, không có một công ty duy nhất kiểm soát tiền của bạn. Hệ thống chạy trên một mạng phân cấp, vì vậy ngay cả nếu NEAR Protocol biến mất ngày mai, đại lý AI của bạn vẫn hoạt động.
"Nếu có một lỗi trong mã?" Tất cả mã nguồn đều công khai và được xác minh bởi các chuyên gia bảo mật. Ngoài ra, bạn có thể đặt giới hạn bảo thủ trong khi công nghệ trưởng thành.
"Chi phí cho điều này là bao nhiêu?" Chi phí vận hành chỉ là vài xu thay vì đô la vì AI không trả phí chuỗi khối truyền thống cho việc suy nghĩ—chỉ cho các giao dịch cuối cùng.

Tại Sao Điều Này Thay Đổi Mọi Thứ
Lần đầu tiên, chúng ta có thể có phần mềm có thể:


 	Suy nghĩ (sử dụng AI thực sự, không chỉ là các quy tắc đơn giản)
 	Hành động (thực sự kiểm soát tiền và tài khoản)
 	Luôn đáng tin cậy (không thể bị làm hỏng bởi bất kỳ thực thể duy nhất nào)

Điều này giải quyết các vấn đề đã tồn tại từ khi internet bắt đầu: Làm thế nào để cung cấp đủ quyền lực cho phần mềm để thực sự hữu ích mà không cung cấp đủ quyền lực để gây hại cho bạn?

Kiểm Tra Thực Tế Hiện Tại
Gì đang có sẵn: Nhà phát triển đang xây dựng các Shade Agents đầu tiên. Các phiên bản sớm tập trung vào các nhiệm vụ đơn giản như giao dịch tự động và chuyển tiền qua các chuỗi khối.
Lịch trình: Mong đợi ứng dụng tiêu dùng đơn giản trong vòng 6-12 tháng, với khả năng AI phức tạp hơn sẽ được triển khai trong vòng 2-3 năm tới.
Chi phí sử dụng: Đang được xác định, nhưng có thể tương tự như phí đăng ký ứng dụng hiện tại ($5-20/tháng) ->

### NEAR new website BugEye sprint

👀BugEye Sprint starts: June 12, 9 am ET
👀BugEye Sprint ends: June 17, 9 am ET
Requirements:





 	
Open the site


 	
Visit NEAR.org on both your phone and laptop/desktop.

 	
Spend a few minutes clicking the main menu, scrolling pages, and trying any buttons or links that interest you.



 	
Keep an eye out for four things


 	
Broken links – you click and land on an error page or the wrong place.

 	
Wrong or outdated info – numbers, dates, or claims that seem suspicious.

 	
Typos & weird wording – spelling, grammar, or formatting mistakes.

 	
Confusing spots – text too small, hard‑to‑read colors, or anything that makes you go “huh?”



 	
Write down each issue


 	
Page URL (copy the web address).

 	
What you clicked / saw.

 	
What went wrong (one short sentence).

 	
Optional: take a quick screenshot.











Fill the Feedback form
You can send as many issues as you find.
Get a thank‑you reward

 	
Up to 5 Ⓝ per useful, first‑reported issue.

 	
Payouts within a week after we review the reports.


That’s it! Explore, note anything odd, and share. Your fresh eyes👀 help make NEAR.org easier for everyone.

### Introduction to Intear Wallet

Intear Wallet is a next-generation web-based wallet designed specifically for the NEAR ecosystem. Built with speed and user experience at its core, Intear positions itself as "the fastest NEAR wallet" while offering advanced smart wallet capabilities that go beyond traditional crypto storage.
It is in Beta with official launch planned on July 6, 2025.

What Makes Intear Different
Intear Wallet stands out in the crowded wallet space through its innovative approach to user onboarding and recovery. Unlike traditional wallets that rely solely on seed phrases, Intear implements a smart wallet architecture that allows users to recover their accounts through multiple methods including Google authentication, biometric verification, passkeys, and even connections to EVM and Solana wallets. This flexibility makes crypto more accessible to mainstream users while maintaining the security standards expected by experienced users.
The wallet's non-custodial nature ensures users maintain full control of their assets, with optional password encryption for local key storage providing an additional security layer. For those who prefer traditional methods, seed phrase and private key recovery options remain available.

Core Features and Ecosystem Integration
Intear Wallet offers comprehensive NEAR ecosystem support, including native staking capabilities, NFT marketplace access, and personalized DeFi recommendations based on users' current holdings. The wallet integrates with multiple DEX aggregators including Rhea, Near Intents, AIdols, Veax, GraFun, and potentially Jump and Vita, providing users with optimal swap rates across the ecosystem.
The platform simplifies user onboarding by allowing the creation of .near usernames coupled with flexible recovery options. This approach reduces the barrier to entry for new crypto users while maintaining the security and decentralization that experienced users demand.

Development and Vision
As an open-source project available on GitHub, Intear Wallet maintains transparency in its development process. The team engages with the community through social media channels and bi-weekly livestreams on X, providing regular updates and gathering user feedback through their Telegram group and built-in live chat support.
Looking ahead, Intear has ambitious plans including a mobile application and recurring payment functionality. Their long-term vision is clear: to become the best NEAR wallet by the end of 2025. With features like automatic yield reinvestment, user-friendly logout processes, and the most up-to-date ecosystem mapping, Intear is positioning itself as the comprehensive solution for NEAR users.

Getting Started
Intear Wallet is currently available as a web application at wallet.intear.tech and integrates seamlessly with NEAR WalletSelector for easy dApp connectivity. While currently English-only, the wallet's focus on user experience and innovative recovery methods make it an attractive option for both newcomers to crypto and seasoned NEAR ecosystem participants.
For users seeking a fast, secure, and feature-rich NEAR wallet that bridges the gap between traditional finance and decentralized applications, Intear Wallet represents a compelling new option in the rapidly evolving crypto wallet landscape.

### AI That Controls Your Money (And Why That's Actually Amazing)

What if your money could think for itself and make smart decisions while you sleep?

The Problem You Didn't Know You Had
Sarah has money in 5 different apps: Venmo, Cash App, her bank savings, Robinhood, and some Bitcoin on Coinbase. When her friend Jake needs to split a $200 dinner bill in Tokyo, she faces a nightmare:


 	Her Venmo doesn't work internationally
 	Her bank charges $25 for wire transfers
 	Converting Bitcoin takes 3 days
 	She has to manually check 5 apps to see where she even has money

Meanwhile, her money just sits there doing nothing instead of earning interest, and she misses investment opportunities because she's at work when the market moves.
What if one smart assistant could manage all of this automatically?

Enter Shade Agents: Your AI Money Manager
NEAR Protocol's Shade Agents are like having a financial advisor, accountant, and personal assistant rolled into one AI that:


 	Controls accounts across different platforms (banks, crypto, apps)
 	Makes smart decisions about your money 24/7
 	Moves funds automatically to get you the best deals
 	Never actually steals your money (we'll explain the clever security trick)

Think of it as Siri for your finances, but one that can actually take action, not just tell you the weather.

"Wait, How Do I Know It Won't Rob Me Blind?"
Great question. Here's the clever security trick that makes this possible:
The Problem with Current AI Money Apps:


 	Either the AI can't actually control your money (useless)
 	Or some company holds your passwords (they could steal everything)

The Shade Agent Solution: Imagine your money is in a vault that requires TWO keys to open:


 	Key 1: Held by the AI running in ultra-secure hardware (like a bank's vault)
 	Key 2: Controlled by code that everyone can see and verify

The AI can only access your money if:


 	It's running the exact code everyone agreed on
 	The secure hardware confirms it hasn't been hacked
 	The transaction follows rules you pre-approved

If the AI tries to do something sketchy, the vault automatically locks. If the secure hardware breaks, you can start a new AI instance with the same access (your money isn't lost).

Real Examples That Actually Matter
1. Auto-Bill Splitting Across Countries
Your AI agent automatically:


 	Splits restaurant bills with friends internationally
 	Finds the cheapest way to send money (maybe through crypto, maybe traditional transfer)
 	Handles currency conversion at the best rates
 	Sends payment confirmations to everyone

2. Smart Savings That Actually Work
While you sleep, your AI:


 	Moves spare cash from checking to high-yield savings
 	Finds better interest rates across different banks
 	Invests small amounts when market conditions are good
 	Never touches money you marked as "emergency only"

3. The Twitter Trader
Tweet: "I bet $50 that it'll rain in NYC tomorrow" Your AI agent:


 	Creates the prediction market automatically
 	Holds everyone's money securely
 	Checks weather data tomorrow
 	Pays out winnings instantly

No apps to download, no accounts to create, no complicated interfaces.

The "But What If..." Concerns
"What if the AI makes a terrible decision?" You set strict rules: "Never invest more than $100 per day" or "Only move money between my approved accounts." The AI cannot break these rules, even if it wanted to.
"What if the company behind this goes bankrupt?" Unlike traditional apps, no single company controls your money. The system runs on a decentralized network, so even if NEAR Protocol disappeared tomorrow, your AI agent would keep working.
"What if there's a bug in the code?" All the code is public and verified by security experts. Plus, you can set conservative limits while the technology matures.
"How much does this cost?" Operations cost pennies instead of dollars because the AI doesn't pay traditional blockchain fees for thinking—only for final transactions.

Why This Changes Everything
For the first time, we can have software that:


 	Thinks (uses real AI, not just simple rules)
 	Acts (actually controls money and accounts)
 	Stays trustworthy (can't be corrupted by any single entity)

This solves problems that have existed since the internet began: How do you give software enough power to be truly helpful without giving it enough power to harm you?

Current Reality Check
What's available now: Developers are building the first Shade Agents. Early versions focus on simple tasks like automated trading and cross-chain money movement.
Timeline: Expect simple consumer applications within 6-12 months, with more sophisticated AI capabilities rolling out over the next 2-3 years.
Cost to use: Still being determined, but likely similar to current app subscription fees ($5-20/month) plus tiny transaction costs.

One Simple Next Step
If this sounds interesting, here's what to do:
Join the waitlist for early Shade Agent applications by following @NEARProtocol on Twitter. They announce new apps and testing opportunities there first.
That's it. No need to learn blockchain programming or understand cryptography. Just like you didn't need to understand HTTP protocols to use the internet.

The Bottom Line
Shade Agents represent the first time AI can be truly helpful with your money without requiring blind trust. Instead of choosing between "powerful but risky" or "safe but useless," we finally get both.
Your money could work as hard as you do, making smart decisions around the clock while you focus on everything else in life.
The question isn't whether AI will manage our finances—it's whether that AI will be controlled by tech giants or work directly for you.



Want to dive deeper into the technical details? Check out the full NEAR Protocol documentation. But honestly, you don't need to understand the engine to drive the car.

### Developer Tools and Resources in the NEAR Protocol Ecosystem

NEAR Protocol offers a comprehensive suite of tools and resources designed to streamline the development of decentralized applications (dApps). Whether you're building smart contracts, integrating wallets, or analyzing on-chain data, NEAR provides robust solutions to support your development journey.




Smart Contract Development
NEAR SDKs
NEAR supports smart contract development in both Rust and JavaScript through its Software Development Kits (SDKs).


 	
Rust SDK: Ideal for performance-critical applications, the Rust SDK provides a secure, production-grade environment for smart contract development.

 	
JavaScript SDK: Designed for accessibility, the JavaScript SDK allows web developers to build and deploy contracts without needing to learn a new language.


Both SDKs come with detailed documentation and example projects to help developers get started quickly.

NEAR CLI
The NEAR Command Line Interface (CLI) is a powerful tool that allows developers to interact with the NEAR network directly from the terminal. With NEAR CLI, you can:


 	
Create and manage accounts

 	
Deploy and interact with smart contracts

 	
Send tokens and manage access keys


It supports various installation methods and is essential for both testing and production deployment workflows.




Frontend & Backend Integration
NEAR API Libraries
NEAR provides official and community-supported API libraries in JavaScript, Python, and Rust, enabling seamless interaction with the blockchain from a variety of environments.


 	
JavaScript (near-api-js)The most mature and widely used NEAR API. It allows you to:


 	
Call smart contract functions

 	
Manage user keys and sessions

 	
Handle wallet authentication and transactionsIdeal for frontend web apps using frameworks like React or Vue.



 	
Python (near-api-py)A growing library for backend services, bots, or server-side tools written in Python.Supports:


 	
Viewing account state and transaction history

 	
Querying contracts and sending signed transactions

 	
Creating and managing access keys



 	
Rust (near-jsonrpc-client-rs)A low-level Rust client for interacting with NEAR's JSON-RPC endpoints.Used mainly in Rust-based infrastructure tools or indexers.Suitable for performance-sensitive applications and native integration.


Each library provides robust access to NEAR's core functionalities: transaction signing, contract calls, querying state, and working with keys.




Wallet Integration
Wallet Selector
The Wallet Selector simplifies integrating NEAR wallets into dApps. It provides a modular interface where users can choose their preferred wallet for authentication and transactions. It supports various wallet providers and can be integrated into JavaScript frameworks like React and Next.js, reducing the complexity of onboarding new users.




Data Access and Indexing
Explorers
NEAR offers several blockchain explorers to access on-chain data:


 	
NearBlocks: A feature-rich explorer for viewing accounts, blocks, and contract interactions.

 	
Nearscope: Focused on validator and delegator metrics.

 	
Pikespeak: Offers real-time and historical on-chain insights.

 	
NEARCatalog: Curated listing of trending NEAR dApps.


Indexing Solutions
For custom data querying and analytics, developers can choose from several solutions:


 	
Indexer.xyz: Provides GraphQL APIs for transaction and contract data across chains.

 	
The Graph: Allows building subgraphs for event-driven indexing.

 	
GetBlock: A multi-chain node service offering reliable RPC access.

 	
NEAR Indexer Framework: For building custom stream processors using Rust.

 	
SubQuery: A powerful end-to-end solution for indexing NEAR data and exposing it via APIs.





Ecosystem Tools
NEAR offers additional utilities to aid development:


 	
Testnet Faucet: Get free NEAR tokens for testing on the testnet.

 	
Developer Portal: Centralized resources including news, tutorials, and starter templates.

 	
Lanstool





Community and Support
The NEAR developer community is active and well-supported:


 	
Community channels like Discord and Telegram provide real-time help.

 	
Developer Hub aggregates updates, tutorials, and community highlights.

 	
Learn NEAR Club and other platforms offer structured learning paths and interactive guides for beginners and advanced users.





Conclusion
NEAR Protocol offers an extensive and developer-friendly ecosystem packed with SDKs, APIs, wallet tools, explorers, indexers, and learning resources. Whether you're building a lightweight web app or a full-scale Web3 platform, NEAR’s tooling is designed to get you from concept to deployment smoothly and securely.

### Aurora's Rainbow Bridge is no longer active

As of June 2025, Aurora's Rainbow Bridge is no longer active. Еhe project has been archived, deposits are halted, and funds are being moved to a new bridge called “Omnibridge.” This shift officially ends the Rainbow Bridge’s role in enabling trustless transfers between Ethereum, NEAR, and Aurora.

### Getting Started with FastFS: Decentralized File Storage on NEAR Protocol

FastFS by Fast NEAR is a decentralized file storage system built on the NEAR blockchain, designed to provide a standardized protocol for uploading and serving files. By leveraging NEAR's transaction capabilities, FastFS ensures that files are stored on-chain and accessible via predictable URLs, facilitating seamless integration with decentralized applications (dApps).




🔗 URL Structure
Each file uploaded to FastFS is accessible through a URL formatted as:







https://{predecessor_id}.fastfs.io/{receiver_id}/{relative_path}



 	
predecessor_id: The account initiating the upload.

 	
receiver_id: The contract account handling the file storage.

 	
relative_path: The file's designated path within the storage system.


Example:Uploading an image via a transaction from mob.near to fastfs.near with the relative path fastnear.png results in the URL:







https://mob.near.fastfs.io/fastfs.near/fastnear.png





🧾 Upload Process
1. Prepare File DataConstruct a data structure containing the file's relative path and content:


const fastfsData = {
simple: {
relativePath: "path/to/your/file.png",
content: {
mimeType: "image/png",
content: new Uint8Array(fileBuffer) // File content as byte array
}
}
};


2. Serialize DataUse Borsh serialization to encode the data:









import { serialize as borshSerialize } from "borsh";

const serializedData = borshSerialize(FastfsSchema.FastfsData, fastfsData);
const base64Data = near.utils.bytesToBase64(serializedData);



3. Submit TransactionSend a NEAR transaction with the following parameters:


 	
Method Name: __fastdata_fastfs

 	
Arguments: base64Data

 	
Receiver: fastfs.near








await near.functionCall({
contractId: "fastfs.near",
methodName: "__fastdata_fastfs",
args: base64Data,
gas: "300000000000000", // 300 TGas
attachedDeposit: "0"
});





✅ Validation Rules
FastFS enforces specific validation criteria to maintain data integrity:


 	
Relative Path: Must not exceed 1,024 characters.

 	
MIME Type: Required and cannot be empty.

 	
Content: Optional; if omitted, the file is considered deleted.








impl SimpleFastfs {
pub fn is_valid(&self) -> bool {
if self.relative_path.len() > MAX_RELATIVE_PATH_LENGTH {
return false;
}
if let Some(content) = &self.content {
if content.mime_type.is_empty() {
return false;
}
}
true
}
}





🗃️ Storage and Indexing
FastFS utilizes an indexer to process transactions and store metadata in ScyllaDB, including:


 	
Transaction details: Receipt ID, block height, timestamp.

 	
Account information: Predecessor ID, receiver ID, signer ID.

 	
File data: Relative path, MIME type, content bytes.

 	
Indexing metadata: Shard ID, receipt index, action index.





🔧 Developer Tools
FastFS provides several repositories to facilitate integration:


 	
FastFS Server: Handles file serving and routing.

 	
FastData Indexer: Processes and indexes transactions.

 	
Drag & Drop Interface: User-friendly frontend for file uploads.


These tools enable developers to seamlessly incorporate decentralized file storage into their applications.




🕺 Using FastFS on NEAR Mainnet for LNCer NFT Collections
For Learn NEAR Club's LNCer NFT collection, FastFS presents an ideal solution for storing NFT metadata and assets directly on NEAR mainnet. LNCer NFTs, which are earned through Learn NEAR Club's learning platform, can leverage FastFS to ensure their digital assets remain permanently accessible and truly decentralized. By storing NFT images, metadata JSON files, and additional multimedia content through FastFS, LNCer holders can be confident that their educational achievement tokens will persist without relying on hard-to-use storage solutions like IPFS gateways or traditional cloud services. The predictable URL structure (https://fastnear.com/fastfs/learnnear.near/fastfs.near/lncer-{token_id}.json) makes it easy for NFT marketplaces and wallets to display LNCer NFTs consistently, while the on-chain storage approach aligns perfectly with NEAR's mission of creating a truly decentralized ecosystem for learning credentials and community recognition.
For more detailed information, refer to the FastFS Upload Format Documentation.

### NEAR Intents: The Future of Web3 is Intent-Driven

Introduction
The Web3 landscape is evolving rapidly, with NEAR Protocol at the forefront of innovation. One groundbreaking advancement is NEAR Intents, designed to simplify blockchain interactions by allowing users to specify goals instead of detailing complex transaction steps. By abstracting these intricacies, NEAR Intents is redefining blockchain usability and making decentralized finance (DeFi) accessible to everyone.
What Are NEAR Intents?
An intent in NEAR represents a high-level declaration of a desired outcome. Rather than manually executing each transaction step, users specify clearly what they wish to achieve—like "swap Token A for Token B at the best price"—while the system manages the detailed processes to fulfill this request. This approach makes blockchain interactions intuitive and broadly accessible.
How NEAR Intents Work
NEAR Intents operate via a structured, decentralized process involving:

 	Intent Creation: Users or AI agents define a desired outcome, broadcasting their intent to a network of solvers.
 	Solver Competition: Specialized off-chain services (solvers) analyze the intent, competing to fulfill it efficiently and cost-effectively. These solvers provide proposed solutions as quotes for user approval.
 	Intent Execution: Once a solution is approved, the chosen solver executes the intent through the NEAR Intents smart contract. This contract ensures correct state changes, settling and reporting the outcome securely to the user.

This model simplifies blockchain interactions while significantly improving operational efficiency.

https://www.youtube.com/watch?v=mOGD2gzZJqE
🎥 Video Credits

 	
Title: NEAR Intents 101 – A New Way to Transact | Build Smarter with AI & Blockchain by NEAR DevHub


Key Features of NEAR Intents

 	Outcome-Driven: Users focus on the desired result, leaving the execution details to the system.
 	Seamless Cross-Chain: Enables smooth interactions across multiple blockchain networks without complex bridges.
 	Secure and Permissionless: Provides enhanced security and decentralization, allowing any developer to build and launch financial products without restrictions.
 	AI Integration: Easily integrates with AI agents, enhancing intelligent decision-making processes and enabling automated blockchain interactions.

Supported Blockchains and Address Types
NEAR Intents facilitates seamless cross-chain interactions by supporting a diverse range of blockchains and their respective address formats. Below is an organized list categorizing these supported chains:

EVM-Compatible Chains
These chains utilize Ethereum Virtual Machine (EVM) architecture, allowing for compatibility with Ethereum-based tools and applications.


 	
Ethereum: Standard 0x-prefixed 42-character hexadecimal addresses.

 	
Gnosis: EVM-compatible addresses.

 	
Bera: EVM-compatible addresses.

 	
Base: EVM-compatible addresses.

 	
Arbitrum: EVM-compatible addresses.

 	
Aurora: EVM-compatible addresses.DeepNewz


UTXO-Based Chains
These chains follow the Unspent Transaction Output (UTXO) model, commonly used in cryptocurrencies like Bitcoin.


 	
Bitcoin: Supports multiple address formats including Legacy (1), P2SH (3), Bech32 (bc1), and Taproot (bc1p).

 	
Dogecoin: Supports P2PKH/Legacy addresses starting with D.

 	
ZCash: Supports Transparent addresses starting with t1 or t3.reflexivityresearch.com+5Messari+5GitHub+5


Other Supported Chains
These chains have unique architectures and address formats:


 	
NEAR: Supports both Named addresses (e.g., example.near) and Implicit addresses (64-character hexadecimal).

 	
Solana: Uses Base58-encoded Ed25519 public keys.

 	
Tron: Utilizes Base58Check-encoded addresses starting with T.

 	
XRP: Supports Classic addresses starting with r.


Note: While NEAR Intents supports a broad range of chains, some address types, especially on chains like ZCash, Dogecoin, and XRP, may have partial support with certain operational limitations.
This extensive support enables NEAR Intents to offer robust cross-chain functionalities, streamlining user experiences across various blockchain ecosystems.

Real-World Applications
NEAR Intents unlock numerous practical use cases beyond traditional DeFi:

 	Decentralized Finance Infrastructure: Enables cross-chain trading and diverse financial instruments.
 	Multichain Abstraction: Simplifies integration across multiple chains, reducing operational complexity and cost.
 	Intent-Based Architecture: Replaces traditional automated market maker (AMM) models, providing improved liquidity access and competitive pricing.
 	AccountFi: Allows users to trade, lend, and manage diverse asset types—including NFTs, fungible tokens, and non-transferable assets like Soulbound Tokens (SBTs). For example, managing NFT-based memberships or diversified cross-chain asset portfolios.

The Role of AI in NEAR Intents
AI agents significantly enhance NEAR Intents by autonomously optimizing transactions, balancing cross-chain asset portfolios, and efficiently navigating multi-chain environments. These capabilities open the door to innovative applications such as AI-driven commerce, automated cross-chain liquidity management, and decentralized gig marketplaces.
Getting Started with NEAR Intents
Developers and users eager to dive into NEAR Intents can use these comprehensive resources:

 	Official Documentation: Detailed explanations, tutorials, and architectural insights (NEAR Intents Documentation).
 	GitHub Repository: Tools, smart contracts, and examples to integrate and build (NEAR Intents GitHub).
 	Quick-Start Example: A simple Python agent implementation available here.

Conclusion
NEAR Intents are revolutionizing blockchain interactions through simplicity, user-centric design, and advanced AI integration. By abstracting complexity and enhancing operational efficiency, NEAR Intents are paving the way for an accessible and intelligent Web3 ecosystem.

Start exploring the future of simplified blockchain interactions today—visit the NEAR Intents Documentation to learn more.

### Contrato Global: Uma Nova Camada de Componibilidade na NEAR

O Protocolo NEAR já está entre as blockchains mais amigáveis para desenvolvedores e performáticas, projetadas para escalabilidade via shardagem. No entanto, os desenvolvedores enfrentam atrito ao precisar implantar a mesma lógica de contrato em vários shards ou contas. O NEP-0591, que introduz Contratos Globais, é uma proposta altamente estratégica que resolve isso de forma elegante.

Em vez de implantar contratos duplicados ou rotear mensagens de forma ineficiente entre shards, os desenvolvedores do NEAR agora podem pensar modular e universalmente: escreva uma vez, use em todos os lugares. Os contratos globais não são apenas uma conveniência técnica - representam uma mudança fundamental em como a lógica compartilhada, protocolos e padrões podem ser incorporados em todo o ecossistema NEAR.

🔍 O Que Torna os Contratos Globais Especiais?
 	
🔗 Endereçamento Global


 	
Esses contratos não estão vinculados a uma conta específica, mas usam um identificador global único. Isso permite que qualquer contrato, usuário ou aplicativo na NEAR chame o contrato de qualquer fragmento instantaneamente.



 	
🧱 Lógica Imutável


 	
O código do contrato é fixo após ser implantado, tornando-o um ponto de referência confiável. Isso garante consistência e segurança, ideal para protocolos críticos do sistema.



 	
🤝 Infraestrutura Compartilhada


 	
Contratos globais podem atuar como bibliotecas canônicas, hubs de utilidade ou padrões para outros contratos dependerem, simplificando o desenvolvimento e reduzindo a duplicação.



 	
🌉 Superpoderes Cross-Shard


 	
Os desenvolvedores podem construir aplicativos verdadeiramente modulares onde partes de sua pilha residem em diferentes fragmentos, mas se comunicam via lógica global compartilhada com latência ou duplicação mínimas.







✅ As Vantagens - Por Que Isso É Importante
 	
💡 Eficiência do DesenvolvedorNão é necessário copiar/colar ou implantar contratos idênticos para diferentes aplicativos ou fragmentos. Os contratos globais são reutilizáveis por design, assim como as bibliotecas NPM ou Cargo na Web2.

 	
🔄 Componibilidade em EscalaIsso aproxima o NEAR de uma arquitetura "tipo Lego", onde os contratos inteligentes se encaixam perfeitamente, independentemente de onde são implantados.

 	
⚡ Cross-Shard FacilitadoOs contratos globais se tornam "serviços públicos" para todos os fragmentos, reduzindo significativamente a complexidade da comunicação entre fragmentos e a reutilização lógica.

 	
🛡️ Previsibilidade e ConfiançaPor serem imutáveis e amplamente utilizados, esses contratos evoluem para padrões de nível de protocolo, incentivando as melhores práticas e facilitando a auditabilidade.

 	
🔌 Padronização do EcossistemaPermite padrões em toda a rede para coisas como tokens fungíveis, módulos de identidade, ferramentas de DAO e muito mais - sem mais versões fragmentadas ou incompatíveis da mesma lógica.





🔧 Casos de Uso Ideais
 	
📚 Bibliotecas PadrãoComponentes reutilizáveis para operações matemáticas, de string ou interfaces de token.

 	
💱 Protocolos DeFiContratos globais podem ancorar DEXs, mercados de empréstimos, oráculos—compartilhados entre todas as aplicações.

 	
🗳 Frameworks de DAOMódulos de governança compartilhados que qualquer DAO pode conectar, garantindo consistência e confiabilidade.

 	
🆔 Identidade e CredenciaisUm contrato global pode gerenciar verificação de identidade descentralizada e gestão de acesso para toda a cadeia.

 	
🧩 dApps Multi-partesAplicações complexas podem dividir responsabilidades entre shards enquanto acessam um núcleo lógico comum.





⚠️ O Que Precisa Ser Resolvido (Mas Não é um Impedimento)
 	
🧭 Governança


 	
Quem implementa e mantém esses contratos? Idealmente, por meio de propostas revisadas pela comunidade ou processos endossados pela NEAR Foundation.

 	
Solução potencial: DAOs nativas da NEAR ou sistemas de aprovação baseados em staking para contratos globais críticos.



 	
🔐 Escopo de Segurança


 	
Global = alto impacto. Vulnerabilidades aqui afetam uma superfície maior.

 	
Mitigação: Verificação formal e imutabilidade forçada fornecem garantias sólidas.



 	
🔄 Caminho de Atualização


 	
Como os contratos são imutáveis, grandes atualizações requerem a implementação de novas versões.

 	
Solução: Utilizar padrões de design de proxy ou modulares—já comuns em Solidity—para preservar o estado e permitir atualizações suaves.







🧠 Pensamentos Finais: Um Passo Audacioso em Direção a uma NEAR Modular e Escalável
Os contratos globais não são apenas um recurso; eles são um bloco de construção fundamental para a próxima era do desenvolvimento blockchain na NEAR. Ao remover limitações baseadas em contas e permitir lógica verdadeiramente compartilhada, o NEP-0591 transforma a NEAR em um protocolo de composabilidade em primeiro lugar, em pé de igualdade ou até mesmo superando Ethereum e Polkadot em design modular.
Se adotado e implementado corretamente, isso poderia ser um marco importante no roadmap da NEAR para se tornar a cadeia preferida para dApps, DAOs e protocolos DeFi componíveis. É uma evolução audaciosa, mas necessária—e que torna a NEAR um lar mais atraente para construtores sérios.

### Contrato Global: Una Nueva Capa de Composabilidad en NEAR

El Protocolo NEAR ya se encuentra entre las blockchains más amigables para los desarrolladores y de mejor rendimiento, diseñado para la escalabilidad a través de sharding. Sin embargo, los desarrolladores enfrentan fricciones al necesitar desplegar la misma lógica de contrato en múltiples shards o cuentas. NEP-0591, que introduce Contratos Globales, es una propuesta altamente estratégica que resuelve esto de manera elegante.

En lugar de desplegar contratos duplicados o enrutar mensajes de manera ineficiente a través de shards, los desarrolladores de NEAR ahora pueden pensar de manera modular y universal: escribir una vez, usar en todas partes. Los contratos globales no son solo una conveniencia técnica, representan un cambio fundamental en cómo la lógica compartida, los protocolos y estándares pueden ser integrados en todo el ecosistema NEAR.

🔍 ¿Qué hace especial a los Contratos Globales?
 	
🔗 Dirección Global


 	
Estos contratos no están vinculados a una cuenta específica, sino que utilizan un identificador global único. Esto permite que cualquier contrato, usuario o aplicación en NEAR llame al contrato desde cualquier fragmento al instante.



 	
🧱 Lógica Inmutable


 	
El código del contrato es fijo una vez desplegado, convirtiéndose en un punto de referencia confiable. Esto garantiza consistencia y seguridad, ideal para protocolos críticos del sistema.



 	
🤝 Infraestructura Compartida


 	
Los contratos globales pueden actuar como bibliotecas canónicas, centros de utilidad o estándares en los que otros contratos pueden confiar, simplificando el desarrollo y reduciendo la duplicación.



 	
🌉 Superpoderes Transfragmento


 	
Los desarrolladores pueden construir aplicaciones verdaderamente modulares donde partes de su pila residen en diferentes fragmentos pero se comunican a través de lógica global compartida con una latencia o duplicación mínima.







✅ Las Ventajas - Por Qué Esto Es Importante
 	
💡 Eficiencia del DesarrolladorNo es necesario copiar/pegar o implementar contratos idénticos para diferentes aplicaciones o fragmentos. Los contratos globales son reutilizables por diseño, al igual que las bibliotecas NPM o Cargo en Web2.

 	
🔄 Composabilidad a EscalaEsto acerca a NEAR a una arquitectura tipo "Lego", donde los contratos inteligentes se unen perfectamente, independientemente de dónde se implementen.

 	
⚡ Facilitando la Comunicación entre FragmentosLos contratos globales se convierten en "servicios públicos" para todos los fragmentos, reduciendo en gran medida la complejidad de la comunicación entre fragmentos y la reutilización lógica.

 	
🛡️ Previsibilidad y ConfianzaAl ser inmutables y ampliamente utilizados, estos contratos se convierten en estándares a nivel de protocolo, fomentando las mejores prácticas y facilitando la auditabilidad.

 	
🔌 Estandarización del EcosistemaPermite estándares en toda la red para cosas como tokens fungibles, módulos de identidad, herramientas de DAO y más, sin más versiones fragmentadas o incompatibles de la misma lógica.





🔧 Casos de Uso Ideales
 	
📚 Bibliotecas EstándarComponentes reutilizables para operaciones matemáticas, de cadenas o interfaces de tokens.

 	
💱 Protocolos DeFiContratos globales que pueden anclar DEXs, mercados de préstamos, oráculos, compartidos entre todas las aplicaciones.

 	
🗳 Marcos de DAOMódulos de gobernanza compartidos a los que cualquier DAO puede conectarse, garantizando consistencia y confiabilidad.

 	
🆔 Identidad y CredencialesUn contrato global puede gestionar la verificación de identidad descentralizada y el acceso para toda la cadena.

 	
🧩 Aplicaciones descentralizadas de varias partesLas aplicaciones complejas pueden dividir responsabilidades entre fragmentos mientras acceden a un núcleo lógico común.





⚠️ Lo que Necesita Ser Resuelto (Pero No Es un Obstáculo)
 	
🧭 Gobernanza


 	
¿Quién despliega y mantiene estos contratos? Idealmente, a través de propuestas revisadas por la comunidad o procesos respaldados por la Fundación NEAR.

 	
Solución potencial: DAOs nativos de NEAR o sistemas de aprobación basados en staking para contratos globales críticos.



 	
🔐 Alcance de Seguridad


 	
Global = alto impacto. Las vulnerabilidades aquí afectan una superficie más grande.

 	
Mitigación: La verificación formal y la inmutabilidad forzada ofrecen garantías sólidas.



 	
🔄 Rutas de Actualización


 	
Dado que los contratos son inmutables, las actualizaciones importantes requieren desplegar nuevas versiones.

 	
Solución: Utilizar patrones de diseño de proxy o modulares, ya comunes en Solidity, para preservar el estado y permitir una actualización suave.







🧠 Pensamientos Finales: Un Paso Audaz Hacia un NEAR Modular y Escalable
Los contratos globales no son solo una característica; son un bloque de construcción fundamental para la próxima era del desarrollo blockchain en NEAR. Al eliminar las limitaciones basadas en cuentas y habilitar una lógica verdaderamente compartida, NEP-0591 transforma NEAR en un protocolo de composabilidad primero, a la par o incluso superando a Ethereum y Polkadot en diseño modular.
Si se adopta e implementa correctamente, esto podría ser un hito clave en la hoja de ruta de NEAR para convertirse en la cadena preferida para dApps, DAOs y protocolos DeFi componibles. Es una evolución audaz pero necesaria, y que hace de NEAR un hogar más atractivo para constructores serios.

### Hợp đồng Toàn cầu: Một Tầng Mới của Khả năng Tương tác trên NEAR

NEAR Protocol hiện đã nằm trong số các blockchain thân thiện với nhà phát triển và hiệu suất cao nhất, được thiết kế để mở rộng thông qua sharding. Tuy nhiên, nhà phát triển gặp sự cản trở khi cần triển khai cùng logic hợp đồng trên nhiều shard hoặc tài khoản. NEP-0591, giới thiệu Hợp Đồng Toàn Cầu, là một đề xuất chiến lược cao cấp giải quyết vấn đề này một cách tinh tế.
Thay vì triển khai các hợp đồng trùng lặp hoặc định tuyến tin nhắn một cách không hiệu quả qua các shard, nhà phát triển NEAR giờ đây có thể suy nghĩ một cách modul và toàn cầu: viết một lần, sử dụng ở mọi nơi. Hợp đồng toàn cầu không chỉ là một tiện ích kỹ thuật—chúng đại diện cho một sự chuyển đổi cơ bản trong cách logic chia sẻ, giao thức và tiêu chuẩn có thể được nhúng vào toàn bộ hệ sinh thái NEAR.



🔍 Điều Gì Làm Cho Hợp Đồng Toàn Cầu Đặc Biệt?
 	
🔗 Địa chỉ Toàn cầu


 	
Những hợp đồng này không liên kết với một tài khoản cụ thể mà thay vào đó sử dụng một bộ nhận dạng toàn cầu duy nhất. Điều này cho phép bất kỳ hợp đồng, người dùng hoặc ứng dụng nào trên NEAR gọi hợp đồng từ bất kỳ shard nào ngay lập tức.



 	
🧱 Logic Bất biến


 	
Mã hợp đồng được cố định sau khi triển khai, tạo thành một điểm tham chiếu đáng tin cậy. Điều này đảm bảo tính nhất quán và an ninh—lý tưởng cho các giao thức quan trọng cho hệ thống.



 	
🤝 Cơ sở hạ tầng Chia sẻ


 	
Các hợp đồng toàn cầu có thể hoạt động như thư viện chuẩn, trung tâm tiện ích hoặc tiêu chuẩn mà các hợp đồng khác có thể dựa vào, giúp đơn giản hóa quá trình phát triển và giảm thiểu sự trùng lặp.



 	
🌉 Sức mạnh Liên Shard


 	
Nhà phát triển có thể xây dựng các ứng dụng thực sự modular nơi các phần của hệ thống của họ đặt trên các shard khác nhau nhưng giao tiếp thông qua logic toàn cầu chung với độ trễ hoặc sự trùng lặp tối thiểu.







✅ Các Ưu điểm – Tại sao Điều Này Quan Trọng
 	
💡 Hiệu suất phát triểnKhông cần sao chép/dán hoặc triển khai các hợp đồng giống nhau cho các ứng dụng hoặc mảnh. Các hợp đồng toàn cầu có thể tái sử dụng theo thiết kế, giống như thư viện NPM hoặc Cargo trong Web2.

 	
🔄 Khả năng kết hợp ở quy mô lớnĐiều này đưa NEAR gần hơn với một kiến trúc "giống như Lego", nơi các hợp đồng thông minh snap cùng nhau một cách mượt mà—bất kể chúng được triển khai ở đâu.

 	
⚡ Dễ dàng Cross-ShardCác hợp đồng toàn cầu trở thành "dịch vụ công cộng" cho tất cả các mảnh, giảm đáng kể sự phức tạp của giao tiếp giữa các mảnh và tái sử dụng logic.

 	
🛡️ Dự đoán và Tin cậyBằng cách bất biến và được sử dụng rộng rãi, các hợp đồng này tiến triển thành tiêu chuẩn cấp giao thức, khuyến khích các phương pháp tốt nhất và làm cho việc kiểm toán dễ dàng hơn.

 	
🔌 Tiêu chuẩn Hệ sinh tháiCho phép tiêu chuẩn trên toàn mạng cho các thứ như token thay thế, mô-đun danh tính, công cụ DAO, và nhiều hơn nữa—không còn phiên bản logic phân mảnh hoặc không tương thích.





🔧 Các Trường hợp Sử dụng Lý tưởng
 	
📚 Thư viện Tiêu ChuẩnCác thành phần có thể tái sử dụng cho các phép toán toán học, chuỗi hoặc giao diện token.

 	
💱 Giao Thức DeFiCác hợp đồng toàn cầu có thể kết nối DEXs, thị trường cho vay, oracles—được chia sẻ trên tất cả các ứng dụng.

 	
🗳 Khung DAOCác mô-đun quản trị chung mà bất kỳ DAO nào cũng có thể kết nối vào, đảm bảo tính nhất quán và đáng tin cậy.

 	
🆔 Danh Tính & ThẻMột hợp đồng toàn cầu có thể quản lý xác minh danh tính phi tập trung và quản lý truy cập cho toàn bộ chuỗi.

 	
🧩 Ứng Dụng đa phầnCác ứng dụng phức tạp có thể chia trách nhiệm qua các mảnh trong khi truy cập vào một lõi logic chung.





⚠️ Những Vấn Đề Cần Giải Quyết (Nhưng Không Phải Là Vấn Đề Lớn)
 	
🧭 Quản trị


 	
Ai triển khai và duy trì các hợp đồng này? Lý tưởng nhất là thông qua các đề xuất được xem xét bởi cộng đồng hoặc các quy trình được NEAR Foundation ủng hộ.

 	
Giải pháp tiềm năng: DAOs gốc NEAR hoặc hệ thống phê duyệt dựa trên staking cho các hợp đồng toàn cầu quan trọng.



 	
🔐 Phạm vi Bảo mật


 	
Toàn cầu = tác động lớn. Những lỗ hổng ở đây ảnh hưởng đến một diện tích lớn hơn.

 	
Giảm thiểu: Xác minh chính thức và tính không thay đổi bắt buộc mang lại các cam kết mạnh mẽ.



 	
🔄 Đường dẫn Nâng cấp


 	
Do các hợp đồng không thể thay đổi, các nâng cấp lớn yêu cầu triển khai các phiên bản mới.

 	
Giải pháp: Sử dụng mẫu thiết kế proxy hoặc modular—đã phổ biến trong Solidity—để bảo tồn trạng thái và cho phép nâng cấp mềm dẻo.







🧠 Nhận xét Cuối cùng: Một Bước Đột Phá Hướng tới Một NEAR Linh hoạt, Mở rộng
Các hợp đồng toàn cầu không chỉ là một tính năng; chúng là khối xây dựng cốt lõi cho thời kỳ tiếp theo của phát triển blockchain trên NEAR. Bằng cách loại bỏ các hạn chế dựa trên tài khoản và cho phép logic thực sự được chia sẻ, NEP-0591 biến NEAR thành một giao thức ưu tiên tính khả dụng, ngang bằng hoặc thậm chí vượt qua Ethereum và Polkadot trong thiết kế modular.
Nếu được chấp nhận và triển khai đúng cách, điều này có thể là một cột mốc quan trọng trong lộ trình của NEAR để trở thành chuỗi lựa chọn cho các ứng dụng phi tập trung, DAOs và giao thức DeFi có thể kết hợp. Đó là một sự tiến hóa táo bạo nhưng cần thiết—và làm cho NEAR trở thành một nơi lý tưởng hơn cho những người xây dựng nghiêm túc.

### NEAR Makes Blockchain Instant: Final in 1.2 Seconds, Changing Everything

In a digital economy where every millisecond matters, NEAR Protocol’s recent upgrade represents a generational leap in blockchain infrastructure. The rollout of 600ms block times and 1.2-second finality isn’t just a technical milestone—it’s a signal that Web3 is stepping into real-time territory, unlocking high-speed, composable applications for both human and machine users.




🚀 What Did NEAR Just Achieve?
1. 600 Millisecond Block Production
This means:


 	
A new block is produced every 0.6 seconds.

 	
Transactions get included in the chain in near-real-time.

 	
Reduces latency for any dApp, smart contract, or AI agent.


Compare that with:


 	
Solana: Takes 1.6 seconds for block confirmation.

 	
Ethereum L2s: Need at least 12 seconds for optimistic inclusion.


This is 2x–20x faster than competitors with stronger guarantees.

2. 1.2 Second Finality
“Finality” is the point after which a transaction cannot be reversed without slashing someone’s stake (i.e., serious consequences).


 	
NEAR’s Doomslug consensus enables this by marking a block as final when it’s built upon.

 	
Combined with optimistic blocks, shards no longer wait on each other—cutting time nearly in half.


In contrast:


 	
Solana requires 4 blocks (~10s) for strong finality.

 	
Ethereum L2s rely on L1 Ethereum finality (~13 minutes in optimistic rollups, longer in zk-rollups).



Takeaway: NEAR isn’t just fast—it’s securely fast.




🔧 What Enabled This Leap?
🧱 Optimistic Blocks (Nightshade 2.0)

 	
Allows shards to process transactions before the parent block is finalized.

 	
“Optimistic” means assuming success unless proven otherwise—similar to optimistic rollups but within the L1 itself.

 	
Doubles the throughput of sharded chains by minimizing cross-shard coordination latency.


⛓️ Doomslug Consensus

 	
Provides one-block finality under normal network conditions.

 	
Malicious rollbacks are economically punishable (slashable).

 	
Think of it as Ethereum’s “finality” but within seconds, not epochs.





🤖 Why This Matters for Developers and AI Agents
1. Real-Time Composability

 	
Multi-step transactions can finalize in ~1.2s.

 	
You can chain DeFi trades, game logic, or supply chain updates without delay.


2. Autonomous Agents

 	
AI agents (think: on-chain chatbots, robotic market makers, or predictive oracles) can act and receive feedback in real-time.

 	
Enables true on-chain automation loops that were impossible before due to latency.


3. Seamless User Experience

 	
No more designing around slow confirmations.

 	
Users get instant feedback and execution.

 	
No need to explain “why your transaction is pending.”





🆚 NEAR vs Other Chains: No More Tradeoffs?
Blockchain development has long been constrained by the blockchain trilemma: balancing speed, security, and decentralization. Here's why NEAR's architecture may actually break the triangle:

✅ Speed:

 	
Faster than Solana with stronger guarantees.

 	
Leaves L2s and Ethereum in the dust.


✅ Security:

 	
Doomslug + Nightshade ensure economic finality.

 	
Sharded validators with slashing create real deterrents.


✅ Scalability:

 	
Dynamic sharding ensures sustainable throughput as usage grows.

 	
Unlike Solana (monolithic), NEAR can parallelize state changes.





🧪 What Could This Enable?
Think beyond dApps. Here’s what becomes practical now:


 	
Autonomous DAOs that respond instantly to market conditions.

 	
Decentralized social media with live user updates and composable reactions.

 	
Real-time gaming where player actions sync across chain with no lag.

 	
Flashbot-less DeFi with latency arbitrage disappearing.

 	
AI agents that react to or trigger events across blockchains via bridges.





🔭 What's Coming Next?
NEAR hinted at even faster block times (~200ms) by end of 2025. If that happens:


 	
It will enter real-time system territory (e.g., low-latency trading, robotics, IoT).

 	
Combined with zk-bridges or chain abstraction, NEAR could act as a real-time execution layer for the entire multichain ecosystem.





✅ Pros and Cons of NEAR’s Update
Pros:

 	
Unmatched speed: Best real-world finality numbers in Web3 today.

 	
Secure execution: Finality via Doomslug means actual guarantees.

 	
Better dev UX: No need to design around confirmations.

 	
Scalable by design: Nightshade sharding evolves with demand.

 	
AI and real-time ready: Ideal for future of autonomous apps.


Cons:

 	
Still early in tooling: Dev ecosystem not as mature as Ethereum or Solana.

 	
Bridge risk: Composability with other chains still depends on secure interoperability layers.

 	
Market perception: NEAR’s performance isn’t yet widely recognized or priced in.

 	
Latency-sensitive edge cases: While finality is fast, inbound/outbound bridge txs could bottleneck multi-chain AI flows.





💡 Unasked but Crucial: Strategic Implications

 	
Multichain Execution Hubs: NEAR could act as the low-latency execution backend for zkRollups or DA apps on other L1s.

 	
AI + Crypto Fusion: Real-time agents (think auto-finance bots, autonomous warehouses) need NEAR’s level of finality to be viable.

 	
DeFi Redesign: Low-latency chains can eliminate traditional front-running protection assumptions (e.g., MEV minimization may need revisiting).

 	
Latency Arbitrage: Builders on slower chains may lose to NEAR-native dApps simply due to physical execution speed.





🔚 Final Word
NEAR’s latest update isn’t just an optimization—it's a paradigm shift. For the first time, developers don’t need to choose between fast, secure, and scalable—they get all three. In an era where AI agents will transact, reason, and learn on-chain, NEAR is arguably the only L1 built to handle this next-generation load in real-time.

### Verifiable & Responsible AI, in Plain English

Artificial intelligence now writes essays, predicts diseases, and approves bank loans. That’s amazing—until a model hallucinates or someone tweaks data to game the result. When we can’t audit how an AI reached its answer, trust evaporates. Verifiable & Responsible AI flips that script: every prediction ships with cryptographic proof that it was produced by the approved model, on authentic data, in a tamper‑proof environment.




Everyday Problems It Can Fix

 	
Healthcare – A radiology AI says “no tumor.” Verifiable AI lets doctors (and regulators) check a cryptographic receipt showing the model, version, and untouched scan used.

 	
Education – Exam scores generated by an AI grader come with verifiable proof of fair scoring criteria, ending “black‑box” complaints.

 	
Data Integrity – Suppliers submit metrics to a procurement AI; buyers get a proof that no one swapped numbers after the fact.





How NEAR Makes It Work

 	
Private ML SDK – NEAR’s open‑source toolkit runs models inside Intel TDX CPUs and NVIDIA TEEs, shielding raw data from prying eyes.

 	
On‑Chain Proofs – After inference, the enclave issues a cryptographic attestation. That proof—and only the minimal proof—can be anchored on NEAR’s blockchain so anyone can audit integrity later.

 	
NEAR Account System – Every action (uploading data, calling the model, publishing a result) is signed by a human‑readable NEAR account like alice.near. These signatures, plus access‑key permissions, create an immutable provenance trail tying who did what to every AI decision.





Why “Responsible” Too?
Privacy and accountability are two sides of the same coin. By locking data in TEEs, users keep ownership. By publishing proofs on-chain, society gets transparency. And by linking actions to NEAR accounts, we know which human or service is responsible if something goes wrong.




The Takeaway
Verifiable & Responsible AI doesn’t ask you to “just trust the algorithm.” It proves its work—privately, cryptographically, and immutably—thanks to NEAR’s Private ML SDK and account‑based provenance. That’s the foundation we need for safe AI in medicine, learning, and every data‑driven decision that really matters.

### Global Contract: A New Layer of Composability on NEAR

The NEAR Protocol is already among the most developer-friendly and performant blockchains, designed for scalability via sharding. Yet, developers face friction when needing to deploy the same contract logic across multiple shards or accounts. NEP-0591, which introduces Global Contracts, is a highly strategic proposal that solves this elegantly.
Rather than deploying duplicate contracts or routing messages inefficiently across shards, NEAR developers can now think modularly and universally: write once, use everywhere. Global contracts aren't just a technical convenience—they represent a fundamental shift in how shared logic, protocols, and standards can be embedded across the NEAR ecosystem.




Update (August 2025):Global Contracts are now live on the NEAR Protocol with the release of version 2.7.0 of its core software. This is a major upgrade that allows developers to create smart contracts that can be used across many apps without having to rewrite or redeploy them each time. Think of it like how your phone uses shared apps—developers can now build reusable, standard pieces of logic that any NEAR app can plug into. This makes development faster, more secure, and more consistent. It also paves the way for open-source libraries and plug-and-play financial or gaming features, much like app stores or software modules in traditional tech. For users, this means better apps with fewer bugs and faster innovation. For the NEAR ecosystem, it's a step toward becoming a more composable and developer-friendly blockchain.

🔍 What Makes Global Contracts Special?

 	
🔗 Global Addressing


 	
These contracts are not tied to a specific account but instead use a unique global identifier. This enables any contract, user, or application on NEAR to call the contract from any shard instantly.



 	
🧱 Immutable Logic


 	
The contract code is fixed once deployed, making it a trusted point of reference. This ensures consistency and security—ideal for system-critical protocols.



 	
🤝 Shared Infrastructure


 	
Global contracts can act as canonical libraries, utility hubs, or standards for other contracts to rely on, simplifying development and reducing duplication.



 	
🌉 Cross-Shard Superpowers


 	
Developers can build truly modular apps where parts of their stack reside on different shards but communicate via shared global logic with minimal latency or duplication.







✅ The Advantages – Why This Is a Big Deal

 	
💡 Developer EfficiencyNo need to copy/paste or deploy identical contracts for different apps or shards. Global contracts are reusable by design, just like NPM or Cargo libraries in Web2.

 	
🔄 Composability at ScaleThis brings NEAR closer to a “Lego-like” architecture, where smart contracts snap together seamlessly—regardless of where they're deployed.

 	
⚡ Cross-Shard Made EasyGlobal contracts become “public services” for all shards, massively reducing the complexity of cross-shard communication and logic reuse.

 	
🛡️ Predictability and TrustBy being immutable and widely used, these contracts evolve into protocol-level standards, encouraging best practices and making auditability easier.

 	
🔌 Ecosystem StandardizationEnables network-wide standards for things like fungible tokens, identity modules, DAO tooling, and more—no more fragmented or incompatible versions of the same logic.





🔧 Ideal Use Cases

 	
📚 Standard LibrariesReusable components for math, string operations, or token interfaces.

 	
💱 DeFi ProtocolsGlobal contracts can anchor DEXs, lending markets, oracles—shared across all applications.

 	
🗳 DAO FrameworksShared governance modules that any DAO can plug into, ensuring consistency and reliability.

 	
🆔 Identity & CredentialsOne global contract can manage decentralized identity verification and access management for the entire chain.

 	
🧩 Multi-part dAppsComplex applications can split responsibilities across shards while accessing a common logic core.


👩‍💻🔧 Real life examples of Global Contract in prod

 	Intear Smart Wallet Contract
A versatile smart contract deployed for all Intear Wallet accounts, enabling users to securely manage their wallets with advanced recovery features. The wallet integrates extensible recovery methods, allowing users to link Ethereum-compatible (EVM) or Solana wallets as backup authentication sources. Through validated signatures from these linked wallets, users can regain full access to their accounts in cases of lost keys or compromised access. Future expansions will include support for social authentication (e.g., Google) and decentralized social recovery (trusted friend groups). However, users should exercise caution, as the contract has not yet undergone a formal security audit.
Github 




⚠️ What Needs to Be Solved (But Isn’t a Dealbreaker)

 	
🧭 Governance


 	
Who deploys and maintains these contracts? Ideally, through community-reviewed proposals or NEAR Foundation-endorsed processes.

 	
Potential solution: NEAR-native DAOs or staking-based approval systems for critical global contracts.



 	
🔐 Security Scope


 	
Global = high impact. Vulnerabilities here affect a larger surface.

 	
Mitigation: Formal verification and enforced immutability give strong guarantees.



 	
🔄 Upgrade Pathing


 	
Since contracts are immutable, major upgrades require deploying new versions.

 	
Solution: Use proxy or modular design patterns—already common in Solidity—to preserve state and allow soft upgradability.







🧠 Final Thoughts: A Bold Step Toward a Modular, Scalable NEAR
Global contracts are not just a feature; they’re a core building block for the next era of blockchain development on NEAR. By removing account-based limitations and enabling truly shared logic, NEP-0591 transforms NEAR into a composability-first protocol, on par with or even exceeding Ethereum and Polkadot in modular design.
If adopted and implemented properly, this could be a key milestone in NEAR’s roadmap to becoming the go-to chain for composable dApps, DAOs, and DeFi protocols. It’s a bold but necessary evolution—and one that makes NEAR a more attractive home for serious builders.

### Securely Running a Crypto Wallet MCP Server with Phala Cloud

Crypto isn't just about owning coins—it's also about securely managing and automating crypto services. If you're building or running an app that interacts with blockchains (like automated trades or portfolio management), you're likely using a Crypto Wallet MCP Server. But hosting it safely is tricky. That's exactly where Phala Cloud shines.




🔍 What is a Crypto Wallet MCP Server?
An MCP (Model Context Protocol) server is a backend service that securely handles blockchain interactions—like managing transactions, balances, or signing operations. Developers and businesses use MCP servers to automate secure crypto operations behind the scenes.
But traditional servers expose your MCP server and private keys to potential risks like hacks and data breaches. The solution? Phala Cloud.




🛡️ Phala Cloud: Next-Level Security for MCP Servers
Phala Cloud provides specialized servers that run inside something called a Trusted Execution Environment (TEE). Imagine a digital fortress built directly inside the computer’s CPU, isolating your sensitive data completely—even from the host machine.

Why use Phala for your MCP server?


 	
✅ Unbreakable Security: Your MCP server runs entirely encrypted inside a TEE, making it practically immune to hacks or theft.

 	
✅ Confidential Computing: Sensitive information like private keys never leave the secure TEE environment.

 	
✅ Easy & Verifiable Setup: You can quickly verify and prove your server runs securely with built-in attestation tools.





⚙️ Simple Setup in 4 Steps
Deploying your MCP server securely on Phala Cloud is easy:

1. Sign Up & Launch

 	
Go to Phala Cloud and register (new users get free credits!).

 	
Deploy a Confidential Virtual Machine (CVM) with Docker in a few clicks.


2. Deploy the MCP Server

 	
Choose your MCP server software (e.g., the Docker image tolak/near-mcp-server) and quickly deploy it within the CVM.


3. Secure Your Keys

 	
Safely enter your MCP server’s crypto wallet keys as encrypted secrets—Phala ensures they're never exposed externally.


4. Verify & Integrate

 	
Use Phala’s built-in attestation to confirm your MCP server runs securely in the TEE.

 	
Connect the MCP server securely to your apps, bots, or AI tools.





🎯 Real-Life Uses: Why It Matters

 	
Automated Crypto Applications: Run crypto trading bots or payment services without fear of compromising keys.

 	
AI Integration: Safely integrate blockchain operations with advanced AI tools.

 	
Compliance & Trust: Easily prove to users, auditors, or business partners that your crypto operations are secure.





🌟 The Bottom Line
With Phala Cloud, your Crypto Wallet MCP Server runs securely, privately, and confidently. You focus on building powerful crypto services—Phala Cloud handles the rest.
👉 Get started: Deploy securely on Phala Cloud today!

### What is Lantstool?

Lantstool is an open-source, client-side development interface purpose-built for the NEAR blockchain. It enables developers to manage transactions, work with cryptographic keys, interact with RPC endpoints, and inspect account details—all within a single, streamlined interface.



 




Feature
Description




Platform
Web-based UI for NEAR Protocol


Primary Features
Transactions, key management, RPC access, utilities, account insights


Security Model
Fully non-custodial; local browser storage only


Current Version
v1.3.0 (Released April 28, 2025)


Repository
GitHub – ui.web.lantstool


Live Interface
app.lantstool.dev








🔍 Core Capabilities
🧱 1. Transaction and Call Builder
Lantstool allows developers to create, preview, save, and reuse transactions and contract calls. These can be exported/imported in JSON, making them versionable and shareable for team workflows.

🔐 2. Key and Account Management
A built-in key generator lets you create cryptographic key pairs directly in the browser. Keys are stored securely in local storage, separated by workspace and network to ensure proper isolation.

🌐 3. RPC Access and API Testing
Lantstool serves as a graphical frontend for NEAR RPC endpoints. Developers can issue view and change function calls, test contracts, or simulate transactions—all without touching the command line.

📊 4. Real-Time Account Insights
The platform retrieves detailed information about NEAR accounts: balance, state usage, storage costs, access keys, and associated contracts. This provides a full diagnostic view of an account’s structure.

🔧 5. Utility Toolbox
Lantstool includes several auxiliary tools:


 	
Unit Converter – Easily switch between yoctoNEAR, NEAR, and other denominations.

 	
Contract WASM Downloader – Download deployed smart contracts in raw WebAssembly format.

 	
Account Cleaner Tool – Clean up large accounts or remove specific state items when standard deletion fails.





✨ New in Version 1.3.0
Lantstool's latest update (v1.3.0) introduces notable improvements:


 	
Account Cleaner UtilityLets users surgically remove state, access keys, or contracts—especially useful for unblocking accounts with storage bloat.

 	
Dedicated Utility PagesEach tool now lives on a distinct page, and the app remembers your last active tab for a smoother dev experience.

 	
Enhanced Key SeparationWorkspace- and network-based scoping of keys adds clarity and avoids cross-contamination.

 	
Streamlined UX and Bug FixesDozens of subtle enhancements make this release more intuitive and polished.


Explore the full release notes for technical details.




🧠 Ideal Use Cases

 	
Developers needing a graphical smart contract playground.

 	
Educators demonstrating how NEAR works in a classroom or workshop.

 	
QA teams looking for a rapid way to simulate or debug contract behavior.

 	
Anyone who prefers full control of their keys without using custodial wallets.





🔗 Try Lantstool Today

 	
🔗 Live Demo: app.lantstool.dev

 	
📦 Source Code: GitHub - ui.web.lantstool

 	
🎥 Overview Video:

https://www.youtube.com/watch?v=84OlJric7lk


Whether you’re just getting started with NEAR or are deep in production, Lantstool will radically accelerate your workflow while keeping you in full control.

### Xen  👀BugEye Sprint

Our friends Dapplets just launched user testing for @yourxenbot – and we’d love your help!
What is Xen?@yourxenbot is your personal AI assistant powered by your custom set of NEAR.AI agents. It acts as an orchestration engine, calling your favorite (⭐starred) NEAR.AI agents to process your requests.
Why try it?During testing, you’ll earn rewards in NEAR for every agent Xen calls on your behalf — and so will the agent’s creator. You’ll even be rewarded if your request causes an inference error!
How to start:


 	Go NEAR AI Hud agents registry https://app.near.ai/agents  login with NEAR account
 	Find useful agents and give them a ⭐
 	
Open @yourxenbot

 	
Log in with the same NEAR account

 	
Chat with Xen naturally, just like you would with a human
Xen will automatically call the most relevant agent. For example:


“Can you monitor Reddit for gardening tips?” → Xen will subscribe you to r/gardening.

If Xen misses a call you expected, just tell it explicitly.

 	Use /f to send feedback – and the most helpful feedback will be rewarded!

Let us know what you think. Your input means a lot!

### What Excites You Most About NEAR Protocol in 2025?

Learn about NEAR in 2025

                 
 
                        What Excites You Most About NEAR Protocol in 2025?(Required)
			
					
					NEAR AI
			
			
					
					NEAR Intents
			
			
					
					Perfect UX
			
			
					
					NEAR DeFi
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                


Please comment if you there is something else you excited

### Understanding Omni Bridge

In the rapidly evolving blockchain landscape, interoperability—the ability for different blockchain networks to communicate and share assets seamlessly—remains a significant challenge. NEAR Protocol's Omni Bridge addresses this by providing a secure and efficient multi-chain asset transfer solution. ​

Understanding Omni Bridge
Omni Bridge is a multi-chain asset bridge developed by NEAR Protocol to facilitate secure and efficient asset transfers between various blockchain networks. It overcomes key challenges in cross-chain communication by leveraging Chain Signatures and a decentralized Multi-Party Computation (MPC) service, enabling trustless cross-chain asset transfers. ​

How Omni Bridge Works
Traditional cross-chain bridges often rely on light clients—smart contracts that allow one blockchain to verify events on another. However, implementing light clients can be complex and resource-intensive. Omni Bridge introduces a more streamlined approach using Chain Signatures. Instead of running light clients on each destination chain, it utilizes Chain Signatures' MPC service to enable secure cross-chain message verification without the overhead of light client verification. This innovation reduces verification times from hours to minutes and significantly lowers gas costs across supported chains.
The core components of Omni Bridge include:​


 	
Deterministic Address Derivation: Every NEAR account can mathematically derive addresses on other chains through specific derivation paths, ensuring consistent control across supported chains.​

 	
Bridge Smart Contract: A central contract on NEAR coordinates with the MPC network to generate secure signatures for cross-chain transactions, handling token locking and signature requests for outbound transfers.

 	
MPC Service: A decentralized network of nodes jointly signs transactions without reconstructing a full private key, ensuring that no single node can create valid signatures alone. ​


Supported Chains
Omni Bridge employs a hybrid architecture, utilizing different verification methods based on chain-specific requirements and technical constraints. This approach allows support for multiple chains from the outset, with plans to transition to full Chain Signatures integration. The initial launch includes support for:​


 	
Ethereum: Light client + Chain Signature

 	
Bitcoin: Light client + Chain Signatures​

 	
Solana: Currently Wormhole, transitioning to Chain Signatures​

 	
Base: Currently Wormhole, transitioning to Chain Signatures​We

 	
Arbitrum: Currently Wormhole, transitioning to Chain Signatures


Implementation Details
At the heart of Omni Bridge is the Bridge Token Factory contract on NEAR, serving as both a token factory and custodian. This unified contract manages both native tokens from the source chain and bridged tokens created by the factory itself, simplifying maintenance and reducing complexity. For bridged tokens, it deploys new token contracts upon first bridging, mints tokens upon receiving valid transfer messages, and burns tokens when initiating transfers back to the origin chain. For native NEAR tokens, it acts as a custodian by locking tokens during transfers and releasing them upon receiving valid transfer messages, managing token operations through the NEP-141 standard. ​

Benefits of Omni Bridge
Omni Bridge offers several advantages


 	
Efficiency: By reducing verification times and lowering gas costs, it enhances the speed and affordability of cross-chain transactions.​

 	
Security: Utilizing Chain Signatures and MPC ensures a trustless and decentralized approach to asset transfers

 	
Scalability: Its hybrid architecture allows for the support of multiple blockchain networks, with the flexibility to integrate additional chains over time.​

 	
Simplicity: The Bridge Token Factory pattern streamlines the management of native and bridged tokens, reducing operational complexity.​


Conclusion
NEAR Protocol's Omni Bridge represents a significant advancement in blockchain interoperability, addressing the complexities of cross-chain asset transfers with a secure, efficient, and scalable solution. By leveraging innovative technologies like Chain Signatures and MPC, Omni Bridge paves the way for a more interconnected and seamless blockchain ecosystem.​
For a more in-depth understanding of Omni Bridge's functionality, you can watch the following presentation:​

### HOT Wallet: Secure NEAR Wallets for Telegram and Web

In the rapidly evolving world of cryptocurrency, managing digital assets securely and efficiently is paramount. HOT Labs addresses this need by offering two innovative solutions: the HOT Wallet and the HOT Wallet Extension. These tools provide users with versatile options for managing their crypto holdings, whether within Telegram or through web browsers.​

HOT Wallet: Seamless Crypto Management in Telegram
The HOT Wallet is a non-custodial, multi-chain cryptocurrency wallet integrated directly into Telegram. This integration allows users to manage and grow their crypto assets without leaving the Telegram environment. Key features of the HOT Wallet include:


 	
Self-Custody Control: Users retain full control over their funds, with no personal information required. Private keys are stored locally on the user's device, ensuring that only the user has access to their assets.

 	
Multi-Chain Access: The wallet supports interaction with various blockchains, including TON, Solana, TRON, NEAR, and EVM-compatible networks. This broad compatibility enables users to manage a diverse portfolio of digital assets.

 	
Integrated Trading Tools: HOT Wallet offers built-in features for trading, swapping, bridging assets, and accessing analytics. Users can participate in staking, missions, and swap contests, with rewards sent directly to their wallets.​

 	
Enhanced Security Measures: The wallet employs Multi-Party Computation (MPC) technology, on-device storage, and offers options for two-factor authentication (2FA) and password protection, providing users with peace of mind regarding the safety of their assets.​


By integrating directly with Telegram, HOT Wallet transforms the messaging app into a dynamic crypto management tool, allowing users to connect with decentralized applications (dApps), receive in-chat updates, and manage their assets seamlessly.

HOT Wallet Extension: Bridging the Gap to Web-Based dApps
The browser extension connects your MPC wallet to any web dApp. With NEAR support baked in, you can sign NEAR transactions, interact with NEAR‑native DeFi platforms, and authorize Intents‑based one‑click swaps straight from your browser - no extra plug‑ins required.
Empowering Users with HOT Protocol
Both the HOT Wallet and its browser extension are built on the HOT Protocol, an open protocol for creating decentralized MPC wallets. This protocol enhances security by distributing private key data across multiple independent validators, ensuring that no single entity has full control. Features enabled by the HOT Protocol include:


 	
Seed Phrase Replacement: Users can change their seed phrases, enhancing security and facilitating the transfer of wallet ownership along with its reputation and tokens.

 	
Two-Factor Authentication (2FA): The protocol supports flexible access systems, allowing users to set up 2FA via SMS or email for transaction signing.​

 	
Cross-Chain Gas Payments: With HOT Relay, users can perform transactions on any supported network and pay for gas fees using HOT tokens, simplifying the transaction process across different blockchains.​


By leveraging the HOT Protocol, HOT Labs provides users with secure, user-friendly tools for managing their cryptocurrency assets across multiple platforms and blockchain networks. ​

Why It Matters for NEAR Users
By bringing MPC security, cross‑chain gas abstraction, and Telegram’s massive reach to NEAR Protocol, HOT Labs lowers the barrier for anyone who wants to explore NEAR DeFi, NFTs, or Intents‑powered swaps. Whether you’re chatting in Telegram or browsing dApps, you keep the same secure wallet, enjoy NEAR’s low‑fee, fast‑finality network, and never give up custody of your keys.
In summary, HOT Labs' offerings - the HOT Wallet and HOT Wallet Extension -  equip users with powerful, secure, and versatile tools for navigating the cryptocurrency landscape, whether within Telegram or through web-based applications.
HOT Wallet is now live on mobile!
Download on iOS https://apps.apple.com/us/app/hot-wallet/id6740916148
 Download on Android https://play.google.com/store/apps/details?id=app.herewallet.hot&pcampaignid=web_share

### NEAR Protocol Expands Mainnet from 6 to 8 Shards: A Technical Milestone

On March 19 2025 NEAR Protocol has successfully completed an important upgrade to its mainnet, expanding from 6 to 8 shards.  So now there are 8 shards! While the 33% capacity improvement is valuable, the technical achievements behind this upgrade represent significant progress toward NEAR's scalability goals.

Revolutionary Resharding Approach
The most notable technical advancement in this upgrade is the implementation of single-block resharding. Previously, NEAR's resharding process required validator nodes to build the entire state of new shards from scratch—a time-consuming process that could take an hour to complete. This approach became impractical after the Nightshade 2.0 launch introduced stateless validation to the protocol.
Instead of the old method, NEAR's new resharding technique works by splitting the state trie of a shard along a boundary and computing two new state roots in logarithmic time (O(log n)). The state witness for this transition is also logarithmic in size, making it small enough for validators to verify efficiently. Most importantly, this entire process happens within a single block time.
This advancement brings NEAR significantly closer to achieving dynamic resharding—a capability where shards would automatically split on demand in response to network needs, all within a very short timeframe.

Multi-Shard Splitting Capabilities
Another key aspect of this upgrade was the simultaneous splitting of two shards. Though this might seem like a minor detail, it demonstrates NEAR's ability to increase the number of shards rapidly when needed. If limited to splitting just one shard at a time, scaling to the targeted 50 shards would be a much lengthier process.

Looking Ahead
The successful implementation of this upgrade represents substantial engineering work from the NEAR team. With these technological foundations in place, NEAR Protocol is well-positioned to continue expanding its shard count in the coming months, further enhancing the network's scalability and throughput.
The smooth execution of this upgrade demonstrates NEAR's technical maturity and brings the protocol one step closer to its vision of a highly scalable blockchain infrastructure.

### Sharded Smart Contracts: The Future of Blockchain Scalability

Blockchain technology has revolutionized numerous industries with its decentralized and secure approach to data management. However, as adoption grows, traditional blockchain architectures face significant scaling challenges. Sharded contracts represent one of the most promising solutions to these limitations, offering a path to truly scalable decentralized applications.

The Fundamental Problem: Blockchain Scalability
Traditional non-sharded blockchains like Bitcoin and Ethereum (pre-2.0) operate on a simple but limiting principle: every node in the network processes the same transactions and maintains an identical copy of the entire state. While this approach maximizes security and decentralization, it creates an inherent bottleneck.
Adding more nodes to such networks doesn't improve performance—it simply reinforces the existing consensus model. This leads to two critical problems:


 	Limited Throughput: The network can only process as many transactions as a single chain can handle.
 	State Growth: As the blockchain grows, the state becomes increasingly unwieldy for nodes to maintain.

Sharding: The First Step Toward Scalability
Sharding divides the blockchain network into smaller partitions called "shards." Each shard functions as its own mini-blockchain with its own set of validators who process transactions specific to that shard. This creates parallel processing capability that can scale linearly with the number of shards.
In NEAR's implementation, rather than each shard maintaining a separate chain (which creates complex fork management issues), there's only one main chain. Each block on this chain contains "chunks" from every shard, simplifying security and cross-shard communication.
Sharding effectively addresses both throughput limitations and state growth concerns by distributing the network's workload and state across multiple partitions. However, there's a critical limitation that standard sharding alone doesn't solve.

The Overlooked Challenge: Smart Contract Limitations
While sharding solves many scalability issues, it introduces a new challenge: what happens when a single smart contract becomes extremely popular and grows very large?
Consider popular DeFi applications like Uniswap or consumer applications with millions of users. These contracts store massive amounts of data and handle high transaction volumes. In a standard sharded environment, each smart contract must reside on a specific shard, meaning:


 	The contract's throughput is limited by the capacity of a single shard
 	The contract's state can grow to unmanageable sizes within that shard

This creates a bottleneck that undermines the benefits of sharding for the most successful applications—precisely those that need scalability the most.

Sharded Smart Contracts: The Solution
Sharded smart contracts elegantly solve this problem by fundamentally changing how contracts exist and store data on the blockchain. A sharded contract:


 	Exists simultaneously across all shards through global contract code
 	Stores user data on individual user accounts rather than in the contract's own storage

How It Works: Global Contract Code
Instead of deploying a contract to a specific account, global contract code is deployed to a special state that's available on all shards simultaneously. This deployment:


 	Generates receipts that propagate to every shard
 	Updates a global contract state on each shard
 	Is intentionally expensive to prevent spam/attacks

Other users can then reference this globally deployed code without redeploying it themselves, creating an efficient system for code reuse across the network.

How It Works: User Account Storage
The second critical innovation is changing where contract data is stored. Instead of maintaining a centralized mapping of user data within the contract account, data is stored within namespaces on the users' own accounts.
For example, in a traditional USDT contract:


 	The USDT account stores a mapping of all users to their balances
 	All operations must interact with this central account

In a sharded USDT contract:


 	Each user account contains a "usdt.near" namespace
 	This namespace stores the user's USDT balance
 	Transfers happen directly between user accounts via cross-shard communication


This reverses the traditional storage model, transforming one massive storage problem into many small, distributed storage operations that naturally benefit from sharding.

Benefits of Sharded Smart Contracts
This architectural shift delivers several crucial advantages:


 	Linear Scalability: Contract throughput scales with the number of shards, just as the overall network does
 	Manageable State Growth: No single account needs to store enormous amounts of data
 	Natural Distribution: User data is automatically distributed according to the network's existing sharding boundaries
 	Complete Scalability Solution: Addresses both throughput and state growth concerns holistically


Implementation Status
NEAR is currently building this solution in two phases:


 	Global contract code - LIVE on NEAR mainmet
 	User account storage for contract data (currently in development)

Together, these components will make sharding a complete solution to blockchain scaling problems, handling both throughput limitations and state growth challenges.
Watch full talk "From Sharded Blockchain to Sharded Smart Contract" by Bowen Wang, NEAR One founder
https://www.youtube.com/watch?v=cG-JyJYj6LY
Conclusion
Sharded smart contracts represent a significant leap forward in blockchain scalability technology. By tackling the often-overlooked challenge of large contract scaling, they remove one of the final barriers to truly scalable decentralized applications. As this technology matures and becomes widely available, it will enable blockchain applications to support user bases in the millions or even billions without sacrificing performance or decentralization.
For developers building high-scale applications on blockchain, sharded contracts offer a pathway to unlimited growth potential without the traditional constraints of blockchain architecture.

### Understanding NEAR SDK for Python: A Comprehensive Guide

Introduction
The NEAR Protocol has emerged as a significant player in the blockchain space, offering a developer-friendly platform for building decentralized applications (dApps). While NEAR has traditionally supported JavaScript/TypeScript and Rust for smart contract development, the introduction of the Python SDK opens up new possibilities for Python developers to join the blockchain ecosystem.

This guide explores the NEAR SDK for Python (near-sdk-py), a toolkit that allows developers to write smart contracts for the NEAR blockchain using Python. By leveraging the familiarity and accessibility of Python, this SDK lowers the barrier to entry for blockchain development and expands NEAR's developer community.
What is NEAR Protocol?
Before diving into the SDK, let's understand what NEAR Protocol is:

NEAR is a layer-1 blockchain designed for usability and scalability. It uses a Proof-of-Stake consensus mechanism and implements sharding (called "Nightshade") to achieve high transaction throughput. NEAR aims to make blockchain more accessible to developers and end-users alike with features like human-readable account names and developer-friendly tools.
Bridging AI and Blockchain: Python as the Common Language
The NEAR SDK for Python creates a strategic bridge for AI developers to enter the blockchain space. With Python firmly established as the dominant language in machine learning—powering TensorFlow, PyTorch, and scikit-learn—this SDK eliminates the need for AI specialists to learn entirely new programming paradigms.
This familiarity enables AI developers to build smart contracts that integrate machine learning capabilities directly on-chain. Examples include deploying prediction markets with statistical models or creating privacy-preserving recommendation systems. Rather than wrestling with unfamiliar language constructs, developers can focus on the innovative aspects of blockchain integration.
As decentralized AI grows in importance, this SDK becomes essential for building trustless AI systems where model parameters, data access rights, and inference processes are managed through smart contracts. This convergence of AI expertise and blockchain capabilities through Python has the potential to accelerate innovation at this technological intersection.

The NEAR SDK for Python: Overview
The near-sdk-py repository provides Python developers with the tools needed to write, test, and deploy smart contracts on the NEAR blockchain. It serves as a bridge between Python's simplicity and NEAR's blockchain capabilities.
Key Components of near-sdk-py
Based on exploration of the repository, the SDK includes:

 	Core Contract Framework: Functions and decorators for defining smart contracts
 	Storage Management: Tools for handling persistent storage on the blockchain
 	Types and Collections: Specialized data structures for blockchain operations
 	Testing Utilities: Frameworks for testing contracts before deployment
 	Build Tools: Mechanisms to compile Python contracts to WebAssembly for the NEAR runtime

Getting Started with near-sdk-py
Installation
To start using the NEAR SDK for Python, you'll need to set up your development environment:
pip install near-sdk-py

Additionally, you'll need the NEAR CLI to interact with contracts on the blockchain:
npm install -g near-cli

Project Structure
A typical NEAR Python project might have the following structure:
my-near-project/
├── contract/
│   ├── __init__.py
│   └── contract.py   # Main contract code
├── tests/
│   ├── __init__.py
│   └── test_contract.py
├── build.sh          # Build script
└── README.md

Writing Your First Smart Contract
Let's examine how to write a simple smart contract using the NEAR SDK for Python:
from near_sdk import near, json, AccountId, NearConfig, Balance

# Initialize the contract with a decorator
@near.contract(config=NearConfig)
class MyFirstContract:
    def __init__(self):
        # Initialize contract state
        self.owner_id = near.predecessor_account_id()
        self.message = "Hello, NEAR!"

    # Define a view method to read state
    @near.view
    def get_message(self) -> str:
        return self.message

    # Define a change method to modify state
    @near.call
    def set_message(self, new_message: str) -> str:
        # Only the owner can change the message
        assert near.predecessor_account_id() == self.owner_id, "Only the owner can change the message"
        old_message = self.message
        self.message = new_message
        return f"Message changed from '{old_message}' to '{new_message}'"

    # Define a payable method
    @near.payable
    def donate(self) -> str:
        # Record the donation amount
        amount = near.attached_deposit()
        return f"Thank you for donating {amount} yoctoNEAR!"

Key Concepts in the Code:

 	Contract Decorator: @near.contract marks the class as a NEAR smart contract.
 	View Methods: Functions marked with @near.view read contract state without modifying it.
 	Call Methods: Functions marked with @near.call can modify contract state.
 	Payable Methods: Functions marked with @near.payable can receive NEAR tokens.
 	Contract Context: Functions like near.predecessor_account_id() provide blockchain context.

Core Concepts in NEAR Python Development
State and Storage
One of the fundamental aspects of smart contracts is managing state. In the NEAR Python SDK, there are several ways to handle persistent storage:
from near_sdk import near, PersistentMap, PersistentVector, PersistentUnorderedMap

@near.contract
class StorageExample:
    def __init__(self):
        # Different types of persistent collections
        self.map = PersistentMap(b"m", key_type=str, value_type=int)
        self.vector = PersistentVector(b"v", element_type=str)
        self.unordered_map = PersistentUnorderedMap(b"u", key_type=str, value_type=str)

The SDK provides specialized collection types that automatically handle the serialization and deserialization of data to and from blockchain storage.
Cross-Contract Calls
Smart contracts often need to interact with other contracts. The NEAR Python SDK facilitates this with asynchronous calls:
@near.call
def call_another_contract(self, contract_id: str, message: str) -> None:
    # Create a promise to call another contract
    promise = near.promise_create(
        contract_id,
        "set_message",
        json.dumps({"new_message": message}).encode(),
        0,  # No attached deposit
        near.prepaid_gas() // 2  # Use half of the remaining gas
    )

    # Return the promise to process the result
    return near.promise_return(promise)

Testing Smart Contracts
The SDK provides utilities for testing contracts before deployment:
from near_sdk.testing import VMContext, setup_context

def test_get_message():
    # Set up a test context
    context = VMContext(
        current_account_id="contract.near",
        signer_account_id="alice.near",
        predecessor_account_id="alice.near",
        attached_deposit=0,
        account_balance=1000000
    )
    setup_context(context)

    # Initialize the contract
    contract = MyFirstContract()

    # Test the view method
    assert contract.get_message() == "Hello, NEAR!"

Advanced Features
Function Call Permissions
NEAR has a robust permission system for contract calls:
@near.call(is_private=True)
def private_method(self) -> str:
    # This method can only be called by the contract itself
    return "This is private"

@near.call(can_be_called_by=["user.near", "admin.near"])
def restricted_method(self) -> str:
    # This method can only be called by specific accounts
    return "Access granted"

Handling NEAR Tokens
Working with tokens is common in blockchain applications:
@near.payable
def process_payment(self, product_id: str) -> str:
    # Get the amount of tokens attached to the call
    payment = near.attached_deposit()

    # Check if payment is sufficient
    price = self.products[product_id]
    assert payment >= price, f"Insufficient payment, required {price}"

    # Process the order
    if payment > price:
        # Refund excess payment
        refund = payment - price
        near.promise_create(
            near.predecessor_account_id(),
            "deposit", 
            b"{}",
            refund,
            near.prepaid_gas() // 10
        )

    return "Order processed successfully"

Deploying Your Contract
After writing and testing your contract, you'll need to compile it to WebAssembly and deploy it to the NEAR blockchain:
# Build the contract
./build.sh

# Deploy to NEAR testnet
near deploy --accountId mycontract.testnet --wasmFile build/contract.wasm

Interacting with Your Contract
Once deployed, you can interact with your contract using the NEAR CLI:
# Call a view method
near view mycontract.testnet get_message

# Call a change method
near call mycontract.testnet set_message '{"new_message": "Hello, World!"}' --accountId myaccount.testnet

# Call a payable method with attached NEAR
near call mycontract.testnet donate --amount 1 --accountId myaccount.testnet

Best Practices for NEAR Python Development

 	Use Type Hints: Python's type hints improve code quality and help catch errors early.
 	Prioritize Gas Efficiency: Blockchain operations cost gas, so optimize your code for efficiency.
 	Handle Errors Gracefully: Use assertions and error handling to make contracts robust.
 	Test Thoroughly: Extensive testing is crucial before deploying contracts to the mainnet.
 	Implement Security Measures: Always validate inputs and implement proper access controls.
 	Document Your Code: Clear documentation helps others understand your contract's purpose and functionality.

Comparison with Other NEAR SDKs



Feature
near-sdk-py
near-sdk-js
near-sdk-rs




Language
Python
JavaScript/TypeScript
Rust


Learning Curve
Low
Medium
High


Performance
Good
Good
Excellent


Ecosystem Maturity
Emerging
Established
Established


Type Safety
Optional
Optional (TS)
Strong



Conclusion
The NEAR SDK for Python represents a significant step toward making blockchain development more accessible. By leveraging Python's simplicity and readability, developers can more easily create and deploy smart contracts on the NEAR blockchain.

Whether you're building a simple token contract or a complex decentralized application, the Python SDK provides the tools needed to bring your ideas to life on the NEAR Protocol. As the ecosystem continues to grow, Python developers will play an increasingly important role in shaping the future of decentralized applications.

### Step-by-step guide to creating and minting NEAR subaccounts using NameSky

Now you can create and mint a NEAR subaccount as an NFT in one seamless step!

 	No manual setup
 	No extra steps
 	Trade & secure unique NEAR identities instantly

So let's L(E)arn on how to do that in today's guide!
What is a NEAR subaccount?
On NEAR, accounts are human-readable — unlike the long cryptographic addresses on other blockchains. NEAR uses a hierarchical account model:

 	Main accounts (like yourname.near) can create subaccounts (like nft.yourname.near).
 	Subaccounts are useful for projects, DAOs, or organizing identities under a parent account.
 	These subaccounts can be minted as NFTs and traded on platforms like NameSky!
 	Independence: A subaccount is a completely separate account on NEAR. The parent account cannot control or manage the subaccount’s funds or actions.
1 main account can create almost unlimited subaccounts, but each operates independently.

How to mint your NEAR subaccount NFT on NameSky
Follow these simple steps to create and mint your subaccount as an NFT:
1. Import your NEAR account

 	Go to NameSky and click Choose NEAR Account.
 	Import via MyNearWallet, Passphrase/Private Key, or create a new account.

2. Create a subaccount


 	Select Create SubAccount And Import.
 	Enter your desired subaccount name (like lnc.meteorkent.near).
 	Click Create SubAccount And Import.
 	Accept the tx on your NEAR wallet.

3. Confirm minting

 	Review the minting and storage fees (e.g., 0.2 NEAR mint fee and 0.15 NEAR storage fee).
 	Click Complete Mint -> Hit Confirm Mint -> Accept transaction on your NEAR wallet


4. Success! 

 	Your new subaccount NFT is minted and ready to be traded or used.
 	Click View NFT to check out your newly minted subaccount.


Optional: Redeem the account and use it as a regular NEAR account!
Go to your account profile → select Take NEAR account back → back up your 12-word seed phrase → press Continue — and you’re done! You can now use the subaccount like a regular NEAR wallet.

Now you can use the subaccount as a normal NEAR wallet!


Why is this only possible on NEAR?
Because NEAR has a powerful built-in account model (a.k.a better account abstraction) that have:

 	Built-in Naming System – NEAR natively supports human-readable names instead of cryptographic addresses.
 	Hierarchical Ownership – Main accounts can create and manage unlimited subaccounts, perfect for branding, projects, and NFT identities.
 	Seamless Trading & Minting – Since subaccounts are real NEAR accounts, they can be minted and traded as NFTs, making them uniquely ownable, transferable, and secure.
 	Independent Subaccounts – A subaccount is a completely separate account on NEAR. The parent account cannot control or manage the subaccount’s funds or actions. This means 1 main account can create almost unlimited subaccounts, but each operates independently.

💡 Fun fact: Most NEAR addresses end with .near — that's because they are actually subaccounts of the top-level account: NEAR! There are other top-level domain account like: .aurora - The Aurora virtual EVM, .sweat - Sweatcoin , .tg - HOT wallet, and many mores!

Ready to secure your unique NEAR identity? Head to NameSky and mint your subaccount today! 🚀


                
                        
                            
                         
 
                        Have you eve created NEAR subaccount?(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### FastNEAR: Supercharging NEAR Protocol with Lightning-Fast Infrastructure

FastNEAR is a high-performance infrastructure platform designed to enhance interactions with the NEAR Protocol blockchain. By offering a suite of services, FastNEAR enables developers to build faster, scale further, and innovate with confidence.
Key Services:


 	
NEAR RPC: Provides enterprise-grade infrastructure with faster query responses, increased reliability, enhanced security features, and customizable configurations.

 	
NEARDATA: Offers free access to indexed blockchain data from both mainnet and testnet, requiring no authentication and featuring an efficient caching system.

 	
Ultra-Fast API: Delivers low-latency APIs optimized for wallets and explorers, supporting functionalities like account ID mapping, delegated staking pool information, token data retrieval, and top holder analytics.

 	
Custom Indexer Solutions: Provides tailored database solutions, including dedicated data collection, customized reports and analytics, expert support, and scalable architecture.

 	
Explorer API: Enables comprehensive blockchain explorer infrastructure with access to transaction details, account information, block data, and receipt tracking.


Pricing Plans:


 	
Dev Plan: $69/month for 10 million RPC requests, shared RPC access, and basic support.
Business Plan: $499/month for 100 million RPC requests, dedicated RPC node, and priority support.
Enterprise Plan: Custom pricing for unlimited RPC requests, multiple dedicated nodes, and 24/7 support.


Team:


 	
Evgeny Kuzyakov, Co-founder & CTO: Formerly with Proximity, NEAR Protocol, Google, and Facebook; founder of NEAR.social.
Mike Purvis, Head of Infrastructure: Early NEAR ecosystem contributor with extensive blockchain infrastructure experience; former web3 startup founder.
Vlad Grichina, Chief Duct Tape Officer: Pioneer in NEAR ecosystem development tools and wallet infrastructure; previously at Human Guild, NEAR, and Google.

FastNEAR is committed to building the future of NEAR Protocol infrastructure, empowering developers with the tools they need to succeed.

### Introducing RHEA Finance

In a groundbreaking move within the decentralized finance (DeFi) sector, two of NEAR Protocol's premier platforms—Ref Finance and Burrow Finance—have merged to form Rhea Finance. This strategic consolidation aims to address the prevalent issue of fragmentation in DeFi by offering a unified, chain-abstracted liquidity solution that caters to a diverse range of users, from Bitcoin holders to Ethereum Virtual Machine (EVM) users and meme coin traders.

The Rationale Behind the Merger
The DeFi landscape has been characterized by a multitude of platforms, each offering distinct services such as token swaps, lending, and yield optimization. This diversity often necessitates users to navigate multiple chains, platforms, and wallets to manage their assets effectively. Recognizing this challenge, Ref Finance, NEAR's leading decentralized exchange (DEX), and Burrow Finance, its top lending protocol, have united their strengths to create Rhea Finance. This merger is designed to streamline user experiences by providing a single platform that integrates various DeFi services, thereby enhancing efficiency and accessibility.

Key Features of Rhea Finance

 	
Unified Liquidity Hub: Rhea Finance consolidates liquidity across multiple blockchain ecosystems, including NEAR, Bitcoin, and EVM-compatible networks. This integration facilitates seamless asset movement and trading, reducing the complexities associated with cross-chain transactions.
Satoshi Ramp: One of the standout features of Rhea Finance is the Satoshi Ramp, which offers the fastest Bitcoin on/off-ramp in the market. This functionality enables users to integrate BTC into NEAR's DeFi ecosystem effortlessly, opening up new yield opportunities and access to enhanced liquidity.
Enhanced Tokenomics: The merger introduces a revamped token structure. The existing tokens, $REF and $BRRR, will be consolidated into a primary token, $RHEA. Additionally, two utility tokens, $xRHEA and $oRHEA, will be launched to enhance governance mechanisms and foster active ecosystem participation.


Implications for the DeFi Ecosystem
The creation of Rhea Finance signifies a pivotal shift towards more integrated and efficient DeFi solutions. By addressing the fragmentation that has long hindered user experiences, Rhea Finance sets a new standard for interoperability and user-centric design in the DeFi space. This merger not only simplifies access to liquidity and financial services but also paves the way for future innovations that can further democratize access to decentralized financial systems.
As the DeFi landscape continues to evolve, the establishment of Rhea Finance exemplifies the potential of strategic collaborations in driving the industry forward. By leveraging the combined strengths of Ref Finance and Burrow Finance, Rhea Finance is poised to become a cornerstone of the NEAR ecosystem and a catalyst for broader DeFi adoption.
For more information, visit Rhea Finance's official website.

### What is your favorite NEAR Wallet 2025?

What is the best NEAR wallet?(Required)
			
					
					HOT wallet
			
			
					
					INTEAR wallet
			
			
					
					Meteor wallet
			
			
					
					My NEAR Wallet
			
			
					
					HERE Wallet
			
			
					
					Ethereum wallet
			
			
					
					Bitte wallet
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                


Please comment if you there is any of your favorite wallets missing

### Update – February 25, 2025

Brief Summary:

 	
🤖NEAR is blockchain for AI and learning🕺


Results:

 	
Introducing (L)Earn AI agent on NEAR AI


 	📚(L)Earn in 2024🕺



 	🔬4th  NanoQuiz🕺 for exclusively 🔥Hot wallet users is LIVE
https://t.me/herewalletbot/app?startapp=web-tg-learnnear-club


 	Ethereum users can Start (L)Earning about NEAR with your favorite wallet Metamask!
 	
NEAR Intents: A Guide for Users and Developers

 	
An Introduction to Analyzing NEAR Data on Dune


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	🕺(L)Earn AI is to be gradually improved!

### Private Personalized AI agent with XTrace

What is an AI agent?
An AI agent is an autonomous software entity designed to perform tasks by perceiving its environment, processing information, and taking actions to achieve specific goals. An AI agent typically comprises three core components:

 	Intelligence: The large language model (LLM) that drives the agent’s cognitive capabilities, enabling it to understand and generate human-like text. This component is usually guided by a system prompt that defines the agent’s goals and the constraints it must follow.
 	Knowledge: The domain-specific expertise and data that the agent leverages to make informed decisions and take action. Agents utilize this knowledge base as context, drawing on past experiences and relevant data to guide their choices.
 	Tools: A suite of specialized tools that extend the agent’s abilities, allowing it to efficiently handle a variety of tasks. These tools can include API calls, executable code, or other services that enable the agent to complete its assigned tasks.




	

	
	
		
			
				What are the three core components of an AI agent?
			
		

		
					

		
			
			
			
			Intelligence, Data, and Programming
		
			
			Intelligence, Knowledge, and Tools
		
			
			LLM, Vector Database, and API
		
			
			System Prompt, Context, and Execution
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What is RAG?
Retrieval-Augmented Generation (RAG) is an AI technique that enhances large language models (LLMs) by integrating relevant information from external knowledge bases. Through semantic similarity calculations, RAG retrieves document chunks from a vector database, where these documents are stored as vector representations. This process reduces the generation of factually incorrect content, significantly improving the reliability of LLM outputs.\cite{RAG}

A RAG system consists of two core components: the vector database and the retriever. The vector database holds document chunks in vector form, while the retriever calculates semantic similarity between these chunks and user queries. The more similar a chunk is to the query, the more relevant it is considered, and it is then included as context for the LLM. This setup allows RAG to dynamically update an LLM’s knowledge base without the need for retraining, effectively addressing knowledge gaps in the model’s training data.

The RAG pipeline operates by augmenting a user’s prompt with the most relevant retrieved text. The retriever fetches the necessary information from the vector database and injects it into the prompt, providing the LLM with additional context. This process not only enhances the accuracy and relevance of responses but also makes RAG a crucial technology in enabling AI agents to work with real-time data, making them more adaptable and effective in practical applications.




	

	
	
		
			
				How does Retrieval-Augmented Generation (RAG) improve LLM responses?
			
		

		
					

		
			
			
			
			By retraining the model with new data
		
			
			By using blockchain to verify information
		
			
			By integrating relevant information from external knowledge bases through semantic similarity calculations
		
			
			By creating a collaborative network of AI agents
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What is Agent Memory?
AI agents, by default, are designed to remember only the current workflow, with their memory typically constrained by a maximum token limit. This means they can retain context temporarily within a session, but once the session ends or the token limit is reached, the context is lost. Achieving long-term memory across workflows—and sometimes even across different users or organizations—requires a more sophisticated approach. This involves explicitly committing important information to memory and retrieving it when needed.
Agent Memory with blockchain:
XTrace  - A Secure AI Agent Knowledge & Memory Protocol for Collective Intelligence - will leverage blockchain as the permission and integrity layer for agent memory, ensuring that only the agent’s owner has access to stored knowledge. Blockchain is especially useful for this long persistent storage as XTrace provides commitment proof for the integrity of both the data layer and integrity of the retrieval process. The agent memory will be securely stored within XTrace’s privacy-preserving RAG framework, enabling privacy, portability and sharability. This approach provides several key use cases:

Stateful Decentralized Autonomous Agents:

 	XTrace can act as a reliable data availability layer for autonomous agents operating within Trusted Execution Environments (TEEs). Even if a TEE instance goes offline or if users want to transfer knowledge acquired by the agents, they can seamlessly spawn new agents with the stored network, ensuring continuity and operational resilience.

XTrace Agent Collaborative Network:

 	XTrace enables AI agents to access and inherit knowledge from other agents within the network, fostering seamless collaboration and eliminating redundant processing. This shared memory system allows agents to collectively improve decision-making and problem-solving capabilities without compromising data ownership or privacy.

XTrace Agent Sandbox Test:

 	XTrace provides a secure sandbox environment for AI agent developers to safely test and deploy their agents. This sandbox acts as a honeypot to detect and mitigate prompt injection attacks before agents are deployed in real-world applications. Users can define AI guardrails within XTrace, such as restricting agents from mentioning competitor names, discussing political topics, or leaking sensitive key phrases. These guardrails can be enforced through smart contracts, allowing external parties to challenge the agents with potentially malicious prompts. If a prompt successfully bypasses the defined safeguards, the smart contract can trigger a bounty release, incentivizing adversarial testing. Unlike conventional approaches, XTrace agents retain memory of past attack attempts, enabling them to autonomously learn and adapt to new threats over time. Following the sandbox testing phase, agents carry forward a comprehensive memory of detected malicious prompts, enhancing their resilience against similar attacks in future deployments.

How to create a Personalized AI agent?
To create an AI agent with XTrace, there are three main steps to follow:

 	Define the Purpose: Determine the specific tasks and goals the agent will accomplish.
 	Choose the AI Model: Select a suitable LLM or other machine learning models that align with the agent's requirements.
 	Gather and Structure Knowledge: Collect domain-specific data and organize it in a way that the agent can efficiently use.
 	Develop Tools and Integrations: Incorporate APIs, databases, or other services that the agent may need to interact with.

How to create a Private Personalized AI agent with XTrace?
XTrace can serve as the data connection layer between the user and the AI agents. Users will be able to securely share data from various apps into the system to create an AI agent that is aware of the user’s system. By leveraging XTrace's encrypted storage and access control mechanisms, AI agents can be personalized without compromising user privacy. Key features include:

 	Seamless Data Integration: Aggregating data from multiple sources securely.
 	Granular Access Control: Ensuring only authorized AI agents can access specific data.
 	Privacy-Preserving Computation: Enabling AI agents to learn from user data without exposing it.
 	Automated Insights: Leveraging AI to provide personalized recommendations based on securely stored data.
 	User Ownership: Empowering users with full control over their data and how it is used.

How do we use XTrace private RAG for (L)Earn AI🕺?

 	We send learning materials in LLM friendly format to LNC RAG at XTrace

 	Once (L)Earn AI🕺 gets the question, first it talks to private RAG and retrieve relevant information

 	The LLM hosted at NEAR AI infrastructure generates a response based on both its pre-trained knowledge and the retrieved information!

 	Learners are encouraged to provide feedback and get 4nLEARNs to improve (L)Earn AI🕺 to work better for NEAR community!

### An Introduction to Analyzing NEAR Data on Dune

New to analyzing NEAR data and want to learn? Then you’re in the right place! Whether you’re a Dune veteran or just starting out this course will cover everything you need to know to get started analyzing the NEAR blockchain using Dune.

This guide is accompanied by a detailed video tutorial for those who prefer learning visually.

This course is for all levels:

 	If you are new to NEAR, spend some extra time on the beginning sections understanding how NEAR transactions, receipts, and sharding work. This will help set your foundation as we learn which tables to pull information from
 	If you are familiar with NEAR but new to Dune, focus on the ‘Getting Started with Dune’ section of the guide. Navigating the Dune UI and finding the right tables will make your learning journey smooth.
 	If you are familiar with both NEAR and Dune, feel free to dive right into the educational queries. We’ll cover beginner, intermediate, and advanced queries.

Overview of NEAR blockchain
NEAR is a layer one, sharded, proof-of-stake blockchain. That was a lot. So what does this all mean?‍

 	Sharding for Efficiency: NEAR employs sharding to split the network into parallel processing units to increase transaction speed and performance.‍
 	Proof-of-Stake Consensus: By using a proof-of-stake mechanism, NEAR minimizes energy consumption.

Advantages as an Analyst:

 	‍Human readable accounts/addresses:
‍NEAR uses human-readable account names like sector.near, instead of hexadecimal-encoded addresses such as 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 used on EVM (Ethereum Virtual Machine). You can think of this like using ENS names natively.
 	‍Native Account Abstraction
 User accounts can also be contracts! You also don’t always need your own gas to transact.
 	‍Raw data tables have human readable actions and logs on Dune!

How to quickly access Dune and its query engine
Here is a fantastic overview by Andrew Hong on how to navigate Dune and its query engine. Make sure you get familiar with the site before we begin writing any queries.
How to access NEAR specific tables
Once you’ve created a new query, NEAR tables are located in the Data Explorer on the left-hand side of the Dune interface. Here's how to find them:

 	Navigate to Data Explorer on the left menu.
 	Scroll down and click on "Raw Blockchain Data". This will display raw datasets for all chains supported by Dune.
 	Scroll down the list or use the search bar to type "NEAR".
 	Select NEAR from the list to access its datasets.

You should now see the page shown below, which contains all NEAR-specific tables.






	

	
	
		
			
				Where can you find NEAR-specific data tables in the Dune interface?
			
		

		
					

		
			
			
			
			Under the "near.transactions" section in the main dashboard
		
			
			In the Data Explorer under "Raw Blockchain Data" by selecting NEAR
		
			
			On the homepage of Dune under "Quick Access"
		
			
			In the Dune query editor under the "Pre-built Queries" tab
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Explanation of NEAR-specific data structures, terminology and flow
Transaction Structure in NEAR

 	A transaction is a high-level operation submitted by a user/account to interact with the blockchain.Note: Unlike many blockchains with a transactions table on Dune, NEAR does not have a near.transactions table. Instead, transaction-related data is captured in the near.actions table. This table breaks down transactions into their individual actions, with each row representing a unique action. So what are actions? I’m glad you asked.
 	An action is a discrete operation within a transaction that defines what the transaction aims to accomplish. A transaction can include multiple actions, such as transferring tokens or calling a smart contract. Here is the full list of available actions available:

 	CreateAccount
 	DeployContract
 	FunctionCall
 	Transfer
 	Stake
 	AddKey
 	DeleteKey
 	DeleteAccount
 	Delegate


 	These actions are grouped together within a single transaction and processed sequentially or asynchronously, depending on their complexity.
 	After a transaction is submitted and executed (via the ExecutionOutcome), it is converted into a series of one or more receipts. These receipts are used to process the actions specified in the transaction, enabling asynchronous execution. This structure is critical for cross-shard operations and can get quite complex. For now, all you need to know is that transactions are converted into receipts, which carry the necessary information to interact with smart contracts and execute the desired actions.
 	Finally, after a receipt is executed, logs are emitted by the smart contracts. We’ll be using near.logs on Dune to extract useful information.




	

	
	
		
			
				How does Dune represent NEAR transactions in its datasets?
			
		

		
					

		
			
					

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				How does Dune represent NEAR transactions in its datasets?
			
		

		
					

		
			
			
			
			As single entries in the near.transactions table
		
			
			Through individual actions stored in the near.actions table
		
			
			Using aggregated summaries in the near.summary table
		
			
			By storing only completed receipts in the near.receipts table
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







Optional Exercises
Ready to dive deeper and test your skills? Try your hand at analyzing the data with these exercises! Follow along with the accompanying video tutorial for this section. You can watch it here. The queries, along with additional metrics, are also available on this dashboard.
Basic Queries:
Intro to querying near.actions on Dune

 	Let's look at a transaction example:
‍dune.com/queries/4575420‍
 	How many successful transactions occurred on 2025-01-01?
Answer: dune.com/queries/4575423‍
 	How many times was each action_kind called on 2025-01-01?
Answer: dune.com/queries/4575426

Intermediate Queries
Let’s analyze the top DEX on NEAR: Ref.Finance

 	Find all 'simple pools' deployed on ref-finance
Answer: dune.com/queries/4575590‍
 	What are the weekly number of pools deployed? Deployers?
Answer: dune.com/queries/4575594‍
 	What is the most common 'simple pool' pair(tokenA-tokenB) deployed?
Answer: dune.com/queries/4575601‍
 	Bonus Questions: Find power users: Top 10 Pool Deployers

Advanced Queries

 	Find all swap on Ref.Finance after 2025-01-01
Answer: dune.com/queries/4575620
 	What was the daily number of swaps for all USDC/wNEAR pairs?
Answer: dune.com/queries/4575631‍
 	What was the daily swap volume for all USDC/wNEAR pair?
Answer: https://dune.com/queries/4575638

### BETTEAR Trading Bot: Your Gateway to Simplified Crypto Trading

Disclaimer: The information does not constitute financial advice or recommendation and should not be considered as such.
INTRODUCTION

Navigating the blockchain space can be intimidating, especially for beginners. But what if there was a tool that simplifies trading, eliminates common obstacles, and provides advanced features for all types of users? That’s exactly what the Bettear Bot offers.

This multi-purpose Telegram bot is designed for trading, project management, and wallet tracking within the NEAR ecosystem. Whether you’re a newbie, a veteran trader, or a project manager, Bettear Bot delivers a flawless experience.




	

	
	
		
			
				Which platform does the Bettear Bot primarily operate on?
			
		

		
					

		
			
			
			
			Discord
		
			
			Telegram
		
			
			X (formerly Twitter)
		
			
			Reddit
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






BRIEF ORIGIN OF BETTEAR BOT

Bettear Bot’s story began with a simple need. Slime, its creator, launched a meme coin and required a buybot. When existing options, like Nearobot, proved too expensive, he decided to build his own. What started as a basic bot evolved into a robust tool that powered the April-to-June meme season, eventually becoming a transformative tool for the NEAR ecosystem.

VISION & MISSION

Vision

To simplify blockchain interactions and trading, empowering every users, newbies and pros alike with uncomplicated tools to navigate the NEAR ecosystem and beyond effortlessly.

Mission

To create a user-friendly, efficient, and secure platform that bridges blockchain complexities, enhances trading experiences, and fosters adoption across diverse communities through innovative solutions.

WHY BETTEAR BOT IS PERFECT FOR NEWCOMERS

If you’re new to the NEAR blockchain, Bettear Bot is your perfect companion. Here's why:

 	Simple Trading Features: You can buy, sell, and manage tokens directly in Telegram without navigating complex platforms.
 	Price Alerts: Stay informed about token price changes and market trends without spending hours analyzing charts.
 	Notifications: Get real-time updates about your wallet activities, token movements, and new token launches to stay ahead.
 	User-Friendly Interface: Everything is straightforward, making it easy to use even if you’ve never traded before.
 	Depositing Tokens Made Easy: Send NEAR or other tokens to your bot wallet, and the bot automatically handles conversions and gas fees for you.

Bettear Bot removes the barriers that discourage newcomers and provides a smooth onboarding experience into the NEAR ecosystem.



FEATURES OVERVIEW

Trading Tools

 	Buy and Sell: Quickly purchase tokens or sell from your open positions with a few clicks.
 	DCA Strategy: Automate investments by buying or selling tokens at regular intervals.
 	Copytrading: Not sure where to start? Link your bot to a wallet, set a percentage to copy their trades, and let the bot execute the same actions for you.
 	Trigger Orders: Buy or sell when the price hits a specific level
 	Sniping: Quickly buy tokens at launch or when liquidity is added.




	

	
	
		
			
				Which feature allows users to mirror another wallet’s trades automatically?
			
		

		
					

		
			
			
			
			DCA Strategy
		
			
			Sniping
		
			
			Copy Trading
		
			
			Referral System
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Notifications

 	Swap Alerts: Know instantly when swaps occur for a token.
 	Price Alerts: Get notified of price changes based on your preferences.
 	New Token Launches: Be the first to know when new tokens are created on NEAR.
 	Wallet Tracking: Monitor wallet activities in real-time, including multiple wallets.

And six more types of alerts.



Multi-Chain Support

Bettear Bot started on NEAR but now supports trading on Solana. It’s a comprehensive tool for trading across multiple ecosystems, with plans to expand to more chains in the future.

Telegram Mini Explorer

Search and view blockchain data directly in Telegram. Share transaction links, token info, or account details without needing external sites like Nearblocks.



Referral System

Earn rewards by referring others to use the bot. Receive 15% of your referrals’ spending, which you can withdraw anytime.




	

	
	
		
			
				How can users earn rewards with Bettear Bot?
			
		

		
					

		
			
			
			
			By holding NEAR tokens
		
			
			Through staking rewards
		
			
			By referring others to the bot
		
			
			By participating in governance votes 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






UNIQUE SELLING POINT

One of the standout features of Bettear Bot is its all-in-one functionality. It combines multiple trading tools, notifications, and account management features into a single Telegram interface. This eliminates the need for multiple platforms, offering users an easy, fast, and secure trading experience.

Whether you're a beginner exploring NEAR or an experienced trader managing multiple accounts, the bot simplifies trading complexities while saving time and effort.

ROADMAP

 	NEAR AI Integration: Automate advanced AI workflows using AI.
 	Teardrops Feature: Allow users to send tokens like “@bettearbot drop 1 NEAR” directly in Telegram chats, even if the bot is not in the chat.
 	Discord Version: Expand bot functionality to Discord for wider adoption.
 	Additional Chain Support: Bring support for more chains in the future.

CONCLUSION

Bettear Bot isn’t just another trading tool it’s a complete solution for navigating the NEAR ecosystem and beyond. From trading and wallet management to notifications and multi-chain support, it simplifies the crypto journey for both beginners and experts.

If you’re new to the blockchain or looking for a reliable tool to streamline your trading, Bettear Bot is your ultimate option. Explore it today and transform your trading experience.

GRATITUDE

Thank you for taking the time to explore the Bettear Bot with us. We hope this article has been both informative and engaging, helping you better understand its features and potential. Whether you're new to the NEAR blockchain or a seasoned user, we believe the bot can enhance your journey. Your support and curiosity drive innovations like this forward. Happy trading.

After exploring Bettear Trading Bot, let’s see how well you’ve grasped its features, benefits, and future plans!

### NEAR AI에서 (L)Earn AI 에이전트를 소개합니다.

소개
아마도 이제 전화로 ChatGPT를 호출할 수 있다는 소식을 들었을 것입니다. 이것은 실제로 믿기 어려울 정도입니다. 멋지지만 누구와 대화를 나누게 될지 아시나요? 가장 좋은 방법은 서비스 제공업체 평판인 - OpenAI OpCo, LLC에 의존하는 것입니다.


현재 AI의 문제점

 	중앙집중화된 모델: GPT-4 또는 Claude와 같은 가장 널리 사용되는 모델은 폐쇄 소스이며 중앙집중화되어 있습니다.
 	중앙집중화된 인프라 의존: "오픈 소스" 모델조차도 Groq 또는 Together와 같은 중앙집중화된 플랫폼에서 실행됩니다 AI.
 	불투명한 운영: 에이전트가 작동하는 방식을 확인하는 것은 불가능합니다 - 프롬프트, 제한 사항 및 중지 목록을 포함하여.
 	데이터 개인 정보 보호 우려: 사용자는 자신의 데이터가 어떻게 처리되거나 저장되는지에 대해 거의 가시성이 없습니다.

이러한 도전은 책임 있는 AI 사용의 필요성을 강조하며 중요한 결정에 AI 에이전트를 의존할 때 주의를 기울여야 함을 강조합니다.
AI와 학습
AI에 의해 망가지기 전에 학교를 졸업한 경우 당신은 운이 좋습니다.

그러나 학습 기술, 비판적 사고, 추론 기술을 개발하지 않았거나 너무 어린 경우 또는 "도움이 되고 효율적인" AI 에이전트에 중독된 경우 무언가를 확인할 수 없는 상황이 될 수 있습니다. 이것은 심각한 문제가 될 수 있습니다. 계산기는 비싼, 제한된 도구로 시작되었지만 학교에 적응할 시간을 주었습니다. 지금은 AI가 교육을 즉시 변화시키고, 모든 과목에 영향을 미칩니다. 학생들은 AI로 부정행위를 할 것이지만 또한 그것을 자신의 작업에 통합하여 교육자들에게 도전을 제기하고 전통적인 과제의 타당성을 의심할 것입니다.
일반적으로 과제가 수업에서 완료되지 않으면 작업이 인간이 만든 것인지 신뢰할 수 없다는 것입니다.

확인 가능한 AI가 이를 바꿀 수 있습니다.


NEAR AI 허브
NEAR.AI가 해답입니다.
알파 단계에서 이미 시도할만한 흥미로운 기능이 몇 가지 제공됩니다. 시도해보면서 배우는 것에 비할 바 없습니다.

NEAR AI 연구 허브로 이동하십시오.

플랫폼과 상호 작용하려면 NEAR 계정으로 로그인할 수 있습니다. 에이전트 탭에서 레지스트리에 추가된 모든 에이전트를 찾을 수 있습니다 - 개인 및 암호화된 항목을 지원하는 분산 저장소.
Learn AI 에이전트 0.0.1을 찾아 확인해보세요.
NEAR Protocol에 대한 다음 텍스트를 번역합니다. 모든 용어는 NEAR Protocol과 관련이 있습니다. HTML 태그를 유지하지만 응답에서 , , , 와 같은 태그를 생성하지 마십시오. 'Burrow', 'NEAR', 'BRR', 'stNEAR' 등의 특정 이름이나 토큰을 번역하지 마십시오.:

NEAR AI 허브 내에서 에이전트와 대화할 수 있으며, 더 중요한 것은 에이전트의 출처를 탐색할 수 있다는 것입니다 - learn-agent.learnclub.near, 소스 코드, 프롬프트 및 불용어를 포함합니다. 또한, 필요한 경우 불용어를 제거하려면 그냥 복제하십시오. 그러나 이제 복제본을 당신이 책임져야 한다는 것을 인식하십시오!



이제 조금 더 깊이 파고들어 봅시다. 모델 탭으로 전환하십시오.


이미 50개 이상의 오픈 소스 모델이 사용 가능합니다. Learn AI가 NEAR AI 인프라에서 호스팅되는 특정 LLaMA를 사용 중임을 확인할 수 있습니다. 에이전트를 통해 모델과 상호 작용하기 위해 NEAR 계정을 사용하면 실제로 누구와 대화 중인지 알 수 있습니다!



NEAR AI는 1.4T 매개변수를 갖는 차세대 프론티어 AI 모델을 구축할 계획입니다! 오픈 소스 AI 개발을 사용료 지불 모델을 통해 지속 가능하게 만드는 것이 아이디어이며, 이것이 NEAR가 중요한 역할을 할 곳입니다.




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR AI가 어떻게 분산 방식으로 1.4T 매개변수, 수익화 모델을 구축할 것인가요? '신뢰할 수 있는 실행 환경' 또는 TEE의 세계로 들어가십시오.

현대 프로세서와 GPU(처음부터 H100s)는 한 배우자인 Alice가 다른 배우자인 Bob의 기계에서 코드를 실행할 수 있게 해줍니다. Bob을 신뢰하지 않고도 다음 두 가지 보장을 제공합니다: (a) Bob이 실제로 Alice가 기대한 코드를 실행하고 있으며, (b) Bob이 Alice가 수행하길 원하는 실행을 감시할 수 없습니다. 다시 말해, Alice는 이러한 계산에 어떤 개인 데이터를 안전하게 보낼 수 있으며, Bob이 그것을 볼 수 없을 것임을 확신할 수 있습니다.
결론
분산 NEAR AI 인프라는 사용자 소유 AI를 가능하게 하는 중요한 진전을 나타냅니다. 투명성, 제어 및 유연성을 제공함으로써 NEAR AI는 데이터 개인 정보 보호를 보장하고 신뢰를 유지하면서 사용자가 AI 에이전트와 상호 작용할 수 있도록 돕습니다.

NEAR의 선구자인 LNC는 실용적인 응용 프로그램을 위해 이 인프라를 활용하는 최전선에 있으며, 실시간 Learn AI 에이전트, 개발 중인 Lean NEAR Tutor 및 계획 중인 WooCommerce 쇼핑 에이전트를 포함한 이러한 응용 프로그램에 대한 인프라를 활용하고 있습니다.

학습자로서, 이 혁신적인 (L)Earn 생태계에 적극적으로 참여하십시오. (L)Earn AI에 관련된 질문을 하고, nLEARN으로 지불하고, 지식을 얻으며, AI의 개선에 기여함으로써 nLEARN을 얻으십시오.

 이 접근 방식은 학습과 수익을 긍정적인 합계 게임으로 결합하여 (L)Earn 개념에 더 깊고 풍부한 의미를 부여합니다.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Happy (L)Earning!🕺

### Представляем (L)Earn AI агента на NEAR AI

Введение
Вы наверняка слышали, что теперь вы можете позвонить ChatGPT по телефону. Это кажется нереальным. Это круто, но у вас есть представление, с кем вы будете разговаривать? Лучшее, что вы можете сделать, это полагаться на репутацию поставщика услуг - OpenAI OpCo, LLC.


Проблемы с текущим искусственным интеллектом

 	Централизованные модели: Большинство широко используемых моделей, таких как GPT-4 или Claude, являются закрытыми и централизованными.
 	Зависимость от централизованной инфраструктуры: Даже "открытые" модели часто работают на централизованных платформах, таких как Groq или Together AI.
 	Непрозрачные операции: Невозможно проверить, как работают агенты, включая подсказки, ограничения и списки остановки.
 	Проблемы конфиденциальности данных: Пользователи имеют мало представления о том, как обрабатываются или хранятся их данные.

Эти вызовы подчеркивают необходимость ответственного использования искусственного интеллекта и осторожности при полагании на искусственные интеллектуальные агенты для принятия критических решений.
ИИ и обучение
Вам повезло, если вы закончили школу до того, как вас испортил искусственный интеллект.

Но что, если вы не можете проверить информацию просто потому, что не развили навыки обучения, критического мышления, навыков рассуждения или просто потому, что вы слишком молоды или зависли на "полезных и эффективных" искусственных интеллектуальных агентах? Это может быть серьезной проблемой. Калькуляторы начинали как дорогие, ограниченные инструменты, давая школам годы для адаптации. Теперь искусственный интеллект мгновенно трансформирует образование, влияя на каждый предмет. Студенты будут обманывать с помощью искусственного интеллекта, но также интегрировать его в свою работу, ставя под сомнение педагогов и споря о целесообразности традиционных заданий.
Общее понимание заключается в том, что если задания не выполнены в классе, невозможно надежно определить, сделаны ли они человеком.

Проверяемый искусственный интеллект может изменить это.


NEAR AI Hub
NEAR.AI - это ответ.
На данный момент в альфа-версии уже доступны некоторые захватывающие функции для попробовать. Нет ничего лучше, чем учиться, пробуя, так что давайте это сделаем.

Перейдите в NEAR Центр исследований по искусственному интеллекту.

Вы можете войти в систему с помощью вашей учетной записи NEAR для взаимодействия с платформой. На вкладке Агенты вы найдете все агенты, добавленные в Реестр - Децентрализованное хранилище с поддержкой частных и зашифрованных элементов.
Найдите и ознакомьтесь с агентом Learn AI 0.0.1.
Вы можете общаться с агентом внутри NEAR AI хаба, а, что более важно, вы можете изучить происхождение агента - который находится по ссылке learn-agent.learnclub.near, исходный код, включая подсказки и стоп-слова. Более того, если вы хотите настроить его - скажем, удалить стоп-слово, которое для вас критично - просто клонируйте его. Но помните, что теперь вы контролируете свой клон!



Теперь давайте немного поглубже. Переключитесь на вкладку Модели.


Уже доступно более 50 открытых моделей. Как вы можете видеть и убедиться, Learn AI использует конкретный LLaMA, размещенный на инфраструктуре NEAR AI. Использование учетных записей NEAR для взаимодействия с моделями через агентов гарантирует, что вы точно знаете, с кем общаетесь!



NEAR AI планирует создать следующее поколение фронтальной модели ИИ с 1,4T параметрами! Идея заключается в том, чтобы сделать разработку открытого исходного кода ИИ устойчивой с помощью модели оплаты за использование, и здесь NEAR сыграет ключевую роль.




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Как NEAR AI собирается создать 1,4T параметровую, монетизируемую модель децентрализованным способом? Вступаем в мир Доверенных Исполнительных Сред, или TEE.

Современные процессоры и графические процессоры (начиная с H100s) позволяют одному актеру, Алисе, запускать код на машине другого актера, Боба, не доверяя Бобу, обеспечивая две гарантии: (a) Боб действительно запускает код, который Алиса ожидала от него, и (b) Боб не может шпионить за выполнением, которое Алиса хочет, чтобы он выполнил. Другими словами, Алиса может безопасно отправлять любые конфиденциальные данные в такое вычисление, будучи уверенной, что Боб не сможет их увидеть.
Заключение
Децентрализованная инфраструктура NEAR AI представляет собой значительный шаг вперед в обеспечении пользовательского владения ИИ. Предлагая прозрачность, контроль и гибкость, NEAR AI дает пользователям возможность взаимодействовать с ИИ-агентами таким образом, что обеспечивается конфиденциальность данных и укрепляется доверие.

LNC, как пионер NEAR, на передовой в использовании этой инфраструктуры для практических приложений, включая живого агента Learn AI, Lean NEAR Tutor (в разработке) и запланированного агента по шопингу WooCommerce.

Как учащийся, вас приглашают активно участвовать в этой инновационной (L)Earn экосистеме. Задавайте (L)Earn AI соответствующие вопросы, платите с помощью nLEARNs, получайте знания и зарабатывайте nLEARNs, внося свой вклад в улучшение ИИ.

 Вместе этот подход придает более глубокий и богатый смысл понятию (L)Earn, сочетая обучение с заработком в позитивной игре с ИИ.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Счастливого (L)Earn!🕺

### Presentando al agente de IA (L)Earn en NEAR AI

Introducción
Probablemente has escuchado que ahora puedes llamar a ChatGPT por teléfono. Esto parece irreal. Es genial, pero ¿tienes idea con quién vas a hablar? Lo mejor que puedes hacer es confiar en la reputación del proveedor de servicios - OpenAI OpCo, LLC.


Problemas con la IA Actual

 	Modelos Centralizados: La mayoría de los modelos ampliamente utilizados como GPT-4 o Claude son de código cerrado y centralizados.
 	Dependencia de Infraestructura Centralizada: Incluso los modelos "de código abierto" a menudo se ejecutan en plataformas centralizadas como Groq o Together AI.
 	Operaciones Opacas: Es imposible verificar cómo operan los agentes, incluyendo las indicaciones, limitaciones y listas de parada.
 	Preocupaciones sobre la Privacidad de los Datos: Los usuarios tienen poca visibilidad sobre cómo se manejan o almacenan sus datos.

Estos desafíos enfatizan la necesidad de un uso responsable de la IA y precaución al depender de agentes de IA para decisiones críticas.
IA y Aprendizaje
Eres afortunado si te graduaste de la escuela antes de que te malcriara la IA.

Pero, ¿qué pasa si no puedes verificar cosas simplemente porque no has desarrollado habilidades de aprendizaje, pensamiento crítico, habilidades de razonamiento o simplemente porque eres muy joven o te has vuelto adicto a los agentes de IA "útiles y eficientes"? Esto podría ser un problema serio. Las calculadoras comenzaron como herramientas costosas y limitadas, dando a las escuelas años para adaptarse. Ahora, la IA está transformando la educación instantáneamente, impactando en cada materia. Los estudiantes harán trampa con la IA pero también la integrarán en su trabajo, desafiando a los educadores y cuestionando la relevancia de las tareas tradicionales.
La comprensión común es que a menos que las tareas se completen en clase, es imposible determinar de manera confiable si el trabajo es hecho por humanos.

La IA verificable puede cambiar esto.


NEAR AI Hub
NEAR.AI es la respuesta.
Mientras está en Alpha, ya hay algunas características emocionantes disponibles para probar. Nada se compara con aprender probando, así que hagámoslo.

Ve al Centro de Investigación de IA de NEAR.

Puedes iniciar sesión con tu cuenta de NEAR para interactuar con la plataforma. En la pestaña de Agentes encontrarás todos los agentes agregados al Registro - Almacenamiento descentralizado con soporte de elementos privados y encriptados.
Encuentra y revisa el agente de IA de Aprendizaje 0.0.1.
Puedes hablar con el agente dentro de NEAR AI hub, y lo que es más importante, puedes explorar el origen del agente - que es learn-agent.learnclub.near, código fuente, incluyendo la indicación y palabras clave. Además, si deseas ajustarlo - por ejemplo, eliminar una palabra clave que sea crucial para ti - simplemente clónalo. ¡Pero ten en cuenta que ahora eres responsable de tu clon!



Ahora vamos a profundizar un poco más. Cambia a la pestaña de Modelos.


Ya hay más de 50 modelos de código abierto disponibles. Como puedes ver y verificar, Learn AI está utilizando ese LLaMA en particular alojado en la infraestructura de NEAR AI. ¡Usar cuentas de NEAR para interactuar con modelos a través de agentes asegura que sepas con quién estás hablando realmente!



NEAR AI planea construir el próximo modelo de IA de frontera de próxima generación con 1.4T de parámetros. La idea es hacer que el desarrollo de IA de código abierto sea sostenible a través de un modelo de pago por uso y aquí es donde NEAR jugará un papel crucial.




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






¿Cómo logrará NEAR AI construir un modelo monetizable de 1.4T de parámetros de manera descentralizada? Entra en el mundo de Entornos de Ejecución Confiables, o TEEs.

Los procesadores y GPUs modernos (comenzando con los H100) permiten que un actor, Alice, ejecute código en una máquina de otro actor, Bob, sin confiar en Bob, mientras tiene las siguientes dos garantías: (a) Bob está ejecutando el código que Alice esperaba que ejecutara, y (b) Bob no puede espiar la ejecución que Alice quiere que realice. En otras palabras, Alice puede enviar de forma segura cualquier dato privado a dicha computación, estando segura de que Bob no podrá verlo.
Conclusión
La infraestructura descentralizada de NEAR AI representa un avance significativo en la habilitación de la IA propiedad del usuario. Al ofrecer transparencia, control y flexibilidad, NEAR AI capacita a los usuarios para interactuar con agentes de IA de una manera que garantiza la privacidad de los datos y fomenta la confianza.

LNC, como pionero de NEAR, está a la vanguardia de aprovechar esta infraestructura para aplicaciones prácticas, incluido el agente de IA en vivo Learn AI, el Tutor Lean NEAR (en desarrollo) y el Agente de Compras de WooCommerce planificado.

Como aprendiz, estás invitado a participar activamente en este innovador ecosistema (L)Earn. Haz preguntas relevantes a (L)Earn AI, paga con nLEARNs, adquiere conocimientos y gana nLEARNs contribuyendo a la mejora de la IA.

 Juntos, este enfoque aporta un significado más profundo y rico al concepto de (L)Earn, combinando el aprendizaje con la ganancia en un juego de suma positiva con IA.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚¡Feliz (L)Earning!🕺

### 在NEAR AI上推出（L）Earn AI代理

介绍
您可能已经听说现在可以通过电话与ChatGPT进行通话。这似乎不真实。这很酷，但您知道您将与谁交谈吗？您最好依赖于服务提供商的声誉-OpenAI OpCo, LLC。


当前AI存在的问题

 	集中式模型：大多数广泛使用的模型如GPT-4或Claude都是闭源和集中式的。
 	依赖于集中式基础设施：即使是“开源”模型通常也在Groq或Together等集中平台上运行。
 	操作不透明：无法验证代理如何运作-包括提示、限制和停止列表。
 	数据隐私问题：用户很难看到他们的数据如何被处理或存储。

这些挑战强调了在依赖AI代理做出关键决策时需要负责任地使用AI并谨慎对待的必要性。
AI和学习
如果您在被AI宠坏之前就毕业了，那您真是幸运。

但如果您无法验证事物，只是因为您没有发展学习技能、批判性思维、推理能力，或者只是因为您太年轻或者对“有用和高效”的AI代理上瘾了，这可能是一个严重问题。计算器最初是昂贵、有限的工具，给学校提供了多年的时间来适应。现在，AI正在即时改变教育，影响每个学科。学生会利用AI作弊，但也会将其整合到他们的工作中，挑战教育工作者，质疑传统作业的相关性。
普遍的看法是，除非作业是在课堂上完成的，否则无法可靠地确定工作是否是人为完成的。

可验证的AI可以改变这一点。


NEAR AI中心
NEAR.AI就是答案。
虽然处于Alpha阶段，但已经有一些令人兴奋的功能可供尝试。没有什么比通过尝试学习更好的了，所以让我们试一试。

前往NEAR AI研究中心。

您可以使用您的NEAR账户登录以与平台进行交互。在代理选项卡中，您会找到所有添加到注册表中的代理-支持私人和加密项目的分散存储。
查找并查看Learn AI代理0.0.1。
您可以在NEAR AI中心与代理人交谈，更重要的是您可以探索代理人的来源 - 即learn-agent.learnclub.near，源代码，包括提示和停用词。此外，如果您想要调整它 - 比如删除对您至关重要的停用词 - 只需克隆它。但请注意，现在您负责您的克隆版本！



现在让我们深入一点。切换到“Models”选项卡。


已经有超过50个开源模型可用。正如您所看到的并验证的，Learn AI正在使用托管在NEAR AI基础设施上的特定LLaMA。通过使用NEAR账户通过代理与模型进行交互，可以确保您知道您实际上正在与谁交谈！



NEAR AI计划构建下一代拥有1.4T参数的前沿AI模型！该想法是通过按使用量付费模型使开源AI开发可持续化，这就是NEAR将发挥关键作用的地方。




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR AI将如何以分散的方式构建一个具有1.4T参数的可货币化模型？进入可信执行环境的世界。

现代处理器和GPU（从H100开始）允许一个参与者Alice在另一个参与者Bob的机器上运行代码，而无需信任Bob，同时具有以下两个保证：（a）Bob实际上正在运行Alice期望他运行的代码，（b）Bob无法窥视Alice希望他执行的计算。换句话说，Alice可以安全地将任何私人数据发送到这样的计算中，确保Bob无法看到它。
结论
分散的NEAR AI基础设施代表着向用户拥有的AI迈出的重要一步。通过提供透明度、控制和灵活性，NEAR AI赋予用户以一种确保数据隐私并培养信任的方式与AI代理人互动。

作为NEAR的先驱，LNC正在积极利用这一基础设施进行实际应用，包括现有的Learn AI代理人、正在开发中的Lean NEAR导师以及计划中的WooCommerce购物代理人。

作为学习者，您被邀请积极参与这一创新的（L）Earn生态系统。向（L）Earn AI提出相关问题，使用nLEARN进行支付，获取知识，并通过为AI的改进做出贡献来赚取nLEARN。

 总的来说，这种方法为（L）Earn的概念带来了更深层次和更丰富的含义，将学习与赚取融合在一起，与AI进行积极的正和游戏。




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚祝您（L）Earn愉快！🕺

### Giới thiệu (L)Earn AI agent trên NEAR AI

Giới thiệu
Bạn có thể đã nghe rằng bây giờ bạn có thể gọi ChatGPT qua điện thoại. Điều này dường như không thực. Điều đó tuyệt vời nhưng bạn có ý tưởng bạn sẽ nói chuyện với ai không? Điều tốt nhất bạn có thể làm là tin tưởng vào uy tín của nhà cung cấp dịch vụ - OpenAI OpCo, LLC.


Vấn đề với Trí tuệ Nhân tạo Hiện tại

 	Mô hình Tập trung: Hầu hết các mô hình phổ biến như GPT-4 hoặc Claude đều là mã nguồn đóng và tập trung.
 	Phụ thuộc vào Cơ sở hạ tầng Tập trung: Ngay cả các mô hình "mã nguồn mở" thường chạy trên các nền tảng tập trung như Groq hoặc Together AI.
 	Hoạt động Mờ Ám: Không thể xác minh cách các đại lý hoạt động - bao gồm cả câu hỏi, giới hạn và danh sách dừng.
 	Lo ngại về Quyền riêng tư Dữ liệu: Người dùng ít thấy được cách dữ liệu của họ được xử lý hoặc lưu trữ.

Những thách thức này nhấn mạnh nhu cầu sử dụng Trí tuệ Nhân tạo một cách có trách nhiệm và cẩn thận khi phụ thuộc vào các đại lý Trí tuệ Nhân tạo cho các quyết định quan trọng.
Trí tuệ Nhân tạo và Học tập
May mắn nếu bạn đã tốt nghiệp trường trước khi bị làm hỏng bởi Trí tuệ Nhân tạo.

Nhưng nếu bạn không thể xác minh thông tin chỉ vì bạn chưa phát triển kỹ năng học, tư duy phê phán, kỹ năng lý luận hoặc chỉ vì bạn quá trẻ hoặc bạn đã nghiện vào các đại lý Trí tuệ "hữu ích và hiệu quả"? Điều này có thể là một vấn đề nghiêm trọng. Máy tính bắt đầu như là các công cụ đắt tiền, giới hạn, mang lại cho trường học nhiều năm để thích nghi. Bây giờ, Trí tuệ Nhân tạo đang biến đổi giáo dục ngay lập tức, ảnh hưởng đến mọi môn học. Sinh viên sẽ gian lận với Trí tuệ Nhân tạo nhưng cũng tích hợp nó vào công việc của họ, thách thức giáo viên và đặt câu hỏi về sự liên quan của các bài tập truyền thống.
Hiểu biết chung là trừ khi bài tập được hoàn thành trong lớp, không thể xác định một cách đáng tin cậy liệu công việc có phải là của con người hay không.

Trí tuệ Nhân tạo có thể xác minh có thể thay đổi điều này.


NEAR AI Hub
NEAR.AI là câu trả lời.
Trong giai đoạn Alpha, một số tính năng thú vị đã sẵn sàng để thử. Không có gì so sánh được với việc học bằng cách thử nghiệm nên hãy làm điều đó.

Đi đến NEAR Trung tâm Nghiên cứu Trí tuệ Nhân tạo.

Bạn có thể đăng nhập bằng tài khoản NEAR của bạn để tương tác với nền tảng. Tại tab Đại lý bạn sẽ tìm thấy tất cả các đại lý được thêm vào Đăng ký - Lưu trữ phi tập trung với hỗ trợ của các mục riêng tư và mã hóa.
Tìm và kiểm tra đại lý Học AI 0.0.1.
Bạn có thể trò chuyện với tác nhân trong NEAR AI hub, và điều quan trọng hơn bạn có thể khám phá nguồn gốc của tác nhân - đó là learn-agent.learnclub.near, mã nguồn, bao gồm cả prompt và stopwords. Hơn nữa, nếu bạn muốn điều chỉnh nó - ví dụ loại bỏ một stopword quan trọng đối với bạn - chỉ cần sao chép nó. Nhưng hãy nhớ rằng bây giờ bạn là người quản lý của bản sao của bạn!



Bây giờ hãy đào sâu hơn một chút. Chuyển sang tab Mô hình.


Hiện có hơn 50 mô hình mã nguồn mở sẵn có. Như bạn có thể thấy và xác minh rằng Learn AI đang sử dụng mô hình LLaMA cụ thể đó được lưu trữ tại cơ sở hạ tầng NEAR AI. Sử dụng tài khoản NEAR để tương tác với các mô hình thông qua tác nhân đảm bảo rằng bạn biết bạn đang nói chuyện với ai thực sự!



NEAR AI đang lên kế hoạch xây dựng mô hình trí tuệ nhân tạo thế hệ tiếp theo với 1.4T tham số! Ý tưởng là tạo ra mô hình phát triển trí tuệ nhân tạo mã nguồn mở bền vững thông qua mô hình trả tiền theo sử dụng và đây là nơi NEAR sẽ đóng vai trò quan trọng.




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Làm thế nào NEAR AI sẽ thực hiện việc xây dựng một mô hình có thể kiếm tiền với 1.4T tham số một cách phi tập trung? Bước vào thế giới của Môi trường Thực thi Đáng tin cậy, hay TEEs.

Các bộ xử lý và GPU hiện đại (bắt đầu từ H100s) cho phép một bên, Alice, chạy mã trên máy của một bên khác, Bob, mà không cần tin tưởng Bob, trong khi có hai cam kết sau: (a) Bob thực sự đang chạy mã mà Alice mong đợi anh ta chạy, và (b) Bob không thể nghe trộm quá trình thực thi mà Alice muốn anh ta thực hiện. Nói cách khác, Alice có thể an toàn gửi bất kỳ dữ liệu riêng tư nào vào một tính toán như vậy, chắc chắn rằng Bob sẽ không thể nhìn thấy nó.
Kết luận
Cơ sở hạ tầng NEAR AI phi tập trung đại diện cho một bước tiến quan trọng trong việc khuyến khích trí tuệ nhân tạo do người dùng sở hữu. Bằng cách cung cấp tính minh bạch, kiểm soát và linh hoạt, NEAR AI trao quyền cho người dùng tương tác với các tác nhân trí tuệ nhân tạo một cách đảm bảo quyền riêng tư dữ liệu và tạo niềm tin.

LNC, là một người tiên phong của NEAR, đang ở hàng đầu trong việc tận dụng cơ sở hạ tầng này cho các ứng dụng thực tế, bao gồm tác nhân trí tuệ nhân tạo Learn AI trực tiếp, Hướng dẫn NEAR Lean (đang phát triển), và Tác nhân Mua sắm WooCommerce dự kiến.

Là một người học, bạn được mời tham gia tích cực vào hệ sinh thái (L)Earn sáng tạo này. Hỏi (L)Earn AI những câu hỏi liên quan, thanh toán bằng nLEARNs, học hỏi và kiếm nLEARNs bằng cách đóng góp vào việc cải thiện của trí tuệ nhân tạo.

 Cùng nhau, phương pháp này mang đến một ý nghĩa sâu sắc và phong phú hơn cho khái niệm (L)Earn, kết hợp học hỏi với kiếm tiền trong một trò chơi tích cực với trí tuệ nhân tạo.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Chúc (L)Earn vui vẻ!🕺

### NEAR AI上の(L)Earn AIエージェントを紹介します

導入
おそらく、今、電話でChatGPTを呼び出すことができると聞いたことがあるでしょう。これは非現実的に思えます。それはクールですが、話す相手が誰かを知っていますか？最善の方法は、サービスプロバイダーの評判であるOpenAI OpCo, LLCに頼ることです。


現在のAIの問題

 	中央集権モデル：GPT-4やClaudeなどの広く使用されているモデルはクローズドソースで中央集権化されています。
 	中央集権インフラへの依存：「オープンソース」とされているモデルでも、GroqやTogether AIなどの中央集権化されたプラットフォームで実行されることがよくあります。
 	不透明な運用：エージェントがどのように操作されているか（プロンプト、制限、停止リストなど）を検証することは不可能です。
 	データプライバシーの懸念：ユーザーは、自分のデータがどのように処理されたり保存されたりしているかについてほとんど見えていません。

これらの課題は、責任あるAIの使用と、重要な意思決定にAIエージェントを頼る際の注意を強調しています。
AIと学習
AIに甘やかされる前に学校を卒業したら幸運です。

しかし、学習スキル、批判的思考、推論スキルを発達させていないために、または若すぎるために、または「役立ち効率的な」AIエージェントに依存しすぎているために、物事を検証できない場合、これは深刻な問題になります。電卓は高価で限られたツールとして始まり、学校に年数をかけて適応しました。今、AIは瞬時に教育を変革し、あらゆる科目に影響を与えています。生徒はAIで不正行為をするかもしれませんが、それを自分の仕事に組み込んで教育者に挑戦し、伝統的な課題の妥当性を疑問視します。
一般的な理解は、課題がクラス内で完了されない限り、その作業が人間によって行われたかどうかを確実に判断することは不可能だということです。

検証可能なAIはこれを変えることができます。


NEAR AI Hub
NEAR.AIが答えです。
アルファ版では、すでにいくつかの興味深い機能が試すことができます。試して学ぶことに勝るものはありませんので、やってみましょう。

NEAR AI Research Hubに移動してください。

プラットフォームとやり取りするために、NEARアカウントでサインインすることができます。Agentsタブで、登録されたすべてのエージェントを見つけることができます - プライベートで暗号化されたアイテムをサポートする分散型ストレージ。
Learn AIエージェント0.0.1を見つけてチェックしてください。
NEAR Protocolに関連する用語をすべて含む以下のテキストをjaに翻訳してください。HTMLタグは保持しますが、、、、などのタグは生成しないでください。特定の名前やトークン（「Burrow」、「NEAR」、「BRR」、「stNEAR」など）は翻訳しないでください。

NEAR AIハブ内でエージェントと会話することができ、さらに重要なのは、エージェントの起源を探ることができるということです - それはlearn-agent.learnclub.near、ソースコード、プロンプト、ストップワードを含む。さらに、重要なストップワードを削除したい場合は、単純にクローンを作成してください。ただし、今後はクローンを管理することになります！



さらに掘り下げてみましょう。モデルタブに切り替えてください。


すでに50以上のオープンソースモデルが利用可能です。Learn AIがNEAR AIインフラでホストされている特定のLLaMAを使用していることが確認できます。エージェントを介してモデルとやり取りするためにNEARアカウントを使用することで、実際に誰と話しているのかがわかります！



NEAR AIは、1.4Tのパラメータを持つ次世代のフロンティアAIモデルを構築する計画です！オープンソースAI開発をペイパーユースモデルを通じて持続可能にするアイデアで、ここでNEARが重要な役割を果たすことになります。




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR AIは、分散型の方法で1.4Tのパラメータを持つモデルを構築し、収益化する方法を実現するのでしょうか？それが「Trusted Execution Environments」、またはTEEsの世界に入るところです。

現代のプロセッサやGPU（H100sから始まる）は、一方のアクターであるアリスが、もう一方のアクターであるボブのマシンでコードを実行することを可能にします。ボブを信頼せずに、次の2つの保証を持っています：（a）ボブがアリスが期待していたコードを実行していること、および（b）ボブがアリスが実行してほしい処理を盗聴できないこと。言い換えると、アリスはそのような計算に任意のプライベートデータを安全に送信でき、ボブがそれを見ることができないことを確信できます。
結論
分散型のNEAR AIインフラは、ユーザー所有のAIを可能にする大きな進歩を表しています。透明性、コントロール、柔軟性を提供することで、NEAR AIは、データプライバシーを確保し、信頼を育む方法でユーザーがAIエージェントとやり取りできるようにしています。

NEARの先駆者であるLNCは、ライブLearn AIエージェント、開発中のLean NEAR Tutor、計画中のWooCommerce Shopping Agentなど、実用的なアプリケーションにこのインフラを活用する最前線に立っています。

学習者として、この革新的な（L）Earnエコシステムに積極的に参加してください。 （L）Earn AIに関連する質問をして、nLEARNで支払い、知識を得て、AIの改善に貢献することでnLEARNを獲得してください。

 このアプローチにより、（L）Earnの概念に深い意味と豊かさがもたらされ、学習とAIとのポジティブなゲームでの収益を組み合わせています。




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Happy (L)Earning!🕺

### Apresentando o agente de IA (L)Earn na NEAR AI

Introdução
Você provavelmente ouviu falar que agora pode ligar para o ChatGPT pelo telefone. Isso parece irreal. É legal, mas você tem ideia com quem vai falar? O melhor que você pode fazer é confiar na reputação do provedor de serviços - OpenAI OpCo, LLC.


Problemas com a IA Atual

 	Modelos Centralizados: A maioria dos modelos amplamente utilizados como GPT-4 ou Claude são de código fechado e centralizados.
 	Dependência da Infraestrutura Centralizada: Mesmo os modelos "de código aberto" frequentemente rodam em plataformas centralizadas como Groq ou Together AI.
 	Operações Opaques: É impossível verificar como os agentes operam - incluindo prompts, limitações e listas de paradas.
 	Preocupações com a Privacidade de Dados: Os usuários têm pouca visibilidade sobre como seus dados são tratados ou armazenados.

Esses desafios destacam a necessidade de uso responsável da IA e cautela ao depender de agentes de IA para decisões críticas.
IA e Aprendizado
Sorte a sua se você se formou na escola antes de ser mimado pela IA.

Mas e se você não consegue verificar coisas simplesmente porque não desenvolveu habilidades de aprendizado, pensamento crítico, habilidades de raciocínio ou simplesmente porque é muito jovem ou ficou viciado em agentes de IA "úteis e eficientes"? Isso poderia ser um problema sério. As calculadoras começaram como ferramentas caras e limitadas, dando às escolas anos para se adaptarem. Agora, a IA está transformando a educação instantaneamente, impactando todas as disciplinas. Os alunos vão trapacear com a IA, mas também integrá-la em seu trabalho, desafiando os educadores e questionando a relevância das tarefas tradicionais.
A compreensão comum é que, a menos que as tarefas sejam concluídas em sala de aula, é impossível determinar de forma confiável se o trabalho é feito por humanos.

A IA Verificável pode mudar isso.


NEAR AI Hub
NEAR.AI é a resposta.
Enquanto em Alpha, alguns recursos emocionantes já estão disponíveis para experimentar. Nada se compara a aprender tentando, então vamos lá.

Vá para o Hub de Pesquisa de IA NEAR.

Você pode entrar com sua conta NEAR para interagir com a plataforma. Na guia Agentes você encontra todos os agentes adicionados ao Registro - Armazenamento descentralizado com suporte a itens privados e criptografados.
Encontre e confira o agente de IA Learn 0.0.1.
Você pode conversar com o agente dentro do NEAR AI hub e, o que é mais importante, pode explorar a origem do agente - que é learn-agent.learnclub.near, código-fonte, incluindo prompt e stopwords. Além disso, se você quiser ajustá-lo - digamos remover um stopword que seja crucial para você - basta cloná-lo. Mas esteja ciente de que agora você é responsável pelo seu clone!



Agora vamos aprofundar um pouco mais. Mude para a aba Modelos.


Já existem mais de 50 modelos de código aberto disponíveis. Como você pode ver e verificar que o Learn AI está usando aquele LLaMA específico hospedado na infraestrutura NEAR AI. Usar contas NEAR para interagir com modelos via agentes garante que você saiba com quem está realmente falando!



NEAR AI planeja construir o próximo modelo de IA de fronteira da próxima geração com 1,4T de parâmetros! A ideia é tornar o desenvolvimento de IA de código aberto sustentável por meio de um modelo de pagamento por uso e é aí que a NEAR desempenhará um papel crucial.




	

	
	
		
			
				What is one major advantage of the NEAR AI infrastructure compared to centralized AI models?
			
		

		
					

		
			
			
			
			It offers faster processing speed
		
			
			It ensures user-owned AI with transparency and control over agents and models
		
			
			It eliminates the need for AI prompts and stopwords
		
			
			It requires no technical knowledge for customization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Como a NEAR AI vai conseguir construir um modelo monetizável de 1,4T de parâmetros de forma descentralizada? Entre no mundo dos Ambientes de Execução Confiáveis, ou TEEs.

Processadores e GPUs modernos (começando com H100s) permitem que um ator, Alice, execute código em uma máquina de outro ator, Bob, sem confiar em Bob, enquanto tendo as seguintes duas garantias: (a) Bob está de fato executando o código que Alice esperava que ele executasse, e (b) Bob não pode espionar a execução que Alice quer que ele realize. Em outras palavras, Alice pode enviar com segurança quaisquer dados privados para tal computação, tendo certeza de que Bob não será capaz de vê-los.
Conclusão
A infraestrutura descentralizada da NEAR AI representa um avanço significativo na capacitação da IA de propriedade do usuário. Ao oferecer transparência, controle e flexibilidade, a NEAR AI capacita os usuários a interagir com agentes de IA de uma maneira que garante a privacidade dos dados e promove a confiança.

LNC, como pioneira da NEAR, está na vanguarda da alavancagem dessa infraestrutura para aplicações práticas, incluindo o agente Learn AI ao vivo, o Lean NEAR Tutor (em desenvolvimento) e o agente de compras WooCommerce planejado.

Como aprendiz, você está convidado a participar ativamente deste ecossistema inovador (L)Earn. Faça perguntas relevantes ao (L)Earn AI, pague com nLEARNs, adquira conhecimento e ganhe nLEARNs contribuindo para a melhoria da IA.

 Juntos, esse enfoque traz um significado mais profundo e rico ao conceito de (L)Earn, misturando aprendizado com ganhos em um jogo de soma positiva com IA.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Feliz (L)Earning!🕺

### Presentando al agente de inteligencia artificial (L)Earn en NEAR AI

Introducción
Probablemente has escuchado que ahora puedes llamar a ChatGPT por teléfono. Esto parece irreal. Es genial, pero ¿tienes idea con quién vas a hablar? Lo mejor que puedes hacer es confiar en la reputación del proveedor de servicios - OpenAI OpCo, LLC.


Problemas con la IA Actual

 	Modelos Centralizados: La mayoría de los modelos ampliamente utilizados como GPT-4 o Claude son cerrados y centralizados.
 	Dependencia de Infraestructura Centralizada: Incluso los modelos "de código abierto" a menudo se ejecutan en plataformas centralizadas como Groq o Together AI.
 	Operaciones Opacas: Es imposible verificar cómo operan los agentes, incluidas las indicaciones, limitaciones y listas de paradas.
 	Preocupaciones sobre la Privacidad de los Datos: Los usuarios tienen poca visibilidad sobre cómo se manejan o almacenan sus datos.

Estos desafíos enfatizan la necesidad de un uso responsable de la IA y precaución al depender de agentes de IA para decisiones críticas.
IA y Aprendizaje
Eres afortunado si te graduaste de la escuela antes de que te malcriara la IA.

Pero, ¿qué pasa si no puedes verificar cosas simplemente porque no has desarrollado habilidades de aprendizaje, pensamiento crítico, habilidades de razonamiento o simplemente porque eres demasiado joven o te has vuelto adicto a los agentes de IA "útiles y eficientes"? Esto podría ser un problema serio. Las calculadoras comenzaron como herramientas costosas y limitadas, dando a las escuelas años para adaptarse. Ahora, la IA está transformando la educación instantáneamente, impactando en cada materia. Los estudiantes harán trampa con la IA pero también la integrarán en su trabajo, desafiando a los educadores y cuestionando la relevancia de las tareas tradicionales.


NEAR AI Hub
NEAR.AI es la respuesta.
Mientras esté en Alpha, ya hay algunas características emocionantes disponibles para probar. Nada se compara con aprender probando, así que hagámoslo.

Ve al Centro de Investigación de IA de NEAR.

Puedes iniciar sesión con tu cuenta de NEAR para interactuar con la plataforma. En la pestaña de Agentes encontrarás todos los agentes agregados al Registro - Almacenamiento descentralizado con soporte de elementos privados y encriptados.
Encuentra y revisa el agente de Aprendizaje de IA 0.0.1.


Puedes hablar con el agente dentro del Centro de Investigación de IA de NEAR, y lo que es más importante, puedes explorar el origen del agente - que es learn-agent.learnclub.nearAhora vamos a profundizar un poco más. Cambia a la pestaña de Modelos.

Hay más de 50 modelos de código abierto disponibles actualmente. Como puedes ver y verificar, Learn AI está utilizando ese LLaMA en particular alojado en la infraestructura de NEAR AI. ¡Usar cuentas de NEAR para interactuar con modelos a través de agentes asegura que sepas con quién estás hablando realmente!

NEAR AI planea construir el próximo modelo de inteligencia artificial de frontera de la próxima generación con 1.4T de parámetros. La idea es hacer que el desarrollo de inteligencia artificial de código abierto sea sostenible a través de un modelo de pago por uso y aquí es donde NEAR jugará un papel crucial.

¿Cómo logrará NEAR AI construir un modelo monetizable de 1.4T de parámetros de forma descentralizada? Entra en el mundo de Entornos de Ejecución Confiables, o TEEs.

Los procesadores y GPUs modernos (comenzando con H100s) permiten que un actor, Alice, ejecute código en una máquina de otro actor, Bob, sin confiar en Bob, mientras tiene las siguientes dos garantías: (a) Bob está ejecutando el código que Alice esperaba que ejecutara, y (b) Bob no puede espiar la ejecución que Alice quiere que lleve a cabo. En otras palabras, Alice puede enviar de forma segura cualquier dato privado a dicha computación, estando segura de que Bob no podrá verlo.

Conclusión

La infraestructura descentralizada de NEAR AI representa un paso significativo en la habilitación de la inteligencia artificial propiedad del usuario. Al ofrecer transparencia, control y flexibilidad, NEAR AI capacita a los usuarios para interactuar con agentes de inteligencia artificial de una manera que garantiza la privacidad de los datos y fomenta la confianza.

LNC, como pionero de NEAR, está a la vanguardia de aprovechar esta infraestructura para aplicaciones prácticas, incluido el agente de Learn AI en vivo, el Lean NEAR Tutor (en desarrollo) y el agente de compras de WooCommerce planificado.

Como aprendiz, estás invitado a participar activamente en este innovador ecosistema (L)Earn. Haz preguntas relevantes a (L)Earn AI, paga con nLEARNs, adquiere conocimientos y gana nLEARNs contribuyendo a la mejora del AI.

Juntos, este enfoque aporta un significado más profundo y rico al concepto de (L)Earn, combinando el aprendizaje con la ganancia en un juego de suma positiva con la IA.

¡Feliz (L)Earning!

### Giới thiệu (L)Earn AI agent trên NEAR AI

Giới thiệu
Chắc bạn đã nghe rằng bây giờ bạn có thể gọi ChatGPT qua điện thoại. Điều này dường như không thể tin được. Đó là điều tuyệt vời nhưng bạn có ý tưởng bạn sẽ nói chuyện với ai không? Điều tốt nhất bạn có thể làm là tin tưởng vào uy tín của nhà cung cấp dịch vụ - OpenAI OpCo, LLC.


Vấn đề với AI Hiện tại

 	Mô hình Tập trung: Hầu hết các mô hình phổ biến như GPT-4 hoặc Claude đều là nguồn đóng và tập trung.
 	Phụ thuộc vào Cơ sở hạ tầng Tập trung: Ngay cả các mô hình "mã nguồn mở" thường chạy trên các nền tảng tập trung như Groq hoặc Together AI.
 	Hoạt động Mờ đục: Không thể xác minh cách các tác nhân hoạt động - bao gồm cả câu hỏi, giới hạn và danh sách dừng.
 	Lo ngại về Quyền riêng tư Dữ liệu: Người dùng ít thấy được cách dữ liệu của họ được xử lý hoặc lưu trữ.

Những thách thức này nhấn mạnh nhu cầu sử dụng AI có trách nhiệm và cẩn trọng khi phụ thuộc vào các tác nhân AI cho các quyết định quan trọng.
AI và Học tập
May mắn nếu bạn đã tốt nghiệp trường trước khi bị làm hỏng bởi AI.

Nhưng nếu bạn không thể xác minh thông tin chỉ vì bạn chưa phát triển kỹ năng học tập, tư duy phê phán, kỹ năng lý luận hoặc chỉ vì bạn quá trẻ hoặc bạn đã nghiện vào các tác nhân AI "hữu ích và hiệu quả"? Điều này có thể là một vấn đề nghiêm trọng. Máy tính bắt đầu như là các công cụ đắt tiền, giới hạn, mang lại cho trường học nhiều năm để thích nghi. Bây giờ, AI đang biến đổi giáo dục ngay lập tức, ảnh hưởng đến mọi môn học. Sinh viên sẽ gian lận với AI nhưng cũng tích hợp nó vào công việc của họ, thách thức giáo viên và đặt câu hỏi về tính liên quan của các bài tập truyền thống.


NEAR AI Hub
NEAR.AI là câu trả lời.
Trong giai đoạn Alpha, một số tính năng thú vị đã sẵn sàng để thử. Không có gì so sánh được với việc học bằng cách thử nghiệm nên hãy làm điều đó.

Đi đến NEAR AI Research Hub.

Bạn có thể đăng nhập bằng tài khoản NEAR của bạn để tương tác với nền tảng. Tại tab Tác nhân, bạn sẽ tìm thấy tất cả các tác nhân được thêm vào Đăng ký - Lưu trữ phi tập trung với hỗ trợ các mục riêng tư và mã hóa.
Tìm và kiểm tra Tác nhân Học AI 0.0.1.


Bạn có thể nói chuyện với tác nhân trong NEAR AI hub, và điều quan trọng hơn là bạn có thể khám phá nguồn gốc của tác nhân - đó là learn-agent.learnclub.nearBây giờ hãy đào sâu hơn. Chuyển sang tab Mô hình.


Hiện đã có hơn 50 mô hình mã nguồn mở sẵn có. Như bạn có thể thấy và xác minh rằng Learn AI đang sử dụng LLaMA cụ thể đó được lưu trữ tại cơ sở hạ tầng NEAR AI. Sử dụng tài khoản NEAR để tương tác với các mô hình qua các đại lý đảm bảo rằng bạn biết bạn đang nói chuyện với ai thực sự!

NEAR AI đang lên kế hoạch xây dựng mô hình trí tuệ nhân tạo thế hệ tiếp theo với 1,4T tham số! Ý tưởng là làm cho việc phát triển trí tuệ nhân tạo mã nguồn mở bền vững thông qua mô hình trả tiền theo sử dụng và đây là nơi mà NEAR sẽ đóng vai trò quan trọng.

Làm thế nào NEAR AI sẽ thực hiện việc xây dựng một mô hình có thể kiếm tiền với 1,4T tham số một cách phi tập trung? Bước vào thế giới của Môi trường Thực thi Đáng tin cậy, hoặc TEEs.

Các bộ xử lý và GPU hiện đại (bắt đầu từ H100s) cho phép một bên, Alice, chạy mã trên máy của một bên khác, Bob, mà không cần tin tưởng Bob, trong khi có hai cam kết sau: (a) Bob thực sự đang chạy mã mà Alice mong đợi anh ta chạy, và (b) Bob không thể nghe trộm quá trình thực thi mà Alice muốn anh ta thực hiện. Nói cách khác, Alice có thể an toàn gửi bất kỳ dữ liệu riêng tư nào vào một tính toán như vậy, chắc chắn rằng Bob sẽ không thể nhìn thấy nó.
Kết luận
Cơ sở hạ tầng NEAR AI phi tập trung đại diện cho một bước tiến quan trọng trong việc cho phép người dùng sở hữu trí tuệ nhân tạo. Bằng cách cung cấp tính minh bạch, kiểm soát và linh hoạt, NEAR AI trao quyền cho người dùng tương tác với các đại lý trí tuệ nhân tạo một cách đảm bảo quyền riêng tư dữ liệu và tạo niềm tin.

LNC, như một người tiên phong của NEAR, đang ở hàng đầu trong việc tận dụng cơ sở hạ tầng này cho các ứng dụng thực tế, bao gồm đại lý trí tuệ nhân tạo Learn AI trực tiếp, Hướng dẫn NEAR Lean (đang phát triển), và Đại lý Mua sắm WooCommerce dự định.

Là một người học, bạn được mời tham gia tích cực vào hệ sinh thái (L)Earn sáng tạo này. Hỏi (L)Earn AI các câu hỏi liên quan, thanh toán bằng nLEARNs, học hỏi và kiếm nLEARNs bằng cách đóng góp vào việc cải thiện của trí tuệ nhân tạo.

 Cùng nhau, phương pháp này mang đến một ý nghĩa sâu sắc và phong phú hơn cho khái niệm (L)Earn, kết hợp học hỏi với kiếm tiền trong một trò chơi tích cực với trí tuệ nhân tạo.

📚Chúc (L)Earn vui vẻ!🕺

### Cómo ejecutar un nodo validador de NEAR en 2025

Introducción
¡Ahora es un buen momento para aprender cómo ejecutar un validador en NEAR!

Nos preocupamos mucho por la descentralización en @NEARProtocol. En la versión más reciente (2.2.1), el umbral de participación para convertirse en validador se ha reducido a ~11k NEAR, menos de la mitad de lo que solía ser. Si eres un validador, ¡es un buen momento para unirte!

 ¿Qué opinas de un programa para incorporar muchos más validadores? ¿Llevar NEAR a 1k en los próximos meses?[/caption>

Entonces, en esta guía, te mostraré cómo ejecutar un validador en la red principal de NEAR. ¡Esta guía fácil y paso a paso te ayudará a unirte rápidamente y validar la red de NEAR, contribuir a su descentralización y resistencia, y ganar recompensas como validador en el camino!

Como miembro de la comunidad de NEAR, he estado ejecutando un nodo de NEAR durante más de dos años, comenzando con Stake Wars 3 (2022). En esta guía, te proporcionaré un tutorial detallado y paso a paso para que puedas configurar tu propio nodo completo de NEAR basado en mi experiencia todos estos años.

¡Estoy emocionado de compartir todo lo que he aprendido, ofreciendo instrucciones claras y detalladas para guiarte a través del proceso de configurar tu propio nodo validador en NEAR! ¡Vamos a alcanzar los 1000 validadores activos en NEAR!


¿Por qué deberías ejecutar un nodo de NEAR?
NEAR es la blockchain con una gran cantidad de actividades en el espacio web3, pero el requisito mínimo para ejecutar un nodo es relativamente ligero, económico de mantener y mucho más fácil de mantener en comparación con otras redes.

Principales blockchains por actividades, fuente: Artemis.


Y aquí está el requisito mínimo de hardware para ejecutar un nodo en algunas cadenas populares (por actividades de red)

 Requisitos de los validadores de NEAR[/caption>

Básicamente, el requisito para un nodo de NEAR es como una computadora portátil de consumo que puedes encontrar en casi cualquier lugar (sería mejor ejecutarlo en una computadora portátil para juegos en mi humilde opinión 😆).Lo genial de NEAR es que no necesitas un mainframe (> 512GB de RAM, 300TB de espacio en disco) ni siquiera tener que configurar un centro de base de datos completo para ejecutarlo y realmente puedes ser rentable sin cubrir los costos de la Fundación, ¡a diferencia de otras cadenas!

¡Por supuesto, para el nodo, cuanto más potente sea la máquina, mejor funcionará!
Personalmente ejecuto mi nodo en una máquina con 32 GB de RAM y 2TB NVME SSD en 12 núcleos de CPU, lo cual cuesta alrededor de 70$/mes.

Otras razones son cuando necesitas ejecutar aplicaciones que dependen en gran medida del rendimiento y/o disponibilidad de RPC, desarrollar e implementar contratos en un nodo local (independiente y aislado) a veces llamado "localnet" o extraer rápidamente datos de la cadena de bloques que se pueden utilizar para análisis de cadena, explorador de bloques, etc...

¡Esa es prácticamente la razón para ser optimista 🐂 sobre la ejecución de un nodo NEAR, así que comencemos ahora!
Instalación
Requisitos

 	Puedes usar cualquier distribución de Linux, pero para esta guía usaré Ubuntu, el requisito de versión de Ubuntu es 20.04 o más reciente, el mío está ejecutando 22.04
 	Requisito mínimo de hardware:

 	8GB de RAM (se recomiendan 16GB+)
 	~1 TB de NVME SSD (se recomiendan 1.5TB+)
 	CPU con 8 núcleos, características de CPU: CMPXCHG16B, POPCNT, SSE4.1, SSE4.2, AVX, SHA-NI
 	Ancho de banda de red de 1Gbit.



Configuración
Configurar la mainnet de NEAR
Necesitarás una dirección de NEAR para ejecutar el nodo, esta dirección también recibirá recompensas de red por ser un validador activo.

 	Crea una dirección de NEAR con nombre GRATUITA aquí: https://wallet.meteorwallet.app Creé lncvalidator.near para esta guía

 	Deposita alrededor de 31 NEAR en la dirección, se necesitan 30 NEAR para crear el grupo de participación y se bloquearán para almacenamiento, puedes recuperar esos NEAR más tarde si ya no ejecutas el nodo.
 	Importa la cuenta a https://app.mynearwallet.com/

Instalar bibliotecas y Nearcore
Ahora viene la parte divertida, configuremos el nodo NEAR, inicia sesión en tu servidor y ejecuta los siguientes comandos primero para actualizar el sistema operativo, instalar herramientas y bibliotecas (near-cli, node, Python, Git, docker...).

Ten en cuenta: ¡Todos los comandos en esta guía necesitarán ejecutarse bajo el usuario root!
sudo apt update && sudo apt upgrade -y && sudo apt install -y git binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev cmake gcc g++ python3 docker.io protobuf-compiler libssl-dev pkg-config clang llvm awscli tmux jq ccze rclone
Instalar Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"rustup -V
Durante la instalación, si se pregunta, ¡simplemente presiona Sí y elige lo predeterminado para todo!

Instalar NEAR Rust CLI y la extensión NEAR-Validator
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh &&
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near-cli-rs/near-validator-cli-rs/releases/latest/download/near-validator-installer.sh | sh && 
source $HOME/.cargo/env
Clonar el repositorio de nearcore, elegir la última rama estable para mainnet y compilar el nearcore desde el origen
cd ~ && git clone https://github.com/near/nearcore && cd nearcore/ && git checkout <VERSION>
make release
echo 'export NEAR_ENV=mainnet' >> ~/.bashrc
source ~/.bashrc
para el <VERSION>, obtener la última versión de lanzamiento de mainnet aquí: https://github.com/near/nearcore/releases, por ejemplo, la versión actual es 2.4.0, por lo que el comando de checkout será git checkout 2.4.0

Este proceso de compilación (make release) tomará alrededor de 15 minutos, necesitas esperar antes de pasar a los siguientes comandos.
Autorizar billetera
near login
Nota: Este comando abre un navegador web que permite la autorización de una clave de acceso completa para ser copiada localmente.

1 - Copia el enlace en tu navegador


2 - Concede acceso a Near CLI, elige "Almacenar la clave de acceso en mi llavero" desde el comando CLI.


3 - Después de conceder, ingresa tu dirección de validador (lncvalidator.near en este caso) y presiona Enter
Inicializar y comenzar el nodo
Definiciones:

 	<pool_id> o pool_id - tu nombre de grupo, por ejemplo lncvalidator
 	<full_pool_id> o full_pool_id - xxx.poolv1.near, donde xxx es tu pool_id
 	<accountId> o accountId - xxx.near donde xxx es tu nombre de cuenta, por ejemplo lncvalidator.near

cd ~/nearcore && target/release/neard init --chain-id="mainnet" --account-id=<full_pool_id>
Establece tu <full_pool_id>, por ejemplo: xxx.poolv1.near, donde xxx es tu pool_id, por ejemplo: lncvalidator.poolv1.near

validator_key.json generado después del comando anterior en la carpeta ~/.near/ debe ser algo así:



La account_id debe coincidir con el id del contrato del grupo de participación  o no podrás firmar/verificar bloques.

Nota: Si tu nodo tiene menos de 1TB de espacio en disco, deberás reducir "epoch data to keep" para evitar problemas de disco lleno mediante

actualiza ~/.near/config.json y reduce "gc_num_epochs_to_keep" a 3 en lugar de 5 por defecto:



Configura Systemd para que el nodo siempre se ejecute con el sistema
sudo nano /etc/systemd/system/neard.service
Pega:
Description=NEARd Daemon Service
[Service]
Type=simple
User=root
WorkingDirectory=/root/.near
ExecStart=/root/nearcore/target/release/neard run
Restart=on-failure
RestartSec=30
KillSignal=SIGINT
TimeoutStopSec=45
KillMode=mixed
[Install]
WantedBy=multi-user.target
Después de eso, habilita el servicio:
sudo systemctl enable neard
Sincroniza datos usando NEAR Peer-to-peer state sync:

NEAR tiene una sincronización de estado descentralizada, un protocolo tipo torrent para que los nodos sincronicen datos entre sí sin depender de proveedores de instantáneas, para sincronizar con p2p state sync, necesitarás obtener la última lista de nodos de arranque de la red NEAR y actualizar el archivo config.json y luego iniciar el servicio neard, aquí está el comando:
curl -s -X POST https://rpc.mainnet.near.org -H "Content-Type: application/json" -d '{
        "jsonrpc": "2.0",
        "method": "network_info",
        "params": [],
        "id": "dontcare"
      }' | 
jq --arg newBootNodes "$(curl -s -X POST https://rpc.mainnet.near.org -H "Content-Type: application/json" -d '{
        "jsonrpc": "2.0",
        "method": "network_info",
        "params": [],
        "id": "dontcare"
      }' | jq -r '.result.active_peers as $list1 | .result.known_producers as $list2 |
          $list1[] as $active_peer | $list2[] |
          select(.peer_id == $active_peer.id) |
          "(.peer_id)@($active_peer.addr)"' | paste -sd "," -)" 
   '.network.boot_nodes = $newBootNodes' ~/.near/config.json > ~/.near/config.tmp && mv ~/.near/config.json ~/.near/config.json.backup && mv ~/.near/config.tmp ~/.near/config.json
después de eso, simplemente reinicia el nodo (sudo systemctl restart neard) y verás algo como esto:



Espera un tiempo (quizás 10 horas) y habrás terminado, ¡sigue el siguiente paso para convertirte en un validador activo!

 

Sincroniza datos con instantánea:Para sincronizar los datos más rápido, podemos descargar la instantánea de los últimos epochs de NEAR en lugar de esperar a que el nodo se sincronice con otros pares, este proceso tomará algunas horas, se espera que el tamaño de los datos sea de alrededor de 580GB.

Ejecuta esto para descargar la instantánea y comenzar el nodo (muchas gracias a FastNEAR por mantener esto):
curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/fastnear/static/refs/heads/main/down_rclone.sh | DATA_PATH=~/.near/data CHAIN_ID=mainnet RPC_TYPE=fast-rpc bash && sudo systemctl restart neard

¡El comando sincronizará los datos y reiniciará el neard!

Si necesitas hacer un cambio en el servicio en el archivo config.json, el nodo también debe ser recargado:
sudo systemctl restart neard
Ver registros

Comando:
journalctl -n 100 -f -u neard | ccze -A


Verifica el estado de ejecución del nodo validador. Si ves algo como la imagen de arriba, significa que el nodo está completamente sincronizado, ¡y estás listo para convertirte en un validador activo!
Convertirse en un Validador Activo
Para convertirse en un validador y entrar en el conjunto de validadores para ayudar a asegurar la red y ganar recompensas, se deben cumplir un conjunto mínimo de criterios de éxito:

 	El nodo debe estar completamente sincronizado
 	El archivo validator_key.json debe estar en su lugar
 	El contrato debe estar inicializado con la clave pública en validator_key.json
 	El account_id debe estar configurado en el id del contrato de la piscina de participación
 	Debe haber suficientes delegaciones para cumplir con el precio mínimo de asiento. Consulta el precio del asiento aquí o simplemente ejecuta este comando
near-validator validators network-config mainnet next
 	Se debe enviar una propuesta pinging al contrato
 	Una vez que se acepta una propuesta, un validador debe esperar 2-3 epochs para entrar en el conjunto de validadores
 	Una vez en el conjunto de validadores, el validador debe producir más del 90% de los bloques asignados o tu nodo será expulsado

Verifica el estado de ejecución del nodo validador. Si aparece "Validador", tu pool está seleccionado en la lista actual de validadores.
Despliega tu contrato de piscina de participación
NEAR utiliza una fábrica de piscinas de participación con un contrato de participación en lista blanca para garantizar que los fondos de los delegadores estén seguros. Para ejecutar un validador en NEAR, una piscina de participación debe ser desplegada en una cuenta de NEAR e integrada en un nodo validador de NEAR. Los delegadores deben usar una interfaz de usuario o la línea de comandos para apostar en la piscina. Una piscina de participación es un contrato inteligente que se despliega en una cuenta de NEAR.

Nota: EL CONTRATO DE LA PISCINA DE PARTICIPACIÓN NO TENDRÁ ACCESO DE ESCRITURA A LOS FONDOS O DATOS DE TODAS LAS SUBCUENTAS, esto también se aplica para cualquier subcuenta en NEAR, ¡eso significa que tu saldo de participación está seguro!

Despliega un Contrato de Piscina de ParticipaciónLlama a la fábrica de pools de staking, crea un nuevo pool de staking con el nombre especificado y lo despliega en la cuenta indicada.

Para Mainnet
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "<pool_id>", "owner_id": "<accountId>", "stake_public_key": "<public_key>", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
Del ejemplo anterior, debes reemplazar:

 	pool_id: Nombre del pool de staking
ejemplo "lncvalidator"
 	owner_id:: La cuenta NEAR que gestionará el pool de staking. Normalmente tu cuenta principal de NEAR.
 	public_key: La clave pública en tu archivo validator_key.json.
 	5: La comisión que cobrará el pool (por ejemplo, en este caso 5 sobre 100 es el 5% de comisión), normalmente los validadores cobran una comisión del 5%, si estableces la comisión tan alta, nadie apostará en tu nodo ;) 
 	accountId: La cuenta NEAR que despliega el pool de staking.

Asegúrate de tener al menos 30 NEAR disponibles, es el mínimo requerido para almacenamiento.

El comando final se verá algo así:
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "lncvalidator", "owner_id": "lncvalidator.near", "stake_public_key": "ed25519:A9RdmNFxxx", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as lncvalidator.near network-config mainnet sign-with-keychain
Para cambiar los parámetros del pool, como cambiar la cantidad de comisión cobrada al 1% en el ejemplo a continuación, utiliza este comando:
near contract call-function as-transaction <full_pool_id> update_reward_fee_fraction json-args '{"reward_fee_fraction": {"numerator": 1, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <account_id> network-config mainnet sign-with-keychain
Nota: full_pool_id: <pool_id>.poolv1.near , en este caso es lncvalidator.poolv1.near .

Verás algo como esto:


Si hay un "True" al final. Tu pool está creado.

¡Felicidades! Ahora has configurado tu pool de staking y está en funcionamiento 🚀🚀🚀🚀
Administra tu contrato de pool de staking
Algunos comandos útiles que debes conocer:

Recupera el ID del propietario del pool de stakingnear contract call-function as-read-only <full_pool_id> get_owner_id json-args {} network-config mainnet now
Emite este comando para recuperar la clave pública que la red tiene para tu validador
near contract call-function as-read-only <full_pool_id> get_staking_key json-args {} network-config mainnet now
Si la clave pública no coincide, puedes actualizar la clave de staking de esta manera (reemplaza la clave pública a continuación con la clave en tu archivo validator.json)
near contract call-function as-transaction <full_pool_id> update_staking_key json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
Trabajando con Pools de Staking
NOTA: Tu validador debe estar completamente sincronizado antes de emitir una propuesta o depositar fondos.
Propuestas y Pings
Para obtener un asiento de validador, primero debes enviar una propuesta con una cantidad adecuada de stake. Las propuestas se envían para el epoch +2. Esto significa que si envías una propuesta ahora, si es aprobada, obtendrías el asiento en 3 epochs. Debes enviar una propuesta cada epoch para asegurar tu asiento. Para enviar una propuesta usamos el comando ping. También se envía una propuesta si se envía un comando de stake o unstake al contrato de staking pool.

Cabe destacar que un ping también actualiza los saldos de staking para tus delegadores. Deberías emitir un ping cada epoch para mantener actualizadas las recompensas reportadas en el contrato de pool. Podrías configurar un ping usando un trabajo cron con un script de ping aquí.

Crea un nuevo archivo en /home/root/scripts/ping.sh y llénalo:
#!/bin/sh
# Llamada de ping para renovar Propuesta agregada a crontab

export NEAR_ENV=mainnet
export LOGS=/home/root/logs
export POOLID=<full_pool_id>
export ACCOUNTID=<account_id>

echo "---" >> $LOGS/all.log
date >> $LOGS/all.log

near contract call-function as-transaction $POOLID ping json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $ACCOUNTID network-config mainnet sign-with-keychain >> $LOGS/all.log


Crea la carpeta de logs:
mkdir $HOME/logs
Cambia los permisos de ejecución para el archivo ping.sh:
chmod +x $HOME/scripts/ping.sh
Crea un nuevo crontab, personalmente lo configuro para que se ejecute cada 8 horas:
crontab -e
Llena esto y guarda
0 */8 * * * sh /home/root/scripts/ping.sh
Lista el crontab para ver si está corriendo:
crontab -l
Revisa tus logs
cat $HOME/logs/all.log¡Eso es todo, ahora necesitas tener suficientes tokens delegados para ser un validador activo, bienvenido al descentralizado Protocolo NEAR y ganar recompensas en el camino! 🚀🚀🚀🚀 💪💪💪💪 🛳️🛳️🛳️👽👽👽🛸🛸🛸
Optimizaciones de red
Para optimizar la configuración de red para un mejor rendimiento del validador, ejecuta los siguientes comandos:
MaxExpectedPathBDP=8388608
sudo sysctl -w net.core.rmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.core.wmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.ipv4.tcp_rmem="4096 87380 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_wmem="4096 16384 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_slow_start_after_idle=0

Estos cambios no persisten después de reiniciar el sistema. Para aplicarlos automáticamente al inicio, agrega lo siguiente en /etc/sysctl.d/local.conf:
net.core.rmem_max = 8388608
net.core.wmem_max = 8388608
net.ipv4.tcp_rmem = 4096 87380 8388608
net.ipv4.tcp_wmem = 4096 16384 8388608
net.ipv4.tcp_slow_start_after_idle = 0
Opcional: Enviar información de la piscina
Agregar información de la piscina ayuda a los delegadores y también ayuda con la difusión para actualizaciones y otros anuncios importantes: https://github.com/zavodil/near-pool-details.

Los campos disponibles para agregar son: https://github.com/zavodil/near-pool-details/blob/master/FIELDS.md.

La información identificativa que los validadores deben proporcionar son: nombre, descripción, URL, telegram, twitter,...

Comandos de ejemplo:

Cambiar nombre y descripción del validador:

 	Reemplaza <full_pool_id> con la dirección de tu piscina, por ejemplo: lncvalidator.poolv1.near
 	Reemplaza <accountId> con la dirección de tu billetera autenticada, lncvalidator.near en este caso

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "name", "value": "LearnNEARClub"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "description", "value": "LearnNEARClub Validator!"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain


Ver tus informaciones de validador desde la CLI:
near contract call-function as-read-only pool-details.near get_fields_by_pool json-args '{"pool_id":"<full_pool_id>"}' network-config mainnet now
 

Ver informaciones del validador en NEARScope o NEARBlocks:

La información se mostrará así: (fuente: NearScope)
Mantenimiento del nodo
Es importante mantener tu nodo y mantenerlo funcionando de manera estable, aquí tienes algunas cosas importantes que necesitas saber.
Códigos de estado del nodo

 	ROJO: ¡actualiza tu nodo lo ANTES POSIBLE! Algo crítico ha sucedido, repito, ¡actualízalo LO MÁS PRONTO POSIBLE!
 	AMARILLO: necesitas actualizar el nodo, pero no es demasiado urgente por ahora. 
Más información aquí: https://near-nodes.io/maintenance/maintenance#runtime-alerts

Comunidad de Validadores de NEAR en Telegram
Únete al grupo para obtener actualizaciones del nodo, soporte y más, por favor utiliza este grupo para preguntas y discusiones relacionadas con la ejecución de un validador en NEAR.
https://t.me/near_validators
Actualizar nueva versión del nodo
Cuando haya una nueva versión del nodo, recibirás una notificación en el grupo de Validadores de Telegram, ejecuta este comando para actualizar el nodo.
cd ~/nearcore && git fetch && export NEAR_RELEASE_VERSION=<node_version> && git checkout $NEAR_RELEASE_VERSION && make release && sudo systemctl stop neard && sudo systemctl start neard
Reemplaza <node_version> con la versión correcta de la versión de nearcore.
Monitorear el rendimiento del nodo
Monitorea el nodo de manera profesional:
https://near-nodes.io/validator/validator-bootcamp#grafana

Monitorea el nodo de manera informal:
 He creado un pequeño bot para ayudarte a monitorear rápidamente el tiempo de actividad del validador aquí, puedes echar un vistazo:
https://x.com/cuongdc_real/status/1839769081723138239

Retira tus recompensas
Básicamente solo inicia sesión en cualquier billetera en NEAR y reclama tus recompensas de validador en la sección de staking de la billetera.
Comandos útiles
Algunos otros comandos útiles que deberías conocer:

 	Obtener la lista de validadores activos y el precio actual del asiento, su rendimiento actual: near-validator validators network-config mainnet now
 	Próxima lista de validadores: near-validator validators network-config mainnet next
 	Ver el saldo apostado del validador: near-validator staking view-stake <full_pool_id> network-config mainnet now

Básicamente solo inicia sesión en cualquier billetera en NEAR y reclama tus recompensas de validador en la sección de staking de la billetera.
Recursos
 	Concepto de Validadores de NEAR: https://docs.near.org/concepts/basics/validators
 	Nodos de NEAR - La documentación oficial de Validadores de NEAR que todos los validadores deberían revisar: https://near-nodes.io/
 	Calcular recompensas de staking de NEAR: https://www.stakingrewards.com/asset/near-protocol
 	Estado de la Cadena de NEAR en Twitter: https://x.com/NEARChainStatus
 	Ver información de validadores en estos sitios web

 	https://near-staking.com/
 	https://nearblocks.io/node-explorer



Conclusión
¡Muchas gracias por leer hasta aquí! Eso es todo lo que quería compartir sobre cómo ejecutar un validador en NEAR.
En mi experiencia, ejecutar un nodo de NEAR es sencillo y casi sin errores, con muchos menos problemas en comparación con otras cadenas de alta actividad. NEAR requiere significativamente menos recursos del servidor debido a su fragmentación con Nightshade. ¡Además, ganas recompensas en el camino!

Hablando de recompensas, pronto, los validadores de NEAR también tendrán la oportunidad de ganar recompensas por ejecutar la red MPC, que contribuye al servicio de Abstracción de Cadena de NEAR para el ecosistema Web3 más amplio. Con su visión de construir la Web Abierta a través de la Abstracción de Cadena y IA Propia del Usuario, NEAR está preparado para ver aún más actividad en la red, brindando a los validadores la oportunidad de ganar recompensas adicionales.

Como validador, tu papel es crucial para asegurar una red de alto rendimiento como NEAR. Al proteger NEAR, también estás apoyando muchas aplicaciones construidas en la red, como Kaiching (una aplicación de devolución de efectivo utilizada por millones en Singapur), Sweatcoin (una aplicación de salud y fitness con 100 millones de usuarios en todo el mundo), HOT (una billetera Web3 que sirve como puerta de entrada para nuevos usuarios de criptomonedas) y Ref Finance (un intercambio descentralizado en NEAR).

Estas aplicaciones sirven a millones de usuarios diariamente, ¡y como validador, eres esencial para ayudarles a mantener sus servicios y crecer!

### AI Глоссарий для начинающих

Основные концепции
Искусственный интеллект (ИИ)
Область создания компьютерных систем, способных выполнять задачи, обычно требующие человеческого интеллекта. Представьте ИИ как обучение компьютеров "думать" и решать проблемы. Современный ИИ повсюду - от рекомендаций Netflix до распознавания лиц на смартфонах.

Машинное обучение (ML)
Подмножество ИИ, где компьютеры учатся на примерах, а не следуют жестким правилам. Представьте, что вы учитесь ребенка распознавать кошек, показывая ему много фотографий кошек, вместо того чтобы перечислять правила типа "имеет острые уши, имеет шерсть". Компьютер аналогично изучает шаблоны из данных.

Глубокое обучение
Мощный тип машинного обучения с использованием нейронных сетей с множеством слоев. Подобно тому, как несколько экспертов работают вместе, каждый слой изучает различные аспекты данных. Глубокое обучение обеспечивает современные прорывы в ИИ в области распознавания изображений, перевода языка и многих других.

Ключевые компоненты
Нейронная сеть
Вычислительная система, вдохновленная структурой человеческого мозга. Представьте ее как сложную сеть взаимосвязанных узлов, передающих информацию друг другу. Каждое соединение может укрепляться или ослабляться по мере обучения сети, аналогично тому, как наши мозги формируют и укрепляют нейронные пути.

Алгоритм
Последовательная процедура решения проблемы. В повседневных терминах это похоже на кулинарный рецепт - конкретные инструкции, которые, если следовать им правильно, приводят к желаемому результату. Алгоритмы ИИ - это рецепты для обработки данных и принятия решений.

Обучающие данные
Информация, используемая для обучения моделей ИИ. Как студенту нужны примеры для обучения, так и ИИ нужны данные для изучения шаблонов. Например, для распознавания спам-писем ИИ нужно видеть много примеров как спама, так и легитимных писем.

Важные процессы
Обучение
Процесс обучения модели ИИ с использованием данных. Аналогично тому, как студенты учатся через практику, модели ИИ улучшают свою производительность, обрабатывая множество примеров. Обучение включает в себя:


 	Эпоха: Одно полное прохождение всех обучающих данных
 	Функция потерь: Измеряет количество ошибок, совершаемых моделью
 	Градиентный спуск: Математический метод для улучшения точности модели

Тонкая настройка
Адаптация заранее обученной модели ИИ для конкретной задачи. Подобно тому, как общее образование переходит в специализацию в определенной области. Например, взятие модели, обученной на общем английском языке, и тонкая настройка ее для медицинской терминологии.Концепции языковой модели
Токен
Основная единица текста, которую обрабатывает искусственный интеллект. Токены могут быть словами, частями слов или даже знаками препинания. Например, "искусственный интеллект" может быть разделен на токены типа ["искус", "ственный", " интеллект"].

Длина контекста
Количество информации, которое искусственный интеллект может рассматривать одновременно. Как кратковременная память человека, это "окно" текста, которое видит искусственный интеллект при генерации ответов. Более длинные контексты позволяют модели поддерживать последовательность в более длинных разговорах.

Инженерия запросов
Искусство эффективного взаимодействия с искусственными интеллектами. Как искусство задавать правильные вопросы, чтобы получить полезные ответы, инженерия запросов включает создание входных данных, направляющих искусственный интеллект на производство желаемых результатов.

Подходы к обучению
Обучение с учителем
Обучение, при котором искусственный интеллект учится на основе размеченных примеров. Как ученик, использующий ключи к ответам, модель учится сопоставлять входные данные с правильными результатами. Пример: обучение классификации электронных писем как спама или не спама на основе ранее размеченных писем.

Обучение без учителя
Обучение, при котором искусственный интеллект находит закономерности в неразмеченных данных. Как ученый, обнаруживающий естественные категории в данных без указаний, пример: группировка клиентов по сегментам на основе их поведения при покупках.

Обучение с подкреплением
Обучение через пробу и ошибку с наградами и штрафами. Как обучение домашних животных - хорошие поведенческие модели вознаграждаются, плохие - наказываются. Пример: искусственный интеллект, обучающийся играть в шахматы путем практики и выигрыша/проигрыша в играх.

Продвинутые концепции
AGI (Искусственный общий интеллект)
Теоретический будущий искусственный интеллект, который мог бы соответствовать уровню человеческого интеллекта во всех задачах. В отличие от текущих систем искусственного интеллекта, которые отлично справляются с определенными задачами, но испытывают трудности с другими, AGI был бы универсальным, как человеческий интеллект. Пока что он не существует и остается объектом исследований.

Трансформер
Мощная архитектура искусственного интеллекта, которая революционизировала обработку языка. Как умный помощник, способный обращать внимание на несколько вещей одновременно, трансформеры могут эффективно обрабатывать отношения между различными частями текста.

Обучение с нулевым и малым количеством примеров
Способность искусственного интеллекта выполнять новые задачи с минимальным или без специального обучения. Как человек, использующий общие знания для решения новых ситуаций, эти возможности позволяют искусственному интеллекту быть более гибким и адаптивным.Этические соображения
Предвзятость в ИИ
Системы искусственного интеллекта могут унаследовать и усилить человеческие предвзятости, присутствующие в обучающих данных. Подобно человеческим предубеждениям, эти предвзятости могут привести к несправедливым или дискриминационным результатам. Признание и устранение предвзятости крайне важно для ответственного развития ИИ.

Объяснимость
Способность понять, почему ИИ принял определенное решение. Важно для доверия и ответственности, как и возможность понять, почему врач поставил определенный диагноз. Некоторые системы ИИ являются "черными ящиками", где решения трудно объяснить.

Конфиденциальность и безопасность
Опасения относительно того, как ИИ системы обрабатывают персональные данные и потенциальные уязвимости. Важными аспектами являются защита данных, согласие и предотвращение злоупотребления технологиями ИИ.

Лучшие практики
Оценка модели
Методы оценки производительности ИИ, включая:


 	Тестирование на новых данных для обеспечения эффективности в реальном мире
 	Мониторинг предвзятостей и ошибок
 	Регулярные обзоры производительности и обновления

Качество данных
Важность использования высококачественных, репрезентативных обучающих данных. Как строить дом на крепком фундаменте, хорошие данные необходимы для надежных систем ИИ.

### Glosario de IA para principiantes

Conceptos clave
Inteligencia Artificial (IA)
El campo de creación de sistemas informáticos que pueden realizar tareas que normalmente requieren inteligencia humana. Piense en la IA como enseñar a las computadoras a "pensar" y resolver problemas. La IA moderna está en todas partes, desde recomendaciones de Netflix hasta reconocimiento facial en teléfonos inteligentes.

Aprendizaje Automático (ML)
Un subconjunto de la IA donde las computadoras aprenden a partir de ejemplos en lugar de seguir reglas rígidas. Imagine enseñar a un niño a reconocer gatos mostrándole muchas imágenes de gatos, en lugar de enumerar reglas como "tiene orejas puntiagudas, tiene pelaje". De manera similar, la computadora aprende patrones a partir de datos.

Aprendizaje Profundo
Un tipo poderoso de aprendizaje automático que utiliza redes neuronales con muchas capas. Como tener múltiples expertos trabajando juntos, cada capa aprende diferentes aspectos de los datos. El aprendizaje profundo impulsa los avances modernos en IA en reconocimiento de imágenes, traducción de idiomas y más.

Componentes clave
Red Neuronal
Un sistema informático inspirado en la estructura del cerebro humano. Imagínelo como una compleja red de nodos interconectados que se pasan información entre sí. Cada conexión puede fortalecerse o debilitarse a medida que la red aprende, de manera similar a cómo se forman y fortalecen las vías neuronales en nuestro cerebro.

Algoritmo
Un procedimiento paso a paso para resolver un problema. En términos cotidianos, es como una receta de cocina: instrucciones específicas que, cuando se siguen correctamente, producen el resultado deseado. Los algoritmos de IA son recetas para procesar datos y tomar decisiones.

Datos de Entrenamiento
La información utilizada para enseñar a los modelos de IA. Al igual que un estudiante necesita ejemplos para aprender, la IA necesita datos para aprender patrones. Por ejemplo, para reconocer correos electrónicos no deseados, una IA necesita ver muchos ejemplos tanto de correos no deseados como legítimos.

Procesos importantes
Entrenamiento
El proceso de enseñar a un modelo de IA utilizando datos. De manera similar a cómo los estudiantes aprenden a través de la práctica, los modelos de IA mejoran su rendimiento procesando muchos ejemplos. El entrenamiento implica:


 	Época: Un pase completo a través de todos los datos de entrenamiento
 	Función de Pérdida: Mide cuántos errores comete el modelo
 	Descenso del Gradiente: El método matemático para mejorar la precisión del modelo

Ajuste fino
Adaptar un modelo de IA pre-entrenado para una tarea específica. Como tomar una educación general y especializarse en un campo particular. Por ejemplo, tomar un modelo entrenado en inglés general y ajustarlo finamente para terminología médica.Conceptos del Modelo de Lenguaje
Token
La unidad básica de texto que procesa la IA. Los tokens pueden ser palabras, partes de palabras o incluso puntuación. Por ejemplo, "inteligencia artificial" podría dividirse en tokens como ["int", "elig", "encia"].

Longitud del Contexto
La cantidad de información que un modelo de IA puede considerar a la vez. Al igual que la memoria a corto plazo humana, es la "ventana" de texto que la IA puede ver al generar respuestas. Longitudes de contexto más largas permiten al modelo mantener consistencia en conversaciones más largas.

Ingeniería de la Solicitud
El arte de comunicarse efectivamente con los modelos de IA. Al igual que aprender a hacer las preguntas correctas para obtener respuestas útiles, la ingeniería de la solicitud implica crear entradas que guíen a la IA para producir salidas deseadas.

Enfoques de Aprendizaje
Aprendizaje Supervisado
Entrenamiento donde la IA aprende a partir de ejemplos etiquetados. Al igual que un estudiante que aprende con una clave de respuestas, el modelo aprende a relacionar las entradas con las salidas correctas. Ejemplo: Aprender a clasificar correos electrónicos como spam o no spam basándose en correos electrónicos previamente etiquetados.

Aprendizaje No Supervisado
Entrenamiento donde la IA encuentra patrones en datos no etiquetados. Al igual que un científico que descubre categorías naturales en datos sin que le digan qué buscar. Ejemplo: Agrupar clientes en segmentos basados en su comportamiento de compra.

Aprendizaje por Refuerzo
Aprendizaje a través de ensayo y error con recompensas y penalizaciones. Al igual que entrenar a una mascota: se premian los buenos comportamientos y se desalientan los malos. Ejemplo: IA aprendiendo a jugar ajedrez practicando y ganando/perdiendo juegos.

Conceptos Avanzados
AGI (Inteligencia Artificial General)
Una futura IA teórica que podría igualar la inteligencia a nivel humano en todas las tareas. A diferencia de los sistemas de IA actuales que sobresalen en tareas específicas pero tienen dificultades con otras, AGI sería versátil como la inteligencia humana. Aún no existe y sigue siendo un tema de investigación.

Transformador
Una potente arquitectura de IA que revolucionó el procesamiento del lenguaje. Al igual que tener un asistente inteligente que puede prestar atención a múltiples cosas simultáneamente, los transformadores pueden procesar relaciones entre diferentes partes del texto de manera efectiva.

Aprendizaje Zero-shot y Few-shot
La capacidad de la IA para realizar nuevas tareas con un entrenamiento mínimo o nulo. Al igual que un humano que utiliza conocimientos generales para manejar nuevas situaciones, estas capacidades permiten que la IA sea más flexible y adaptable.Consideraciones éticas
Prejuicios en la IA
Los sistemas de IA pueden heredar y amplificar los prejuicios humanos presentes en los datos de entrenamiento. Al igual que los prejuicios humanos, estos sesgos pueden llevar a resultados injustos o discriminatorios. Reconocer y abordar los prejuicios es crucial para el desarrollo responsable de la IA.

Explicabilidad
La capacidad de entender por qué una IA tomó una decisión particular. Importante para la confianza y la responsabilidad, como poder entender por qué un médico hizo un diagnóstico específico. Algunos sistemas de IA son "cajas negras" donde las decisiones son difíciles de explicar.

Privacidad y Seguridad
Preocupaciones sobre cómo los sistemas de IA manejan los datos personales y las posibles vulnerabilidades. Consideraciones importantes incluyen la protección de datos, el consentimiento y la prevención del mal uso de las tecnologías de IA.

Mejores Prácticas
Evaluación del Modelo
Métodos para evaluar el rendimiento de la IA, incluyendo:


 	Pruebas en nuevos datos para garantizar la efectividad en el mundo real
 	Monitoreo de prejuicios y errores
 	Revisiones periódicas de rendimiento y actualizaciones

Calidad de Datos
La importancia de utilizar datos de entrenamiento de alta calidad y representativos. Al igual que construir una casa sobre una base sólida, los buenos datos son esenciales para sistemas de IA confiables.

### Glossário de IA para iniciantes

Conceitos Principais
Inteligência Artificial (IA)
O campo de criação de sistemas de computador que podem realizar tarefas que normalmente requerem inteligência humana. Pense na IA como ensinar computadores a "pensar" e resolver problemas. A IA moderna está em toda parte - desde recomendações da Netflix até reconhecimento facial em smartphones.

Aprendizado de Máquina (AM)
Um subconjunto da IA onde os computadores aprendem a partir de exemplos em vez de seguir regras rígidas. Imagine ensinar uma criança a reconhecer gatos mostrando muitas fotos de gatos, em vez de listar regras como "tem orelhas pontudas, tem pelo." O computador aprende padrões a partir de dados de forma semelhante.

Aprendizado Profundo
Um poderoso tipo de aprendizado de máquina que utiliza redes neurais com muitas camadas. Como ter vários especialistas trabalhando juntos, cada camada aprende diferentes aspectos dos dados. O aprendizado profundo impulsiona avanços modernos em IA em reconhecimento de imagem, tradução de idiomas e muito mais.

Componentes Chave
Rede Neural
Um sistema de computação inspirado na estrutura do cérebro humano. Imagine como uma rede complexa de nós interconectados que passam informações uns aos outros. Cada conexão pode ser fortalecida ou enfraquecida à medida que a rede aprende, semelhante à forma como nossos cérebros formam e fortalecem vias neurais.

Algoritmo
Um procedimento passo a passo para resolver um problema. Em termos cotidianos, é como uma receita de culinária - instruções específicas que, quando seguidas corretamente, produzem o resultado desejado. Algoritmos de IA são receitas para processar dados e tomar decisões.

Dados de Treinamento
As informações usadas para ensinar modelos de IA. Assim como um aluno precisa de exemplos para aprender, a IA precisa de dados para aprender padrões. Por exemplo, para reconhecer e-mails de spam, uma IA precisa ver muitos exemplos de e-mails de spam e legítimos.

Processos Importantes
Treinamento
O processo de ensinar um modelo de IA usando dados. Semelhante à forma como os alunos aprendem por meio da prática, os modelos de IA melhoram seu desempenho processando muitos exemplos. O treinamento envolve:


 	Época: Uma passagem completa por todos os dados de treinamento
 	Função de Perda: Mede quantos erros o modelo comete
 	Descida de Gradiente: O método matemático para melhorar a precisão do modelo

Ajuste Fino
Adaptação de um modelo de IA pré-treinado para uma tarefa específica. Como fazer uma educação geral e se especializar em um campo específico. Por exemplo, pegar um modelo treinado em inglês geral e ajustá-lo para terminologia médica.Conceitos do Modelo de Linguagem
Token
A unidade básica de texto que a IA processa. Tokens podem ser palavras, partes de palavras ou até mesmo pontuação. Por exemplo, "inteligência artificial" pode ser dividida em tokens como ["int", "igência", " artificial"].

Comprimento do Contexto
A quantidade de informações que um modelo de IA pode considerar de uma vez. Como a memória de curto prazo humana, é a "janela" de texto que a IA pode ver ao gerar respostas. Comprimentos de contexto mais longos permitem que o modelo mantenha consistência ao longo de conversas mais extensas.

Engenharia de Prompt
A arte de se comunicar efetivamente com modelos de IA. Assim como aprender a fazer as perguntas certas para obter respostas úteis, a engenharia de prompt envolve a criação de inputs que orientam a IA a produzir saídas desejadas.

Abordagens de Aprendizado
Aprendizado Supervisionado
Treinamento no qual a IA aprende a partir de exemplos rotulados. Como um aluno aprendendo com um gabarito, o modelo aprende a associar inputs a saídas corretas. Exemplo: Aprender a classificar emails como spam ou não spam com base em emails previamente rotulados.

Aprendizado Não Supervisionado
Treinamento no qual a IA encontra padrões em dados não rotulados. Como um cientista descobrindo categorias naturais em dados sem ser informado sobre o que procurar. Exemplo: Agrupar clientes em segmentos com base em seu comportamento de compras.

Aprendizado por Reforço
Aprendizado por tentativa e erro com recompensas e penalidades. Como treinar um animal de estimação - comportamentos bons são recompensados, os ruins são desencorajados. Exemplo: IA aprendendo a jogar xadrez praticando e ganhando/perdendo jogos.

Conceitos Avançados
AGI (Inteligência Artificial Geral)
Uma IA teórica futura que poderia igualar a inteligência humana em todas as tarefas. Ao contrário dos sistemas de IA atuais que se destacam em tarefas específicas, mas têm dificuldade em outras, a AGI seria versátil como a inteligência humana. Ainda não existe e permanece um tópico de pesquisa.

Transformer
Uma arquitetura de IA poderosa que revolucionou o processamento de linguagem. Como ter um assistente inteligente que pode prestar atenção em várias coisas simultaneamente, os transformers podem processar relacionamentos entre diferentes partes de texto de forma eficaz.

Aprendizado Zero-shot e Few-shot
A capacidade da IA de realizar novas tarefas com treinamento mínimo ou nenhum treinamento específico. Assim como um humano usando conhecimento geral para lidar com novas situações, essas capacidades permitem que a IA seja mais flexível e adaptável.Considerações Éticas
Viés na IA
Os sistemas de IA podem herdar e amplificar os preconceitos humanos presentes nos dados de treinamento. Assim como os preconceitos humanos, esses viés podem levar a resultados injustos ou discriminatórios. Reconhecer e abordar o viés é crucial para o desenvolvimento responsável da IA.

Explicabilidade
A capacidade de entender por que uma IA tomou uma decisão específica. Importante para confiança e responsabilidade, como ser capaz de entender por que um médico fez um diagnóstico específico. Alguns sistemas de IA são "caixas-pretas" onde as decisões são difíceis de explicar.

Privacidade e Segurança
Preocupações sobre como os sistemas de IA lidam com dados pessoais e vulnerabilidades potenciais. Considerações importantes incluem proteção de dados, consentimento e prevenção de uso indevido de tecnologias de IA.

Melhores Práticas
Avaliação do Modelo
Métodos para avaliar o desempenho da IA, incluindo:


 	Testar em novos dados para garantir eficácia no mundo real
 	Monitorar viés e erros
 	Avaliações regulares de desempenho e atualizações

Qualidade dos Dados
A importância de usar dados de treinamento de alta qualidade e representativos. Assim como construir uma casa em uma base sólida, bons dados são essenciais para sistemas de IA confiáveis.

### Cách chạy một nút xác thực NEAR vào năm 2025

Giới thiệu
Bây giờ là thời điểm tốt để học cách chạy validator trên NEAR!

Chúng tôi quan tâm rất nhiều đến sự phân quyền @NEARProtocol . Trong bản phát hành mới nhất (2.2.1), ngưỡng cọc để trở thành một validator đã được giảm xuống còn ~11k NEAR, ít hơn gần một nửa so với trước đây. Nếu bạn là một validator, đây là thời điểm tốt để tham gia!

 Bạn nghĩ sao về một chương trình để thu hút nhiều validator hơn? Đưa NEAR lên 1k trong vài tháng tới?[/caption>

Vậy, trong hướng dẫn này, tôi sẽ hướng dẫn bạn cách chạy một validator trên mạng chính NEAR. Hướng dẫn dễ dàng này sẽ giúp bạn nhanh chóng tham gia và xác minh mạng NEAR, đóng góp vào sự phân quyền và sự chống chịu của nó, và kiếm được phần thưởng của validator trên đường đi!

Là một thành viên cộng đồng NEAR, tôi đã chạy một nút NEAR trong hơn hai năm, bắt đầu từ Stake Wars 3 (2022). Trong hướng dẫn này, tôi sẽ cung cấp cho bạn một hướng dẫn chi tiết, từng bước để bạn có thể thiết lập nút NEAR đầy đủ của riêng mình dựa trên kinh nghiệm của tôi suốt những năm qua!

Tôi rất háo hức chia sẻ tất cả những gì tôi đã học được, cung cấp hướng dẫn rõ ràng, chi tiết để hướng dẫn bạn qua quá trình thiết lập nút validator của riêng bạn trên NEAR! Hãy đạt được 1000 validator hoạt động trên NEAR!


Tại sao bạn nên chạy một nút NEAR?
NEAR là blockchain với một lượng hoạt động lớn trong không gian web3 nhưng yêu cầu tối thiểu để chạy một nút tương đối nhẹ, giá rẻ và dễ bảo trì hơn so với các mạng khác.

Các blockchain hàng đầu về hoạt động, nguồn: Artemis.


Và đây là yêu cầu về phần cứng tối thiểu để chạy một nút trên một số chuỗi phổ biến (theo hoạt động mạng)

 Yêu cầu của Validator NEAR[/caption>

Về cơ bản, yêu cầu cho nút NEAR giống như một laptop tiêu dùng mà bạn có thể tìm thấy ở hầu hết mọi nơi (tốt nhất là chạy trên một laptop chơi game theo ý kiến của tôi 😆).Điều tuyệt vời về NEAR là bạn không cần một mainframe (> 512GB ram, 300TB không gian ổ đĩa) hoặc thậm chí phải thiết lập một trung tâm cơ sở dữ liệu hoàn chỉnh để chạy và thực sự bạn có thể có lợi nhuận mà không cần phải chi trả chi phí cơ sở của Quỹ, khác với các chuỗi khác!

Tất nhiên, với node, máy mạnh càng tốt, nó hoạt động tốt hơn!
Cá nhân tôi chạy node của mình trên một máy với 32gb RAM và 2TB NVME SSD trên 12 lõi CPU, chi phí khoảng 70$/tháng.

Lý do khác là khi bạn cần chạy các ứng dụng phụ thuộc nặng vào hiệu suất và/hoặc sẵn có của RPC, phát triển và triển khai hợp đồng trên một node cục bộ (độc lập và cô lập) hoặc nhanh chóng trích xuất dữ liệu blockchain có thể được sử dụng cho phân tích chuỗi, khám phá khối, v.v...

Đó chính là lý do để lạc quan 🐂 về việc chạy một node NEAR, vì vậy chúng ta bắt đầu ngay bây giờ!
Cài đặt
Yêu cầu

 	Bạn có thể sử dụng bất kỳ bản phân phối Linux nào nhưng trong hướng dẫn này tôi sẽ sử dụng Ubuntu, yêu cầu cho phiên bản Ubuntu là 20.04 hoặc mới hơn, máy của tôi đang chạy 22.04
 	Yêu cầu phần cứng tối thiểu:

 	8GB RAM (khuyến nghị 16gb+)
 	~1 TB NVME SSD (khuyến nghị 1.5TB+)
 	CPU với 8 lõi, tính năng CPU: CMPXCHG16B, POPCNT, SSE4.1, SSE4.2, AVX, SHA-NI
 	Băng thông mạng 1Gbit.



Thiết lập
Thiết lập NEAR mainnet
Bạn sẽ cần một địa chỉ NEAR để chạy node, địa chỉ này cũng sẽ nhận được phần thưởng mạng cho việc chạy một validator hoạt động.

 	Tạo một địa chỉ NEAR có tên MIỄN PHÍ tại đây: https://wallet.meteorwallet.app Tôi đã tạo lncvalidator.near cho hướng dẫn này

 	Nạp khoảng 31 NEAR vào địa chỉ, cần 30 NEAR để tạo pool đặt cược và sẽ bị khóa để lưu trữ, bạn có thể khôi phục những NEAR đó sau này nếu bạn không chạy node nữa.
 	Nhập tài khoản vào https://app.mynearwallet.com/

Cài đặt thư viện và Nearcore
Bây giờ là phần vui vẻ, hãy thiết lập node NEAR, đăng nhập vào máy chủ của bạn và chạy các lệnh sau đầu tiên để cập nhật hệ điều hành, cài đặt công cụ và thư viện (near-cli, node, Python, Git, docker...).

Vui lòng lưu ý: Tất cả các lệnh trong hướng dẫn này sẽ cần phải chạy dưới người dùng root!
sudo apt update && sudo apt upgrade -y && sudo apt install -y git binutils-dev libcurl4-openssl-dev zlib1g-dev libdw-dev libiberty-dev cmake gcc g++ python3 docker.io protobuf-compiler libssl-dev pkg-config clang llvm awscli tmux jq ccze nodejs rclone
Cài đặt Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"rustup -V
Trong quá trình cài đặt, nếu được hỏi, chỉ cần nhấn Yes và mặc định cho mọi thứ!

Cài đặt NEAR Rust CLI và tiện ích mở rộng NEAR-Validator
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh &&
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near-cli-rs/near-validator-cli-rs/releases/latest/download/near-validator-installer.sh | sh && 
source $HOME/.cargo/env
Clone thư mục nearcore, chọn nhánh ổn định mới nhất cho mainnet và xây dựng nearcore từ mã nguồn
cd ~ && git clone https://github.com/near/nearcore && cd nearcore/ && git checkout <VERSION>
make release
echo 'export NEAR_ENV=mainnet' >> ~/.bashrc
source ~/.bashrc
đối với <VERSION>, lấy phiên bản phát hành mainnet mới nhất tại đây: https://github.com/near/nearcore/releases, ví dụ, phiên bản hiện tại là 2.4.0, vì vậy lệnh checkout sẽ trở thành git checkout 2.4.0

Quá trình xây dựng này (make release) sẽ mất khoảng 15 phút, bạn cần phải đợi trước khi chuyển sang các lệnh tiếp theo.
Ủy quyền ví
near login
Lưu ý: Lệnh này mở trình duyệt web cho phép ủy quyền một khóa truy cập đầy đủ để được sao chép cục bộ.

1 - Sao chép liên kết trong trình duyệt của bạn


2 - Cấp quyền truy cập cho Near CLI


3 - Sau khi cấp quyền, điền địa chỉ validator của bạn (lncvalidator.near trong trường hợp này) và nhấn Enter
Khởi tạo & Bắt đầu Node
Định nghĩa:

 	<pool_id> hoặc pool_id - tên pool của bạn, ví dụ lncvalidator
 	<full_pool_id> hoặc full_pool_id - xxx.poolv1.near, trong đó xxx là pool_id của bạn
 	<accountId> hoặc accountId - xxx.near trong đó xxx là tên tài khoản của bạn, ví dụ lncvalidator.near

cd ~/nearcore && target/release/neard init --chain-id="mainnet" --account-id=<full_pool_id>
Đặt <full_pool_id> của bạn, ví dụ: xxx.poolv1.near, trong đó xxx là pool_id của bạn, ví dụ: lncvalidator.poolv1.near



validator_key.json được tạo sau lệnh trên trong thư mục ~/.near/ phải giống như sau:

account_id phải khớp với id hợp đồng staking pool  hoặc bạn sẽ không thể ký/ xác minh các khối.

Lưu ý: Nếu nút của bạn chỉ có ít hơn 1TB không gian đĩa, bạn sẽ cần giảm "epoch data to keep" để tránh vấn đề đầy ổ đĩa bằng cách

cập nhật ~/.near/config.json và giảm "gc_num_epochs_to_keep" xuống 3 thay vì mặc định 5:



Cài đặt Systemd để nút luôn chạy với hệ thống
sudo nano /etc/systemd/system/neard.service
Dán:
Description=NEARd Daemon Service
[Service]
Type=simple
User=root
WorkingDirectory=/root/.near
ExecStart=/root/nearcore/target/release/neard run
Restart=on-failure
RestartSec=30
KillSignal=SIGINT
TimeoutStopSec=45
KillMode=mixed
[Install]
WantedBy=multi-user.target
Sau đó, kích hoạt dịch vụ:
sudo systemctl enable neard
Đồng bộ dữ liệu: Để đồng bộ dữ liệu nhanh hơn, chúng ta có thể tải snapshot của các epoch NEAR gần đây thay vì chờ nút đồng bộ với các đồng nghiệp khác, quá trình này sẽ mất vài giờ, kích thước dữ liệu dự kiến sẽ khoảng 600GB.

Chạy lệnh này để tải snapshot và bắt đầu nút:
mkdir ~/.near/data && curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/fastnear/static/refs/heads/main/down_rclone.sh | DATA_PATH=~/.near/data CHAIN_ID=mainnet bash && sudo systemctl start neard

Lưu ý: Nếu không gian đĩa của bạn chỉ có 1TB, trong một số trường hợp bạn có thể hết không gian đĩa trong quá trình tải xuống, trong trường hợp đó, mẹo là dừng quá trình tải xuống, khởi động lại nút và chờ đợi nó đồng bộ từ các đồng nghiệp. (vì chúng ta đã giảm gc_num_epochs_to_keep, vì vậy nút sẽ chỉ giữ 3 epoch gần đây nhất và nó sẽ phù hợp với ổ đĩa máy chủ của bạn)

Sau khi đồng bộ dữ liệu hoàn tất, bây giờ chúng ta có thể khởi động nút:
sudo systemctl start neard
Nếu bạn cần thay đổi dịch vụ trong tệp config.json, nút cũng cần được tải lại:
sudo systemctl reload neard
Xem logs

Lệnh:
journalctl -n 100 -f -u neard | ccze -A


Kiểm tra trạng thái chạy của nút validator. Nếu bạn thấy một cái gì đó giống như hình ảnh trên, điều đó có nghĩa là nút đã được đồng bộ hoàn toàn, và bạn đã sẵn sàng trở thành một validator hoạt động!
Trở thành một Validator hoạt động
Để trở thành một validator và tham gia vào bộ validator, cần đạt một tập hợp tối thiểu các tiêu chí thành công.
	Nút phải được đồng bộ hoàn toàn
	validator_key.json phải được đặt đúng vị trí
	Hợp đồng phải được khởi tạo với public_key trong validator_key.json
	account_id phải được đặt thành id hợp đồng staking pool
	Phải có đủ sự ủng hộ để đáp ứng giá ghế tối thiểu. Xem giá ghế tại đây hoặc chỉ cần chạy lệnh này
near-validator validators network-config mainnet next
	Một đề xuất phải được gửi bằng cách ping hợp đồng
	Khi một đề xuất được chấp nhận, một validator phải đợi 2-3 epoch để vào tập hợp validator
	Khi đã ở trong tập hợp validator, validator phải tạo ra hơn 90% số block được giao hoặc nếu không, nút của bạn sẽ bị loại bỏ

Kiểm tra trạng thái hoạt động của nút validator. Nếu "Validator" xuất hiện, pool của bạn đã được chọn trong danh sách validator hiện tại.
Triển khai hợp đồng staking pool của bạn
NEAR sử dụng một nhà máy staking pool với một hợp đồng staking được liệt kê trắng để đảm bảo tiền của người ủng hộ an toàn. Để chạy một validator trên NEAR, một staking pool phải được triển khai vào một tài khoản NEAR và tích hợp vào một nút validator NEAR. Người ủng hộ phải sử dụng giao diện người dùng hoặc dòng lệnh để đặt cược vào pool. Một staking pool là một hợp đồng thông minh được triển khai vào một tài khoản NEAR.

Lưu ý: HỢP ĐỒNG STAKING POOL SẼ KHÔNG CÓ QUYỀN TRUY CẬP VIẾT ĐẾN TẤT CẢ CÁC TÀI KHOẢN CON HOẶC DỮ LIỆU, điều này cũng áp dụng cho bất kỳ tài khoản con nào trên NEAR, điều đó có nghĩa là số dư staking của bạn là AN TOÀN!

Triển khai một Hợp đồng Staking Pool

Gọi nhà máy staking pool, tạo một staking pool mới với tên được chỉ định và triển khai nó vào accountId đã chỉ định.

Đối với Mainnet
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "<pool_id>", "owner_id": "<accountId>", "stake_public_key": "<public_key>", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
Từ ví dụ trên, bạn cần thay thế:

	pool_id: Tên staking pool, nhà máy tự động thêm tên của nó vào tham số này, tạo {pool_id}.{staking_pool_factory}.
ví dụ "lncvalidator"
	owner_id:: Tài khoản NEAR sẽ quản lý staking pool. Thông thường là tài khoản NEAR chính của bạn.
	public_key: Khóa công khai trong tệp validator_key.json của bạn.
	5: Phí mà pool sẽ thu (ví dụ trong trường hợp này 5 trên 100 là 5% phí), thông thường validators thu 5% phí, nếu bạn đặt phí quá cao, không ai sẽ muốn đặt cược vào node của bạn ;) 
	accountId: Tài khoản NEAR triển khai staking pool.
Hãy chắc chắn rằng bạn có ít nhất 30 NEAR có sẵn, đó là số tối thiểu cần thiết cho việc lưu trữ.

Lệnh cuối cùng sẽ trông giống như thế này:
near contract call-function as-transaction poolv1.near create_staking_pool json-args '{"staking_pool_id": "lncvalidator", "owner_id": "lncvalidator.near", "stake_public_key": "ed25519:A9RdmNFxxx", "reward_fee_fraction": {"numerator": 5, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '30 NEAR' sign-as lncvalidator.near network-config mainnet sign-with-keychain
Để thay đổi các tham số của pool, như thay đổi số phần trăm hoa hồng tính phí thành 1% trong ví dụ dưới đây, sử dụng lệnh này:
near contract call-function as-transaction <full_pool_id> update_reward_fee_fraction json-args '{"reward_fee_fraction": {"numerator": 1, "denominator": 100}}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <account_id> network-config mainnet sign-with-keychain
Lưu ý: full_pool_id: <pool_id>.poolv1.near , đó là lncvalidator.poolv1.near trong trường hợp này

Bạn sẽ thấy một cái gì đó như thế này:


Nếu có "True" ở cuối. Pool của bạn đã được tạo.

Chúc mừng! Bạn đã cấu hình Staking pool của mình và đang hoạt động 🚀🚀🚀🚀
Quản lý hợp đồng staking pool của bạn
Một số lệnh hữu ích bạn nên biết:

Lấy ID chủ sở hữu của staking pool
near contract call-function as-read-only <full_pool_id> get_owner_id json-args {} network-config mainnet now
Thực hiện lệnh này để lấy khóa công khai mà mạng có cho validator của bạn
near contract call-function as-read-only <full_pool_id> get_staking_key json-args {} network-config mainnet now
Nếu khóa công khai không khớp, bạn có thể cập nhật khóa staking như sau (thay thế pubkey dưới đây bằng khóa trong tệp validator.json của bạn)
near contract call-function as-transaction <full_pool_id> update_staking_key json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain
Làm việc với Staking Pools
LƯU Ý: Validator của bạn phải được đồng bộ hoàn toàn trước khi phát ra một đề xuất hoặc gửi tiền.
Đề xuất và PingsĐể có một chỗ ngồi validator, bạn phải trước tiên gửi một đề xuất với một lượng cọc phù hợp. Các đề xuất được gửi cho epoch +2. Nghĩa là nếu bạn gửi một đề xuất bây giờ, nếu được chấp nhận, bạn sẽ nhận chỗ ngồi trong 3 epoch. Bạn nên gửi một đề xuất mỗi epoch để đảm bảo chỗ ngồi của mình. Để gửi một đề xuất, chúng ta sử dụng lệnh ping. Một đề xuất cũng được gửi nếu một lệnh cọc hoặc rút cọc được gửi đến hợp đồng staking pool.

Lưu ý, một lệnh ping cũng cập nhật số dư cọc cho những người ủy quyền của bạn. Một lệnh ping nên được phát ra mỗi epoch để giữ cho phần thưởng được báo cáo hiện tại trên hợp đồng pool. Bạn có thể thiết lập một lệnh ping bằng cách sử dụng một công việc cron với một tập lệnh ping ở đây.

Tạo một tệp mới trên /home/root/scripts/ping.sh và điền vào đây:
#!/bin/sh
# Gọi lệnh Ping để gia hạn Đề xuất được thêm vào crontab

export NEAR_ENV=mainnet
export LOGS=/home/root/logs
export POOLID=<full_pool_id>
export ACCOUNTID=<account_id>

echo "---" >> $LOGS/all.log
date >> $LOGS/all.log

near contract call-function as-transaction $POOLID ping json-args '{"stake_public_key": "<public key>"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $ACCOUNTID network-config mainnet sign-with-keychain >> $LOGS/all.log


Tạo thư mục logs:
mkdir $HOME/logs
Thay đổi quyền thực thi cho tệp ping.sh:
chmod +x $HOME/scripts/ping.sh
Tạo một crontab mới, tôi cá nhân thiết lập nó để chạy mỗi 8 giờ:
crontab -e
Điền vào đây và lưu
0 */8 * * * sh /home/root/scripts/ping.sh
Liệt kê crontab để xem nó đang chạy:
crontab -l
Xem lại logs của bạn
cat $HOME/logs/all.log
Đó là tất cả, bây giờ bạn cần có đủ token được ủy quyền để trở thành một validator hoạt động, chào mừng đến với NEAR Protocol phi tập trung và kiếm phần thưởng trên đường đi 🚀🚀🚀🚀 💪💪💪💪 🛳️🛳️🛳️👽👽👽🛸🛸🛸
Tối ưu hóa mạng
Để tối ưu hóa cài đặt mạng để cải thiện hiệu suất validator, thực thi các lệnh sau:
MaxExpectedPathBDP=8388608
sudo sysctl -w net.core.rmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.core.wmem_max=$MaxExpectedPathBDP
sudo sysctl -w net.ipv4.tcp_rmem="4096 87380 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_wmem="4096 16384 $MaxExpectedPathBDP"
sudo sysctl -w net.ipv4.tcp_slow_start_after_idle=0

Những thay đổi này không tồn tại sau khi khởi động lại hệ thống. Để áp dụng chúng tự động khi khởi động, thêm vào /etc/sysctl.d/local.conf:
net.core.rmem_max = 8388608
net.core.wmem_max = 8388608
net.ipv4.tcp_rmem = 4096 87380 8388608
net.ipv4.tcp_wmem = 4096 16384 8388608
net.ipv4.tcp_slow_start_after_idle = 0
Tùy chọn: Gửi Thông tin Pool
Thêm thông tin pool giúp người ủy quyền và cũng giúp với việc tiếp cận cho việc nâng cấp và các thông báo quan trọng khác:Các trường thông tin có sẵn để thêm là: https://github.com/zavodil/near-pool-details/blob/master/FIELDS.md.

Thông tin xác định mà các nhà xác thực cần cung cấp là: tên, mô tả, url, telegram, twitter,...

Các lệnh ví dụ:

Thay đổi tên và mô tả của nhà xác thực:

    Thay thế <full_pool_id> bằng địa chỉ pool của bạn, ví dụ: lncvalidator.poolv1.near
    Thay thế <accountId> bằng địa chỉ ví xác thực của bạn, lncvalidator.near trong trường hợp này

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "name", "value": "LearnNEARClub"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain

near contract call-function as-transaction pool-details.near update_field json-args '{"pool_id": "<full_pool_id>", "name": "description", "value": "LearnNEARClub Validator!"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <accountId> network-config mainnet sign-with-keychain


Xem thông tin nhà xác thực của bạn từ CLI:
near contract call-function as-read-only pool-details.near get_fields_by_pool json-args '{"pool_id":"<full_pool_id>"}' network-config mainnet now
 

Xem thông tin nhà xác thực trên NEARScope hoặc NEARBlocks:

Thông tin sẽ hiển thị như sau: (nguồn: NearScope)

Bảo trì node
Quan trọng để duy trì node của bạn và giữ cho nó hoạt động ổn định, đây là một số điều quan trọng bạn cần biết
Mã trạng thái node

    ĐỎ: cập nhật node của bạn NGAY LẬP TỨC!!1!!!, có điều gì đó quan trọng đã xảy ra, tôi lặp lại, cập nhật NGAY LẬP TỨC!!
    VÀNG: bạn cần cập nhật node, nhưng không quá khẩn cấp cho đến bây giờ.
Tìm hiểu thêm tại đây: https://near-nodes.io/maintenance/maintenance#runtime-alerts

Cộng đồng Nhà xác thực NEAR trên Telegram
Tham gia nhóm để nhận cập nhật node, hỗ trợ và nhiều hơn nữa, vui lòng sử dụng nhóm này cho các câu hỏi và thảo luận liên quan đến xác thực trên NEAR
https://t.me/near_validators
Cập nhật phiên bản node mới
Khi có phiên bản node mới, bạn sẽ nhận được thông báo trên nhóm xác thực Telegram, chạy lệnh này để cập nhật node.cd ~/nearcore && git fetch && export NEAR_RELEASE_VERSION=<node_version> && git checkout $NEAR_RELEASE_VERSION && make release && sudo systemctl stop neard && sudo systemctl start neard
Thay <node_version> bằng phiên bản phát hành nearcore chính xác.
Giám sát hiệu suất node
Giám sát node theo cách chuyên nghiệp:
https://near-nodes.io/validator/validator-bootcamp#grafana

Giám sát node theo cách degen:
 Tôi đã tạo một bot nhỏ để giúp bạn giám sát nhanh chóng thời gian hoạt động của validator ở đây, bạn có thể xem:
https://x.com/cuongdc_real/status/1839769081723138239

Rút phần thưởng của bạn
Đơn giản chỉ cần đăng nhập vào bất kỳ ví nào trên NEAR và yêu cầu phần thưởng của validator tại phần đặt cược ví.
Tài nguyên

 	Khái niệm NEAR Validators: https://docs.near.org/concepts/basics/validators
 	NEAR Nodes - Tài liệu chính thức của NEAR Validator mà mọi validator nên xem qua: https://near-nodes.io/
 	MainnetGo - Hướng dẫn NEAR Validator🚀: https://github.com/Open-Shard-Alliance/MainnetOnboarding/blob/main/MainnetGO.md
 	Tính phần thưởng đặt cược NEAR: https://www.stakingrewards.com/asset/near-protocol
 	Xem thông tin validator trên các trang web này

 	https://near-staking.com/
 	https://nearblocks.io/node-explorer
 	https://legacy.explorer.near.org/nodes/validators



Kết luận
 

Cảm ơn bạn đã đọc đến đây! Đó là tất cả những gì tôi muốn chia sẻ về việc chạy một validator trên NEAR.
Theo trải nghiệm của tôi, việc chạy một node NEAR rất dễ dàng và gần như không có lỗi, với ít vấn đề hơn so với các chuỗi hoạt động cao khác. NEAR yêu cầu ít tài nguyên máy chủ hơn đáng kể do việc phân mảnh với Nightshade. Ngoài ra, bạn cũng kiếm được phần thưởng trên đường đi!

Nói về phần thưởng, sớm thôi, các validator NEAR cũng sẽ có cơ hội kiếm phần thưởng cho việc chạy mạng MPC, góp phần vào dịch vụ Abstraction của NEAR's Chain cho hệ sinh thái Web3 rộng lớn. Với tầm nhìn xây dựng Web Mở thông qua Abstraction của Chuỗi và AI của Người Sử DụngTrong tương lai gần, NEAR sẽ thấy thêm nhiều hoạt động mạng, tạo cơ hội cho các validator kiếm thêm phần thưởng.

Là một validator, vai trò của bạn rất quan trọng trong việc bảo vệ mạng hoạt động cao như NEAR. Bằng cách bảo vệ NEAR, bạn cũng đang hỗ trợ nhiều ứng dụng được xây dựng trên mạng, như Kaiching (một ứng dụng hoàn tiền được sử dụng bởi hàng triệu người ở Singapore), Sweatcoin (một ứng dụng sức khỏe và thể dục với 100 triệu người dùng trên toàn thế giới), HOT (một ví Web3 là cổng vào cho người dùng tiền điện tử mới), và Ref Finance (một sàn giao dịch phi tập trung trên NEAR).

Những ứng dụng này phục vụ hàng triệu người dùng hàng ngày, và với vai trò của một validator, bạn rất quan trọng trong việc giúp họ duy trì dịch vụ và phát triển!

### Introducing (L)Earn AI agent on NEAR AI

Introduction
You probably heard that now you can call ChatGPT over the phone. This seems unreal. It is cool but do you have an idea whom you're gonna be talking to? The best you can do is to rely on service provider reputation - OpenAI OpCo, LLC.


Issues with Current AI

 	Centralized Models: Most widely-used models like GPT-4 or Claude are closed-source and centralized.
 	Dependence on Centralized Infrastructure: Even "open-source" models often run on centralized platforms like Groq or Together AI.
 	Opaque Operations: It is impossible to verify how agents operate—including prompts, limitations, and stop lists.
 	Data Privacy Concerns: Users have little visibility into how their data is handled or stored.

These challenges emphasize the need for responsible AI use and caution when relying on AI agents for critical decisions.
AI and Learning
Lucky you if you graduated from school before getting spoiled by AI.

But what if you are not able to verify stuff just because you have not developed learning skills, critical thinking, reasoning skills or just because you are too young or you got addicted to “helpful and efficient” AI agents? This could be a serious issue. Calculators began as costly, limited tools, giving schools years to adapt. Now, AI is transforming education instantly, impacting every subject. Students will cheat with AI but also integrate it into their work, challenging educators and questioning the relevance of traditional assignments.
Common understanding is that unless assignments are completed in class, it’s impossible to reliably determine if the work is human-made.

Verifiable AI can change this.


NEAR AI Hub
NEAR.AI is the answer.
While in Alpha, some exciting features are already available to try. Nothing compares to learning by trying so let’s do it.

Go to the NEAR AI Research Hub.

You may sign in with your NEAR account to interact with the platform. At the Agents tab you find all the agents added to the Registry - Decentralized storage with support of private and encrypted items.
Find and check out Learn AI agent 0.0.1.


You can talk to the agent within NEAR AI hub, and what is more important you can explore the agent’s origin - which is learn-agent.learnclub.near, source code, including prompt and stopwords. (L)Earn AI agent "lives on NEAR AI infrastructure - agent itself and the LLM. Moreover, if you want to tweak it - say remove a stopword that is crucial for you - just clone it. But be aware that now you are in charge of your clone!



Now let’s dig a bit deeper. Switch to the Models tab.


There are over 50 open source models available already. As you can see and verify that Learn AI is using that particular LLaMA hosted at the NEAR AI infrastructure. Using NEAR accounts for interacting with models via agents makes it sure that you know whom you are actually talking to!



 

Recently, private RAG (a LLM friendly LNC knowledge base) powered by XTrace was added. It dramatically improved the quality (L)Earn AI🕺.



 
🕺(L)Earn AI
The decentralized NEAR AI infrastructure represents a significant step forward in enabling user-owned AI. By offering transparency, control, and flexibility, NEAR AI empowers users to interact with AI agents in a way that ensures data privacy and fosters trust.

LNC, as a NEAR pioneer, is at the forefront of leveraging this infrastructure for practical applications, including the live Learn AI agent, the Lean NEAR Tutor (in development), and the planned WooCommerce Shopping Agent.
❓Ask
As a learner, you’re invited to actively participate in this innovative (L)Earn ecosystem. Ask the (L)Earn AI relevant questions, pay with nLEARNs, gain knowledge, and earn nLEARNs by contributing to the AI’s improvement.
 Together, this approach brings a deeper and richer meaning to the concept of (L)Earn, blending learning with earning in a positive sum game with AI.

Ask (L)Earn AI also available at Telegram

Check out the most recent (L)Earn AI🕺  agents:
📝Summarize
LNC Summarize🕺 Agent quickly breaks down complex guides into easy-to-understand summaries . It pulls out the most important points and explains them clearly, helping students grasp key concepts without wading through lengthy materials. This time-saving tool makes learning more efficient while keeping the essential information intact. If you're not a native speaker, you can ask the agent to summarize it in your language!



 
✏Comment
In AI era it is safe to assume AI first commenting. 
(L)Earn Comment Agent 🕺analyzes the topic of (L)Earners choice and drafts a comment.
The (l)Earner then reviews this draft and posts it with any necessary edits so the comment does reflect the user's point.
Once comment posted, the nLEARNs reward is to be distributed according AI and user participation! 🤖and🕺 work and learn together!

   

 
✅Quiz
(L)Earn AI Quiz is the first step to introducing the future of learning - personalized, on demand verifiable AI assisted learning. Choose the difficulty and (L)Earn AI will create a quiz to help you memorize the major concepts!
As (L)Earn AI intelligence evolve most likely it will be integrated with other NEAR projects - for example as learning assistant chat bot at other Dapps and Telegram chats, or (L)Earn AI can also cooperate with other NEAR AI agents like NEAR Docs agent and help users to get more technical development related help.
🚩AI Feedback
If you like the answer, tap “Like it? Tip Author”—the authors gets 2 nL and the AI learns what works.If you see a mistake, tap “Not quite right? Flag”—you earn 4 nL and help the AI improve.
Either action teaches the AI what works and what needs fixing while sharing incentives with you.




	

	
	
		
			
				What is the unique feature of the (L)Earn AI agent in the NEAR ecosystem?
			
		

		
					

		
			
			
			
			It provides free access to all AI models
		
			
			It allows users to earn and spend nLEARNs while improving the agent
		
			
			It replaces the need for signing in with NEAR accounts
		
			
			It restricts users from viewing agent source code
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






📚Happy (L)Earning!🕺

 

### Từ điển AI dành cho người mới bắt đầu

Các Khái Niệm Cốt Lõi
Trí Tuệ Nhân Tạo (AI)
Lĩnh vực tạo ra các hệ thống máy tính có thể thực hiện các nhiệm vụ thường đòi hỏi trí tuệ của con người. Hãy tưởng tượng AI như việc dạy máy tính "suy nghĩ" và giải quyết vấn đề. AI hiện đại hiện diện ở mọi nơi - từ gợi ý Netflix đến nhận diện khuôn mặt trên điện thoại thông minh.

Học Máy (ML)
Một phần của AI nơi máy tính học từ các ví dụ thay vì tuân theo các quy tắc cứng nhắc. Hãy tưởng tượng việc dạy một đứa trẻ nhận biết mèo bằng cách cho họ xem nhiều hình ảnh mèo, thay vì liệt kê các quy tắc như "có tai nhọn, có lông." Máy tính tương tự học các mẫu từ dữ liệu.

Học Sâu
Một loại học máy mạnh mẽ sử dụng mạng nơ-ron với nhiều lớp. Giống như việc có nhiều chuyên gia làm việc cùng nhau, mỗi lớp học các khía cạnh khác nhau của dữ liệu. Học sâu là nguồn năng lượng cho các đột phá AI hiện đại trong việc nhận diện hình ảnh, dịch ngôn ngữ và nhiều hơn nữa.

Các Thành Phần Chính
Mạng Nơ-ron
Một hệ thống tính toán được lấy cảm hứng từ cấu trúc não người. Hãy tưởng tượng nó như một mạng phức tạp của các nút kết nối thông tin với nhau. Mỗi kết nối có thể được tăng cường hoặc yếu đi khi mạng học, tương tự như cách não của chúng ta hình thành và củng cố các đường dẫn nơ-ron.

Thuật Toán
Một quy trình từng bước để giải quyết một vấn đề. Trong ngôn ngữ hàng ngày, nó giống như một công thức nấu ăn - hướng dẫn cụ thể mà khi tuân thủ đúng, sẽ tạo ra kết quả mong muốn. Các thuật toán AI là công thức cho việc xử lý dữ liệu và ra quyết định.

Dữ Liệu Huấn Luyện
Thông tin được sử dụng để dạy các mô hình AI. Giống như một học sinh cần các ví dụ để học, AI cần dữ liệu để học các mẫu. Ví dụ, để nhận diện email rác, một AI cần xem nhiều ví dụ của cả email rác và email hợp lệ.

Các Quy Trình Quan Trọng
Huấn Luyện
Quá trình dạy một mô hình AI bằng dữ liệu. Tương tự như cách học sinh học thông qua thực hành, các mô hình AI cải thiện hiệu suất của họ bằng cách xử lý nhiều ví dụ. Huấn luyện bao gồm:


 	Epoch: Một lượt đi qua tất cả dữ liệu huấn luyện
 	Hàm Mất Mát: Đo lường số lỗi mà mô hình gây ra
 	Điều Chỉnh Độ Dốc: Phương pháp toán học để cải thiện độ chính xác của mô hình

Tinh Chỉnh
Điều chỉnh một mô hình AI đã được huấn luyện trước cho một nhiệm vụ cụ thể. Giống như việc học giáo dục tổng quát và chuyên sâu vào một lĩnh vực cụ thể. Ví dụ, lấy một mô hình được huấn luyện trên tiếng Anh tổng quát và tinh chỉnh nó cho thuật ngữ y học.Khái niệm Mô hình Ngôn ngữ
Token
Đơn vị cơ bản của văn bản mà trí tuệ nhân tạo xử lý. Token có thể là từ, phần của từ, hoặc thậm chí là dấu câu. Ví dụ, "trí tuệ nhân tạo" có thể được chia thành các token như ["trí", "tuệ", " nhân tạo"].

Độ Dài Ngữ cảnh
Lượng thông tin mà một mô hình trí tuệ nhân tạo có thể xem cùng một lúc. Giống như bộ nhớ ngắn hạn của con người, đó là "cửa sổ" của văn bản mà trí tuệ nhân tạo có thể nhìn thấy khi tạo ra phản hồi. Độ dài ngữ cảnh dài hơn cho phép mô hình duy trì tính nhất quán qua các cuộc trò chuyện dài hơn.

Kỹ Thuật Khởi Đầu
Nghệ thuật giao tiếp hiệu quả với các mô hình trí tuệ nhân tạo. Giống như việc học cách đặt câu hỏi đúng để nhận được câu trả lời hữu ích, kỹ thuật khởi đầu bao gồm việc tạo ra đầu vào để hướng dẫn trí tuệ nhân tạo tạo ra các đầu ra mong muốn.

Các Phương Pháp Học
Học Có Giám Sát
Quá trình đào tạo mà trí tuệ nhân tạo học từ các ví dụ được gán nhãn. Giống như một học sinh học với một bảng đáp án, mô hình học cách phù hợp giữa đầu vào và đầu ra đúng. Ví dụ: Học phân loại email là thư rác hay không dựa trên các email đã được gán nhãn trước đó.

Học Không Giám Sát
Quá trình đào tạo mà trí tuệ nhân tạo tìm ra các mẫu trong dữ liệu chưa được gán nhãn. Giống như một nhà khoa học khám phá các danh mục tự nhiên trong dữ liệu mà không được chỉ cho điều gì để tìm kiếm. Ví dụ: Nhóm khách hàng thành các đoạn dựa trên hành vi mua sắm của họ.

Học Thưởng
Học thông qua thử và lỗi với phần thưởng và phạt. Giống như huấn luyện một con vật cưng - hành vi tốt được thưởng, hành vi xấu bị ngăn chặn. Ví dụ: Trí tuệ nhân tạo học chơi cờ bằng cách thực hành và thắng/thua trò chơi.

Khái Niệm Nâng Cao
AGI (Trí Tuệ Nhân Tạo Tổng Quát)
Một trí tuệ nhân tạo lý thuyết trong tương lai có thể sánh ngang với trí tuệ cấp độ con người trên tất cả các nhiệm vụ. Khác với các hệ thống trí tuệ nhân tạo hiện tại mà xuất sắc trong các nhiệm vụ cụ thể nhưng gặp khó khăn trong các nhiệm vụ khác, AGI sẽ linh hoạt như trí tuệ con người. Nó vẫn chưa tồn tại và vẫn là một đề tài nghiên cứu.

Transformer
Một kiến trúc trí tuệ nhân tạo mạnh mẽ đã cách mạng hóa xử lý ngôn ngữ. Giống như có một trợ lý thông minh có thể chú ý đến nhiều điều cùng một lúc, transformers có thể xử lý mối quan hệ giữa các phần khác nhau của văn bản một cách hiệu quả.

Học Không Dùng Dữ Liệu và Học Với Ít Dữ Liệu
Khả năng của trí tuệ nhân tạo thực hiện các nhiệm vụ mới với ít hoặc không có đào tạo cụ thể. Giống như một con người sử dụng kiến thức tổng quát để xử lý tình huống mới, những khả năng này cho phép trí tuệ nhân tạo linh hoạt và thích ứng hơn.Xem xét Đạo đức
Thiên vị trong AI
Các hệ thống AI có thể thừa kế và tăng cường các thiên vị của con người có mặt trong dữ liệu đào tạo. Giống như các định kiến của con người, những thiên vị này có thể dẫn đến các kết quả không công bằng hoặc phân biệt đối xử. Nhận biết và đối phó với thiên vị là rất quan trọng đối với việc phát triển AI có trách nhiệm.

Khả năng Giải thích
Khả năng hiểu vì sao một hệ thống AI đã đưa ra một quyết định cụ thể. Quan trọng cho sự tin cậy và trách nhiệm, giống như việc hiểu vì sao một bác sĩ đã đưa ra một chẩn đoán cụ thể. Một số hệ thống AI là "hộp đen" nơi quyết định khó giải thích.

Quyền riêng tư và Bảo mật
Lo ngại về cách hệ thống AI xử lý dữ liệu cá nhân và các lỗ hổng tiềm ẩn. Những xem xét quan trọng bao gồm bảo vệ dữ liệu, sự đồng ý và ngăn chặn việc lạm dụng các công nghệ AI.

Thực hành Tốt nhất
Đánh giá Mô hình
Các phương pháp đánh giá hiệu suất AI, bao gồm:


 	Kiểm tra trên dữ liệu mới để đảm bảo hiệu quả trong thế giới thực
 	Theo dõi thiên vị và lỗi
 	Đánh giá hiệu suất định kỳ và cập nhật

Chất lượng Dữ liệu
Sự quan trọng của việc sử dụng dữ liệu đào tạo chất lượng cao và đại diện. Giống như xây dựng một ngôi nhà trên nền móng vững chắc, dữ liệu tốt là điều cần thiết cho các hệ thống AI đáng tin cậy.

### AI Glossary for beginners

Core Concepts
Artificial Intelligence (AI)
The field of creating computer systems that can perform tasks typically requiring human intelligence. Think of AI as teaching computers to "think" and solve problems. Modern AI is everywhere - from Netflix recommendations to smartphone facial recognition.

Machine Learning (ML)
A subset of AI where computers learn from examples rather than following rigid rules. Imagine teaching a child to recognize cats by showing them many cat pictures, rather than listing rules like "has pointy ears, has fur." The computer similarly learns patterns from data.

Deep Learning
A powerful type of machine learning using neural networks with many layers. Like having multiple experts working together, each layer learns different aspects of the data. Deep learning powers modern AI breakthroughs in image recognition, language translation, and more.

Key Components
Neural Network
A computing system inspired by human brain structure. Picture it as a complex web of interconnected nodes passing information to each other. Each connection can be strengthened or weakened as the network learns, similar to how our brains form and strengthen neural pathways.

Algorithm
A step-by-step procedure for solving a problem. In everyday terms, it's like a cooking recipe - specific instructions that, when followed correctly, produce the desired result. AI algorithms are recipes for processing data and making decisions.

Training Data
The information used to teach AI models. Like a student needs examples to learn, AI needs data to learn patterns. For instance, to recognize spam emails, an AI needs to see many examples of both spam and legitimate emails.

Important Processes
Training
The process of teaching an AI model using data. Similar to how students learn through practice, AI models improve their performance by processing many examples. Training involves:


 	Epoch: One complete pass through all training data
 	Loss Function: Measures how many mistakes the model makes
 	Gradient Descent: The mathematical method for improving the model's accuracy

Fine-tuning
Adapting a pre-trained AI model for a specific task. Like taking a general education and specializing in a particular field. For example, taking a model trained on general English and fine-tuning it for medical terminology.

Language Model Concepts
Token
The basic unit of text that AI processes. Tokens can be words, parts of words, or even punctuation. For example, "artificial intelligence" might be split into tokens like ["art", "ificial", " intelligence"].

Context Length
The amount of information an AI model can consider at once. Like human short-term memory, it's the "window" of text the AI can see when generating responses. Longer context lengths allow the model to maintain consistency over longer conversations.

Prompt Engineering
The art of effectively communicating with AI models. Like learning to ask the right questions to get helpful answers, prompt engineering involves crafting inputs that guide the AI to produce desired outputs.

Learning Approaches
Supervised Learning
Training where the AI learns from labeled examples. Like a student learning with an answer key, the model learns to match inputs to correct outputs. Example: Learning to classify emails as spam or not spam based on previously labeled emails.

Unsupervised Learning
Training where the AI finds patterns in unlabeled data. Like a scientist discovering natural categories in data without being told what to look for. Example: Grouping customers into segments based on their shopping behavior.

Reinforcement Learning
Learning through trial and error with rewards and penalties. Like training a pet - good behaviors are rewarded, bad ones discouraged. Example: AI learning to play chess by practicing and winning/losing games.

Advanced Concepts
AGI (Artificial General Intelligence)
A theoretical future AI that could match human-level intelligence across all tasks. Unlike current AI systems that excel at specific tasks but struggle with others, AGI would be versatile like human intelligence. It doesn't exist yet and remains a topic of research.

Transformer
A powerful AI architecture that revolutionized language processing. Like having a smart assistant that can pay attention to multiple things simultaneously, transformers can process relationships between different parts of text effectively.

Zero-shot and Few-shot Learning
The ability of AI to perform new tasks with minimal or no specific training. Like a human using general knowledge to handle new situations, these capabilities allow AI to be more flexible and adaptable.

RAG - for Retrieval-Augmented Generation
A technique that enhances large language models (LLMs) by combining them with information retrieval systems.
In a RAG system:


 	The model retrieves relevant information from an external knowledge base
 	This retrieved information is then used to augment the context given to the LLM
 	The LLM generates a response based on both its pre-trained knowledge and the retrieved information

RAG helps overcome limitations of LLMs by providing access to more current, accurate, or specialized information than what's in their training data. It's particularly useful for enterprise applications where access to private documents, databases, or domain-specific knowledge is needed

Ethical Considerations
Bias in AI
AI systems can inherit and amplify human biases present in training data. Like human prejudices, these biases can lead to unfair or discriminatory outcomes. Recognizing and addressing bias is crucial for responsible AI development.

Explainability
The ability to understand why an AI made a particular decision. Important for trust and accountability, like being able to understand why a doctor made a specific diagnosis. Some AI systems are "black boxes" where decisions are hard to explain.

Privacy and Security
Concerns about how AI systems handle personal data and potential vulnerabilities. Important considerations include data protection, consent, and preventing misuse of AI technologies.

Best Practices
Model Evaluation
Methods for assessing AI performance, including:


 	Testing on new data to ensure real-world effectiveness
 	Monitoring for biases and errors
 	Regular performance reviews and updates

Data Quality
The importance of using high-quality, representative training data. Like building a house on a solid foundation, good data is essential for reliable AI systems.

### NEAR Intentions: Un guide pour les utilisateurs et les développeurs

un DEX utilisant NEAR-Intents - échangez simplement du BTC contre du Dogecoin en quelques clics ! Propulsé par NEAR !
Pourquoi vous avez besoin de NEAR Intents
Tout d'abord, commençons par une question simple : pourquoi devriez-vous vous soucier de NEAR Intents ?

Avez-vous déjà essayé d'échanger du BTC contre du Doge, ou de l'Ethereum contre du NEAR en utilisant un DEX ?

Les étapes typiques ressemblent à ceci pour ETH vers NEAR :

 	Préparez du $ETH dans votre portefeuille.
 	Pont ETH vers NEAR (n'oubliez pas de conserver un peu d'ETH pour les frais de pont).
 	Assurez-vous d'avoir du NEAR comme jeton de gaz.
 	Échangez ETH contre NEAR.

Semble complexe, n'est-ce pas ? Cela fonctionne toujours, mais prend beaucoup de temps et d'efforts.
Alors que faire si vous voulez échanger Bitcoin <> Dogecoin, Doge <> XRP, ou Ethereum <> Dogecoin ? Ces chaînes n'ont pas de DEX et la seule option ? Les échanges centralisés comme Binance ou Coinbase.

NEAR Intents résout tout cela !




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Avec NEAR Intents, vous pouvez :

 	Déposer des jetons depuis n'importe quel portefeuille.
 	Échanger contre n'importe quel jeton sur n'importe quelle chaîne.
 	Signer simplement pour échanger - pas besoin d'un jeton de gaz (gain de temps et d'argent).
 	Retirer vers n'importe quel portefeuille sur la chaîne native avec juste une signature.

Par exemple, vous pouvez échanger du $BTC sur le réseau Bitcoin contre du $NEAR en moins de 30 secondes !

https://youtu.be/JoyJgRi0G7s

NEAR Intents fonctionne comme un CEX mais est décentralisé comme un DEX - facile à utiliser, moins cher, plus rapide et sans permission, le tout alimenté par la blockchain NEAR !

Stylé, non ? Pensez-y comme une expérience similaire à Coinbase mais décentralisée et ultra-lisse !

Il existe des applications intéressantes exploitant NEAR-Intents que vous pouvez essayer dès maintenant :

 	NEAR Intents DEX
 	Solswap pour les utilisateurs de Solana
 	Dogecoin Swap : le premier DEX pour Dogecoin
 	Turbo Swap

🤖📈 INTEAR - Un bot de trading Telegram alimenté par NEAR Intents :
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - Portefeuilles IA
https://x.com/BitteProtocol/status/1868682419785605630

Bon usage ! Maintenant, vous êtes curieux de savoir comment tout cela fonctionne. Creusons un peu plus ! 🤓
https://x.com/i/status/1855475653283594591

Un jeton, n'importe quelle chaîne.
Toute la liquidité, une seule chaîne.

NEAR Intents est lancé dans le cadre de la pile technologique NEAR.

La vraie DeFi inter-chaînes est là, et elle est alimentée par NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 10 novembre 2024
"NEAR Intents sont un nouveau type de transaction qui permet d'échanger des informations, des demandes, des actifs et des actions entre des agents IA, des services et des utilisateurs finaux."En termes simples, les Intentions NEAR vous permettent de décrire ce que vous voulez réaliser sans vous soucier de comment le faire. Au lieu de cela, un réseau décentralisé de solveurs (agents d'IA, services web2 et web3, etc.) fait le travail pour vous de manière ouverte, sécurisée et décentralisée, alimenté par la blockchain NEAR.

La démo que vous avez vue précédemment n'est qu'une interface présentant la puissance des Intentions NEAR. Mais les cas d'utilisation potentiels sont vastes. Par exemple, avec Bitte Wallet, vous pouvez demander à l'IA de gérer les échanges, le staking, ou même de trouver les meilleurs validateurs pour vous.

Comment fonctionnent les Intentions NEAR ?

Voici un aperçu simplifié de comment les Intentions NEAR fonctionnent :

1. L'utilisateur définit une Intention : Vous voulez échanger 10 ETH contre des USDC et demandez : "Combien de USDC puis-je obtenir pour 10 ETH ?"
2. Les requêtes du Bus de Solveurs : Le Bus de Solveurs envoie votre demande à plusieurs solveurs pour trouver la meilleure offre de USDC pour 10 ETH.
3. Réponses des Solveurs : Les solveurs calculent leurs offres (par exemple, Solveur 1 : 40 100 USDC ; Solveur 2 : 40 000 USDC) en se procurant de la liquidité de n'importe où.
4. Meilleure Offre Sélectionnée : Le Bus de Solveurs choisit la meilleure offre (40 100 USDC) et vous informe.
5. Approbation de l'Utilisateur : Vous approuvez l'échange en signant un message sur votre portefeuille, pas besoin d'une transaction coûteuse, économisez beaucoup d'argent sur des chaînes coûteuses comme Ethereum ou Bitcoin.
6. Exécution de l'Échange : Le Bus de Solveurs envoie vos données signées à un contrat vérificateur, qui exécute l'échange sur la chaîne.

Cela garantit aux utilisateurs d'obtenir les meilleurs taux de manière sécurisée et efficace, avec le prix qui vous a été cité étant exactement le prix que vous obtenez.

Au-delà des actifs cryptographiques, les prochaines mises à jour permettront d'échanger des services web2 comme des abonnements Netflix, des billets, des paiements en ligne, ou des rampes d'accès fiat. Tant qu'il y a un solveur prêt à répondre à votre intention, les possibilités sont infinies ! Un Solveur pourrait être une bourse, un agent d'IA prêt à traiter votre commande !

Je recommande vivement de regarder la présentation d'Alex Shevchenko sur la couche d'Intentions à [REDACTED] 2024 pour en savoir plus.

https://www.youtube.com/watch?v=PD7SbJrHjGo

Intentions NEAR : Avantages Clés

Les Intentions NEAR, une partie essentielle de la pile d'Abstraction de Chaîne de NEAR, offrent de nombreux avantages :
 	Apporter la fonctionnalité des contrats intelligents pour soutenir toutes les chaînes : y compris les chaînes non intelligentes comme Bitcoin, XRP, Doge..., les utilisateurs de ces chaînes peuvent enfin utiliser DeFi avec DEXs, prêts...!
 	Support instantané pour les nouvelles chaînes sans intégration manuelle : Les NEAR-Intents peuvent déjà fonctionner avec toutes les chaînes EVM au lieu d'attendre que l'équipe fasse une intégration manuelle pour chaque nouvelle chaîne EVM car elles ont exactement la même infrastructure.
 	Exécution pilotée par l'IA : Un réseau de solveurs, y compris des agents d'IA, analyse votre intention et l'exécute de la manière la plus efficace possible. Cela signifie que vous bénéficiez des meilleures sources de liquidité, qu'elles soient sur chaîne, hors chaîne, des échanges centralisés (CEXs) ou décentralisés (DEXs), le tout optimisé pour la vitesse et le coût.
 	Liquidité unifiée : Les NEAR Intents réunissent des participants d'IA avec des services financiers, le commerce et les utilisateurs finaux, unifiant la liquidité sur différentes plateformes.
 	Nouvelles possibilités et cas d'utilisation : En combinant n'importe quel type d'intention avec des agents d'IA, vous pouvez explorer de nouveaux primitives et réimaginer le trading, les enchères, les jetons, et plus encore.
 	Gestion sécurisée des actifs : Transférer, miser et gérer une large gamme d'actifs, y compris des NFTs, FTs, SBTs et des actifs non transférables, en tenant compte de la sécurité et de la conformité.
 	Ouvert et sans permission : L'infrastructure décentralisée et inter-chaînes vous permet de construire ou de lancer facilement de nouveaux produits financiers.
 	Expérience fiable et rapide : Le règlement inter-chaînes entre les agents et les utilisateurs se fait en quelques secondes, garantissant une expérience fluide.
 	Liquidité combinée : Combler le fossé entre les DEXs à travers les chaînes, les CEXs, et même en dehors de la crypto assure la participation et l'innovation de divers intervenants.

"Les intentions sont une interface universelle pour le commerce mondial, permettant la transition DeFi, TradFi, et plus encore. Pensez à elles comme des contrats juridiques multi-parties réglés de manière cryptographique." – Illia Polosukhin, Co-fondateur de NEAR

 
Intégration avec NEAR-intents
Les NEAR Intents simplifient le développement blockchain, permettant une fonctionnalité inter-chaînes transparente et des solutions alimentées par l'IA. Que vous construisiez des applications DeFi, des portefeuilles inter-chaînes, ou des services innovants, les NEAR Intents fournissent les outils pour le réaliser !

Ressources pour les développeurs :

 	Page d'accueil de NEAR-Intents : https://near.org/intents
 	Docs, APIs et le SDK : https://docs.near-intents.org/
 	Groupe de développeurs NEAR : https://t.me/neardev
 	Groupe NEAR Intents : https://t.me/near_intents
 	Docs NEAR : https://docs.near.org/
 	[REDACTED] 2024 | Alex Shevchenko - Couche d'intentions
 	[REDACTED] 2024 | Omnibridge : Comment ça marche réellement

Plongez-vous dedans et commencez à construire dès aujourd'hui !
En conclusionNEAR Intents change la donne en rendant les interactions blockchain plus fluides, plus rapides et plus intelligentes. Plus besoin de sauter à travers des obstacles pour échanger des jetons ou gérer des actifs, tout est à portée de clic, sans les tracas des frais de gaz ou des configurations complexes.

Avec des solveurs pilotés par l'IA, une liquidité unifiée et un support inter-chaînes même pour des chaînes non basées sur des smart contracts comme Bitcoin et Doge, NEAR Intents débloque des possibilités infinies. Du swap de jetons en quelques secondes à l'utilisation de la DeFi pour n'importe quelle chaîne, c'est rapide, sécurisé, décentralisé et incroyablement facile à utiliser.

Pensez-y comme une expérience similaire à Coinbase mais décentralisée, rentable et sans autorisation. Il est temps de vivre la blockchain comme elle était censée être - sans effort et magique.

Pour les développeurs, NEAR Intents simplifie la construction d'applications décentralisées en gérant la complexité inter-chaînes, vous permettant de vous concentrer sur ce qui compte le plus - vos applications. Vous pouvez intégrer NEAR Intents dans vos projets pour débloquer de nouvelles opportunités et offrir des expériences fluides et sécurisées aux utilisateurs.

### NEAR Intents: Panduan untuk Pengguna dan Pengembang

sebuah DEX menggunakan NEAR-Intents - cukup tukar BTC ke Dogecoin dalam beberapa klik! Didukung oleh NEAR!
Mengapa Anda Membutuhkan NEAR Intents
Pertama, mari kita mulai dengan pertanyaan sederhana: mengapa Anda harus peduli tentang NEAR Intents?

Pernahkah Anda mencoba menukar BTC ke Doge, atau Ethereum ke NEAR menggunakan DEX?

Langkah-langkah tipikal terlihat seperti ini untuk ETH ke NEAR:

 	Siapkan $ETH di dompet Anda.
 	Jembatani ETH ke NEAR (jangan lupa menyimpan sebagian ETH untuk biaya jembatan).
 	Pastikan Anda memiliki NEAR sebagai token gas.
 	Tukar ETH ke NEAR.

Terlihat kompleks, bukan? Itu masih berfungsi, tetapi membutuhkan banyak waktu dan usaha.
Jadi bagaimana jika Anda ingin menukar Bitcoin <> Dogecoin, Doge <> XRP, atau Ethereum <> Dogecoin? Rantai ini tidak memiliki DEX dan satu-satunya pilihan? Bursa terpusat seperti Binance atau Coinbase.

NEAR Intents menyelesaikan semua ini!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Dengan NEAR Intents, Anda dapat:

 	Menyetorkan token dari dompet apa pun.
 	Tukar ke token apa pun di rantai apa pun.
 	Hanya perlu menandatangani untuk menukar—tidak perlu token gas (menghemat waktu dan uang).
 	Menarik ke dompet apa pun di rantai asli hanya dengan tanda tangan.

Sebagai contoh, Anda dapat menukar $BTC di jaringan Bitcoin ke $NEAR dalam waktu kurang dari 30 detik!

https://youtu.be/JoyJgRi0G7s

NEAR Intents bekerja seperti CEX tetapi terdesentralisasi seperti DEX—mudah digunakan, lebih murah, lebih cepat, dan tanpa izin, semuanya didukung oleh blockchain NEAR!

Keren, bukan? Bayangkan sebagai pengalaman mirip Coinbase tetapi terdesentralisasi dan sangat mulus!

Ada aplikasi menarik yang memanfaatkan NEAR-Intents yang dapat Anda coba sekarang juga:

 	NEAR Intents DEX
 	Solswap untuk pengguna Solana
 	Dogecoin Swap: DEX pertama untuk Dogecoin
 	Turbo Swap

🤖📈 INTEAR - Sebuah bot perdagangan Telegram yang didukung oleh NEAR Intents:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - Dompet AI
https://x.com/BitteProtocol/status/1868682419785605630

Selamat menggunakan! Sekarang Anda penasaran tentang bagaimana semua ini bekerja. Mari kita gali lebih dalam! 🤓
https://x.com/i/status/1855475653283594591

Satu token, semua rantai.
Semua likuiditas, satu rantai.

NEAR Intents diluncurkan sebagai bagian dari NEAR Tech Stack.

DeFi lintas rantai sejati ada di sini, dan didukung oleh NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 10 November 2024
"NEAR Intents adalah jenis transaksi baru yang memungkinkan pertukaran informasi, permintaan, aset, dan tindakan antara agen AI, layanan, dan pengguna akhir."Dalam istilah yang lebih sederhana, NEAR Intents memungkinkan Anda untuk menjelaskan apa yang ingin Anda capai tanpa khawatir tentang bagaimana melakukannya. Sebaliknya, jaringan terdesentralisasi dari solver (agen AI, layanan web2 dan web3, dll.) melakukan pekerjaan untuk Anda secara terbuka, aman, dan terdesentralisasi, didukung oleh blockchain NEAR.

Demo sebelumnya yang Anda lihat, itu hanya antarmuka yang memperlihatkan kekuatan NEAR Intents. Tetapi kasus penggunaan potensialnya sangat luas. Misalnya, dengan Bitte Wallet, Anda dapat memerintahkan AI untuk menangani pertukaran, staking, atau bahkan menemukan validator terbaik untuk Anda.
Bagaimana NEAR Intents Bekerja?
Berikut adalah gambaran sederhana tentang bagaimana NEAR Intents bekerja:



 	Pengguna Mendefinisikan Intent: Anda ingin menukar 10 ETH dengan USDC dan bertanya, "Berapa USDC yang bisa saya dapatkan dengan 10 ETH?"
 	Kueri Bus Solver: Bus Solver mengirim permintaan Anda ke beberapa solver untuk menemukan penawaran USDC terbaik untuk 10 ETH.
 	Tanggapan Solver: Solver menghitung penawarannya (misalnya, Solver 1: 40.100 USDC; Solver 2: 40.000 USDC) dengan mengambil likuiditas dari mana saja.
 	Penawaran Terbaik Dipilih: Bus Solver memilih penawaran terbaik (40.100 USDC) dan memberitahu Anda.
 	Persetujuan Pengguna: Anda menyetujui pertukaran dengan menandatangani pesan di dompet Anda—tidak perlu transaksi mahal, hemat banyak uang di rantai mahal seperti Ethereum atau Bitcoin.
 	Pelaksanaan Pertukaran: Bus Solver mengirim data yang ditandatangani Anda ke kontrak verifikasi, yang melaksanakan pertukaran on-chain.

Hal ini memastikan pengguna mendapatkan tarif terbaik secara aman dan efisien, dengan harga yang Anda kutip adalah harga yang Anda dapatkan.

Selain aset kripto, pembaruan mendatang akan memungkinkan pertukaran layanan web2 seperti langganan Netflix, tiket, pembayaran online, atau jalan keluar masuk fiat. Selama ada solver siap untuk memenuhi niat Anda, kemungkinan tak terbatas!
Seorang Solver bisa menjadi bursa, agen AI yang bersedia memproses pesanan Anda!




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Saya sangat merekomendasikan menonton presentasi Alex Shevchenko tentang Lapisan Intents di [REDACTED] 2024 untuk belajar lebih lanjut.

https://www.youtube.com/watch?v=PD7SbJrHjGo

 

NEAR Intents: Keuntungan Utama
NEAR Intents, bagian inti dari tumpukan Abstraksi Rantai NEAR, menawarkan banyak manfaat:
 	Membawa fungsionalitas kontrak pintar untuk mendukung semua rantai: termasuk rantai non-kontrak pintar seperti Bitcoin, XRP, Doge..., pengguna dari rantai-rantai ini akhirnya dapat menggunakan DeFi dengan DEXs, Peminjaman...!
 	Dukungan instan untuk rantai baru tanpa integrasi manual: NEAR-Intents sudah dapat bekerja dengan semua rantai EVM daripada harus menunggu tim untuk integrasi manual untuk setiap rantai EVM baru karena mereka memiliki infrastruktur yang sama persis.
 	Eksekusi Berbasis AI: Jaringan solver, termasuk agen AI, menganalisis niat Anda dan mengeksekusinya dengan cara yang paling efisien. Ini berarti Anda mendapatkan manfaat dari sumber likuiditas terbaik, baik on-chain, off-chain, dari bursa terpusat (CEXs), atau terdesentralisasi (DEXs), semua dioptimalkan untuk kecepatan dan biaya.
 	Likuiditas Terpadu: NEAR Intents mengumpulkan peserta AI bersama dengan layanan keuangan, perdagangan, dan pengguna akhir, menyatukan likuiditas di berbagai platform.
 	Kemungkinan dan Kasus Penggunaan Baru: Dengan menggabungkan jenis niat apa pun dengan agen AI, Anda dapat menjelajahi primitif baru dan membayangkan perdagangan, pelelangan, token, dan lainnya.
 	Penanganan Aman Aset: Transfer, staking, dan mengelola berbagai aset, termasuk NFT, FT, SBT, dan aset yang tidak dapat ditransfer, dengan keamanan dan kepatuhan dalam pikiran.
 	Terbuka dan Tanpa Izin: Infrastruktur lintas-rantai terdesentralisasi memungkinkan Anda untuk dengan mudah membangun atau meluncurkan produk keuangan baru.
 	Pengalaman yang Handal dan Cepat: Penyelesaian lintas-rantai antara agen dan pengguna terjadi dalam hitungan detik, memastikan pengalaman yang lancar.
 	Likuiditas Gabungan: Menjembatani kesenjangan antara DEXs lintas rantai, CEXs, dan bahkan di luar kripto memastikan partisipasi dan inovasi dari berbagai pemangku kepentingan

"Intents adalah antarmuka universal untuk perdagangan global, memungkinkan transisi DeFi, TradFi, dan lainnya. Pikirkan mereka sebagai kontrak hukum multi-pihak yang diselesaikan secara kriptografis." – Illia Polosukhin, Pendiri NEAR

 
Integrasi dengan NEAR-intents
NEAR Intents menyederhanakan pengembangan blockchain, memungkinkan fungsionalitas lintas-rantai yang mulus dan solusi berbasis AI. Baik Anda membangun aplikasi DeFi, dompet lintas-rantai, atau layanan inovatif, NEAR Intents menyediakan alat untuk mewujudkannya!

Sumber Daya untuk Pengembang:

 	Halaman beranda NEAR-Intents: https://near.org/intents
 	Dokumentasi, API, dan SDK: https://docs.near-intents.org/
 	Grup pengembang NEAR: https://t.me/neardev
 	Grup NEAR Intents: https://t.me/near_intents
 	Dokumentasi NEAR: https://docs.near.org/
 	[DISENSOR] 2024 | Alex Shevchenko - Lapisan Intents
 	[DISENSOR] 2024 | Omnibridge: Bagaimana Cara Kerjanya

Mulailah membangun sekarang juga!NEAR Intents mengubah permainan dengan membuat interaksi blockchain lebih lancar, lebih cepat, dan lebih cerdas. Tidak perlu lagi melompat-lompat untuk menukar token atau mengelola aset—semuanya hanya beberapa klik saja, tanpa masalah biaya gas atau setup yang kompleks.

Dengan solver yang didorong oleh kecerdasan buatan, likuiditas yang terpadu, dan dukungan lintas rantai bahkan untuk rantai non-smart-contract seperti Bitcoin dan Doge, NEAR Intents membuka kemungkinan tanpa batas. Mulai dari menukar token dalam hitungan detik hingga menggunakan DeFi untuk setiap rantai, itu cepat, aman, terdesentralisasi, dan sangat mudah digunakan.

Pikirkan itu sebagai pengalaman mirip Coinbase tetapi terdesentralisasi, hemat biaya, dan tanpa izin. Sudah saatnya mengalami blockchain sebagaimana seharusnya—tanpa usaha dan ajaib.

Bagi pengembang, NEAR Intents menyederhanakan pembangunan aplikasi terdesentralisasi dengan menangani kompleksitas lintas rantai, memungkinkan Anda fokus pada hal yang paling penting—aplikasi Anda. Anda dapat mengintegrasikan NEAR Intents ke dalam proyek Anda untuk membuka peluang baru dan menawarkan pengalaman yang mulus dan aman bagi pengguna.


                 
 
                        Now I know how NEAR Intents work(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### NEAR 의도: 사용자 및 개발자를 위한 안내서

NEAR-Intents를 사용하는 DEX - 몇 번의 클릭만으로 BTC를 Dogecoin으로 교환하세요! NEAR의 동력으로 작동합니다!
NEAR Intents가 필요한 이유
먼저 간단한 질문으로 시작해보죠: NEAR Intents에 대해 왜 신경 써야 할까요?

DEX를 사용하여 BTC를 Doge로 또는 이더리움을 NEAR로 교환해 본 적이 있나요?

ETH를 NEAR로 교환하는 일반적인 단계는 다음과 같습니다:

 	지갑에 $ETH를 준비합니다.
 	ETH를 NEAR로 브릿지합니다 (브릿지 수수료를 위해 일부 ETH를 저장하는 것을 잊지 마세요).
 	NEAR를 가스 토큰으로 사용할 수 있도록 합니다.
 	ETH를 NEAR로 교환합니다.

복잡해 보이죠? 여전히 작동하지만 많은 시간과 노력이 필요합니다.
그렇다면 비트코인 <> 도지코인, 도지 <> XRP 또는 이더리움 <> 도지코인을 교환하고 싶다면 어떻게 해야 할까요? 이러한 체인에는 DEX가 없으며 유일한 옵션은 중앙화된 거래소인 바이낸스나 코인베이스입니다.

NEAR Intents가 이 모든 것을 해결합니다!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR Intents를 사용하면 다음을 할 수 있습니다:

 	어떤 지갑에서든 토큰을 입금합니다.
 	어떤 체인의 어떤 토큰으로든 교환합니다.
 	교환을 위해 서명만 하면 되므로 가스 토큰이 필요하지 않습니다 (시간과 돈을 절약합니다).
 	서명만으로 네이티브 체인의 어떤 지갑으로 출금합니다.

예를 들어, 비트코인 네트워크에서 $BTC를 30초 이내에 $NEAR로 교환할 수 있습니다!

https://youtu.be/JoyJgRi0G7s

NEAR Intents는 CEX처럼 작동하지만 DEX처럼 분산화되어 사용하기 쉽고 저렴하며 빠르며 허가 없이 NEAR 블록체인으로 구동됩니다!

멋지죠? 코인베이스와 비슷한 경험을 생각해보세요. 분산화되고 매우 부드러운 경험입니다!

지금 바로 NEAR-Intents를 활용한 흥미로운 응용 프로그램을 시도해 볼 수 있습니다:

 	NEAR Intents DEX
 	Solana 사용자를 위한 Solswap
 	도지코인을 위한 최초의 DEX인 Dogecoin Swap
 	Turbo Swap

🤖📈 NEAR Intents로 구동되는 텔레그램 트레이딩 봇 INTEAR:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - 인공지능 지갑
https://x.com/BitteProtocol/status/1868682419785605630

즐거운 사용하세요! 이제 이 모든 것이 어떻게 작동하는지 궁금해졌죠. 좀 더 깊게 파고들어보죠! 🤓
https://x.com/i/status/1855475653283594591

한 토큰, 어떤 체인.
모든 유동성, 한 체인.

NEAR Intents는 NEAR 기술 스택의 일부로 출시됩니다.

진정한 크로스체인 DeFi가 여기에 있으며 NEAR로 구동됩니다 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 2024년 11월 10일
"NEAR Intents는 AI 에이전트, 서비스 및 최종 사용자 간에 정보, 요청, 자산 및 작업을 교환할 수 있는 새로운 유형의 거래입니다."간단히 말해, NEAR 인텐트는 당신이 어떤 것을 달성하고 싶은지를 설명할 수 있게 해줍니다. 어떻게 하는지에 대해 걱정할 필요 없이 대신, 분산 네트워크의 해결사들 (AI 에이전트, 웹2 및 웹3 서비스 등)가 NEAR 블록체인의 동력으로 오픈, 안전하고 분산된 방식으로 당신을 위해 일을 처리합니다.

이전에 보았던 데모는 NEAR 인텐트의 힘을 보여주는 인터페이스일 뿐입니다. 그러나 잠재적인 사용 사례는 매우 다양합니다. 예를 들어, Bitte Wallet을 사용하여 AI에게 스왑, 스테이킹 또는 최적의 검증자를 찾도록 지시할 수 있습니다.

NEAR 인텐트는 어떻게 작동합니까?
NEAR 인텐트가 작동하는 간단한 개요는 다음과 같습니다:



 	사용자가 인텐트 정의: 10 ETH를 USDC로 스왑하고, "10 ETH로 얼마의 USDC를 받을 수 있을까?"라고 물어봅니다.
 	해결사 버스 쿼리: 해결사 버스는 여러 해결사에게 10 ETH에 대한 최상의 USDC 제안을 찾도록 요청을 보냅니다.
 	해결사 응답: 해결사들은 어디서든 유동성을 조달하여 제안을 계산합니다 (예: 해결사 1: 40,100 USDC; 해결사 2: 40,000 USDC).
 	최상의 제안 선택: 해결사 버스는 최상의 견적 (40,100 USDC)을 선택하고 당신에게 알려줍니다.
 	사용자 승인: 당신은 지갑에서 메시지에 서명하여 스왑을 승인합니다 - 비싼 거래가 필요 없으며, 이더리움이나 비트코인과 같은 비싼 체인에서 많은 돈을 절약할 수 있습니다.
 	스왑 실행: 해결사 버스는 당신의 서명된 데이터를 검증자 계약에 보내어 체인 상에서 스왑을 실행합니다.

이를 통해 사용자가 안전하고 효율적으로 최상의 환율을 얻을 수 있으며, 제안받은 가격이 정확히 받는 가격입니다.

암호화 자산 이외에도, 예정된 업데이트를 통해 Netflix 구독, 티켓, 온라인 결제 또는 피아트 입출금과 같은 웹2 서비스를 교환할 수 있게 될 것입니다. 당신의 의도를 충족할 해결사가 준비되어 있다면, 가능성은 무한합니다!
해결사는 교환소, 당신의 주문을 처리할 의사가 있는 AI 에이전트일 수 있습니다!




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






더 자세한 내용은 [REDACTED] 2024에서 Alex Shevchenko의 인텐트 레이어에 대한 강연을 시청하는 것을 강력히 추천합니다.

https://www.youtube.com/watch?v=PD7SbJrHjGo

NEAR 인텐트: 주요 장점
NEAR 인텐트는 NEAR의 체인 추상화 스택의 핵심 부분으로 다양한 혜택을 제공합니다:
	모든 체인을 지원하는 스마트 계약 기능 제공: 비트코인, XRP, Doge와 같은 스마트 계약이 없는 체인을 포함하여 이러한 체인의 사용자들은 마침내 DEXs, 대출 등을 통해 DeFi를 사용할 수 있습니다!
	수동 통합 없이 새로운 체인에 대한 즉각적인 지원: NEAR-Intents는 모든 EVM 체인과 이미 작동할 수 있으므로 새로운 EVM 체인마다 팀의 수동 통합을 기다릴 필요가 없습니다. 왜냐하면 그들은 정확히 동일한 인프라를 가지고 있기 때문입니다.
	AI-Driven Execution: AI 에이전트를 포함한 솔버 네트워크가 여러분의 의도를 분석하고 가능한 가장 효율적인 방식으로 실행합니다. 이는 온체인, 오프체인, 중앙화 거래소(CEXs) 또는 탈중앙화 거래소(DEXs)에서 최적화된 속도와 비용을 위해 최상의 유동성 소스를 활용할 수 있음을 의미합니다.
	통합된 유동성: NEAR Intents는 AI 참가자들을 금융 서비스, 상업 및 최종 사용자와 통합하여 다양한 플랫폼 간의 유동성을 통합합니다.
	새로운 가능성과 사용 사례: 모든 의도 유형을 AI 에이전트와 결합하여 새로운 기본 요소를 탐색하고 거래, 경매, 토큰 등을 재상상할 수 있습니다.
	자산의 안전한 처리: NFT, FT, SBT 및 이전할 수 없는 자산을 포함한 다양한 자산을 안전하고 규정 준수를 염두에 두고 이체, 지분 및 관리할 수 있습니다.
	공개 및 허가 없음: 탈중앙화된 크로스체인 인프라를 통해 쉽게 새로운 금융 제품을 구축하거나 출시할 수 있습니다.
	신뢰할 수 있고 빠른 경험: 에이전트와 사용자 간의 크로스체인 결제가 몇 초 안에 이루어져 원활한 경험을 보장합니다.
	통합된 유동성: 체인 간 DEXs, CEXs 및 심지어 암호화폐 외부를 연결하여 다양한 이해관계자들의 참여와 혁신을 보장합니다

"Intents are a universal interface for global commerce, enabling DeFi, TradFi transitions, and more. Think of them as cryptographically settled multi-party legal contracts." – Illia Polosukhin, NEAR Co-Founder

 
NEAR-intents와의 통합
NEAR Intents는 블록체인 개발을 간단하게 만들어 크로스체인 기능과 AI 기반 솔루션을 원활하게 제공합니다. DeFi 앱, 크로스체인 지갑 또는 혁신적인 서비스를 구축 중이라면 NEAR Intents는 그것을 가능하게 하는 도구를 제공합니다!

개발자를 위한 자료:

	NEAR-Intents 홈페이지: https://near.org/intents
	문서, API 및 SDK: https://docs.near-intents.org/
	NEAR 개발 그룹: https://t.me/neardev
	NEAR Intents 그룹: https://t.me/near_intents
	NEAR 문서: https://docs.near.org/
	[REDACTED] 2024 | Alex Shevchenko - Intents layer
	[REDACTED] 2024 | Omnibridge: How it Actually Works

지금 바로 참여하고 빌드를 시작하세요!

마무리NEAR 인텐트는 블록체인 상호작용을 더 부드럽고 빠르고 똑똑하게 만들어 게임을 바꿉니다. 토큰 교환이나 자산 관리를 위해 번거롭게 뛰어다니지 않아도 됩니다. 모든 것이 몇 번의 클릭만으로 가능하며, 가스 수수료나 복잡한 설정 없이 모든 것이 가능합니다.

AI 기반 솔버, 통합된 유동성, 비트코인이나 도지 같은 비 스마트 계약 체인까지 교차 체인 지원을 통해 NEAR 인텐트는 끝없는 가능성을 열어줍니다. 몇 초 안에 토큰을 교환하거나 어떤 체인에 대해 DeFi를 사용하는 것은 빠르고 안전하며 탈중앙화되어 사용하기 매우 쉽습니다.

코인베이스와 같은 경험을 탈중앙화하고 비용 효율적이며 허가되지 않은 것으로 생각해보세요. 블록체인을 경험하는 것은 노력 없이 마법 같은 경험을 할 시간입니다.

개발자들에게 NEAR 인텐트는 교차 체인 복잡성을 처리하여 분산 애플리케이션을 구축하는 것을 간단하게 만들어줍니다. 가장 중요한 것에 집중할 수 있도록 해주며, 프로젝트에 NEAR 인텐트를 통합하여 사용자에게 원활하고 안전한 경험을 제공하고 새로운 기회를 개방할 수 있습니다.

### NEAR Intenções: Um Guia para Usuários e Desenvolvedores

uma DEX usando NEAR-Intents - simplesmente troque BTC por Dogecoin em poucos cliques! Alimentado por NEAR!
Por Que Você Precisa de NEAR Intents
Primeiro, vamos começar com uma pergunta simples: por que você deveria se importar com NEAR Intents?

Você já tentou trocar BTC por Doge, ou Ethereum por NEAR usando uma DEX?

Os passos típicos são assim para ETH para NEAR:

 	Prepare $ETH em sua carteira.
 	Bridge ETH para NEAR (não se esqueça de salvar algum ETH para a taxa da ponte).
 	Garanta que você tenha NEAR como token de gás.
 	Troque ETH por NEAR.

Parece complexo, certo? Ainda funciona, mas leva muito tempo e esforço.
E se você quiser trocar Bitcoin <> Dogecoin, Doge <> XRP, ou Ethereum <> Dogecoin? Essas redes não têm uma DEX e a única opção? Exchanges centralizadas como Binance ou Coinbase.

NEAR Intents resolve tudo isso!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Com NEAR Intents, você pode:

 	Depositar tokens de qualquer carteira.
 	Trocar por qualquer token em qualquer rede.
 	Simplesmente assinar para trocar—sem necessidade de um token de gás (economizando tempo e dinheiro).
 	Retirar para qualquer carteira na rede nativa com apenas uma assinatura.

Por exemplo, você pode trocar $BTC na rede Bitcoin por $NEAR em menos de 30 segundos!

https://youtu.be/JoyJgRi0G7s

NEAR Intents funciona como uma CEX, mas é descentralizado como uma DEX—fácil de usar, mais barato, mais rápido e sem permissão, tudo alimentado pela blockchain NEAR!

Legal, né? Pense nisso como uma experiência semelhante à da Coinbase, mas descentralizada e ultra-suave!

Há aplicações interessantes aproveitando NEAR-Intents que você pode experimentar agora mesmo:

 	NEAR Intents DEX
 	Solswap para usuários da Solana
 	Dogecoin Swap: a primeira DEX para Dogecoin
 	Turbo Swap

🤖📈 INTEAR - Um bot de negociação do Telegram alimentado por NEAR Intents:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - Carteiras de IA
https://x.com/BitteProtocol/status/1868682419785605630

Divirta-se! Agora você está curioso sobre como tudo isso funciona. Vamos aprofundar! 🤓
https://x.com/i/status/1855475653283594591

Uma token, qualquer rede.
Toda a liquidez, uma rede.

NEAR Intents está sendo lançado como parte do NEAR Tech Stack.

A verdadeira DeFi intercadeias está aqui, e é alimentada pela NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 10 de novembro de 2024
"NEAR Intents são um novo tipo de transação que permite a troca de informações, solicitações, ativos e ações entre agentes de IA, serviços e usuários finais."Em termos mais simples, os Intents NEAR permitem que você descreva o que deseja alcançar sem se preocupar com como fazê-lo. Em vez disso, uma rede descentralizada de solvers (agentes de IA, serviços web2 e web3, etc.) faz o trabalho por você de maneira aberta, segura e descentralizada, alimentada pela blockchain NEAR.

A demonstração anterior que você viu, é apenas uma interface mostrando o poder dos Intents NEAR. Mas os casos de uso potenciais são vastos. Por exemplo, com o Bitte Wallet, você pode instruir a IA a lidar com trocas, staking ou até mesmo encontrar os melhores validadores para você.

Como Funcionam os Intents NEAR?
Aqui está uma visão simplificada de como os Intents NEAR funcionam:



 	Usuário Define um Intent: Você deseja trocar 10 ETH por USDC e pergunta: "Quanto USDC posso obter por 10 ETH?"
 	Consultas do Solver Bus: O Solver Bus envia sua solicitação para vários solvers para encontrar a melhor oferta de USDC para 10 ETH.
 	Respostas do Solver: Os solvers calculam suas ofertas (por exemplo, Solver 1: 40.100 USDC; Solver 2: 40.000 USDC) obtendo liquidez de qualquer lugar.
 	Melhor Oferta Selecionada: O Solver Bus escolhe a melhor cotação (40.100 USDC) e informa você.
 	Aprovação do Usuário: Você aprova a troca assinando uma mensagem em sua carteira - sem a necessidade de uma transação cara, economize muito dinheiro em blockchains caras como Ethereum ou Bitcoin.
 	Execução da Troca: O Solver Bus envia seus dados assinados para um contrato verificador, que executa a troca on-chain.

Isso garante que os usuários obtenham as melhores taxas de forma segura e eficiente, com o preço cotado sendo exatamente o preço que você obtém.

Além de ativos criptográficos, atualizações futuras permitirão a troca de serviços web2 como assinaturas da Netflix, ingressos, pagamentos online ou rampas de entrada/saída de moeda fiduciária. Contanto que haja um solver pronto para atender ao seu intento, as possibilidades são infinitas!
Um Solver pode ser uma exchange, um agente de IA disposto a processar seu pedido!




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Recomendo assistir à palestra de Alex Shevchenko sobre a camada de Intents em [REDACTED] 2024 para saber mais.

https://www.youtube.com/watch?v=PD7SbJrHjGo

Intents NEAR: Principais Vantagens
Os Intents NEAR, uma parte central da pilha de Abstração de Cadeia da NEAR, oferecem inúmeros benefícios:
 	Leve funcionalidade de contrato inteligente para suportar todas as cadeias: incluindo cadeias não inteligentes como Bitcoin, XRP, Doge..., os usuários dessas cadeias finalmente podem usar DeFi com DEXs, Empréstimos...!
 	Suporte instantâneo para novas cadeias sem integração manual: NEAR-Intents já pode funcionar com todas as cadeias EVM em vez de ter que esperar pela integração manual da equipe para cada nova cadeia EVM, pois possuem a mesma infraestrutura exata.
 	Execução impulsionada por IA: Uma rede de solucionadores, incluindo agentes de IA, analisa sua intenção e a executa da maneira mais eficiente possível. Isso significa que você se beneficia das melhores fontes de liquidez, seja on-chain, off-chain, de exchanges centralizadas (CEXs) ou descentralizadas (DEXs), todas otimizadas para velocidade e custo.
 	Liquidez Unificada: NEAR Intents reúne participantes de IA com serviços financeiros, comércio e usuários finais, unificando a liquidez em diferentes plataformas.
 	Novas Possibilidades e Casos de Uso: Ao combinar qualquer tipo de intenção com agentes de IA, você pode explorar novos primitivos e reimaginar negociações, leilões, tokens e muito mais.
 	Manuseio Seguro de Ativos: Transferir, apostar e gerenciar uma ampla gama de ativos, incluindo NFTs, FTs, SBTs e ativos não transferíveis, com segurança e conformidade em mente.
 	Aberto e Sem Permissão: A infraestrutura descentralizada e cross-chain permite que você construa ou lance novos produtos financeiros facilmente.
 	Experiência Confiável e Rápida: O acerto cross-chain entre agentes e usuários acontece em segundos, garantindo uma experiência suave.
 	Liquidez Combinada: A ponte entre DEXs em diferentes cadeias, CEXs e até fora do cripto garante a participação e inovação de vários interessados.

"Intenções são uma interface universal para o comércio global, possibilitando transições DeFi, TradFi e muito mais. Pense nelas como contratos legais multi-partes resolvidos criptograficamente." – Illia Polosukhin, Co-Fundador da NEAR

 
Integração com NEAR-intents
NEAR Intents simplifica o desenvolvimento blockchain, possibilitando funcionalidade cross-chain e soluções impulsionadas por IA sem problemas. Se você está construindo aplicativos DeFi, carteiras cross-chain ou serviços inovadores, NEAR Intents fornece as ferramentas para tornar isso possível!

Recursos para Desenvolvedores:

 	Página inicial do NEAR-Intents: https://near.org/intents
 	Documentação, APIs e SDK: https://docs.near-intents.org/
 	Grupo de desenvolvedores NEAR: https://t.me/neardev
 	Grupo NEAR Intents: https://t.me/near_intents
 	Documentação NEAR: https://docs.near.org/
 	[REDACTED] 2024 | Alex Shevchenko - Camada de Intenções
 	[REDACTED] 2024 | Omnibridge: Como Funciona na Realidade

Mergulhe e comece a construir hoje!

Para ConcluirNEAR Intents está mudando o jogo ao tornar as interações com blockchain mais suaves, rápidas e inteligentes. Não é mais necessário pular obstáculos para trocar tokens ou gerenciar ativos - tudo está a apenas alguns cliques de distância, sem a complicação de taxas de gás ou configurações complexas.

Com solucionadores impulsionados por IA, liquidez unificada e suporte cross-chain até mesmo para cadeias não baseadas em contratos inteligentes como Bitcoin e Doge, NEAR Intents desbloqueia possibilidades infinitas. Desde a troca de tokens em segundos até o uso de DeFi para qualquer cadeia, é rápido, seguro, descentralizado e incrivelmente fácil de usar.

Pense nisso como uma experiência semelhante à da Coinbase, mas descentralizada, econômica e sem permissão. É hora de experimentar o blockchain da maneira como deveria ser - sem esforço e mágico.

Para desenvolvedores, NEAR Intents simplifica a construção de aplicativos descentralizados lidando com a complexidade cross-chain, permitindo que você se concentre no que mais importa - seus aplicativos. Você pode integrar NEAR Intents em seus projetos para desbloquear novas oportunidades e oferecer experiências perfeitas e seguras para os usuários.


                 
 
                        Now I know how NEAR Intents work(Required)
			
					
					YES
			
			
					
					NO
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### NEAR Intenciones: Una Guía para Usuarios y Desarrolladores

un DEX que utiliza NEAR-Intents: ¡simplemente intercambia BTC por Dogecoin en unos pocos clics! ¡Impulsado por NEAR!
Por qué necesitas NEAR Intents
Primero, comencemos con una pregunta simple: ¿por qué deberías preocuparte por NEAR Intents?

¿Alguna vez has intentado intercambiar BTC por Doge, o Ethereum por NEAR usando un DEX?

Los pasos típicos son los siguientes para ETH a NEAR:

 	Prepara $ETH en tu billetera.
 	Pasa ETH a NEAR (no olvides guardar algo de ETH para la tarifa del puente).
 	Asegúrate de tener NEAR como token de gas.
 	Intercambia ETH por NEAR.

¿Parece complejo, verdad? Aún funciona, pero lleva mucho tiempo y esfuerzo.
Entonces, ¿qué pasa si quieres intercambiar Bitcoin <> Dogecoin, Doge <> XRP, o Ethereum <> Dogecoin? Estas cadenas no tienen un DEX y ¿la única opción? Intercambios centralizados como Binance o Coinbase.

¡NEAR Intents resuelve todo esto!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Con NEAR Intents, puedes:

 	Depositar tokens desde cualquier billetera.
 	Intercambiar por cualquier token en cualquier cadena.
 	Solo firma para intercambiar, no necesitas un token de gas (ahorrando tiempo y dinero).
 	Retirar a cualquier billetera en la cadena nativa con solo una firma.

Por ejemplo, ¡puedes intercambiar $BTC en la red de Bitcoin por $NEAR en menos de 30 segundos!

https://youtu.be/JoyJgRi0G7s

¡NEAR Intents funciona como un CEX pero es descentralizado como un DEX, fácil de usar, más barato, más rápido y sin permisos, todo impulsado por la cadena de bloques NEAR!

¡Genial, verdad? ¡Piénsalo como una experiencia similar a Coinbase pero descentralizada y ultra suave!

Hay aplicaciones interesantes que aprovechan NEAR-Intents que puedes probar ahora mismo:

 	NEAR Intents DEX
 	Solswap para usuarios de Solana
 	Dogecoin Swap: el primer DEX para Dogecoin
 	Turbo Swap

🤖📈 INTEAR - Un bot de trading de Telegram impulsado por NEAR Intents:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - Billeteras de IA
https://x.com/BitteProtocol/status/1868682419785605630

¡Feliz uso! Ahora estás curioso sobre cómo funciona todo esto. ¡Vamos a profundizar! 🤓
https://x.com/i/status/1855475653283594591

Un token, cualquier cadena.
Toda la liquidez, una cadena.

NEAR Intents se está lanzando como parte del NEAR Tech Stack.

La verdadera DeFi intercadena está aquí, ¡y está impulsada por NEAR! 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 10 de noviembre de 2024
"NEAR Intents son un nuevo tipo de transacción que permite intercambiar información, solicitudes, activos y acciones entre agentes de IA, servicios y usuarios finales."En términos más simples, los Intents de NEAR te permiten describir lo que deseas lograr sin preocuparte por cómo hacerlo. En cambio, una red descentralizada de solucionadores (agentes de IA, servicios web2 y web3, etc.) hace el trabajo por ti de manera abierta, segura y descentralizada, impulsada por la cadena de bloques NEAR.

La demostración anterior que viste, es solo una interfaz que muestra el poder de los Intents de NEAR. Pero los casos de uso potenciales son vastos. Por ejemplo, con Bitte Wallet, puedes instruir a la IA para manejar intercambios, participaciones, o incluso encontrar los mejores validadores para ti.

¿Cómo funciona NEAR Intents?
Aquí tienes una descripción simplificada de cómo funcionan los Intents de NEAR:

1. El usuario define un Intent: Quieres intercambiar 10 ETH por USDC y preguntas, "¿Cuánto USDC puedo obtener por 10 ETH?"
2. Consultas del Bus del Solucionador: El Bus del Solucionador envía tu solicitud a múltiples solucionadores para encontrar la mejor oferta de USDC por 10 ETH.
3. Respuestas del Solucionador: Los solucionadores calculan sus ofertas (por ejemplo, Solucionador 1: 40,100 USDC; Solucionador 2: 40,000 USDC) obteniendo liquidez de cualquier lugar.
4. Mejor Oferta Seleccionada: El Bus del Solucionador elige la mejor cotización (40,100 USDC) y te informa.
5. Aprobación del Usuario: Apruebas el intercambio firmando un mensaje en tu billetera, sin necesidad de una transacción costosa, ahorrando mucho dinero en cadenas costosas como Ethereum o Bitcoin.
6. Ejecución del Intercambio: El Bus del Solucionador envía tus datos firmados a un contrato verificador, que ejecuta el intercambio en la cadena.

Esto asegura que los usuarios obtengan las mejores tasas de manera segura y eficiente, con el precio que te cotizaron siendo el precio exacto que obtienes.

Más allá de los activos criptográficos, las próximas actualizaciones permitirán el intercambio de servicios web2 como suscripciones de Netflix, boletos, pagos en línea, o rampas de entrada/salida de fiat. ¡Siempre que haya un solucionador listo para cumplir tu intención, las posibilidades son infinitas! ¡Un Solucionador podría ser un intercambio, un agente de IA dispuesto a procesar tu orden!

¡Recomiendo encarecidamente ver la charla de Alex Shevchenko sobre la capa de Intents en [REDACTED] 2024 para aprender más!

https://www.youtube.com/watch?v=PD7SbJrHjGo

Intents de NEAR: Ventajas Clave
Los Intents de NEAR, una parte fundamental de la pila de Abstracción de Cadena de NEAR, ofrecen numerosos beneficios:
 	Llevar la funcionalidad de contratos inteligentes para soportar todas las cadenas: incluyendo cadenas no inteligentes como Bitcoin, XRP, Doge..., ¡los usuarios de estas cadenas finalmente pueden usar DeFi con DEXs, préstamos...!
 	Soporte instantáneo para nuevas cadenas sin integración manual: NEAR-Intents ya puede trabajar con todas las cadenas EVM en lugar de tener que esperar a que el equipo haga una integración manual para cada nueva cadena EVM porque tienen la misma infraestructura exactamente.
 	Ejecución impulsada por IA: Una red de solucionadores, incluidos agentes de IA, analizan tu intención y la ejecutan de la manera más eficiente posible. Esto significa que te beneficias de las mejores fuentes de liquidez, ya sea en cadena, fuera de cadena, de intercambios centralizados (CEXs) o descentralizados (DEXs), todo optimizado para velocidad y costo.
 	Liquidez unificada: NEAR Intents reúne a participantes de IA con servicios financieros, comercio y usuarios finales, unificando la liquidez en diferentes plataformas.
 	Nuevas posibilidades y casos de uso: Al combinar cualquier tipo de intención con agentes de IA, puedes explorar nuevos primitivos y reimaginar el trading, subastas, tokens y más.
 	Manejo seguro de activos: Transfiere, apuesta y administra una amplia gama de activos, incluidos NFTs, FTs, SBTs y activos no transferibles, con seguridad y cumplimiento en mente.
 	Abierto y sin permisos: La infraestructura descentralizada y entre cadenas te permite construir o lanzar nuevos productos financieros fácilmente.
 	Experiencia confiable y rápida: El liquidación entre agentes y usuarios entre cadenas se realiza en segundos, asegurando una experiencia fluida.
 	Liquidez combinada: Al bridar la brecha entre DEXs entre cadenas, CEXs e incluso fuera del cripto asegura la participación e innovación de varios interesados.

"Las intenciones son una interfaz universal para el comercio global, permitiendo transiciones DeFi, TradFi y más. Piensa en ellas como contratos legales multiparte resueltos criptográficamente." – Illia Polosukhin, Cofundador de NEAR

 
Integración con NEAR-intents
NEAR Intents simplifica el desarrollo de blockchain, permitiendo una funcionalidad sin problemas entre cadenas y soluciones impulsadas por IA. ¡Ya sea que estés construyendo aplicaciones DeFi, billeteras entre cadenas o servicios innovadores, NEAR Intents proporciona las herramientas para hacerlo realidad!

Recursos para desarrolladores:

 	Página de inicio de NEAR-Intents: https://near.org/intents
 	Documentos, APIs y el SDK: https://docs.near-intents.org/
 	Grupo de desarrolladores de NEAR: https://t.me/neardev
 	Grupo de NEAR Intents: https://t.me/near_intents
 	Documentos de NEAR: https://docs.near.org/
 	[REDACTED] 2024 | Alex Shevchenko - Capa de Intents
 	[REDACTED] 2024 | Omnibridge: Cómo funciona en realidad

¡Sumérgete y comienza a construir hoy!

En conclusiónNEAR Intents está cambiando el juego al hacer que las interacciones en blockchain sean más suaves, rápidas e inteligentes. Ya no es necesario dar vueltas para intercambiar tokens o gestionar activos, todo está a solo unos clics de distancia, sin la molestia de tarifas de gas o configuraciones complejas.

Con solucionadores impulsados por IA, liquidez unificada y soporte entre cadenas incluso para cadenas no inteligentes como Bitcoin y Doge, NEAR Intents desbloquea posibilidades infinitas. Desde intercambiar tokens en segundos hasta utilizar DeFi para cualquier cadena, es rápido, seguro, descentralizado y increíblemente fácil de usar.

Piénsalo como una experiencia similar a Coinbase pero descentralizada, rentable y sin permisos. Es hora de experimentar blockchain de la manera en que estaba destinado a ser: sin esfuerzo y mágico.

Para los desarrolladores, NEAR Intents simplifica la construcción de aplicaciones descentralizadas al manejar la complejidad entre cadenas, permitiéndote centrarte en lo que más importa: tus aplicaciones. Puedes integrar NEAR Intents en tus proyectos para desbloquear nuevas oportunidades y ofrecer experiencias fluidas y seguras para los usuarios.

### NEARインテント：ユーザーと開発者向けガイド

NEAR-Intentsを使用したDEX - たった数クリックでBTCをDogecoinに交換！NEARのパワーで動作します！
NEAR Intentsが必要な理由
まず、簡単な質問から始めましょう：なぜNEAR Intentsに注意を払う必要があるのでしょうか？

DEXを使用してBTCをDogeに、またはEthereumをNEARに交換したことがありますか？

ETHからNEARへの典型的な手順は次のようになります：

 	ウォレット内の$ETHを準備します。
 	ETHをNEARにブリッジします（ブリッジ手数料のために一部のETHを保存するのを忘れないでください）。
 	NEARをガストークンとして持っていることを確認します。
 	ETHをNEARに交換します。

複雑そうですね？まだ機能しますが、多くの時間と労力がかかります。
では、Bitcoin <> Dogecoin、Doge <> XRP、またはEthereum <> Dogecoinを交換したい場合はどうでしょうか？これらのチェーンにはDEXがなく、唯一の選択肢は？BinanceやCoinbaseなどの中央集権取引所です。

NEAR Intentsはこれらすべてを解決します！




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR Intentsを使用すると、次のことができます：

 	任意のウォレットからトークンを入金します。
 	任意のチェーン上の任意のトークンに交換します。
 	交換するために署名するだけで済みます - ガストークンは不要です（時間とお金を節約できます）。
 	署名だけでネイティブチェーン上の任意のウォレットに引き出します。

例えば、Bitcoinネットワーク上の$BTCを30秒以内に$NEARに交換できます！

https://youtu.be/JoyJgRi0G7s

NEAR IntentsはCEXのように機能しますが、DEXのように分散化されており、使用が簡単で安価で高速で許可が必要ありません。すべてNEARブロックチェーンで動作します！

スリックですね？Coinbaseのような体験を考えてみてくださいが、分散化されており、超スムーズです！

NEAR-Intentsを活用した興味深いアプリケーションを今すぐ試してみることができます：

 	NEAR Intents DEX
 	Solanaユーザー向けSolswap
 	Dogecoin Swap：Dogecoin用の最初のDEX
 	Turbo Swap

🤖📈INTEAR - NEAR Intentsで動作するTelegramトレーディングボット：https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - AIウォレットhttps://x.com/BitteProtocol/status/1868682419785605630

お楽しみください！これがどのように機能するかについて興味を持っています。さらに深く掘り下げましょう！🤓
https://x.com/i/status/1855475653283594591

One token, any chain.
All liquidity, one chain.

NEAR Intents is launching as part of the NEAR Tech Stack.

True crosschain DeFi is here, and it’s powered by NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) November 10, 2024
"NEAR Intentsは、AIエージェント、サービス、エンドユーザー間で情報、リクエスト、資産、アクションを交換する新しいタイプのトランザクションです。"より簡単な言葉で言えば、NEARインテントは、どのように実現するかを気にせずに、何を達成したいかを説明することができます。代わりに、分散型のソルバー（AIエージェント、web2およびweb3サービスなど）が、NEARブロックチェーンによって駆動され、オープンで安全かつ分散化された方法であなたのために作業を行います。

以前に見たデモは、NEARインテントの力を示すインターフェースに過ぎません。しかし、潜在的なユースケースは非常に多岐にわたります。例えば、Bitte Walletを使用すると、AIにスワップ、ステーキング、または最適なバリデータを見つけるよう指示することができます。
NEARインテントはどのように機能するのか？
NEARインテントの動作の簡略化された概要は次のとおりです：



 	ユーザーがインテントを定義： 10 ETHをUSDCにスワップしたいとし、「10 ETHでどれだけのUSDCを得られるか？」と尋ねます。
 	ソルバーバスがクエリを送信： ソルバーバスは、あなたのリクエストを複数のソルバーに送信して、10 ETHの最良のUSDCオファーを見つけます。
 	ソルバーの応答： ソルバーは、どこからでも流動性を調達して、自分のオファーを計算します（例：ソルバー1：40,100 USDC；ソルバー2：40,000 USDC）。
 	最良のオファーが選択される： ソルバーバスは、最良の見積もり（40,100 USDC）を選択して、あなたに通知します。
 	ユーザーの承認： あなたはウォレットでメッセージに署名することでスワップを承認します。高額なトランザクションは不要で、EthereumやBitcoinなどの高額なチェーンで多くのお金を節約できます。
 	スワップの実行： ソルバーバスは、署名されたデータを検証者契約に送信し、チェーン上でスワップを実行します。

これにより、ユーザーは安全かつ効率的に最良のレートを得ることができ、見積もりを受けた価格が正確な価格であることが保証されます。

暗号資産以外にも、今後のアップデートでは、Netflixのサブスクリプション、チケット、オンライン支払い、またはフィアットのオン/オフランプなど、web2サービスの交換が可能になります。あなたの意図を満たす準備ができているソルバーがいる限り、可能性は無限です！
ソルバーは、注文を処理するAIエージェントや交換所などがあります！




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






より詳しく知るために、Alex Shevchenko氏のIntents Layerに関するトークを[REDACTED] 2024でご覧いただくことを強くお勧めします。

https://www.youtube.com/watch?v=PD7SbJrHjGo

 
NEARインテント：主な利点
NEARインテントは、NEARのChain Abstractionスタックの中核部分であり、多くの利点を提供します。
 	すべてのチェーンをサポートするスマートコントラクト機能を提供: ビットコイン、XRP、Dogeなどの非スマートコントラクトチェーンを含む、これらのチェーンのユーザーは、ついにDeFiやDEX、Lendingsなどを利用できます！
 	手動統合なしで新しいチェーンを即座にサポート: NEAR-Intentsは、すべてのEVMチェーンとすでに連携しており、新しいEVMチェーンごとにチームの手動統合を待つ必要がなくなりました。なぜなら、それらはまったく同じインフラストラクチャを持っているからです。
 	AIによる実行: AIエージェントを含むソルバーのネットワークが、あなたの意図を分析し、最も効率的な方法で実行します。これにより、オンチェーン、オフチェーン、中央集権取引所（CEX）、または分散型取引所（DEX）など、最適化された速度とコストで最適な流動性ソースを活用できます。
 	統一された流動性: NEAR Intentsは、AI参加者を金融サービス、商業、エンドユーザーと統合し、異なるプラットフォーム間で流動性を統一します。
 	新しい可能性とユースケース: 任意の意図タイプをAIエージェントと組み合わせることで、新しいプリミティブや取引、オークション、トークンなどを探索し、再構築できます。
 	資産の安全な取り扱い: NFT、FT、SBT、および移転不可能な資産を含む幅広い資産の移転、ステーキング、管理を、セキュリティとコンプライアンスを考慮して行います。
 	オープンで許可なし: 分散型のクロスチェーンインフラストラクチャを使用すると、新しい金融製品を簡単に構築またはローンチできます。
 	信頼性と高速な体験: エージェントとユーザー間のクロスチェーン決済は数秒で行われ、スムーズな体験を保証します。
 	統合された流動性: DEX、CEX、さらには暗号通貨外でも、さまざまなステークホルダーからの参加とイノベーションを確保する、チェーン間のギャップを埋める

"インテントは、グローバルな商取引のための普遍的なインターフェースであり、DeFi、TradFiの移行などを可能にします。それらを、暗号的に決済された多者間の法的契約と考えてください。" – イリア・ポロスフィン、NEAR共同創設者

 
NEAR-intentsとの統合
NEAR Intentsは、ブロックチェーン開発を簡素化し、シームレスなクロスチェーン機能とAIパワードソリューションを実現します。DeFiアプリ、クロスチェーンウォレット、または革新的なサービスを構築している場合、NEAR Intentsはそれを実現するためのツールを提供します！

開発者向けリソース:

 	NEAR-Intentsホームページ: https://near.org/intents
 	ドキュメント、API、SDK: https://docs.near-intents.org/
 	NEAR開発者グループ: https://t.me/neardev
 	NEAR Intentsグループ: https://t.me/near_intents
 	NEARドキュメント: https://docs.near.org/
 	[REDACTED] 2024 | アレックス・シェフチェンコ - インテントレイヤー
 	[REDACTED] 2024 | Omnibridge: 実際の動作方法

今すぐ潜入して、開発を始めましょう！
最後にNEARインテントは、ブロックチェーンとのやり取りをスムーズで高速、そしてスマートに変えています。トークンの交換や資産の管理に手間取ることはもうありません。すべてが数クリックで手に入り、ガス料金や複雑な設定の煩わしさもありません。

AI駆動のソルバー、統合された流動性、そしてBitcoinやDogeなどのスマートコントラクトでないチェーンにもクロスチェーンサポートを提供することで、NEARインテントは無限の可能性を開放します。数秒でトークンを交換したり、どんなチェーンでもDeFiを利用したりすることができ、速く、安全で、分散化され、使いやすいです。

Coinbaseのような体験を分散化し、コスト効果的で許可なしに提供します。ブロックチェーンを、手間なく、魔法のように体験する時が来ました。

開発者にとって、NEARインテントはクロスチェーンの複雑さを処理し、あなたが最も重要だと考えることに集中できるようにすることで、分散化アプリケーションの構築を簡素化します。プロジェクトにNEARインテントを統合して、ユーザーにシームレスで安全な体験を提供する新しい機会を開放できます。

### NEAR Намерения: Руководство для пользователей и разработчиков

биржа, использующая NEAR-Intents - просто обменяйте BTC на Dogecoin всего в несколько кликов! Работает на NEAR!
Почему вам нужны NEAR Intents
Давайте начнем с простого вопроса: почему вам следует обратить внимание на NEAR Intents?

Вы когда-нибудь пытались обменять BTC на Doge или Ethereum на NEAR с использованием DEX?

Типичные шаги выглядят так для ETH на NEAR:

 	Подготовьте $ETH в своем кошельке.
 	Мост ETH на NEAR (не забудьте оставить немного ETH на комиссию за мост).
 	Убедитесь, что у вас есть NEAR в качестве токена газа.
 	Обменять ETH на NEAR.

Кажется сложным, верно? Это все еще работает, но занимает много времени и усилий.
Что если вы хотите обменять Bitcoin <> Dogecoin, Doge <> XRP или Ethereum <> Dogecoin? У этих цепочек нет DEX, и единственный вариант? Централизованные биржи, такие как Binance или Coinbase.

NEAR Intents решает все это!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






С NEAR Intents вы можете:

 	Внести токены из любого кошелька.
 	Обменять на любой токен на любой цепочке.
 	Просто подписать обмен - не нужно газовый токен (экономия времени и денег).
 	Вывести на любой кошелек на родной цепочке всего с одной подписью.

Например, вы можете обменять $BTC на сети Bitcoin на $NEAR менее чем за 30 секунд!

https://youtu.be/JoyJgRi0G7s

NEAR Intents работает как CEX, но децентрализованно, как DEX - легко использовать, дешево, быстро и без разрешений, все это работает на блокчейне NEAR!

Круто, верно? Представьте это как опыт, похожий на Coinbase, но децентрализованный и ультра-плавный!

Есть интересные приложения, использующие NEAR-Intents, которые вы можете попробовать прямо сейчас:

 	NEAR Intents DEX
 	Solswap для пользователей Solana
 	Dogecoin Swap: первый DEX для Dogecoin
 	Turbo Swap

🤖📈 INTEAR - Торговый бот Telegram, работающий на NEAR Intents:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - AI Кошельки
https://x.com/BitteProtocol/status/1868682419785605630

Счастливого использования! Теперь вас интересует, как все это работает. Давайте поглубже разберемся! 🤓
https://x.com/i/status/1855475653283594591

One token, any chain.
All liquidity, one chain.

NEAR Intents is launching as part of the NEAR Tech Stack.

True crosschain DeFi is here, and it’s powered by NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) 10 ноября 2024 г.
"NEAR Intents - новый тип транзакций, позволяющий обменивать информацию, запросы, активы и действия между искусственными интеллектами, сервисами и конечными пользователями."Проще говоря, Намерения NEAR позволяют вам описать, что вы хотите достичь, не беспокоясь о как это сделать. Вместо этого децентрализованная сеть решателей (ИИ-агенты, веб2 и веб3 сервисы и т. д.) делает работу за вас в открытом, безопасном и децентрализованном режиме, работая на блокчейне NEAR.

Ранее вы видели демонстрацию, это просто интерфейс, демонстрирующий мощь Намерений NEAR. Но потенциальные случаи использования огромны. Например, с помощью Bitte Wallet, вы можете поручить ИИ обрабатывать обмены, стейкинг или даже находить лучших валидаторов для вас.
Как работают Намерения NEAR?
Вот упрощенный обзор того, как работают Намерения NEAR:



 	Пользователь определяет намерение: Вы хотите обменять 10 ETH на USDC и спрашиваете: "Сколько USDC я могу получить за 10 ETH?"
 	Запросы Solver Bus: Solver Bus отправляет ваш запрос нескольким решателям, чтобы найти лучшее предложение USDC за 10 ETH.
 	Ответы решателей: Решатели рассчитывают свои предложения (например, Решатель 1: 40 100 USDC; Решатель 2: 40 000 USDC), используя ликвидность из любого источника.
 	Выбор лучшего предложения: Solver Bus выбирает лучшее предложение (40 100 USDC) и информирует вас.
 	Подтверждение пользователя: Вы подтверждаете обмен, подписывая сообщение в своем кошельке - нет необходимости в дорогих транзакциях, экономьте много денег на дорогих цепях, таких как Ethereum или Bitcoin.
 	Выполнение обмена: Solver Bus отправляет ваши подписанные данные контракту верификатора, который выполняет обмен на цепи.

Это обеспечивает пользователям лучшие курсы безопасно и эффективно, причем цена, по которой вам было предложено, точно такая, какую вы получите.

Помимо криптовалютных активов, предстоящие обновления позволят обменивать веб2-сервисы, такие как подписки на Netflix, билеты, онлайн-платежи или фиатные входы/выходы. Пока есть решатель, готовый выполнить ваше намерение, возможности бесконечны!
Решателем может быть биржа, ИИ-агент, готовый обработать ваш заказ!




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Я настоятельно рекомендую посмотреть выступление Алекса Шевченко о слое Намерений на [REDACTED] 2024, чтобы узнать больше.

https://www.youtube.com/watch?v=PD7SbJrHjGo

Намерения NEAR: ключевые преимущества
Намерения NEAR, являющиеся основной частью стека абстракции цепи NEAR, предлагают множество преимуществ:
 	Принесите функциональность смарт-контрактов для поддержки всех цепочек: включая цепочки без смарт-контрактов, такие как Bitcoin, XRP, Doge... , пользователи этих цепочек наконец могут использовать DeFi с DEXs, кредитованием...!
 	Мгновенная поддержка новых цепочек без ручной интеграции: NEAR-Intents уже могут работать со всеми цепочками EVM, вместо того чтобы ждать, пока команда выполнит ручную интеграцию для каждой новой цепочки EVM, потому что у них есть точно такая же инфраструктура.
 	Исполнение на основе ИИ: Сеть решателей, включая агентов ИИ, анализируют ваше намерение и выполняют его наиболее эффективным способом. Это означает, что вы получаете выгоду от лучших источников ликвидности, будь то on-chain, off-chain, с централизованными биржами (CEXs) или децентрализованными (DEXs), все оптимизировано для скорости и стоимости.
 	Объединенная ликвидность: NEAR Intents объединяют участников ИИ с финансовыми услугами, коммерцией и конечными пользователями, объединяя ликвидность на различных платформах.
 	Новые возможности и сценарии использования: Сочетая любой тип намерения с агентами ИИ, вы можете исследовать новые примитивы и переосмыслить торговлю, аукционы, токены и многое другое.
 	Безопасная обработка активов: Передача, стейкинг и управление широким спектром активов, включая NFT, FT, SBT и непередаваемые активы, с учетом безопасности и соответствия.
 	Открытое и беспозволительное: Децентрализованная, межцепочная инфраструктура позволяет легко создавать или запускать новые финансовые продукты.
 	Надежный и быстрый опыт: Межцепочное урегулирование между агентами и пользователями происходит за секунды, обеспечивая плавный опыт.
 	Объединенная ликвидность: Заполнение пробела между DEXs через цепочки, CEXs и даже за пределами криптовалюты обеспечивает участие и инновации от различных заинтересованных сторон

"Намерения - универсальный интерфейс для глобальной коммерции, позволяющий переходить от DeFi к TradFi и не только. Представьте их как криптографически урегулированные многосторонние юридические контракты." – Илля Полосухин, Сооснователь NEAR

 
Интеграция с NEAR-намерениями
NEAR Intents упрощает разработку блокчейна, обеспечивая безшовную межцепочную функциональность и решения на основе ИИ. Независимо от того, создаете ли вы DeFi-приложения, межцепочные кошельки или инновационные сервисы, NEAR Intents предоставляет инструменты для осуществления этого!

Ресурсы для разработчиков:

 	Домашняя страница NEAR-Intents: https://near.org/intents
 	Документация, API и SDK: https://docs.near-intents.org/
 	Группа разработчиков NEAR: https://t.me/neardev
 	Группа NEAR Intents: https://t.me/near_intents
 	Документация NEAR: https://docs.near.org/
 	[СКРЫТО] 2024 | Алекс Шевченко - Слой намерений
 	[СКРЫТО] 2024 | Omnibridge: Как это работает на самом деле

Погрузитесь и начните строить уже сегодня!
В заключениеNEAR Intents меняет правила игры, делая взаимодействие с блокчейном более плавным, быстрым и умным. Не нужно больше прыгать сквозь кольца, чтобы обменивать токены или управлять активами - все это на расстоянии пары кликов, без необходимости платить газовые сборы или настраивать сложные системы.

С помощью AI-приводимых решателей, объединенной ликвидности и поддержки межцепочечных транзакций даже для цепочек без смарт-контрактов, таких как Bitcoin и Doge, NEAR Intents открывает бесконечные возможности. От обмена токенов в считанные секунды до использования DeFi для любой цепочки, это быстро, безопасно, децентрализованно и невероятно просто в использовании.

Представьте себе опыт, похожий на Coinbase, но децентрализованный, экономичный и без разрешений. Пришло время испытать блокчейн таким, каким он должен быть - без усилий и волшебным образом.

Для разработчиков NEAR Intents упрощает создание децентрализованных приложений, обрабатывая сложности межцепочечных транзакций, позволяя вам сосредоточиться на самом важном - ваших приложениях. Вы можете интегрировать NEAR Intents в свои проекты, чтобы открывать новые возможности и предлагать безупречные, безопасные впечатления для пользователей.

### NEAR Intents: A Guide for Users and Developers

a DEX using NEAR-Intents - simply swap BTC to Dogecoin in a few clicks! Powered by NEAR!
Why You Need NEAR Intents
First, let’s start with a simple question: why should you care about NEAR Intents?

Have you ever tried swapping BTC to Doge, or Ethereum to NEAR using a DEX?

The typical steps look like this for ETH to NEAR:

 	Prepare $ETH in your wallet.
 	Bridge ETH to NEAR (don’t forget to save some ETH for the bridge fee).
 	Ensure you have NEAR as a gas token.
 	Swap ETH to NEAR.

Seems complex, right? It still works, but takes a lot of times and efforts.
So what if you want to exchange Bitcoin <> Dogecoin, Doge <> XRP, or Ethereum <> Dogecoin? These chains have no DEX and the only option? Centralized exchanges like Binance or Coinbase.

NEAR Intents solves all of this!




	

	
	
		
			
				What is the primary purpose of NEAR Intents?
			
		

		
					

		
			
			
			
			To create NFTs
		
			
			To simplify cross-chain transactions and intent execution
		
			
			To mine cryptocurrencies
		
			
			To develop centralized exchanges
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






With NEAR Intents, you can:

 	Deposit tokens from any wallet.
 	Swap to any token on any chain.
 	Simply sign to swap—no need for a gas token (saving time and money).
 	Withdraw to any wallet on the native chain with just a signature.

For example, you can swap $BTC on the Bitcoin network to $NEAR in under 30 seconds!

https://youtu.be/JoyJgRi0G7s

NEAR Intents works like a CEX but is decentralized like a DEX—easy to use, cheaper, faster, and permissionless, all powered by the NEAR blockchain!

Slick, right? Think of it as a Coinbase-like experience but decentralized and ultra-smooth!

There are interesting applications leveraging NEAR-Intents you can try right now:

 	NEAR Intents DEX
 	Solswap for Solana users
 	Dogecoin Swap: the first DEX for Dogecoin
 	Turbo Swap

🤖📈 INTEAR - A Telegram trading bot powered by NEAR Intents:
https://x.com/intelnear/status/1869461097646104620

🧠 Bitte Wallet - AI Wallets
https://x.com/BitteProtocol/status/1868682419785605630

Happy using! Now you’re curious about how all this works. Let’s dig deeper! 🤓
https://x.com/i/status/1855475653283594591

One token, any chain.
All liquidity, one chain.

NEAR Intents is launching as part of the NEAR Tech Stack.

True crosschain DeFi is here, and it’s powered by NEAR 🧵 pic.twitter.com/qB5HqiS9QG

— NEAR Protocol (@NEARProtocol) November 10, 2024
"NEAR Intents are a new type of transaction that allows information, requests, assets, and actions to be exchanged between AI agents, services, and end users."

In simpler terms, NEAR Intents let you describe what you want to achieve without worrying about how to do it. Instead, a decentralized network of solvers (AI agents, web2 and web3 services, etc.) does the work for you in an open, secure, and decentralized manner, powered by the NEAR blockchain.

The earlier demo you saw, It’s just an interface showcasing the power of NEAR Intents. But the potential use cases are vast. For example, with Bitte Wallet, you can instruct AI to handle swaps, staking, or even finding the best validators for you.
How Does NEAR Intents Work?
Here’s a simplified overview of how NEAR Intents work:



 	User Defines an Intent: You want to swap 10 ETH for USDC and ask, “How much USDC can I get for 10 ETH?”
 	Solver Bus Queries: The Solver Bus sends your request to multiple solvers to find the best USDC offer for 10 ETH.
 	Solver Responses: Solvers calculate their offers (e.g., Solver 1: 40,100 USDC; Solver 2: 40,000 USDC) by sourcing liquidity from anywhere.
 	Best Offer Selected: The Solver Bus picks the best quote (40,100 USDC) and informs you.
 	User Approval: You approve the swap by signing a message on your wallet—no need for a costly transaction, save a lot of money on expensive chains like Ethereum or Bitcoin.
 	Swap Execution: The Solver Bus sends your signed data to a verifier contract, which executes the swap on-chain.
This means the Solver is going to fulfill your request (i.e., the solver sends the token to your address).

This ensures users get the best rates securely and efficiently, with the price you got quoted is the exact the price you get.

Beyond crypto assets, upcoming updates will enable exchanging web2 services like Netflix subscriptions, tickets, online payments, or fiat on/off-ramps. As long as there’s a solver ready to fulfill your intent, the possibilities are endless!
A Solver could be an exchange, an AI agent that willing to process your order!




	

	
	
		
			
				In NEAR Intents, what is the role of a "solver"?
			
		

		
					

		
			
			
			
			It generates NFTs for users
		
			
			A dangerous AI system that could destroy humanity
		
			
			It fulfills the user’s intent, such as finding the best token swap rate
		
			
			It manages staking for users automatically
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






I highly recommend watching Alex Shevchenko’s talk on Intents Layer at [REDACTED] 2024 to learn more.

https://www.youtube.com/watch?v=PD7SbJrHjGo

 
NEAR Intents: Key Advantages
NEAR Intents, a core part of NEAR’s Chain Abstraction stack, offers numerous benefits:

 	Bring smart contract functionality to supports all chains: including non-smart contract chains like Bitcoin, XRP, Doge... , users of these chains can finally using DeFi with DEXs, Lendings...!
 	Instant support for new chains without manual integration: NEAR-Intents can already work with all EVM chains instead of have to wait for team to manual integration for each new EVM chains because they have the exactly same infrastructure.
 	AI-Driven Execution: A network of solvers, including AI agents, analyze your intent and execute it in the most efficient way possible. This means you benefit from the best liquidity sources, whether on-chain, off-chain, from centralized exchanges (CEXs), or decentralized ones (DEXs), all optimized for speed and cost.
 	Unified Liquidity: NEAR Intents bring AI participants together with financial services, commerce, and end users, unifying liquidity across different platforms.
 	New Possibilities and Use Cases: By combining any intent type with AI agents, you can explore new primitives and reimagine trading, auctions, tokens, and more.
 	Secure Handling of Assets: Transfer, stake, and manage a wide range of assets, including NFTs, FTs, SBTs, and non-transferable assets, with security and compliance in mind.
 	Open and Permissionless: The decentralized, cross-chain infrastructure allows you to build or launch new financial products easily.
 	Reliable and Fast Experience: Cross-chain settlement between agents and users happens in seconds, ensuring a smooth experience.
 	Combined Liquidity: Bridging the gap between DEXs across chains, CEXs, and even outside crypto ensures participation and innovation from various stakeholders

"Intents are a universal interface for global commerce, enabling DeFi, TradFi transitions, and more. Think of them as cryptographically settled multi-party legal contracts." – Illia Polosukhin, NEAR Co-Founder
Technical Architecture Behind NEAR Intents
While NEAR Intents provides a seamless experience for users, understanding the technical architecture helps developers appreciate the robustness of the system. NEAR Intents builds upon two key components of the NEAR Protocol:
Chain Signatures: This foundational technology enables the cross-chain functionality that makes NEAR Intents possible. Chain Signatures allow users to sign transactions that can be verified and executed across different blockchains, which is why you can swap BTC directly to NEAR or Dogecoin without intermediary steps.
Sharding for Scalability: NEAR's sharded architecture ensures that the intent settlement process can handle high transaction volumes without congestion. This is particularly important for DEX-like applications where trading popular assets could otherwise create bottlenecks.
The intent protocol follows a structured process:


 	Advertising Phase: When you initiate a swap in applications like NEAR Intents DEX or Dogecoin Swap, your intent is advertised to solvers through one of several methods:

 	Broadcasting to all solvers (for best price discovery)
 	Through a centralized order book
 	Via direct communication channels
 	Posted directly on-chain


 	Collection and Commitment: The application collects quotes from solvers and presents you with the best option. When you sign this option, you're creating a cryptographically secure commitment that functions as a binding agreement.
 	Settlement and Finalization: After commitment, the transaction settles on the NEAR blockchain, allowing for highly scalable execution of trades across different assets and chains.

This architecture effectively addresses traditional blockchain challenges like MEV (Maximal Extractable Value) and trading latency by keeping the advertising and quote collection phases off-chain while ensuring secure settlement on-chain.
For developers looking to build on NEAR Intents, understanding this architecture helps in designing applications that fully leverage the protocol's capabilities while maintaining the simple user experience showcased in the examples above.

Integration with NEAR-intents
NEAR Intents simplifies blockchain development, enabling seamless cross-chain functionality and AI-powered solutions. Whether you’re building DeFi apps, cross-chain wallets, or innovative services, NEAR Intents provides the tools to make it happen!

Resources for Developers:

 	NEAR-Intents homepage: https://near.org/intents
 	Docs, APIs and the SDK: https://docs.near-intents.org/
 	NEAR dev group: https://t.me/neardev
 	NEAR Intents group: https://t.me/near_intents
 	NEAR docs: https://docs.near.org/
 	[REDACTED] 2024 | Alex Shevchenko - Intents layer
 	[REDACTED] 2024 | Omnibridge: How it Actually Works

Dive in and start building today!
Intents Analytics
Please check the NEAR Intents Dashboard at Dune

### Использование вашего кошелька Ethereum на NEAR: Простое руководство

Большие новости: используйте свой кошелек Ethereum на NEAR! 🎉
Отличные новости для пользователей криптовалют! Если у вас есть MetaMask или любой другой кошелек Ethereum, теперь вы можете использовать его для доступа к приложениям на блокчейне NEAR. Нет необходимости создавать новый кошелек или запоминать еще один пароль - просто подключитесь с помощью кошелька, который вам уже знаком и который вы любите.

Что это значит для вас?

 	Используйте MetaMask: У вас уже есть MetaMask? Прекрасно! Теперь вы можете использовать его для входа в приложения NEAR
 	Поддерживается 400+ кошельков: Используете другой кошелек Ethereum? Вероятно, он тоже будет работать!
 	Простой вход: Нет необходимости создавать новые учетные записи или запоминать новые пароли
 	Без проблем: Все работает так, как вы привыкли с вашим кошельком Ethereum

Как это работает?
Допустим, вы хотите использовать приложение NEAR с вашим кошельком MetaMask. Вот что происходит за кулисами (простыми словами!):


 	Первый вход: Когда вы подключаете свой кошелек MetaMask к приложению NEAR в первый раз, NEAR автоматически создает для вас учетную запись

 	Ваш адрес остается тем же: Адрес вашего кошелька Ethereum становится именем вашей учетной записи NEAR
 	Все как обычно: Когда вам нужно что-то сделать в приложении, MetaMask появится как обычно, чтобы запросить ваше одобрение




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Что делает это крутым?
Это похоже на получение универсального адаптера для вашего криптокошелька. Представьте, что ваша американская кредитная карта вдруг начинает идеально работать в Европе, не нуждаясь в получении новой - вот в чем суть происходящего здесь!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Готовы попробовать?
Просто перейдите на свое любимое приложение NEAR и найдите опцию подключения с помощью MetaMask или WalletConnect. Ваш кошелек Ethereum сделает всю тяжелую работу за вас!
Для тех, кто технически любопытен
Эта интеграция стала возможной благодаря команде NEAR, работающей с лабораторией Aurora более года. Они создали умную систему, которая переводит все, что говорит ваш кошелек Ethereum, в то, что может понять NEAR - как универсальный переводчик для блокчейнов.

### 在NEAR上使用您的以太坊钱包：简易指南

重大消息：在NEAR上使用您的以太坊钱包！🎉
加密货币用户的好消息！如果您有MetaMask或任何其他以太坊钱包，现在可以使用它来访问NEAR区块链上的应用程序。无需创建新钱包或记住另一个密码 - 只需连接您已经了解和喜爱的钱包。

这对您意味着什么？

 	使用MetaMask：已经有MetaMask？太好了！现在您可以使用它登录NEAR应用
 	支持400多种钱包：使用其他以太坊钱包？很可能也可以使用！
 	简单登录：无需创建新帐户或记住新密码
 	无缝体验：一切都像您习惯的以太坊钱包一样运作

它是如何工作的？
假设您想要使用MetaMask钱包访问NEAR应用。这是幕后发生的事情（用简单的英语解释！）：


 	首次登录：当您首次将MetaMask钱包连接到NEAR应用时，NEAR会自动为您创建一个帐户

 	您的地址保持不变：您的以太坊钱包地址将成为您的NEAR帐户名
 	一切照旧：当您需要在应用中执行操作时，MetaMask会像往常一样弹出要求您的批准




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





这有什么酷之处？
这就像为您的加密货币钱包获得一个通用适配器。想象一下，如果您的美国信用卡突然在欧洲完美运作，而无需换新卡 - 这基本上就是这里发生的事情！



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





准备好尝试了吗？
只需前往您喜爱的NEAR应用程序，并查找连接到MetaMask或WalletConnect的选项。您的以太坊钱包将为您处理所有繁重的工作！
对技术上感兴趣的人
这种整合是由NEAR团队与Aurora实验室合作一年多而实现的。他们构建了一个智能系统，将您的以太坊钱包所说的一切内容转化为NEAR可以理解的内容 - 就像区块链的通用翻译器一样。

### NEAR에서 이더리움 지갑 사용하기: 간단한 안내

대소식: NEAR에서 이더리움 지갑 사용 가능! 🎉
암호화폐 사용자를 위한 좋은 소식! 만약 MetaMask나 다른 이더리움 지갑을 가지고 있다면, 이제 NEAR 블록체인 앱에 액세스할 수 있습니다. 새로운 지갑을 만들거나 다른 비밀번호를 기억할 필요가 없습니다 - 이미 알고 사랑하는 지갑과 연결하면 됩니다.

이것이 당신에게 무엇을 의미하나요?

 	MetaMask 사용: 이미 MetaMask를 가지고 계신가요? 완벽합니다! 이제 그것을 사용하여 NEAR 앱에 로그인할 수 있습니다
 	400개 이상의 지갑 지원: 다른 이더리움 지갑을 사용 중이신가요? 작동 가능성이 높습니다!
 	간편한 로그인: 새로운 계정을 만들거나 새로운 비밀번호를 기억할 필요가 없습니다
 	원활한 경험: 모든 것이 이더리움 지갑과 같이 익숙하게 작동합니다

어떻게 작동하나요?
MetaMask 지갑으로 NEAR 앱을 사용하고 싶다고 가정해봅시다. 여기서 (간단한 영어로!) 뒷면에서 무슨 일이 벌어지는지 알아봅시다:


 	첫 번째 로그인: MetaMask 지갑을 NEAR 앱에 처음 연결할 때, NEAR가 자동으로 계정을 생성합니다

 	주소는 그대로 유지: 이더리움 지갑 주소가 NEAR 계정 이름이 됩니다
 	평소처럼: 앱에서 무언가를 해야 할 때, MetaMask가 일반적으로 나타나서 승인을 요청할 것입니다




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





이게 왜 멋진가요?
이것은 암호화폐 지갑을 위한 유니버설 어댑터를 얻는 것과 같습니다. 새로운 것을 얻지 않고도 미국 신용카드가 유럽에서 완벽하게 작동한다면 어떨까 상상해보세요 - 이게 바로 여기서 일어나고 있는 것입니다!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





이제 시도해보실 준비가 되셨나요?
즐겨 사용하는 NEAR 애플리케이션으로 이동하여 MetaMask 또는 WalletConnect와 연결할 수 있는 옵션을 찾아보세요. 이더리움 지갑이 모든 번거로운 작업을 대신해줄 것입니다!
기술적으로 호기심 많은 분들을 위해
이 통합은 NEAR 팀이 Aurora Labs와 1년 넘게 협력하여 가능해졌습니다. 그들은 이더리움 지갑이 말하는 모든 것을 NEAR가 이해할 수 있는 것으로 번역하는 스마트 시스템을 구축했습니다 - 마치 블록체인을 위한 유니버설 번역기처럼요.

### Menggunakan Dompet Ethereum Anda di NEAR: Panduan Sederhana

Berita Besar: Gunakan Dompet Ethereum Anda di NEAR! 🎉
Berita bagus bagi pengguna kripto! Jika Anda memiliki MetaMask atau dompet Ethereum lainnya, Anda sekarang dapat menggunakannya untuk mengakses aplikasi di blockchain NEAR. Tidak perlu membuat dompet baru atau mengingat kata sandi lain - cukup hubungkan dengan dompet yang sudah Anda kenal dan cintai.

Apa Artinya Ini Bagi Anda?

 	Gunakan MetaMask: Sudah memiliki MetaMask? Sempurna! Anda sekarang dapat menggunakannya untuk masuk ke aplikasi NEAR
 	400+ Dompet Didukung: Menggunakan dompet Ethereum lain? Kemungkinan besar juga berfungsi!
 	Login Sederhana: Tidak perlu membuat akun baru atau mengingat kata sandi baru
 	Pengalaman Tanpa Sambungan: Semuanya berfungsi seperti biasa dengan dompet Ethereum Anda

Bagaimana Cara Kerjanya?
Misalkan Anda ingin menggunakan aplikasi NEAR dengan dompet MetaMask Anda. Inilah yang terjadi di balik layar (dalam bahasa yang mudah dimengerti!):


 	Login Pertama: Saat Anda menghubungkan dompet MetaMask Anda ke aplikasi NEAR untuk pertama kalinya, NEAR secara otomatis membuat akun untuk Anda

 	Alamat Anda Tetap Sama: Alamat dompet Ethereum Anda menjadi nama akun NEAR Anda
 	Bisnis Seperti Biasa: Saat Anda perlu melakukan sesuatu di aplikasi, MetaMask akan muncul seperti biasa untuk meminta persetujuan Anda




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apa yang Membuat Ini Menarik?
Ini seperti mendapatkan adaptor universal untuk dompet kripto Anda. Bayangkan jika kartu kredit Amerika Anda tiba-tiba berfungsi dengan sempurna di Eropa tanpa perlu mendapatkan yang baru - itu pada dasarnya apa yang terjadi di sini!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Siap Mencobanya?
Cukup menuju aplikasi NEAR favorit Anda dan cari opsi untuk terhubung dengan MetaMask atau WalletConnect. Dompet Ethereum Anda akan melakukan semua pekerjaan berat untuk Anda!
Bagi Mereka yang Tekninya Penasaran
Integrasi ini dimungkinkan oleh tim NEAR yang bekerja dengan Aurora Labs selama lebih dari satu tahun. Mereka membangun sistem pintar yang menerjemahkan semua yang dikatakan dompet Ethereum Anda menjadi sesuatu yang bisa dipahami oleh NEAR - seperti penerjemah universal untuk blockchain.

### Usando sua carteira Ethereum na NEAR: Um guia simples

Grande Novidade: Use sua Carteira Ethereum na NEAR! 🎉
Ótimas notícias para usuários de criptomoedas! Se você tem o MetaMask ou qualquer outra carteira Ethereum, agora pode usá-la para acessar aplicativos na blockchain NEAR. Não é necessário criar uma nova carteira ou lembrar de outra senha - basta conectar com a carteira que você já conhece e ama.

O Que Isso Significa Para Você?

 	Use o MetaMask: Já tem o MetaMask? Perfeito! Agora você pode usá-lo para fazer login em aplicativos NEAR
 	400+ Carteiras Suportadas: Usando outra carteira Ethereum? Provavelmente também funciona!
 	Login Simples: Não é necessário criar novas contas ou lembrar de novas senhas
 	Experiência Sem Emendas: Tudo funciona como você está acostumado com sua carteira Ethereum

Como Funciona?
Digamos que você queira usar um aplicativo NEAR com sua carteira MetaMask. Aqui está o que acontece nos bastidores (em linguagem simples!):


 	Primeiro Login: Quando você conecta sua carteira MetaMask a um aplicativo NEAR pela primeira vez, a NEAR cria automaticamente uma conta para você

 	Seu Endereço Permanece o Mesmo: Seu endereço da carteira Ethereum se torna o nome da sua conta NEAR
 	Tudo Como de Costume: Quando você precisa fazer algo no aplicativo, o MetaMask irá aparecer normalmente para solicitar sua aprovação




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O Que Torna Isso Legal?
Isso é como obter um adaptador universal para sua carteira de criptomoedas. Imagine se seu cartão de crédito americano de repente funcionasse perfeitamente na Europa sem precisar obter um novo - é basicamente o que está acontecendo aqui!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pronto para Experimentar?
Basta ir para o seu aplicativo NEAR favorito e procurar a opção de conectar com o MetaMask ou WalletConnect. Sua carteira Ethereum fará todo o trabalho pesado para você!
Para os Curiosos Técnicos
Essa integração foi possível graças à equipe da NEAR trabalhando com Aurora Labs por mais de um ano. Eles construíram um sistema inteligente que traduz tudo o que sua carteira Ethereum diz em algo que a NEAR pode entender - como um tradutor universal para blockchains.

### Usando tu billetera de Ethereum en NEAR: Una guía simple

¡Grandes noticias: Usa tu billetera de Ethereum en NEAR! 🎉
¡Excelentes noticias para los usuarios de criptomonedas! Si tienes MetaMask u otra billetera de Ethereum, ahora puedes usarla para acceder a aplicaciones en la cadena de bloques de NEAR. No es necesario crear una nueva billetera o recordar otra contraseña, simplemente conéctate con la billetera que ya conoces y amas.

¿Qué significa esto para ti?

 	Usa MetaMask: ¿Ya tienes MetaMask? ¡Perfecto! Ahora puedes usarlo para iniciar sesión en aplicaciones de NEAR
 	Compatible con más de 400 billeteras: ¿Usas otra billetera de Ethereum? ¡Probablemente también funcione!
 	Ingreso sencillo: No es necesario crear nuevas cuentas o recordar nuevas contraseñas
 	Experiencia fluida: Todo funciona como estás acostumbrado con tu billetera de Ethereum

¿Cómo funciona?
Digamos que quieres usar una aplicación de NEAR con tu billetera MetaMask. Aquí tienes lo que sucede detrás de escena (¡en un lenguaje sencillo!):


 	Primer inicio de sesión: Cuando conectas tu billetera MetaMask a una aplicación de NEAR por primera vez, NEAR crea automáticamente una cuenta para ti

 	Tu dirección permanece igual: La dirección de tu billetera de Ethereum se convierte en tu nombre de cuenta de NEAR
 	Todo sigue igual: Cuando necesites hacer algo en la aplicación, MetaMask aparecerá como de costumbre para pedir tu aprobación




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Qué hace esto genial?
Esto es como obtener un adaptador universal para tu billetera de criptomonedas. ¡Imagina si tu tarjeta de crédito americana de repente funcionara perfectamente en Europa sin necesidad de obtener una nueva, eso es básicamente lo que está sucediendo aquí!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Listo para probarlo?
Simplemente ve a tu aplicación de NEAR favorita y busca la opción para conectarte con MetaMask o WalletConnect. ¡Tu billetera de Ethereum hará todo el trabajo pesado por ti!
Para los Curiosos Técnicos
Esta integración fue posible gracias al equipo de NEAR que trabajó con Aurora Labs durante más de un año. Construyeron un sistema inteligente que traduce todo lo que dice tu billetera de Ethereum en algo que NEAR puede entender, algo así como un traductor universal para blockchains.

### Sử dụng Ví Ethereum của bạn trên NEAR: Hướng dẫn đơn giản

Thông Tin Lớn: Sử Dụng Ví Ethereum của Bạn trên NEAR! 🎉
Thông tin tuyệt vời cho người dùng tiền điện tử! Nếu bạn có MetaMask hoặc bất kỳ ví Ethereum nào khác, bạn có thể sử dụng nó để truy cập ứng dụng trên blockchain NEAR. Không cần tạo ví mới hoặc nhớ mật khẩu khác - chỉ cần kết nối với ví mà bạn đã biết và yêu thích.

Điều Này Có Ý Nghĩa Gì Đối Với Bạn?

 	Sử Dụng MetaMask: Đã có MetaMask? Hoàn hảo! Bây giờ bạn có thể sử dụng nó để đăng nhập vào các ứng dụng NEAR
 	Hỗ Trợ 400+ Ví: Sử dụng một ví Ethereum khác? Có khả năng nó cũng hoạt động!
 	Đăng Nhập Đơn Giản: Không cần tạo tài khoản mới hoặc nhớ mật khẩu mới
 	Trải Nghiệm Mượt Mà: Mọi thứ hoạt động giống như bạn đã quen với ví Ethereum của mình

Làm Thế Nào Nó Hoạt Động?
Hãy nói bạn muốn sử dụng một ứng dụng NEAR với ví MetaMask của bạn. Đây là điều gì xảy ra sau cánh cửa (bằng tiếng Anh đơn giản!):


 	Đăng Nhập Đầu Tiên: Khi bạn kết nối ví MetaMask của mình với một ứng dụng NEAR lần đầu tiên, NEAR tự động tạo một tài khoản cho bạn

 	Địa Chỉ Của Bạn Vẫn Giữ Nguyên: Địa chỉ ví Ethereum của bạn trở thành tên tài khoản NEAR của bạn
 	Hoạt Động Bình Thường: Khi bạn cần làm điều gì đó trong ứng dụng, MetaMask sẽ hiện lên giống như bình thường để yêu cầu sự chấp thuận của bạn




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Điều Gì Làm Nó Thú Vị?
Điều này giống như việc có một bộ chuyển đổi đa năng cho ví tiền điện tử của bạn. Hãy tưởng tượng nếu thẻ tín dụng Mỹ của bạn đột nhiên hoạt động hoàn hảo ở châu Âu mà không cần phải có một thẻ mới - đó chính là điều đang xảy ra ở đây!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sẵn Sàng Thử Nghiệm Không?
Chỉ cần đến ứng dụng NEAR yêu thích của bạn và tìm tùy chọn kết nối với MetaMask hoặc WalletConnect. Ví Ethereum của bạn sẽ làm tất cả công việc nặng cho bạn!
Dành cho những người tò mò về mặt kỹ thuật
Sự tích hợp này đã trở nên khả thi nhờ vào đội ngũ NEAR làm việc cùng với Aurora Labs trong hơn một năm. Họ đã xây dựng một hệ thống thông minh chuyển đổi mọi thông tin mà ví Ethereum của bạn nói thành điều mà NEAR có thể hiểu - giống như một bộ phiên dịch đa năng cho các chuỗi khối.

### Using Your Ethereum Wallet on NEAR: A Simple Guide

Big News: Use Your Ethereum Wallet on NEAR! 🎉
Great news for crypto users! If you have MetaMask or any other Ethereum wallet, you can now use it to access apps on the NEAR blockchain. No need to create a new wallet or remember another password – just connect with the wallet you already know and love.

What Does This Mean For You?

 	Use MetaMask: Already have MetaMask? Perfect! You can now use it to log into NEAR apps
 	400+ Wallets Supported: Using another Ethereum wallet? Chances are it works too!
 	Simple Login: No need to create new accounts or remember new passwords
 	Seamless Experience: Everything works just like you're used to with your Ethereum wallet

How Does It Work?
Let's say you want to use a NEAR app with your MetaMask wallet. Here's what happens behind the scenes (in plain English!):


 	First Login: When you connect your MetaMask wallet to a NEAR app for the first time, NEAR automatically creates an account for you

 	Your Address Stays the Same: Your Ethereum wallet address becomes your NEAR account name
 	Business as Usual: When you need to do something in the app, MetaMask will pop up just like normal to ask for your approval




	

	
	
		
			
				What happens when you first connect your Ethereum wallet to a NEAR app?
			
		

		
					

		
			
			
			
			You need to manually create a new NEAR account
		
			
			Your Ethereum wallet stops working
		
			
			NEAR automatically creates an account for you 
		
			
			You need to buy new tokens first
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What Makes This Cool?
This is like getting a universal adapter for your crypto wallet. Imagine if your American credit card suddenly worked perfectly in Europe without needing to get a new one – that's basically what's happening here!



	

	
	
		
			
				Which of the following is true about using Ethereum wallets on NEAR?
			
		

		
					

		
			
			
			
			You need to create new passwords
		
			
			You can only use MetaMask
		
			
			You need to convert all your tokens first
		
			
			Your Ethereum wallet address becomes your NEAR account name
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ready to Try It Out?
Just head to your favorite NEAR application and look for the option to connect with MetaMask or WalletConnect. Your Ethereum wallet will do all the heavy lifting for you!

For the Technically Curious
This integration was made possible by the NEAR team working with Aurora Labs for over a year. They built a smart system that translates everything your Ethereum wallet says into something NEAR can understand – kind of like a universal translator for blockchains.

### Update – November 1, 2024

Brief Summary:

 	
🤝We are quarter million (l)earners🕺


Results:

 	
No NEAR? No problem! Pass NEAR 101 express-course and mint you LNCer NFT for FREE!🕺

 	🔬3d NanoQuiz🕺 for exclusively 🔥Hot wallet users is LIVE
https://t.me/herewalletbot/app?startapp=web-tg-learnnear-club


 	📚(L)Earn What Is GPT And How Does It Work and Why Users Matter🕺
 	📚 (L)Earn ''How to run a NEAR validator node''🕺
 	📚(L)Earn What Are Chain Signatures On NEAR?🕺
 	📚(L)Earn about ''Introduction to NEAR CLI''🕺

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	NEAR AI is coming soon with better model and more use cases!

### What Is GPT And How Does It Work and Why Users Matter

💡AI Glossary for beginners
Artificial Intelligence (AI) has attracted considerable interest over the past few years, generating excitement and innovation across industries. It has become more than just a buzzword found on LinkedIn profiles, and has the potential to change humanity’s future. However, it has also sparked debates and garnered intense criticism. One of the key advancements of AI is Generative Pre-Trained Transformers (GPT), designed to automate tasks and simulate an output similar to that created by humans.

Before continue reading, please WATCH this video
"Do not become replaceable"
from NEAR AI office hours with special guest Paolo Ardoino, CEO of Tether

"Do not become replaceable"
Must watch by @paoloardoino at NEAR AI office hour with @ilblackdragon and @AlexSkidanov pic.twitter.com/Pmy0M9YzSu
— Learn NEAR Club | (L)Earn (@LearnNear) November 27, 2024

This article will examine GPT, its workings, and its use cases in more detail. It will also discuss NEAR.AI’s efforts to create an open-source AI that everyone can use and why a user-owned AI is the need of the hour.
What Is GPT?
Generative Pre-Trained Transformers, commonly referred to as GPT, are a family of advanced neural network models designed for Natural Language Processing (NLP) tasks. These large language models (LLMs) use transformer architecture and are considered a significant advancement in AI. They power an array of AI applications, the most well-known being ChatGPT.

GPT models allow applications like ChatGPT to create human-like output (text, images, music, and more), allowing them to answer queries conversationally. Several organizations have begun using GPT models for content creation, summarization, Q&A bots, and simple research. GPT models are a significant breakthrough in AI research. They can be used to automate and improve an array of tasks such as document summarization, research, language translation, writing blog posts, building websites, writing code, making animations, and more.

GPT models are known for the speed and scale at which they function. An average person may need hours or even days to research and write an article or create a specific code for a website. GPT models can complete such tasks in seconds, leading companies to begin research in AI to achieve artificial general intelligence. This would allow AI to help companies achieve unprecedented productivity and substantially improve their experiences.
How Does GPT Work?
Now, let’s understand how GPT works. As we’ve mentioned earlier, GPT models are neural network-based language prediction models built on the transformer architecture. They function by analyzing natural language queries and predicting the best response or outcome based on their understanding. However, to do so, these neural-based language models need unprecedented amounts of data.

GPT models are trained using hundreds of billions of parameters on massive language datasets. Once trained on these datasets, they can analyze input sequences and predict the most likely output by using probability to identify the next word to frame a complete sentence. They can also process natural language prompts and generate human-like text responses. When prompted, GPT models create responses based on their training data.

As mentioned earlier, these models rely on vast datasets to generate a relevant response. The vastness of these data sets, running into billions of parameters, allows GPT models to mimic human-like responses. GPT models such as ChatGPT use deep learning to gain context and generate an optimum response. Two key aspects are crucial for GPT models. These are

 	Generative pretraining - Generative training teaches the GPT model to detect patterns in data and apply these patterns to new inputs.
 	Transformer architecture - This allows the GPT model to process an input sequence in parallel.

However, the current infrastructure supporting AI development and deployment presents a substantial challenge: centralization. Centralization creates a slew of problems, including high barriers to entry and various other bottlenecks. A high entry barrier stifles innovation and gives a few entities control over the technology. This is where NEAR.AI comes into the picture.
Why Is A User-Owned AI Important?
As mentioned earlier, the infrastructure supporting AI development and deployment is highly centralized, enabling a few influential players to dominate the industry. The high costs associated with accessing high-performing resources often create insurmountable entry barriers for AI innovators, leading to the concentration of power in the hands of a few entities, which is precisely what we are witnessing. Additionally, centralization also hinders collaboration and innovation because data silos are isolated. That’s not all. In the hands of the wrong people, AI technology can do more harm than good and could be used to manipulate opinion, making it a tool for control.
Introducing NEAR.AI
NEAR.AI aims to create and deploy advanced AI that everyone can access and use. NEAR has cemented itself as one of the most dominant blockchains, handling millions of transactions per second. Now, it is turning its focus to the creation of an open-source and user-owned AI. AI is one of the most promising and disruptive technologies in recent memory. However, almost all AI-related development occurs within centralized, for-profit companies. This is the issue that NEAR.AI aims to address, and put AI’s power into ordinary users’ hands.

But how does it plan to do this?

NEAR.AI aims to achieve its goal by implementing a three-step plan.

 	Create an AI Developer - The AI Developer will first learn to code and then teach machines how to code.
 	AI Researcher - Use the AI Developer to teach machines to conduct research.
 	Create an advanced AI for everyone - The final step is to use the research to create a powerful AI that belongs to everyone.

A Closer Look At NEAR’s User-Owned AI
NEAR.AI promises to be open-source. Unlike centralized AI systems that are accessible only to a few entities, anyone can use and improve upon NEAR.AI’s advanced AI. It also promises users complete ownership of their AI. A user-owned AI can allow the user to access data without leaking it to third parties and optimize it for the user’s benefit. It will also allow users to customize their computing experience without compromising ownership, privacy, and security.

NEAR began working on an AI Developer in 2017 when it attempted to create an AI-driven autocomplete. However, while developing it, the team realized that current (2017) blockchain systems had several limitations. This is why NEAR underwent a significant transition, pivoting and building a decentralized developmental platform that could handle billions of users while being easy to use and program, becoming a fully sharded, proof-of-stake blockchain.

Now, NEAR has an entire ecosystem of infrastructure and application builders, having onboarded millions of users, of which 2 million are daily active users, setting the stage for the next stage of innovation, combining Web3 and AI. However, there are still major hurdles to overcome. These are

 	Fragmentation - Products are scattered across hundreds of chains. Additionally, the number of products available today is insufficient to offer a competitive landscape to existing systems
 	Few developers - Currently, there are fewer than 7,000 full-time Web3 developers
 	Escalating costs - Web3 code is costly to develop and supports multi-billion dollar projects on small codebases.

The AI Developer can address this by significantly increasing efficiency in creating Web3 applications by creating Web3 products using simple language inputs This would unlock more value and allow almost anyone to become a developer. Because NEAR.AI development is open source, the community will have access to software, datasets, and models to develop products. NEAR.AI will also collaborate with projects across the Web3 and AI ecosystems to use resources more efficiently through collaboration and incentive frameworks.

To achieve its vision, NEAR.AI will involve developers and engage with the NEAR community to write code, create new applications, and train the AI model. It will also leverage NEAR’s token-based economy. As NEAR.AI progresses, it will help attract more users to the NEAR ecosystem and create new economic activities and network effects. However, to succeed in its vision, NEAR.AI will need a range of infrastructure beyond peer-to-peer communication, on-edge data and inference, decentralized data storage, and private computation. It will also need developers to write code and train the AI model. To do this, NEAR.AI can engage with the NEAR ecosystem and leverage NEAR’s token-based economy.

NEAR.AI’s AI Researcher can use advancements in reasoning made possible through a chain of thought, search, and combination with formal methods to break through current AI models. It can also discover new insights and knowledge by recombining existing information.

The end goal for NEAR.AI is the creation of a user-owned AGI that can transform how users interact with computing and help enhance productivity by allowing users to focus on creativity, innovation, and unique economic activities. An AI that serves and is owned by individuals and communities instead of large institutions or governments.




	

	
	
		
			
				The NEAR.AI Master plan comprises of:The NEAR.AI Master plan comprises of:
			
		

		
					

		
			
			
			
			AI Developer
		
			
			AI Researcher
		
			
			A powerful advanced AI
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





AI and Learning
One of the most obvious use cases for AI is learning. NEAR.AI can facilitate a mutually beneficial ecosystem that allows learners to interact with AI. Such a circular learning economy would ensure that the AI gets more refined thanks to user feedback, while the user can access knowledge and earn rewards.
AI Helps Learners
But how would such an ecosystem work? Here, at Learn NEAR Club, NEAR AI already helps learners with their comments at learning Guides - for non-English native speakers this is a life-saver! Commenting plays a crucial role in cognitive process so LNC acetifies
Learner Pays AI
In a scenario where learners come across a new or complicated topic, they could pay to access specific AI-powered topics, explanations, or tutorials. The AI would act as a tutor, helping users understand complex subjects or topics through personalized learning experiences or explanations tailored to the learner’s understanding and requirements. Already in prod!

AI Pays For Feedback
This is the ecosystem coming full circle. The learner gives feedback on the AI’s accuracy, tutoring skills, and explanations, helping it improve over time. The AI then compensates the learner in the form of tokens and other incentives. This can be the future of education, where AI can assist learners in acquiring knowledge and incentivize them to provide feedback.


AI Must Engage Content Creators
Training AI models solely on AI-generated content will yield only limited results. For better results, AI models must be trained on human-generated content that allows them to advance exponentially.

However, this is where corporations have fallen short, focusing on maximizing profits and monopolizing technology over empowering the creators and creating an imbalance.
For AI and its users to benefit from one another, both must operate in a framework that facilitates mutual gain and a cooperative exchange of incentives and rewards.
In Closing: Why Users matter
Think of AI as a student who learns from every interaction. The more diverse perspectives and experiences it encounters, the smarter and more helpful it becomes. That's why AI systems need to play nice with everyone – both the creators who build amazing things and the everyday users who interact with them. Even your simplest reactions, like clicking that thumbs-up or thumbs-down button, are like little nuggets of gold for AI's learning process.
Here's where things get interesting: web3, and especially the NEAR Protocol, is a game-changer. It's like creating a fair playing field where everyone who helps AI grow – whether they're building it or using it – gets their fair share of recognition and rewards. After all, we're all in this together, helping shape our future and the future of AI.

Vote for Your Data

                 
 
                        My personal Digital data(Required)
			
					
					Belongs to me and I want to control it
			
			
					
					Owned and controlled  by apps to maximize their profit
			
			
					
					Owned and controlled  by apps to maximize my profit
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                


 

### NEAR protocol คืออะไร?

ผลลัพธ์ที่คาดหวัง: เข้าใจพื้นฐานเกี่ยวกับวิธีการทำงานของ NEAR จากมุมมองของผู้ใช้สุดท้าย
NEAR เป็นแพลตฟอร์มแอปพลิเคชันที่มีลักษณะการทำงานบนบล็อกเชน NEAR Protocol ที่เป็นบล็อกเชนที่ทำงานบนเครือข่ายของเซิร์ฟเวอร์ที่มีจำนวนร้อยเครื่องทั่วโลก ถูกออกแบบให้เป็นแบบไม่มีการอนุญาต มีประสิทธิภาพและปลอดภัยพอที่จะสร้างชั้นข้อมูลที่แข็งแกร่งและมีความกระจายสำหรับเว็บใหม่
พร้อมกับภารกิจหลักของ NEAR คือการนำเสนอแพลตฟอร์มที่เหมาะสมสำหรับการเรียกใช้แอปพลิเคชันที่มีการเข้าถึงกับกลุ่มเงิน ตัวตนและข้อมูลที่มีความปลอดภัย ซึ่งเป็นเจ้าของโดยผู้ใช้ของตน มันรวมคุณสมบัติของการเชื่อมต่อเครือข่ายที่ต้านการแบ่งแยก การคำนวณแบบเซิร์ฟเวอร์เลส และการจัดเก็บข้อมูลแบบกระจายลงในแพลตฟอร์มประเภทใหม่
ดังนั้นก่อนที่เราจะไปไกลขึ้น ให้เราเรียนรู้เรื่องราวบางส่วนและดูว่าแพลตฟอร์มบล็อกเชนได้เจริญเติบโตไปยังไหนในช่วงเวลาที่ผ่านมา

การวิวัฒนาการของเทคโนโลยีบล็อกเชน
ตั้งแต่ Satoshi Nakamoto ปล่อย whitepaper ของ Bitcoin เมื่อตุลาคม 2008 โลกได้รู้จักกับเทคโนโลยีบล็อกเชนที่เปลี่ยนเกม ในช่วงสิบปีที่ผ่านมา บล็อกเชนได้ผ่านการวิวัฒนาการสามระดับ
รุ่นที่ 1: Bitcoin
Bitcoin เป็นตัวอย่างที่ดีที่สุดของบล็อกเชนรุ่นแรก จุดประสงค์ของบล็อกเชนนี้คือการเป็นระบบชำระเงินที่ง่ายและตรงไปตรงมา เริ่มต้นเป็น "สกุลเงินของอินเทอร์เน็ต" Bitcoin ตอนนี้กลายเป็นหนึ่งในคลาสส์สินทรัพย์ที่ต้องการมากที่สุด อย่างไรก็ตาม มีปัญหาใหญ่เมื่อเรื่องเกี่ยวกับ BTC คือ ไม่สามารถดำเนินการธุรกรรมที่ซับซ้อนได้ด้วยมันซึ่งอาจมีชั้นข้อมูลและตรรกะหลายชั้นที่แนบมากับมัน
รุ่นที่ 2: Ethereum และแพลตฟอร์มสมาร์ทคอนแทรค
Ethereum นำเข้าแพลตฟอร์มบล็อกเชนรุ่นที่สองด้วยสมาร์ทคอนแทรค สุดท้าย นักพัฒนาสามารถเขียนโปรแกรม ธุรกรรมที่ซับซ้อนผ่านสมาร์ทคอนแทรคเหล่านี้ และสามารถสร้างแอปพลิเคชันที่มีการเข้าถึงแบบกระจาย (dApps) ผ่าน dApps เหล่านี้ กรณีการใช้งานของบล็อกเชนได้เพิ่มขึ้นอย่างมาก
อย่างไรก็ตาม พื้นที่นี้กำลังต่อสู้กับปัญหาการเจริญเติบโตของมัน สิ่งสำคัญคือ บล็อกเชนเหล่านี้กำลังเผชิญกับปัญหาการขยายของมันอย่างรุนแรง ตัวอย่างเช่น Bitcoin มีประสิทธิภาพในการทำธุรกรรม 7 รายการต่อวินาที ในขณะที่ Ethereum สามารถจัดการได้เพียง 25 รายการ เมื่อเปรียบเทียบกับ PayPal (115 tps) และ Visa (1,700 tps) มันเป็นเรื่องน่าเสียดายมาก
เพื่อเป็นธรรมกับ Ethereum และ Bitcoin ได้พยายามแก้ปัญหาการขยายของมันด้วยวิธีการชั้นที่สองหลายวิธี เช่น lightning network, raiden, plasma protocol เป็นต้น ความคิดที่นี่คือ สร้างชั้นเพิ่มเติมเหนือบล็อกเชนพื้นฐานซึ่งโปรโตคอลหลักสามารถมอบหมายงานที่ซ้ำซ้อนและยุ่งยากไปยังอย่างไรก็ตาม มีปัญหาสองประการที่เกิดขึ้นจากวิธีการนี้ ในที่สุด โซลูชันชั้นที่ 2 เหล่านี้ยังไม่ได้รับการยอมรับจากมวลชน และอีกอย่างคือ โซลูชันชั้นที่ 2 เหล่านี้ทำลายโครงสร้างพื้นฐานของโปรโตคอล ซึ่งอาจมีผลกระทบในระยะยาว
นี่คือที่ที่รุ่นที่สามเข้ามา
รุ่นที่ 3: NEAR
NEAR เป็นตัวอย่างของบล็อกเชนรุ่นที่ 3 ซึ่งมีเป้าหมายที่จะแก้ไขปัญหาการขยายของข้อมูลและอนุญาตให้ผู้ใช้สุดท้ายและนักพัฒนาสามารถเพลิดเพลินกับศักยภาพเต็มของสมาร์ทคอนแทรคและเทคโนโลยีบล็อกเชน แทนที่จะพึ่งพาเทคโนโลยีชั้นที่ 2 NEAR ปลดปล่อยตัวจากความคิดว่าทุกๆ โหนดที่มีส่วนร่วมในเครือข่ายจะต้องเรียกใช้รหัสทั้งหมดเพราะว่านั้นจะสร้างข้อจำกัดที่เป็นข้อจำกัดและทำให้การเข้าถึงทั้งหมดช้าลง
เพื่อแก้ไขปัญหานี้ NEAR ใช้เทคนิคที่มีอยู่อย่างแพร่หลายในโลกฐานข้อมูล - การแบ่งชั้น หากดำเนินการอย่างถูกต้อง มันจะช่วยให้ความสามารถของเครือข่ายขยายตัวขึ้นเมื่อจำนวนโหนดในเครือข่ายเพิ่มขึ้นดังนั้นจึงไม่มีข้อจำกัดทฤษฎีในความสามารถของเครือข่าย ส่วนที่ดีที่สุด? การแบ่งชั้นเป็นเทคนิคในการขยายของชั้นที่ 1
การแบ่งชั้นคืออะไร?
ในฐานข้อมูล บางครั้งคุณต้องจัดการกับข้อมูลที่ใหญ่และหนัก นี้ทำให้ประสิทธิภาพและประสิทธิภาพลดลงอย่างมากและทำให้กระบวนการทั้งหมดเป็นไปอย่างไม่เป็นประสบการณ์ นี่คือที่ที่การแบ่งชั้นมาช่วย
การแบ่งชั้นทำการแบ่งพาร์ทิชันแนวนอนของฐานข้อมูลของคุณและเปลี่ยนเป็นตารางที่เล็กกว่าและง่ายต่อการจัดการมากขึ้น

ดังนั้น ทำไมต้องแบ่งพาร์ทิชันแนวนอนและไม่ใช่แบ่งพาร์ทิชันแนวตั้ง?
พิจารณาตารางนี้:


A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



See that?
Because of the partition, the table turns into two completely different tables. 
As opposed to that, what happens when the table gets partitioned horizontally:
Do you see what happens? When you vertically partition a table they tend to become two completely different tables altogether.
However, if we were to partition them horizontally:


A
B
A*B
A/B


3
3
9
1


4
4
16
1



เห็นไหม?
การแบ่งพาร์ทิชันแนวนอนจะทำให้ฐานข้อมูลเป็นตารางขนาดเล็กของฐานข้อมูลเดียวกัน ฐานข้อมูลขนาดเล็กเหล่านี้เรียกว่าชาร์ด

การแบ่งพาร์ทิชันช่วยอะไรในบล็อกเชน?
เมื่อมีโหนดมากขึ้นในระบบ Ethereum และ Bitcoin การตรวจสอบและการยืนยันทั้งหมดจะใช้เวลามากขึ้น ตอนนี้ การแบ่งพาร์ทิชันจะช่วยอะไรได้?
การแบ่งพาร์ทิชันจะแบ่งสถานะโลกของบล็อกเชนเป็นชาร์ดขนาดเล็กขึ้นที่จะง่ายต่อการจัดการ
เกิดอะไรขึ้นเมื่อชาร์ดถูกเปิดใช้งาน?


 	สถานะถูกแบ่งเป็นชาร์ด
 	บัญชีที่ไม่ซ้ำกันแต่ละบัญชีอยู่ในชาร์ดเดียวกัน และบัญชีในชาร์ดนั้นจะทำธุรกรรมกับบัญชีอื่นในชาร์ดเดียวกันเท่านั้น

ในคำนึงง่ายๆ จินตนาการฉากนี้ มีเครือข่ายที่มีโหนดสามตัวคือ A, B, และ C และต้องตรวจสอบข้อมูล T ข้อมูล T ถูกแบ่งเป็นชาร์ด T1, T2, และ T3 แทนที่โหนดเหล่านี้ทำงานกับ T ในรูปแบบทั้งหมด พวกเขาสามารถทำงานกับชาร์ดแต่ละชาร์ดพร้อมกัน ดังนั้นคุณจะเห็นว่าเวลาที่คุณประหยัดได้เป็นอย่างมาก
ไม่เหมือนกับวิธีการแบ่งพาร์ทิชันอื่นๆ ที่ยังต้องการให้โหนดทำงานบนฮาร์ดแวร์ที่ซับซ้อนขึ้นเรื่อยๆ (ลดความสามารถให้ผู้คนมาเข้าร่วมในเครือข่ายได้มากขึ้น) เทคนิคของ NEAR ช่วยให้โหนดเล็กพอที่จะทำงานบนอินสแตนซ์ในคลาวด์อย่างง่าย

ทำไมบล็อกเชนที่สามารถขยายได้เช่น NEAR จำเป็น?
คำใบ้: มันไม่ได้เกี่ยวกับความเร็วเท่านั้น!
เมื่อเราพูดถึงบล็อกเชนรุ่นที่สองและรุ่นที่สาม สิ่งที่กำหนดค่าที่แท้จริงของมันคือระบบนิวเคลียร์ที่เติบโตอย่างรวดเร็วบนมัน ดังนั้น ส่วนใหญ่ของแพลตฟอร์มบล็อกเชนเหล่านี้อยู่ในการแข่งขันอย่างต่อเนื่องเพื่อดึงดูดนักพัฒนามากที่สุดเท่าที่จะเป็นไปได้อย่างไรก็ตามปัญหากับแพลตฟอร์มปัจจุบันคือว่าพวกเขาไม่มีความซับซ้อนที่จำเป็นสำหรับการโฮสต์แอปพลิเคชันคุณภาพสูง ปัญหาที่นี่คือเรามีนักพัฒนาพยายามสร้างเกม PS4 บนแพลตฟอร์มที่เทียบเท่ากับ Windows 98 ดังนั้นพวกเขาจำเป็นต้องทำความตัดสินใจอย่างมากเกี่ยวกับความสามารถโดยรวมของ dApps ของพวกเขา
นอกจากนี้ยังมีปัจจัยอีกอย่างที่ควรพิจารณาที่นี่ ความเร็วเป็นปัจจัยสำคัญเมื่อเราพูดถึงความสามารถในการใช้งานของแอปพลิเคชัน หลังจากทั้งหมดทำไมผู้ใช้จะใช้แอปพลิเคชันถ้ามันไม่สามารถใช้งานได้เลย? นักพัฒนาต้องการผู้ใช้จำนวนเฉพาะที่ใช้แอปพลิเคชันของพวกเขาอย่างต่อเนื่องก่อนที่มันจะถึงจุดวิกฤต
นี่คือเหตุผลที่แพลตฟอร์มบล็อกเชนที่มีความยืดหยุ่นเช่น NEAR มีความสำคัญสำหรับการนำเทคโนโลยีบล็อกเชนและสมาร์ทคอนแทรคไปสู่การใช้งานทั่วไป
NEAR ช่วยให้นักพัฒนาสามารถฝากแอปพลิเคชันของพวกเขาโดยไม่ต้องคิดมากเกี่ยวกับวิธีการทำงานหรือการขยายตัวของโครงสร้างรอบตัว ซึ่งคล้ายกับเมฆที่ทันสมัยเช่น Amazon AWS หรือ GCP หรือ Azure ซึ่งเป็นที่มาของแอปพลิเคชันเว็บทั้งหมดในปัจจุบัน

ประวัติย่อของ NEAR
NEAR เริ่มต้นในฤดูร้อนของปี 2018 เมื่อ Alex Skidanov และ Illia Polosukhin ตัดสินใจเปลี่ยนทิศทางออกจากการผจญภัยทางธุรกิจก่อนหน้าของพวกเขา หากคุณอยากรู้เพิ่มเติมคุณสามารถอ่านเพิ่มเติมได้ที่นี่ อย่างรวดเร็วมาก โดยที่ Misha ลาออกจาก MemSQL ทีมขยายจากไม่กี่คนเป็น 9 คนภายใน 3 วันในเดือนสิงหาคม ทีมเริ่มต้นประกอบด้วย 7 วิศวกร Erik ดำเนินการธุรกิจและ Sasha พูดกับตลาด
วันนี้ NEAR Collective เป็นกลุ่มทีมที่กระจายตัวทั่วโลก ประกอบด้วยหลายองค์กรและผู้มีส่วนร่วมหลายคน ที่จัดระเบียบตนเองเพื่อให้เทคโนโลยีนี้เป็นจริง มันไม่ใช่ธุรกิจหรืออะไรที่เป็นรูปแบบใกล้เคียง คิดว่ามันเหมือนกลุ่มคนที่ดำเนินการโครงการซอฟต์แวร์โอเพนซอร์สขนาดใหญ่
หนึ่งในโครงการของ Collective คือการเขียนรหัสเริ่มต้นและการนำไปใช้สำหรับเครือข่าย NEAR โอเพนซอร์ส คล้ายกับการสร้างเครื่องยนต์จรวดบนผู้บินอวกาศ งานของพวกเขาคือการทำงานวิจัยและพัฒนาเพื่อช่วยให้บล็อกเชนเข้าสู่วงแหวน รหัสสำหรับเครือข่ายนั้นเปิดเผยข้อมูลแหล่งที่มาเพื่อให้ใครก็ตามสามารถมีส่วนร่วมหรือเรียกใช้ได้สำคัญที่จะเน้นว่าเครือข่ายเช่น NEAR ถูกออกแบบให้เป็นระบบที่มีการกระจายอย่างสมบูรณ์ นั่นหมายความว่าพวกเขาทำงานอย่างสมบูรณ์บนตัวของพวกเขาเองและไม่สามารถถูกเซ็นเซอร์, ปิดหรือถูกแก้ไขโดยบุคคลที่สาม... แม้แต่ทีมที่สร้างขึ้นมาแรก! ดังนั้น ในขณะที่สมาชิกของคอลเลกทีฟนี้มาเพื่อเริ่มต้นการสร้างการปฏิบัติตัวอย่าง พวกเขากลายเป็นไม่จำเป็นต่อการดำเนินการของเครือข่ายเมื่อเริ่มทำงานแล้ว ในความเป็นจริง หลังจากที่พร้อมใช้งาน ใครก็สามารถแก้ไขและเริ่มเรียกใช้รหัส NEAR Protocol เพื่อเริ่มต้นบล็อกเชนของตัวเองเพราะมันเป็นโอเพนซอร์สทั้งหมดและการเปลี่ยนแปลงใดๆ จะต้องได้รับการยอมรับโดยประชาธิปไตยจากผู้ตรวจสอบอิสระที่เรียกใช้
NEAR มีทีมที่หลากหลายมาจากพื้นหลังต่างๆ ประกอบด้วยนักพัฒนาและนักวิจัยจากบริษัทเช่น Microsoft, MemSQL, Meta, Google และอื่นๆ โครงการยังได้รับการสนับสนุนจากกว่า 40 บริษัทลงทุนซึ่งรวมถึงบางในผู้ลงทุน VC ที่มีอิทธิพลที่สุดใน Silicon Valley เช่น Andreessen Horowitz’s a16z, Metastable, Pantera, Ripple’s developer ecosystem project Xspring และ Coinbase

หลังจากการเปิดให้บริการหลัก ทีม NEAR เริ่มทำงานในการเตรียมพื้นฐานสำหรับช่วงการนำมาใช้
การพัฒนาสะพานรุ้ง
สะพานรุ้งถือว่าเป็นสะพานที่สำคัญที่สุดในนิเวศ NEAR โปรโตคอล NEAR มองว่าสะพานนี้เป็นสะพานที่ไม่มีความเชื่อถือและไม่มีการอนุญาตที่ทำให้สามารถโอนสินทรัพย์ระหว่าง Ethereum, NEAR และในที่สุด Aurora สะพานรุ้งช่วยให้นักพัฒนาสามารถใช้สินทรัพย์ Ethereum บน NEAR อย่างไม่มีปัญหาและสินทรัพย์ NEAR บน Ethereum ตั้งแต่เริ่มใช้งานสะพานนี้ นักพัฒนาได้ใช้สะพานเพื่อโอนมูลค่ามากกว่า 1 ล้านเหรียญ DAI, ETH และอื่นๆ สะพานรุ้งยังสามารถใช้ใหม่และเชื่อมต่อ NEAR และทุกๆ โซ่ที่เข้ากันได้กับ Ethereum เช่น Binance Smart Chain, Polygon, Avalanche, Optimism, Arbitrum และอื่นๆ
การพัฒนา Aurora
การพัฒนา Aurora EVM ยังถือเป็นเหตุการณ์สำคัญในการผลักดันของ NEAR สำหรับการนำมาใช้ Aurora สามารถถือว่าเป็น EVM ที่มีประสิทธิภาพที่สุด โดยใช้ประโยชน์จากคุณสมบัติที่เป็นเอกลักษณ์ของ NEAR  Aurora ประกอบด้วยส่วนประกอบหลักสองส่วน คือ Aurora Engine และ Rainbow Bridge Aurora Engine ทำให้สามารถใช้งานสัญญาฉลาด Solidity และ Vyper อย่างไม่มีปัญหาในขณะที่ Rainbow Bridge ทำให้สามารถโอนสินทรัพย์ระหว่าง Ethereum และ Aurora ตามอนุญาต เมื่อเปรียบเทียบกับ Ethereum Aurora สามารถให้ค่าธรรมเนียมต่ำถึง 1000 เท่าและรองรับพันล้านธุรกรรมต่อวินาที แทนการเพิ่มขึ้น 50 เท่าของ Ethereum
เปิดให้บริการชาร์ดส่วนตัว
ในเดือนกันยายน 2021 NEAR ได้บรรลุเป้าหมายสำคัญด้วยการเปิดให้บริการชาร์ดส่วนตัว ชาร์ดส่วนตัวเหล่านี้ทำงานเป็นชาร์ดบน NEAR ทำให้สัญญาชาร์ดสาธารณชนสามารถเรียกใช้สัญญาชาร์ดส่วนตัวและกลับกัน

อ่านเพิ่มเติมเกี่ยวกับ ชาร์ดส่วนตัวบน NEAR ที่เว็บไซต์ Calimero
การสร้างกองทุน DeFiในตุลาคม 2021 Proximity Labs ประกาศกองทุนการพัฒนามูลค่า 350 ล้านเหรียญสำหรับ NEAR ทุนนี้จะช่วยในการสร้างการเงินที่ไม่มีกลาง - แอปพลิเคชัน DeFi บน NEAR นี้ตามด้วยประกาศจาก NEAR Foundation ระบุว่ากำลังสร้างกองทุน DeFi มูลค่า 800 ล้านเหรียญ Blockworks ยังประกาศเปิดตัวกองทุนที่เน้นที่ NEAR โดยมีแผนที่จะระดมเงินประมาณ 40 ล้านเหรียญ

การพัฒนาที่สำคัญอื่น ๆ
การพัฒนาที่กล่าวถึงข้างต้นไม่ใช่เพียงการพัฒนาเดียวที่เกิดขึ้นเกี่ยวกับ NEAR Protocol

- ในเดือนพฤศจิกายน 2021 บริษัทท่องเที่ยวระดับโลก Travala.com ประกาศความร่วมมือกับ NEAR ซึ่งจะเห็นการรวมเหรียญเครือข่ายกับ Travala
- NEAR ยังประกาศเปิดตัว Pagoda แพลตฟอร์มสตาร์ทอัพที่เน้นการช่วยให้นักพัฒนาสร้างแอปพลิเคชันบน NEAR หลังจากประกาศนี้ NEAR ยังประกาศเปิดตัว NEARPay NEARPay เป็นบัตรเดบิตและวิดเจ็ตการชำระเงินครั้งแรกบน NEAR ที่เชื่อมระหว่างเงินตราและเหรียญดิจิทัล
- NEAR ถูกเลือกโดย OrangeDAO คอลเล็กทีฟคริปโตที่สร้างขึ้นโดย Y Combinator Alumni เป็นบล็อกเชนชั้นที่ 1 หลักของตน
- สกุลเงินคงที่เชิงพื้นเมือง $USN ของ NEAR ถูกเปิดตัวผ่าน Decentral Bank

วิธีการทำงานของ NEAR Blockchain
เทคโนโลยีที่อยู่เบื้องหลังสกุลเงินดิจิทัล บล็อกเชนเป็นเทคโนโลยีที่สามารถเก็บบันทึกรายการธุรกรรมอย่างปลอดภัยบนเครือข่าย peer-to-peer แทนที่จะเก็บข้อมูลในตำแหน่งเดียวกัน เซิร์ฟเวอร์ที่อิสระทั่วโลกที่เรียกว่าโหนด ประกอบเครือข่ายที่ดำเนินการบล็อกเชน

หนึ่งในจุดเด่นสำคัญของเทคโนโลยีบล็อกเชนคือการกระจายอำนาจ ดังนั้น ทำไมการกระจายอำนาจมีประโยชน์? มาดูจากมุมมองของนักพัฒนาและผู้ใช้สุดท้าย

- นักพัฒนา: ในโลกที่มีการกำหนดเอง นักพัฒนามักอยู่ในการคุมโดยแพลตฟอร์มคลาวด์หรือแม้กระทั่งรัฐบาลเพื่อให้แน่ใจว่าพวกเขาสามารถดำเนินการแอปพลิเคชันต่อไปได้ ในโลกที่กระจายอำนาจไม่มีผู้กล่าวควบคุม
- ผู้ใช้สุดท้าย: ความโปร่งใสของแอปพลิเคชันที่กระจายอำนาจสามารถทำให้ผู้ใช้เห็นรหัสด้านหลังและทราบอย่างแน่นอนว่าแอปพลิเคชันจะใช้ข้อมูลส่วนตัวของคุณอย่างไร

อัลกอริทึมการตกลงของ NEAR คืออะไร?โปรโตคอลความเห็นถูกใช้เพื่อเรียกร้องความเห็นเพียงค่าเดียวระหว่างผู้ร่วมกิจกรรมหลายคนในระบบ หากผู้ร่วมเครือข่ายทุกคนทำงานร่วมกันตามโปรโตคอลความเห็น ค่าความเห็นใหม่อาจถูกเพิ่มเข้าไปในบัญชีและถูกตรวจสอบโดยโหนด อย่างไรก็ตาม ในกรณีของข้อพิพาท เครือข่ายอาจเน้นที่ความปลอดภัยหรือความมีชีวิตชีวา
กลไกความเห็นที่นำมาใช้บน NEAR ชื่อ Nightshade Nightshade จำลองระบบเป็นบล็อกเชนเดียว รายการของธุรกรรมทั้งหมดในแต่ละบล็อกถูกแบ่งเป็นชิ้นส่วนทางกายภาพหนึ่งชิ้นส่วนต่อชาร์ด ชิ้นส่วนทั้งหมดสะสมเข้าไปในบล็อกหนึ่ง โปรดทราบว่าชิ้นส่วนสามารถถูกตรวจสอบได้เฉพาะโหนดที่รักษาสถานะของชาร์ดนั้น
เมื่อพูดถึงการตรวจสอบ ส่วนสำคัญของ NEAR คือผู้ตรวจสอบ ผู้ตรวจสอบเหล่านี้รับผิดชอบในการรักษาความเห็นในโปรโตคอลผู้ตรวจสอบเป็นโหนดที่เชี่ยวชาญที่ต้องรักษาเซิร์ฟเวอร์ของพวกเขาออนไลน์ 100% ของเวลาในขณะที่รักษาระบบของพวกเขาอยู่เสมอ
นี่คือข้อควรจำเอาไว้เกี่ยวกับผู้ตรวจสอบเครือข่าย


 	NEAR กำหนดผู้ตรวจสอบเครือข่ายของตัวเองทุกสมัยใหม่ ๆ โดยเลือกตั้งพวกเขาตามส่วนของพวกเขา
 	ผู้ตรวจสอบที่เลือกไว้แล้วจะถูกลงทะเบียนใหม่โดยการเดิมพันโดยอัตโนมัติพร้อมกับรางวัลที่สะสมมา
 	ผู้ตรวจสอบที่เป็นไปได้ต้องมีส่วนของพวกเขาเหนือระดับที่กำหนดได้โดยไดนามิก
 	มีวิธีการที่ผู้ตรวจสอบสามารถใช้เพื่อเสริมส่วนของพวกเขา - ซื้อโทเคนเองหรือยืมผ่านการมอบหมายส่วนของพวกเขา
 	รางวัลที่คุณได้รับเป็นสัมพัทธ์ตรงกับส่วนของคุณ ส่วนของคุณมากขึ้น รางวัลของคุณก็มากขึ้น

ความเห็นถูกตั้งบนความเห็นของสายส่วนใหญ่ หมายความว่า เมื่อผู้ผลิตบล็อกเผยแพร่บล็อก พวกเขารวบรวมลายเซ็นของโหนดผู้ตรวจสอบ น้ำหนักของบล็อกก็คือสะสมของส่วนของผู้ลงนามทั้งหมดซึ่งลายเซ็นของพวกเขาถูกรวมอยู่ในบล็อก น้ำหนักของสายเชือกคือผลรวมของน้ำหนักบล็อก นอกจากนี้ ความเห็นใช้เครื่องมือความสมบูรณ์ที่นำเข้าเงื่อนไขการตัดสินใจเพิ่มเติมสำหรับความปลอดภัยของสาย



	

	
	
		
			
				Express Quiz: The weight of a block is:
			
		

		
					

		
			
			
			
			The maximum stake of the signers whose signatures are included in the block
		
			
			The cumulative stake of all the signers whose signatures are included in the block
		
			
			The average stake of the entire network divided by the number of signers in the block
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Runtime
เลเยอร์รันไทม์ถูกใช้ในการดำเนินการสมาร์ทคอนแทรคและการกระทำอื่น ๆ ที่สร้างขึ้นโดยผู้ใช้และรักษาสถานะระหว่างการดำเนินการ สามารถอธิบายได้จากมุมมองสามมุมต่าง: การไปขั้นตอนต่อขั้นผ่านฉากต่าง ๆ การอธิบายส่วนประกอบของรันไทม์ และการอธิบายฟังก์ชันที่รันไทม์ดำเนินการ

NEAR โทเคนคืออะไร?NEAR token เป็นสินทรัพย์เชิงพื้นฐานของ ระบบนิวร์ และความสามารถของมันถูกเปิดให้ใช้งานสำหรับบัญชีทั้งหมด แต่ละโทเค็นเป็นสินทรัพย์ดิจิทัลที่เป็นเอกลักษณ์เหมือนกับ Ether ซึ่งสามารถใช้ได้เพื่อ:


 	จ่ายระบบสำหรับการประมวลผลธุรกรรมและเก็บข้อมูล
 	เรียกใช้โหนดที่ยืนยันเป็นส่วนหนึ่งของเครือข่ายโดยเข้าร่วมในกระบวนการเดิมพัน
 	ช่วยกำหนดว่าทรัพยากรของเครือข่ายจะถูกจัดสรรอย่างไรและทิศทางเทคนิคในอนาคตโดยการเข้าร่วมในกระบวนการการบริหาร

NEAR token ทำให้การประสานเศรษฐกิจของผู้เข้าร่วมทุกคนที่ดำเนินการเครือข่ายและยังเปิดให้พฤติกรรมใหม่ในแอปพลิเคชันที่สร้างขึ้นบนเครือข่ายนั้น

วิธีเริ่มต้นกับ NEAR?
บัญชี/กระเป๋าเงิน
ก่อนที่คุณจะเริ่มต้นกับ NEAR สิ่งแรกที่คุณต้องทำคือการตั้งค่าบัญชี NEAR
ดูวิดีโอเกี่ยวกับบัญชี NEAR นี้:

กระเป๋าเงินช่วยให้คุณทำการโทรศัพท์ไปยังบล็อกเชน ตั้งค่าโหนดท้องถิ่นของคุณ และส่งและรับเงินจากผู้ใช้คนอื่น ๆ เมื่อคุณลงทะเบียน Account ID ของคุณ คุณต้องให้ชื่อที่ไม่ซ้ำกัน แม้ว่าทุกกระเป๋าเงินจะต้องมีชื่อที่ไม่ซ้ำกัน ผู้ใช้ทุกคนสามารถตั้งค่ากระเป๋าเงินหลาย ๆ อันได้
คุณสามารถนึกภาพนี้เหมือนกับบัญชี Facebook หรือ Google เมื่อคุณลงทะเบียนกับบริการใด ๆ คุณสามารถใช้บัญชีเดียวกันเข้าสู่บริการของบุคคลที่สาม ความแตกต่างระหว่าง NEAR Account IDs และบัญชี Google คือข้อมูลที่เก็บไว้ตาม Account ID สามารถเข้าถึงและจัดการได้เฉพาะเจ้าของกระเป๋าเงิน นอกจากนี้ ข้อมูลทั้งหมดถูกเก็บไว้บนเครือข่ายที่กระจายของโหนดแทนการเซิร์ฟเวอร์เดียว
สร้างบัญชี NEAR ตอนนี้: https://wallet.near.org/create
ข้อมูลเพิ่มเติมเกี่ยวกับ บัญชีที่ DOCS.NEAR

NEAR ExplorerNEAR Explorer ช่วยให้คุณสามารถดูการสร้างบล็อกแบบเรียลไทม์! เครื่องมือที่มีประโยชน์นี้ช่วยให้คุณสามารถค้นหา ธุรกรรม และ บัญชี ที่ช่วยให้คุณสามารถดูการโต้ตอบทั้งหมดระหว่างผู้ใช้และสมาร์ทคอนแทรกต์


วิธีการรับ NEAR tokens?
มี 3 วิธีในการรับ $NEAR

รับได้
คุณสามารถรับ $NEAR โดยการเข้าร่วม development bounties, โดย เปิดชุมชน ที่ช่วยให้คนสร้างบน NEAR, โดยชนะ NEAR hackathon หรือเป็นส่วนหนึ่งของชุมชนอย่างเป็นกิจกรรม. หากคุณสามารถดึงดูดคนอื่นให้ให้ยืมโทเค็นให้คุณสำหรับการจำนอง, คุณยังสามารถรับ $NEAR โดยการเป็น validator.

ซื้อได้
$NEAR มีจำหน่ายบนแลกเชนหลักหลายแห่ง (ดูด้านล่าง), ที่คุณสามารถสมัครสมาชิกและซื้อโทเคนโดยใช้เงินฟีแอตหรือเหรียญดิจิตอล
แลกเชนที่รายการ $NEAR
คุณสามารถดูภาพรวมของราคาและคู่สกุลเงินบน coinmarketcap และ coingecko.
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

จากเพื่อน
คุณไม่จำเป็นต้องมีบัญชี NEAR เพื่อรับ NEAR tokens! วิธีการ "NEAR Drop" ช่วยให้เพื่อนของคุณทำการเติมเงินล่วงหน้าในบัญชีใหม่และส่งลิงก์ร้อนให้คุณเพื่อรับโทเคน

สิ่งที่ฉันสามารถทำกับ NEAR tokens?
โอน NEARส่ง $NEAR ไปมาระหว่างบัญชีของคุณและเพื่อน และตรวจสอบธุรกรรมใน Block Explorer โดยค่าธุรกรรมต่ำมาก คุณสามารถย้ายจำนวนเงิน $NEAR เล็กๆ ได้อย่างรวดเร็วและง่ายดายเพื่อเล่นด้วย
ส่งเป็นของขวัญที่ http://redpacket.near.org/

ลอง NEAR Drop (เชิญเพื่อน)
ส่ง NEAR drop ให้เพื่อนของคุณ NEAR drop หากพวกเขาต้องการสร้างบัญชี

ใช้ NEAR Apps
เพื่อดูรายการแอปที่กำลังถูกสร้างบน NEAR ที่เพิ่มขึ้น คลิกที่นี่.
เริ่มต้นง่ายกับ NFT - ซื้อ/เผยแพร่/ซื้อขายงานศิลปะที่ https://paras.id/
เล่นที่ BerryClub เพื่อเข้าร่วมในการสร้างศิลปะร่วมกัน: https://berryclub.io/

ค่าใช้จ่ายในการใช้ NEAR (Gas) เท่าไร?
เมื่อคุณเรียกใช้ blockchain ของ NEAR เพื่ออัปเดตหรือเปลี่ยนแปลงข้อมูล ผู้ทำงานในโครงสร้างของ blockchain จะต้องรับผิดชอบค่าใช้จ่ายบางส่วน ณ ที่สุดของวัน คอมพิวเตอร์บางเครื่องจะประมวลผลคำขอของคุณ และผู้ตรวจสอบที่ดำเนินการเหล่านี้จะใช้ทุนสำคัญในการเดินเครื่องคอมพิวเตอร์เหล่านี้
เหมือนกับ blockchain ที่เป็นไปได้อื่นๆ NEAR จะชดเชยผู้ทำงานเหล่านี้โดยเรียกเก็บค่าธุรกรรม ที่เรียกว่าค่า gas ด้วย
หากคุณคุ้นเคยกับผู้ให้บริการบริการคลาวด์ web2 (Amazon Web Services, Google Cloud, เป็นต้น) ความแตกต่างใหญ่กับ blockchain คือผู้ใช้จะถูกเรียกเก็บเงินทันทีเมื่อพวกเขาเรียกใช้แอป แทนที่นักพัฒนาจะต้องจ่ายค่าใช้จ่ายในการใช้โครงสร้างทั้งหมดนั้นสร้างโอกาสใหม่ เช่น แอปที่ไม่มีความเสี่ยงในการหายไปในระยะยาวเนื่องจากเงินของนักพัฒนาหรือบริษัทหมด อย่างไรก็ตาม มันก็มาพร้อมกับอุปสรรคความสามารถในการใช้งาน ในการช่วยเหลือในเรื่องนี้ NEAR ยังมีความสามารถในการครอบคลุมค่า gas สำหรับผู้ใช้ เพื่อสร้างประสบการณ์ที่เข้าใจง่ายมากขึ้นสำหรับผู้ที่มาจาก web2
เมื่อคิดถึง gas ควรจำสองแนวคิดไว้ใจดี:
 	หน่วยก๊าซ: ภายใน, ค่าธรรมเนียมการทำธุรกรรมไม่ถูกคำนวณโดยตรงใน NEAR tokens แต่ผ่านขั้นตอนกลางของ "หน่วยก๊าซ" ประโยชน์ของหน่วยก๊าซคือว่าพวกเขาเป็นไปตามกฎ - ธุรกรรมเดียวกันจะต้องมีค่าใช้จ่ายในหน่วยก๊าซเดียวกันเสมอ
 	ราคาก๊าซ: หน่วยก๊าซจะถูกคูณด้วยราคาก๊าซเพื่อกำหนดว่าจะเรียกเก็บเท่าไรจากผู้ใช้ ราคานี้จะถูกคำนวณใหม่ในแต่ละบล็อกขึ้นอยู่กับความต้องการของเครือข่าย (ถ้าบล็อกก่อนหน้าเต็มกว่าครึ่งราคาจะเพิ่มขึ้น มิฉะนั้นจะลดลง และจะไม่เปลี่ยนแปลงมากกว่า 1% ในแต่ละบล็อก) และลดลงไปที่ราคาที่ถูกกำหนดโดยเครือข่าย ณ ปัจจุบันคือ 100 ล้าน yoctoNEAR

โปรดทราบว่าราคาก๊าซอาจแตกต่างกันระหว่าง mainnet และ testnet ของ NEAR ตรวจสอบราคาก๊าซก่อนที่จะพึ่งพาต่อตัวเลขด้านล่าง
คิดในมุมมองของก๊าซ
NEAR มีเวลาบล็อกประมาณหนึ่งวินาที โดยจำกัดปริมาณก๊าซต่อบล็อก หน่วยก๊าซถูกคำนวณอย่างรอบคอบเพื่อให้ได้เป็นตัวเลขที่ง่ายต่อการคิด:
10¹² หน่วยก๊าซ หรือ 1 TGas (TeraGas)…
≈ 1 มิลลิวินาทีของเวลา "คำนวณ"
…ซึ่ง, ที่ราคาก๊าซขั้นต่ำ 100 ล้าน yoctoNEAR, เท่ากับค่าใช้จ่าย 0.1 มิลลิNEAR
1 มิลลิวินาทีนี้เป็นการประมาณอย่างรวบรวมแต่เป็นประโยชน์ และเป็นเป้าหมายปัจจุบันของว่าหน่วยก๊าซถูกตั้งค่าไว้ใน NEAR หน่วยก๊าซรวมถึงเวลาคำนวณ/CPU และเวลาแบนด์วิดธ์/เครือข่าย และเวลาเก็บข้อมูล/IO ผ่านกลไกการปกครอง พารามิเตอร์ของระบบสามารถถูกปรับเปลี่ยน ทำให้การจับคู่ระหว่าง TGas และมิลลิวินาทีเปลี่ยนไปในอนาคต แต่ข้างต้นยังคงเป็นจุดเริ่มต้นที่ดีสำหรับการคิดถึงหน่วยก๊าซหมายถึงอะไรและมาจากที่ไหน
คำถาม: 1 TeraGas หรือ TGas เท่ากับ:



	

	
	
		
			
				1 TeraGas or TGas is equal to:
			
		

		
					

		
			
			
			
			1 microsecond of compute time
		
			
			10 seconds of compute time
		
			
			1 millisecond of compute time
		
			
			1 nano second of compute time
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







ค่าใช้จ่ายของการกระทำทั่วไป
เพื่อให้คุณมีจุดเริ่มต้นสำหรับค่าใช้จ่ายใน NEAR ตารางด้านล่างระบุการกระทำทั่วไปบางอย่างและจำนวน TGas ที่ต้องการในปัจจุบัน และค่าธรรมเนียมที่จะเป็นไปได้ในมิลลิNEAR ที่ราคาก๊าซขั้นต่ำ 100 ล้าน yN


การดำเนินการ
TGas
ค่าธรรมเนียม (mN)
ค่าธรรมเนียม (Ⓝ)


สร้างบัญชี
0.42
0.042
4.2⨉10⁻⁵


ส่งเงิน
0.45
0.045
4.5⨉10⁻⁵


เส้นทาง
0.50
0.050
5.0⨉10⁻⁵


เพิ่มกุญแจการเข้าถึงเต็มรูปแบบ
0.42
0.042
4.2⨉10⁻⁵


ลบกุญแจ
0.41
0.041
4.1⨉10⁻⁵



ฉันจะได้รับกำไรจาก NEAR ได้อย่างไร?
เสียเงิน NEAR ของคุณ
ความสำคัญของโมเดล Proof-of-Stake คือวิธีที่ Validators ได้รับการสนับสนุนจากชุมชนผ่านการ Stake. Validators ได้รับรางวัล NEAR token จากการดำเนินการโหนดที่เป็นเครือข่ายในรูปแบบอัตราการขยายเส้นทางคงที่ของ 5% ต่อปี โดยสร้างโทเคนใหม่สำหรับ Validators ทุก epoch (~12 ชั่วโมง) เป็นรางวัล
Validators ต้องรักษาจำนวน Stake ขั้นต่ำเพื่อรักษาที่นั่ง Validator ของตน ผู้ถือโทเคนสามารถ Stake กับ Validator ที่พวกเขาเชื่อว่าดำเนินการได้ดีสำหรับเครือข่ายและได้รับส่วนหนึ่งของรางวัลโทเคนที่สร้างขึ้นโดยเครือข่ายด้วย นี่เป็นการกระตุ้นให้ผู้ถือโทเคนเข้าร่วมกับชุมชน!
กระเป๋า NEAR ตอนนี้มีอินเตอร์เฟซการ Stake ที่สร้างอย่างตรงไปตรงมาในแอปเว็บ
เพื่อ Stake:


 	เลือก "Staking" จากแถบนำทาง (หรือดรอปดาวน์บนมือถือ)
 	คลิกที่ปุ่ม "เลือก Validator"
 	เลือก Validator
 	ยืนยันความเลือกของคุณและเลือก "Stake with Validator"
 	ป้อนจำนวน NEAR ที่คุณต้องการ Stake และคลิก "ส่ง Stake"
คุณจะต้องยืนยันธุรกรรมสองรายการ คือการเลือกผู้ตรวจสอบและการฝากและเดิมพันกับผู้ตรวจสอบ

เพื่อยกเลิกการเดิมพัน:

1. ในแดชบอร์ดการเดิมพัน (/staking) เลือกผู้ตรวจสอบปัจจุบันของคุณ
2. คลิก "ยกเลิกการเดิมพัน" และยืนยันธุรกรรม

หลังจาก 36 ถึง 48 ชั่วโมง (4 รอบเต็ม) คุณจะสามารถถอนเงินเดิมพันของคุณ ในการทำเช่นนั้น กลับไปที่หน้าผู้ตรวจสอบ และคลิก "ถอนเงิน"

สร้าง DeFi บน NEAR

นิวระบบ DeFi (Decentralized Finance) กำลังระเบิด ในขณะที่ Ethereum ถือเครือข่าย DeFi มูลค่าเกิน 100 พันล้านเหรียญ สำหรับ NEAR นั้น นิวระบบ DeFi ยังเป็นเด็กและกำลังเติบโต

ตาม DeFiLlama มูลค่ารวมที่ล็อค (TVL) ของนิวระบบ NEAR น้อยกว่า 100 ล้านเหรียญ โดย Ref Finance เป็นผู้นำตลาด ความจริงที่ระบบ DeFi ของ Ethereum เป็น 1000 เท่าของ NEAR แสดงให้เห็นว่าเรายังอยู่ในช่วงเริ่มต้นเมื่อเทียบกับ NEAR DeFi ในปี 2021 นิวโปรโตคอลจริงๆ ประกาศกิจกรรมทุน 800 ล้านเหรียญ ส่วนใหญ่ของทุนถูกกำหนดให้เติบโตในภาคของโปรโตคอล DeFi

หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับนิวระบบ DeFi ของ NEAR อ่านบทความนี้

นิวระบบ NFT ของ NEAR ที่กำลังเติบโต

สินทรัพย์ที่ไม่สามารถแลกเปลี่ยนมีคุณสมบัติที่แตกต่างหรือคุณสมบัติที่ทำให้มันแตกต่างจากสินทรัพย์อื่น ๆ โทเค็นที่ไม่สามารถแลกเปลี่ยนมีขึ้นบนสินทรัพย์ที่ไม่สามารถแลกเปลี่ยนและเป็นสินทรัพย์ดิจิทัลที่ไม่ซ้ำกันที่ใช้เทคโนโลยีบล็อกเชน ในช่วงเวลาที่ผ่านมา กลุ่มนี้ได้รับความนิยมและระเบิดขึ้น

นิวระบบ NEAR เป็นแพลตฟอร์มที่เหมาะสมสำหรับ NFT เนื่องจากมีข้อได้เปรียบสองประการสำคัญเมื่อเปรียบเทียบกับ Ethereum:

NEAR มีความเร็วมากกว่าอย่างมีนัย
Ethereum ยังมีค่าธรรมเนียมในการใช้งานสูงมาก
ปัจจัยเหล่านี้ทำให้ NEAR เหมาะสมสำหรับการซื้อขาย NFT อ่านบทความนี้เพื่อทราบข้อมูลเพิ่มเติมเกี่ยวกับโครงการ NFT 7 อันดับบน NEAR

ดังนั้น ตอนนี้จะทำอย่างไร? ฉันจะสามารถโต้ตอบกับ NEAR ได้อย่างไร?ดีแล้ว ดังนั้นสิ่งที่จะเกิดขึ้นต่อไปคืออะไร? หากคุณได้อ่านไปถึงตรงนี้แล้ว คุณอาจต้องการศึกษาเพิ่มเติมเกี่ยวกับ โปรโตคอล NEAR ดังนั้นสิ่งถัดไปที่คุณควรทำคือตรวจสอบ เอกสารขาว NEAR หากคุณเป็นมือใหม่ในด้านบล็อกเชนและต้องการเรียนรู้เพิ่มเติมเกี่ยวกับเทคโนโลยีเอง คุณอาจต้องการดูวิดีโอนี้เกี่ยวกับการแยกส่วนของ ระบบนิเวศบล็อกเชน เข้าร่วม เซิร์ฟเวอร์ NEAR Discord และตรวจสอบ NEAR Forum

### โปรโตคอล NEAR และ TON

NEAR Protocol และเครือข่ายเปิด (TON)
NEAR และ TON (The Open Network) เป็นหนึ่งในโครงการที่มีความมั่นคงสูงที่สุดในระบบคริปโต  NEAR มีคุณสมบัติที่ซึ่งประกอบด้วยการสร้างบัญชีและบัญชีที่มีชื่อ แพลตฟอร์ม dApp (แอปพลิเคชันที่ไม่มีกลาง) ซึ่งเน้นไปที่ความเป็นมิตรต่อผู้ใช้และนักพัฒนา และถูกสร้างโดย NEAR Collective ในทางตรงกันข้าม TON เป็นบล็อกเชนชั้นที่ 1 ที่ไม่มีกลางที่ถูกสร้างโดย Telegram เมื่อปี 2018 อย่างไรก็ตาม มันถูกละทิ้งในไม่ช้าหลังจากนั้น

บทความนี้จะสำรวจโครงการแต่ละโครงการอย่างละเอียดมากขึ้น รวมถึงวิธีการทำงาน ระบบนิเวศ การใช้งาน และอื่น ๆ
NEAR คืออะไร?
NEAR เป็นบล็อกเชน Proof-of-Stake สาธารณะที่สามารถใช้สมาร์ทคอนแทรคได้ ซึ่งให้นักพัฒนาพื้นที่สำหรับการสร้างแอปพลิเคชันที่ไม่มีกลาง (dApps) ถูกสร้างโดย NEAR Collective มันแข่งขันโดยส่วนใหญ่กับ Ethereum และบล็อกเชนที่สามารถใช้สมาร์ทคอนแทรคอื่น ๆ เช่น EOS และ Polkadot โปรโตคอลมีเป้าหมายที่จะปรับปรุงข้อบกพร่องของ Ethereum ในด้านความเร็ว ประสิทธิภาพ และค่าใช้จ่าย

NEAR เร็วกว่าและถูกกว่า Ethereum ประมวลผลได้สูงสุดถึง 100,000 ธุรกรรมต่อวินาที ความยืดหยุ่นของโปรโตคอลที่น่าทึ่งสามารถเปลี่ยนวิธีการทำงานของโลกของสมาร์ทคอนแทรคและแอปพลิเคชันที่ไม่มีกลาง สำคัญสำหรับการออกแบบและวิธีการทำงานของ NEAR Protocol คือแนวคิดที่เรียกว่า sharding Sharding แบ่งโครงสร้างของเครือข่ายเป็นช่วงย่อยๆ ทำให้โหนดสามารถจัดการกับเฉพาะส่วนของธุรกรรมทั้งหมดของเครือข่าย การแบ่งช่วงสามารถสร้างวิธีการเรียกข้อมูลของเครือข่ายที่มีประสิทธิภาพมากขึ้นและช่วยในการขยายของแพลตฟอร์ม

NEAR สามารถเปรียบเทียบกับระบบจัดเก็บข้อมูลเช่น Amazon Web Services (AWS) ซึ่งเป็นชั้นฐานที่ใช้สร้างแอปพลิเคชัน อย่างไรก็ตาม ควาความแตกต่างสำคัญคือ NEAR เป็นระบบที่ไม่มีกลางและถูกดูแลโดยเครือข่ายที่กระจายของคอมพิวเตอร์ (โหนด) โทเคนเฉพาะของโปรโตคอล NEAR ถูกใช้ในการชำระค่าธุรกรรมและการจัดเก็บ ผู้ถือโทเคนยังสามารถเสนอโทเคนของตนเพื่อเป็นผู้ตรวจสอบและช่วยเครือข่ายให้เกิดความเห็นเชื่อ
NEAR Collective
NEAR Collective เป็นหน่วยงานที่อยู่เบื้องหลัง NEAR Protocol และประกอบด้วยองค์กรและผู้มีส่วนร่วมอื่น ๆ ที่ทำงานอย่างต่อเนื่องเพื่อปรับปรุงมัน องค์กรทำงานกับโครงการโดยเขียนรหัสเริ่มต้นของพวกเขาและช่วยในการนำมันมาใช้บน NEAR NEAR Collective ยังช่วยในกิจกรรมการพัฒนาและการปกครอง ในขณะที่ NEAR Collective ได้พัฒนา NEAR โปรโตคอลเป็นอย่างมาก โปรโตคอลเป็นระบบที่ไม่มีกลางอย่างสมบูรณ์ มันทำงานอย่างอิสระและไม่สามารถปิดหรือถูกจัดการ
NEAR Protocol ทำงานอย่างไร?
NEAR Protocol เป็นบล็อกเชน Proof-of-Stake กลไก Proof-of-Stake ต้องการผู้ถือโทเคนจำนวนหนึ่งที่ต้องเสนอโทเคนเพื่อมีสิทธิ์ตรวจสอบบล็อก สำคัญสำหรับการทำงานของโปรโตคอลคืออัลกอริทึมเชื่อมั่นของมัน - Nightshade
NightshadeNightshade เป็นโซลูชันการแบ่งชั้นของ NEAR Protocol ซึ่งช่วยให้ NEAR สามารถกระจายภาระการคำนวณเป็นชิ้นส่วนที่สามารถจัดการได้ ด้วย Nightshade แต่ละโหนดที่เข้าร่วมจะต้องเก็บข้อมูลบางส่วนของแพลตฟอร์มเท่านั้น จากนั้นโหนดสามารถประมวลผล 'ชิ้น' ของข้อมูลเหล่านี้และเพิ่มเข้าสู่โซ่หลัก

หนึ่งในประโยชน์หลักของ Nightshade คือลดจำนวนจุดที่เป็นจุดล้มละลายอย่างมีนัยยะ นี้เป็นเพราะทุกโหนดรับผิดชอบเพียงข้อมูลบางส่วนเท่านั้นและรักษาเพียงส่วนเล็กน้อยของโซ่ ทำให้เพิ่มประสิทธิภาพอย่างมาก

Validators เล่นบทบาทสำคัญใน NEAR และรับผิดชอบในการรักษาความเห็นอย่างต่อเนื่องในโปรโตคอล พวกเขาต้องเก็บเซิร์ฟเวอร์ของพวกเขาออนไลน์ตลอดเวลาและอัปเดตระบบของพวกเขา  Validators จะถูกกำหนดในทุกๆ ยุคใหม่และถูกเลือกตั้งโดยขึ้นอยู่กับสเตคของพวกเขา  Validators ที่ได้รับการเลือกได้รับการเลือกใหม่โดยการเสียเงินเดิมและรางวัลที่สะสมได้ ในขณะเดียวกัน ผู้เล่นที่เป็นไปได้ต้องมีสเตคของพวกเขาเหนือระดับที่กำหนดไว้ล่วงหน้า

NEAR รองรับที่อยู่ที่สามารถอ่านได้โดยมนุษย์ มีสองประเภทของบัญชี NEAR: ที่อยู่อ้อมความแท้จริงและที่อยู่ที่มีชื่อ

บัญชีที่อยู่อ้อมความแท้จริงถูกกำหนดโดยที่อยู่ 64 ตัวอักษรที่สอดคล้องกับคู่กุญแจสาธารณะ/ส่วนตัว ในการใช้ประเภทบัญชีนี้ผู้ใช้ต้องเติมเงินให้กับ NEAR โทเคนของพวกเขาหรือจ่ายค่าธรรมเนียมก๊าซสำหรับธุรกรรม

NEAR ยังอนุญาตให้ผู้ใช้ลงทะเบียนบัญชีที่มีชื่อที่ง่ายต่อการแบ่งปันและจำจำ บัญชีที่มีชื่อยังสามารถสร้างบัญชีย่อยได้ ทำหน้าที่เป็นโดเมน

TON (Toncoin) สร้างขึ้นโดย Telegram เมื่อปี 2018 ในเวลานั้น Telegram ได้ระดมทุนเอกชนมูลค่า 1.7 พันล้านเหรียญสำหรับบล็อกเชนใหม่ของตน ที่ตั้งใจเป็นคู่แข่งกับ Ethereum อย่างไรก็ตาม มันละทิ้งโครงการหลังจากที่ กรมการค้าและหลักทรัพย์แห่งสหรัฐเข้ามาและฟ้องว่า $TON โทเคนตัวเองเป็นหลักทรัพย์ หลังจากที่ Telegram ละทิ้งโครงการนี้ มันถูกนำไปโดยนักพัฒนาที่ไม่มีความเกี่ยวข้องกับ Telegram รับมอบชื่อโดเมน ton.org และที่เก็บโค้ด Toncoin  Toncoin จากนั้นเปิดตัวบล็อกเชน TON และโทเคน TON

TON เป็นเครือข่ายสมาร์ทคอนแทรคชั้นที่ 1 ที่ถูกสร้างสำหรับแอปพลิเคชันทางการเงินและ NFT จนถึงตอนนี้มี NFT กว่าหนึ่งล้านรายการถูกสร้าง คล้ายกับ NEAR TON เป็นบล็อกเชน Proof-of-Stake ที่ส่งผลให้เครือข่ายที่มีประสิทธิภาพสูงที่เหมาะสำหรับธุรกรรมทางการเงิน มันยังสามารถให้การโต้ตอบระหว่างผู้ใช้ผ่านโครงสร้างการเงินที่ไม่สามารถเปลี่ยนแปลงได้ บล็อกเชน TON ยอดเยี่ยมด้วยความสามารถในการขยายขนาดและประสิทธิภาพสูง มันสร้างบันทึกของตนเมื่อมันประมวลผลธุรกรรม 55,000 รายการต่อวินาที ซึ่งเป็นไปได้ด้วยโครงสร้างหลายระดับที่เฉพาะตัว การรวมโซ่หลักกับโซ่คำอื่นๆ หลายๆ อันProof-of-Stake Consensus 
การตกลงคือวิธีที่โหนดบนเครือข่ายตกลงกันเกี่ยวกับสถานะปัจจุบันและสถานะที่ถูกต้องของเครือข่าย  TON ใช้กลไกการตกลง Proof-of-Stake ที่ประหยัดพลังงาน ผู้ตรวจสอบสามารถเดิมพันโทเค็นของตนและได้รับรางวัลสำหรับการช่วยในการรักษาความปลอดภัยของเครือข่าย ณ เวลาที่เขียน TON มีผู้ตรวจสอบ 329 คนและมี 511,880,772 $TON เดิมพัน ผู้ตรวจสอบได้รับ $TON สำหรับทุกบล็อกที่พวกเขาตรวจสอบ การตรวจสอบบล็อกของ TON-Proof-of-Stake ทำให้เครือข่ายยังคงทำงานต่อไปได้ แม้ว่าผู้ตรวจสอบทุกคนจะไม่สามารถเข้าร่วมในการตกลง
Sharding 
Sharding ช่วยเพิ่มความสามารถในการขยายของบล็อกเชนและใช้โดย NEAR ด้วย Sharding แบ่ง TON เป็นส่วนย่อยที่เรียกว่าชาร์ด แต่ละชาร์ดได้รับหน้าที่เฉพาะ ช่วยให้บล็อกเชนรักษาสถานะโลก การรักษาสถานะโลกช่วยให้ไม่ต้องมีความจำเป็นในการประมวลผลทุกธุรกรรมของโหนดเครือข่าย เพิ่มความเป็นประสิทธิภาพ
The TON Virtual Machine (TVM)
เครื่องจำลองเสมือน TON เล่นบทบาทที่คล้ายกับ Ethereum Virtual Machine คำนวณคำสั่งจากแอปพลิเคชันสัญญาและเปลี่ยนสถานะเครือข่ายหลังจากการดำเนินการทุกครั้ง ผ่าน TVM นักพัฒนาสามารถสร้างแอปพลิเคชันที่สามารถอัตโนมัติกระบวนการต่าง ๆ เช่นการสร้างสินทรัพย์ การโอนสินทรัพย์ และการลงนามข้อความบนเครือข่าย
Toncoin 
Toncoin ($TON) เป็นสกุลเงินดิจิทัลใน TON และมีการใช้งานหลายอย่างในระบบ TON โทเคนถูกใช้ในการชำระค่าธรรมเนียมธุรกรรม เดิมพัน และการปกครองโปรโตคอล
ค่าธรรมเนียมธุรกรรม 
โทเคน ($TON) ถูกใช้ในการชำระค่าธรรมเนียมสำหรับธุรกรรมในเครือข่าย TON ผู้ใช้ต้องใช้โทเคนเพื่อประมวลผลธุรกรรมหรือชำระค่าธรรมเนียมก๊าส โทเคนยังถูกใช้ในการชำระค่าเก็บข้อมูลของเครือข่าย TON และชื่อโดเมนที่ใช้บล็อกเชน
การปกครอง 
โทเคน ($TON) เล่นบทบาทสำคัญในการปกครอง ผู้ถือโทเคนสามารถลงคะแนนเสียงในข้อเสนอและมีส่วนร่วมในอนาคตของเครือข่าย
การเดิมพัน 
ผู้ถือโทเคน ($TON) ยังสามารถเดิมพันโทเคนของตน ทำหน้าที่เป็นผู้ตรวจสอบ ช่วยในการตรวจสอบธุรกรรมและรักษาความปลอดภัยของเครือข่าย ผู้ใช้สามารถเดิมพันโทเคนของตนโดยตรงบนเครือข่ายหรือผ่านแลกเปลี่ยนสกุลเงินดิจิทัลชั้นนำ




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





แผนอนาคตสำหรับ NEAR และ TON
NEAR - ประสิทธิภาพ AI ของผู้ใช้
NEAR กำลังเดินหน้า ประสิทธิภาพ AI ของผู้ใช้ โดยรวม AI การวิจัยและการประยุกต์ใช้ในระบบบล็อกเชนของตน NEAR.AI R&D Lab มีเป้าหมายที่จะพัฒนา AI ที่สร้างแอปพลิเคชัน Web3 จากจุดประสงค์ของผู้ใช้ โดยใช้ฐานผู้ใช้ขนาดใหญ่ นิเวศน์นักพัฒนา และทรัพยากรทางการเงิน NEAR มีเป้าหมายที่จะดึงดูด AI ชั้นนำความสามารถในการสร้างและสร้างโครงสร้าง AI แบบกระจายที่ทำให้ผู้ใช้และชุมชนมีพลังงาน
TON - การผนวกของ Telegram อย่างละเอียด
การขยายความสามารถของ TON ใน Telegram ไม่มีข้อสงสัยว่าเป็นสิ่งที่น่าตื่นเต้นที่สุดเกี่ยวกับ TONCoin ตาม ผู้ก่อตั้ง Telegram Pavel Durov ผู้ใช้จะสามารถจ่ายค่าโฆษณาใน TON และให้เงินเหรียญให้ผู้ดูแลช่อง ในไม่ช้าสติกเกอร์สามารถซื้อขายเป็น NFTs โดยศิลปินจะได้รับ 95% ของรายได้ ผู้ใช้ยังสามารถแบ่งปัน TON เข้าสู่บัญชีโดยใช้กระเป๋าสตางค์คริปโต และลงทะเบียนและขายชื่อบัญชี
ในการปิด
NEAR และ TON เป็นแพลตฟอร์มนวัตกรรมที่ได้เปลี่ยนแปลงภูมิทัศน์ของ dApp และสัญญาอัจฉริยะ ด้วยการให้ความสำคัญกับความเร็ว การขยายขอบเขต และความเป็นมิตรต่อผู้พัฒนา NEAR ได้เป็นทางเลือกที่คุ้มค่าสำหรับ Ethereum ในขณะเดียวกัน TON กำลังดึงดูดนักลงทุนและนักพัฒนาอย่างรวดเร็ว การผนวกของ TON ยังให้เครือข่ายเข้าถึงผู้ใช้มากกว่า 700 ล้านคน
โหวตตอนนี้!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### แผนการที่เป็นเจ้าของ NEAR.AI: คู่มือง่าย

NEAR.AI ต้องการสร้าง AI ขั้นสูงที่ทุกคนสามารถใช้และเป็นเจ้าของได้ นี่คือแผนการทำงาน:

 	การสอนเครื่องจักรให้เขียนโค้ด: นักพัฒนา AI - ตัวแรกที่พวกเขาจะสร้าง AI ที่สามารถเรียนรู้การเขียนโค้ด
 	การวิจัยด้วย AI: นักวิจัย AI - ต่อมา AI นี้จะเรียนรู้การทำวิจัย
 	การสร้าง AI ขั้นสูงสำหรับทุกคน - ในที่สุดพวกเขาจะใช้การวิจัยนี้เพื่อสร้าง AI ที่มีพลังและเป็นเจ้าของของทุกคน

คำสัญญา:

 	โอเพนซอร์ส: ทุกอย่างจะเปิดให้ทุกคนใช้และปรับปรุง
 	องค์กรไม่แสวงหาผลกำไร: มูลนิธิ NEAR องค์กรไม่แสวงหาผลกำไร จะเป็นผู้นำในการดำเนินงานนี้
 	การเป็นเจ้าของของผู้ใช้: จุดมุ่งหมายคือให้ผู้ใช้เป็นเจ้าของ AI ของตนเอง

นิวระบบ NEAR:

 	ผู้ใช้ล้านคน: NEAR มีผู้ใช้เป็นสิบล้านคน
 	ชุมชนนักพัฒนาที่กำลังเติบโต: โครงการ AI มากขึ้นกำลังเข้าร่วม NEAR
 	เงินทุนแข็งแกร่ง: NEAR มีเงินทุนที่จำเป็นสำหรับความสำเร็จ

ผลิตภัณฑ์ปัจจุบันของ NEAR:

 	บล็อกเชนที่ใช้ง่าย: NEAR มีบล็อกเชนที่ใช้ง่ายและพัฒนาได้
 	ผู้ใช้ที่ใช้งานอยู่มากกว่าบล็อกเชนใดๆ

วิสัยทัศน์ในอนาคต:

 	AI ที่เป็นเจ้าของของผู้ใช้: AI ที่ทำงานเพื่อคุณและรักษาข้อมูลของคุณเป็นส่วนตัว
 	การปรับแต่งอย่างสมบูรณ์: ผู้ใช้สามารถปรับแต่งประสบการณ์ AI ของตนอย่างสมบูรณ์
 	ชุมชนและแบรนด์: AI จะช่วยให้ชุมชนและแบรนด์ทำงานร่วมกันและทำธุรกรรมโดยตรง

การสร้าง AI นักพัฒนา:

 	เริ่มในปี 2017: NEAR เริ่มด้วยการพยายามสร้าง AI-driven autocomplete
 	เปลี่ยนทิศทางในปี 2018: พวกเขาเปลี่ยนไปสร้างแพลตฟอร์มที่ไม่มีการกำหนด
 	ความก้าวหน้าถึงปี 2024: ตอนนี้ NEAR มีผู้ใช้ล้านคนและผู้ใช้ที่ใช้งานอยู่ทุกวันมากมาย

ความท้าทายในบล็อกเชน:

 	การแยกแยะ: ผลิตภัณฑ์กระจายอยู่บนบล็อกเชนหลายแห่ง
 	นักพัฒนาน้อย: น้อยกว่า 7,000 นักพัฒนา Web3 ที่ทำงานเต็มเวลา
 	มูลค่าสูงของโค้ด Web3: โค้ด Web3 มีมูลค่าและมีค่าใช้จ่ายในการพัฒนา

บทบาทของนักพัฒนา AI:

 	การกระโดดขึ้นขั้น: สร้างผลิตภัณฑ์ Web3 ได้อย่างง่ายดายโดยใช้ข้อมูลภาษาที่เรียบง่าย
 	การพัฒนาโอเพนซอร์ส: ซอฟต์แวร์ทั้งหมด ชุดข้อมูล และโมเดลจะเปิดเผย
 	การทำงานร่วมกัน: ทำงานร่วมกับโครงการ AI และ Web3 อื่นๆ

การมีส่วนร่วมของชุมชน:
 	แอปพลิเคชันใหม่: เชื่อมโยงกับชุมชนเพื่อสร้างแอปพลิเคชันใหม่
 	โครงสร้างพื้นฐานเพิ่มเติม: ต้องการมากกว่าบล็อกเชนเท่านั้น เช่น การสื่อสารแบบ peer-to-peer และการคำนวณเชิงส่วนตัว
 	การใช้ประโยชน์จาก ระบบนิเวศ NEAR: ใช้เศรษฐกิจที่มีตัวเลือกของ NEAR ที่มีอยู่

ประโยชน์ต่อระบบนิเวศ NEAR:

 	แอปพลิเคชันเพิ่มเติม: ดึงดูดผู้ใช้มากขึ้นด้วยแอปพลิเคชันใหม่
 	โอกาสทางเศรษฐกิจ: สร้างโอกาสทางเศรษฐกิจใหม่และผลกระทบของเครือข่าย

ก้าวหน้าในด้าน AI:

 	นักวิจัยด้าน AI: ค้นพบความรู้ใหม่ๆ โดยการรวมข้อมูลที่มีอยู่
 	เป้าหมายสุดท้าย: AGI ที่เป็นเจ้าของโดยผู้ใช้: AI ที่ฉลาดกว่าผู้เชี่ยวชาญมนุษย์ ทำให้การคำนวณเปลี่ยนแปลง

หลักการ:

 	ให้บริการแก่ผู้ใช้: AI ต้องให้บริการและเป็นเจ้าของโดยบุคคลและชุมชน
 	AGI เปิดเป็นแหล่งข้อมูล: เพื่อประโยชน์แก่ทุกคน ทุก AI และ AGI ต้องเป็นแหล่งข้อมูลเปิดและเป็นเจ้าของโดยผู้ใช้




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





สรุป:
วิสัยทัศน์ของ NEAR.AI คือการประชาธิปไตย AI โดยการให้แน่ใจว่ามันเปิดและเป็นเจ้าของโดยผู้ใช้ โดยการมีส่วนร่วมกับชุมชน การใช้ประโยชน์จากระบบนิเวศที่มีประสิทธิภาพของ NEAR และการให้ความสำคัญกับการพัฒนาโอเพ่นซอร์ส NEAR.AI มีเป้าหมายที่จะเปลี่ยนวิธีการเชื่อมต่อกับเทคโนโลยี การเดินทางนี้ ที่เริ่มต้นด้วยการสอนเครื่องให้เขียนโค้ดและก้าวหน้าไปสู่ AI ขั้นสูง สัญญาความเชื่อในอนาคตที่ AI ทำให้ทุกคนมีพลัง พร้อมกัน เราสามารถสร้างโลกดิจิทัลที่สม่ำเสมอและนวัตกรรมได้มากขึ้น

### Ví NEAR

Hướng Dẫn Sử Dụng Ví NEAR 
Trong thị trường tiền điện tử hiện tại, Ethereum là nền tảng được lựa chọn cho các ứng dụng phi tập trung, hợp đồng thông minh và tài chính phi tập trung. Tuy nhiên, Ethereum đang gặp phải nhiều vấn đề như phí gas cao và vấn đề lớn về khả năng mở rộng. Vì vậy, trong khi Ethereum có thể là "Numero Uno", có nhiều giao thức khác đang nổi lên để thách thức Ethereum trên thị trường. 

Giao thức NEAR là một trong những chuỗi khối đã nổi lên như một đối thủ đáng gờm của Ethereum trong không gian này. Nhóm tại NEAR đã nhìn vào những điểm yếu của Ethereum và tạo ra một giao thức nhắm thẳng vào điểm yếu lớn nhất của nó: thiếu khả năng mở rộng và phí gas cao. NEAR sử dụng quá trình gọi là sharding, cho phép giao thức mở rộng theo cấp số nhân. NEAR cũng đã quản lý được một số vốn đầu tư đáng kể từ một số nhà đầu tư mạo hiểm lớn nhất, bao gồm a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital và nhiều hơn nữa. Trong hướng dẫn này, chúng ta sẽ tìm hiểu về NEAR, và đặc biệt là ví NEAR. 
Giao Thức NEAR
Được thành lập vào năm 2018, Giao thức NEAR là một nền tảng phát triển phi tập trung được thiết kế để tạo ra môi trường mượt mà và gần như hoàn hảo cho các ứng dụng phi tập trung (dApps) và hợp đồng thông minh. NEAR được tạo ra sau khi phân tích những điểm yếu của các giao thức hiện có, đặc biệt là Ethereum. Giao thức tập trung vào giải quyết những vấn đề này, và đang cố trở thành nền tảng được lựa chọn cho Ứng dụng Phi tập trung (dApps) và Tài chính Phi tập trung (DeFi). Việc sử dụng sharding của NEAR cho phép giao thức mở rộng theo cấp số nhân, giải quyết vấn đề về khả năng mở rộng phổ biến trong không gian này. 

Blockchain Proof-of-Stake của NEAR rất thân thiện với nhà phát triển, nhờ vào việc giá thấp và khả năng mở rộng cao, và nhà phát triển có thể tạo ra các ứng dụng phi tập trung một cách mượt mà. Giao thức NEAR cũng có một số tính năng khác, như ví NEAR và các thành phần khác. Trong bài viết này, chúng ta sẽ tập trung vào ví NEAR, nhưng sẽ nói thêm về điều đó sau. NEAR cũng sử dụng cơ chế đồng thuận Doomslug, cho phép các khối đạt đến sự hoàn thiện trong vài giây. Các chuỗi khối khác thường tập trung xử lý, giới hạn khả năng sử dụng của chúng cho phần cứng cực kỳ cao cấp. Mặc dù cách tiếp cận này tăng cường hiệu suất, nhưng chỉ là tạm thời. NEAR có khả năng mở rộng theo cấp số nhân, hỗ trợ hàng tỷ giao dịch một cách phi tập trung. 

NEAR đã được tạo ra bởi NEAR Collective, một cộng đồng các nhà nghiên cứu và nhà phát triển. Trọng tâm của NEAR Collective là phát triển liên tục và cải thiện giao thức. Collective cũng đã làm việc trên mã nguồn ban đầu của Giao thức NEAR và triển khai Mạng NEAR. Trong khi NEAR Collective đứng sau việc phát triển Giao thức NEAR, cái sau hoạt động hoàn toàn độc lập và hoàn toàn phi tập trung, ngay cả NEAR Collective cũng không thể tắt nó. 
Ưu Điểm Của Giao Thức NEAR
 	Người dùng NEAR không cần bất kỳ tiện ích mở rộng trình duyệt phức tạp hoặc khóa để đăng ký. Một email đơn giản và mật khẩu là đủ để đăng ký.
 	Hợp đồng thông minh NEAR tương thích với Máy ảo WebAssembly (WASM).
 	Giao thức cho phép các nhà phát triển triển khai ứng dụng blockchain có khả năng mở rộng và hiệu suất cao.
 	Một phần nhỏ phí gas so với các loại khác như Ethereum.

Wallet Tiền Điện Tử Là Gì
Trước khi chuyển sang ví NEAR, quan trọng là hiểu rõ ví là gì. Đơn giản nhất, ví tiền điện tử an toàn lưu trữ khóa riêng của bạn, đảm bảo rằng tiền điện tử của bạn an toàn và dễ truy cập. Bạn cũng có thể sử dụng ví tiền điện tử để thực hiện giao dịch, gửi và nhận tiền điện tử, hoặc thậm chí tiêu tiền điện tử của bạn. Khi chọn ví tiền điện tử, bạn có nhiều lựa chọn để chọn. Đó là ví giấy, ví cứng và ví trực tuyến.
Ví Nóng
Ví nóng là ví trực tuyến cho phép người dùng chuyển tiền điện tử của họ nhanh chóng. Hầu hết các sàn giao dịch trực tuyến có ví của riêng họ mà người dùng có thể truy cập. Ví nóng dễ truy cập thông qua điện thoại di động hoặc máy tính để bàn. Mặc dù ví nóng cung cấp kết nối dễ dàng, chúng cũng đối mặt với nguy cơ từ các mối đe dọa như hack. Ví máy tính để bàn, ví trực tuyến và ví di động là ví nóng.
Ví Lạnh
Ví lạnh hoặc ví cứng là thiết bị tương tự như thiết bị USB nơi người dùng có thể lưu trữ khóa của họ. Ví có thể mang đi và kết nối với máy tính xách tay/máy tính để bàn bất cứ khi nào người dùng muốn truy cập tiền điện tử của họ. Ví cứng ít bị ảnh hưởng hơn bởi các mối đe dọa như hack hoặc bất kỳ cuộc tấn công độc hại nào khác có thể xảy ra trực tuyến.
Ví Giấy
Ví giấy về cơ bản là một tờ giấy in chứa khóa công khai và khóa riêng của bạn. Các khóa chỉ có thể truy cập thông qua mã QR. Ví giấy được sử dụng để lưu trữ một lượng lớn tiền điện tử vì chúng được coi là cực kỳ an toàn.
Ví Lạnh Tốt Nhất Cho NEAR
Ledger Nano S Plus


Ví lạnh tốt nhất cho NEAR là bất kỳ thiết bị ledger nào, với Ledger Nano S Plus là phổ biến nhất. Thiết bị ledger là tiêu chuẩn ngành khi lưu trữ ví lạnh của tiền điện tử, và chúng tương thích với hơn 5.500 đồng tiền và mã thông báo. Chúng đi kèm với ứng dụng đồng minh gọi là Ledger Live có nhiều tính năng hữu ích như mua, bán, đổi và đặt cược tiền điện tử, cùng với khả năng tương thích với gần như bất kỳ NFT nào. Ngoài ra, ledger tương thích với nhiều ví nóng được thảo luận trong bài viết này.

 
9 Ví Nóng Tốt Nhất Cho NEAR
MyNearWallet
Lịch sử và Ví Di Sản
Ví NEAR cũ đã gặp nhiều lỗi, vấn đề và vấn đề thiết kế tái diễn từ khi ra mắt vào năm 2020. Ngoài ra, hệ sinh thái NEAR được sử dụng bởi nhiều người dùng khác nhau có nhu cầu và sở thích khác nhau. Cuối cùng, các nhà phát triển NEAR quyết định rằng hệ sinh thái NEAR sẽ tốt hơn nếu không có ví chính thức, và các ứng dụng phi tập trung sẽ được khuyến khích sử dụng bộ chọn ví. Quyết định này được đưa ra để tăng cường phân quyền và truyền cảm hứng cho sự cạnh tranh lành mạnh trên toàn hệ sinh thái dẫn đến nhiều đổi mới trong các sản phẩm cuối cùng.

Ra mắt vào năm 2022, MyNearWallet là người kế nhiệm chính thức của hệ sinh thái NEAR. Kikimora Labs bắt đầu phát triển nó từ cùng một mã nguồn mở như ví NEAR cũ. Hiện họ đang làm việc để cải thiện các tính năng cũ, thêm nhiều tính năng mới, cải thiện bảo mật, sửa lỗi và cải thiện giao diện toàn diện. Trong những ngày đầu tiên, MyNearWallet trông gần như giống hệt ví cũ, nhưng với sự làm việc chăm chỉ và tận tâm, đội ngũ phát triển đã có thể cải thiện giao diện, sửa lỗi, giải quyết vấn đề bảo mật và thêm nhiều tính năng mới như đã hứa.




	

	
	
		
			
				What is the most secure type of crypto wallet
			
		

		
					

		
			
			
			
			Hot Wallet
		
			
			Cold Wallet
		
			
			Paper Wallet
		
			
			Custodial Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tổng Quan Sản Phẩm
MyNearWallet cho phép người dùng lưu trữ, đổi, giao dịch và đặt cược token NEAR và tài sản tương thích như NFT một cách an toàn. Nó hỗ trợ tất cả các tiêu chuẩn token NEAR mới nhất như tiêu chuẩn NEP-141 (FT), NEP-148 (FT), NEP-171 (NFT) và NEP-177 (NFT). MyNearWallet là người kế nhiệm chính thức của ví NEAR cũ. Ngoài ra, ví này cũng có sẵn các giao dịch wNEAR và USN, cũng như cách mua NEAR. Một cách khác để kiếm tiền bằng cách sử dụng MyNearWallet là bằng cách đặt cược NEAR để giúp blockchain xác thực giao dịch, mang lại lợi nhuận khoảng ~10% APY.

MyNearWallet không chỉ là một ví khác; nó cũng phục vụ như một cổng vào hệ sinh thái rộng lớn của các ứng dụng NEAR. Một số ứng dụng tốt nhất được xây dựng trên NEAR bao gồm Ref.finance (nền tảng DeFi hàng đầu trên NEAR), Rainbow Bridge (chuyển đổi token giữa Ethereum và NEAR), Mintbase (nền tảng NFT hàng đầu trên NEAR) và Sweatcoin (duy trì hoạt động để kiếm tiền điện tử) chỉ là một số ví dụ.

Một điểm khác biệt quan trọng cho tài khoản NEAR là NEAR sử dụng tài khoản có thể đọc được bởi con người, không phải là hash. Vì vậy, một tài khoản trên NEAR sẽ không đọc như 0x71C7656EC7ab88b098defB751B7401B5f6d8976F mà sẽ là alice.near hoặc bob.near. Tài khoản NEAR cũng có thể tạo các tài khoản con, nhưng chỉ tài khoản gốc mới có thể tạo chúng. Một điểm khác biệt quan trọng khác là hầu hết các blockchain chỉ có một cặp khóa công khai / khóa riêng tư cho mỗi tài khoản. Trên NEAR, các tài khoản có thể có nhiều cặp khóa được liên kết với họ. Chúng được gọi là "khóa truy cập." Có hai loại khóa truy cập, một khóa truy cập đầy đủ và một cuộc gọi chức năng. Một khóa truy cập đầy đủ cấp cho người dùng quyền kiểm soát hoàn toàn tài khoản NEAR của họ tài khoản NEAR trong khi một cuộc gọi chức năng cho phép ký giao dịch không phải là tiền tệ.

Địa chỉ Ví - Địa chỉ ví vốn là một chuỗi ký tự hoặc số hoặc cả hai được sử dụng để gửi hoặc nhận token bằng cách sử dụng ví NEAR. 

Khóa Riêng Tư Và Cụm Từ Khóa - Cụm từ khóa và khóa bảo mật là một loại mật khẩu. Cụm từ khóa bao gồm 12 từ, trong khi khóa riêng tư bao gồm một chuỗi các chữ cái và số. Cả hai đều rất quan trọng khi phục hồi ví.
Tạo Một Tài Khoản Sử Dụng MyNearWallet 
MyNearWallet cho phép bạn tạo một tài khoản NEAR để truy cập vào tất cả các tính năng đã được thảo luận trước đó. 

 	Để tạo một tài khoản, hãy truy cập vào www.mynearwallet.com. Khi bạn đến trang này, bạn sẽ thấy hai tùy chọn: Tạo tài khoản hoặc Nhập Tài Khoản Hiện Có. Nếu bạn đã có một tài khoản NEAR hiện có và muốn chuyển nó sang MyNearWallet, hãy chọn Nhập Tài Khoản Hiện Có và làm theo hướng dẫn. Chúng tôi sẽ tập trung vào việc tạo một tài khoản mới trong hướng dẫn này. Chọn tùy chọn "Tạo Tài Khoản".


2. Nhập tên mong muốn cho tài khoản của bạn vào ô "ID Tài Khoản", sau đó nhấn vào "Đặt Tên Tài Khoản Của Tôi".

3. Nhập mật khẩu cho tài khoản NEAR của bạn, hãy chắc chắn rằng đó là một mật khẩu mạnh, vì nó sẽ cấp quyền truy cập vào tài khoản và tiền điện tử của bạn. Đánh dấu vào hai ô.

4. Nhấn vào "Bắt Đầu"
5. Bạn sẽ có thể chọn từ 2 tùy chọn: "Mật khẩu an toàn" hoặc "Ví cứng Ledger". Chọn "Mật khẩu an toàn" (chúng tôi sẽ hướng dẫn bạn cách thiết lập nó với thiết bị Ledger sau trong hướng dẫn này).

6. MyNearWallet sẽ tạo cho bạn một mật khẩu bao gồm 12 từ ngẫu nhiên. Bạn có thể tạo một mật khẩu mới nếu bạn không thích của mình. Hãy chắc chắn ghi lại mật khẩu của bạn, hoặc lưu trữ nó trong một trình quản lý mật khẩu như LastPass, vì bạn sẽ cần nó để truy cập vào tài khoản của mình. Nhấn tiếp tục khi bạn sẵn sàng.

7. Sau đó, bạn sẽ được nhắc nhập một trong những từ từ mật khẩu của bạn. Nhập từ vào ô được cung cấp.
8. Bước cuối cùng để thiết lập tài khoản của bạn là mua một số token NEAR, hoặc có một người bạn chuyển chúng vào tài khoản của bạn.
a. Bạn có thể nhấn vào nút này để truy cập các phương thức thanh toán để mua NEAR.

b. Yêu cầu một người bạn gửi cho bạn một số NEAR.
i. Nhấn vào địa chỉ ví của bạn ở góc phải màn hình.

ii. Sao chép địa chỉ của bạn và gửi cho bạn bè của bạn.


Tạo Tài Khoản Với Ledger

 	Lặp lại các bước 1-4 từ phần trước của hướng dẫn này.
 	Chọn tùy chọn "Ví cứng Ledger".


3. Tham khảo hướng dẫn trên Trang web Hỗ trợ Khách hàng của Ledger để biết thêm hướng dẫn chi tiết.



	

	
	
		
			
				What cold/hardware wallet brand is recommended for storing NEAR?
			
		

		
					

		
			
			
			
			Trezor
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Ledger
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Here WalletHERE Wallet là một ví di động không giữ tài sản cho Giao thức NEAR. Với việc sử dụng ví này, người dùng có thể dễ dàng chuyển, nhận, đặt cược và đổi NEAR cùng với các mã thông bình và không thông bình dựa trên NEAR. Nó có một giao thức chồng lỏng có nghĩa là người dùng có khả năng rút NEAR của họ từ việc đặt cược vào bất kỳ lúc nào. Lợi suất đặt cược là ~9% APY. Ví cũng có tài liệu hỗ trợ khách hàng cho người dùng tham khảo nếu họ gặp khó khăn.

HERE Wallet có nhiều tính năng bảo mật như lưu trữ mật khẩu trên thiết bị, sinh trắc học và truy cập mã pin giúp nó trở thành một trong những ví thân thiện với điện thoại nhất trên thị trường. Cụm từ khóa được lưu trữ cục bộ trên thiết bị, tuy nhiên ví cũng có tích hợp với ví phần cứng Ledger và HITO cho những người muốn có thêm bảo mật. Ví cũng sẽ định kỳ gửi cảnh báo bảo mật cho người dùng khi phát hiện hoạt động đáng ngờ và đã được kiểm toán độc lập bởi OtterSec.

Ví Người Gửi
Sender Wallet là một ví mở rộng trình duyệt được xây dựng cho giao thức NEAR, cũng có sẵn dưới dạng ứng dụng. Nó được ra mắt vào tháng 2 năm 2022 và đang trở nên phổ biến trong số người dùng NEAR với nhiều tính năng như danh sách đen của các địa chỉ độc hại, hỗ trợ Ledger, NFT, trao đổi token và đặt cược.

Nếu bạn lo lắng về bảo mật, Sender sẽ bảo vệ bạn. Nó đã được kiểm toán bởi SlowMist, một công ty hàng đầu về an ninh mạng, và thường xuyên trao thưởng cho lỗi để đảm bảo rằng bảo mật được cập nhật. Với các nhà đầu tư như Binance Labs và Crypto.com Capital, Sender Wallet đã nhận được rất nhiều sự ủng hộ từ ngành công nghiệp và chắc chắn sẽ trở thành một phần không thể thiếu trong hệ sinh thái NEAR.

Ví Meteor
Meteor Wallet là một ví mở rộng trình duyệt và ví web được xây dựng cho hệ sinh thái NEAR. Ra mắt trên giao thức NEAR vào Q3 năm 2022, ví mới này có giao diện trực quan và nhiều tính năng hấp dẫn như quá trình đăng ký đơn giản, khôi phục dễ dàng, tính năng NFT tiên tiến và nhiều hơn nữa. Mọi thứ trên ví đều được mã hóa và không có gì được đăng nhập, để bạn có thể yên tâm rằng tài sản tiền điện tử của mình an toàn. Ví có một đội ngũ hỗ trợ khách hàng tuyệt vời với các hướng dẫn chi tiết được viết cho người dùng mới và người dùng nâng cao.Ví Meteor là một trong những ví NEAR đơn giản và dễ sử dụng nhất. Đó là một ví web cũng có thể được sử dụng như một tiện ích Chrome. Hiện tại, nó chỉ hoạt động với giao thức NEAR vì nó được thiết kế đặc biệt cho mục đích đó. Một số tính năng của Meteor bao gồm đặt cược, chuyển khoản, mua bán và đổi NEAR, cùng với các mã thông báo có thể đổi và không thể đổi khác được xây dựng trên NEAR. Ví này cũng mở ra cánh cửa cho toàn bộ hệ sinh thái NEAR, và cung cấp quyền truy cập vào các ứng dụng được xây dựng trên NEAR.
Tạo tài khoản với Ví Meteor
Để tạo một ví, hãy mở trang web Ví Meteor và nhập tên người dùng của bạn:

Vâng, đơn giản như vậy.
Các Bước Tiếp Theo
Bây giờ bạn có thể chuyển một số NEAR vào ví của bạn (Nhận NEAR) hoặc tiếp tục khám phá các tính năng khác của Ví Meteor.



Trong ví dụ trên, địa chỉ của chúng tôi là simpleisland-slime.near.
Gửi NEAR
Để gửi NEAR cho ai đó, bạn cần biết ID tài khoản của người nhận (tên người dùng). Khi bạn có nó, bạn có thể gửi NEAR cho họ:

Bạn có thể gửi các mã thông báo khác khi bạn nhấp vào chúng, cùng một menu sẽ mở cho mã thông báo được chọn:
NFTs
Ví Meteor có một trình xem NFT tích hợp, nơi bạn có thể xem NFT của mình trong ví, xem các đặc điểm của họ, giá sàn, chuyển NFT, và nhiều hơn nữa.




Lịch sử giao dịch
Dưới biểu tượng "tia chớp", bạn có thể xem lịch sử giao dịch của mình:


Cài đặt
Cài đặt trong Ví Meteor được đặt ở đây:


	Ứng dụng đã kết nối: Ở đây bạn có thể xem tất cả các ứng dụng mà bạn đã kết nối ví của mình tới (hoặc kỹ thuật, đã tạo một chìa khóa truy cập cuộc gọi chức năng). Bạn cũng có thể thu hồi quyền truy cập cho các ứng dụng này bằng cách nhấn vào "Hủy ủy quyền".


2. Bảo mật và Khôi phục: Phần này của ví chứa cụm từ khóa bí mật của tài khoản của bạn cụm từ khóa. Bạn có thể xem hoặc xuất cụm từ khóa & khóa riêng từ trang này. Nó cũng cung cấp cho bạn một tùy chọn để quản lý Chìa khóa Truy cập Đầy đủ và Chìa khóa Truy cập Cuộc gọi Chức năng của tài khoản của bạn.

3. Bạn cũng có thể cung cấp phản hồi, chia sẻ vấn đề của mình với hỗ trợ kỹ thuật, đặt mật khẩu, xóa tài khoản khỏi ví meteor, và các vấn đề khác từ trang này.
Tìm hiểu sâu hơn tại Tài liệu NEAR
Ví Trust
Ví Trust là một ví phi tập trung và phi tập trung cho phép người dùng lưu trữ tiền điện tử của họ. Tài sản được lưu trữ trong một địa chỉ số có thể truy cập chỉ bởi người dùng, làm cho nó trở thành một cách lưu trữ tài sản số an toàn và hiệu quả. Ví Trust tập trung vào sự đơn giản và dễ sử dụng. Ví này là một ví đa tiền tệ, mã nguồn mở, được cộng đồng điều hành, có khả năng lưu trữ gần như tất cả các loại tiền điện tử. Nó cung cấp cho người dùng một cách tiện lợi để quản lý tiền điện tử của họ và cho phép họ hoàn toàn kiểm soát các khóa riêng của mình.

Ví đã được Binance mua lại và là ví chính thức của sàn giao dịch Binance. Ví cho phép người dùng giữ hoàn toàn quyền kiểm soát tài sản và khóa riêng tư được lưu trữ trên thiết bị của người dùng. Các nhà phát triển cũng có thể xây dựng ứng dụng phi tập trung mà không gặp phải bất kỳ vấn đề nào như chi tiết triển khai cấp thấp. Ví cũng hỗ trợ việc đặt cược trên ví, điều này có nghĩa là người dùng có thể kiếm được phần thưởng trên bất kỳ mã thông báo Proof-of-Stake hoặc Delegated Proof-of-Stake nào được hỗ trợ. Trust Wallet cho phép người dùng kiếm được phần thưởng và liên tục thêm nhiều stablecoin và tiền điện tử hơn.
Bitte Wallet
Mintbase Wallet đã được tái thương hiệu thành Bitte Wallet.

Bitte wallet giúp việc sử dụng công nghệ blockchain dễ dàng hơn bao giờ hết, tất cả nhờ vào một số tính năng thông minh từ blockchain NEAR.
Các Tính Năng Chính:
Quá Trình Đăng Ký Người Dùng Thân Thiện: Với passkeys và trừu tượng tài khoản, Bitte Wallet cung cấp trải nghiệm đăng ký dễ dàng, thường nhanh hơn so với các nền tảng Web2 truyền thống.

Bảo Quản An Toàn Tài Sản: Sử dụng các tính năng sinh học như Face ID hoặc dấu vân tay, Bitte Wallet lưu trữ an toàn các khóa ví trong trình quản lý mật khẩu bạn chọn, đảm bảo bạn hoàn toàn kiểm soát tài sản của mình.

Không Phí Gas: Tận dụng trừu tượng tài khoản và công nghệ giao dịch meta-transaction độc đáo của blockchain NEAR, Bitte Wallet hỗ trợ các giao dịch bao gồm phí gas.

Vì vậy, người dùng Bitte wallet hiện có thể tận hưởng trải nghiệm mượt mà, quen thuộc hơn, tương tự như việc sử dụng các ứng dụng thông thường, mà không gặp phải những rắc rối thông thường của blockchain.
Ví Guarda
Ví Guarda được ra mắt vào năm 2017, và đã trở thành lựa chọn phổ biến cho người dùng tiền điện tử từ các blockchain khác nhau. Đó là một ví dễ sử dụng, thân thiện với người mới bắt đầu, có tính tích hợp với các sàn giao dịch phi tập trung. Ví hỗ trợ nhiều tài khoản và có giao diện đơn giản để quản lý, lưu trữ và giao dịch NEAR.



Guarda là một ví không giữ tài sản đa nền tảng cho phép truy cập an toàn và dễ dàng vào tiền điện tử trên hầu hết các thiết bị bao gồm Windows, Mac OS, iOS, Android và Linux. Ví có tính năng xác thực đa yếu tố, hỗ trợ lưu trữ lạnh và lưu trữ khóa riêng tư trên thiết bị của bạn dưới dạng mã hóa. Một nhược điểm lớn của Ví Guarda là nó hỗ trợ hạn chế cho các loại tiền tệ fiat và NFT.
Ví Coinbase
Ví Coinbase là một ví không giữ tài sản linh hoạt với một loạt các chức năng. Nó có chức năng NFT và DeFi rộng lớn, là lựa chọn lý tưởng cho các nhà giao dịch hoặc nhà đầu tư. Ví tương thích với Android, iOS và hầu hết các trình duyệt web phổ biến dưới dạng tiện ích mở rộng, mang lại trải nghiệm tiện lợi và chuyển đổi mượt mà trên nhiều thiết bị.

Yếu tố chính phân biệt ví này so với các ví khác là truy cập trực tiếp vào nền tảng Coinbase. Ví này tích hợp tốt với các ứng dụng NEAR bao gồm, nhưng không giới hạn ở DeFi, gaming, thị trường NFT và nhiều hơn nữa. Đây là một ví tuyệt vời cho người dùng đến từ Coinbase, vì nó sẽ giúp dễ dàng và mượt mà chuyển đổi vào hệ sinh thái NEAR.




	

	
	
		
			
				Which wallet is the official successor to NEAR Wallet?
			
		

		
					

		
			
			
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Meteor Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Suy nghĩ cuối cùng
Hệ sinh thái của NEAR cho phép người dùng truy cập vào một loạt các NFT, ứng dụng phi tập trung và các giải pháp DeFi. NEAR giải quyết nhược điểm của các blockchain như Ethereum, cung cấp giải pháp cho các vấn đề lâu nay như tắc nghẽn mạng, phí gas cao và phí xử lý chậm. Ví NEAR cho phép người dùng tạo và tương tác với các tài khoản NEAR, cho phép người dùng lưu trữ token NEAR của họ và đặt cược để kiếm phần thưởng. Chúng tôi hy vọng hướng dẫn này cung cấp một số thông tin rõ ràng về cách hoạt động của ví NEAR và các trường hợp sử dụng của nó.
Bình chọn cho ví NEAR yêu thích của bạn!

### กระเป๋า NEAR คืออะไร?
NEAR Wallets คืออุปกรณ์ที่ช่วยให้ผู้ใช้สามารถจัดการ NEAR ของตนได้ โดยสามารถสร้างบัญชี NEAR, ส่งและรับ NEAR, และเข้าถึง dApps ต่าง ๆ บน NEAR Protocol ได้ง่ายดายผ่านอินเทอร์เฟซที่ใช้งานง่าย. กระเป๋า NEAR สามารถเข้าถึงผ่านเว็บแอปพลิเคชันหรือแอปพลิเคชันบนมือถือ โดยใช้ Seed Phrase หรือ Private Key เพื่อเข้าถึงบัญชี NEAR ของตน.

คู่มือเกี่ยวกับ NEAR Wallets 
ในตลาดคริปโตปัจจุบัน Ethereum เป็นแพลตฟอร์มที่ถูกเลือกใช้สำหรับแอปพลิเคชันที่ไม่มีการกำหนด, สัญญาอัจฉริยะ, และการเงินที่ไม่มีการกำหนด อย่างไรก็ตาม, Ethereum มีปัญหาหลายประการที่เป็นอุปสรรค เช่น ค่าธรรมเนียมแก๊สสูงและปัญหาที่สำคัญเกี่ยวกับการขยายขนาด ดังนั้นในขณะที่ Ethereum อาจเป็น "Numero Uno", มีโปรโตคอลหลายรายที่กำลังเกิดขึ้นเพื่อท้าทาย Ethereum ในตลาด

NEAR protocol เป็นหนึ่งในบล็อกเชนที่เกิดขึ้นเป็นผู้ท้าทายจริงใจของ Ethereum ในพื้นที่ ทีมงานที่ NEAR มองไปที่ข้อบกพร่องของ Ethereum และสร้างโปรโตคอลที่เข้าไปตรงในจุดอ่อนที่สุดของมัน: ขาดความสามารถในการขยายขนาดและค่าธรรมเนียมแก๊สสูง NEAR ใช้กระบวนการที่เรียกว่า sharding ทำให้โปรโตคอลสามารถขยายตัวอย่างได้ NEAR ยังสามารถระดมทุนได้มากจากนักลงทุนเสนอแนะที่ใหญ่ที่สุด เช่น a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital และอีกหลายราย ในคู่มือนี้เราจะมองไปที่ NEAR และโดยเฉพาะที่ NEAR wallet
โปรโตคอล NEAR
ก่อตั้งขึ้นในปี 2018 NEAR Protocol เป็นแพลตฟอร์มการพัฒนาที่ไม่มีการกำหนดที่ออกแบบมาเพื่อสร้างสภาพแวดล้อมที่เหมาะสมและใกล้เคียงกับความสมบูรณ์สำหรับแอปพลิเคชันที่ไม่มีการกำหนด (dApps) และสัญญาอัจฉริยะ NEAR ถูกสร้างหลังจากการวิเคราะห์ข้อบกพร่องของโปรโตคอลที่มีอยู่โดยเฉพาะ Ethereum โปรโตคอลเน้นการแก้ไขปัญหาเหล่านี้และมองหาว่าจะเป็นแพลตฟอร์มที่เหมาะสมสำหรับแอปพลิเคชันที่ไม่มีการกำหนด (dApps) และการเงินที่ไม่มีการกำหนด (DeFi) การใช้ sharding ของ NEAR ทำให้โปรโตคอลสามารถขยายตัวอย่างได้และแก้ไขปัญหาเรื่องการขยายขนาดที่พบอยู่ในพื้นที่

บล็อกเชน Proof-of-Stake ของ NEAR เป็นมิตรต่อนักพัฒนาโดยอย่างมากเนื่องจากมีราคาถูกและมีการขยายขนาดอย่างมาก และนักพัฒนาสามารถสร้างแอปพลิเคชันที่ไม่มีการกำหนดได้อย่างไม่มีปัญหา โปรโตคอล NEAR ยังมีคุณสมบัติอื่น ๆ เช่น NEAR wallet และส่วนอื่น ๆ การใช้กลไกความเห็น Doomslug ของ NEAR ทำให้บล็อกสามารถบรรจบได้ในไม่กี่วินาที บล็อกเชนอื่น ๆ มักจะทำให้การประมวลผลเป็นส่วนกลาง จำกัดความสามารถในการใช้งานไปยังฮาร์ดแวร์ระดับสูงมาก ในขณะที่วิธีการนี้เพิ่มประสิทธิภาพในการถ่ายทอดข้อมูล แต่ทำเช่นนั้นเพียงชั่วคราว NEAR สามารถขยายตัวเป็นเส้นตรงรองรับพันล้านธุรกรรมในลักษณะที่ไม่มีการกำหนด

NEAR ได้ถูกสร้างขึ้นโดย NEAR Collective ชุมชนของนักวิจัยและนักพัฒนา NEAR Collective มุ่งเน้นการพัฒนาและปรับปรุงโปรโตคอลอย่างต่อเนื่อง ชุมชนยังทำงานกับโค้ดเริ่มต้นของ NEAR Protocol และการปฏิบัติของ NEAR Network ในขณะที่ NEAR Collective อยู่เบื้องหลังการพัฒนาของ NEAR Protocol โปรโตคอลเหล่านี้ทำงานอย่างเอิกเข้าและเป็นอิสระอย่างสมบูรณ์ โดยที่ NEAR Collective ไม่สามารถปิดการใช้งานได้
ข้อดีของ NEAR Protocol
	ผู้ใช้ NEAR ไม่ต้องใช้ส่วนขยายเบราว์เซอร์หรือคีย์ที่ซับซ้อนเพื่อลงทะเบียน การลงทะเบียนด้วยอีเมลและรหัสผ่านง่ายๆ ก็เพียงพอ
	สัญญาอัจฉริยะ NEAR เข้ากันได้กับ WebAssembly Virtual Machine (WASM)
	โปรโตคอลช่วยให้นักพัฒนาสามารถนำแอปพลิเคชันบล็อกเชนที่มีประสิทธิภาพสูงและสามารถขยายได้
	ค่าธรรมเนียมแก๊สเพียงเพียงเศษเทียบกับ Ethereum และอื่นๆ

กระเป๋าสตางค์คริปโตคืออะไร
ก่อนที่จะไปยังกระเป๋าสตางค์ NEAR ควรเข้าใจว่ากระเป๋าสตางค์คืออะไร ในคำจำกัดความง่ายที่สุด กระเป๋าสตางค์คริปโตเก็บคีย์ส่วนตัวของคุณอย่างปลอดภัยเพื่อให้สามารถเข้าถึงสกุลเงินดิจิทัลของคุณได้อย่างปลอดภัยและสะดวกสบาย คุณยังสามารถใช้กระเป๋าสตางค์คริปโตเพื่อดำเนินการธุรกรรม ส่งและรับสกุลเงินดิจิทัล หรือใช้สกุลเงินดิจทัลของคุณ ในการเลือกกระเป๋าสตางค์คริปโต คุณมีหลายตัวเลือกให้เลือก ซึ่งรวมถึงกระเป๋าสตางค์กระดาษ กระเป๋าสตางค์ฮาร์ดแวร์ และกระเป๋าสตางค์ออนไลน์
กระเป๋าสตางค์ร้อน
กระเป๋าสตางค์ร้อนเป็นกระเป๋าสตางค์ที่อยู่ออนไลน์ที่ช่วยให้ผู้ใช้สามารถโอนสกุลเงินดิจิทัลของพวกเขาได้อย่างรวดเร็ว ส่วนใหญ่แล้ว แลกเปลี่ยนออนไลน์มักมีกระเป๋าสตางค์ของตนเองที่ผู้ใช้สามารถเข้าถึง กระเป๋าสตางค์ร้อนง่ายต่อการเข้าถึงผ่านมือถือหรือคอมพิวเตอร์โต๊ะ ในขณะที่กระเป๋าสตางค์ร้อนมีความสะดวกสบายในการเชื่อมต่อ แต่ก็อยู่ในความเสี่ยงจากอุปกรณ์ที่เสี่ยงต่อการโจมตี เช่น การโจมตีด้วยการแฮ็ก กระเป๋าสตางค์เดสก์ท็อป กระเป๋าสตางค์ออนไลน์ และกระเป๋าสตางค์มือถือเป็นตัวอย่างของกระเป๋าสตางค์ร้อน
กระเป๋าสตางค์เย็น
กระเป๋าสตางค์เย็นหรือกระเป๋าสตางค์ฮาร์ดแวร์เป็นอุปกรณ์ที่คล้ายกับอุปกรณ์ USB ที่ผู้ใช้สามารถเก็บคีย์ของพวกเขาได้ กระเป๋าสตางค์สามารถพกพาได้และสามารถเชื่อมต่อกับแล็ปท็อป/เดสก์ท็อปเมื่อผู้ใช้ต้องการเข้าถึงสกุลเงินดิจิทัลของพวกเขา กระเป๋าสตางค์ฮาร์ดแวร์มีความน้อยเสี่ยงต่อการโจมตีเช่นการแฮ็กหรือการโจมตีที่อาจเกิดขึ้นออนไลน์
กระเป๋าสตางค์กระดาษ
กระเป๋าสตางค์กระดาษเป็นชิ้นกระดาษที่พิมพ์มีคีย์สาธารณะและคีย์ส่วนตัวของคุณ คีย์สามารถเข้าถึงได้เฉพาะผ่านรหัส QR กระเป๋าสตางค์กระดาษใช้เก็บจำนวนสกุลเงินดิจิทัลที่สำคัญเนื่องจากถือว่ามีความปลอดภัยมาก
กระเป๋าสตางค์เย็นที่ดีที่สุดสำหรับ NEAR
Ledger Nano S Plus


กระเป๋าสตางค์เย็นที่ดีที่สุดสำหรับ NEAR คืออุปกรณ์ ledger ใดก็ได้ โดยที่เครื่อง ledger รุ่นยอดนิยมที่สุดคือ Ledger Nano S Plus อุปกรณ์ ledger เป็นมาตรฐานอุปกรณ์เย็นเมื่อเทียบกับการเก็บสกุลเงินดิจิทัล และมีความเข้ากันได้กับเหรียญและโทเคนมากกว่า 5,500 รายการ มีแอปพลิเคชันคู่ความเรียบร้อยที่เรียกว่า Ledger Live ซึ่งมีคุณสมบัติมากมาย เช่น การซื้อ การขาย การสลับและการจำนวนสกุลเงินดิจิทัล รวมถึงความเข้ากันได้กับ NFT ใดๆ อีกด้วย นอกจากนี้ ledger ยังเข้ากันได้กับหลายกระเป๋าสตางค์ร้อนที่ได้รับการพูดถึงในบทความนี้

 
กระเป๋าสตางค์ร้อนยอดนิยม 9 รายการสำหรับ NEAR
MyNearWallet
ประวัติและพื้นที่ที่สำคัญของ NEAR Wallet
NEAR Wallet เวอร์ชันเก่ามีปัญหาที่เกิดซ้ำๆ และปัญหาด้านการออกแบบตั้งแต่เปิดตัวในปี 2020 นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากนี้ นอกจากການເລີ່ມຕົ້ນບັນຊີໃຊ້ບໍລິການ MyNearWallet
MyNearWallet ໃຊ້ການສ້າງບັນຊີ NEAR ເພື່ອເຂົ້າໃຊ້ຄວາມທີ່ເລີ່ມຕົ້ນທີ່ກ່ຽວນັ້ນ.

 	ເພີ່ມບັນຊີການໄປທີ່ www.mynearwallet.com. ຖ້າຫາກທ່ານເປັນບັນຊີ NEAR ແລະຕ້ອງການຍືນຍາແລ້ວຕ້ອງເລືອກ Import Existing Account ແລະຕິດຕໍ່ການການຮັບບັນຊີ. ພວກເຮົາຈະສະຫນາບການສ້າງບັນຊີໃໝ່ໃນການຂໍ້ມູນນີ້. ເລືອກຕົວຢ່າງ "ສ້າງບັນຊີ" ຕົວຢ່າງ.


2. ພິມຊື່ບັນຊີທີ່ຕ້ອງການໃຊ້ໃນສໍານັ້ນ "ຊື່ບັນຊີ", ຕໍ່ກັບ "ຈອງຊື່ບັນຊີຂອງຂ້ອຍ" ແລະຄລິກ "ຈອງຊື່ບັນຊີຂອງຂ້ອຍ".

3. ໃສ່ລະຫັດຜ່ານສໍາລັບບັນຊີ NEAR ຂ້ອຍ, ກະລຸນາເປັນລະຫັດຜ່ານທີ່ຖືກສະຫນາບເຂົ້າໃຊ້ກັບບັນຊີຂອງທ່ານແລະການເຮັດເງິນດ້ວຍການການການ. ການກວດສອບການເລືອກສີສັງການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການການ5. คุณจะสามารถเลือกจาก 2 ตัวเลือก: "Secure Passphrase" หรือ "Ledger Hardware Wallet" เลือก "Secure Passphrase" (เราจะแสดงวิธีการตั้งค่าด้วยอุปกรณ์ Ledger ในขั้นตอนถัดไปในคู่มือนี้)

6. MyNearWallet จะสร้างรหัสผ่านที่ประกอบด้วยคำ 12 คำสุ่ม คุณสามารถสร้างใหม่หากคุณไม่ชอบของคุณ โปรดตรวจสอบว่าคุณได้เขียนรหัสผ่านของคุณลงไปหรือเก็บไว้ในโปรแกรมจัดการรหัสผ่าน เช่น LastPass เนื่องจากคุณจะต้องใช้มันเพื่อเข้าถึงบัญชีของคุณ คลิกต่อเมื่อคุณพร้อม

7. จากนั้นคุณจะถูกขอให้ป้อนคำหนึ่งจากรหัสผ่านของคุณ ป้อนคำในช่องที่ให้
8. ขั้นตอนสุดท้ายในการตั้งค่าบัญชีของคุณคือการซื้อ NEAR tokens หรือให้เพื่อนๆ โอนมันเข้าสู่บัญชีของคุณ
a. คุณสามารถคลิกที่ปุ่มนี้เพื่อเข้าถึงวิธีการชำระเงินสำหรับการซื้อ NEAR

b. ขอให้เพื่อนๆ ส่ง NEAR ให้คุณ
i. คลิกที่ที่อยู่กระเป๋าเงินของคุณที่มุมขวาบนของหน้าจอ

ii. คัดลอกที่อยู่ของคุณและส่งให้เพื่อนๆ

iii. เมื่อ NEAR ถูกส่งไปยังที่อยู่ของคุณ การตั้งค่าจะเสร็จสมบูรณ์

การสร้างบัญชีด้วย Ledger

 	ทำซ้ำขั้นตอน 1-4 จากส่วนก่อนหน้าของคู่มือนี้
 	เลือก "Ledger Hardware Wallet" option


3. อ้างถึงคู่มือที่ เว็บไซต์สนับสนุนลูกค้าของ Ledger สำหรับคำแนะนำเพิ่มเติม



	

	
	
		
			
				What cold/hardware wallet brand is recommended for storing NEAR?
			
		

		
					

		
			
			
			
			Trezor
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Ledger
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Here Wallet

HERE Wallet เป็นกระเป๋าเงินมือถือที่ไม่ใช่ความมั่นคงสำหรับ NEAR Protocol ด้วยการใช้กระเป๋าเงินนี้ผู้ใช้สามารถโอน รับเงิน สเเค และสวอพ NEAR รวมถึงโทเคนที่เป็นฟังจิเบิลและไม่เป็นฟังจิเบิลที่ขึ้นอยู่กับ NEAR มีโปรโตคอลสเเต็กกิ้งที่เป็นของเหลวหมายความว่าผู้ใช้สามารถถอน NEAR จากการเสแกทุกเมื่อ ผลตอบแทนจากการเสแกประมาณ ~9% APY กระเป๋าเงินยังมีเอกสารสนับสนุนลูกค้าสำหรับผู้ใช้ที่ต้องการอ้างอิงเมื่อพบปัญหา

HERE Wallet มีคุณสมบัติด้านความปลอดภัยหลายอย่าง เช่น การจัดเก็บรหัสผ่านบนอุปกรณ์ ไบโอเมตริกส์ และการเข้าถึงพิน ทำให้เป็นหนึ่งในกระเป๋าเงินที่เหมาะกับโทรศัพท์ที่มีมากที่สุดในตลาด วลีดฟราสถูกจัดเก็บบนอุปกรณ์โดยท้องถิ่น อย่างไรก็ตามกระเป๋าเงินยังมีคุณสมบัติการรวมกับกระเป๋าเงินฮาร์ดแวร์ Ledger และ HITO สำหรับผู้ที่ต้องการความปลอดภัยเพิ่มเติม กระเป๋าเงินยังจะส่งการแจ้งเตือนความปลอดภัยออกไปยังผู้ใช้เมื่อพบกิจกรรมที่น่าสงสัยและได้รับการตรวจสอบอย่างอิสระโดย OtterSec
Sender Wallet


Sender Wallet เป็นกระเป๋าเงินส่วนขยายเบราว์เซอร์ที่สร้างขึ้นสำหรับ NEAR protocol ซึ่งมีให้ใช้เป็นแอปพลิเคชันเช่นกัน มีการเปิดตัวในเดือนกุมภาพันธ์ 2022 และกำลังได้รับความนิยมในหมู่ผู้ใช้ NEAR สำหรับคุณสมบัติหลากหลาย เช่น รายชื่อดำของที่อาจเป็นที่อยู่ที่ไม่ดี Ledger support NFT collectibles การแลกเปลี่ยนโทเคน และการเสแก

หากคุณกังวลเกี่ยวกับความปลอดภัย Sender มีการปกป้องคุณ ได้รับการตรวจสอบโดย SlowMist บริษัทรักษาความปลอดภัยชั้นนำ และมันยังมอบรางวัลค่าของข้อผิดพลาดอย่างสม่ำเสมอเพื่อให้มั่นใจว่าความปลอดภัยอยู่ในสภาพที่ดี ด้วยนักลงทุนอย่าง Binance Labs และ Crypto.com Capital Sender Wallet ได้รับการสนับสนุนจากอุตสาหกรรมมากมายและมั่นใจว่าจะเป็นส่วนหนึ่งในนิวระบบ NEAR
Meteor Wallet


Meteor Wallet เป็นกระเป๋าเงินส่วนขยายเบราว์เซอร์และเว็บกระเป๋าเงินที่สร้างขึ้นสำหรับนิวระบบ NEAR ที่เปิดตัวในไตรมาสที่ 3 ปี 2022 กระเป๋าเงินใหม่นี้มีอินเตอร์เฟซที่ intuitive และคุณสมบัติที่น่าตื่นเต้นมากมาย เช่น การลงทะเบียนง่าย การกู้คืนง่าย คุณสมบัติ NFT ขั้นสูง และอื่น ๆ อีกมากมาย ทุกอย่างในกระเป๋าเงินถูกเข้ารหัสและไม่มีการบันทึกอะไรเลย เพื่อให้คุณมีความสงบใจว่าสินทรัพย์คริปโตของคุณปลอดภัย กระเป๋าเงินมีทีมสนับสนุนลูกค้าที่ยอดเยี่ยมพร้อมมีคู่มือที่เขียนอย่างละเอียดสำหรับผู้ใช้ใหม่และผู้ใช้ขั้นสูงMeteor Wallet เป็นหนึ่งในกระเป๋าเงิน NEAR ที่ง่ายที่สุดและใช้งานง่ายที่สุด นอกจากนี้ยังเป็นกระเป๋าเงินเว็บที่สามารถใช้เป็นส่วนขยาย Chrome ปัจจุบันมีการทำงานกับโปรโตคอล NEAR เท่านั้นเนื่องจากถูกออกแบบมาเพื่อวัตถุประสงค์นั้น บางคุณสมบัติของ Meteor รวมถึงการจัดการเงิน, การโอน, การซื้อและการสลับ NEAR รวมถึงเหรียญและโทเคนที่สามารถแลกเปลี่ยนที่สร้างขึ้นบน NEAR กระเป๋าเงินนี้ยังเปิดโอกาสให้เข้าถึงนิวอีคอสิสเต็มอื่น ๆ และให้เข้าถึง dApps ที่สร้างขึ้นบน NEAR
การสร้างบัญชีด้วย Meteor Wallet
เพื่อสร้างกระเป๋าเงิน ให้เปิดMeteor Wallet เว็บไซต์และใส่ชื่อผู้ใช้ของคุณ:

ใช่ ง่ายแค่เท่านั้น
ขั้นตอนถัดไป
ตอนนี้คุณสามารถย้าย NEAR บางส่วนในกระเป๋าเงินของคุณ (การรับ NEAR) หรือดำเนินการสำรวจคุณสมบัติอื่น ๆ ของ Meteor Wallet



ในตัวอย่างด้านบน ที่อยู่ของเราคือ simpleisland-slime.near.
การส่ง NEAR
เพื่อส่ง NEAR ให้คุณทราบรหัสบัญชีผู้รับ (ชื่อผู้ใช้) เมื่อคุณมีรหัสนั้น คุณสามารถส่ง NEAR ให้พวกเขา:

คุณสามารถส่งโทเคนอื่น ๆ เมื่อคุณคลิกที่พวกเขา จะมีเมนูเดียวกันเปิดขึ้นสำหรับโทเคนที่เลือก:
NFTs
Meteor Wallet มีตัวดู NFT ในตัว ที่คุณสามารถดู NFT ของคุณในกระเป๋าเงิน ดูลักษณะเฉพาะของพวกเขา ราคาพื้น, โอน NFT และอื่น ๆ




ประวัติธุรกรรม
ภายใต้เครื่องหมาย "ลูกฟ้า" คุณสามารถดูประวัติธุรกรรมของคุณ:


การตั้งค่า
การตั้งค่าใน Meteor Wallet ตั้งอยู่ที่นี่:


	แอปที่เชื่อมต่อ: ที่นี่คุณสามารถดูแอปทั้งหมดที่คุณเชื่อมต่อกับกระเป๋าเงินของคุณ (หรือเทคนิคลี, สร้าง คีย์การเรียกใช้ฟังก์ชัน). คุณยังสามารถเพิกเฉยต่อแอปเหล่านี้ได้โดยการคลิก "ยกเลิกอนุญาต"


2. ความปลอดภัยและการกู้คืน: ส่วนนี้ของกระเป๋าเงินมีคำสั่ง วลีเมล็ดพันธุ์ ของบัญชีของคุณ คุณสามารถดูหรือส่งออกเมล็ดพันธุ์และคีย์ส่วนตัวของคุณจากหน้านี้ มันยังให้คุณตัวเลือกในการจัดการ คีย์การเข้าถึงเต็มรูปแบบ และ คีย์การเข้าถึงฟังก์ชันการเรียกใช้ ของบัญชีของคุณ

3. คุณยังสามารถให้คำติชม, แชร์ปัญหาของคุณกับฝ่ายสนับสนุนทางเทคนิค, ตั้งรหัสผ่าน, ลบบัญชีออกจากกระเป๋าเงิน meteor, และอื่นๆ จากหน้านี้
ศึกษาเพิ่มเติมที่ NEAR Docs
Trust Wallet
Trust Wallet เป็นกระเป๋าเงินที่ไม่ใช่การจัดเก็บและกระเป๋าเงินที่กระจายทั่วทั้งที่อนุญาตให้ผู้ใช้เก็บเงินดิจิตอลของพวกเขา สินทรัพย์ถูกเก็บไว้ในที่อยู่ดิจิตอลที่สามารถเข้าถึงได้เฉพาะโดยผู้ใช้ ทำให้เป็นวิธีที่ปลอดภัยและมีประสิทธิภาพในการเก็บสินทรัพย์ดิจิตอล Trust wallet ให้ความสำคัญกับความง่ายและความสะดวกในการใช้งาน กระเป๋าเงินเป็นเปิดโค้ง, มีชุมชนที่ขับเคลื่อนด้วยกัน, กระเป๋าเงินหลายสกุลเงินที่สามารถเก็บสตอร์สกุลเงินทั้งหมดเกือบทั้งหมด มันให้ผู้ใช้วิธีการจัดการสินทรัพย์ดิจิตอลของพวกเขาอย่างสะดวกและอนุญาตให้พวกเขาควบคุมคีย์ส่วนตัวของพวกเขาอย่างสมบูรณ์

กระเป๋าเงินถูกซื้อโดย Binance และเป็นกระเป๋าเงินอย่างเป็นทางการของแลกเปลี่ยน Binance กระเป๋าเงินช่วยให้ผู้ใช้รักษาการควบคุมทั้งหมดของสินทรัพย์และคีย์ส่วนตัวที่เก็บไว้บนอุปกรณ์ของผู้ใช้ นักพัฒนายังสามารถสร้าง dApps โดยไม่มีปัญหาใด ๆ เช่น รายละเอียดการดำเนินการระดับต่ำ กระเป๋าเงินยังรองรับการ stake บนกระเป๋าเงินซึ่งหมายความว่าผู้ใช้สามารถรับรางวัลได้บนสินทรัพย์ Proof-of-Stake หรือ Delegated Proof-of-Stake ที่รองรับ  Trust Wallet ช่วยให้ผู้ใช้ได้รับรางวัลและเพิ่ม stablecoins และ cryptocurrencies เรื่อย ๆ
กระเป๋า Bitte
Mintbase Wallet ได้เปลี่ยนชื่อเป็น Bitte Wallet.

กระเป๋า Bitte ทำให้การใช้เทคโนโลยี blockchain ง่ายขึ้นมาก ๆ ด้วยคุณสมบัติที่ฉลาดจาก NEAR blockchain
คุณสมบัติสำคัญ:
การลงทะเบียนผู้ใช้งานง่าย: ด้วย passkeys และ account abstraction Bitte Wallet มีประสบการณ์การลงทะเบียนที่ไม่มีข้อบกพร่อง บ่อยครั้งเร็วกว่าแพลตฟอร์ม Web2 แบบดั้งเดิม

การเก็บรักษาสินทรัพย์อย่างปลอดภัย: โดยใช้คุณสมบัติชีวภาพเช่น Face ID หรือ ลายนิ้วมือ Bitte Wallet เก็บคีย์กระเป๋าเงินอย่างปลอดภัยในตัวจัดการรหัสผ่านที่คุณเลือก ทำให้คุณมีควบคุมทั้งหมดของสินทรัพย์ของคุณ

ไม่มีค่าธรรมเนียม Gas: โดยใช้ account abstraction และเทคโนโลยี meta-transaction ที่เป็นเอกลักษณ์ของ NEAR blockchain Bitte Wallet สนับสนุนการทำธุรกรรมที่ครอบคลุมค่าธรรมเนียม Gas

ดังนั้น ผู้ใช้ Bitte wallet ตอนนี้สามารถเพลิดเพลินกับประสบการณ์ที่นุ่มนวลและน่าเชื่อถือมากขึ้น คล้ายกับการใช้แอปพลิเคชันปกติโดยไม่มีปัญหา blockchain ที่เป็นปกติ
กระเป๋า Guarda
กระเป๋า Guarda เริ่มให้บริการในปี 2017 และกลายเป็นทางเลือกยอดนิยมสำหรับผู้ใช้ crypto จาก blockchain ต่าง ๆ มันเป็นกระเป๋าเงินที่ใช้ง่ายและเหมาะสำหรับผู้เริ่มต้น มีคุณสมบัติการผสมกับตลาดแบบกระจาย กระเป๋าเงินรองรับบัญชีหลายรายการ และมีอินเตอร์เฟซที่ง่ายสำหรับการจัดการ เก็บรักษา และซื้อขาย NEAR



Guarda เป็นกระเป๋าเงินที่ใช้ได้บนหลายแพลตฟอร์ม และไม่ใช่การเก็บรักษา ที่ช่วยให้เข้าถึง crypto ได้อย่างปลอดภัยและง่ายบนอุปกรณ์หลายรายการ เช่น Windows, Mac OS, iOS, Android และ Linux กระเป๋าเงินมีคุณสมบัติการตรวจสอบหลายขั้นตอน การสนับสนุนการเก็บรักษาแบบเย็น ๆ และเก็บคีย์ส่วนตัวบนอุปกรณ์ของคุณในรูปแบบที่เข้ารหัส จุดอ่อนสำคัญของ Guarda Wallet คือมีการสนับสนุนที่จำกัดสำหรับสกุลเงินเงินบาทและ NFTs
กระเป๋า Coinbase
กระเป๋า Coinbase เป็นกระเป๋าเงินที่ไม่ใช่การเก็บรักษาที่ยืดหยุ่นมีระบบความสามารถที่หลากหลาย มีความสามารถทางด้าน NFT และ DeFi ที่กว้างขวาง ทำให้เหมาะสำหรับนักซื้อขายหรือนักลงทุน กระเป๋าเงินเข้ากันได้กับ Android, iOS และเบราว์เซอร์เว็บที่นิยมใช้งานเป็นส่วนขยาย ให้ประสบการณ์ที่สะดวกและการเปลี่ยนแปลงอย่างไม่มีปัญหาระหว่างอุปกรณ์หลายรายการ

ปัจจัยหลักที่แยกแยะวอลเล็ตนี้จากอื่น ๆ คือการเข้าถึงแพลตฟอร์ม Coinbase โดยตรง วอลเลตนี้มีการบูรณาการที่ยอดเยี่ยมกับ NEAR dApps รวมถึง แต่ไม่จำกัดเฉพาะกับ DeFi, เกม, ตลาด NFT และอื่น ๆ นี่เป็นวอลเลตที่ยอดเยี่ยมสำหรับผู้ใช้ที่มาจาก Coinbase เนื่องจากจะช่วยให้การเปลี่ยนแปลงไปสู่นิเวศ NEAR เป็นเรื่องง่ายและเรียบง่าย

ความคิดเห็นสุดท้าย
นิเวศมีระบบนิเวศที่ช่วยให้ผู้ใช้สามารถเข้าถึง NFTs, แอปพลิเคชันที่ไม่มีกลาง, และ DeFi โซลูชัน นิเวศแอดเดรสปัญหาข้อบกพร่องของบล็อกเชนเช่น Ethereum โดยให้การแก้ไขปัญหาที่มีมานานเช่นการแอบแอบ, ค่าธรรมเนียมแก๊สสูง, และค่าธรรมเนียมการประมวลผลช้า วอลเลต NEAR ช่วยให้ผู้ใช้สามารถสร้างและปฏิสัมพันธ์กับบัญชี NEAR อนุญาตให้ผู้ใช้เก็บ NEAR โทเคนของตนและเสาะเพื่อรับรางวัล เราหวังว่าคู่มือนี้จะให้ความชัดเจนเกี่ยวกับการทำงานของวอลเลต NEAR และการใช้งานของมัน
โหวตสำหรับวอลเลต NEAR ที่คุณชื่นชอบ!

### Ví NEAR

Hướng dẫn sử dụng Ví NEAR 
Trong thị trường tiền điện tử hiện tại, Ethereum là nền tảng được lựa chọn cho các ứng dụng phi tập trung, hợp đồng thông minh và tài chính phi tập trung. Tuy nhiên, Ethereum đang gặp phải một số vấn đề như phí gas cao và vấn đề đáng kể về khả năng mở rộng. Vì vậy, trong khi Ethereum có thể là "Numero Uno", có nhiều giao thức khác đang nổi lên để thách thức Ethereum trên thị trường. 

Giao thức NEAR là một trong những chuỗi khối đã nổi lên như một đối thủ thực sự đối với sự thống trị của Ethereum trong không gian này. Nhóm tại NEAR đã xem xét những điểm yếu của Ethereum và tạo ra một giao thức nhắm thẳng vào điểm yếu nổi bật nhất của nó: thiếu khả năng mở rộng và phí gas cao. NEAR sử dụng quá trình gọi là sharding, cho phép giao thức mở rộng theo cấp số nhân. NEAR cũng đã quản lý được việc huy động vốn đáng kể từ một số nhà đầu tư mạo hiểm lớn nhất, bao gồm a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital và nhiều hơn nữa. Trong hướng dẫn này, chúng ta sẽ tìm hiểu về NEAR, và đặc biệt là Ví NEAR. 
Giao thức NEAR
Được thành lập vào năm 2018, Giao thức NEAR là một nền tảng phát triển phi tập trung được thiết kế để tạo ra một môi trường mượt mà và gần như hoàn hảo cho các ứng dụng phi tập trung (dApps) và hợp đồng thông minh. NEAR được tạo ra sau khi phân tích những điểm yếu của các giao thức hiện có, đặc biệt là Ethereum. Giao thức tập trung vào giải quyết những vấn đề này, và đang muốn trở thành nền tảng lựa chọn cho Các Ứng dụng Phi tập trung (dApps) và Tài chính Phi tập trung (DeFi). Việc sử dụng sharding của NEAR cho phép giao thức mở rộng theo cấp số nhân, giải quyết vấn đề về khả năng mở rộng phổ biến trong không gian này. 

Blockchain Proof-of-Stake của NEAR rất thân thiện với nhà phát triển, nhờ vào việc giá thấp và khả năng mở rộng cao, và nhà phát triển có thể dễ dàng tạo ra các ứng dụng phi tập trung. Giao thức NEAR cũng có một số tính năng khác, như Ví NEAR và các thành phần khác. Trong bài viết này, chúng ta sẽ tập trung vào Ví NEAR, nhưng sẽ nói thêm về điều đó sau. NEAR cũng sử dụng cơ chế đồng thuận Doomslug, cho phép các khối đạt được sự hoàn thiện trong vài giây. Các chuỗi khối khác thường tập trung xử lý, giới hạn khả năng sử dụng của chúng cho phần cứng cực kỳ cao cấp. Mặc dù phương pháp này tăng cường hiệu suất, nhưng chỉ là tạm thời. NEAR có khả năng mở rộng theo cấp số nhân, hỗ trợ hàng tỷ giao dịch một cách phi tập trung. 

NEAR đã được tạo ra bởi NEAR Collective, một cộng đồng các nhà nghiên cứu và nhà phát triển. Trọng tâm của NEAR Collective là phát triển liên tục và cải thiện giao thức. Collective cũng đã làm việc trên mã nguồn ban đầu của Giao thức NEAR và triển khai Mạng NEAR. Trong khi NEAR Collective đứng sau việc phát triển của Giao thức NEAR, cái sau hoạt động hoàn toàn độc lập và hoàn toàn phi tập trung, với thậm chí NEAR Collective cũng không thể tắt nó. 
Ưu điểm của Giao thức NEAR
	Người dùng NEAR không cần bất kỳ tiện ích mở rộng trình duyệt phức tạp hoặc khóa để đăng ký. Một địa chỉ email và mật khẩu đơn giản là đủ để đăng ký.
	Hợp đồng thông minh NEAR tương thích với Máy ảo WebAssembly (WASM).
	Giao thức cho phép các nhà phát triển triển khai ứng dụng blockchain có khả năng mở rộng và hiệu suất cao.
	Một phần nhỏ phí gas so với các nền tảng khác như Ethereum.

Wallet Tiền Điện Tử Là Gì
Trước khi chuyển sang ví NEAR, quan trọng là hiểu rõ ví là gì. Đơn giản nhất, ví tiền điện tử an toàn lưu trữ các khóa riêng tư của bạn, đảm bảo rằng tiền điện tử của bạn an toàn và dễ truy cập. Bạn cũng có thể sử dụng ví tiền điện tử để thực hiện giao dịch, gửi và nhận tiền điện tử, hoặc thậm chí tiêu tiền điện tử của bạn. Khi chọn ví tiền điện tử, bạn có nhiều lựa chọn. Đó là ví giấy, ví cứng và ví trực tuyến.
Ví Nóng
Ví nóng là các ví trực tuyến cho phép người dùng chuyển tiền điện tử của họ nhanh chóng. Hầu hết các sàn giao dịch trực tuyến có ví của riêng họ mà người dùng có thể truy cập. Ví nóng dễ truy cập thông qua điện thoại di động hoặc máy tính để bàn. Mặc dù ví nóng cung cấp kết nối dễ dàng, chúng cũng có nguy cơ từ các mối đe dọa như hack. Ví máy tính để bàn, ví trực tuyến và ví di động là ví nóng.
Ví Lạnh
Ví lạnh hoặc ví cứng là một thiết bị tương tự như thiết bị USB nơi người dùng có thể lưu trữ các khóa của họ. Ví có thể mang đi và kết nối với máy tính xách tay/máy tính để bàn bất cứ khi nào người dùng muốn truy cập tiền điện tử của họ. Ví cứng ít bị ảnh hưởng hơn bởi các mối đe dọa như hack hoặc bất kỳ cuộc tấn công độc hại nào khác có thể xảy ra trực tuyến.
Ví Giấy
Ví giấy về cơ bản là một tờ giấy in chứa khóa công khai và khóa riêng tư của bạn. Các khóa chỉ có thể truy cập thông qua mã QR. Ví giấy được sử dụng để lưu trữ một lượng lớn tiền điện tử vì chúng được coi là cực kỳ an toàn.
Ví Lạnh Tốt Nhất Cho NEAR
Ledger Nano S Plus


Ví lạnh tốt nhất cho NEAR là bất kỳ thiết bị ledger nào, với Ledger Nano S Plus là phổ biến nhất. Các thiết bị ledger là tiêu chuẩn ngành khi nói đến lưu trữ tiền điện tử trong ví lạnh, và chúng tương thích với hơn 5.500 đồng tiền và token. Chúng đi kèm với ứng dụng đồng hành gọi là Ledger Live có nhiều tính năng hữu ích như mua, bán, đổi và đặt cược tiền điện tử, cùng với khả năng tương thích với gần như mọi NFT. Ngoài ra, ledger tương thích với nhiều ví nóng được thảo luận trong bài viết này.

 
9 Ví Nóng Tốt Nhất Cho NEAR
MyNearWallet
Lịch sử và Ví Di Truyền
Ví NEAR di truyền đã gặp nhiều lỗi tái diễn, vấn đề và vấn đề thiết kế kể từ khi ra mắt vào năm 2020. Ngoài ra, hệ sinh thái NEAR được sử dụng bởi một loạt người dùng khác nhau có nhu cầu và sở thích khác nhau. Cuối cùng, các nhà phát triển NEAR quyết định rằng hệ sinh thái NEAR sẽ tốt hơn nếu không có ví chính thức, và các ứng dụng phi tập trung sẽ được khuyến khích sử dụng một bộ chọn ví. Quyết định này được đưa ra để tăng cường phân quyền và truyền cảm hứng cho sự cạnh tranh lành mạnh trên toàn hệ sinh thái dẫn đến nhiều sáng tạo trong các sản phẩm cuối cùng.

Ra mắt vào năm 2022, MyNearWallet là người kế nhiệm chính thức của hệ sinh thái NEAR. Kikimora Labs bắt đầu phát triển nó từ cùng một mã nguồn mở như ví NEAR di truyền. Hiện họ đang làm việc để cải thiện các tính năng cũ, thêm nhiều tính năng mới, cải thiện bảo mật, sửa lỗi và cải thiện giao diện toàn diện. Trong những ngày đầu tiên, MyNearWallet trông gần như giống hệt ví di truyền, nhưng với sự làm việc chăm chỉ và tận tâm, đội ngũ phát triển đã có thể cải thiện giao diện, sửa lỗi, giải quyết vấn đề bảo mật và thêm nhiều tính năng mới như đã hứa.




	

	
	
		
			
				What is the most secure type of crypto wallet
			
		

		
					

		
			
			
			
			Hot Wallet
		
			
			Cold Wallet
		
			
			Paper Wallet
		
			
			Custodial Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tổng Quan Sản Phẩm
MyNearWallet cho phép người dùng lưu trữ, đổi, giao dịch và đặt cược token NEAR và tài sản tương thích như NFT một cách an toàn. Nó hỗ trợ tất cả các tiêu chuẩn token NEAR mới nhất như tiêu chuẩn NEP-141 (FT), NEP-148 (FT), NEP-171 (NFT) và NEP-177 (NFT). MyNearWallet là người kế nhiệm chính thức của ví NEAR di truyền. Ngoài ra, ví này cũng có sẵn các giao dịch wNEAR và USN, cũng như cách mua NEAR. Một cách khác để kiếm tiền bằng cách sử dụng MyNearWallet là bằng cách đặt cược NEAR để giúp blockchain xác thực giao dịch, mang lại lợi nhuận khoảng ~10% APY.

MyNearWallet không chỉ là một ví khác; nó cũng phục vụ như một cổng vào hệ sinh thái rộng lớn của các ứng dụng phi tập trung NEAR. Một số ứng dụng tốt nhất được xây dựng trên NEAR bao gồm Ref.finance (nền tảng DeFi hàng đầu trên NEAR), Rainbow Bridge (chuyển đổi token giữa Ethereum và NEAR), Mintbase (nền tảng NFT hàng đầu trên NEAR) và Sweatcoin (duy trì hoạt động để kiếm tiền điện tử) chỉ là một số ví dụ.

Một điểm khác biệt quan trọng cho tài khoản NEAR là NEAR sử dụng tài khoản có thể đọc được bởi con người, không phải là một hash. Vì vậy, một tài khoản trên NEAR sẽ không đọc như 0x71C7656EC7ab88b098defB751B7401B5f6d8976F mà sẽ là alice.near hoặc bob.near. Tài khoản NEAR cũng có thể tạo các tài khoản con, nhưng chỉ tài khoản gốc mới có thể tạo chúng. Một điểm khác biệt quan trọng khác là hầu hết các blockchain chỉ có một cặp khóa công khai / khóa riêng tư cho mỗi tài khoản. Trên NEAR, các tài khoản có thể có nhiều cặp khóa được liên kết với chúng. Chúng được gọi là "khóa truy cập." Có hai loại khóa truy cập, một khóa truy cập đầy đủ và một cuộc gọi chức năng. Một khóa truy cập đầy đủ cấp cho người dùng quyền kiểm soát hoàn toàn tài khoản NEAR của họ tài khoản NEAR trong khi một cuộc gọi chức năng cho phép ký giao dịch không phải là tiền tệ.

Địa chỉ Ví - Địa chỉ ví vốn là một chuỗi ký tự hoặc số hoặc cả hai được sử dụng để gửi hoặc nhận token bằng cách sử dụng ví NEAR.

Khóa Riêng Tư Và Cụm Từ Khóa - Cụm từ khóa và khóa bảo mật là một loại mật khẩu. Cụm từ khóa bao gồm 12 từ, trong khi khóa riêng tư bao gồm một chuỗi các chữ cái và số. Cả hai đều rất quan trọng khi phục hồi ví.
Tạo Một Tài Khoản Sử Dụng MyNearWallet 
MyNearWallet cho phép bạn tạo một tài khoản NEAR để truy cập vào tất cả các tính năng đã được thảo luận trước đó.

 	Để tạo một tài khoản, hãy truy cập vào www.mynearwallet.com. Khi bạn đến trang này, bạn sẽ thấy hai tùy chọn: Tạo Tài Khoản hoặc Nhập Tài Khoản Hiện Có. Nếu bạn đã có một tài khoản NEAR hiện có và muốn chuyển nó sang MyNearWallet, hãy chọn Nhập Tài Khoản Hiện Có và làm theo hướng dẫn. Chúng tôi sẽ tập trung vào việc tạo một tài khoản mới trong hướng dẫn này. Chọn tùy chọn "Tạo Tài Khoản".


2. Nhập tên mong muốn cho tài khoản của bạn vào ô "ID Tài Khoản", sau đó nhấp vào "Đặt Tên Tài Khoản Của Tôi".

3. Nhập mật khẩu cho tài khoản NEAR của bạn, hãy chắc chắn rằng đó là một mật khẩu mạnh, vì nó sẽ cấp quyền truy cập vào tài khoản và tiền điện tử của bạn. Đánh dấu vào hai ô.

4. Nhấp vào "Bắt Đầu"
5. Bạn sẽ có thể chọn từ 2 tùy chọn: "Mật khẩu an toàn" hoặc "Ví cứng Ledger". Chọn "Mật khẩu an toàn" (chúng tôi sẽ hướng dẫn bạn cách thiết lập nó với thiết bị Ledger sau trong hướng dẫn này).

6. MyNearWallet sẽ tạo cho bạn một mật khẩu bao gồm 12 từ ngẫu nhiên. Bạn có thể tạo một cái mới nếu bạn không thích của mình. Hãy chắc chắn ghi lại mật khẩu của bạn, hoặc lưu trữ nó trong một trình quản lý mật khẩu như LastPass, vì bạn sẽ cần nó để truy cập vào tài khoản của mình. Nhấn tiếp tục khi bạn sẵn sàng.

7. Sau đó, bạn sẽ được nhắc nhập một trong những từ từ mật khẩu của bạn. Nhập từ vào ô được cung cấp.
8. Bước cuối cùng để thiết lập tài khoản của bạn là mua một số token NEAR, hoặc có một người bạn chuyển chúng vào tài khoản của bạn.
a. Bạn có thể nhấn vào nút này để truy cập các phương thức thanh toán để mua NEAR.

b. Yêu cầu một người bạn gửi cho bạn một số NEAR.
i. Nhấn vào địa chỉ ví của bạn ở góc trên bên phải màn hình.

ii. Sao chép địa chỉ của bạn và gửi nó cho bạn bè của bạn.


Tạo Tài Khoản Với Ledger

 	Lặp lại các bước 1-4 từ phần trước của hướng dẫn này.
 	Chọn tùy chọn "Ví cứng Ledger".


3. Tham khảo hướng dẫn trên Trang web Hỗ trợ Khách hàng của Ledger để biết thêm hướng dẫn chi tiết.



	

	
	
		
			
				What cold/hardware wallet brand is recommended for storing NEAR?
			
		

		
					

		
			
			
			
			Trezor
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Ledger
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Here WalletHERE Wallet là một ví di động không giữ tài sản cho Giao thức NEAR. Với việc sử dụng ví này, người dùng có thể dễ dàng chuyển, nhận, đặt cược và đổi NEAR cùng với các mã thông bình và không thông bình dựa trên NEAR. Nó có một giao thức chồng lỏng có nghĩa là người dùng có khả năng rút NEAR của họ từ việc đặt cược vào bất kỳ lúc nào. Lợi suất đặt cược là ~9% APY. Ví cũng có tài liệu hỗ trợ khách hàng để người dùng tham khảo nếu họ gặp khó khăn.

HERE Wallet có nhiều tính năng bảo mật như lưu trữ mật khẩu trên thiết bị, sinh trắc học và truy cập mã pin giúp nó trở thành một trong những ví thân thiện với điện thoại nhất trên thị trường. Cụm từ khóa được lưu trữ cục bộ trên thiết bị, tuy nhiên ví cũng có tích hợp với ví phần cứng Ledger và HITO cho những người muốn có thêm bảo mật. Ví cũng sẽ định kỳ gửi cảnh báo bảo mật cho người dùng khi phát hiện hoạt động đáng ngờ và đã được kiểm định độc lập bởi OtterSec.

Ví Người Gửi
Sender Wallet là một ví mở rộng trình duyệt được xây dựng cho Giao thức NEAR, cũng có sẵn dưới dạng ứng dụng. Nó được ra mắt vào tháng 2 năm 2022 và đang trở nên phổ biến trong số người dùng NEAR với nhiều tính năng đa dạng như danh sách đen của các địa chỉ độc hại, hỗ trợ Ledger, bộ sưu tập NFT, trao đổi token và đặt cược.

Nếu bạn lo lắng về bảo mật, Sender đã bảo vệ bạn. Nó đã được kiểm định bởi SlowMist, một công ty hàng đầu về an ninh mạng, và thường xuyên trao các phần thưởng cho lỗi để đảm bảo rằng bảo mật luôn được cập nhật. Với các nhà đầu tư như Binance Labs và Crypto.com Capital, Sender Wallet đã nhận được rất nhiều sự ủng hộ từ ngành công nghiệp và chắc chắn sẽ trở thành một phần không thể thiếu trong hệ sinh thái NEAR.

Ví Meteor
Meteor Wallet là một ví mở rộng trình duyệt và ví web được xây dựng cho hệ sinh thái NEAR. Ra mắt trên Giao thức NEAR vào Quý 3 năm 2022, ví mới này có giao diện trực quan và nhiều tính năng hấp dẫn như quy trình đăng ký đơn giản, khôi phục dễ dàng, tính năng NFT tiên tiến và nhiều hơn nữa. Mọi thứ trên ví đều được mã hóa và không có gì được đăng nhập, giúp bạn yên tâm rằng tài sản tiền điện tử của bạn an toàn. Ví có một đội ngũ hỗ trợ khách hàng tuyệt vời với các hướng dẫn chi tiết được viết cho người dùng mới và người dùng nâng cao.Ví Meteor là một trong những ví NEAR đơn giản và dễ sử dụng nhất. Đó là một ví web cũng có thể được sử dụng như một tiện ích Chrome. Hiện tại, nó chỉ hoạt động với giao thức NEAR vì nó được thiết kế đặc biệt cho mục đích đó. Một số tính năng của Meteor bao gồm đặt cược, chuyển khoản, mua bán và đổi NEAR, cùng với các mã thông báo có thể đổi và không thể đổi khác được xây dựng trên NEAR. Ví này cũng mở ra cánh cửa cho toàn bộ hệ sinh thái NEAR, và cung cấp quyền truy cập vào các ứng dụng được xây dựng trên NEAR.
Tạo tài khoản với Ví Meteor
Để tạo một ví, hãy mở trang web Ví Meteor và nhập tên người dùng của bạn:

Vâng, đơn giản như vậy.
Bước tiếp theo
Bây giờ bạn có thể chuyển một số NEAR vào ví của bạn (Nhận NEAR) hoặc tiếp tục khám phá các tính năng khác của Ví Meteor.



Trong ví dụ trên, địa chỉ của chúng tôi là simpleisland-slime.near.
Gửi NEAR
Để gửi NEAR cho ai đó, bạn cần biết ID tài khoản của người nhận (tên người dùng). Khi bạn có nó, bạn có thể gửi NEAR cho họ:

Bạn có thể gửi các mã thông báo khác khi bạn nhấp vào chúng, cùng một menu sẽ mở cho mã thông báo được chọn:
NFTs
Ví Meteor có một trình xem NFT tích hợp, nơi bạn có thể xem NFT của mình trong ví, xem các đặc điểm của họ, giá sàn, chuyển NFT, và nhiều hơn nữa.




Lịch sử giao dịch
Dưới biểu tượng "tia chớp", bạn có thể xem lịch sử giao dịch của mình:


Cài đặt
Cài đặt trong Ví Meteor được đặt ở đây:


	Ứng dụng đã kết nối: Ở đây bạn có thể xem tất cả các ứng dụng mà bạn đã kết nối ví của mình với (hoặc kỹ thuật, đã tạo một chìa khóa truy cập cuộc gọi chức năng). Bạn cũng có thể thu hồi quyền truy cập cho các ứng dụng này bằng cách nhấp vào "Hủy ủy quyền".


2. Bảo mật và Khôi phục: Phần này của ví chứa cụm từ khóa của tài khoản của bạn seed phrase. Bạn có thể xem hoặc xuất cụm từ & khóa riêng từ trang này. Nó cũng cung cấp cho bạn một tùy chọn để quản lý Chìa khóa Truy cập Đầy đủ và Chìa khóa Truy cập Cuộc gọi chức năng của tài khoản của bạn.

3. Bạn cũng có thể cung cấp phản hồi, chia sẻ vấn đề của mình với hỗ trợ kỹ thuật, đặt mật khẩu, xóa tài khoản khỏi ví meteor, và những điều khác từ trang này.
Tìm hiểu sâu hơn tại Tài liệu NEAR
Ví Trust
Ví Trust là một ví phi tập trung và phi tập trung cho phép người dùng lưu trữ tiền điện tử của họ. Tài sản được lưu trữ trong một địa chỉ số có thể truy cập chỉ bởi người dùng, làm cho nó trở thành một cách an toàn và hiệu quả để lưu trữ tài sản số. Ví Trust tập trung vào sự đơn giản và dễ sử dụng. Ví này là mã nguồn mở, được cộng đồng hỗ trợ, ví đa tiền tệ có khả năng lưu trữ gần như tất cả các loại tiền điện tử. Nó cung cấp cho người dùng một cách tiện lợi để quản lý tiền điện tử của họ và cho phép họ hoàn toàn kiểm soát chìa khóa riêng của mình.

Ví đã được Binance mua lại và là ví chính thức của sàn giao dịch Binance. Ví cho phép người dùng giữ hoàn toàn quyền kiểm soát tài sản và khóa riêng tư được lưu trữ trên thiết bị của người dùng. Các nhà phát triển cũng có thể xây dựng các ứng dụng phi tập trung mà không gặp phải bất kỳ vấn đề cụ thể nào như chi tiết triển khai cấp thấp. Ví cũng hỗ trợ việc đặt cược trên ví, điều này có nghĩa là người dùng có thể kiếm được phần thưởng trên bất kỳ mã thông báo Proof-of-Stake hoặc Delegated Proof-of-Stake nào được hỗ trợ. Trust Wallet cho phép người dùng kiếm được phần thưởng và liên tục thêm nhiều stablecoin và tiền điện tử khác.
Bitte Wallet
Mintbase Wallet đã được tái thương hiệu thành Bitte Wallet.

Bitte wallet giúp việc sử dụng công nghệ blockchain trở nên dễ dàng hơn bao giờ hết, tất cả nhờ vào một số tính năng thông minh từ blockchain NEAR.
Các Tính Năng Chính:
Quy trình Onboarding Thân Thiện Người Dùng: Với passkeys và trừu tượng tài khoản, Bitte Wallet cung cấp trải nghiệm onboarding mượt mà, thường nhanh hơn so với các nền tảng Web2 truyền thống.

Bảo Quản An Toàn Tài Sản: Sử dụng các tính năng sinh trắc học như Face ID hoặc dấu vân tay, Bitte Wallet lưu trữ an toàn các khóa ví trong trình quản lý mật khẩu bạn chọn, đảm bảo bạn hoàn toàn kiểm soát tài sản của mình.

Không Phí Gas: Tận dụng trừu tượng tài khoản và công nghệ giao dịch meta-transaction độc đáo của blockchain NEAR, Bitte Wallet hỗ trợ giao dịch bao gồm phí gas.

Vì vậy, người dùng Bitte wallet hiện có thể tận hưởng trải nghiệm mượt mà, quen thuộc hơn, tương tự như việc sử dụng các ứng dụng thông thường, mà không gặp phải những phiền toái thông thường của blockchain.
Guarda Wallet
Guarda Wallet ra mắt vào năm 2017, và đã trở thành lựa chọn phổ biến cho người dùng tiền điện tử từ các blockchain khác nhau. Đây là một ví dễ sử dụng, thân thiện với người mới bắt đầu, có tính tích hợp với các sàn giao dịch phi tập trung. Ví hỗ trợ nhiều tài khoản và có giao diện đơn giản để quản lý, lưu trữ và giao dịch NEAR.



Guarda là một ví không giữ tài sản đa nền tảng cho phép truy cập an toàn và dễ dàng vào tiền điện tử trên hầu hết các thiết bị bao gồm Windows, Mac OS, iOS, Android và Linux. Ví có tính năng xác thực đa yếu tố, hỗ trợ lưu trữ lạnh và lưu trữ khóa riêng tư trên thiết bị của bạn dưới dạng mã hóa. Một điểm hạn chế lớn của Guarda Wallet là nó hỗ trợ giới hạn cho tiền tệ fiat và NFT.
Coinbase Wallet
Coinbase Wallet là một ví không giữ tài sản linh hoạt với một loạt các chức năng. Nó có chức năng NFT và DeFi rộng lớn, là lựa chọn lý tưởng cho các nhà giao dịch hoặc nhà đầu tư. Ví tương thích với Android, iOS và hầu hết các trình duyệt web phổ biến dưới dạng tiện ích mở rộng, mang lại trải nghiệm thuận tiện và chuyển đổi mượt mà qua nhiều thiết bị.

Yếu tố chính phân biệt ví này với các ví khác là truy cập trực tiếp vào nền tảng Coinbase. Ví này tích hợp tốt với các ứng dụng NEAR bao gồm, nhưng không giới hạn ở DeFi, gaming, thị trường NFT và nhiều hơn nữa. Đây là một ví tuyệt vời cho người dùng đến từ Coinbase, vì nó sẽ giúp dễ dàng và mượt mà chuyển đổi vào hệ sinh thái NEAR.




	

	
	
		
			
				Which wallet is the official successor to NEAR Wallet?
			
		

		
					

		
			
			
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Meteor Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Suy nghĩ cuối cùng
Hệ sinh thái của NEAR cho phép người dùng truy cập vào một loạt các NFT, ứng dụng phi tập trung và các giải pháp DeFi. NEAR giải quyết nhược điểm của các blockchain như Ethereum, cung cấp các giải pháp cho các vấn đề lâu nay như tắc nghẽn mạng, phí gas cao và phí xử lý chậm. Ví NEAR cho phép người dùng tạo và tương tác với các tài khoản NEAR, cho phép người dùng lưu trữ token NEAR của họ và đặt cược để kiếm phần thưởng. Chúng tôi hy vọng hướng dẫn này cung cấp một số sự rõ ràng về cách hoạt động của ví NEAR và các trường hợp sử dụng của nó.
Bình chọn cho ví NEAR yêu thích của bạn!

### Sweatcoinは、歩数を追跡して仮想通貨を獲得できるアプリケーションです。ユーザーは歩数を記録し、それに応じてSweatcoinを獲得します。この仮想通貨は、様々な商品やサービスと交換することができます。SweatcoinはNEAR Protocol上で動作し、ブロックチェーン技術を活用して信頼性と透明性を提供しています。 NEAR Protocolは、スマートコントラクトや分散型アプリケーションをサポートするブロックチェーンプラットフォームです。

ブロックチェーン技術と暗号通貨のおかげで、世界は驚異的なスケールで革新を見ています。そのような革新の1つがSweatcoinです。これは、ユーザーがさまざまな報酬をインセンティブとして健康的なライフスタイルを採用するよう奨励するトップランクの健康とフィットネスアプリケーションです。2022年、Sweatcoinは、自社の暗号通貨であるSweatcoinトークン（SWEAT）を発行することを発表しました。このトークンはNEARとEthereumブロックチェーンに基づいており、アプリにさらに多くのユーザーを引き付けるためのインセンティブとして利用されます。

この投稿では、Sweatcoinの背後にあるコンセプト、その動作方法、およびさまざまなユースケースについて理解するのに役立ちます。




What Is Sweatcoin?
Sweatcoinは、運動とアクティブなライフスタイルが実際の価値を持つという信念に基づいて設立されたプレイ・トゥ・アーン・プロジェクトと言えます。Sweatcoinは、分散型ファイナンス（DeFi）や非代替トークン（NFT）を利用して、ユーザーに返還される価値を解放します。一方、DAOは、ユーザーがSweatcoinエコシステムのガバナンス、開発、意思決定プロセスに参加できるようにします。

このプロジェクトは、ユーザーに価値創造の新たな手段を提供し、アプリで記録された動きを通じてユーザーが稼ぐことを可能にします。Sweatcoinはオープンソースプロジェクトでもあり、誰もがプロジェクトを前進させることができます。

最初は、Sweatcoinトークンは非暗号トークンであり、アプリをダウンロードしたユーザーが指定された歩数を達成すると、Sweatcoinトークンが与えられました。トークン保有者は、HeadspaceやAudibleなどの組織から報酬としてこれらのトークンを引き換えることができます。また、ユーザーはこれらのトークンを慈善事業に寄付することもできました。理論上、Sweatcoinトークンは暗号通貨にいくつかの類似点を持っており、チームはSweatcoinトークン（SWEAT）を作成することに駆り立てられました。






スウェットコイントークン（SWEAT）
スウェットコインのトークン生成イベントは9月12日に行われました。トークン生成イベントの後、新しいSWEATトークンを作成する唯一の方法は、運動検証者によって検証された運動を通じてです。最初は、SWEATは参加する資格のあるスウェットコインユーザーのみに利用可能になります。トークン生成イベントの後、ユーザーの現在のスウェットコイン残高はSWEATトークンと1：1で一致します。12日以降、SWEATを獲得することはより難しくなります。なぜなら、毎日最初の5000歩で新しいSWEATを作成できる一方、それ以上の歩数では通常通りスウェットコインが作成されます。1スウェットコインは常に1000歩に等しくなりますが、時間が経つにつれてSWEATを作成することが難しくなります。









	

	
	
		
			
				What term best describes Sweatcoin as a project? 
			
		

		
					

		
			
			
			
			Play-to-Earn project 
		
			
			Move-to-Earn project
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





スウェットコインはどのように機能しますか？


スウェットコインとスウェット経済の機能を理解しましょう。無料のスウェットコインアプリはApple App StoreとGoogle Playで利用可能です。デバイスにアプリをダウンロードしてインストールすると、アプリは1日中のアクティビティを監視し、歩数を追跡します。ユーザーは、記録された1000歩ごとに1つのスウェットコインを獲得できます。ユーザーはこれらのコインを使ってランニングシューズ、デジタルウォッチ、音楽ダウンロード、エナジードリンクなどさまざまなものを購入できます。歩くほど、獲得できるスウェットコインも増えます。

ホワイトペーパーによると、スウェットコインは人々に動き続けることを奨励し、動きを報酬とし、より健康な惑星を作るために作成されました。スウェット経済の誰もが稼ぎ、貢献することができます。最初は、SWEATはスウェットコインアプリをダウンロードできる対象ユーザーのみが利用できました。2022年第1四半期までに、スウェットコインは6500万ユーザーに成長し、2022年8月までに1億1000万ユーザーに達し、さらなる成長が期待されています。

SWEATトークンは検証可能な動きだけで作成できます。安定したユーザー数は入力（歩数）を増加させ、ネットワークに参加するユーザーが増えると、入力は指数関数的に増加します。さらに、新しいSWEATトークンごとに以前のトークンよりも多くの歩数が必要になります。これは、スウェットコインが世界をより活発にするという目標と一致しています。新しいSWEATトークンがますます難しくなるにつれ、ユーザーが動き続ける刺激とともに、SWEATトークンの有用性も保持されます。

ユーザーの動きは、動きの検証者によってブロックチェーンが更新されることで検証されます。一貫した検証は、基礎となる資産（SWEAT）の整合性を確保するために重要です。前述のように、ユーザーは達成した1000歩ごとに1つのSWEATトークンを獲得できます。検証者はユーザーのデバイスからデータを受信し、アルゴリズムを使用して不正な動きを検出し、真の動きのみが記録されるようにします。






	

	
	
		
			
				SWEAT token is based on which blockchains? 
			
		

		
					

		
			
			
			
			Ethereum and NEAR 
		
			
			Polygon and Cardano 
		
			
			Ethereum and Cardano
		
			
			NEAR and Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





スウェットコインの将来計画
スウェット経済には独自の暗号ウォレット、スウェットウォレットがあり、エコシステムにNFTを導入する計画もあります。さらに、2022年末までにユーザーがフィアット通貨を使用して直接SWEATを購入できるようにする計画があります。チームはまた、NFTマーケットプレイスを作成し、SWEATトークンを分散型取引所で利用可能にする計画を発表しています。最終的に、スウェット経済とSWEATのガバナンスは分散型自治組織（DAO）に移行されます。将来的には、スウェットコインの鋳造はサイクリング、水泳などの他の活動方法にも拡大されます。




	

	
	
		
			
				After the token generation event, users can mint SWEAT by 
			
		

		
					

		
			
			
			
			Registering the first 5000 steps on the Sweatcoin app
		
			
			Registering the first 1000 steps on the Sweatcoin app
		
			
			Purchasing the SWEAT token directly 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Clubで学ぶ
Learn NEAR Club（LNC）は、NEARプロトコルに関するすべてを網羅した、実践的なオンボーディングプラットフォームです。NEARプロトコルの使用方法や構築方法を学び、NEARトークンを獲得できます。LNCには多くのオンボーディングガイドやコースがあります。LNCのユーザーは、優れた学習者に対する報酬として機能する内部ポイントであるnLearnsを獲得することもできます。LNCのユーザーは、NEARガイド、NEARコース、または独自の（L）Earner NFTから始めることができます。

スウェットを学んだら、 Learn NEAR Clubに移動して、学び、稼ぎましょう。また、Sweatcoin GuideもLNCで利用可能です。他にも多くのガイドやコースがあります。







	

	
	
		
			
				What can you do with your Sweatcoins?
			
		

		
					

		
			
			
			
			Buy deals, products, and digital offers
		
			
			Bid in high-value auctions (PlayStation 5, GoPro Hero 9)
		
			
			Donate to charities like Save the Children
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### Sweatcoin은 NEAR 프로토콜을 기반으로 한 디지털 통화입니다. Sweatcoin은 사용자들이 활동량을 추적하고 보상을 받을 수 있는 애플리케이션을 통해 획득할 수 있습니다. 이 디지털 통화는 걷기, 달리기 또는 자전거 타기와 같은 활동을 통해 채굴됩니다. Sweatcoin은 사용자들이 더 많은 활동을 유도하고 건강한 라이프스타일을 촉진하기 위해 설계되었습니다.

블록체인 기술과 암호화폐 덕분에 세계는 엄청난 규모의 혁신을 경험하고 있습니다. 그 중 하나가 Sweatcoin인데, 이는 사용자들이 다양한 보상을 인센티브로 채택하여 더 건강한 삶을 살도록 장려하는 최고 순위의 건강 및 피트니스 애플리케이션입니다. 2022년, Sweatcoin은 자체 암호화폐인 Sweatcoin 토큰 (SWEAT)을 출시할 것이라고 발표했습니다. 이 토큰은 NEAR 및 이더리움 블록체인을 기반으로 하며 앱에 더 많은 사용자를 유치하기 위한 인센티브로 활용될 것입니다.

이 게시물은 Sweatcoin의 개념, 작동 방식 및 다양한 사용 사례에 대해 이해하는 데 도움이 될 것입니다.




스웨트코인(Sweatcoin)이란?
Sweatcoin은 움직임과 활동적인 삶이 실제 가치를 가질 수 있다는 믿음에 기반을 둔 플레이 투 어니언 프로젝트로 설명될 수 있습니다. Sweatcoin은 탈중앙화된 금융(DeFi) 및 대체 불가능한 토큰(NFT)을 활용하여 사용자에게 반환되는 가치를 해제합니다. 한편 DAO는 사용자가 Sweatcoin 생태계의 거버넌스, 개발 및 의사 결정 프로세스에 참여할 수 있도록 합니다.

이 프로젝트는 사용자들에게 가치 창출을 위한 새로운 길을 제공하며, 앱에서 기록된 움직임을 통해 수익을 창출할 수 있도록 합니다. Sweatcoin은 또한 오픈 소스 프로젝트로, 누구나 프로젝트를 발전시킬 수 있습니다.

초기에 Sweatcoin 토큰은 비암호화폐 토큰이었으며, 애플리케이션을 다운로드한 사용자가 특정 단계 수를 달성하면 Sweatcoin 토큰을 제공받았습니다. 토큰 소지자는 Headspace 및 Audible과 같은 기관으로부터 보상을 받을 수 있습니다. 또는 사용자는 이러한 토큰을 자선 사업에 기부할 수도 있습니다. 이론적으로 Sweatcoin 토큰은 암호화폐와 많은 유사점을 가지고 있어서 팀이 Sweatcoin 토큰 (SWEAT)을 만들게 했습니다.






스웨트코인 토큰 (SWEAT)
스웨트코인의 토큰 생성 이벤트는 9월 12일에 진행되었습니다. 토큰 생성 이벤트 이후 새로운 SWEAT 토큰을 만드는 유일한 방법은 움직임 검증자에 의해 확인된 움직임을 통해입니다. 처음에는 SWEAT가 참여한 스웨트코인 사용자에게만 제공됩니다. 토큰 생성 이벤트 이후 사용자의 현재 스웨트코인 잔액은 SWEAT 토큰과 1:1로 매칭됩니다. 12일 이후에는 SWEAT를 얻는 것이 더 어려워지며, 매일 처음 5000걸음은 새로운 SWEAT를 만들어내지만 그 이상의 걸음은 일반적으로 스웨트코인을 만들어냅니다. 1 스웨트코인은 항상 1000걸음과 동일하지만, 시간이 지남에 따라 SWEAT를 만드는 것이 더 어려워질 것입니다.









	

	
	
		
			
				What term best describes Sweatcoin as a project? 
			
		

		
					

		
			
			
			
			Play-to-Earn project 
		
			
			Move-to-Earn project
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





스웨트코인은 어떻게 작동합니까?


스웨트코인과 스웨트 경제가 어떻게 작동하는지 이해해 봅시다. 무료 스웨트코인 앱은 애플 앱 스토어와 구글 플레이에서 사용할 수 있습니다. 기기에 앱을 다운로드하고 설치하면 앱은 하루 종일 활동을 모니터링하여 걸음 수를 추적합니다. 사용자는 1000걸음 당 한 개의 스웨트코인을 벌 수 있습니다. 사용자는 이 코인을 교환하여 러닝화, 디지털 시계, 음악 다운로드, 에너지 음료 등 다양한 물건을 구매할 수 있습니다. 더 많이 걸으면 더 많은 스웨트코인을 벌 수 있습니다.

화이트페이퍼에 따르면, 스웨트코인은 사람들이 계속 움직이도록 동기부여하고 움직임을 보상하며 더 건강한 행성을 만들기 위해 만들어졌습니다. 스웨트 경제의 누구나 벌고 기여할 수 있습니다. 처음에는 스웨트는 스웨트코인 앱을 다운로드할 수 있는 자격이 있는 사용자에게만 제공되었습니다. 2022년 1분기까지 스웨트코인은 6500만 명의 사용자로 성장했으며, 2022년 8월에는 1억 1000만 명의 사용자에 이르렀으며, 이 수는 더 늘어날 것으로 예상됩니다.

SWEAT 토큰은 확인 가능한 움직임을 통해서만 발행될 수 있습니다. 안정적인 사용자 수는 입력(걸음 수)을 증가시킵니다. 더 많은 사용자가 네트워크에 가입할수록 입력은 기하급수적으로 증가할 것입니다. 또한, 각 새로운 SWEAT 토큰은 이전 토큰보다 더 많은 걸음 수를 필요로 합니다. 이는 스웨트코인의 목표인 세계를 더 활발하게 만드는 것과 일치합니다. 새로운 SWEAT 토큰이 점점 더 어렵게 발행되면, 사용자가 계속 움직이는 것뿐만 아니라 SWEAT 토큰의 유틸리티를 보존하는 동기부여로 작용합니다.

사용자의 움직임은 움직임 검증자에 의해 블록체인에 업데이트됩니다. 일관된 검증은 기본 자산(SWEAT)의 무결성을 보장하는 데 중요합니다. 앞서 언급했듯이, 사용자는 달성한 1000걸음 당 한 개의 SWEAT 토큰을 벌 수 있습니다. 검증자는 사용자 기기로부터 데이터를 받아들이고 알고리즘을 통해 부정한 움직임을 감지하여 진정한 움직임만을 기록합니다.






	

	
	
		
			
				SWEAT token is based on which blockchains? 
			
		

		
					

		
			
			
			
			Ethereum and NEAR 
		
			
			Polygon and Cardano 
		
			
			Ethereum and Cardano
		
			
			NEAR and Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





스웨트코인의 미래 계획
스웨트 경제에는 스웨트 월렛이라는 자체 암호화폐 지갑이 있으며, NFT를 생태계에 도입할 계획도 있습니다. 또한, 2022년 말까지 사용자가 스웨트를 직접 피아트 화폐로 구매할 수 있도록 하는 계획이 있습니다. 팀은 또한 NFT 마켓플레이스를 만들고 SWEAT 토큰을 탈중앙화 거래소에서 이용할 수 있도록 할 계획입니다. 마침내, 스웨트 경제와 SWEAT의 지배권은 분산 자치 조직(DAO)에 넘어갈 것입니다. 스웨트코인의 발행은 자전거 타기, 수영 등과 같은 다른 활동 방법으로 확대될 것입니다.




	

	
	
		
			
				After the token generation event, users can mint SWEAT by 
			
		

		
					

		
			
			
			
			Registering the first 5000 steps on the Sweatcoin app
		
			
			Registering the first 1000 steps on the Sweatcoin app
		
			
			Purchasing the SWEAT token directly 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Club에서 배우기
Learn NEAR Club (LNC)는 NEAR 프로토콜에 대한 모든 포괄적이고 실용적인 온보딩 플랫폼으로, NEAR 프로토콜을 사용하고 구축하는 방법을 배우고 NEAR 토큰을 벌 수 있습니다. LNC에는 다양한 온보딩 가이드와 코스가 제공됩니다. LNC 사용자는 우수한 학습자에 대한 보상으로 작용하는 내부 포인트인 nLearns를 벌 수 있습니다. LNC 사용자는 NEAR 가이드, NEAR 코스 또는 자체 (L)Earner NFT를 만들기로 시작할 수 있습니다.

이제 스웨트를 배웠으니 Learn NEAR Club로 이동하여 (L)Earn할 수 있습니다. 또한 Sweatcoin Guide을 포함한 다양한 가이드와 코스를 LNC에서 확인할 수 있습니다.







	

	
	
		
			
				What can you do with your Sweatcoins?
			
		

		
					

		
			
			
			
			Buy deals, products, and digital offers
		
			
			Bid in high-value auctions (PlayStation 5, GoPro Hero 9)
		
			
			Donate to charities like Save the Children
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### Ano ang Sweatcoin: Isang Maikling Pagsasalaysay

Salamat sa teknolohiyang blockchain at mga cryptocurrency, ang mundo ay nakakakita ng pagbabago sa isang kahanga-hangang antas. Isa sa mga inobasyon na ito ay ang Sweatcoin, isang nangungunang aplikasyon sa kalusugan at fitness na nagtutulak sa mga gumagamit na tanggapin ang mas malusog na pamumuhay sa pamamagitan ng iba't ibang mga gantimpala bilang insentibo. Noong 2022, inihayag ng Sweatcoin na ilulunsad nito ang sariling cryptocurrency, ang token ng Sweatcoin (SWEAT). Ang token ay batay sa NEAR at Ethereum blockchains at gagamitin bilang insentibo upang maakit ang higit pang mga gumagamit sa aplikasyon.

Ang post na ito ay makatutulong sa pag-unawa sa konsepto sa likod ng Sweatcoin, kung paano ito gumagana, at ano ang iba't ibang mga paggamit nito.

Ano ang Sweatcoin?
Ang Sweatcoin ay maaaring ilarawan bilang isang proyektong play-to-earn na itinatag sa paniniwala na ang paggalaw at isang aktibong pamumuhay ay maaaring magkaroon ng tunay na halaga. Ginagamit ng Sweatcoin ang decentralized finance (DeFi) at non-fungible tokens (NFTs) upang buksan ang halaga na ibinabalik sa gumagamit. Samantala, pinapayagan ng DAO ang mga gumagamit na makilahok sa pamamahala, pag-unlad, at proseso ng pagdedesisyon ng ecosystem ng Sweatcoin.

Binibigyan ng proyekto ang mga gumagamit ng bagong paraan para sa paglikha ng halaga, pinapayagan ang mga gumagamit na kumita sa pamamagitan ng mga galaw na naitala sa aplikasyon. Ang Sweatcoin ay isang open-source project din, na nagbibigay-daan sa lahat na mag-ambag sa proyekto.

Sa simula, ang token ng Sweatcoin ay isang non-crypto token, at kapag nakamit ng mga gumagamit na nag-download ng aplikasyon ang isang partikular na bilang ng hakbang, binibigyan sila ng mga token ng Sweatcoin. Maaaring mag-redempta ang mga tagahawak ng token na ito para sa mga gantimpala mula sa mga organisasyon tulad ng Headspace at Audible. Sa kabilang banda, maaari rin nilang i-donate ang mga token na ito para sa mga mabubuting layunin. Sa teorya, ang token ng Sweatcoin ay nag-aalok ng ilang mga pagkakatulad sa mga cryptocurrency, na nag-udyok sa koponan na lumikha ng token ng Sweatcoin (SWEAT)

Ang Token ng Sweatcoin (SWEAT)
Ang pangyayaring pagbuo ng token ng Sweatcoin ay naganap noong ika-12 ng Setyembre. Pagkatapos ng pangyayaring pagbuo ng token, ang tanging paraan upang lumikha ng bagong mga SWEAT token ay sa pamamagitan ng paggalaw, na napatunayan ng mga validator ng paggalaw. Sa simula, ang SWEAT ay magiging magagamit lamang sa mga kwalipikadong gumagamit ng Sweatcoin na pumili. Pagkatapos ng pangyayaring pagbuo ng token, ang kasalukuyang balanse ng Sweatcoin ng mga gumagamit ay magiging katumbas ng 1:1 sa mga SWEAT token. Pagkatapos ng ika-12, ang pagkakaroon ng SWEAT ay magiging mas mahirap, dahil ang iyong unang 5000 hakbang bawat araw ang magbibigay sa iyo ng pagkakataon na lumikha ng bagong SWEAT, samantalang ang anumang karagdagang hakbang ay maglilikha ng mga Sweatcoin tulad ng karaniwan. Bagaman ang 1 Sweatcoin ay palaging katumbas ng 1000 hakbang, ang SWEAT ay magiging mas mahirap na ilikha habang lumilipas ang panahon.









	

	
	
		
			
				What term best describes Sweatcoin as a project? 
			
		

		
					

		
			
			
			
			Play-to-Earn project 
		
			
			Move-to-Earn project
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paano Gumagana ang Sweatcoin?


Unawain natin kung paano gumagana ang Sweatcoin at ang ekonomiya ng Sweat. Ang libreng app ng Sweatcoin ay available sa Apple App store at Google Play. Kapag nag-download at nag-install ka ng app sa iyong device, sinusubaybayan ng app ang iyong aktibidad sa buong araw, sinusukat ang bilang ng hakbang na iyong nagawa. Bilang user, maaari kang kumita ng isang Sweatcoin para sa bawat 1000 hakbang na nairekord. Maaaring gamitin ng mga user ang mga coin na ito at bumili ng iba't ibang bagay tulad ng mga sapatos pangtakbo, digital na relo, music downloads, energy drinks, at iba pa. Habang mas marami kang maglakad, mas marami kang Sweatcoins na maaaring kitain.

Ayon sa whitepaper, nilikha ang Sweatcoin upang magbigay-insentibo sa mga tao na patuloy na gumalaw, gantimpalaan ang paggalaw, at lumikha ng mas malusog na planeta. Ang sinumang nasa ekonomiya ng Sweat ay maaaring kumita at mag-ambag dito. Sa simula, ang SWEAT ay available lamang sa mga karapat-dapat na user na maaaring mag-download ng app ng Sweatcoin. Sa Q1 2022, umabot sa 65 milyong user ang Sweatcoin, isang bilang na umabot sa 110 milyong user sa Agosto 2022, at inaasahang lalaki pa ang bilang.

Ang SWEAT token ay maaaring mabuo lamang sa pamamagitan ng beripikadong galaw. Ang isang stable na bilang ng users ay tumutulong sa pagtaas ng input (hakbang); habang mas maraming users ang sumasali sa network, ang input ay magiging exponential. Bukod dito, ang bawat bagong SWEAT token ay mangangailangan ng mas maraming hakbang upang mabuo kaysa sa naunang token. Ito ay tumutugma sa layunin ng Sweatcoin na gawing mas aktibo ang mundo. Sa bawat bagong SWEAT token na mas mahirap mabuo, hindi lamang ito nagiging insentibo para sa mga users na patuloy na gumalaw kundi nagpapanatili rin ng kahalagahan ng SWEAT token.

Ang mga galaw ng user ay sinusuri ng mga movement validators na nag-uupdate sa blockchain. Mahalaga ang patuloy na pagsusuri upang tiyakin ang integridad ng underlying asset (SWEAT). Tulad ng nabanggit kanina, maaaring kumita ang mga users ng isang SWEAT token para sa bawat 1000 hakbang na naabot. Natatanggap ng mga validators ang data mula sa mga device ng user at nahuhuli ang anumang mapanlinlang na galaw sa pamamagitan ng isang algorithm, tiyak na ang tanging totoong galaw lamang ang naire-record.






	

	
	
		
			
				SWEAT token is based on which blockchains? 
			
		

		
					

		
			
			
			
			Ethereum and NEAR 
		
			
			Polygon and Cardano 
		
			
			Ethereum and Cardano
		
			
			NEAR and Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Mga Plano Para sa Sweatcoin sa Hinaharap
Mayroon ding sariling crypto wallet ang Sweat economy, ang Sweat Wallet, at may mga plano rin na mag-introduce ng NFTs sa ekosistema. Bukod dito, may mga plano na payagan ang mga users na bumili ng SWEAT nang direkta gamit ang fiat currency sa katapusan ng 2022. Inihayag din ng team ang plano na lumikha ng isang NFT marketplace at gawing available ang SWEAT token sa decentralized exchanges. Sa huli, ang governance ng Sweat economy at SWEAT ay ipapasa sa isang decentralized autonomous organization (DAO). Sa bandang huli, ang pagmimint ng Sweatcoin ay papalawakin sa iba't ibang paraan ng mga aktibidad tulad ng pagbibisikleta, paglangoy, at iba pa.




	

	
	
		
			
				After the token generation event, users can mint SWEAT by 
			
		

		
					

		
			
			
			
			Registering the first 5000 steps on the Sweatcoin app
		
			
			Registering the first 1000 steps on the Sweatcoin app
		
			
			Purchasing the SWEAT token directly 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Matuto sa NEAR Club
Ang Learn NEAR Club (LNC) ay isang all-inclusive, hands-on onboarding platform para sa NEAR protocol, kung saan maaari kang matuto kung paano gumamit at magtayo sa NEAR protocol, at kumita ng NEAR tokens. Nagtatampok ang LNC ng maraming mga gabay at kurso para sa onboarding. Ang mga users sa LNC ay maaari ring kumita ng nLearns, na pangunahing internal points, na nagiging insentibo para sa mga outstanding learners. Ang mga users sa LNC ay maaaring magsimula sa NEAR Guides, NEAR Courses, o magminta ng kanilang sariling (L)Earner NFT.

Ngayong natutunan mo na ang SWEAT, maaari kang pumunta sa Learn NEAR Club, at (L)Earn. Maaari mo ring tingnan ang Sweatcoin Guide na available sa LNC, kasama ang iba't ibang mga gabay at kurso. 







	

	
	
		
			
				What can you do with your Sweatcoins?
			
		

		
					

		
			
			
			
			Buy deals, products, and digital offers
		
			
			Bid in high-value auctions (PlayStation 5, GoPro Hero 9)
		
			
			Donate to charities like Save the Children
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### ¿Qué es Sweatcoin: Una breve introducción

Gracias a la tecnología blockchain y las criptomonedas, el mundo está viendo innovación a una escala impresionante. Una de esas innovaciones es Sweatcoin, una aplicación de salud y fitness de alto rango que anima a los usuarios a adoptar un estilo de vida más saludable utilizando diversas recompensas como incentivo. En 2022, Sweatcoin anunció que lanzaría su propia criptomoneda, el token Sweatcoin (SWEAT). El token está basado en las blockchains de NEAR y Ethereum y se utilizará como incentivo para atraer a más usuarios a la aplicación.

Esta publicación ayudará a comprender el concepto detrás de Sweatcoin, cómo funciona y cuáles son sus diversos casos de uso.




¿Qué es Sweatcoin?
Sweatcoin se puede describir como un proyecto de jugar para ganar fundado en la creencia de que el movimiento y un estilo de vida activo podrían tener un valor real. Sweatcoin utiliza finanzas descentralizadas (DeFi) y tokens no fungibles (NFT) para desbloquear valor que se devuelve al usuario. Mientras tanto, el DAO permite a los usuarios participar en la gobernanza, desarrollo y proceso de toma de decisiones del ecosistema de Sweatcoin.

El proyecto brinda a los usuarios una nueva vía para la creación de valor, permitiéndoles ganar a través de movimientos registrados en la aplicación. Sweatcoin también es un proyecto de código abierto, lo que permite a todos avanzar en el proyecto.

Inicialmente, el token Sweatcoin era un token no criptográfico, y cuando los usuarios que descargaron la aplicación alcanzaron un número especificado de pasos, se les otorgaban tokens Sweatcoin. Los titulares de tokens pueden canjear estos tokens por recompensas de organizaciones como Headspace y Audible. Alternativamente, los usuarios también podrían donar estos tokens a causas benéficas. En teoría, el token Sweatcoin ofrece varias similitudes con las criptomonedas, lo que llevó al equipo a crear el token Sweatcoin (SWEAT)






El Token Sweatcoin (SWEAT)
El evento de generación de tokens de Sweatcoin tuvo lugar el 12 de septiembre. Después del evento de generación de tokens, la única forma de acuñar nuevos tokens SWEAT es a través del movimiento, verificado por validadores de movimiento. Inicialmente, SWEAT solo estará disponible para usuarios elegibles de Sweatcoin que opten por participar. Después del evento de generación de tokens, el saldo actual de Sweatcoin de los usuarios se igualará 1:1 con los tokens SWEAT. Después del 12, ganar SWEAT se vuelve más complicado, ya que tus primeros 5000 pasos cada día te permitirían acuñar nuevos SWEAT, mientras que cualquier paso adicional acuñaría Sweatcoins como de costumbre. Mientras que 1 Sweatcoin siempre será igual a 1000 pasos, SWEAT se volverá más difícil de acuñar a medida que pase el tiempo.









	

	
	
		
			
				What term best describes Sweatcoin as a project? 
			
		

		
					

		
			
			
			
			Play-to-Earn project 
		
			
			Move-to-Earn project
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo funciona Sweatcoin?


Veamos cómo funcionan tanto Sweatcoin como la economía de Sweat. La aplicación gratuita de Sweatcoin está disponible en la App Store de Apple y Google Play. Una vez que descargues e instales la aplicación en tu dispositivo, la aplicación monitorea tu actividad durante el día, rastreando el número de pasos dados. Como usuario, puedes ganar un Sweatcoin por cada 1000 pasos registrados. Los usuarios pueden canjear estas monedas y comprar varias cosas como zapatillas para correr, relojes digitales, descargas de música, bebidas energéticas y más. Cuanto más camines, más Sweatcoins puedes ganar.

Según el whitepaper, Sweatcoin se creó para incentivar a las personas a mantenerse en movimiento, recompensar el movimiento y crear un planeta más saludable. Cualquiera en la economía de Sweat puede ganar y contribuir a ella. Inicialmente, el SWEAT estaba disponible solo para usuarios elegibles que podían descargar la aplicación de Sweatcoin. Para el primer trimestre de 2022, Sweatcoin había crecido hasta llegar a 65 millones de usuarios, un número que alcanzó los 110 millones de usuarios para agosto de 2022, con la expectativa de que siga creciendo.

El token SWEAT solo se puede acuñar a través de movimientos verificables. Un número estable de usuarios ayuda a aumentar la entrada (pasos); a medida que más usuarios se unen a la red, la entrada aumentaría exponencialmente. Además, cada nuevo token SWEAT requeriría más pasos para acuñar que el token anterior. Esto se alinea con el objetivo de Sweatcoin de hacer que el mundo sea más activo físicamente. Con cada nuevo token SWEAT cada vez más difícil de acuñar, no solo actúa como un incentivo para que los usuarios sigan moviéndose, sino que también preserva la utilidad del token SWEAT.

Los movimientos de los usuarios son validados por validadores de movimientos que actualizan la cadena de bloques. La validación constante es fundamental para garantizar la integridad del activo subyacente (SWEAT). Como se mencionó anteriormente, los usuarios pueden ganar un token SWEAT por cada 1000 pasos logrados. Los validadores reciben datos de los dispositivos de los usuarios y detectan cualquier movimiento fraudulento a través de un algoritmo, asegurando que solo se registren movimientos reales.






	

	
	
		
			
				SWEAT token is based on which blockchains? 
			
		

		
					

		
			
			
			
			Ethereum and NEAR 
		
			
			Polygon and Cardano 
		
			
			Ethereum and Cardano
		
			
			NEAR and Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planes futuros para Sweatcoin
La economía de Sweat también tiene su propia billetera criptográfica, la Sweat Wallet, y también planea introducir NFT en el ecosistema. Además, hay planes para permitir a los usuarios comprar SWEAT directamente con moneda fiduciaria para finales de 2022. El equipo también ha anunciado planes para crear un mercado de NFT y hacer que el token SWEAT esté disponible en intercambios descentralizados. Eventualmente, la gobernanza de la economía de Sweat y SWEAT se transferirá a una organización autónoma descentralizada (DAO). Finalmente, la acuñación de Sweatcoin se ampliará a otros métodos de actividades como ciclismo, natación, etc.




	

	
	
		
			
				After the token generation event, users can mint SWEAT by 
			
		

		
					

		
			
			
			
			Registering the first 5000 steps on the Sweatcoin app
		
			
			Registering the first 1000 steps on the Sweatcoin app
		
			
			Purchasing the SWEAT token directly 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aprende en NEAR Club
Learn NEAR Club (LNC) es una plataforma integral y práctica de integración para el protocolo NEAR, donde puedes aprender a usar y construir en el protocolo NEAR, y ganar tokens NEAR. LNC cuenta con una variedad de guías y cursos de integración. Los usuarios en LNC también pueden ganar nLearns, que son básicamente puntos internos, que actúan como recompensa para los aprendices destacados. Los usuarios en LNC pueden comenzar con Guías NEAR, Cursos NEAR o acuñar su propio NFT de (L)Earner.

Ahora que has aprendido sobre SWEAT, puedes ir a Learn NEAR Club, y (L)Earn. También puedes consultar la Guía de Sweatcoin disponible en LNC, junto con una variedad de otras guías y cursos. 







	

	
	
		
			
				What can you do with your Sweatcoins?
			
		

		
					

		
			
			
			
			Buy deals, products, and digital offers
		
			
			Bid in high-value auctions (PlayStation 5, GoPro Hero 9)
		
			
			Donate to charities like Save the Children
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### My personal Digital data

My personal digital data
                         
 
                        My personal Digital data(Required)
			
					
					Belongs to me and I want to control it
			
			
					
					Owned and controlled  by apps to maximize their profit
			
			
					
					Owned and controlled  by apps to maximize my profit
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Ano ang (L)Earner NFTs?

Isang nakakabighaning bagong koleksyon ng NFT ang kamakailan lang na inilabas sa NEAR Ecosystem. Bago natin alamin kung ano ang (L)Earner NFT collection, narito ang maikling buod ng kung ano ang isang NFT. Huwag mag-atubiling mag-skip kung ikaw ay pamilyar na sa NFT.

Ano ang isang NFT?
Ang NFT ay tumutukoy sa Non-Fungible Token. Ang mga NFT ay mga natatanging digital na ari-arian na may kanilang impormasyon ng pagkakakilanlan na naitala sa isang smart contract. Ang impormasyon sa smart contract ang nagpapagawa ng isang NFT na natatangi. Ang isang NFT ay isang hindi mapalitang ari-arian. Ang hindi mapalitang ari-arian ay hindi maipamamahagi. Halimbawa, hindi mo maaring ipadala sa iba ang isang bahagi ng isang pintura o tiket.

Ang mga NFT ay digital na sertipiko ng pagmamay-ari para sa digital na ari-arian. Ang isang NFT ay isang smart contract na ginagamit para sa pagtitiyak ng isang digital na ari-arian. Kapag isinulat na ito, ito ay inilalathala sa isang token (ERC-721 o NEP-171) sa blockchain. Anuman ay maaaring maging isang NFT, at ang pinakapopular ay mga video, GIFs, o JPEGs.

Ano ang (L)Earner NFT Collection?
Ang (L)Earner NFT Collection ay isang kolaborasyon sa pagitan ng Learn Near Club (LNC) community at Denis Bashev, isa sa mga pinakamahusay na nagwagi ng graphic designer sa Europa.

Konsepto ng Disenyo
Ang konsepto ng disenyo ay batay sa dinamikong pagkakaiba-iba ng tao na pinapalakas ng kakaibang katangian ng bawat mag-aaral. Bawat tao ay isang natatanging indibidwal na may iba't ibang paraan ng pag-aaral, lakas at kahinaan. Layunin ng (L)Earner NFT Collection na bigyang-diin ang indibidwalidad ng bawat mag-aaral at kung paano nag-iinteract ang iba't ibang sangkap sa makina upang lumikha ng isang buo at natatanging tao, bawat isa na may kaniya-kaniyang pangarap, takot, karanasan at personalidad.

Para sa mga hindi pamilyar sa kung paano tayo natututo sa isang siyentipikong antas, narito ang kabuuan nito:Kapag aktibong nakikilahok ka sa pag-aaral ng isang bagay, nagsisimula ang mga neuron (selula ng utak) na bumubuo ng mga koneksyon sa isa't isa. Sa simula, ang mga koneksyon na ito ay napaka-hina, at ang kaalaman ay hindi pa lubusang naiimbak sa pangmatagalang memorya. Habang lumilipas ang panahon at mas marami kang oras na ginugol sa pag-aaral ng isang konsepto, ang mga koneksyon na ito ay lumalakas at naiimbak sa pangmatagalang memorya. Ang iyong kaalaman ay tunay na naka-imbak sa bilyon-bilyong neural connections sa pagitan ng mga neuron sa utak ng tao. Tinatawag na Hebbian learning ang prosesong ito.



Ang ideya ng mga stick figures ay batay sa sistema ng nerbiyos ng tao. Ang mga segmentong binubuo ng mga stick people ay inspirasyon ng Myelin sheaths na tumutulong sa pagpapasa ng mga electric impulses sa pamamagitan ng mga neuron.

 

Ang mga poses ng karakter ay sumasagisag sa mga walang katapusang kombinasyon ng neural connections na nagkakaisa sa kanilang sariling microcosms upang bumuo ng mga natatanging pangmatagalang alaala ng isang konsepto o aktibidad. Ang mga line segments ay inilalagay sa isang cartesian plane upang lumikha ng mga masayang poses.

 

Ang color pallet ay maingat na pinili ni Denis upang magdala ng buhay, at magdagdag ng mas masayang tono sa mga stick people. Ito ay sumisimbolo sa kasiyahan ng pag-aaral. Ang kasiyahan sa pag-aaral ay hindi lamang nararamdaman sa agarang kasiyahan. Ito ay ang kabuuan ng lahat ng paraan kung paano ang uhaw para sa bagong kasanayan at kaalaman ay nagpabuti sa iyong buhay at sa buhay ng mga taong nasa paligid mo.


Tingnan ang talakayan ni Sasha tungkol sa NFTs sa pangkalahatan at (L)Earner nang partikular

https://youtu.be/Z9gYY-z2tms
Pagmimintis
Inaanyayahan ang lahat ng mga nagmimintis ng NFT na makilahok sa proyektong ito sa cutting edge. Ang mint cost ay nagsimula mula sa 2 $NEAR at unti-unting tataas habang lumalaki ang koleksyon patungo sa limitasyon nito na 10,000 NFTs. Ang mga nagmimintis ay maaaring:

 	Mag-generate- ang software ay nag-ge-generate ng isang random na pose, at halo ng mga kulay kung gaano karaming beses mo gusto, upang makuha mo ang (L)Earner NFT na gusto mo. Karamihan sa mga NFT sa merkado ay "generated" mula sa mga pre-built models, habang ang (L)Earner NFTs ay may halos walang hanggang bilang ng mga kombinasyon na lumilikha ng isang NFT na tunay na natatangi sa iyo.

 	Pangalan- bigyan ng pangalan ang iyong (L)Earner NFT, gawing kasing-unique ng iyong karakter


 	Magmint- magmint ng iyong NFT at siguruhing ito ay naka-secure sa NEAR blockchain.


 	Kurasyon- magtipon ng kahit ilan at kurasyon ang iyong orihinal, personal na koleksyon
 	Mag-trade- bumili at magbenta ng (L)Earner NFTs sa Paras NEAR NFT Marketplace

Mga Benepisyo ng (L)Earner NFT LNC
Hindi lang ikaw makakakuha ng cool na NFT kapag nagmi-mint ka ng (L)Earner NFT, makakakuha ka rin ng mga perks bilang opisyal na miyembro ng LNC community:

 	Priority 2 oras na maagang access sa Redeem to NEAR window
 	Iyong sariling CalenD
 	Mint Proof ng (L)Earn NFTs
 	Marami pang darating sa hinaharap...

Sumali sa LNC telegram group upang ibahagi ang iyong (L)Earner NFT sa iba pang miyembro ng komunidad.
Tindahan ng Swag ng Learn NEAR Club
BAGO! Ngayon maaari kang mag-order ng iyong sariling (L)Earner NFT bilang sticker sa totoong buhay mula sa LNC Swag store


Konklusyon
Ang koleksyon ng (L)Earner NFT ay isang cutting edge na collaboration sa pagitan ng LNC at Denish Bashev (award winning graphic designer). Layunin ng proyekto na mailarawan ang indibidwal na karanasan sa pag-aaral ng bawat mag-aaral sa isang NFT. Ang koleksyon ay limitado sa 10,000 NFT kaya kunin mo ang sa iyo habang maaari!

### (L)Earner NFTsとは何ですか？

最近、NEARエコシステムに新しい興奮をもたらすNFTコレクションがリリースされました。 (L)Earner NFTコレクションとは何かを探る前に、NFTとは何かについての簡単な要約をご紹介します。NFTについて既にご存知の場合は、スキップしても構いません。
NFTとは何ですか？
NFTは「Non-Fungible Token」の略です。NFTは、スマートコントラクトにその識別情報が記録されたユニークなデジタルアセットです。スマートコントラクト上の情報がNFTをユニークにします。NFTは、分割できない非代替性アセットです。例えば、絵画やチケットの一部を誰かに送ることはできません。

NFTはデジタルアセットの所有権のデジタル証明書です。NFTは、デジタルアセットを保護するために利用されるスマートコントラクトです。一度書かれると、ブロックチェーン上のトークン（ERC-721またはNEP-171）に公開されます。何でもNFTに変換できますが、最も人気のあるものは動画、GIF、またはJPEGです。
(L)Earner NFTコレクションとは何ですか？
(L)Earner NFTコレクションは、Learn Near Club (LNC)コミュニティと、ヨーロッパで最も優れた賞を受賞したグラフィックデザイナーのDenis Bashevのコラボレーションです。
デザインコンセプト
デザインコンセプトは、各学習者のユニークさによって力を得たダイナミックな人間の知性の多様性に基づいています。すべての人間は、異なる学習パターン、強み、弱みを持つユニークな個人です。 (L)Earner NFTコレクションは、各学習者の個性と、異なる歯車が機械内でどのように相互作用して、それぞれが独自の夢、恐怖、経験、個性を持つ完全な人間を作り出すかを強調することを目的としています。



科学的レベルで学ぶ方法に慣れていない方のために、以下にその要点を示します：何かを積極的に学ぶと、ニューロン（脳細胞）がお互いにつながりを形成し始めます。最初はこれらのつながりは非常に弱く、知識は長期記憶に完全に確約されていません。時間が経つにつれて、ある概念について学ぶ時間を増やすと、これらのつながりは強くなり、長期記憶に確約されます。あなたの知識は、人間の脳のニューロン間の数十億の神経結合に実際に保存されています。このプロセスはヘビアン学習と呼ばれます。



スティックフィギュアのアイデアは、人間の神経系に基づいています。スティック人々が構成されているセグメントは、ニューロンを通じて電気インパルスを伝達するのに役立つミエリン鞘に触発されています。

 

キャラクターポーズは、概念や活動の独自のマイクロコスモを形成する無数の神経結合の組み合わせを具現化しています。直線セグメントは、楽しいポーズを作成するために直交座標平面にプロットされます。

 

色のパレットは、生命をもたらし、スティック人々により遊び心のあるトーンを加えるようデニスが注意深く選択しました。それは学ぶ喜びを象徴しています。学ぶ喜びは、ただちに満足感を感じることができるものではありません。それは、新しいスキルや知識への渇望があなたの人生と周囲の人々の人生をどのように向上させたかのすべての方法の集大成です。


Sashaの一般的なNFTに関するトークと（L）Earnerについての詳細はこちら

https://youtu.be/Z9gYY-z2tms
Minting
すべてのNFTミンターは、この最先端のプロジェクトに参加するよう招待されています。 ミント コスト は、最初は 2 $NEAR から始まり、コレクションが10,000個のNFTに向けて成長するにつれて徐々に増加します。ミンターは以下のことができます：

 	生成- ソフトウェアはランダムなポーズと色の組み合わせを何度でも生成し、欲しい（L）Earner NFTを手に入れることができます。市場に出回っているほとんどのNFTは、事前に構築されたモデルから「生成」されていますが、（L）Earner NFTは、あなたに真にユニークなNFTを作成する無限の組み合わせを持っています。

 	Name- (L)Earner NFTに名前を付けて、キャラクターと同様にユニークなものにしてください


 	Mint- NFTを作成し、NEARブロックチェーン上でセキュアに保管します。


 	Curate- お好きなだけ集め、オリジナルで個人的なコレクションをキュレーションしてください
 	Trade- Paras NEAR NFT Marketplaceで(L)Earner NFTを購入および販売します

(L)Earner  NFT LNC Benefits
(L)Earner NFTを作成すると、かっこいいNFTだけでなく、公式LNCコミュニティメンバーとして便利な特典も受け取れます：

 	リディームto NEARウィンドウへの2時間早いアクセスの優先権
 	あなただけのCalenD
 	(L)Earn NFTsのミント証明
 	今後もさらに追加予定…

(L)Earner NFTを他のコミュニティメンバーと共有するために、LNCテレグラムグループに参加してください。
Learn NEAR Club Swag store
NEW! 今、LNC Swag storeから(L)Earner NFTをリアルライフステッカーとして注文できます


Conclusion
(L)Earner NFTコレクションは、LNCとDenish Bashev（受賞歴のあるグラフィックデザイナー）の最先端のコラボレーションです。このプロジェクトの目的は、各学習者の個々の学習体験をNFTに収めることです。コレクションは10,000個に限定されているので、手に入れるチャンスを逃さないようにしましょう！

### (L)Earner NFTs는 NEAR Protocol에서 사용되는 특별한 유형의 NFT입니다. NEAR 생태계에서 사용자가 수익을 창출하고 배포하는 방법 중 하나입니다. NFT를 보유하고 있는 사용자는 수익을 얻을 수 있으며, 이는 NEAR 생태계의 발전에 기여할 수 있습니다.

NEAR Protocol에서 최근 놓칠 수 없는 새로운 NFT 컬렉션이 출시되었습니다. (L)Earner NFT 컬렉션에 대해 알아보기 전에 NFT가 무엇인지 간단히 요약해보겠습니다. 이미 NFT에 익숙하다면 건너뛰어도 괜찮습니다.
NFT란 무엇인가요?
NFT은 Non-Fungible Token의 약자입니다. NFT는 고유한 디지털 자산으로, 스마트 계약에 식별 정보가 기록되어 있습니다. 스마트 계약에 있는 정보가 NFT를 고유하게 만듭니다. NFT는 대체할 수 없는 자산입니다. 예를 들어, 그림이나 티켓의 일부를 보낼 수는 없습니다.

NFT는 디지털 자산의 소유권을 나타내는 디지털 인증서입니다. NFT는 디지털 자산을 보호하기 위해 사용되는 스마트 계약입니다. 작성된 후 블록체인에 토큰(ERC-721 또는 NEP-171)으로 발행됩니다. 모든 것을 NFT로 변환할 수 있으며, 가장 인기 있는 것은 비디오, GIF 또는 JPEG입니다.
(L)Earner NFT 컬렉션은 무엇인가요?
(L)Earner NFT 컬렉션은 Learn Near Club (LNC) 커뮤니티와 유럽 최고의 수상 경력을 지닌 그래픽 디자이너인 Denis Bashev의 협업작품입니다.
디자인 컨셉
디자인 컨셉은 모든 학습자의 독특함에 의해 구동되는 동적 인간 지능 다양성에 기반합니다. 각 인간은 다양한 학습 패턴, 강점 및 약점을 가진 독특한 개인입니다. (L)Earner NFT 컬렉션은 각 학습자의 개성을 강조하고 서로 다른 톱니바퀴가 기계 안에서 상호 작용하여 독특한 꿈, 두려움, 경험 및 성격을 가진 전체적인 인간을 만들어낸다는 목표를 가지고 있습니다.



과학적 수준에서 학습하는 방법에 익숙하지 않은 분들을 위해 간단히 설명드리면 다음과 같습니다:무언가를 학습하는 데 적극적으로 참여하면 신경세포(뇌세포)가 서로 연결을 형성하기 시작합니다. 처음에는 이러한 연결이 매우 약하며 지식이 장기 기억에 완전히 고정되지 않습니다. 시간이 지남에 따라 특정 개념에 대해 더 많은 시간을 투자하면 이러한 연결이 강해지고 장기 기억에 고정됩니다. 실제로 인간 뇌의 뉴런 사이에 수십억 개의 신경 연결에 지식이 저장됩니다. 이 과정을 헤비안 학습이라고 합니다.



스틱 인형의 아이디어는 인간 신경계를 기반으로 합니다. 스틱 인형이 구성된 세그먼트는 뉴런을 통해 전기 자극을 전달하는 데 도움을 주는 미엘린 시트에 영감을 받았습니다.

 

캐릭터 포즈는 특정 개념이나 활동의 독특한 장기 기억을 형성하기 위해 자신만의 소규모 세계에서 융합되는 수많은 신경 연결의 조합을 대변합니다. 직선 세그먼트는 재미있는 포즈를 만들기 위해 직교 좌표계에 플로팅됩니다.

 

색상 팔레트는 Denis가 신경 인형에 생명을 불어넣고 더 재미있는 톤을 추가하기 위해 신중히 선택되었습니다. 이는 학습의 즐거움을 상징합니다. 학습의 즐거움은 즉각적인 만족으로 느낄 수 있는 것이 아닙니다. 새로운 기술과 지식에 대한 갈증이 어떻게 당신의 삶과 주변 사람들의 삶을 개선했는지의 모든 방식의 결합입니다.


Sasha의 NFT에 대한 일반적인 이야기와 (L)Earner에 대한 이야기를 확인해보세요

https://youtu.be/Z9gYY-z2tms
Minting
모든 NFT 발행자들은 이 첨단 프로젝트에 참여할 것을 초대받습니다. 발행 비용은 2 $NEAR부터 시작되어 컬렉션이 10,000개의 NFT로 성장함에 따라 점차 증가합니다. 발행자들은 다음을 할 수 있습니다:

 	생성- 소프트웨어가 원하는 (L)Earner NFT를 얻을 수 있도록 무작위 자세와 색상의 조합을 여러 번 생성할 수 있습니다. 시장에 있는 대부분의 NFT는 미리 제작된 모델에서 "생성"되는 반면, (L)Earner NFT는 당신에게 완전히 독특한 NFT를 만드는 거의 무한한 조합을 가지고 있습니다.

 	Name- (L)Earner NFT에 이름을 지어주세요. 캐릭터와 독특성을 반영해주세요.


 	Mint- NFT를 발행하고 NEAR 블록체인에 안전하게 보관하세요.


 	Curate- 원하는 만큼 수집하고 독창적이고 개인적인 컬렉션을 만드세요.
 	Trade- Paras NEAR NFT 마켓플레이스에서 (L)Earner NFT를 구매하고 판매하세요.

(L)Earner  NFT LNC 혜택
(L)Earner NFT를 발행하면 멋진 NFT뿐만 아니라 LNC 공식 커뮤니티 회원으로서 유용한 혜택을 받을 수 있습니다:

 	리딤을 NEAR로 2시간 일찍 할 수 있는 우선권 제공
 	나만의 CalenD
 	(L)Earn NFT의 발행 증명
 	앞으로 더 많은 혜택이 제공될 예정입니다...

(L)Earner NFT를 LNC 커뮤니티의 다른 회원들과 공유하려면 LNC 텔레그램 그룹에 가입하세요.
Learn NEAR Club 스왹 스토어
NEW! 이제 LNC 스왹 스토어에서 (L)Earner NFT를 실제 스티커로 주문할 수 있습니다.


결론
(L)Earner NFT 컬렉션은 LNC와 Denish Bashev(수상 경력을 가진 그래픽 디자이너) 간의 첨단 협업입니다. 이 프로젝트의 목표는 각 학습자의 개별 학습 경험을 NFT로 담아내는 것입니다. 컬렉션은 10,000개로 제한되어 있으므로 가능한 한 빨리 구매하세요!

### なぜWordPressがWeb3への扉を開ける可能性があるのか

Web3への移行は避けられないようです。既にいくつかの企業が、NFT、メタバース、トークン化など、web3のさまざまな側面を実験し始めています。しかし、この移行をどのようにスムーズにするのでしょうか？Learn Near Clubでは、web3の未来を、証明済みでオープンなweb2プラットフォームにweb3ツールを組み込むことで実現できます。その中でも最も優れた例として挙げられるのが「証明済みでオープンな」Webプラットフォームの1つ、WordPressです。このブログでは、WordPressが中央集権的なフレームワーク内で分散型成長を促進する方法を見てみましょう。WordPressとは？
WordPressは、ユーザーがウェブサイトやブログを作成および管理できる人気のあるオープンソースのコンテンツ管理システム（CMS）です。2003年のリリース以来、インターネット上のすべてのウェブサイトの約43%を支える最も広く使用されているウェブサイトプラットフォームの1つに成長しました。

その人気の理由の1つは、コーディングの知識を必要としないユーザーフレンドリーなインターフェースです。これにより、簡単にコンテンツを作成および公開したい人々の間で人気があります。さらに、多くの開発者コミュニティが数多くのプラグインやテーマを作成しており、これらはプラットフォームに簡単に統合でき、追加の機能と美的魅力を提供します。

WordPressは高度にカスタマイズ可能であり、小規模な個人ブログから大規模な企業サイトまで幅広いウェブサイトに対応できます。また、ビジネスやウェブサイトの成長に合わせて拡張できるスケーラビリティも備えています。必要に応じて新しい機能や機能を追加できるため、非常に適応性が高いです。

WordPressのもう1つの利点は、SEOに優しい構造です。WordPressで構築されたウェブサイトには、コンテンツを最適化し、検索エンジンにフレンドリーにするための組み込みのSEOツールがあります。この機能により、多くの企業や個人が、ウェブサイトが検索エンジンに簡単に見つけられるようにしたいと考えるため、WordPressが選択されることが多くなっています。
WordPressの哲学
WordPressの哲学は、その開発とコミュニティを導くいくつかの基本原則に基づいています。これらの原則は：
 	誰もがオンラインでコンテンツを作成および公開できるユーザーフレンドリーかつアクセス可能なプラットフォームを提供します。つまり、ソフトウェアは使いやすく、理解しやすく、無料でアクセスできる必要があります。
 	オープンソースであるため、ソフトウェアは制限なく使用、変更、配布できます。これにより、プラットフォームを常に改善し、新機能や機能を追加する開発者コミュニティが形成されました。
 	ユーザーが協力して知識を共有することを奨励し、ユーザー、開発者、貢献者の活発なコミュニティが形成され、プラットフォームをより良くするために協力しています。
 	技術的な専門知識や身体的な能力に関係なく誰でも使用できるツールを提供します。つまり、ソフトウェアはアクセシビリティを考慮して設計され、すべてのユーザーが簡単に使用およびナビゲートできるようにする必要があります。

WordPressは、オープンでアクセス可能でユーザーフレンドリーなプラットフォームを作成することに焦点を当てており、コミュニティと協力に重点を置いています。これらの基本原則は、WordPressを世界で最も人気のあるコンテンツ管理システムの1つにしました。
	バグを報告したり、新機能を提案したり、既存の機能にフィードバックを行うことで、ユーザーは開発者が問題を特定し必要な改善を行うのを助けます。このフィードバックはプラットフォームの持続的な成長と成功にとって重要です。
	WordPressは多言語で利用可能ですが、さらに多くの翻訳者が必要です。プラットフォームをより多くの人々にアクセス可能にするために、複数の言語に堪能である必要はありません - 小さな貢献でも大きな違いを生むことができます。
	コーディングスキルを持っている場合、WordPressにコードを書いたり、バグを修正したり、新機能を開発することで貢献することができます。WordPressはオープンソースプラットフォームであり、誰でもそのコードにアクセスして開発に貢献することができます。スキルや興味に応じて、WordPressのコア、プラグイン、またはテーマに貢献することができます。
	ドキュメンテーション、デザイン、またはコミュニティマネジメントを手伝うことで、WordPressに貢献することもできます。これらの分野はコーディングと同じくらい重要であり、参加の機会はたくさんあります。
	フォーラムで他のユーザーを助けたり、ミートアップに参加したり、WordPressイベントを開催することで、WordPressコミュニティをサポートすることができます。コミュニティをサポートすることで、誰もが利益を得る歓迎される包括的な環境を作り出すことができます。

WordPress経済
WPEngineによる調査によると、2020年にはWordPressに関連するすべての企業、開発者、ユーザーを含む世界中のWordPress経済は約$596.7 billionで評価されました。

Automatticは、WordPress.comの背後にあるグローバルな分散型企業であり、96か国に住む1,983人のAutomatticiansが123の異なる言語を話しており、オフィスはZEROです。

WordPressで収益を上げることはさまざまな方法で可能です。以下はWordPressウェブサイトを収益化するためのいくつかの方法です：
 	ECOMMERCE: WooCommerceのようなプラグインを使用して、WordPressのウェブサイトをオンラインストアに変えて、物理的またはデジタル製品、サービス、予約を販売できます。
 	広告: ウェブサイトに広告を表示し、クリックごと（PPC）またはその他の広告モデルを通じて収益を得る。Google AdSenseはサイトに関連する広告を表示する人気のオプションです。
 	アフィリエイトマーケティング: ブログやウェブサイトで他社の製品やサービスをプロモートし、固有のアフィリエイトリンクを使用します。紹介を通じて行われた各販売またはアクションに対して手数料を得ます。
 	独占コンテンツ: 訪問者に有料でプレミアムまたは独占コンテンツを提供します。これには記事、ビデオ、コース、その他の貴重なリソースが含まれる場合があります。
 	オンラインコース: 専門知識やスキルを持っている場合、WordPressのウェブサイトを通じてオンラインコースを作成して販売できます。これにより、専門知識を共有し、知識を収益化することができます。
 	プラグインの開発: コーディングスキルを持っている場合、WordPress用のプラグインを開発して販売できます。多くのウェブサイト所有者は、ウェブサイトの機能を向上させるプラグインに対して支払いをすることを喜んでいます。
 	クライアント向けのWordPressサイトの構築: ウェブ開発のスキルを持っている場合、クライアントに対してWordPressウェブサイトのデザインと開発サービスを提供できます。高品質のウェブサイトを提供できれば、これは利益を上げるビジネスになります。

これがWeb3の真髄ではありませんか？
コミュニティに大きく依存するモデルを作成することで、WordPressはWeb3の非常に先鋭に位置するビジネスを作り出しました。覚えておいてください、Web3の環境では、すべての操作が中央集権的な取締役会ではなくコミュニティによって実行されます。WordPressはWeb2のシナリオでそのモデルを可能な限り先駆者としています。

さらに、WordPressは、地理的位置、政治的および経済的状況に関係なく、実際のユーザーに実際の価値を提供する意志のあるすべての人々に無限の機会を提供します。
Learn Near ClubがWordPressのWeb3への道程にどのように貢献しているか
WordPress用の2つのプラグインを作成しました。これにより、ユーザーはNearエコシステムと連携できます。

 	NEARでログイン
 	LNC Near Comments

NEARでログイン


簡単にショートコードを使用してWordPressサイトでNEARでログイン機能を設定およびカスタマイズできます。以下にいくつかの機能を紹介します。
	人気のあるNearウォレットをサポート - “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, “Sender”
	簡単な登録とログイン：ユーザーがNearウォレットを持っている場合、すでにサイトのすべての機能を使用し、WPユーザーとして識別されます
	WordPressアプリがNEARスマートコントラクトを使用している場合、プラグインを使用してユーザーがそれ用の機能制限付きアクセスキーを作成できます。また、ユーザーは他のスマートコントラクトに対して変更/表示メソッドを呼び出すことができます
	プラグインはログインUIを簡単にカスタマイズできます。

プラグインを作成し、ログインしたユーザーからスマートコントラクトを呼び出す場合は、次のように簡単に行うことができます：

view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

プラグインデモを見る。

プラグインをダウンロード。
LNC Near Comments


簡単なショートコード[lnc_near_comments]を使用して、WordPressサイトにLNC Near Commentsプラグインを統合およびカスタマイズできます。以下に考慮すべき機能がいくつかあります：

	人気のあるNearウォレットをサポート - “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, “Sender”
	コメントセクションに固有のキャプチャを提供し、ユーザーコメントをv1.ncaptcha.nearスマートコントラクトへの小さなチップトランザクション後に投稿します
	ユニークな支払いシステムにより、ユーザーが解決した各キャプチャに対して支払いの一部を受け取ることができます。収益を自分の側で構成できます
	最新バージョンのWordPressとの動作をテストおよび設計されています。プラグインを使用する前にWordPressのインストールが更新されていることを確認してください
	LNC Near Commentsプラグインは正しく機能するためにNear Loginプラグインが必要です。必要な依存関係やインストール手順については、プラグインのドキュメントを参照してください。

スマートコントラクトを使用してプラグインを活用し、ログインしたユーザーが相互作用できるようにするには、次のメソッドを使用してください：

View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

プラグインデモを見る。

プラグインをダウンロード。
最後にweb2とweb3技術の交差点は、デジタル世界にとってユニークでエキサイティングなフロンティアを提供しています。WordPressのような従来のプラットフォームは、この進化する環境での適応性と関連性を示してきました。分散型ドメイン名システム、分散型ストレージシステム、暗号通貨支払いAPIなどのweb3機能を統合することで、WordPressはハイブリッドモデルを具現化し、web3革命の最前線に位置しています。

WordPressのオープンソースでコミュニティ主導の精神は、web3の原則と密接に一致しています。広範な採用、使いやすさ、適応性により、WordPressはより分散型のインターネットへの移行の理想的な飛び地となっています。コミュニティの貢献をサポートし奨励することで、WordPressはweb2の文脈でweb3に似た環境を育んでいます。

NEARをWordPressに接続して参加したい方は、このTelegram Groupに参加してください



	

	
	
		
			
				Which of the following is not a way that users can contribute to WordPress?
			
		

		
					

		
			
			
			
			Reporting bugs and suggesting new features
		
			
			Helping with translations
		
			
			Writing code or fixing bugs
		
			
			Paying for premium features
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR CLIの紹介

NEAR CLI（Command Line Interface）は、開発者やユーザーがNEAR Protocolと直接やり取りするために設計された強力なツールです。これにより、グラフィカルインターフェースを必要とせずに、アカウントの管理、契約の展開、その他のタスクが簡素化されます。NEAR CLIとは？
NEAR CLIは、NEARブロックチェーンと連携するためのコマンドラインツールです。ユーザーは以下を行うことができます：

 	アカウントの管理
 	スマートコントラクトの展開とやり取り
 	トークンの送受信
 	アカウント残高と取引履歴の表示
 	タスクを自動化するためのさまざまなスクリプトの実行

NEAR CLIを使用する理由
開発者や上級ユーザーの場合、NEAR CLIを使用することでNEARアカウントやスマートコントラクトを直接制御できます。軽量であり、開発ワークフローに簡単に統合して自動化やスクリプト化を目的として使用できます。
はじめに

 	インストール：Windowsマシンでは、NEAR CLIは.msiインストーラーを介してインストールできます。
最新のものはこちらで入手できます：
https://github.com/near/near-cli-rs/releases/
 	NEAR CLIの使用を開始：初心者向けには、インタラクティブモードでnear-cliを使用することをお勧めします。
Windowsターミナルに次のように入力してください：
near


Dive deeper at NEAR Docs
機能

 	アカウント管理：NEARアカウントの作成、削除、管理を簡単に行うことができます。
 	スマートコントラクトのやり取り：契約の展開と契約上の関数の呼び出しを行います。
 	トークンの送金：NEARトークンを任意のアカウントに送信します。
 	取引履歴：任意のアカウントの過去の取引と残高を表示します。

結論
NEAR CLIは、NEARブロックチェーンと強力かつ柔軟にやり取りするための開発者や上級ユーザーにとって不可欠なツールです。使いやすく、スクリプト可能であり、開発ワークフローとシームレスに統合します。NEAR エコシステムに飛び込む準備が整っている場合、NEAR CLIは素晴らしいスタート地点です！

詳細情報については、NEAR CLIドキュメントをご覧ください。

### Mengapa WordPress Dapat Membuka Gerbang ke Web3

Transisi ke web3 tampaknya tak terhindarkan. Beberapa perusahaan sudah mulai bereksperimen dengan berbagai aspek web3, seperti NFT, metaverse, dan tokenisasi. Namun, bagaimana kita bisa melancarkan transisi ini? Di Learn Near Club, masa depan web3 dapat dicapai dengan menggabungkan peralatan web3 ke dalam platform web2 yang terbukti dan terbuka. Salah satu contoh terbaik dari platform web yang "terbukti dan terbuka" adalah WordPress. Di blog ini, mari kita lihat bagaimana WordPress mendorong pertumbuhan terdesentralisasi dalam kerangka terpusatnya.
Apa itu WordPress?
WordPress adalah sistem manajemen konten (CMS) sumber terbuka yang populer yang memungkinkan pengguna untuk membuat dan mengelola situs web dan blog. Sejak dirilis pada tahun 2003, WordPress telah tumbuh menjadi salah satu platform situs web yang paling banyak digunakan, menggerakkan sekitar 43% dari semua situs web di Internet.

Salah satu alasan utama popularitasnya adalah antarmuka yang ramah pengguna yang tidak memerlukan pengguna untuk memiliki pengetahuan pemrograman. Hal ini menjadikannya pilihan populer bagi mereka yang ingin membuat dan menerbitkan konten dengan mudah. Selain itu, komunitas besar pengembang telah membuat berbagai plugin dan tema, yang dapat dengan mudah diintegrasikan ke dalam platform, memberikan fungsionalitas tambahan dan daya tarik estetika.

https://www.youtube.com/watch?v=HCyn97xeKig

WordPress sangat dapat disesuaikan, yang berarti dapat melayani berbagai situs web, mulai dari blog pribadi kecil hingga situs korporat besar. Ini juga dapat berkembang seiring dengan pertumbuhan bisnis atau situs web. Platform ini memiliki kemampuan untuk menambahkan fitur dan fungsionalitas baru sesuai kebutuhan, menjadikannya sangat mudah beradaptasi.

Keuntungan lain dari WordPress adalah strukturnya yang ramah SEO. Situs web yang dibangun dengan WordPress memiliki alat SEO bawaan yang memungkinkan pengguna untuk mengoptimalkan kontennya dan memastikan bahwa konten tersebut ramah mesin telusur. Fitur ini telah membuat WordPress menjadi pilihan yang disukai oleh banyak bisnis dan individu yang ingin situs web mereka mudah ditemukan oleh mesin telusur.


Filosofi WordPress
Filosofi WordPress dibangun di atas beberapa prinsip inti yang memandu pengembangannya dan komunitasnya. Prinsip-prinsip ini adalah:
	Memberikan platform yang ramah pengguna dan mudah diakses bagi siapa pun untuk membuat dan mempublikasikan konten secara online. Ini berarti bahwa perangkat lunak harus mudah digunakan, mudah dipahami, dan gratis diakses.
	Dengan menjadi sumber terbuka, perangkat lunak tersedia secara gratis untuk digunakan, dimodifikasi, dan didistribusikan tanpa batasan. Hal ini telah membantu menciptakan komunitas besar pengembang yang terus memperbaiki dan membangun platform, menambah fitur-fitur baru, dan fungsionalitas.
	Mendorong pengguna untuk bekerja sama dan berbagi pengetahuan, yang telah mengarah pada terciptanya komunitas yang ramai dari pengguna, pengembang, dan kontributor yang bekerja sama untuk membuat platform menjadi lebih baik.
	Memberikan alat yang dapat digunakan oleh siapa pun, tanpa memandang keahlian teknis atau kemampuan fisik mereka. Ini berarti bahwa perangkat lunak harus dirancang dengan aksesibilitas dalam pikiran, sehingga mudah digunakan dan dinavigasi oleh semua pengguna.

WordPress berfokus pada menciptakan platform yang terbuka, mudah diakses, dan ramah pengguna, dengan penekanan kuat pada komunitas dan kolaborasi. Prinsip-prinsip inti ini telah membantu membuat WordPress menjadi salah satu sistem manajemen konten paling populer di dunia.




	

	
	
		
			
				What is one of the key reasons for the popularity of WordPress as a content management system?
			
		

		
					

		
			
			
			
			Its cost
		
			
			Its user-friendly interface does not require users to have any coding knowledge
		
			
			Its compatibility with other platforms
		
			
			Its proprietary nature
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress dan Web3
Mari kita lihat hubungan yang ada antara WordPress dan web3. Meskipun WordPress tidak secara inheren merupakan platform Web3, ada cara untuk mengintegrasikan teknologi Web3 ke dalam Wordpress untuk menciptakan situs web yang lebih terdesentralisasi dan aman. Salah satu cara tersebut adalah melalui penggunaan sistem nama domain terdesentralisasi (DNS), seperti Unstoppable Domains. Anda juga dapat menggunakan sistem penyimpanan terdesentralisasi, seperti IPFS. IPFS adalah sistem penyimpanan peer-to-peer yang memungkinkan pengguna untuk menyimpan dan berbagi file secara terdesentralisasi dan tahan sensor. Dengan mengintegrasikan IPFS ke dalam situs web WordPress, pengguna dapat menciptakan platform yang lebih aman dan terdesentralisasi untuk berbagi konten. Terakhir, pencipta situs web selalu dapat mengintegrasikan API pembayaran kripto untuk mengakses pembayaran terdesentralisasi.
Wordpress adalah Standar Emas
Seperti yang dapat Anda lihat, WordPress adalah platform web2 yang fleksibel yang memungkinkan Anda untuk dengan mudah mengintegrasikan teknologi web3. Ada alasan mengapa CMS ini digunakan oleh 38% dari semua situs web internet untuk membuat dan mengelola berbagai jenis situs seperti blog pribadi, toko online, dan lainnya. Sifat terbuka ini juga telah memungkinkan WordPress untuk menciptakan komunitas kontributor yang terbuka dan ramai. Para kontributor ini bekerja keras untuk memperbaiki platform dengan mengembangkan fitur-fitur baru, memperbaiki bug, dan memelihara kode inti. Siapa pun dapat berkontribusi ke WordPress, dan ada banyak cara untuk melakukannya.




	

	
	
		
			
				How does WordPress align with the principles of web3?
			
		

		
					

		
			
			
			
			By being a centralized platform with a fixed set of features
		
			
			By relying on a single developer for all updates
		
			
			By being a closed-source platform
		
			
			By supporting and encouraging community contributions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Kontributor Membantu WordPress
	Dengan melaporkan bug, menyarankan fitur baru, dan memberikan umpan balik tentang fitur yang sudah ada, pengguna membantu pengembang mengidentifikasi masalah dan melakukan perbaikan yang diperlukan. Umpan balik ini sangat penting untuk pertumbuhan dan kesuksesan platform.
	WordPress tersedia dalam banyak bahasa, tetapi selalu ada kebutuhan untuk lebih banyak penerjemah untuk membantu membuat platform dapat diakses oleh lebih banyak orang. Seseorang tidak perlu lancar dalam beberapa bahasa untuk membantu dengan terjemahan - bahkan kontribusi kecil dapat membuat perbedaan besar.
	Jika Anda memiliki keterampilan pemrograman, Anda dapat berkontribusi pada WordPress dengan menulis kode, memperbaiki bug, atau mengembangkan fitur baru. WordPress adalah platform sumber terbuka, dan siapa pun dapat mengakses kode-nya dan berkontribusi pada pengembangannya. Bergantung pada keterampilan dan minat Anda, Anda dapat berkontribusi pada inti WordPress, plugin, atau tema.
	Anda juga dapat berkontribusi pada WordPress dengan membantu dalam dokumentasi, desain, atau manajemen komunitas. Area-area ini sama pentingnya dengan pemrograman, dan ada banyak kesempatan untuk terlibat.
	Anda dapat mendukung komunitas WordPress dengan membantu pengguna lain di forum, menghadiri pertemuan, dan mengorganisir acara WordPress. Dengan mendukung komunitas, Anda menciptakan lingkungan yang ramah dan inklusif yang bermanfaat bagi semua pihak yang terlibat.

Ekonomi WordPress
Menurut sebuah studi oleh WPEngine, Ekonomi WordPress global, yang mencakup semua bisnis, pengembang, dan pengguna yang terkait dengan WordPress, bernilai sekitar $596.7 miliar pada tahun 2020.

Automattic, perusahaan global yang didistribusikan di balik WordPress.com dengan 1.983 Automatticians di 96 negara yang berbicara dalam 123 bahasa yang berbeda, tidak memiliki kantor.

Menghasilkan uang di WordPress memungkinkan melalui berbagai metode. Berikut adalah beberapa cara terbaik untuk memonetisasi situs web WordPress Anda:
 	Ecommerce: Gunakan plugin seperti WooCommerce untuk mengubah situs web WordPress Anda menjadi toko online di mana Anda dapat menjual produk fisik atau digital, layanan, atau janji temu.
 	Periklanan: Tampilkan iklan di situs web Anda dan dapatkan uang melalui model pembayaran per klik (PPC) atau model periklanan lainnya. Google AdSense adalah pilihan populer untuk menampilkan iklan yang relevan di situs Anda.
 	Pemasaran Afiliasi: Promosikan produk atau layanan dari perusahaan lain di blog atau situs web Anda menggunakan tautan afiliasi unik. Anda mendapatkan komisi untuk setiap penjualan atau tindakan yang dilakukan melalui referensi Anda.
 	Konten Eksklusif: Tawarkan konten premium atau eksklusif kepada pengunjung Anda dengan membayar. Ini dapat mencakup artikel, video, kursus, atau sumber daya berharga lainnya.
 	Kursus Online: Jika Anda memiliki pengetahuan atau keterampilan khusus, buat dan jual kursus online melalui situs web WordPress Anda. Ini memungkinkan Anda untuk berbagi keahlian Anda dan memonetisasi pengetahuan Anda.
 	Pembuatan Plugin: Jika Anda memiliki keterampilan pemrograman, Anda dapat mengembangkan dan menjual plugin untuk WordPress. Banyak pemilik situs web bersedia membayar untuk plugin yang meningkatkan fungsionalitas situs web mereka.
 	Membangun Situs WordPress untuk Klien: Jika Anda memiliki keterampilan pengembangan web, Anda dapat menawarkan layanan desain dan pengembangan situs web WordPress kepada klien. Ini bisa menjadi bisnis yang menguntungkan jika Anda dapat memberikan situs web berkualitas tinggi.

Bukankah Ini Etnos yang Sangat Penting dari Web3?
Dengan menciptakan model yang sangat bergantung pada komunitasnya untuk perbaikan, WordPress telah menciptakan bisnis yang berada di ambang web3. Ingatlah, dalam lingkungan web3, semua operasi dijalankan dan dilaksanakan oleh komunitas daripada dewan direksi terpusat. WordPress menjadi perintis model tersebut sebanyak mungkin dalam skenario web2.

Selain itu, WordPress menciptakan peluang tak terbatas bagi siapa pun yang bersedia menciptakan nilai nyata bagi pengguna nyata tanpa memandang lokasi geografis, kondisi politik, dan ekonomi.
Inilah Bagaimana Learn Near Club Memberikan Kontribusi pada perjalanan WordPress menuju web3
Kami telah membuat dua plugin untuk WordPress, yang memungkinkan pengguna terhubung dengan ekosistem Near.

 	Login dengan NEAR
 	Komentar Near LNC

Login dengan NEAR


Mudah menyiapkan dan menyesuaikan fungsionalitas login dengan NEAR di situs WordPress Anda dengan menggunakan shortcode sederhana. Berikut adalah beberapa fitur yang perlu diingat:
	Mendukung dompet Near populer seperti - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender"
	Pendaftaran dan login yang mudah: Jika pengguna memiliki Near Wallet, dia sudah dapat menggunakan semua fungsionalitas dari situs Anda dan diidentifikasi sebagai Pengguna WP
	Jika aplikasi WordPress Anda menggunakan kontrak pintar NEAR, plugin ini memungkinkan pengguna untuk membuat kunci akses terbatas fungsional untuknya. Selain itu, pengguna dapat melakukan panggilan untuk mengubah/melihat metode ke kontrak pintar lainnya
	Plugin ini juga mudah untuk menyesuaikan UI login.

Jika Anda ingin membuat plugin dengan kontrak pintar dan memanggilnya dari pengguna yang sudah login, Anda dapat melakukannya dengan cara ini:

metode tampilan: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

metode perubahan: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Tonton demo plugin.

Unduh plugin.
Komentar Near LNC


Integrasikan dan sesuaikan plugin Komentar Near LNC untuk situs WordPress Anda dengan menggunakan shortcode mudah [lnc_near_comments]. Berikut adalah beberapa fitur yang perlu diingat:

	Mendukung dompet Near populer seperti - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", dan "Sender"
	Memberikan captcha unik untuk bagian komentar dan memposting komentar pengguna setelah transaksi tip kecil ke kontrak pintar v1.ncaptcha.near
	Sistem pembayaran unik memungkinkan Anda menerima sebagian dari pembayaran untuk setiap captcha yang diselesaikan oleh pengguna Anda. Anda dapat mengonfigurasi pendapatan di sisi Anda
	Diuji dan dirancang untuk bekerja dengan versi terbaru WordPress. Pastikan instalasi WordPress Anda diperbarui sebelum menggunakan plugin
	Plugin Komentar Near LNC memerlukan plugin Near Login untuk berfungsi dengan baik. Silakan lihat dokumentasi plugin untuk dependensi dan petunjuk instalasi yang diperlukan.

Untuk menggunakan plugin dengan kontrak pintar dan memungkinkan pengguna yang sudah login berinteraksi, gunakan metode berikut:

Metode Tampilan: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Metode Perubahan: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Tonton demo plugin.

Unduh plugin.
PenutupPersimpangan teknologi web2 dan web3 menawarkan sebuah wilayah unik dan menarik bagi dunia digital. Platform tradisional seperti WordPress telah menunjukkan adaptabilitas dan relevansinya dalam lanskap yang terus berkembang ini. Dengan mengintegrasikan fitur web3 seperti sistem nama domain terdesentralisasi, sistem penyimpanan terdesentralisasi, dan API pembayaran kripto, WordPress mewujudkan model hibrid, menempatkannya di garis depan revolusi web3.

Etos sumber terbuka dan didorong oleh komunitas WordPress sejalan dengan prinsip-prinsip web3. Penerimaan yang luas, kemudahan penggunaan, dan adaptabilitasnya menjadikannya sebagai peluncur ideal untuk transisi ke internet yang lebih terdesentralisasi. Dengan mendukung dan mendorong kontribusi komunitas, WordPress memupuk lingkungan mirip web3 dalam konteks web2.

Jika Anda siap untuk berpartisipasi dalam menghubungkan NEAR ke WordPress, bergabunglah dengan Grup Telegram



	

	
	
		
			
				Which of the following is not a way that users can contribute to WordPress?
			
		

		
					

		
			
			
			
			Reporting bugs and suggesting new features
		
			
			Helping with translations
		
			
			Writing code or fixing bugs
		
			
			Paying for premium features
		
	
		

		
		
			
				Correct!
				Wrong!

### Introducción a NEAR CLI

NEAR CLI (Interfaz de Línea de Comandos) es una herramienta poderosa diseñada para ayudar a los desarrolladores y usuarios a interactuar con el Protocolo NEAR directamente desde la línea de comandos. Simplifica la gestión de cuentas, implementación de contratos y otras tareas sin necesidad de una interfaz gráfica.
¿Qué es NEAR CLI?
NEAR CLI es una herramienta de línea de comandos para trabajar con la cadena de bloques NEAR. Permite a los usuarios:

 	Gestionar cuentas
 	Implementar e interactuar con contratos inteligentes
 	Enviar y recibir tokens
 	Ver saldos de cuentas e historial de transacciones
 	Ejecutar varios scripts para automatizar tareas

¿Por qué usar NEAR CLI?
Si eres un desarrollador o usuario avanzado, NEAR CLI te brinda control directo sobre cuentas y contratos inteligentes de NEAR. Es ligero y se puede integrar fácilmente en flujos de trabajo de desarrollo para fines de automatización y scripting.
Empezar

 	Instalación: En máquinas Windows, NEAR CLI se puede instalar a través del instalador .msi.
Encuentra el más reciente aquí:
https://github.com/near/near-cli-rs/releases/
 	Comenzar a usar NEAR CLI: Para principiantes, recomendamos usar near-cli en modo interactivo.
Simplemente escribe en tu terminal de Windows
near


Dive deeper at NEAR Docs
Características

 	Gestión de Cuentas: Crea, elimina y gestiona cuentas NEAR fácilmente.
 	Interacción con Contratos Inteligentes: Implementa contratos y llama funciones en contratos.
 	Transferencias de Tokens: Envía tokens NEAR a cualquier cuenta.
 	Historial de Transacciones: Visualiza transacciones pasadas y saldos de cualquier cuenta.

Conclusión
NEAR CLI es una herramienta esencial para desarrolladores y usuarios avanzados que desean una forma poderosa y flexible de interactuar con la cadena de bloques NEAR. Es fácil de usar, scriptable e se integra perfectamente con tu flujo de trabajo de desarrollo. ¡Si estás listo para sumergirte en el ecosistema de NEAR, NEAR CLI es un excelente lugar para empezar!

Para obtener información más detallada, visita la documentación de NEAR CLI.

### 워드프레스가 웹3으로의 문을 열 수 있는 이유

웹3로의 전환은 불가피한 것으로 보입니다. 이미 여러 기업들이 NFT, 메타버스, 토큰화 등 웹3의 다양한 측면을 실험하기 시작했습니다. 그러나 이러한 전환을 어떻게 원활하게 할 수 있을까요? Learn Near Club에서는 웹3 도구를 검증된 오픈 웹2 플랫폼에 통합함으로써 웹3의 미래를 이룰 수 있습니다. "검증된 오픈" 웹 플랫폼의 가장 좋은 예는 WordPress입니다. 이 블로그에서는 WordPress가 중앙 집중형 프레임워크 내에서 탈중앙화 성장을 어떻게 촉진하는지 살펴보겠습니다.

WordPress란?
WordPress는 사용자가 웹사이트와 블로그를 만들고 관리할 수 있는 인기 있는 오픈 소스 콘텐츠 관리 시스템(CMS)입니다. 2003년 출시 이후로 인터넷 상의 모든 웹사이트의 약 43%를 구동하는 가장 널리 사용되는 웹사이트 플랫폼 중 하나로 성장했습니다.

그 인기의 주요 이유 중 하나는 코딩 지식이 없어도 사용자가 쉽게 콘텐츠를 만들고 게시할 수 있는 사용자 친화적 인터페이스입니다. 이로 인해 콘텐츠를 쉽게 만들고 게시하고 싶은 사람들에게 인기가 있습니다. 또한 개발자 커뮤니티가 다양한 플러그인과 테마를 만들어 플랫폼에 쉽게 통합할 수 있도록 했으며, 추가 기능과 미적 매력을 제공합니다.

WordPress는 매우 사용자 정의가 가능하며, 작은 개인 블로그부터 대규모 기업 사이트까지 다양한 웹사이트에 대응할 수 있습니다. 또한 사업 또는 웹사이트의 성장과 함께 성장할 수 있도록 확장 가능하며, 필요에 따라 새로운 기능과 기능을 추가할 수 있는 능력을 갖추고 있어 매우 적응력이 뛰어납니다.

WordPress의 또 다른 장점은 SEO 친화적인 구조입니다. WordPress로 제작된 웹사이트는 검색 엔진 최적화 도구가 내장되어 있어 사용자가 콘텐츠를 최적화하고 검색 엔진 친화적으로 만들 수 있습니다. 이 기능 덕분에 많은 기업과 개인들이 웹사이트가 검색 엔진에서 쉽게 찾을 수 있기를 원하는 경우 WordPress를 선호하는 선택으로 삼았습니다.


WordPress의 철학
WordPress의 철학은 개발과 커뮤니티를 이끄는 여러 핵심 원칙에 기반합니다. 이러한 원칙은:
 	누구나 온라인 콘텐츠를 만들고 게시할 수 있는 사용자 친화적이고 접근 가능한 플랫폼을 제공합니다. 이는 소프트웨어가 사용하기 쉽고 이해하기 쉽며 무료로 접근할 수 있어야 한다는 것을 의미합니다.
 	오픈 소스로, 소프트웨어는 어떠한 제한 없이 무료로 사용, 수정 및 배포할 수 있습니다. 이는 플랫폼을 지속적으로 개선하고 새로운 기능과 기능을 추가하는 개발자 커뮤니티를 만드는 데 도움이 되었습니다.
 	사용자들이 협력하고 지식을 공유하도록 장려하여, 사용자, 개발자 및 기여자들이 함께 더 나은 플랫폼을 만들기 위해 협력하는 활기찬 커뮤니티가 형성되었습니다.
 	기술적 전문 지식이나 신체적 능력에 관계없이 누구나 사용할 수 있는 도구를 제공합니다. 이는 모든 사용자가 쉽게 사용하고 탐색할 수 있도록 설계되어야 한다는 것을 의미합니다.

워드프레스는 개방적이고 접근 가능하며 사용자 친화적인 플랫폼을 만드는 데 초점을 맞추고 있으며, 커뮤니티와 협력에 강한 강조를 두고 있습니다. 이러한 핵심 원칙들은 워드프레스를 세계에서 가장 인기 있는 콘텐츠 관리 시스템 중 하나로 만드는 데 도움이 되었습니다.




	

	
	
		
			
				What is one of the key reasons for the popularity of WordPress as a content management system?
			
		

		
					

		
			
			
			
			Its cost
		
			
			Its user-friendly interface does not require users to have any coding knowledge
		
			
			Its compatibility with other platforms
		
			
			Its proprietary nature
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





워드프레스와 웹3
워드프레스와 웹3 간의 기존 관계를 살펴보겠습니다. 워드프레스는 본질적으로 웹3 플랫폼은 아니지만, 웹3 기술을 워드프레스에 통합하여 보다 탈중앙화되고 안전한 웹사이트를 만들 수 있습니다. 그 중 하나는 Unstoppable Domains와 같은 탈중앙화 도메인 이름 시스템(DNS)을 사용하는 것입니다. 또한 IPFS와 같은 탈중앙화 저장 시스템을 사용할 수 있습니다. IPFS는 사용자가 파일을 탈중앙화 및 검열 방지 방식으로 저장하고 공유할 수 있는 P2P 저장 시스템입니다. 워드프레스 웹사이트에 IPFS를 통합함으로써 사용자는 콘텐츠를 공유하기 위한 보다 안전하고 탈중앙화된 플랫폼을 만들 수 있습니다. 마지막으로, 웹사이트 제작자는 항상 암호화폐 결제 API를 통합하여 탈중앙화된 결제에 접근할 수 있습니다.
워드프레스는 금 표준
워드프레스는 웹2 플랫폼으로 웹3 기술을 원활하게 통합할 수 있는 유연한 플랫폼입니다. 개인 블로그, 온라인 상점 등 다양한 유형의 사이트를 만들고 관리하기 위해 인터넷 웹사이트의 38%에서 사용되는 CMS가 되었을 이유가 있습니다. 이 개방적인 성격은 또한 워드프레스가 개방적이고 활기찬 기여자 커뮤니티를 만들 수 있도록 했습니다. 이러한 기여자들은 새로운 기능을 개발하고 버그를 수정하며 핵심 코드를 유지보수함으로써 플랫폼을 개선하기 위해 노력합니다. 누구나 워드프레스에 기여할 수 있으며, 그 방법은 다양합니다.




	

	
	
		
			
				How does WordPress align with the principles of web3?
			
		

		
					

		
			
			
			
			By being a centralized platform with a fixed set of features
		
			
			By relying on a single developer for all updates
		
			
			By being a closed-source platform
		
			
			By supporting and encouraging community contributions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





기여자가 워드프레스를 도와주는 방법
	버그를 보고하고 새로운 기능을 제안하며 기존 기능에 대한 피드백을 제공함으로써 사용자는 개발자가 문제를 식별하고 필요한 개선을 할 수 있도록 돕습니다. 이 피드백은 플랫폼의 지속적인 성장과 성공에 중요합니다.
	워드프레스는 여러 언어로 제공되지만 플랫폼을 더 많은 사람들에게 접근 가능하게 만들기 위해 더 많은 번역가가 필요합니다. 번역을 돕기 위해 여러 언어에 능통할 필요는 없습니다 - 작은 기여도 큰 차이를 만들 수 있습니다.
	코딩 기술이 있다면 코드를 작성하거나 버그를 수정하거나 새로운 기능을 개발함으로써 워드프레스에 기여할 수 있습니다. 워드프레스는 오픈 소스 플랫폼이며 누구나 코드에 액세스하고 개발에 기여할 수 있습니다. 여러분의 기술과 관심에 따라 워드프레스 코어, 플러그인 또는 테마에 기여할 수 있습니다.
	문서 작성, 디자인 또는 커뮤니티 관리를 돕는 것으로도 워드프레스에 기여할 수 있습니다. 이러한 영역은 코딩만큼 중요하며 참여할 수 있는 많은 기회가 있습니다.
	포럼에서 다른 사용자를 돕거나 모임에 참석하거나 워드프레스 이벤트를 조직함으로써 워드프레스 커뮤니티를 지원할 수 있습니다. 커뮤니티를 지원함으로써 모두에게 이로운 환영하고 포용적인 환경을 만들어냅니다.

워드프레스 경제
WPEngine의 연구에 따르면, 2020년 전 세계 워드프레스 경제는 워드프레스와 관련된 모든 기업, 개발자 및 사용자를 포함하여 약 $596.7 billion에 가치가 있었습니다.

Automattic, 워드프레스닷컴 뒤에 있는 글로벌 분산 회사로 96개국에서 1,983명의 Automatticians가 123개 다른 언어로 의사소통하며, ZERO 사무실을 운영합니다.

워드프레스에서 돈을 벌 수 있는 방법은 여러 가지가 있습니다. 여기 워드프레스 웹사이트를 통해 수익을 창출하는 가장 좋은 방법 중 일부가 있습니다:
 	전자 상거래: WooCommerce와 같은 플러그인을 사용하여 WordPress 웹사이트를 온라인 상점으로 변환하여 물리적 또는 디지털 제품, 서비스 또는 예약을 판매할 수 있습니다.
 	광고: 웹사이트에 광고를 게재하고 클릭당 비용 (PPC) 또는 기타 광고 모델을 통해 수익을 올릴 수 있습니다. Google AdSense는 사이트에 관련 광고를 표시하는 인기 있는 옵션입니다.
 	제휴 마케팅: 블로그나 웹사이트에서 다른 회사의 제품이나 서비스를 고유한 제휴 링크를 사용하여 홍보할 수 있습니다. 추천을 통해 이루어진 각 판매 또는 행동에 대해 커미션을 받습니다.
 	독점 콘텐츠: 방문자들에게 유료로 프리미엄 또는 독점 콘텐츠를 제공할 수 있습니다. 이는 기사, 비디오, 코스 또는 기타 가치 있는 자원을 포함할 수 있습니다.
 	온라인 코스: 특정 지식이나 기술이 있는 경우 WordPress 웹사이트를 통해 온라인 코스를 만들고 판매할 수 있습니다. 이를 통해 전문 지식을 공유하고 지식을 활용할 수 있습니다.
 	플러그인 개발: 코딩 기술이 있는 경우 WordPress용 플러그인을 개발하고 판매할 수 있습니다. 많은 웹사이트 소유자들은 웹사이트 기능을 향상시키는 플러그인에 대해 지불할 의향이 있습니다.
 	고객을 위한 WordPress 사이트 구축: 웹 개발 기술이 있는 경우 고객에게 WordPress 웹사이트 디자인 및 개발 서비스를 제공할 수 있습니다. 고품질 웹사이트를 제공할 수 있다면 수익성 있는 비즈니스가 될 수 있습니다.

이것이 Web3의 본질이 아닌가요?
커뮤니티에 많이 의존하여 개선하는 모델을 만들어낸 워드프레스는 Web3의 매우 가장자리에 위치한 비즈니스를 만들었습니다. 기억하세요, Web3 환경에서 모든 작업은 중앙 집행이 아닌 커뮤니티에 의해 실행됩니다. 워드프레스는 Web2 시나리오에서 가능한 한 그 모델을 선도합니다.

게다가, 워드프레스는 지리적 위치, 정치적 및 경제적 상황과 관계없이 실제 사용자들을 위해 실질적 가치를 창출하려는 모든 사람들에게 끝없는 기회를 제공합니다.
Learn Near Club이 워드프레스의 Web3 여정에 기여하는 방법
우리는 Near 생태계와 연결할 수 있는 두 가지 워드프레스 플러그인을 만들었습니다.

 	NEAR로 로그인
 	LNC Near 댓글

NEAR로 로그인


간단한 쇼트코드를 사용하여 WordPress 사이트에서 NEAR로 로그인 기능을 쉽게 설정하고 사용자 정의할 수 있습니다. 기억해야 할 몇 가지 기능은 다음과 같습니다:
	인기 있는 Near 지갑 지원 - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender"
	쉬운 등록 및 로그인: 사용자가 Near 지갑을 가지고 있다면 이미 귀하의 사이트의 모든 기능을 사용할 수 있으며 WP 사용자로 식별됩니다.
	귀하의 워드프레스 앱이 NEAR 스마트 계약을 사용하는 경우 플러그인을 통해 사용자가 해당 계약을 위한 기능 제한된 액세스 키를 생성할 수 있습니다. 또한, 사용자는 다른 스마트 계약에 대한 변경/보기 메소드 호출을 할 수 있습니다.
	플러그인은 또한 로그인 UI를 쉽게 사용자 정의할 수 있습니다.

플러그인을 만들어 스마트 계약을 사용하고 로그인한 사용자가 호출할 수 있도록 하려면 다음과 같이 간단히 할 수 있습니다:

보기 메소드: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

변경 메소드: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

플러그인 데모 시청.

플러그인 다운로드.
LNC Near Comments


LNC Near Comments 플러그인을 사용하여 워드프레스 사이트에 통합하고 사용자 정의하는 방법은 간단한 쇼트코드 [lnc_near_comments]를 사용하면 됩니다. 주의해야 할 몇 가지 기능은 다음과 같습니다:

	인기 있는 Near 지갑 지원 - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender"
	댓글 섹션에 고유한 캡차를 제공하고 사용자 댓글을 작성한 후 v1.ncaptcha.near 스마트 계약으로 소액 팁 거래를 합니다.
	고유한 결제 시스템을 통해 사용자가 해결한 각 캡차에 대한 결제의 일부를 받을 수 있습니다. 수익을 구성할 수 있습니다.
	최신 버전의 워드프레스와 함께 작동하도록 테스트되고 설계되었습니다. 플러그인을 사용하기 전에 워드프레스 설치가 최신 상태인지 확인하십시오.
	LNC Near Comments 플러그인은 올바르게 작동하려면 Near Login 플러그인이 필요합니다. 필요한 종속성 및 설치 지침은 플러그인 설명서를 참조하십시오.

스마트 계약을 사용하여 플러그인을 활용하고 로그인한 사용자가 상호 작용할 수 있도록 하려면 다음 메소드를 사용하십시오:

보기 메소드: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

변경 메소드: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

플러그인 데모 시청.

플러그인 다운로드.
마무리웹2와 웹3 기술의 교차로는 디지털 세계에 독특하고 흥미로운 새로운 지평을 제시합니다. 워드프레스와 같은 전통적인 플랫폼은 이러한 변화하는 환경에서 그들의 적응성과 관련성을 입증했습니다. 분산형 도메인 이름 시스템, 분산형 저장 시스템, 그리고 암호화폐 결제 API와 같은 웹3 기능을 통합함으로써, 워드프레스는 하이브리드 모델을 구현하여 웹3 혁명의 최전선에 자리 잡고 있습니다.

워드프레스의 오픈 소스, 커뮤니티 중심적인 정신은 웹3의 원칙과 밀접하게 일치합니다. 널리 채택되고 사용하기 쉽고 적응성이 뛰어나기 때문에, 워드프레스는 보다 분산화된 인터넷으로의 전환에 이상적인 출발점이 됩니다. 커뮤니티 기여를 지원하고 장려함으로써, 워드프레스는 웹2 환경에서 웹3와 유사한 환경을 육성합니다.

NEAR를 워드프레스에 연결하여 참여하고 싶다면 이 텔레그램 그룹에 가입하세요



	

	
	
		
			
				Which of the following is not a way that users can contribute to WordPress?
			
		

		
					

		
			
			
			
			Reporting bugs and suggesting new features
		
			
			Helping with translations
		
			
			Writing code or fixing bugs
		
			
			Paying for premium features
		
	
		

		
		
			
				Correct!
				Wrong!

### Introdução ao NEAR CLI

NEAR CLI (Command Line Interface) é uma ferramenta poderosa projetada para ajudar desenvolvedores e usuários a interagir com o Protocolo NEAR diretamente a partir da linha de comando. Simplifica a gestão de contas, implantação de contratos e outras tarefas sem a necessidade de uma interface gráfica.
O que é NEAR CLI?
NEAR CLI é uma ferramenta de linha de comando para trabalhar com o blockchain NEAR. Permite aos usuários:

 	Gerenciar contas
 	Implantar e interagir com contratos inteligentes
 	Enviar e receber tokens
 	Visualizar saldos de conta e histórico de transações
 	Executar vários scripts para automatizar tarefas

Por que usar NEAR CLI?
Se você é um desenvolvedor ou usuário avançado, NEAR CLI oferece controle direto sobre contas NEAR e contratos inteligentes. É leve e pode ser facilmente integrado aos fluxos de trabalho de desenvolvimento para fins de automação e script.
Começando

 	Instalação: Em máquinas Windows, NEAR CLI pode ser instalado via instalador .msi.
Encontre o mais recente aqui:
https://github.com/near/near-cli-rs/releases/
 	Comece a usar NEAR CLI Para iniciantes, recomendamos usar o near-cli no modo Interativo.
Basta digitar no terminal do Windows
near


Dive deeper at NEAR Docs
Recursos

 	Gerenciamento de Contas: Criar, excluir e gerenciar contas NEAR facilmente.
 	Interação com Contratos Inteligentes: Implantar contratos e chamar funções em contratos.
 	Transferências de Tokens: Enviar tokens NEAR para qualquer conta.
 	Histórico de Transações: Visualizar transações passadas e saldos de qualquer conta.

Conclusão
NEAR CLI é uma ferramenta essencial para desenvolvedores e usuários avançados que desejam uma forma poderosa e flexível de interagir com o blockchain NEAR. É fácil de usar, scriptável e se integra perfeitamente ao seu fluxo de trabalho de desenvolvimento. Se você está pronto para mergulhar no ecossistema NEAR, NEAR CLI é um ótimo lugar para começar!

Para obter informações mais detalhadas, visite a documentação do NEAR CLI.

### Giới thiệu về NEAR CLI

NEAR CLI (Command Line Interface) là một công cụ mạnh mẽ được thiết kế để giúp các nhà phát triển và người dùng tương tác trực tiếp với Giao thức NEAR từ dòng lệnh. Nó giúp đơn giản hóa việc quản lý tài khoản, triển khai hợp đồng và các nhiệm vụ khác mà không cần giao diện đồ họa.
NEAR CLI là gì?
NEAR CLI là một công cụ dòng lệnh để làm việc với blockchain NEAR. Nó cho phép người dùng:

 	Quản lý tài khoản
 	Triển khai và tương tác với các hợp đồng thông minh
 	Gửi và nhận token
 	Xem số dư tài khoản và lịch sử giao dịch
 	Chạy các tập lệnh khác nhau để tự động hóa các nhiệm vụ

Tại sao sử dụng NEAR CLI?
Nếu bạn là một nhà phát triển hoặc người dùng nâng cao, NEAR CLI cho phép bạn kiểm soát trực tiếp tài khoản NEAR và các hợp đồng thông minh. Nó nhẹ và có thể dễ dàng tích hợp vào quy trình làm việc phát triển để tự động hóa và viết kịch bản.
Bắt đầu

 	Cài đặt: Trên máy tính Windows, NEAR CLI có thể được cài đặt thông qua trình cài đặt .msi.
Tìm phiên bản mới nhất tại đây:
https://github.com/near/near-cli-rs/releases/
 	Bắt đầu sử dụng NEAR CLI
Đối với người mới bắt đầu, chúng tôi khuyến nghị sử dụng near-cli trong Chế độ tương tác.
Chỉ cần nhập vào dòng lệnh Windows của bạn
near


Dive deeper at NEAR Docs
Tính năng

 	Quản lý tài khoản: Tạo, xóa và quản lý tài khoản NEAR một cách dễ dàng.
 	Tương tác với Hợp đồng thông minh: Triển khai hợp đồng và gọi các chức năng trên hợp đồng.
 	Chuyển token: Gửi token NEAR đến bất kỳ tài khoản nào.
 	Lịch sử giao dịch: Xem các giao dịch trước đó và số dư cho bất kỳ tài khoản nào.

Kết luận
NEAR CLI là một công cụ cần thiết cho các nhà phát triển và người dùng nâng cao muốn tương tác mạnh mẽ và linh hoạt với blockchain NEAR. Nó dễ sử dụng, có thể viết kịch bản và tích hợp một cách mượt mà vào quy trình làm việc phát triển của bạn. Nếu bạn sẵn sàng bắt đầu với hệ sinh thái NEAR, NEAR CLI là nơi tuyệt vời để bắt đầu!

Để biết thông tin chi tiết hơn, truy cập tài liệu NEAR CLI.

### Bakit ang WordPress ay maaaring magbukas ng mga pintuan patungo sa Web3

Ang transisyon patungo sa web3 ay tila hindi maiiwasan. Maraming kumpanya ang nagsimulang mag-eksperimento sa iba't ibang aspeto ng web3, tulad ng NFTs, metaverse, at tokenization. Ngunit paano natin mapapadali ang transisyong ito? Sa Learn Near Club, maabot ang hinaharap ng web3 sa pamamagitan ng pagpapasok ng web3 tooling sa mga napatunayang at bukas na web2 platforms. Isa sa pinakamahusay na halimbawa ng "napatunayang at bukas" na web platform ay ang WordPress. Sa blog na ito, tingnan natin kung paano pinapalago ng WordPress ang decentralized growth sa loob ng kanyang centralized framework.
Ano ang WordPress?
Ang WordPress ay isang sikat na open-source content management system (CMS) na nagbibigay-daan sa mga gumagamit na lumikha at pamahalaan ang kanilang mga website at blog. Mula nang ilabas ito noong 2003, ito ay lumago upang maging isa sa pinakamalawak na ginagamit na website platform, na nagpapatakbo ng mga 43% ng lahat ng mga website sa Internet.

Isa sa mga pangunahing dahilan ng kanyang kasikatan ay ang user-friendly interface nito na hindi nangangailangan ng anumang kaalaman sa coding mula sa mga gumagamit. Ito ay naging isang popular na pagpipilian para sa mga nais lumikha at mag-publish ng content nang madali. Bukod dito, may malaking komunidad ng mga developers na lumikha ng maraming plugins at themes, na madaling ma-integrate sa platform, na nagbibigay ng karagdagang functionality at aesthetic appeal.

https://www.youtube.com/watch?v=HCyn97xeKig

Ang WordPress ay highly customizable, kaya't maaari itong magamit sa iba't ibang uri ng mga website, mula sa maliit na personal blogs hanggang sa malalaking korporasyon. Ito rin ay scalable, na nagpapahintulot dito na lumago kasabay ng paglago ng isang negosyo o website. Ang platform ay may kakayahan na magdagdag ng mga bagong feature at functionality kapag kinakailangan, na ginagawang highly adaptable.

Isa pang bentahe ng WordPress ay ang SEO-friendly structure nito. Ang mga website na ginawa sa WordPress ay may built-in na SEO tool na nagbibigay-daan sa mga gumagamit na i-optimize ang kanilang content at siguruhing ito ay search engine friendly. Ang feature na ito ang nagpapagawa sa WordPress na pinipili ng maraming negosyo at indibidwal na nais na madaling mahanap ng mga search engines ang kanilang mga website.


Ang Pilosopiya ng WordPress
Ang pilosopiya ng WordPress ay itinatag sa ilang core principles na nagsisilbing gabay sa pag-unlad at komunidad nito. Ang mga prinsipyong ito ay:
 	Magbigay ng isang user-friendly at accessible platform para sa sinuman na lumikha at mag-publish ng content online. Ibig sabihin nito ay dapat madaling gamitin, madaling maintindihan, at libreng ma-access ang software.
 	Dahil sa pagiging open source, ang software ay libreng magamit, baguhin, at ipamahagi nang walang anumang mga paghihigpit. Ito ay nakatulong sa paglikha ng isang malaking komunidad ng mga developers na patuloy na nagpapabuti at nagtatayo sa platform, nagdaragdag ng bagong mga feature at functionality.

### Tại sao WordPress có thể mở cánh cửa cho Web3

Chuyển đổi sang web3 dường như không thể tránh khỏi. Một số công ty đã bắt đầu thử nghiệm với các khía cạnh khác nhau của web3, như NFTs, thế giới ảo và tokenization. Tuy nhiên, làm thế nào để làm mịn sự chuyển đổi này? Tại Learn Near Club, tương lai của web3 có thể được đạt được bằng cách tích hợp công cụ web3 vào các nền tảng web2 đã được chứng minh và mở. Một trong những ví dụ tốt nhất về một nền tảng web "đã được chứng minh và mở" là WordPress. Trong blog này, hãy xem cách WordPress thúc đẩy sự phát triển phi tập trung trong khung của mình.
WordPress là gì?
WordPress là một hệ thống quản lý nội dung mã nguồn mở phổ biến (CMS) cho phép người dùng tạo và quản lý trang web và blog. Kể từ khi ra mắt vào năm 2003, nó đã phát triển trở thành một trong những nền tảng trang web được sử dụng rộng rãi nhất, cung cấp khoảng 43% trên tất cả các trang web trên Internet.

Một trong những lý do chính cho sự phổ biến của nó là giao diện thân thiện với người dùng không yêu cầu người dùng phải có bất kỳ kiến thức lập trình nào. Điều này đã khiến nó trở thành lựa chọn phổ biến cho những người muốn tạo và xuất bản nội dung một cách dễ dàng. Ngoài ra, một cộng đồng lớn của các nhà phát triển đã tạo ra nhiều plugin và chủ đề, có thể dễ dàng tích hợp vào nền tảng, cung cấp chức năng bổ sung và sức hấp dẫn thẩm mỹ.

https://www.youtube.com/watch?v=HCyn97xeKig

WordPress có khả năng tùy chỉnh cao, điều này có nghĩa là nó có thể phục vụ cho một loạt các trang web, từ blog cá nhân nhỏ đến các trang web doanh nghiệp lớn. Nó cũng có khả năng mở rộng, cho phép nó phát triển song song với sự phát triển của doanh nghiệp hoặc trang web. Nền tảng có khả năng thêm tính năng và chức năng mới theo yêu cầu, khiến nó trở nên rất linh hoạt.

Một ưu điểm khác của WordPress là cấu trúc thân thiện với SEO. Các trang web được xây dựng bằng WordPress có một công cụ SEO tích hợp giúp người dùng tối ưu hóa nội dung của họ và đảm bảo nó thân thiện với công cụ tìm kiếm. Tính năng này đã khiến WordPress trở thành lựa chọn ưa thích của nhiều doanh nghiệp và cá nhân muốn trang web của họ dễ dàng được tìm thấy bởi các công cụ tìm kiếm.


Triết lý của WordPress
Triết lý của WordPress được xây dựng trên một số nguyên tắc cốt lõi hướng dẫn sự phát triển và cộng đồng của nó. Những nguyên tắc này là:
 	Cung cấp một nền tảng dễ sử dụng và tiện lợi cho bất kỳ ai muốn tạo và xuất bản nội dung trực tuyến. Điều này có nghĩa là phần mềm nên dễ sử dụng, dễ hiểu và miễn phí để truy cập.
 	Với tính mã nguồn mở, phần mềm có sẵn miễn phí để sử dụng, chỉnh sửa và phân phối mà không có bất kỳ hạn chế nào. Điều này đã giúp tạo ra một cộng đồng lớn của các nhà phát triển luôn cải thiện và xây dựng trên nền tảng, thêm các tính năng và chức năng mới.
 	Khuyến khích người dùng hợp tác và chia sẻ kiến thức, dẫn đến việc tạo ra một cộng đồng sôi động của người dùng, nhà phát triển và người đóng góp làm việc cùng nhau để làm cho nền tảng tốt hơn.
 	Cung cấp một công cụ có thể sử dụng bởi bất kỳ ai, không phụ thuộc vào kiến thức kỹ thuật hoặc khả năng vật lý của họ. Điều này có nghĩa là phần mềm nên được thiết kế với tính khả dễ tiếp cận, giúp người dùng dễ sử dụng và điều hướng.

WordPress tập trung vào việc tạo ra một nền tảng mở, tiện lợi và dễ sử dụng, với sự tập trung mạnh mẽ vào cộng đồng và sự hợp tác. Những nguyên tắc cốt lõi này đã giúp WordPress trở thành một trong những hệ thống quản lý nội dung phổ biến nhất trên thế giới.




	

	
	
		
			
				What is one of the key reasons for the popularity of WordPress as a content management system?
			
		

		
					

		
			
			
			
			Its cost
		
			
			Its user-friendly interface does not require users to have any coding knowledge
		
			
			Its compatibility with other platforms
		
			
			Its proprietary nature
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress và Web3
Hãy xem mối quan hệ hiện tại giữa WordPress và web3. Mặc dù WordPress không phải là một nền tảng Web3 theo bản chất, nhưng có cách để tích hợp các công nghệ Web3 vào WordPress để tạo ra các trang web phân quyền và an toàn hơn. Một trong những cách đó là thông qua việc sử dụng hệ thống tên miền phân quyền, như Unstoppable Domains. Bạn cũng có thể sử dụng các hệ thống lưu trữ phân quyền, như IPFS. IPFS là một hệ thống lưu trữ ngang hàng cho phép người dùng lưu trữ và chia sẻ tệp tin một cách phân quyền và chống kiểm duyệt. Bằng cách tích hợp IPFS vào trang web WordPress, người dùng có thể tạo ra một nền tảng an toàn và phân quyền hơn để chia sẻ nội dung. Cuối cùng, người tạo trang web luôn có thể tích hợp các API thanh toán tiền điện tử để truy cập thanh toán phân quyền.
Wordpress là Tiêu Chuẩn Vàng
Như bạn có thể thấy, WordPress là một nền tảng web2 linh hoạt cho phép bạn tích hợp mượt mà các công nghệ web3. Có lý do khiến hệ thống quản lý nội dung này được sử dụng bởi 38% của tất cả các trang web trên internet để tạo và quản lý các loại trang web như blog cá nhân, cửa hàng trực tuyến và nhiều hơn nữa. Tính mở này cũng đã giúp WordPress tạo ra một cộng đồng mở và sôi động của người đóng góp. Những người đóng góp này làm việc chăm chỉ để cải thiện nền tảng bằng cách phát triển các tính năng mới, sửa lỗi và duy trì mã nguồn cốt lõi. Bất kỳ ai cũng có thể đóng góp cho WordPress, và có nhiều cách để làm điều đó.




	

	
	
		
			
				How does WordPress align with the principles of web3?
			
		

		
					

		
			
			
			
			By being a centralized platform with a fixed set of features
		
			
			By relying on a single developer for all updates
		
			
			By being a closed-source platform
		
			
			By supporting and encouraging community contributions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Làm thế nào người đóng góp giúp đỡ WordPress
	Bằng cách báo cáo lỗi, đề xuất tính năng mới và đưa ra phản hồi về các tính năng hiện có, người dùng giúp các nhà phát triển xác định vấn đề và thực hiện các cải tiến cần thiết. Phản hồi này rất quan trọng cho sự phát triển và thành công liên tục của nền tảng.
	WordPress có sẵn trong nhiều ngôn ngữ, nhưng luôn cần thêm dịch giả để giúp làm cho nền tảng trở nên dễ truy cập hơn đối với nhiều người hơn. Không cần phải thông thạo nhiều ngôn ngữ để giúp đỡ với việc dịch - ngay cả những đóng góp nhỏ cũng có thể tạo ra sự khác biệt lớn.
	Nếu bạn có kỹ năng lập trình, bạn có thể đóng góp cho WordPress bằng cách viết mã, sửa lỗi hoặc phát triển tính năng mới. WordPress là một nền tảng mã nguồn mở, và bất kỳ ai cũng có thể truy cập mã nguồn của nó và đóng góp vào sự phát triển của nó. Tùy thuộc vào kỹ năng và sở thích của bạn, bạn có thể đóng góp vào lõi của WordPress, plugin hoặc chủ đề.
	Bạn cũng có thể đóng góp cho WordPress bằng cách giúp đỡ với tài liệu, thiết kế hoặc quản lý cộng đồng. Những lĩnh vực này không kém phần quan trọng so với việc lập trình, và có nhiều cơ hội để tham gia.
	Bạn có thể hỗ trợ cộng đồng WordPress bằng cách giúp đỡ người dùng khác trên diễn đàn, tham dự các cuộc họp, và tổ chức sự kiện WordPress. Bằng cách hỗ trợ cộng đồng, bạn tạo ra một môi trường chào đón và bao hàm mang lại lợi ích cho tất cả mọi người tham gia.

Nền kinh tế WordPress
Theo một nghiên cứu của WPEngine, Nền kinh tế WordPress toàn cầu, bao gồm tất cả các doanh nghiệp, nhà phát triển và người dùng liên quan đến WordPress, được định giá khoảng 596,7 tỷ đô la vào năm 2020.

Automattic, công ty phân phối toàn cầu đứng sau WordPress.com với 1.983 nhân viên Automatticians ở 96 quốc gia nói 123 ngôn ngữ khác nhau, không có văn phòng nào.

Kiếm tiền trên WordPress là hoàn toàn có thể thông qua các phương pháp khác nhau. Dưới đây là một số cách tốt nhất để tạo thu nhập từ trang web WordPress của bạn:
 	Thương mại điện tử: Sử dụng một plugin như WooCommerce để biến trang web WordPress của bạn thành cửa hàng trực tuyến nơi bạn có thể bán sản phẩm vật lý hoặc số, dịch vụ hoặc cuộc hẹn.
 	Quảng cáo: Hiển thị quảng cáo trên trang web của bạn và kiếm tiền thông qua mô hình trả tiền theo mỗi lần nhấp (PPC) hoặc các mô hình quảng cáo khác. Google AdSense là một lựa chọn phổ biến để hiển thị quảng cáo liên quan trên trang web của bạn.
 	Marketing liên kết: Quảng cáo sản phẩm hoặc dịch vụ từ các công ty khác trên blog hoặc trang web của bạn bằng cách sử dụng liên kết liên kết duy nhất. Bạn kiếm hoa hồng cho mỗi bán hàng hoặc hành động được thực hiện thông qua giới thiệu của bạn.
 	Nội dung độc quyền: Cung cấp nội dung cao cấp hoặc độc quyền cho khách truy cập của bạn với một khoản phí. Điều này có thể bao gồm bài viết, video, khóa học hoặc các tài nguyên có giá trị khác.
 	Khóa học trực tuyến: Nếu bạn có kiến thức hoặc kỹ năng chuyên môn, hãy tạo và bán khóa học trực tuyến thông qua trang web WordPress của bạn. Điều này cho phép bạn chia sẻ chuyên môn của mình và kiếm tiền từ kiến thức của mình.
 	Xây dựng Plugin: Nếu bạn có kỹ năng lập trình, bạn có thể phát triển và bán các plugin cho WordPress. Nhiều chủ sở hữu trang web sẵn lòng trả tiền cho các plugin cải thiện chức năng của trang web của họ.
 	Xây dựng Trang web WordPress cho Khách hàng: Nếu bạn có kỹ năng phát triển web, bạn có thể cung cấp dịch vụ thiết kế và phát triển trang web WordPress cho khách hàng. Điều này có thể là một doanh nghiệp sinh lời nếu bạn có thể cung cấp các trang web chất lượng cao.

Đây Có Phải Là Bản Chất Của Web3?
Bằng cách tạo ra một mô hình phụ thuộc nhiều vào cộng đồng của mình để cải thiện, WordPress đã tạo ra một doanh nghiệp đặt ở ngay bên bờ của web3. Hãy nhớ, trong môi trường web3, tất cả các hoạt động được thực hiện và thực hiện bởi cộng đồng thay vì một hội đồng quản trị tập trung. WordPress tiên phong mô hình đó càng nhiều càng tốt trong tình huống web2.

Hơn nữa, WordPress tạo ra vô số cơ hội cho tất cả mọi người muốn tạo ra giá trị thực sự cho người dùng thực sự bất kể vị trí địa lý, điều kiện chính trị và kinh tế.
Đây Là Cách Learn Near Club Đóng Góp Cho Hành Trình Của WordPress đến web3
Chúng tôi đã tạo ra hai plugin cho WordPress, cho phép người dùng kết nối với hệ sinh thái Near.

 	Đăng nhập với NEAR
 	LNC Near Comments

Đăng nhập với NEAR


Dễ dàng thiết lập và tùy chỉnh chức năng đăng nhập với NEAR trên trang web WordPress của bạn bằng cách sử dụng mã rút gọn đơn giản. Dưới đây là một số tính năng cần nhớ:
	Hỗ trợ các ví Near phổ biến như - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender"
	Đăng ký và đăng nhập dễ dàng: Nếu người dùng có một Ví Near, anh ấy đã có thể sử dụng tất cả các chức năng từ trang web của bạn và được xác định là Người dùng WP
	Nếu ứng dụng WordPress của bạn sử dụng hợp đồng thông minh NEAR, plugin cho phép người dùng tạo một khóa truy cập có giới hạn chức năng cho nó. Ngoài ra, người dùng cũng có thể gọi để thay đổi/xem các phương thức khác của hợp đồng thông minh
	Plugin cũng dễ dàng tùy chỉnh giao diện đăng nhập.

Nếu bạn muốn tạo plugin với hợp đồng thông minh và gọi nó từ người dùng đã đăng nhập, bạn có thể đơn giản làm như sau:

phương thức xem: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

phương thức thay đổi: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Xem bản demo của plugin.

Tải plugin về.
Bình luận Near LNC


Tích hợp và tùy chỉnh plugin Bình luận Near LNC cho trang web WordPress của bạn bằng cách sử dụng mã ngắn dễ dàng [lnc_near_comments]. Dưới đây là một số tính năng cần lưu ý:

	Hỗ trợ các ví Near phổ biến như - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet" và "Sender"
	Cung cấp một captcha duy nhất cho phần bình luận và đăng bài của người dùng sau một giao dịch tiền tip nhỏ đến hợp đồng thông minh v1.ncaptcha.near
	Hệ thống thanh toán duy nhất cho phép bạn nhận một phần của số tiền cho mỗi captcha được giải quyết bởi người dùng của bạn. Bạn có thể cấu hình doanh thu trên phía của bạn
	Đã được kiểm tra và thiết kế để hoạt động với phiên bản mới nhất của WordPress. Đảm bảo cài đặt WordPress của bạn đã được cập nhật trước khi sử dụng plugin
	Plugin Bình luận Near LNC yêu cầu plugin Đăng nhập Near để hoạt động đúng cách. Vui lòng tham khảo tài liệu của plugin để biết bất kỳ phụ thuộc và hướng dẫn cài đặt cần thiết.

Để sử dụng plugin với hợp đồng thông minh và cho phép người dùng đã đăng nhập tương tác, sử dụng các phương thức sau:

Phương thức xem: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Phương thức thay đổi: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Xem bản demo của plugin.

Tải plugin về.
Kết luậnSự giao thoa của công nghệ web2 và web3 tạo ra một biên giới độc đáo và hấp dẫn cho thế giới số. Các nền tảng truyền thống như WordPress đã chứng minh tính linh hoạt và sự liên quan của họ trong cảnh quan tiến hóa này. Bằng cách tích hợp các tính năng web3 như hệ thống tên miền phi tập trung, hệ thống lưu trữ phi tập trung và API thanh toán tiền điện tử, WordPress thể hiện một mô hình lai, đặt mình ở vị trí hàng đầu của cuộc cách mạng web3.

Tinh thần mã nguồn mở và cộng đồng của WordPress tương đồng chặt chẽ với nguyên tắc của web3. Sự phổ biến rộng rãi, dễ sử dụng và tính linh hoạt của nó làm cho nó trở thành một bước nhảy lý tưởng cho sự chuyển đổi sang một internet phi tập trung hơn. Bằng cách hỗ trợ và khuyến khích đóng góp của cộng đồng, WordPress tạo ra một môi trường giống web3 trong bối cảnh web2.

Nếu bạn sẵn sàng tham gia kết nối NEAR với WordPress, hãy tham gia Nhóm Telegram này



	

	
	
		
			
				Which of the following is not a way that users can contribute to WordPress?
			
		

		
					

		
			
			
			
			Reporting bugs and suggesting new features
		
			
			Helping with translations
		
			
			Writing code or fixing bugs
		
			
			Paying for premium features
		
	
		

		
		
			
				Correct!
				Wrong!

### Ano ang NEAR protocol?

Inaasahan na resulta: batayang pag-unawa kung paano gumagana ang NEAR mula sa perspektibang end-user
Ang NEAR ay isang platform ng decentralized application na tumatakbo sa ibabaw ng blockchain ng NEAR Protocol. Ang blockchain na ito, na tumatakbo sa daan-daang mga makina sa buong mundo, ay naayos upang maging walang pahintulot, maaasahan at sapat na ligtas upang lumikha ng isang malakas at decentralized na data layer para sa bagong web,
Ang pangunahing misyon ng NEAR ay upang magpresenta ng isang platform na angkop para sa pagpapatakbo ng mga aplikasyon na may access sa isang pinagsasamang — at ligtas — pool ng pera, pagkakakilanlan at data na pag-aari ng kanilang mga user. Pinagsasama nito ang mga feature ng partition-resistant networking, serverless compute at distributed storage sa isang bagong uri ng platform.
Kaya, bago tayo magpatuloy, mag-aral muna tayo ng ilang kasaysayan at tingnan kung paano umunlad ang mga blockchain platform sa paglipas ng panahon.

Ang Pag-unlad ng Teknolohiyang Blockchain
Simula nang ilabas ni Satoshi Nakamoto ang Bitcoin whitepaper noong Oktubre 2008, nakilala na ng mundo ang makabagong teknolohiyang blockchain. Sa loob ng nakaraang dekada, ang blockchain ay dumaan sa tatlong yugto ng pag-unlad.
Generasyon 1: Bitcoin
Ang Bitcoin ay ang perpektong halimbawa ng unang-generasyon na blockchain. Layunin ng blockchain na ito na maging isang simpleng at tuwirang sistema ng pagbabayad. Nagsimula bilang "pera ng internet," ang Bitcoin ay naging isa sa pinakasikat na asset classes. Gayunpaman, may malaking problema pagdating sa BTC. Hindi ito praktikal na magconduct ng mga komplikadong transaksyon na maaaring may ilang mga layer ng metadata at logic na kaakibat nito.
Generasyon 2: Ethereum at Smart Contract Platforms
Ang Ethereum ang nagdala ng pangalawang-generasyon ng mga platform ng blockchain na may smart contracts. Sa wakas, naging posible sa mga developers na programahan ang mga sopistikadong transaksyon sa pamamagitan ng mga smart contracts, at lumikha ng decentralized applications (dApps). Sa pamamagitan ng mga dApps na ito, lumobo ang mga use cases ng blockchain.
Gayunpaman, ang espasyong ito ay nagtutumbas sa mga paghihirap sa paglaki. Ang pangunahing isyu ay ang mga blockchains na ito ay nagdurusa sa malalang isyu sa scalability. Halimbawa, ang Bitcoin ay may throughput na 7 transaksyon bawat segundo, habang ang Ethereum ay maaaring magmanage lamang ng 25. Kapag ihahambing mo ito sa PayPal (115 tps) at Visa (1,700 tps), napakababa nito.
Upang maging patas, kamakailan lang ay sinubukan ng Ethereum at Bitcoin na ayusin ang mga isyu sa scalability na ito sa pamamagitan ng ilang layer-two solutions tulad ng lightning network, raiden, plasma protocol atbp. Ang ideya dito ay lumikha ng karagdagang layer sa ibabaw ng underlying blockchain kung saan maaaring i-delegate ng pangunahing protocol ang mga repetitive at mahirap na gawain.Gayunpaman, may dalawang isyu sa paraang ito. Una, hindi pa natatanggap ng karamihan ang mga solusyong layer-2. Pangalawa, sinisira ng mga solusyong layer-2 ang orihinal na arkitektura ng protocol, na maaaring magdulot ng pangmatagalang epekto.
Dito pumapasok ang ikatlong henerasyon.
Henerasyon 3: NEAR
Ang NEAR ay isang halimbawa ng mga gen-3 blockchains, na layuning lutasin ang mga isyu sa scalability at payagan ang mga end-users at developers na tamasahin ang buong potensyal ng smart contracts at teknolohiyang blockchain. Sa halip na umasa sa teknolohiyang layer-2, lumalaya ang NEAR mula sa ideya na bawat solong node na lumalahok sa network ay dapat magpatakbo ng lahat ng code dahil ito ay nagdudulot ng isang malaking bottleneck at pumapabagal sa iba pang mga pamamaraan.
Upang ayusin ang isyung ito, gumagamit ang NEAR ng isang teknik na lubos nang popular sa mundo ng database - sharding. Kung maayos na ipinatutupad, ito ay nagbibigay-daan sa kapasidad ng network na lumaki habang dumarami ang bilang ng mga node sa network kaya't walang teoretikal na limitasyon sa kapasidad ng network. Ang pinakamahusay? Ang sharding ay isang teknik sa layer-1 scalability.

Ano ang Sharding?
Sa isang database, minsan kailangan mong harapin ang malalaking data. Ito ay lubos na nagpapabagal sa performance at throughput at nagiging lubos na hindi epektibo ang buong proseso. Dito pumapasok ang sharding.
Ang sharding ay nagpapartisyon ng iyong database nang horizontal at ginagawang mas maliit, mas madaling pamahalaan ang mga table.

Kaya, bakit horizontal partition at hindi vertical partition?
Isipin ang table na ito:


A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Nakita mo ba?
Dahil sa paghahati, ang table ay naging dalawang magkaibang table.
Sa kabaligtaran nito, ano ang nangyayari kapag hinati ang table ng horizontal:
Nakikita mo ba ang nangyayari? Kapag hinati mo ng pahalang ang table, sila ay nagiging dalawang magkaibang table sa kabuuan.
Gayunpaman, kung hahatiin natin sila ng pahalang:


A
B
A*B
A/B


3
3
9
1


4
4
16
1



Nakita mo ba?
Ang horizontal na partition ay nagpapaliit sa database sa mas maliit na mga table ng parehong database. Ang mga mas maliit na database na ito ay tinatawag na shards.

Paano Nakakatulong ang Sharding sa Blockchain?
Kung nakita natin hanggang ngayon, habang mas maraming nodes ang pumapasok sa Ethereum at Bitcoin ecosystem, mas matagal na ang buong proseso ng consensus at verification. Ngayon, paano tutulong ang sharding dito?
Ang sharding ay magbabahagi ng global state ng blockchain sa mas maliit na mga shards na mas madaling pamahalaan.
Ano ang nangyayari sa shard activation?


 	Ang state ay nahahati sa shards
 	Ang bawat natatanging account ay nasa isang shard, at ang mga accounts sa shard na iyon ay magttransact lamang sa iba pang accounts sa parehong shard.

Sa simpleng paraan, isipin ang scenario na ito. Mayroong isang kathang-isip na network na may tatlong nodes - A, B, at C at kailangan nilang i-verify ang data T. Ang data T ay hinati sa tatlong shards T1, T2, at T3. Sa halip na lahat ng mga nodes ay magtrabaho sa T bilang isang buo, maaari silang magtrabaho sa isang shard nang sabay-sabay. Makikita mo na ang dami ng oras na iyong nasasave ay exponential.
Hindi katulad ng maraming iba pang sharding approaches, na kailangan pa rin ng mga nodes na tumakbo sa mas kumplikadong hardware (na nagpapabawas sa kakayahan ng mas maraming tao na makilahok sa network), ang pamamaraan ng NEAR ay pinapayagan ang mga nodes na manatiling sapat na maliit upang tumakbo sa simpleng cloud-hosted instances.

Bakit Kinakailangan ang mga scalable blockchains tulad ng NEAR?
Hint: Hindi lahat tungkol sa bilis!
Kapag dating sa second at third gen blockchains, ang tunay na nagtatakda ng kanyang likas na halaga ay ang dapp ecosystem na umaasenso sa ibabaw nito. Kaya't, karamihan sa mga platform ng blockchain ay laging naglalaban upang maakit ang maraming developers hangga't maaari.Gayunpaman, ang problema sa kasalukuyang mga plataporma ay hindi nila kayang mag-host ng mataas na kalidad na mga apps. Ang isyu dito ay may mga developers na sumusubok na lumikha ng mga PS4 games sa isang plataporma na katulad ng Windows 98. Kaya't kailangan nilang mag-compromise ng malaki sa kabuuang kakayahan ng kanilang dApps.
Bukod dito, may isa pang factor na dapat isaalang-alang dito. Ang bilis ay isang mahalagang factor pagdating sa paggamit ng aplikasyon. Sa huli, bakit gagamitin ng mga users ang isang aplikasyon kung hindi ito magamit sa lahat? Kailangan ng mga developers ng isang tiyak na bilang ng mga users na patuloy na gagamit ng kanilang mga aplikasyon bago ito magkaroon ng kritikal na dami.
Ito ang dahilan kung bakit mahalaga ang isang blockchain platform na scalable tulad ng NEAR para sa pangunahing pagtanggap ng blockchain at smart contracts.
Pinapayagan ng NEAR ang mga developers na i-deploy ang kanilang app nang hindi masyadong iniisip kung paano gumagana o nag-sascale ang infrastructure sa paligid nito, na katulad ng mga modernong ulap tulad ng Amazon AWS o GCP o Azure na nagpapatakbo ng halos lahat ng mga web applications ngayon.

Kasaysayan ng NEAR
Nagsimula ang NEAR noong tag-init ng 2018 nang magpasya sina Alex Skidanov at Illia Polosukhin na magbago ng direksyon mula sa kanilang naunang pakikipagsapalaran sa negosyo, kung interesado ka maaari kang magbasa pa rito. Agad na, nang mag-quit si Misha sa MemSQL, lumaki ang team mula sa ilan hanggang 9 katao sa loob ng 3 araw noong Agosto. Ang orihinal na team ay binubuo ng 7 engineers, si Erik na nagpapatakbo ng business operations, at si Sasha na nakikipag-usap sa merkado.
Ngayon ang NEAR Collective ay ang pandaigdigang grupo ng mga team, binubuo ng maraming indibidwal na organisasyon at contributors, na nag-oorganisa ng kanilang sarili upang dalhin ang teknolohiyang ito sa buhay. Ito ay hindi isang negosyo o anumang malapit sa ganoon. Ihalintulad ito sa mga grupo ng mga tao na nagpapatakbo ng malalaking open-source software projects.
Isa sa mga proyekto ng Collective ay ang pagsusulat ng orihinal na code at reference implementation para sa open source NEAR network, parang pagbuo ng mga rocket boosters sa space shuttle. Ang kanilang trabaho ay gawin ang kinakailangang R&D work upang matulungan ang blockchain na makapasok sa orbit. Ang code para sa chain na ito ay open source kaya literal na sinuman ay maaaring mag-contribute o patakbuhin ito.Mahalaga na bigyang-diin na ang mga network tulad ng NEAR ay idinisenyo upang maging lubos na hindi nakakontrol. Ibig sabihin nito, sila ay ganap na umaandar nang hindi na kailangan ng tulong mula sa mga third parties... kahit na mula sa mga koponan na unang nagtayo sa kanila! Kaya, habang ang mga miyembro ng kolektibong ito ay narito upang simulan ang pagbuo ng reference implementation, sila agad na nagiging hindi na kailangan sa operasyon ng network kapag ito ay nagsimula nang tumakbo. Sa katunayan, kapag handa na ito sa paglulunsad, maaaring baguhin at patakbuhin ng sinuman ang NEAR Protocol na kodigo upang simulan ang kanilang sariling blockchain dahil ito ay bukas na mapagkukunan at ang anumang pagbabago ay dapat na tanggapin sa pamamagitan ng mga independent validators na patakbo nito.

Ang NEAR ay may magkakaibang koponan mula sa iba't ibang mga background, binubuo ng mga devs at researchers mula sa mga kumpanya tulad ng Microsoft, MemSQL, Meta, Google, at iba pa. Ang proyekto ay may suporta mula sa higit sa 40 investment firms na kasama ang ilan sa pinakamaimpluwensiyang VCs sa Silicon Valley, tulad ng a16z ng Andreessen Horowitz, Metastable, Pantera, Xspring ng Ripple's developer ecosystem project, at Coinbase.

Matapos ang mainnet launch, nagsimula ang koponan sa NEAR sa paghahanda para sa adoption phase.

Pagsulong ng Rainbow Bridge
Ang Rainbow Bridge ay itinuturing na pinakamahalagang tulay sa NEAR ecosystem. Inaasahan ng NEAR protocol ang tulay bilang isang trustless at permissionless bridge na nagbibigay-daan sa paglipat ng mga assets sa pagitan ng Ethereum, NEAR, at sa huli, Aurora. Pinapayagan ng Rainbow bridge ang mga developer na gamitin ang mga Ethereum assets sa NEAR nang walang abala at NEAR assets sa Ethereum. Mula nang ilunsad ang tulay, ginamit ng mga developer ang tulay upang ilipat ang higit sa $1 milyon halaga ng DAI, ETH, at iba pa. Maaari ring gamitin ang Rainbow Bridge at i-connect ang NEAR at lahat ng Ethereum-compatible chains tulad ng Binance Smart Chain, Polygon, Avalanche, Optimism, Arbitrum, at iba pa.

Pagsulong ng Aurora
Ang pagbuo ng Aurora EVM ay itinuturing din na mahalagang milestone sa pagtulak ng NEAR para sa adoption. Maaring ituring ang Aurora bilang pinakamalakas na EVM sa kasalukuyan, na kumukuha ng pakinabang mula sa ilang natatanging feature na inaalok ng NEAR. Binubuo ng Aurora ang dalawang pangunahing bahagi, ang Aurora Engine at ang Rainbow Bridge. Pinapayagan ng Aurora Engine ang walang abalang pag-deploy ng Solidity at Vyper smart contracts, habang pinapayagan ng Rainbow Bridge ang permissionless transfer ng mga assets sa pagitan ng Ethereum at Aurora. Kumpara sa Ethereum, kayang magbigay ng mas mababang bayad ang Aurora hanggang sa 1000x at mag-host ng libo-libong transaksyon kada segundo, na nagreresulta sa pagtaas ng 50x kumpara sa Ethereum.

Pagsisimula ng Private Shards
Noong Setyembre 2021, nakamit ng NEAR ang isang mahalagang milestone sa pagsisimula ng Private Shards. Ang mga private shards na ito ay umaandar bilang isang shard sa NEAR, pinapayagan ang mga public chain contracts na tumawag sa mga private shard contracts at vice versa.

Alamin pa ang tungkol sa Private Shards sa NEAR sa Calimero website

Paglikha ng DeFi FundsNoong Oktubre 2021, inanunsyo ng Proximity Labs ang isang $350 milyon development fund para sa NEAR. Ang grant ay tutulong sa pagbuo ng decentralized finance - mga aplikasyon ng DeFi sa NEAR. Sinundan ito ng isang pahayag ng NEAR Foundation, na nagsasabing lumilikha ito ng isang $800 milyon DeFi fund. Nag-anunsyo rin ang Blockworks ng paglulunsad ng isang NEAR-focused fund, na may plano na mag-ipon ng mga halos $40 milyon. 

Iba Pang Mahahalagang Pag-unlad

Ang mga nabanggit na pag-unlad sa itaas ay hindi lamang ang mga pag-unlad na naganap kaugnay ng NEAR Protocol. 

- Noong Nobyembre 2021, inanunsyo ng global travel agency na Travala.com ang isang partnership sa NEAR na magiging sanhi ng integrasyon ng network token sa Travala. 
- Inanunsyo rin ng NEAR ang paglulunsad ng Pagoda, isang startup platform na magfo-focus sa pagtulong sa mga developer sa paglikha ng mga app sa NEAR. Kasunod ng pahayag na ito, inanunsyo rin ng NEAR ang paglulunsad ng NEARPay. Ang NEARPay ay naging ang unang debit card at payments widget sa NEAR, na nagbubuklod ng fiat at crypto. 
- Pinili rin ng OrangeDAO, isang crypto collective na nilikha ng Y Combinator Alumni, ang NEAR bilang kanilang pangunahing Layer-1 blockchain. 
- Inilunsad ang NEAR-native stablecoin $USN sa pamamagitan ng Decentral Bank. 

Paano Gumagana ang NEAR Blockchain

Ang teknolohiyang sumusuporta sa cryptocurrency. Ang Blockchain ay isang teknolohiya na maaaring ligtas na mag-imbak ng mga tala ng transaksyon sa isang peer-to-peer network sa halip na ito ay iimbak sa isang solong lokasyon. Ang mga independent servers sa buong mundo, na tinatawag na nodes, ay bumubuo ng network na gumagana sa blockchain. 

Isa sa pinakamahalagang aspeto ng teknolohiyang blockchain ay ang decentralization. Kaya, bakit mahalaga ang decentralization? Tingnan natin ito mula sa perspektibo ng mga developer at end users. 

- Developers: Sa mundo ng centralized, madalas na nasa kagustuhan ng mga developer ang mga cloud platforms o kahit na ang gobyerno upang siguruhing maaari pa rin nilang patakbuhin ang mga apps. Sa mundo ng decentralized, walang mapang-api na mga intermediaryo. 
- End Users: Ang transparency ng decentralized applications ay maaaring magbigay daan sa mga users na makita ang backend code at malaman ng eksaktong kung paano gagamitin ng mga apps ang kanilang personal na impormasyon. 

Ano ang NEAR consensus algorithm?Ang mga protocol ng consensus ay ginagamit upang makarating sa kasunduan sa isang solong halaga sa pagitan ng maraming mga kalahok sa isang sistema. Kung lahat ng mga kalahok sa network ay nakikipagtulungan ayon sa protocol ng consensus, maaaring idagdag ang mga bagong halaga sa ledger at ma-verify ng mga nodes. Gayunpaman, sa kaso ng mga alitan, maaaring mag-focus ang network sa kaligtasan o liveness.
Ang mekanismo ng consensus na ipinatutupad sa NEAR ay tinatawag na Nightshade. Ang Nightshade ay nagmumodelo ng sistema bilang isang solong blockchain. Ang listahan ng lahat ng mga transaksyon sa bawat block ay hinati sa mga physical chunk, isang chunk bawat shard. Ang lahat ng chunks ay nag-aaccumulate sa isang block. Tandaan na ang mga chunks ay maaari lamang i-validate ng mga nodes na nagmamantini ng estado ng shard na iyon.
Pangungusap sa validation, isang pangunahing bahagi ng NEAR ay ang mga validators. Ang mga validators ay responsable sa pagmamantini ng consensus sa loob ng protocol. Ang mga validators ay espesyalisadong nodes na kailangang panatilihing online ang kanilang mga servers 100% ng oras habang patuloy na nag-u-update ang kanilang mga sistema.
Narito ang ilang mga punto na dapat mong tandaan tungkol sa mga network validators.


 	Itinatakda ng NEAR ang mga network validators nito sa bawat bagong epoch, pinipili sila batay sa kanilang stake.
 	Ang mga naunang napili na validators ay muling ina-enroll sa pamamagitan ng awtomatikong pag-re-stake ng kanilang mga tokens pati na rin ang mga accrued rewards
 	Ang mga potensyal na validators ay dapat magkaroon ng kanilang stake higit sa isang dynamically determined level.
 	May dalawang paraan na maaaring gamitin ng isang validator upang palakasin ang kanilang stake - bumili ng mga tokens o manghiram sa pamamagitan ng stake delegation.
 	Ang reward na natatanggap mo ay direkta proporsyonal sa iyong stake. Mas mataas ang iyong stake, mas mataas ang iyong rewards.

Ang consensus ay batay sa heaviest chain consensus. Ibig sabihin, kapag naglathala ng isang block producer ng isang block, nagko-collect sila ng mga pirma ng validator nodes. Ang timbang ng isang block ay ang cumulative stake ng lahat ng mga signers kung saan kasama ang kanilang mga pirma sa block. Ang timbang ng isang chain ay ang kabuuan ng mga timbang ng mga block. Bukod dito, ang consensus ay gumagamit ng isang finality gadget na nagdadagdag ng karagdagang slashing conditions para sa mas mataas na seguridad ng chain.



	

	
	
		
			
				Express Quiz: The weight of a block is:
			
		

		
					

		
			
			
			
			The maximum stake of the signers whose signatures are included in the block
		
			
			The cumulative stake of all the signers whose signatures are included in the block
		
			
			The average stake of the entire network divided by the number of signers in the block
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Runtime
Ang layer ng runtime ay ginagamit upang ipatupad ang smart contracts at iba pang mga aksyon na nilikha ng mga users at panatilihin ang estado sa pagitan ng mga executions. Maaaring ilarawan ito mula sa tatlong iba't ibang anggulo: pagtahak sa iba't ibang mga scenario, paglalarawan ng mga component ng runtime, at paglalarawan ng mga functions na isinasagawa ng runtime.

Ano ang NEAR token?Ang NEAR token ay ang pangunahing native asset ng NEAR ecosystem at ang kanyang kakayahan ay pinapagana para sa lahat ng mga account. Bawat token ay isang natatanging digital asset na katulad ng Ether na maaaring gamitin upang:


 	Magbayad sa sistema para sa pagproseso ng mga transaksyon at pag-iimbak ng data.
 	Patakbuhin ang isang validating node bilang bahagi ng network sa pamamagitan ng pagsali sa staking process.
 	Tumulong sa pagtukoy kung paano ina-allocate ang mga network resources at kung saan patutungo ang hinaharap na teknikal na direksyon nito sa pamamagitan ng pagsali sa governance processes.

Ang NEAR token ay nagpapagana ng ekonomikong koordinasyon ng lahat ng mga kalahok na nagpapatakbo ng network pati na rin ito ay nagpapagana ng mga bagong kilos sa mga aplikasyon na itinayo sa tuktok ng network na iyon.

Paano magsimula sa NEAR?
Account/Wallet
Bago ka magsimula sa NEAR, ang unang bagay na dapat mong gawin ay itakda ang isang NEAR account.
Panoodin ang video na ito tungkol sa NEAR accounts:

Ang wallet ay nagbibigay-daan sa iyo upang gumawa ng mga contract calls sa blockchain, itakda ang iyong lokal na node, at magpadala at tumanggap ng pondo mula sa iba pang mga user. Kapag nagparehistro ka ng iyong Account ID, kailangan mong magbigay ng isang natatanging pangalan. Bagaman bawat wallet ay dapat magkaroon ng isang natatanging pangalan, maaaring magtakda ng maraming wallets ang bawat user.
Maaari mong isipin ito katulad ng isang Facebook o Google account. Kapag nagparehistro ka sa isa sa mga serbisyo, maaari mong gamitin ang parehong account upang mag-log in sa third-party services. Ang pagkakaiba sa pagitan ng NEAR Account IDs at Google accounts ay na ang data, na naka-imbak laban sa isang Account ID, ay maaari lamang ma-access at pamahalaan ng may-ari ng wallet. Bukod dito, ang lahat ng impormasyon ay naka-imbak sa isang distributed network ng nodes sa halip na isang solong server.
Lumikha ng NEAR account ngayon: https://wallet.near.org/create
Karagdagang impormasyon tungkol sa Accounts sa DOCS.NEAR

NEAR ExplorerAng NEAR Explorer ay nagbibigay-daan sa iyo na tingnan ang mga block creations sa real time! Ang kapaki-pakinabang na tool na ito ay nagbibigay-daan sa iyo na maghanap para sa transactions at accounts na nagbibigay-daan sa iyo na tingnan ang lahat ng mga interactions sa pagitan ng mga user at smart contracts.


Paano makakuha ng NEAR tokens?
Mayroong 3 paraan para makakuha ng $NEAR

Kumita nito
Maaari kang kumita ng $NEAR sa pamamagitan ng pagsali sa development bounties, sa pamamagitan ng pagpapatakbo ng isang komunidad na tumutulong sa mga tao na magtayo sa NEAR, sa pamamagitan ng pagwawagi sa isang NEAR hackathon o sa iba pang paraan na maging aktibong bahagi ng komunidad. Kung makakapag-akit ka ng ibang tao na magpapahiram sa iyo ng tokens para sa staking, maaari ka ring kumita ng $NEAR sa pamamagitan ng pagpapatakbo ng isang validator.

Bilhin ito
Ang $NEAR ay available sa ilang major exchanges (tingnan sa ibaba), kung saan maaari kang mag-sign up at bumili ng token gamit ang fiat currency o crypto.
Mga exchanges na naglalista ng $NEAR
Maaari mong tingnan ang mga overview ng pricing at pairs sa coinmarketcap at coingecko.
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

Mula sa Kaibigan
Hindi mo kailangang magkaroon ng NEAR account para makatanggap ng NEAR tokens! Ang "NEAR Drop" approach ay nagbibigay-daan sa iyong kaibigan na mag-pre-fund ng bagong account at magpadala sa iyo ng hot link upang makuha ang mga tokens.

Ano ang magagawa ko sa NEAR tokens?
I-transfer ang NEARIpadala ang $NEAR pabalik-balik sa pagitan ng iyong account at ng kaibigan mo at tingnan ang mga transaksyon sa Block Explorer. Dahil napakababa ng mga bayad sa transaksyon, maaari mong madaling ilipat ang napakaliit na halaga ng $NEAR upang maglaro dito.
Ipadala ang mga ito bilang regalo sa http://redpacket.near.org/

Subukan ang NEAR Drop (Mag-imbita ng kaibigan)
Ipadala sa iyong kaibigan ang NEAR drop kung kailangan nilang lumikha ng account.

Gamitin ang NEAR Apps
Upang tingnan ang lumalaking listahan ng mga apps na itinatag sa NEAR, pindutin dito.
Madaling simulan ang NFT- bumili/maglathala/magpalitan ng sining sa https://paras.id/
Maglaro sa BerryClub upang makilahok sa kolektibong paglikha ng sining: https://berryclub.io/

Magkano ang halaga ng paggamit ng NEAR (Gas)?
Kapag tumatawag ka sa blockchain ng NEAR upang i-update o baguhin ang data, mayroong mga tao na nagpapatakbo ng imprastruktura ng blockchain na nagbabayad ng gastos. Sa katapusan ng araw, may mga computer sa ibang lugar na nagproseso ng iyong kahilingan, at ang mga validator na nagpapatakbo ng mga computer na ito ay naglalaan ng malaking puhunan upang mapanatili ang mga computer na ito.
Katulad ng iba pang programmable blockchains, nagpapalitan ng bayad ang NEAR sa mga taong ito sa pamamagitan ng pagpapataw ng bayad sa transaksyon, na tinatawag ding gas fees.
Kung pamilyar ka sa mga nagbibigay ng serbisyong cloud sa web2 (Amazon Web Services, Google Cloud, atbp), isang malaking kaibahan sa mga blockchains ay ang pagkakaroon ng bayad kaagad ng mga gumagamit kapag tumatawag sila sa isang app, sa halip na ang mga developer ang nagtutustos ng gastos sa paggamit ng lahat ng imprastruktura. Ito ay lumilikha ng mga bagong posibilidad, tulad ng mga apps na walang pangmatagalang panganib na mawala dahil sa pagkaubos ng pondo ng developer/kumpanya. Gayunpaman, may ilang mga hadlang sa bilis ng paggamit nito. Upang matulungan dito, nagbibigay din ang NEAR ng kakayahan para sa mga developer na sagutin ang mga gastos sa gas para sa mga gumagamit, upang lumikha ng mas pamilyar na karanasan sa mga nagmumula sa web2.
Kapag iniisip ang gas, tandaan ang dalawang konsepto:
 	Gas units: internally, transaction fees are not calculated directly in NEAR tokens, but instead go through an in-between phase of “gas units”. The benefit of gas units is that they are deterministic – the same transaction will always cost the same number of gas units.
 	Gas price: gas units are then multiplied by a gas price to determine how much to charge users. This price is automatically recalculated each block depending on network demand (if previous block is more than half full the price goes up, otherwise it goes down, and it won’t change by more than 1% each block), and bottoms out at a price that’s configured by the network, currently 100 million yoctoNEAR.

Note that the gas price can differ between NEAR’s mainnet & testnet. Check the gas price before relying on the numbers below.
Thinking in gas
NEAR has a more-or-less one second block time, accomplished by limiting the amount of gas per block. The gas units have been carefully calculated to work out to some easy-to-think-in numbers:
10¹² gas units, or 1 TGas (TeraGas)…
≈ 1 millisecond of “compute” time
…which, at a minimum gas price of 100 million yoctoNEAR, equals a 0.1 milliNEAR charge
This 1ms is a rough but useful approximation, and is the current goal of how gas units are set within NEAR. Gas units encapsulate not only compute/CPU time but also bandwidth/network time and storage/IO time. Via a governance mechanism, system parameters can be tweaked, shifting the mapping between TGas and milliseconds in the future, but the above is still a good starting point for thinking about what gas units mean and where they come from.
Quiz: 1 TeraGas or TGas is equal to:



	

	
	
		
			
				1 TeraGas or TGas is equal to:
			
		

		
					

		
			
			
			
			1 microsecond of compute time
		
			
			10 seconds of compute time
		
			
			1 millisecond of compute time
		
			
			1 nano second of compute time
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







The cost of common actions
To give you a starting point for what to expect for costs on NEAR, the table below lists some common actions and how much TGas they currently require, and what the fee would be, in milliNEAR, at the minimum gas price of 100 million yN.


Operation
TGas
bayad (mN)
bayad (Ⓝ)


Lumikha ng Account
0.42
0.042
4.2⨉10⁻⁵


Ipadala ang Pondo
0.45
0.045
4.5⨉10⁻⁵


Mag-Stake
0.50
0.050
5.0⨉10⁻⁵


Magdagdag ng Buong Access Key
0.42
0.042
4.2⨉10⁻⁵


Tanggalin ang Key
0.41
0.041
4.1⨉10⁻⁵



Paano ako kikita sa NEAR?
Mag-Stake ng iyong NEAR
Ang susi sa modelo ng Proof-of-Stake ay kung paano sinusuportahan ng komunidad ang mga Validator sa pamamagitan ng Staking. Kikita ng mga Validator ng mga token ng NEAR bilang gantimpala sa pagpapatakbo ng mga node na tumatakbo sa network sa anyo ng isang static inflation rate na 5% bawat taon, na lumilikha ng bagong mga token para sa mga Validator bawat epoch (~12 oras) bilang gantimpala.
Dapat panatilihin ng mga Validator ang isang minimum na halaga ng Stake upang mapanatili ang kanilang Validator seat. Ang mga may-ari ng token ay maaaring mag-Stake sa isang partikular na Validator na pinaniniwalaan nilang mahusay na nagpapatakbo para sa network at kumita ng isang bahagi ng mga gantimpalang Token na nilikha ng network. Ito ay nagbibigay ng insentibo sa mga may-ari ng token na manatiling kasangkot sa komunidad!
Ang NEAR Wallet ngayon ay mayroong staking user interface na direktang built-in sa web app.
Upang Mag-Stake:


 	Pumili ng "Staking" mula sa navigation bar (o dropdown sa mobile)
 	I-click ang "Pumili ng Validator" button
 	Pumili ng isang validator
 	Kumpirmahin ang iyong pagpili at piliin ang "Stake with Validator"
 	Ilagay ang halaga ng NEAR na nais mong i-stake, at i-click ang "Ipasa ang Stake"
Kailangan mong kumpirmahin ang dalawang transaksyon, isa para pumili ng validator, at isa pa para magdeposito at mag-stake sa validator.
Upang Mag-Unstake:


	Sa staking dashboard (/staking), piliin ang iyong kasalukuyang validator
	I-click ang "Unstake" at kumpirmahin ang transaksyon

Matapos ang 36 hanggang 48 oras (4 buong epochs), maaari mo nang i-withdraw ang iyong stake. Upang gawin ito, bumalik sa pahina ng validator, at i-click ang "Withdraw."



	

	
	
		
			
				New tokens are created as rewards after epoch which is approximately every:
			
		

		
					

		
			
			
			
			12 minutes
		
			
			12 seconds
		
			
			12 days
		
			
			12 hours
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Pagbuo ng DeFi Sa NEAR
Ang ekosistema ng DeFi (Decentralized Finance) ay nasa kasalukuyang usok. Sa ngayon, ang Ethereum ay may hawak ng DeFi network na nagkakahalaga ng higit sa $100 bilyon. Pagdating sa NEAR, ang DeFi ekosistema nito ay bago pa at patuloy na lumalaki.


Base sa DeFiLlama, ang Total Value Locked (TVL) ng ekosistema ng NEAR ay mas mababa sa $100 milyon, kung saan ang Ref Finance ang nangunguna sa merkado. Ang katunayan na ang DeFi ekosistema ng Ethereum ay 1000X kaysa sa NEAR ay nagpapakita na maaga pa tayo pagdating sa NEAR DeFi. Sa katunayan, noong 2021, inanunsyo ng NEAR Protocol ang isang $800 milyong funding initiative. Ang karamihan ng pondo ay nakalaan upang palaguin ang sektor ng DeFi ng protocol.

Kung gusto mong malaman pa ang tungkol sa DeFi ekosistema ng NEAR, basahin ito.
Lumalaking Ecosystem ng NFT sa NEAR
Ang non-fungible asset ay may natatanging katangian na naghihiwalay dito mula sa iba pang mga asset. Ang non-fungible tokens ay batay sa non-fungible assets at mga natatanging digital asset na gumagamit ng teknolohiyang blockchain. Kamakailan lamang, ang sektor na ito ay sumiklab at lumobo sa kasikatan.

Ang NEAR Protocol ay ang perpektong platform para sa NFTs dahil mayroon itong dalawang pangunahing bentahe kumpara sa Ethereum:

	Ang NEAR ay significantly mas mabilis.
	Ang Ethereum ay may mas mataas na gas fees.

Dahil dito, ang NEAR ay ideal para sa pagbili at pagbebenta ng NFTs. Basahin ang artikulong ito upang malaman pa ang tungkol sa top 7 NFT projects sa NEAR.
Ano Na Ngayon? Paano Ako Makikipag-ugnayan sa NEAR?Sige, ano ang susunod? Kung nabasa mo ito hanggang dulo, malamang gusto mong mas lalimin ang NEAR protocol. Kaya, ang susunod na dapat mong gawin ay tingnan ang NEAR whitepaper. Kung bago ka sa blockchain at gusto mong matuto pa tungkol sa tech mismo, maaari mong tingnan ang video na ito sa pag-deconstruct ng blockchain ecosystem.
Sumali sa NEAR Discord server at tingnan ang NEAR Forum

### Chain Signatures trên NEAR là một phương pháp xác thực chữ ký được sử dụng để xác minh các giao dịch trên chuỗi. Điều này giúp đảm bảo tính toàn vẹn và an toàn của hệ thống NEAR.

Vào ngày 8 tháng 8 năm 2024, NEAR đã công bố việc ra mắt "Chain Signatures," cho phép các tài khoản NEAR, bao gồm cả hợp đồng thông minh, ký và thực thi giao dịch trên các chuỗi khối được hỗ trợ. Theo NEAR, Chain Signatures có thể loại bỏ các rào cản đối với việc tham gia, thúc đẩy tính thanh khoản và tính sử dụng cao hơn, và khuyến khích một tương lai trừu tượng hóa chuỗi. Bài viết này sẽ xem xét Chain Signatures và hiểu cách chúng hoạt động. Nó cũng sẽ thảo luận ngắn gọn về cách tạo một Chain Signature.
Những Thách Thức Của Tính Tương Thích Mạng Lưới Giữa Các Chuỗi 
Số lượng giao dịch qua cầu đã tăng đáng kể trong những tháng gần đây, cho thấy nhu cầu ngày càng tăng về tính tương thích mạng lưới giữa các chuỗi và giao dịch. Tuy nhiên, tính tương thích mạng lưới giữa các chuỗi đi kèm với những thách thức, chủ yếu là do cầu cầu cầu giữa các chuỗi dễ bị tấn công vì có một bề mặt tấn công lớn. Vấn đề thứ hai là thiếu sự hỗ trợ từ các chuỗi. Hầu hết các cầu không hỗ trợ các chuỗi không phải EVM. Vấn đề lớn thứ ba là UX không nhất quán và cồng kềnh. Mỗi cầu có một thiết kế khác nhau, có nghĩa là người dùng phải trải qua một quá trình học trước khi sử dụng nó.

Một vấn đề quan trọng khác xảy ra khi người dùng phải mua các token khác nhau để thanh toán phí gas. Một số cầu cũng sử dụng phiên bản bọc của một tài sản cụ thể. Phiên bản bọc khác biệt so với tài sản gốc trên chuỗi ban đầu. Nó có thể không phải là tài sản mà người dùng cần, và sau khi qua cầu, họ có thể kết thúc với một tài sản không được hỗ trợ hoặc một tài sản có tính thanh khoản thấp.




	

	
	
		
			
				What Are The Challenges Facing Cross-Chain Interoperability?
			
		

		
					

		
			
			
			
			The threat of exploits
		
			
			A lack of chain support
		
			
			An inconsistent and cumbersome UX
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Chain Signatures Là Gì? 
Chain Signatures trên NEAR cho phép tất cả các tài khoản NEAR, bao gồm cả hợp đồng thông minh, ký và thực thi giao dịch trên nhiều chuỗi khối được hỗ trợ. Chúng tận dụng tính toán đa bên (MPC), và một mạng lưới phân tán của các nhà điều hành nút để tạo chữ ký chung, cho phép các tài khoản NEAR và hợp đồng thông minh kiểm soát các chuỗi khối bên ngoài. MPC là một giao thức phối hợp bảo vệ quyền riêng tư cho phép nhiều bên thực hiện tính toán mà không tiết lộ dữ liệu cho nhau. Chain Signatures mở khóa cấp độ tiếp theo của tính tương thích mạng lưới bằng cách cho phép một tài khoản NEAR sở hữu một loạt các tài sản, dữ liệu và tài khoản giữa các chuỗi.

Bởi NEAR Docs
Chain Signatures Hoạt Động Như Thế Nào?
Chain Signatures trên NEAR hoạt động nhờ vào sự tương tác giữa ba yếu tố chính:

 	Các đường dẫn phát sinh
 	Hợp đồng thông minh đa chuỗi
 	Dịch vụ Tính toán Đa bên

Hãy xem xét kỹ hơn từng yếu tố.
Các Đường Dẫn Phát Sinh Chữ ký chuỗi cho phép một tài khoản NEAR được liên kết với các địa chỉ dựa trên các blockchain khác bằng cách sử dụng một cơ chế gọi là Additive Key Derivation. Đây là một cơ chế đơn giản được sử dụng để tạo ra các subkey từ một master key duy nhất. Các subkey được tạo ra bằng cách sử dụng Derivation Paths. Vậy, Derivation Path là gì? Derivation Path là một chuỗi đơn giản tạo ra một địa chỉ duy nhất trên blockchain mục tiêu khi được sử dụng với một tài khoản NEAR.
Hợp Đồng Thông Minh Đa Chuỗi
Như tên gọi, một hợp đồng thông minh đa chuỗi yêu cầu chữ ký cho các giao dịch trên các blockchain khác. Các hợp đồng này sử dụng một phương thức sign xem xét hai tham số chính khi yêu cầu chữ ký.

	Dữ liệu hoặc giao dịch cần được ký cho blockchain mục tiêu.
	Đường dẫn xác định tài khoản mà người dùng muốn sử dụng để ký giao dịch.

Khi có yêu cầu chữ ký, phương thức sign trả về "execution waiting", và dịch vụ ký MPC ký giao dịch. Khi sẵn sàng, hợp đồng tiếp tục tính toán và trả về chữ ký cho người dùng. Chữ ký sau đó có thể được gửi đến blockchain mục tiêu, nơi nó có thể được thực thi.
Dịch Vụ Tính Toán Đa Bên
Trong bài viết trước, chúng ta đã tóm tắt về Tính Toán Đa Bên (MPC). MPC cho phép các bên độc lập thực hiện tính toán chia sẻ trên thông tin riêng mà không tiết lộ bất cứ điều gì cho nhau. Blockchain có thể sử dụng hệ thống này để ký giao dịch thay mặt cho người dùng mà không tiết lộ private keys. Dịch Vụ Tính Toán Đa Bên trên NEAR bao gồm các nút độc lập. Những nút này không thể tự ký giao dịch. Thay vào đó, họ tạo ra chữ ký-shares. Những chữ ký-shares này được tổng hợp thông qua nhiều vòng để ký giao dịch chung.

Khi dịch vụ MPC phát hiện yêu cầu chữ ký, nó thực hiện các bước sau.

	Yêu cầu các nút tạo chung một chữ ký cho dữ liệu sử dụng tài khoản được xác định bằng đường dẫn.
	Gọi hợp đồng v1.signer để lưu trữ chữ ký khi nó sẵn sàng.




	

	
	
		
			
				What Key Elements Facilitate The Functioning Of Chain Signatures?
			
		

		
					

		
			
			
			
			Multichain smart contracts
		
			
			Multi-party Computational Service
		
			
			Derivation Paths
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tạo Một Chữ Ký Chuỗi
Việc Tạo Một Chữ Ký Chuỗi bao gồm năm bước:

	Tạo ra địa chỉ nước ngoài
	Tạo một giao dịch
	Yêu cầu một chữ ký
	Khôi phục chữ ký
	Chuyển tiếp giao dịch đã ký

Tạo Địa Chỉ Nước Ngoài
Như đã đề cập, Chữ Ký Chuỗi sử dụng đường dẫn tạo ra để đại diện cho một hoặc nhiều tài khoản trên blockchain mục tiêu bằng các bước được liệt kê dưới đây. Tên tài khoản NEAR và phần tạo ra được sử dụng để tạo ra một địa chỉ duy nhất cho người dùng trên blockchain mục tiêu.
Tạo Giao Dịch
Sau khi tạo ra địa chỉ, người dùng xây dựng giao dịch cần được ký. Các bước để tạo giao dịch cần được ký khác nhau tùy thuộc vào blockchain mục tiêu.
Yêu Cầu Chữ KýKhi giao dịch đã được tạo và sẵn sàng để ký, yêu cầu chữ ký có thể được thực hiện bằng cách gọi "sign" trên hợp đồng thông minh MPC. Phương pháp này yêu cầu hai tham số chính: giao dịch phải được ký cho blockchain mục tiêu và đường dẫn phát sinh cho tài khoản được sử dụng để ký giao dịch.
Tái Tạo Chữ Ký 
Hợp đồng MPC không trả về chính chữ ký giao dịch. Thay vào đó, nó trả về các yếu tố cần thiết để tái tạo chữ ký, cho phép hợp đồng tổng quát hóa quá trình ký cho nhiều blockchain.
Truyền Chữ Ký 
Sau khi chữ ký đã được tái tạo, nó có thể được truyền đến mạng tương ứng. Phương pháp này cũng thay đổi tùy thuộc vào blockchain mục tiêu.
Các Ứng Dụng Của Chữ Ký Chuỗi 
Chữ Ký Chuỗi có một số ứng dụng tiềm năng. Hãy xem một số trong số chúng.
DeFi Trên Các Chuỗi Không Có Hợp Đồng Thông Minh 
Chữ Ký Chuỗi có thể kích hoạt DeFi trên các chuỗi không có hợp đồng thông minh, bao gồm Ripple, Doge, và thậm chí Bitcoin. Cho đến nay, những chuỗi này chỉ hỗ trợ các chuyển khoản trên mạng. Hợp đồng thông minh NEAR có thể hoạt động như các hợp đồng ủy thác, và các nhà phát triển cũng có thể xây dựng giao thức trao đổi hoặc cho vay có khả năng hỗ trợ bất kỳ tài sản nào trên bất kỳ chuỗi nào.
Các Ứng Dụng Không Phụ Thuộc Vào Chuỗi 
Chữ Ký Chuỗi có thể ký giao dịch cho nhiều blockchain, cho phép các nhà phát triển hỗ trợ các chuỗi khác nhau với một hợp đồng thông minh.
Trừu Tượng Hóa Tài Khoản Đa Chuỗi 
Chữ Ký Chuỗi có thể cho phép người dùng kiểm soát tài sản trên nhiều chuỗi chỉ với tài khoản NEAR của họ. Họ cũng có thể sử dụng các tính năng trừu tượng hóa tài khoản trên các chuỗi khác nhau, bao gồm passkeys và key rotation.
DeFi Chéo Chuỗi Không Cần Cầu 
Chữ ký chéo chuỗi loại bỏ nhu cầu cho cầu chéo chuỗi. Thay vào đó, các giao dịch chéo chuỗi có thể được thực hiện bằng cách sử dụng giao thức chữ ký MPC, tạo điều kiện cho một loạt sản phẩm DeFi. Chữ Ký Chuỗi dựa trên hợp đồng thông minh cũng có thể tạo điều kiện cho các ứng dụng tập trung vào quyền riêng tư và triển khai đa chuỗi không cần tin cậy.
Bắt Đầu Với Chữ Ký Chuỗi 
Bạn có thể làm quen với Chữ Ký Chuỗi bằng cách làm theo các bước được liệt kê dưới đây.
 	Bạn có thể xem tài liệu NEAR để hiểu cách Chữ ký Chuỗi có thể đơn giản hóa việc tương tác giữa các blockchain.
 	Bạn cũng có thể xem một số ví dụ về các trường hợp sử dụng Chữ ký Chuỗi. Điều này bao gồm Multichain DAO, Multichain NFT Minter, và Bitcoin Runes airdrop.
 	Bạn có thể truy cập thông tin kỹ thuật chi tiết và đoạn mã thông qua tài liệu Chữ ký Chuỗi trên NEAR.
 	Bạn cũng có thể sử dụng demo để gửi giao dịch trên Bitcoin, Ethereum, Doge, và Ripple.
 	Cuối cùng, bạn có thể tham gia cộng đồng Chữ ký Chuỗi bằng cách tham gia kênh phát triển Chain Abstraction trên Telegram.

Kết luận
Sau khi mới xuất hiện trên mainnet, Chữ ký Chuỗi đã trở thành một công cụ mạnh mẽ cho phép tài khoản NEAR kiểm soát tài khoản trên các blockchain khác. Điều này đánh dấu một bước quan trọng trong việc cho phép sở hữu tài sản và dữ liệu trên nhiều chuỗi. Chữ ký Chuỗi làm cho toàn bộ quá trình sở hữu qua nhiều chuỗi trở nên trên chuỗi. Tất cả người dùng cần làm là gọi hợp đồng thông minh và chờ phản hồi.




	

	
	
		
			
				What Are The Use Cases Of Chain Signatures?
			
		

		
					

		
			
			
			
			Enabling DeFi on non-smart contract chains
		
			
			Multichain account abstraction
		
			
			Bridgeless cross-chain DeFi
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Các đường đi sai cho phép một tài khoản NEAR duy nhất kiểm soát nhiều tài khoản trên nhiều blockchain, trong khi dịch vụ MPC cho phép người dùng đảm bảo chỉ có họ mới có thể yêu cầu chữ ký cho những tài khoản đó. Chữ ký Chuỗi cũng có thể thúc đẩy sự trừu tượng chuỗi, cho phép một lớp người dùng duy nhất tương tác với bất kỳ tài sản nào trên bất kỳ chuỗi nào, đơn giản hóa sự phức tạp của Web3.

### ¿Qué son las firmas de cadena en NEAR?

El 8 de agosto de 2024, NEAR anunció el lanzamiento de "Firmas de Cadena", que permiten a las cuentas de NEAR, incluidos los contratos inteligentes, firmar y ejecutar transacciones en las blockchains compatibles. Según NEAR, las Firmas de Cadena pueden eliminar barreras de entrada, promover la liquidez y una mayor usabilidad, y fomentar un futuro abstracto de cadenas. Este artículo examinará las Firmas de Cadena y entenderá cómo funcionan. También discutirá brevemente cómo crear una Firma de Cadena.Los Desafíos de la Interoperabilidad entre Cadenas
Los volúmenes de los puentes han registrado un fuerte aumento en los últimos meses, señalando una creciente demanda de interoperabilidad y transacciones entre cadenas. Sin embargo, la interoperabilidad entre cadenas conlleva desafíos, principalmente porque los puentes entre cadenas son vulnerables a exploits debido a una gran superficie de ataque. El segundo problema es la falta de soporte de cadenas. La mayoría de los puentes no admiten cadenas que no sean EVM. El tercer problema importante es una experiencia de usuario inconsistente y engorrosa. Cada puente tiene un diseño diferente, lo que significa que los usuarios deben pasar por una curva de aprendizaje antes de usarlo.

Otro problema significativo ocurre cuando los usuarios deben adquirir diferentes tokens para pagar las tarifas de gas. Algunos puentes también utilizan una versión envuelta de un activo particular. La versión envuelta es diferente del activo nativo en la cadena original. Es posible que ni siquiera sea el activo que el usuario necesita, y una vez transferido, pueden terminar con un activo no compatible o uno con baja liquidez.




	

	
	
		
			
				What Are The Challenges Facing Cross-Chain Interoperability?
			
		

		
					

		
			
			
			
			The threat of exploits
		
			
			A lack of chain support
		
			
			An inconsistent and cumbersome UX
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Qué Son las Firmas de Cadena?
Las Firmas de Cadena en NEAR permiten que todas las cuentas de NEAR, incluidos los contratos inteligentes, firmen y ejecuten transacciones en múltiples blockchains compatibles. Utilizan Cómputos de Partes Múltiples (MPC) y una red distribuida de operadores de nodos para crear firmas conjuntas, lo que permite a las cuentas de NEAR y a los contratos inteligentes controlar blockchains externas. MPC es un protocolo de coordinación que preserva la privacidad y permite a múltiples partes realizar cálculos sin revelar los datos entre sí. Las Firmas de Cadena desbloquean el siguiente nivel de interoperabilidad entre blockchains al dar a una sola cuenta de NEAR la propiedad de una amplia gama de activos, datos y cuentas entre cadenas.

 Por NEAR Docs
¿Cómo Funcionan las Firmas de Cadena?
Las Firmas de Cadena en NEAR funcionan debido a las interacciones entre tres elementos clave:

 	Rutas de derivación
 	Contratos inteligentes multichain
 	Servicio Computacional de Partes Múltiples

Veamos más de cerca cada uno.
Rutas de DerivaciónLas Firmas de Cadena permiten que una cuenta de NEAR esté vinculada a direcciones basadas en otras blockchains utilizando un mecanismo llamado Derivación de Clave Aditiva. Este es un mecanismo simple utilizado para derivar subclaves a partir de una única clave maestra. Las subclaves se generan utilizando Caminos de Derivación. Ahora, ¿qué es un Camino de Derivación? Un Camino de Derivación es una cadena simple que deriva una dirección única en la blockchain objetivo cuando se utiliza con una cuenta de NEAR.
Contratos Inteligentes Multicadena 
Como su nombre lo indica, un contrato inteligente multicadena solicita firmas para transacciones en otras blockchains. Estos contratos utilizan un método de firma que considera dos parámetros principales al solicitar firmas.

 	La carga útil o transacción que debe ser firmada para la blockchain objetivo.
 	El camino que identifica la cuenta que un usuario desea utilizar para firmar la transacción.

Cuando se realiza una solicitud de firmas, el método de firma produce "espera de ejecución", y el servicio de firma MPC firma la transacción. Una vez listo, el contrato reanuda la computación y devuelve la firma al usuario. La firma luego se puede enviar a la blockchain objetivo, donde se puede ejecutar.
Servicio de Computación Multi-Parte 
Anteriormente en el artículo, discutimos brevemente la Computación Multi-Parte (MPC). MPC permite que partes independientes realicen cálculos compartidos sobre información privada sin revelar nada entre sí. Las blockchains pueden utilizar este sistema para firmar transacciones en nombre de los usuarios sin revelar claves privadas. El Servicio de Computación Multi-Parte en NEAR consta de nodos independientes. Estos nodos no pueden firmar transacciones por sí mismos. En su lugar, crean partes de firma. Estas partes de firma se agregan a través de múltiples rondas para firmar conjuntamente transacciones.

Cuando el servicio MPC detecta una solicitud de firma, ejecuta los siguientes pasos.

 	Solicita a los nodos crear conjuntamente una firma para la carga utilizando la cuenta identificada por el camino.
 	Llama al contrato v1.signer para almacenar la firma una vez que esté lista.




	

	
	
		
			
				What Key Elements Facilitate The Functioning Of Chain Signatures?
			
		

		
					

		
			
			
			
			Multichain smart contracts
		
			
			Multi-party Computational Service
		
			
			Derivation Paths
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Creando una Firma de Cadena 
Crear una Firma de Cadena implica cinco pasos:

 	Derivar la dirección extranjera
 	Crear una transacción
 	Solicitar una firma
 	Reconstruir la firma
 	Reenviar la transacción firmada

Derivando la Dirección Extranjera 
Como se mencionó, las Firmas de Cadena utilizan caminos de derivación para representar una cuenta o cuentas en la blockchain objetivo utilizando los pasos enumerados a continuación. El nombre de la cuenta de NEAR y la parte de derivación se utilizan para derivar una dirección única para los usuarios en la blockchain objetivo.
Creando la Transacción 
Después de derivar la dirección, el usuario construye la transacción que debe ser firmada. Los pasos para crear la transacción que debe ser firmada difieren dependiendo de la blockchain objetivo.
Solicitando la FirmaUna vez que la transacción está creada y lista para ser firmada, se puede hacer una solicitud de firma llamando a "sign" en el contrato inteligente de MPC. Este método requiere dos parámetros clave: la transacción debe ser firmada para el blockchain objetivo y la ruta de derivación para la cuenta que se está utilizando para firmar la transacción.
Reconstruyendo la Firma 
El contrato de MPC no devuelve la firma de la transacción en sí. En su lugar, devuelve los elementos necesarios para reconstruir la firma, lo que permite al contrato generalizar el proceso de firma para múltiples blockchains.
Transmitiendo la Firma 
Una vez que la firma ha sido reconstruida, se puede transmitir a la red correspondiente. Este método también varía dependiendo del blockchain objetivo.
Casos de Uso de Firmas de Cadena 
Las Firmas de Cadena tienen varios casos de uso potenciales. Veamos algunos de ellos.
DeFi en Cadenas sin Contratos Inteligentes 
Las Firmas de Cadena pueden habilitar DeFi en cadenas sin contratos inteligentes, incluyendo Ripple, Doge e incluso Bitcoin. Hasta ahora, estas cadenas solo admiten transferencias en la red. Los contratos inteligentes de NEAR pueden actuar como contratos de garantía, y los desarrolladores también pueden construir intercambios o protocolos de préstamos capaces de admitir cualquier activo en cualquier cadena.
Aplicaciones Agnósticas de Cadena 
Las Firmas de Cadena pueden firmar transacciones para múltiples blockchains, permitiendo a los desarrolladores admitir diferentes cadenas con un solo contrato inteligente.
Abstracción de Cuenta Multicadena 
Las Firmas de Cadena pueden permitir a los usuarios controlar activos en múltiples cadenas con solo su cuenta de NEAR. También pueden utilizar funciones de abstracción de cuenta en diferentes cadenas, incluyendo contraseñas y rotación de claves.
DeFi sin Puentes entre Cadenas 
Las firmas entre cadenas eliminan la necesidad de puentes entre cadenas. En su lugar, las transacciones entre cadenas pueden realizarse utilizando protocolos de firma de MPC, facilitando una variedad de productos DeFi. Las Firmas de Cadena basadas en contratos inteligentes también pueden facilitar aplicaciones centradas en la privacidad y despliegues multicadena sin confianza.
Empezando con Firmas de Cadena 
Puedes familiarizarte con las Firmas de Cadena siguiendo los pasos enumerados a continuación.
 	Puedes revisar la documentación de NEAR para entender cómo las Firmas de Cadena pueden simplificar las interacciones entre blockchains.
 	También puedes ver algunos ejemplos de casos de uso de Firmas de Cadena. Estos incluyen Multichain DAO, Multichain NFT Minter y la distribución aérea de Bitcoin Runes.
 	Puedes acceder a información técnica detallada y fragmentos de código a través de la documentación de Firmas de Cadena en NEAR.
 	También puedes utilizar demos para enviar transacciones en Bitcoin, Ethereum, Doge y Ripple.
 	Por último, puedes interactuar con la comunidad de Firmas de Cadena uniéndote al canal de desarrolladores de Abstracción de Cadena en Telegram.

En Conclusión
Habiendo recientemente llegado a la mainnet, las Firmas de Cadena han surgido como una herramienta poderosa que permite a las cuentas de NEAR controlar cuentas en otros blockchains. Esto marca un paso crucial para permitir la propiedad de activos y datos en múltiples cadenas. Las Firmas de Cadena hacen que todo el proceso de propiedad entre cadenas sea en cadena. Todo lo que los usuarios deben hacer es llamar al contrato inteligente y esperar una respuesta.




	

	
	
		
			
				What Are The Use Cases Of Chain Signatures?
			
		

		
					

		
			
			
			
			Enabling DeFi on non-smart contract chains
		
			
			Multichain account abstraction
		
			
			Bridgeless cross-chain DeFi
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Los caminos de desviación permiten que una sola cuenta de NEAR controle múltiples cuentas en múltiples blockchains, mientras que el servicio MPC permite a los usuarios asegurarse de que solo ellos pueden solicitar firmas para esas cuentas. Las Firmas de Cadena también pueden impulsar la abstracción de cadenas, permitiendo que una sola capa de usuario interactúe con cualquier activo en cualquier cadena, simplificando la complejidad de Web3.

### NEARにおけるチェーン署名とは何ですか？

2024年8月8日、NEARは「Chain Signatures」のローンチを発表しました。これにより、スマートコントラクトを含むNEARアカウントは、サポートされているブロックチェーン全体でトランザクションに署名して実行することができます。NEARによると、Chain Signaturesは参入障壁を取り除き、流動性と利便性を促進し、チェーンに抽象化された未来を育成することができます。この記事では、Chain Signaturesを調査し、その動作原理を理解します。また、Chain Signatureを作成する方法についても簡単に説明します。クロスチェーン相互運用性の課題
最近の数か月でブリッジの取引量が急増しており、クロスチェーン相互運用性とトランザクションへの需要が高まっていることが示されています。ただし、クロスチェーン相互運用性には課題があります。主な問題は、クロスチェーンブリッジが大きな攻撃面を持つため、悪用されやすいことです。2番目の問題は、チェーンのサポートが不足していることです。ほとんどのブリッジは、EVM以外のチェーンをサポートしていません。3番目の主要な問題は、一貫性のない煩雑なUXです。各ブリッジには異なるデザインがあり、ユーザーはそれを使用する前に学習曲線を経る必要があります。

ユーザーが異なるトークンを取得してガス料金を支払う必要がある場合もあります。一部のブリッジは特定のアセットのラップバージョンを使用しています。ラップバージョンは、元のチェーン上のネイティブアセットとは異なります。ユーザーが必要とするアセットでさえない場合があり、ブリッジされるとサポートされていないアセットや流動性の低いアセットになる可能性があります。




	

	
	
		
			
				What Are The Challenges Facing Cross-Chain Interoperability?
			
		

		
					

		
			
			
			
			The threat of exploits
		
			
			A lack of chain support
		
			
			An inconsistent and cumbersome UX
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Chain Signaturesとは？
NEAR上のChain Signaturesは、すべてのNEARアカウント（スマートコントラクトを含む）が複数のサポートされているブロックチェーン全体でトランザクションに署名して実行できるようにします。これらはMulti-Party Computations（MPC）を活用し、分散ネットワークのノードオペレーターが共同署名を作成することで、NEARアカウントやスマートコントラクトが外部ブロックチェーンを制御できるようにします。MPCは、複数の当事者がデータを互いに公開せずに計算を実行できるプライバシー保護の調整プロトコルです。Chain Signaturesは、単一のNEARアカウントがさまざまなアセット、データ、およびクロスチェーンアカウントの所有権を持つことで、次のレベルのブロックチェーン相互運用性を実現します。

By NEAR Docs
Chain Signaturesの動作原理は？
NEAR上のChain Signaturesは、3つの主要要素の相互作用によって機能します：

 	導出パス
 	マルチチェーンスマートコントラクト
 	マルチパーティコンピュテーションサービス

それぞれを詳しく見てみましょう。
導出パスチェーン署名は、Additive Key Derivationと呼ばれるメカニズムを使用して、他のブロックチェーンに基づいてNEARアカウントをリンクすることを可能にします。これは、単一のマスターキーからサブキーを導出するために使用される単純なメカニズムです。サブキーは導出パスを使用して生成されます。では、導出パスとは何でしょうか？導出パスは、NEARアカウントと一緒に使用されると、ターゲットブロックチェーン上のユニークなアドレスを導出する単純な文字列です。

マルチチェーンスマートコントラクト
その名前が示すように、マルチチェーンスマートコントラクトは、他のブロックチェーン上のトランザクションに署名を要求します。これらのコントラクトは、署名を要求する際に2つの主要なパラメータを考慮するsignメソッドを使用します。

 	ターゲットブロックチェーンで署名する必要があるペイロードまたはトランザクション。
 	トランザクションに署名するためにユーザーが使用したいアカウントを識別するパス。

署名の要求が行われると、signメソッドは「実行待ち」となり、MPC署名サービスがトランザクションに署名します。準備ができたら、コントラクトは計算を再開し、署名をユーザーに返します。その署名は、その後、実行される可能性のあるターゲットブロックチェーンに送信できます。

マルチパーティコンピュテーションサービス
この記事の前半で、マルチパーティコンピュテーション（MPC）について簡単に説明しました。MPCは、独立した当事者が互いに何も明かさずにプライベート情報で共有計算を行うことを可能にします。ブロックチェーンは、このシステムを使用して、ユーザーの秘密鍵を明かさずにトランザクションに署名することができます。NEARのマルチパーティコンピュテーションサービスは、独立したノードで構成されています。これらのノードは自分自身でトランザクションに署名することはできません。代わりに、署名シェアを作成します。これらの署名シェアは、複数のラウンドを通じて集約され、共同でトランザクションに署名します。

MPCサービスが署名リクエストを検出すると、以下の手順を実行します。

 	パスによって識別されたアカウントを使用して、ノードにペイロードの署名を共同で作成するよう要求します。
 	準備ができたら、署名を格納するためにv1.signerコントラクトを呼び出します。


チェーン署名の作成
チェーン署名の作成には、以下の5つのステップが必要です：

 	外部アドレスの導出
 	トランザクションの作成
 	署名の要求
 	署名の再構築
 	署名されたトランザクションの中継


外部アドレスの導出
前述のように、チェーン署名は、以下の手順を使用して、ターゲットブロックチェーン上のアカウントを表すために導出パスを使用します。NEARアカウントの名前と導出部分を使用して、ユーザーのためにターゲットブロックチェーン上のユニークなアドレスを導出します。

トランザクションの作成
アドレスを導出した後、ユーザーは署名する必要のあるトランザクションを作成します。署名する必要のあるトランザクションを作成する手順は、ターゲットブロックチェーンによって異なります。

署名の要求トランザクションが作成され、署名する準備が整ったら、MPCスマートコントラクトで「sign」を呼び出すことで署名リクエストを行うことができます。この方法には2つの主要なパラメータが必要です：対象のブロックチェーン用にトランザクションに署名する必要があり、トランザクションに署名するために使用されるアカウントの導出パスが必要です。
署名の再構築
MPC契約はトランザクションの署名自体を返しません。代わりに、署名を再構築するために必要な要素を返し、契約が複数のブロックチェーンに対して署名プロセスを一般化できるようにします。
署名の中継
署名が再構築されたら、それを対応するネットワークに中継することができます。この方法も、対象のブロックチェーンによって異なります。
チェーン署名のユースケース
チェーン署名にはいくつかの潜在的なユースケースがあります。いくつか見てみましょう。
非スマートコントラクトチェーン上のDeFi
チェーン署名を使用すると、Ripple、Doge、さらにはBitcoinなどの非スマートコントラクトチェーン上でDeFiを可能にすることができます。これらのチェーンはこれまでネットワーク上での送金のみをサポートしていました。NEARスマートコントラクトはエスクローコントラクトとして機能し、開発者は任意のチェーン上の任意のアセットをサポートできるスワップや貸出プロトコルを構築することもできます。
チェーンに対応したアプリケーション
チェーン署名は複数のブロックチェーンのトランザクションに署名することができ、開発者は1つのスマートコントラクトで異なるチェーンをサポートすることができます。
マルチチェーンアカウント抽象化
チェーン署名を使用すると、ユーザーはNEARアカウントだけで複数のチェーン上の資産を制御することができます。また、異なるチェーン上でのアカウント抽象化機能、パスキー、キーローテーションなども利用できます。
ブリッジレスクロスチェーンDeFi
クロスチェーン署名はクロスチェーンブリッジの必要性を排除します。代わりに、MPC署名プロトコルを使用してクロスチェーントランザクションを行うことができ、さまざまなDeFi製品を容易にします。スマートコントラクトベースのチェーン署名は、プライバシーに焦点を当てたアプリや信頼できるマルチチェーン展開も可能にします。
チェーン署名の始め方
以下の手順に従って、チェーン署名について理解を深めることができます。
    	ブロックチェーン間のやり取りを簡素化するChain Signaturesの仕組みを理解するために、NEARのドキュメントを参照できます。
    	Chain Signatureの使用例をいくつか見ることもできます。これにはMultichain DAO、Multichain NFT Minter、およびBitcoin Runesのエアドロップが含まれます。
    	NEARのChain Signaturesのドキュメントを通じて、詳細な技術情報やコードスニペットにアクセスできます。
    	デモを使用して、Bitcoin、Ethereum、Doge、およびRippleでトランザクションを送信することもできます。
    	最後に、Chain Signaturesコミュニティに参加するために、TelegramのChain Abstraction開発者チャンネルに参加することができます。

最後に
最近メインネットに登場したChain Signaturesは、NEARアカウントが他のブロックチェーン上のアカウントを制御する強力なツールとして登場しました。これは、複数のチェーン上で資産やデータの所有権を可能にする重要な一歩です。Chain Signaturesは、クロスチェーンの所有権を完全にオンチェーン化します。ユーザーはスマートコントラクトを呼び出して応答を待つだけです。




	

	
	
		
			
				What Are The Use Cases Of Chain Signatures?
			
		

		
					

		
			
			
			
			Enabling DeFi on non-smart contract chains
		
			
			Multichain account abstraction
		
			
			Bridgeless cross-chain DeFi
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






逸脱パスを使用すると、単一のNEARアカウントが複数のブロックチェーン上の複数のアカウントを制御できます。MPCサービスを使用すると、ユーザーはそれらのアカウントの署名をリクエストできるのは自分だけであることを確認できます。Chain Signaturesはまた、チェーンの抽象化を推進し、単一のユーザーレイヤーが任意のチェーン上の任意のアセットとやり取りできるようにすることで、Web3の複雑さを簡素化できます。

### What Are Chain Signatures On NEAR?

Updated on 30/01/2025
On 8 August 2024, NEAR announced the launch of “Chain Signatures,” which allow NEAR accounts, including smart contracts, to sign and execute transactions across supported blockchains. According to NEAR, Chain Signatures can remove barriers to entry, promote liquidity and greater usability, and foster a chain-abstracted future. This article will examine Chain Signatures and understand how they work. It will also briefly discuss how to create a Chain Signature.
The Challenges Of Cross-Chain Interoperability 
Bridge volumes have registered a sharp uptick in recent months, signaling a growing demand for cross-chain interoperability and transactions. However, cross-chain interoperability comes with challenges, primarily because cross-chain bridges are vulnerable to exploits thanks to a large attack surface. The second problem is a lack of chain support. Most bridges do not support non-EVM chains. The third major issue is an inconsistent and cumbersome UX. Each bridge has a different design, meaning users must go through a learning curve before using it.

Another significant problem occurs when users must acquire different tokens to pay gas fees. Some bridges also use a wrapped version of a particular asset. The wrapped version is different from the native asset on the original chain. It may not even be the asset the user needs, and once bridged, they may end up with an unsupported asset or one with low liquidity.




	

	
	
		
			
				What Are The Challenges Facing Cross-Chain Interoperability?
			
		

		
					

		
			
			
			
			The threat of exploits
		
			
			A lack of chain support
		
			
			An inconsistent and cumbersome UX
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What Are Chain Signatures? 
Chain Signatures on NEAR enable all NEAR accounts, including smart contracts, to sign and execute transactions across multiple supported blockchains. They leverage Multi-Party Computations (MPC), and a distributed network of node operators to create joint signatures, allowing NEAR accounts and smart contracts to control external blockchains. MPC is a privacy-preserving coordination protocol that allows multiple parties to perform computations without revealing the data to one another. Chain Signatures unlock the next level of blockchain interoperability by giving a single NEAR account ownership of a diverse range of assets, data, and cross-chain accounts.

By NEAR Docs
How Do Chain Signatures Work?
Chain Signatures on NEAR function due to interactions between three key elements:

 	Derivation paths
 	Multichain smart contracts
 	Multi-party Computational Service

Let’s take a closer look at each.
Derivation Paths 
Chain Signatures allow one NEAR account to be linked to addresses based on other blockchains using a mechanism called Additive Key Derivation. This is a simple mechanism used to derive subkeys from a single master key. The subkeys are generated using Derivation Paths. Now, what is a Derivation Path? A Derivation Path is a simple string that derives a unique address on the target blockchain when used with a NEAR account.
Multichain Smart Contracts 
As the name suggests, a multichain smart contract requests signatures for transactions on other blockchains. These contracts use a sign method that considers two primary parameters when requesting signatures.

 	The payload or transaction that has to be signed for the target blockchain.
 	The path that identifies the account that a user wants to use to sign the transaction.

When a request for signatures is made, the sign method yields “execution waiting”, and the MPC signing service signs the transaction. Once ready, the contract resumes computation and returns the signature to the user. The signature can then be sent to the target blockchain, where it can be executed.
Multi-Party Computation Service 
Earlier in the article, we briefly discussed Multi-Party Computation (MPC). MPC enables independent parties to perform shared computations on private information without revealing anything to one another. Blockchains can use this system to sign transactions on behalf of users without disclosing private keys. The Multi-Party Computation Service on NEAR consists of independent nodes. These nodes cannot sign transactions by themselves. Instead they create signature-shares. These signature-shares are aggregated through multiple rounds to jointly sign transactions.

When the MPC service detects a signature request, it executes the following steps.

 	Requests the nodes to jointly create a signature for the payload using the account identified by the path.
 	Call the v1.signer contract to store the signature once it is ready.




	

	
	
		
			
				What Key Elements Facilitate The Functioning Of Chain Signatures?
			
		

		
					

		
			
			
			
			Multichain smart contracts
		
			
			Multi-party Computational Service
		
			
			Derivation Paths
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Creating A Chain Signature 
Creating a Chain Signature involves five steps:

 	Deriving the foreign address
 	Creating a transaction
 	Requesting a signature
 	Reconstructing the signature
 	Relaying the signed transaction

Deriving The Foreign Address 
As mentioned, Chain Signatures use derivation paths to represent an account or accounts on the target blockchain using the steps listed below. The NEAR account’s name and derivation part are used to derive a unique address for users on the target blockchain.
Creating The Transaction 
After deriving the address, the user constructs the transaction that must be signed. The steps to create the transaction that has to be signed differ depending on the target blockchain.
Requesting The Signature
Once the transaction is created and ready to be signed, a signature request can be made by calling “sign” on the MPC smart contract. This method requires two key parameters: the transaction must be signed for the target blockchain and the derivation path for the account being used to sign the transaction.
Reconstructing The Signature 
The MPC contract does not return the transaction signature itself. Instead, it returns the elements needed to reconstruct the signature, allowing the contract to generalize the signing process for multiple blockchains.
Relaying The Signature 
Once the signature has been reconstructed, it can be relayed to the corresponding network. This method also varies depending on the target blockchain.
Use Cases Of Chain Signatures 
Chain Signatures have several potential use cases. Let’s look at some of them.
DeFi On Non-Smart Contract Chains 
Chain Signatures can enable DeFi on non-smart contract chains, including Ripple, Doge, and even Bitcoin. So far, these chains only support transfers on the network. NEAR smart contracts can act as escrow contracts, and developers can also build swaps or lending protocols capable of supporting any asset on any chain.
Chain Agnostic Applications 
Chain Signatures can sign transactions for multiple blockchains, allowing developers to support different chains with one smart contract.
Multichain Account Abstraction 
Chain Signatures can enable users to control assets on multiple chains with just their NEAR account. They can also utilize account abstraction features on different chains, including passkeys and key rotation.
Bridgeless Cross-Chain DeFi 
Cross-chain signatures eliminate the need for cross-chain bridges. Instead, cross-chain transactions can be conducted using MPC signature protocols, facilitating a range of DeFi products. Smart contract-based Chain Signatures can also facilitate privacy-focused apps and trustless multichain deployments.
Getting Started With Chain Signatures 
You can familiarize yourself with Chain Signatures by following the steps listed below.

 	You can review NEAR documentation to understand how Chain Signatures can simplify interactions between blockchains.
 	You can also look at some examples of Chain Signature use cases. These include Multichain DAO, Multichain NFT Minter, and the Bitcoin Runes airdrop.
 	You can access detailed technical information and code snippets through the Chain Signatures documentation on NEAR.
 	You can also use demos to send transactions on Bitcoin, Ethereum, Doge, and Ripple.
 	Lastly, you can engage with the Chain Signatures community by joining the Chain Abstraction developers’ channel on Telegram.

In Closing 
Having recently made their way to the mainnet, Chain Signatures have emerged as a powerful tool allowing NEAR accounts to control accounts on other blockchains. This marks a crucial step in enabling ownership of assets and data across multiple chains. Chain Signatures make the entire process of cross-chain ownership on-chain. All users must do is call the smart contract and await a response.




	

	
	
		
			
				What Are The Use Cases Of Chain Signatures?
			
		

		
					

		
			
			
			
			Enabling DeFi on non-smart contract chains
		
			
			Multichain account abstraction
		
			
			Bridgeless cross-chain DeFi
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Deviation paths allow a single NEAR account to control multiple accounts on multiple blockchains, while MPC service allows users to ensure only they can request signatures for those accounts. Chain Signatures can also drive chain abstraction, allowing a single user layer to interact with any asset on any chain, simplifying the complexity of Web3.
What’s Next? [Update January 29, 2025]
Since its launch, the NEAR engineering team has been focused on enhancing the performance and security of this feature. A significant update is scheduled for February 2025, promising a 300-fold increase in transaction processing capacity and a 50% reduction in the time it takes to finalize transactions. These improvements aim to provide users with faster and more efficient cross-chain transactions.

Looking ahead to the first half of 2025, NEAR plans to implement several key upgrades to Chain Signatures. One major enhancement involves integrating Trusted Execution Environments (TEE) into the network. TEEs are secure areas within a device's processor that ensure sensitive data is processed in a protected environment, preventing unauthorized access. This integration will bolster the security of Chain Signatures by safeguarding cryptographic keys during transaction signing. Additionally, NEAR is expanding support to include EdDSA, a signature scheme used by popular blockchains like Solana and TON, thereby broadening the compatibility of Chain Signatures with more blockchain networks.

Beyond these developments, NEAR is exploring advanced cryptographic research to further enhance the efficiency and scalability of Chain Signatures. The goal is to expand the network to 30 nodes without compromising performance, which will improve decentralization and resistance to censorship. There are also plans to support additional signature schemes, such as Secp256r1, commonly used for mobile device passkeys. These initiatives reflect NEAR's commitment to advancing blockchain technology and providing users with secure, efficient, and versatile tools for cross-chain interactions.

### Would you use AI for learning?

Would you use AI for learning? 
            
                281 votes by,
                503 nLEARNs spent
            
            
            
                                    
                        
                            Yes                            
                                (270 votes,
                                486 nLEARNs)
                            
                        
                        
                             
                            96%
                        
                    
                                    
                        
                            No                            
                                (11 votes,
                                17 nLEARNs)
                            
                        
                        
                             
                            4%

### NEAR Protocol 和 TON

NEAR Protocol和The Open Network（TON）
NEAR和TON（The Open Network）是加密生态系统中最有前途的两个项目之一。NEAR为用户提供了内置功能，包括帐户抽象和命名帐户。这个dApp（去中心化应用）平台专注于用户和开发者友好性，由NEAR Collective构建。另一方面，TON是由Telegram于2018年创建的去中心化的第一层区块链。然而，它很快被放弃了。

本文将更详细地审查每个项目，包括它的工作原理、生态系统、用途等。
NEAR是什么？
NEAR是一个智能合约能力的公共权益证明区块链，为开发人员提供了一个构建去中心化应用程序（dApps）的平台。由NEAR Collective构建，它主要与以太坊和其他智能合约启用的区块链（如EOS和Polkadot）竞争。该协议旨在改进以太坊在速度、可扩展性和成本方面的缺点。

NEAR比以太坊更快、更便宜，每秒处理高达100,000笔交易。该协议的惊人可扩展性有可能彻底改变智能合约和去中心化应用程序的世界。NEAR Protocol设计和运行方式的关键是一种称为分片的概念。分片将网络基础设施分割成较小的段，使节点只处理网络总交易量的一部分。分片可以创造一种更有效的检索网络数据的方式，并帮助扩展平台。

NEAR可以与亚马逊网络服务（AWS）等数据存储系统进行比较，这些系统充当应用程序构建的基础层。然而，关键区别在于NEAR是去中心化的，由分布式计算机（节点）网络维护。该协议的原生代币NEAR用于支付交易费用和存储。代币持有者还可以抵押他们的代币，承担验证者的角色，帮助网络达成共识。
NEAR Collective
NEAR Collective是NEAR Protocol背后的实体，由个人组织和其他贡献者组成，他们不断努力改进它。该组织致力于项目，编写其初始代码，并帮助在NEAR上实施。NEAR Collective还协助开发和治理活动。虽然NEAR Collective开发了NEAR，但该协议完全去中心化。它独立运作，无法关闭或操纵。
NEAR Protocol如何工作？
NEAR Protocol是一个权益证明区块链。权益证明机制要求代币持有者抵押一定数量的代币才能有资格验证区块。该协议运作的关键是其共识算法Nightshade。
NightshadeNightshade 是 NEAR Protocol 的分片解决方案，它允许 NEAR 将计算工作负载分布到可管理的块中。由于 Nightshade，每个参与节点只需存储平台数据的一个小子集。然后节点可以处理这些信息“块”并将它们添加到主链中。

Nightshade 的主要好处之一是它显著减少了潜在的故障点数量。这是因为每个节点只负责少量数据并且仅维护链的一小部分，大大提高了效率。

验证人员在 NEAR 上也发挥着至关重要的作用，负责在协议内维护共识。他们必须始终保持其服务器在线并更新其系统。验证人员在每个新纪元中确定，并根据其股份选举产生。已经被选举的验证人员可以通过重新抵押其代币和累积奖励来重新当选。同时，任何潜在的验证人员必须将其股份保持在预定水平以上。

NEAR 账户是什么？
正如前面提到的，NEAR 支持可读的地址。NEAR 有两种类型的账户：隐式地址和命名地址。

隐式地址
隐式地址账户由一个对应于公钥/私钥对的 64 个字符地址表示。要使用这种类型的账户，用户必须用他们的 NEAR 代币为其充值或支付交易的燃气费用。

命名地址
NEAR 还允许用户注册命名账户，这些账户更容易共享和记忆。命名账户还可以创建子账户，有效地充当域。

TON 是什么？
TON（Toncoin）最初由 Telegram 在 2018 年构建。在创建时，Telegram 为其新的区块链筹集了 17 亿美元的私人资金，旨在成为以太坊的竞争对手。然而，在美国证券交易委员会介入并起诉称其本地代币 $TON 是一种证券后，Telegram 放弃了该项目。Telegram 放弃项目后，它被与 Telegram 无关的开发人员接手，接管了 ton.org 域名和 Toncoin 代码存储库。Toncoin 随后推出了 TON 区块链和 TON 代币。

TON 是为金融应用和 NFT 创建的去中心化 Layer1 智能合约网络。到目前为止，已经铸造了一百万个 NFT。与 NEAR 一样，TON 是一个权益证明区块链，提供了一个非常适合金融交易的高度可扩展的网络。它还促进了用户在不可变的金融基础设施上的互动。TON 区块链以其可扩展性和高性能脱颖而出。当它每秒处理 55,000 笔交易时，它创造了一种记录，这得益于其独特的多级架构，将主链与多个其他单词链结合在一起。

TON 如何运作？
TON 的运作有四个关键方面：权益证明共识、分片、TON 虚拟机以及其本地代币 Toncoin。权益证明共识
共识是网络节点就网络的当前和有效状态达成一致的方式。TON使用高效的权益证明共识机制。验证者可以抵押他们的代币，并因为他们对网络安全的贡献而获得奖励。截至撰写本文时，TON有329个验证者和511,880,772美元的TON抵押。验证者为他们验证的每个区块收到TON代币。TON的区块权益证明确保即使所有验证者无法参与共识，网络仍然可以运行。
分片
分片有助于增加区块链的可扩展性，NEAR也在使用。分片将TON分成称为分片的较小组件。每个分片被分配了特定的角色，帮助区块链维护全局状态。维护全局状态有助于消除网络节点处理每个交易的需求，带来更高的效率。
TON虚拟机（TVM）
TON虚拟机的作用类似于以太坊虚拟机，计算合同应用程序的命令，并在每次执行后更改网络状态。通过TVM，开发人员可以创建可以自动化各种流程的应用程序，例如资产铸造、资产转移和在网络上签署消息。
TON币
TON币（$TON）是TON的本地加密货币，在TON生态系统中有多种用途。该代币用于支付交易费用、抵押和协议治理。
交易费用
$TON代币用于在TON网络上支付交易费用。用户必须使用代币来处理交易或支付燃气费。该代币还用于支付TON网络存储和基于区块链的域名。
治理
$TON代币在治理中扮演关键角色。$TON代币持有者可以对提案进行投票，并对网络的未来发表意见。
抵押
$TON代币持有者还可以抵押他们的代币，充当验证者，帮助验证交易并保护网络。用户可以直接在网络上或通过主要加密货币交易所抵押他们的代币。




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR和TON的未来计划
NEAR - 用户拥有的人工智能
NEAR正在推进将人工智能研究和应用集成到其区块链生态系统中的用户拥有的人工智能。NEAR.AI研发实验室旨在开发能够根据用户意图创建端到端Web3应用程序的人工智能。通过利用其庞大的用户群、开发者生态系统和财务资源，NEAR致力于吸引顶尖的AI。利用人才，构建赋予用户和社区权力的去中心化人工智能基础设施。
TON - 进一步的Telegram集成
TONCoin在Telegram内的实用性扩展无疑是最令人兴奋的事情。根据Telegram创始人Pavel Durov的说法，用户将能够用TON支付广告费用并给频道管理员小费。很快，贴纸可以作为NFT购买和出售，艺术家将获得95%的收益。用户还可以分享TON，使用加密钱包登录账户，并注册和出售账户名称。
总结
NEAR和TON是革新性平台，彻底改变了dApp和智能合约领域。NEAR专注于速度、可扩展性和用户开发者友好性，已成为以太坊的值得选择的替代品。与此同时，TON正在迅速吸引投资者和开发者。其Telegram集成还使网络可以接触到超过7亿潜在用户。
立即投票！

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Protocole NEAR et TON

NEAR Protocol Et Le Réseau Ouvert (TON)
NEAR et TON (The Open Network) sont deux des projets les plus prometteurs de l'écosystème crypto. NEAR offre aux utilisateurs des fonctionnalités intégrées telles que l'abstraction de compte et les comptes nommés. La plateforme dApp (application décentralisée) axée sur la convivialité pour les utilisateurs et les développeurs a été construite par le NEAR Collective. D'autre part, TON est une blockchain décentralisée de couche 1 créée par Telegram en 2018. Cependant, elle a été abandonnée peu de temps après.

Cet article examinera chaque projet plus en détail, y compris son fonctionnement, son écosystème, ses utilisations, et plus encore.
Qu'est-ce que NEAR?
NEAR est une blockchain publique Proof-of-Stake capable de contrats intelligents qui fournit aux développeurs une plateforme pour construire des applications décentralisées (dApps). Construit par le NEAR Collective, il rivalise principalement avec Ethereum et d'autres blockchains activées pour les contrats intelligents comme EOS et Polkadot. Le protocole vise à améliorer les lacunes d'Ethereum en termes de vitesse, de scalabilité et de coût.

NEAR est plus rapide et moins cher qu'Ethereum, traitant jusqu'à 100 000 transactions par seconde. La scalabilité incroyable du protocole a le potentiel de révolutionner le monde des contrats intelligents et des applications décentralisées. La clé de la conception et du fonctionnement du protocole NEAR est un concept appelé sharding. Le sharding divise l'infrastructure d'un réseau en segments plus petits, permettant aux nœuds de gérer seulement une fraction des transactions totales du réseau. Le sharding peut créer un moyen plus efficace de récupérer les données du réseau et aider à mettre en place la plateforme.

NEAR peut être comparé à des systèmes de stockage de données tels qu'Amazon Web Services (AWS), qui agissent comme la couche de base sur laquelle les applications sont construites. Cependant, la différence critique est que NEAR est décentralisé et maintenu par un réseau distribué d'ordinateurs (nœuds). Le jeton natif du protocole, NEAR, est utilisé pour payer les frais de transaction et de stockage. Les détenteurs de jetons peuvent également miser leurs jetons, assumant le rôle de validateurs et aidant le réseau à atteindre un consensus.
Le NEAR Collective
Le NEAR Collective est l'entité derrière le NEAR Protocol et se compose d'organisations individuelles et d'autres contributeurs qui travaillent constamment à son amélioration. L'organisation travaille sur des projets, écrit leur code initial et aide à leur mise en œuvre sur NEAR. Le NEAR Collective participe également aux activités de développement et de gouvernance. Bien que le NEAR Collective ait développé NEAR, le protocole est entièrement décentralisé. Il fonctionne de manière indépendante et ne peut pas être arrêté ou manipulé.
Comment fonctionne le protocole NEAR?
Le protocole NEAR est une blockchain Proof-of-Stake. Le mécanisme Proof-of-Stake exige que les détenteurs de jetons misent un certain nombre de jetons pour être éligibles à valider des blocs. La clé du fonctionnement du protocole est son algorithme de consensus - Nightshade.
NightshadeNightshade est la solution de sharding du protocole NEAR, qui permet à NEAR de répartir la charge de calcul en morceaux gérables. Grâce à Nightshade, chaque nœud participant ne doit stocker qu'un petit sous-ensemble des données de la plateforme. Les nœuds peuvent ensuite traiter ces 'morceaux' d'informations et les ajouter à la chaîne principale.

Un des principaux avantages de Nightshade est qu'il réduit considérablement le nombre de points de défaillance potentiels. Cela est dû au fait que chaque nœud est responsable d'une petite quantité de données et ne maintient qu'une petite partie de la chaîne, ce qui augmente considérablement l'efficacité.

Les validateurs jouent également un rôle crucial sur NEAR et sont responsables de maintenir le consensus au sein du protocole. Ils doivent garder leurs serveurs en ligne en permanence et mettre à jour leurs systèmes. Les validateurs sont déterminés à chaque nouvel époque et sont élus en fonction de leur mise. Les validateurs déjà élus peuvent être réélus en remisant leurs jetons et leurs récompenses accumulées. Pendant ce temps, tout validateur potentiel doit avoir sa mise au-dessus d'un niveau prédéterminé.

Les comptes NEAR prennent en charge les adresses lisibles par l'homme. Il existe deux types de comptes NEAR : les adresses implicites et les adresses nommées.

Les comptes d'adresses implicites sont désignés par une adresse de 64 caractères correspondant à une paire de clés publique/privée. Pour utiliser ce type de compte, les utilisateurs doivent le financer avec leurs jetons NEAR ou payer les frais de gaz pour la transaction.

NEAR permet également aux utilisateurs d'enregistrer des comptes nommés qui sont beaucoup plus simples à partager et à retenir. Les comptes nommés peuvent également créer des sous-comptes, agissant ainsi comme des domaines.

TON (Toncoin) a été initialement créé par Telegram en 2018. Au moment de sa création, Telegram a levé 1,7 milliard de dollars de financement privé pour sa nouvelle blockchain, destinée à concurrencer Ethereum. Cependant, il a abandonné le projet après l'intervention de la Securities and Exchange Commission des États-Unis, qui a poursuivi en justice, alléguant que $TON, son jeton natif, était une sécurité. Après l'abandon du projet par Telegram, il a été repris par des développeurs non affiliés à Telegram, reprenant le nom de domaine ton.org et le référentiel de code Toncoin. Toncoin a ensuite lancé la blockchain TON et le jeton TON.

TON est un réseau de contrats intelligents Layer1 décentralisé créé pour les applications financières et les NFT. Jusqu'à présent, plus d'un million de NFT ont été créés. Comme NEAR, TON est une blockchain de preuve d'enjeu qui offre un réseau hautement évolutif idéal pour les transactions financières. Il facilite également les interactions entre les utilisateurs sur une infrastructure financière immuable. La blockchain TON se distingue par sa scalabilité et ses performances élevées. Elle a établi un record en traitant 55 000 transactions par seconde, rendu possible par son architecture multi-niveaux unique, combinant la chaîne principale avec plusieurs autres chaînes de mots.Consensus Proof-of-Stake 
Le consensus est la manière dont les nœuds du réseau s'accordent sur l'état actuel et valide du réseau. TON utilise le mécanisme de consensus Proof-of-Stake économe en énergie. Les validateurs peuvent miser leurs jetons et gagner des récompenses pour leur contribution à la sécurisation du réseau. Au moment de la rédaction, TON compte 329 validateurs et 511 880 772 $TON misés. Les validateurs reçoivent des jetons $TON pour chaque bloc qu'ils valident. Le Proof-of-Stake par bloc de TON garantit que le réseau continue de fonctionner même si tous les validateurs ne peuvent pas participer au consensus.
Sharding 
Le sharding aide à augmenter la scalabilité de la blockchain et est également utilisé par NEAR. Le sharding divise TON en composants plus petits appelés shards. Chaque shard se voit attribuer un rôle spécifique, aidant la blockchain à maintenir un état global. Le maintien d'un état global aide à éliminer le besoin pour les nœuds du réseau de traiter chaque transaction, apportant ainsi une plus grande efficacité.
La Machine Virtuelle TON (TVM)
La Machine Virtuelle TON joue un rôle similaire à celui de la Machine Virtuelle Ethereum, en calculant les commandes des applications de contrat et en modifiant l'état du réseau après chaque exécution. Grâce à la TVM, les développeurs peuvent créer des applications qui peuvent automatiser divers processus, tels que la création d'actifs, les transferts d'actifs et la signature de messages sur le réseau.
Toncoin 
Toncoin ($TON) est la cryptomonnaie native de TON et a plusieurs utilisations dans l'écosystème TON. Le jeton est utilisé pour payer les frais de transaction, le staking et la gouvernance du protocole.
Frais de Transaction 
Le jeton $TON est utilisé pour payer les transactions sur le réseau TON. Les utilisateurs doivent utiliser les jetons pour traiter les transactions ou payer les frais de gaz. Le jeton est également utilisé pour payer le stockage sur le réseau TON et les noms de domaine basés sur la blockchain.
Gouvernance 
Le jeton $TON joue un rôle crucial dans la gouvernance. Les détenteurs de jetons $TON peuvent voter sur des propositions et avoir leur mot à dire dans l'avenir du réseau.
Staking 
Les détenteurs de jetons $TON peuvent également miser leurs jetons, agissant en tant que validateurs, aidant à valider les transactions et à sécuriser le réseau. Les utilisateurs peuvent miser leurs jetons directement sur le réseau ou via des grandes plateformes d'échange de cryptomonnaies.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plans Futurs Pour NEAR et TON
NEAR - Intelligence Artificielle Possédée par l'Utilisateur
NEAR fait progresser l'Intelligence Artificielle Possédée par l'Utilisateur en intégrant la recherche et les applications en IA dans son écosystème blockchain. Le laboratoire de R&D NEAR.AI vise à développer une IA qui crée des applications Web3 de bout en bout à partir des intentions des utilisateurs. En exploitant sa grande base d'utilisateurs, son écosystème de développeurs et ses ressources financières, NEAR cherche à attirer les meilleures intelligences artificielles.talent et construire une infrastructure d'IA décentralisée qui autonomise les utilisateurs et les communautés.
TON - Autres Intégrations Telegram
L'expansion de l'utilité de TON au sein de Telegram est sans aucun doute la chose la plus excitante à propos de TONCoin. Selon le Fondateur de Telegram Pavel Durov, les utilisateurs pourront payer pour la publicité en TON et donner des pourboires aux administrateurs de chaînes. Bientôt, les autocollants pourront être achetés et vendus en tant que NFT, les artistes recevant 95% des recettes. Les utilisateurs pourront également partager TON, se connecter à des comptes en utilisant des portefeuilles de crypto-monnaie, et enregistrer et vendre des noms de compte.
En Conclusion
NEAR et TON sont des plateformes innovantes qui ont révolutionné le paysage des dApp et des contrats intelligents. Avec son accent sur la vitesse, la scalabilité et la convivialité pour les utilisateurs et les développeurs, NEAR s'est imposé comme une alternative digne à Ethereum. Pendant ce temps, TON attire rapidement les investisseurs et les développeurs. Son intégration à Telegram donne également au réseau accès à plus de 700 millions d'utilisateurs potentiels.
Votez MAINTENANT!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### NEAR Protocol At TON

NEAR Protocol At Ang Open Network (TON)
NEAR at TON (The Open Network) ay dalawang sa pinakamapromising na proyekto sa crypto ecosystem. Nag-aalok ang NEAR ng mga built-in na feature para sa mga user tulad ng account abstraction at named accounts. Ang dApp (decentralized application) platform ay nakatuon sa user at developer-friendliness at binuo ng NEAR Collective. Sa kabilang banda, ang TON ay isang decentralized layer-1 blockchain na nilikha ng Telegram noong 2018. Gayunpaman, ito ay iniwanan agad.

Sa artikulong ito ay tatalakayin ang bawat proyekto ng mas detalyado, kasama ang kung paano ito gumagana, ang ecosystem nito, mga gamit, at iba pa.
Ano ang NEAR?
Ang NEAR ay isang smart contract-capable, public Proof-of-Stake blockchain na nagbibigay ng platform para sa mga developer upang magbuo ng decentralized applications (dApps). Binuo ng NEAR Collective, ito ay kadalasang nakikipagkumpitensya sa Ethereum at iba pang smart contract-enabled blockchains tulad ng EOS at Polkadot. Layunin ng protocol na mapabuti ang mga kakulangan ng Ethereum sa bilis, scalability, at cost.

Mas mabilis at mas mura ang NEAR kaysa sa Ethereum, na nakaproseso ng hanggang 100,000 transaksyon bawat segundo. Ang kahusayan ng protocol sa scalability ay may potensyal na baguhin ang mundo ng smart contracts at decentralized applications. Mahalaga sa disenyo at paraan ng paggana ng NEAR Protocol ang isang konsepto na tinatawag na sharding. Ang sharding ay pumuputol ng infrastructure ng network sa mas maliit na segmento, na nagbibigay daan sa mga nodes na mag-handle lamang ng isang bahagi ng kabuuang transaksyon ng network. Ang sharding ay maaaring lumikha ng mas epektibong paraan para makuha ang network data at makatulong sa pag-scale ng platform.

Maaaring ihambing ang NEAR sa mga data storage system tulad ng Amazon Web Services (AWS), na nagiging base layer kung saan binubuo ang mga applications. Gayunpaman, ang malaking pagkakaiba ay ang NEAR ay decentralized at inaalagaan ng isang distributed network ng mga computer (nodes). Ang native token ng protocol, NEAR, ay ginagamit upang bayaran ang transaction fees at storage. Ang mga may-ari ng token ay maaari ring mag-stake ng kanilang mga token, na nag-aassume ng papel ng validators at tumutulong sa network na makamit ang consensus.
Ang NEAR Collective
Ang NEAR Collective ang entidad sa likod ng NEAR Protocol at binubuo ng mga indibidwal na organisasyon at iba pang mga contributor na patuloy na nagtatrabaho upang mapabuti ito. Ang organisasyon ay gumagawa ng mga proyekto, sumusulat ng kanilang initial code at tumutulong sa kanilang implementasyon sa NEAR. Ang NEAR Collective ay tumutulong din sa development at governance activities. Bagaman ang NEAR Collective ang nag-develop ng NEAR, ang protocol ay ganap na decentralized. Ito ay umaandar ng independiyente at hindi maaaring isara o manipulahin.
Papaano gumagana ang NEAR Protocol?
Ang NEAR Protocol ay isang Proof-of-Stake blockchain. Ang Proof-of-Stake mechanism ay nangangailangan sa mga may-ari ng token na mag-stake ng tiyak na bilang ng mga token upang maging eligible sa pag-validate ng mga blocks. Mahalaga sa paggana ng protocol ang kanyang consensus algorithm - Nightshade.
NightshadeAng Nightshade ay ang solusyon sa sharding ng NEAR Protocol, na nagbibigay-daan sa NEAR na hatiin ang computational workload sa mga manageable chunks. Dahil sa Nightshade, ang bawat partisipante na node ay kailangang mag-imbak lamang ng isang maliit na subset ng data ng platform. Maaari ng mga nodes na proseso ang mga 'chunks' ng impormasyon at idagdag ang mga ito sa pangunahing chain.

Isa sa mga pangunahing benepisyo ng Nightshade ay ang malaking pagbawas sa bilang ng mga potensyal na puntos ng pagkabigo. Ito ay dahil bawat node ay responsable lamang sa isang maliit na halaga ng data at nag-iimbak lamang ng isang maliit na bahagi ng chain, na lubos na nagpapataas ng efficiency.

Ang mga Validators ay naglalaro rin ng isang mahalagang papel sa NEAR at responsable sa pagpapanatili ng consensus sa loob ng protocol. Kailangan nilang panatilihing online ang kanilang mga server sa lahat ng oras at i-update ang kanilang mga sistema. Ang mga Validators ay itinatakda sa bawat bagong epoch at inihalal batay sa kanilang stake. Ang mga Validators na nauna nang nahalal ay maaaring muling mahalal sa pamamagitan ng pag-re-stake ng kanilang mga tokens at mga natipon na rewards. Samantala, ang anumang potensyal na validator ay dapat magkaroon ng kanilang stake higit sa isang itinakdang antas.

Ano ang mga NEAR Accounts?
Tulad ng nabanggit kanina, suportado ng NEAR ang mga human-readable addresses. Mayroong dalawang uri ng NEAR accounts: Implicit addresses at Named addresses.

Implicit Address
Ang mga account ng implicit address ay tinutukoy ng isang 64-character address na katumbas ng isang public/private key pair. Upang magamit ang uri ng account na ito, kailangang pondohan ng mga users ito gamit ang kanilang NEAR tokens o bayaran ang gas fee para sa transaksyon.

Named Address
Pinapayagan din ng NEAR ang mga users na magparehistro ng mga named accounts na mas madali at mas madaling tandaan. Ang mga named accounts ay maaari ring lumikha ng sub-accounts, na epektibong nagiging mga domain.

Ano ang TON?
Ang TON (Toncoin) ay orihinal na itinayo ng Telegram noong 2018. Sa panahon ng paglikha nito, nagkaroon ng $1.7 bilyon na pribadong pondo ang Telegram para sa kanilang bagong blockchain, na inilaan bilang isang katunggali sa Ethereum. Gayunpaman, iniwan ng Telegram ang proyekto matapos pumasok ang United States Securities and Exchange Commission at magsampa ng kaso, na nag-aakusa na ang $TON, ang kanilang native token, ay isang security. Pagkatapos iwanan ng Telegram ang proyekto, ito ay kinuha ng mga developers na hindi konektado sa Telegram, na kumuha ng ton.org domain name at ang Toncoin code repository. Binuksan ng Toncoin ang TON blockchain at ang TON token.

Paano Gumagana ang TON?
Apat na aspeto ang mahalaga sa pag-andar ng TON: proof-of-stake consensus, Sharding, ang TON Virtual Machine, at ang kanilang native token, Toncoin.Proof-of-Stake Consensus 
Ang Consensus ay kung paano nagkakasundo ang mga nodes sa network sa kasalukuyang at wastong estado ng network. Gumagamit ang TON ng energy-efficient Proof-of-Stake consensus mechanism. Ang mga Validators ay maaaring mag-stake ng kanilang mga tokens at kumita ng mga rewards para sa kanilang kontribusyon sa pag-secure ng network. Sa panahon ng pagsusulat, mayroon ang TON ng 329 validators at 511,880,772 $TON na naka-stake. Natatanggap ng mga Validators ang $TON tokens para sa bawat block na kanilang na-validate. Pinapangalagaan ng Block-Proof-of-Stake ng TON na patuloy na gumana ang network kahit hindi lahat ng validators ay makalahok sa consensus.
Sharding 
Ang Sharding ay tumutulong sa pag-increase ng blockchain scalability at ginagamit din ng NEAR. Binabahagi ng Sharding ang TON sa mas maliit na components na tinatawag na shards. Bawat shard ay may itinakdang partikular na papel, na tumutulong sa blockchain na panatilihin ang global state. Ang pagpapanatili ng global state ay tumutulong sa pagtanggal ng pangangailangan para sa mga network nodes na proseso ang bawat transaksyon, na nagdudulot ng mas malaking efficiency.
Ang TON Virtual Machine (TVM)
Ang TON Virtual Machine ay may papel na katulad ng Ethereum Virtual Machine, na nagko-compute ng mga commands mula sa contract applications at nagbabago ng network state matapos ang bawat execution. Sa pamamagitan ng TVM, maaaring lumikha ng mga developers ng mga applications na maaaring mag-automate ng iba't ibang proseso, tulad ng asset minting, asset transfers, at pag-sign ng mga messages sa network.
Toncoin 
Ang Toncoin ($TON) ay ang native cryptocurrency ng TON at may maraming gamit sa TON ecosystem. Ginagamit ang token para sa pagbabayad ng transaction fees, staking, at protocol governance.
Transaction Fees 
Ginagamit ang token na $TON para sa pagbabayad ng mga transaksyon sa TON Network. Kailangang gamitin ng mga users ang mga tokens para proseso ng mga transaksyon o pagbabayad ng gas fees. Ginagamit din ang token para sa pagbabayad ng TON Network storage at blockchain-based domain names.
Governance 
Mahalagang papel ang ginagampanan ng token na $TON sa governance. Maaaring bumoto ang mga holders ng $TON token sa mga proposals at magkaroon ng boses sa kinabukasan ng network.
Staking 
Maaari ring mag-stake ng kanilang mga tokens ang mga holders ng $TON, na kumakatawan bilang validators, na tumutulong sa pag-validate ng mga transaksyon at pag-secure ng network. Maaaring mag-stake ng kanilang mga tokens ang mga users diretso sa network o sa pamamagitan ng major cryptocurrency exchanges.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Mga Plano Para sa NEAR at TON
NEAR - User-Owned AI
Ang NEAR ay nagpapalawak ng User-Owned AI sa pamamagitan ng pagsasama ng AI research at applications sa kanilang blockchain ecosystem. Layunin ng NEAR.AI R&D Lab na mag-develop ng AI na lumilikha ng end-to-end Web3 applications mula sa mga intents ng users. Sa pamamagitan ng kanilang malaking user base, developer ecosystem, at financial resources, layunin ng NEAR na ma-attract ang mga top AItalento at itayo ang isang desentralisadong AI infrastructure na nagbibigay ng kapangyarihan sa mga gumagamit at komunidad.
TON - Mga Karagdagang Integrasyon sa Telegram
Ang pagpapalawak ng utilidad ng TON sa loob ng Telegram ay walang dudang pinakakaabang-abang na bagay tungkol sa TONCoin. Ayon kay Telegram Founder Pavel Durov, ang mga gumagamit ay magagamit na magbayad para sa advertising sa TON at magbigay-tip sa mga administrator ng channel. Sa madaling salita, ang mga stickers ay maaaring mabili at maibenta bilang NFTs, kung saan ang mga artist ay makakatanggap ng 95% ng kita. Ang mga gumagamit din ay magagamit na magbahagi ng TON, mag-log in sa mga account gamit ang crypto wallets, at magparehistro at magbenta ng mga pangalan ng account.
Wakas
Ang NEAR at TON ay mga makabagong plataporma na nagbago ng dApp at smart contract landscape. Sa pagtuon nito sa bilis, kakayahan sa pag-scale, at kaibigang user-developer, ang NEAR ay lumitaw bilang isang karapat-dapat na alternatibo sa Ethereum. Samantala, ang TON ay mabilis na nakakaakit ng mga mamumuhunan at mga developer. Ang integrasyon nito sa Telegram ay nagbibigay din sa network ng access sa higit sa 700 milyong potensyal na mga gumagamit.
Bumoto NA!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Pakilala sa NEAR CLI

Ang NEAR CLI (Command Line Interface) ay isang makapangyarihang tool na dinisenyo upang tulungan ang mga developer at mga user na makipag-ugnayan sa NEAR Protocol nang direkta mula sa command line. Ito ay nagpapadali sa pagpapamahala ng mga account, pag-deploy ng mga kontrata, at iba pang mga gawain nang hindi na kailangan ng graphical interface.
Ano ang NEAR CLI?
Ang NEAR CLI ay isang command-line tool para sa pagtatrabaho sa NEAR blockchain. Ito ay nagbibigay daan sa mga user na:

 	Pamahalaan ang mga account
 	Mag-deploy at makipag-ugnayan sa mga smart contract
 	Magpadala at tumanggap ng mga token
 	Makita ang mga balanse ng account at kasaysayan ng transaksyon
 	Patakbuhin ang iba't ibang mga script upang otomatikong gawain

Bakit Gamitin ang NEAR CLI?
Kung ikaw ay isang developer o advanced user, ang NEAR CLI ay nagbibigay sa iyo ng direktang kontrol sa NEAR accounts at smart contracts. Ito ay magaang gamitin at madaling ma-integrate sa development workflows para sa mga layuning automation at scripting.
Pagsisimula

 	Instalasyon: Sa Windows machine, maaaring i-install ang NEAR CLI sa pamamagitan ng .msi installer.
Hanapin ang pinakabagong bersyon dito:
https://github.com/near/near-cli-rs/releases/
 	Magsimula gamit ang NEAR CLI: Para sa mga nagsisimula, inirerekomenda namin ang paggamit ng near-cli sa Interactive mode.
Mag-type lamang sa iyong Windows terminal
near


Mga Tampok

 	Pamamahala ng Account: Lumikha, magtanggal, at pamahalaan nang madali ang NEAR accounts.
 	Pag-ugnay sa Smart Contract: Mag-deploy ng mga kontrata at tawagin ang mga function sa mga kontrata.
 	Token Transfers: Magpadala ng NEAR tokens sa anumang account.
 	Kasaysayan ng Transaksyon: Makita ang mga nakaraang transaksyon at balanse para sa anumang account.

Konklusyon
Ang NEAR CLI ay isang mahalagang tool para sa mga developer at advanced users na nais ng isang mabisang at malikhaing paraan ng pakikipag-ugnayan sa NEAR blockchain. Ito ay madaling gamitin, scriptable, at maayos na nag-iintegrate sa iyong development workflow. Kung handa ka nang pasukin ang NEAR ecosystem, ang NEAR CLI ay isang magandang lugar upang magsimula!

Para sa mas detalyadong impormasyon, bisitahin ang dokumentasyon ng NEAR CLI.

### Введение в NEAR CLI

NEAR CLI (Command Line Interface) - это мощный инструмент, разработанный для помощи разработчикам и пользователям взаимодействовать с протоколом NEAR напрямую из командной строки. Он упрощает управление учетными записями, развертывание контрактов и другие задачи без необходимости графического интерфейса.
Что такое NEAR CLI?
NEAR CLI - это инструмент командной строки для работы с блокчейном NEAR. Он позволяет пользователям:

 	Управлять учетными записями
 	Развертывать и взаимодействовать с умными контрактами
 	Отправлять и получать токены
 	Просматривать балансы учетных записей и историю транзакций
 	Запускать различные скрипты для автоматизации задач

Почему использовать NEAR CLI?
Если вы разработчик или опытный пользователь, NEAR CLI дает вам прямой контроль над учетными записями NEAR и умными контрактами. Он легкий и легко интегрируется в рабочие процессы разработки для автоматизации и написания скриптов.
Начало работы

 	Установка: На компьютере с Windows NEAR CLI можно установить с помощью установщика .msi.
Найдите самую последнюю версию здесь:
https://github.com/near/near-cli-rs/releases/
 	Начало использования NEAR CLI
Для начинающих мы рекомендуем использовать near-cli в Интерактивном режиме.
Просто введите в вашем терминале Windows
near


Особенности

 	Управление учетными записями: Легкое создание, удаление и управление учетными записями NEAR.
 	Взаимодействие с умными контрактами: Развертывание контрактов и вызов функций в контрактах.
 	Передача токенов: Отправка токенов NEAR на любую учетную запись.
 	История транзакций: Просмотр прошлых транзакций и балансов для любой учетной записи.

Заключение
NEAR CLI - это важный инструмент для разработчиков и опытных пользователей, которые хотят мощный и гибкий способ взаимодействия с блокчейном NEAR. Он легок в использовании, поддерживает написание скриптов и легко интегрируется в ваш рабочий процесс разработки. Если вы готовы погрузиться в экосистему NEAR, NEAR CLI - отличное место для начала!

Для получения более подробной информации посетите документацию NEAR CLI.

### NEAR Protocol: Rencana untuk Masa Depan

Pencapaian Terbaru: Validasi Stateless
Pada Agustus 2024, NEAR Protocol meluncurkan fitur baru yang disebut "validasi stateless." Ini adalah langkah besar ke depan, namun masih banyak pekerjaan yang harus dilakukan.

Keberhasilan Saat Ini dan Tujuan di Masa Depan
NEAR memiliki lebih dari 110 juta pengguna, yang luar biasa! Namun tujuan mereka lebih besar lagi - mereka ingin mencapai 1 miliar pengguna. Untuk mencapai hal ini, mereka perlu membuat sistem mereka lebih baik:


 	Lebih dapat diskalakan (mampu menangani lebih banyak pengguna)
 	Lebih performa (bekerja lebih cepat dan lebih baik)
 	Lebih aman (lebih aman digunakan)
 	Lebih cepat (lebih cepat dalam melakukan tugas)

Rencana untuk Sisa Tahun 2024
Setelah peluncuran Agustus, tim akan bekerja pada perbaikan-perbaikan berikut:


 	Membuat "saksi state" lebih kecil: Ini akan membantu lebih banyak transaksi terjadi sekaligus.
 	Membuat operasi penyimpanan lebih murah: Ini juga akan memungkinkan lebih banyak transaksi.
 	Meningkatkan "resharding": Ini akan membantu NEAR tumbuh lebih besar lagi.
 	Meningkatkan sinkronisasi node: Ini akan membantu NEAR bekerja lebih lancar.

Rencana untuk Awal 2025 dan Selanjutnya

 	Menambahkan biaya prioritas transaksi: Ini akan membantu pengguna yang membutuhkan transaksi mereka selesai dengan cepat.
 	Membuat resharding dinamis: Jaringan akan menyesuaikan diri berdasarkan seberapa sibuknya.
 	Meningkatkan cara NEAR berjalan: Ini akan membuat segalanya berjalan lebih cepat.
 	Membuat "konsensus tanpa pemimpin": Ini akan membantu NEAR bekerja lebih baik bahkan jika beberapa bagian offline.
 	Membuat "kontrak pintar terfragmentasi": Ini akan memungkinkan lebih banyak pengguna dan cara baru untuk menggunakan NEAR.




	

	
	
		
			
				What is the primary goal of NEAR Protocol's future plans as described in the text?
			
		

		
					

		
			
			
			
			To launch stateless validation
		
			
			To reach 1 billion users on the User-Owned Internet
		
			
			To improve node synchronization
		
			
			To create dynamic resharding
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apa Artinya Ini
Semua perubahan ini akan membuat NEAR mampu menangani ratusan juta, atau bahkan miliaran, transaksi setiap hari. Ini akan membantu NEAR tumbuh dan mendukung fitur-fitur baru seperti Abstraksi Rantai, Modularitas, dan Kepemilikan Pengguna AI.
Tim NEAR akan membagikan pembaruan lebih lanjut nanti dalam tahun ini tentang rencana masa depan mereka.

### Introduction to NEAR CLI

NEAR CLI (Command Line Interface) is a powerful tool designed to help developers and users interact with the NEAR Protocol directly from the command line. It simplifies managing accounts, deploying contracts, and other tasks without needing a graphical interface.
What is NEAR CLI?
NEAR CLI is a command-line tool for working with the NEAR blockchain. It allows users to:

 	Manage accounts
 	Deploy and interact with smart contracts
 	Send and receive tokens
 	View account balances and transaction history
 	Run various scripts to automate tasks

Why Use NEAR CLI?
If you're a developer or advanced user, NEAR CLI gives you direct control over NEAR accounts and smart contracts. It’s lightweight and can be easily integrated into development workflows for automation and scripting purposes.
Getting Started

 	Installation: On Windows machine NEAR CLI can be via .msi installer.
Find the most recent one here:
https://github.com/near/near-cli-rs/releases/
For Windows users this is the default choice

 	Run Windows Command Prompt
Click the Start menu, type “cmd” or “Command Prompt,” and press Enter
 	Start using NEAR CLI
For beginners we recommend to use near-cli in Interactive mode.
Just type in your Windows terminal
near


Dive deeper at NEAR Docs
Features

 	Account Management: Create, delete, and manage NEAR accounts easily.
 	Smart Contract Interaction: Deploy contracts and call functions on contracts.
 	Token Transfers: Send NEAR tokens to any account.
 	Transaction History: View past transactions and balances for any account.

Updates
Since v0.15.0 (Sept 2024) NEAR CLI has evolved from a basic wallet‐and-deploy tool into a full “Swiss-army terminal” for the protocol. Hardware-wallet flows were smoothed first—Ledger devices now auto-launch the NEAR app and --teach-me covers async account look-ups. December brought offline-friendly additions: you can save the raw broadcast_tx_commit payload, replay every generated command from your shell history, and even push fully signed transactions or meta-transactions straight from a file, plus faucet-sponsored account creation in Teach-Me mode. Key management was tightened with commands to fetch an account’s public key, derive it automatically from a plaintext private key, and a new “send-all” flag, memo support, and a --quiet switch for scripting. Spring releases introduced global-contract deployment/inspection, an extended action builder, and eliminated the need to pass a public key when it can be inferred. The latest 0.21.0 (July 2025) tops it off with local contract/source verification, one-line DAO proposal submission, smarter implicit-account import, and extra FAST NEAR & Lava RPC endpoints—rounding out end-to-end dev, ops, and governance from a single CLI prompt.
Conclusion
NEAR CLI is an essential tool for developers and advanced users who want a powerful and flexible way to interact with the NEAR blockchain. It's easy to use, scriptable, and integrates seamlessly with your development workflow. If you're ready to dive into the NEAR ecosystem, NEAR CLI is a great place to start!

For more detailed information, visit the NEAR CLI documentation.

### NEAR Protocol: Planes para el Futuro

Logro Reciente: Validación sin Estado
En agosto de 2024, NEAR Protocol lanzó una nueva función llamada "validación sin estado". Este es un gran avance, pero aún queda mucho trabajo por hacer.

Éxito Actual y Metas Futuras
¡NEAR tiene más de 110 millones de usuarios, lo cual es genial! Pero su objetivo es aún mayor: quieren alcanzar 1 mil millones de usuarios. Para lograr esto, necesitan mejorar aún más su sistema:


 	Más escalable (capaz de manejar más usuarios)
 	Más eficiente (trabajar más rápido y mejor)
 	Más seguro (más seguro de usar)
 	Más rápido (más rápido en realizar tareas)

Planes para el Resto de 2024
Después del lanzamiento en agosto, el equipo trabajará en estas mejoras:


 	Reducir el tamaño del "testigo de estado": Esto ayudará a que más transacciones ocurran al mismo tiempo.
 	Hacer más baratas las operaciones de almacenamiento: Esto también permitirá más transacciones.
 	Mejorar el "resharding": Esto ayudará a que NEAR crezca aún más.
 	Mejorar la sincronización de nodos: Esto ayudará a que NEAR funcione de manera más fluida.

Planes para Principios de 2025 y Más Allá

 	Agregar tarifas de prioridad de transacción: Esto ayudará a los usuarios que necesitan que sus transacciones se realicen rápidamente.
 	Crear reshards dinámicos: La red se ajustará según lo ocupada que esté.
 	Mejorar cómo funciona NEAR: Esto hará que todo funcione más rápido.
 	Crear un "consenso sin líder": Esto ayudará a que NEAR funcione mejor incluso si algunas partes están fuera de línea.
 	Crear "contratos inteligentes fragmentados": Esto permitirá aún más usuarios y nuevas formas de usar NEAR.

Lo que Esto Significa
Todos estos cambios harán que NEAR pueda manejar cientos de millones, o incluso mil millones, de transacciones todos los días. Esto ayudará a que NEAR crezca y soporte nuevas características como Abstracción de Cadena, Modularidad y IA Propiedad por el Usuario.
El equipo de NEAR compartirá más actualizaciones más adelante en el año sobre sus planes futuros.

### NEAR Protocol: Kế hoạch cho Tương lai

Thành tựu gần đây: Stateless Validation
Vào tháng 8 năm 2024, NEAR Protocol đã ra mắt tính năng mới mang tên "stateless validation." Điều này là một bước tiến lớn, nhưng vẫn còn rất nhiều công việc phải làm.

Thành công hiện tại và Mục tiêu tương lai
NEAR có hơn 110 triệu người dùng, điều này rất tuyệt vời! Nhưng mục tiêu của họ còn lớn hơn nữa - họ muốn đạt được 1 tỷ người dùng. Để làm được điều này, họ cần phải làm cho hệ thống của mình tốt hơn:


 	Mở rộng quy mô hơn (có thể xử lý nhiều người dùng hơn)
 	Hiệu suất cao hơn (hoạt động nhanh hơn và tốt hơn)
 	An toàn hơn (an toàn hơn khi sử dụng)
 	Nhanh hơn (nhanh chóng trong việc thực hiện các nhiệm vụ)

Kế hoạch cho phần còn lại của năm 2024
Sau sự ra mắt vào tháng 8, nhóm sẽ làm việc để cải thiện những điều sau:


 	Làm cho "state witness" nhỏ hơn: Điều này sẽ giúp thực hiện nhiều giao dịch cùng một lúc hơn.
 	Làm cho các hoạt động lưu trữ rẻ hơn: Điều này cũng sẽ cho phép thực hiện nhiều giao dịch hơn.
 	Cải thiện "resharding": Điều này sẽ giúp NEAR phát triển hơn nữa.
 	Làm cho đồng bộ hóa nút tốt hơn: Điều này sẽ giúp NEAR hoạt động mượt mà hơn.

Kế hoạch cho đầu năm 2025 và xa hơn

 	Thêm phí ưu tiên giao dịch: Điều này sẽ giúp người dùng cần giao dịch của họ được thực hiện nhanh chóng.
 	Tạo ra "resharding" động: Mạng sẽ điều chỉnh dựa trên mức độ bận rộn của nó.
 	Cải thiện cách NEAR hoạt động: Điều này sẽ làm cho mọi thứ hoạt động nhanh hơn.
 	Tạo ra "leaderless consensus": Điều này sẽ giúp NEAR hoạt động tốt hơn ngay cả khi một số phần không kết nối.
 	Tạo ra "sharded smart contracts": Điều này sẽ cho phép nhiều người dùng hơn và cách mới để sử dụng NEAR.

Ý nghĩa của điều này
Tất cả những thay đổi này sẽ giúp NEAR có thể xử lý hàng trăm triệu, hoặc thậm chí một tỷ, giao dịch mỗi ngày. Điều này sẽ giúp NEAR phát triển và hỗ trợ các tính năng mới như Chain Abstraction, Modularity, và User-Owned AI.
Nhóm NEAR sẽ chia sẻ thêm cập nhật vào cuối năm về kế hoạch tương lai của họ.

### NEARプロトコル：将来の計画

最近の成果：ステートレス検証
2024年8月、NEARプロトコルは「ステートレス検証」という新機能を発表しました。これは大きな前進ですが、まだたくさんの作業が残っています。

現在の成功と将来の目標
NEARは1億1,000万人以上のユーザーを持っています、これは素晴らしいことです！しかし、彼らの目標はさらに大きいです - 10億人のユーザーに到達したいと考えています。これを達成するために、システムをさらに改善する必要があります：


 	よりスケーラブル（より多くのユーザーを処理できる）
 	より高性能（より速く、より良く動作する）
 	より安全（安全に使用できる）
 	より速い（タスクをより迅速に実行する）

2024年の残りの計画
8月のローンチ後、チームは以下の改善に取り組みます：


 	「ステートウィットネス」を小さくする：これにより、より多くのトランザクションが一度に行われるようになります。
 	ストレージ操作を安くする：これにより、より多くのトランザクションが可能になります。
 	「リシャーディング」を改善する：これにより、NEARの成長がさらに促進されます。
 	ノード同期を改善する：これにより、NEARの動作がよりスムーズになります。

2025年初頭以降の計画

 	トランザクション優先手数料を追加する：トランザクションを迅速に行いたいユーザーに役立ちます。
 	ダイナミックリシャーディングを作成する：ネットワークは、どれだけ忙しいかに基づいて自動調整されます。
 	NEARの動作を改善する：すべてがより速く動作します。
 	「リーダーレスコンセンサス」を作成する：一部の部分がオフラインでも、NEARの動作をより良くします。
 	「シャーデッドスマートコントラクト」を作成する：さらに多くのユーザーやNEARの新しい利用方法を可能にします。

これが意味すること
これらの変更により、NEARは毎日数億、あるいは10億のトランザクションを処理できるようになります。これにより、NEARは成長し、Chain Abstraction、Modularity、User-Owned AIなどの新機能をサポートすることができます。
NEARチームは、将来の計画について後日さらにアップデートを共有します。

### NEAR Protocol: Plans for the Future

Recent Achievement: Stateless Validation
In August 2024, NEAR Protocol launched a new feature called "stateless validation." This is a big step forward, but there's still a lot of work to do.

Current Success and Future Goals
NEAR has over 110 million users, which is great! But their goal is even bigger - they want to reach 1 billion users. To do this, they need to make their system even better:


 	More scalable (able to handle more users)
 	More performant (work faster and better)
 	More secure (safer to use)
 	Faster (quicker in doing tasks)

Plans for the Rest of 2024
After the August launch, the team will work on these improvements:


 	Make "state witness" smaller: This will help more transactions happen at once.
 	Make storage operations cheaper: This will also allow more transactions.
 	Improve "resharding": This will help NEAR grow even more.
 	Make node synchronization better: This will help NEAR work more smoothly.

Plans for Early 2025 and Beyond

 	Add transaction priority fees: This will help users who need their transactions done quickly.
 	Create dynamic resharding: The network will adjust itself based on how busy it is.
 	Improve how NEAR runs: This will make everything work faster.
 	Create "leaderless consensus": This will help NEAR work better even if some parts are offline.
 	Make "sharded smart contracts": This will allow for even more users and new ways to use NEAR.




	

	
	
		
			
				What is the primary goal of NEAR Protocol's future plans as described in the text?
			
		

		
					

		
			
			
			
			To launch stateless validation
		
			
			To reach 1 billion users on the User-Owned Internet
		
			
			To improve node synchronization
		
			
			To create dynamic resharding
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What This Means
All these changes will make NEAR able to handle hundreds of millions, or even a billion, transactions every day. This will help NEAR grow and support new features like Chain Abstraction, Modularity, and User-Owned AI.
The NEAR team will share more updates later in the year about their future plans.

### 웹3을 통한 체인 추상화 수용: 디지턈 자기 주권으로 가는 길

분산 기술과 생태계의 잠재력에 대한 의심은 거의 없습니다, 특히 자기 주권을 갖는 개인들에게 권한을 부여할 때입니다. 그러나 분산 애플리케이션 (dApps)의 복잡성과 블록체인 및 롤업의 단편화된 생태계는 넓은 대중에게 매력을 제한하고 있습니다.

Web3의 변혁적인 힘을 완전히 이용하기 위해 사용자 경험을 추상화하고 디지털 자기 주권을 지원하는 환경을 육성해야 합니다.

Web3의 복잡성 문제

#1 데이터 처리

현재의 dapps 상태는 명백한 진실을 보여줍니다: 대부분이 실제로 분산화되지 않았으며 사용자 친화적이지 않습니다. 사용자가 거래소를 탐색하고 여러 계정을 관리하며 가스 수수료를 처리해야 하는 필요성은 원활한 애플리케이션의 이상과 실제 복잡성 사이의 격차를 강조합니다. 이 복잡성은 주류 채택을 방해뿐만 아니라 dapps를 상상한 민주화된 웹과는 거리가 먼 특정 사용자 베이스에 제한합니다.

그러나 이 복잡성은 어디에서 비롯됩니까? 기본으로 돌아가서 Web3가 데이터를 처리하는 방식을 이해해 봅시다. Web3는 데이터가 중앙 집중형 데이터베이스에서 분산 환경으로 이동되어 암호화 증명으로 보호되는 방식으로 데이터가 관리되고 저장되는 방식을 완전히 바꿉니다.

Web3의 데이터 처리 방식은 분산화와 암호화 검증에 중점을 두어 전통적인 데이터 관리 전략에 도전하는 복잡한 환경을 제시합니다.

#2 모듈화

Web3의 현재 추세는 모듈화로 향하고 있으며, 이는 결제, 데이터 가용성 및 실행과 같은 구별된 계층으로 블록체인 기능을 분해하는 것을 목표로 합니다. 레이어 투, 낙관론적 및 ZK 롤업, 사이드체인과 같은 기술은 이 모듈식 접근 방식을 보여줍니다. 그러나 이는 사용자와 개발자 경험을 복잡하게 만들었으며, 여러 블록체인에 걸쳐 생태계를 단편화시키고 유동성, 애플리케이션 및 사용자 베이스의 분산된 풍경으로 이어졌습니다. 개발자들은 특정 블록체인에 헌신할지 여부에 대한 딜레마를 직면하며, 이는 프로젝트의 영향력을 제한할 수 있습니다.

추상화가 이 문제를 해결할 수 있을까요?더 나아가기 전에 추상화가 무엇인지 이해해 봅시다. 불필요한 세부 사항을 숨겨 복잡성을 단순화하는 기본 개념으로, 사용자가 하위 복잡성에 시달리지 않고 고수준 기능에 집중할 수 있도록 합니다. 객체 지향 프로그래밍에서 중요한 이 원칙은 소프트웨어 개발을 넘어서 복잡한 로직 구현을 용이하게 하여 다양한 영역에서 단순화된 인터페이스를 제공함으로써 확장됩니다.

추상화는 프로그램 구축의 복잡성을 단순화하여 소프트웨어 개발에서 중요한 역할을 합니다. 이를 통해 프로그래머는 구현 세부 사항에 시달리는 대신 코드의 고수준 기능에 집중할 수 있습니다. 복잡한 코드를 보다 관리하기 쉬운 구성 요소로 추상화함으로써, 개발자는 작업 흐름을 가속화하고 프로그램을 문제 해결하고 반복하는 능력을 향상시킬 수 있으며, 더 높은 효율성으로 고급 프로젝트에 도전할 수 있습니다.

추상화는 개발 프로세스를 최적화할 뿐만 아니라 프로그래머들이 새로운 아이디어와 해결책을 탐구하도록 자유롭게 하여 혁신을 촉진합니다. 기존의 추상화된 구성 요소를 기반으로 소프트웨어가 달성할 수 있는 영역의 한계를 넓히는 데 기여합니다.

그러나 이러한 논리를 블록체인에 적용할 수 있을까요?

체인 추상화는 블록체인 사용자 경험을 단순화하여 복잡한 기반이 되는 메커니즘을 숨기는 것을 의미합니다. 이 전략은 더 직관적인 인터페이스를 제공함으로써 접근성을 향상시키고 널리 사용되도록 하려는 목표를 가지고 있으며, NEAR의 추상화에 중점을 둔 2018년 이후의 사용자 증가로 확인됩니다.
체인 추상화의 비전

체인 추상화를 통해 사용자는 블록체인 네트워크의 복잡한 메커니즘을 이해하지 않고도 원활하게 dapp와 상호 작용할 수 있습니다. 목표는 블록체인 상호 작용을 일반적인 애플리케이션 사용과 같이 직관적으로 만들어 진입 장벽을 낮추고 Web3 기술의 널리 사용을 촉진하는 것입니다.

NEAR 프로토콜은 체인 추상화의 성공적인 구현을 보여주며 사용자 참여를 크게 증가시킬 수 있는 잠재력을 보여줍니다. 블록체인 계층을 추상화함으로써, NEAR은 사용자가 단일 통합된 인터페이스를 통해 다양한 네트워크에서 거래를 수행하고 디지털 경제에 참여할 수 있도록 했습니다. 이는 사용성을 향상시킬 뿐만 아니라 Web3 공간을 보다 넓은 관객에게 열어주어 생태계의 성장과 다양성에 기여합니다.

체인 추상화는 또한 다중체인 애플리케이션 개발을 촉진함으로써 개발자가 특정 블록체인의 기술적 한계에 제약받지 않고 고품질 사용자 경험을 만들 수 있도록 합니다. 이 접근 방식은 Web3 커뮤니티 내에서 혁신과 협력을 촉진하여 디지털 신분과 자산이 다양한 블록체인 플랫폼을 통해 원활하게 관리되고 거래될 수 있는 미래로 나아가며, 현재의 Web3 생태계의 단편화된 풍경을 통합합니다.

체인 추상화의 예시제로 지식 증명(ZKPs)은 체인 추상화를 가능하게 하는 좋은 방법일 수 있습니다. ZK 증명은 정보의 정확성을 확인할 수 있는 메커니즘을 소개하며 정보 자체를 공개하지 않고 확인할 수 있게 합니다. 합법적으로 술을 마실 수 있는 나이임을 증명하기 위해 생년을 보여주는 것처럼 다른 민감한 정보(이름, 주소, 주민등록번호 등) 대신 생년을 보여주는 것을 상상해보세요. 이것이 ZKPs의 실제 예입니다. 이제 이를 블록체인 네트워크로 확장해 봅시다.

기존에는 블록체인 거래의 보안과 무결성이 분산된 검증자 네트워크에 의존했습니다. 이는 여러 당사자가 거래를 검증하고 그들의 합법성을 보장하여 네트워크의 신뢰를 유지하는 합의 메커니즘이 필요했습니다. 그러나 이 방법은 집단 검증자에 대한 일정 수준의 신뢰를 요구하며 합의를 위해 필요한 계산 노력으로 인해 상당한 자원 소비를 야기합니다.

ZKPs를 사용하면 하나의 컴퓨터가 특정 규칙이나 조건이 충족되었음을 확인할 수 있게 되며 기밑 데이터를 공개하지 않거나 여러 검증자로부터 합의를 요구하지 않습니다. 이러한 변화로 인해 분산된 검증자 네트워크에 대한 의존성이 크게 감소하며 보다 간소화되고 효율적인 검증 프로세스가 가능해집니다.

결과적으로 개발자들은 대규모 검증자 네트워크를 설립하고 유지할 필요가 없어져 새로운 블록체인을 더 낮은 자원 요구 사항으로 시작할 수 있는 유연성을 얻게 됩니다. 블록체인이 ZK-provable 보안을 점차 채택함에 따라 한 체인에서 ZK 증명을 발행하면 이를 통해 다른 체인에 걸쳐 거래를 확인할 수 있게 되어 한 체인의 상태를 변경하더라도 이러한 증명에 의해 연결된 다른 체인에 영향을 미치지 않게 됩니다. NEAR 프로토콜이 체인 추상화를 어떻게 가능하게 하는지에 대한 내용입니다.NEAR 프로토콜은 다중 블록체인 간 상호 작용을 간소화하는 사용자 중심 생태계를 개발하여 체인 추상화를 발전시키고 있습니다. 2018년부터 NEAR는 사용성, 확장성 및 유연한 계정 모델을 우선시하여 수십억 사용자를 유치할 수 있는 주류 응용 프로그램을 수용하고자 합니다. 이 플랫폼은 체인 추상화를 완전히 지원하도록 발전하여 다양한 블록체인 및 응용 프로그램 간의 원활한 작동을 허용합니다.

NEAR의 접근 방식의 주요 구성 요소는 수십억 개의 활성 계정을 지원할 수 있는 확장 가능한 블록체인 인프라와 견고한 보안 스택을 포함합니다. 이 스택에는 NEAR의 데이터 가용성(DA) 솔루션, 효율적인 제로 지식 증명을 위한 Polygon Labs와의 협력인 zkWASM, 그리고 향상된 최종성을 위한 EigenLayer가 포함되어 있습니다. 이러한 요소들이 모여 탈중앙화 응용 프로그램을 위한 안전하고 확장 가능한 환경을 보장합니다.

NEAR는 계정 집계를 통해 체인 추상화를 더욱 강화하여 사용자가 단일 계정을 통해 다양한 체인 간 상호 작용을 관리할 수 있도록 합니다. 이 간소화는 데이터 레이어로 확장되어 다양한 블록체인 아키텍처를 지원하고 일관된 데이터 액세스를 보장합니다. 또한 NEAR 인프라 내의 의도 중계자는 여러 체인 간의 복잡한 작업을 용이하게 하여 상호 운용성과 사용자 경험을 향상시킵니다.

NEAR의 탈중앙화 프론트엔드는 Web3 스펙트럼 전반에 걸쳐 응용 프로그램을 발견하고 상호 작용할 수 있는 통합 인터페이스를 제공하며, 사용자 경험을 최적화하기 위해 네트워크 전환이나 가스 수수료 관리의 필요성을 제거하는 슈퍼 지갑을 지원합니다.

사용자에게 자기 주권 부여
사용자 경험을 간소화하는 것을 넘어, 체인 추상화는 디지털 자기 주권의 보다 넓은 목표와 일치합니다. 개인 데이터와 디지털 자산이 점점 가치를 더하는 세상에서 디지털 신원과 자산을 제어하고 관리하는 능력은 중요해집니다. 탈중앙화된 성격을 가진 Web3는 사용자가 중앙 시스템의 제약과 위험 없이 이러한 수준의 제어를 달성할 수 있는 프레임워크를 제공합니다.

자기 주권은 개인이 데이터, 자산 및 신원을 제어하여 중앙화된 권위의 악용으로부터 개인 정보 보호와 자율성을 보호합니다. 이 개념은 개인 정보 침해를 방지하고 사용자가 감시 걱정 없이 자유롭게 상호 작용하고 거래할 수 있는 안전한 디지털 상호 작용을 촉진하는 데 중요합니다. 이는 디지털 경제를 보다 공정한 공간으로 변화시켜 권력의 불균형을 줄이고 사용자가 감시 걱정 없이 자유롭게 상호 작용하고 거래할 수 있는 민주적 환경을 조성합니다.NEAR 프로토콜은 분산형 플랫폼을 통해 자기 주권을 촉진하며, 사용자들이 디지털 상호작용을 통제할 수 있도록 설계되었습니다. 블록체인 기술의 복잡성을 추상화함으로써 NEAR은 사용자들이 기반 인프라의 심층적인 지식 없이도 dApps와 상호 작용할 수 있도록 쉽게 만들어줍니다. 이 접근 방식은 사용성을 향상시킬 뿐만 아니라 사용자가 다양한 응용 프로그램과 플랫폼을 통해 디지털 자산과 신원을 원활하게 관리할 수 있도록 보장합니다.

NEAR의 오픈 소스 소프트웨어에 대한 헌신과 슈퍼 지갑 및 분산형 프론트엔드와 같은 사용자 친화적인 도구의 개발은 사용자들을 더욱 강화시키며, Web3의 정신과 분산형 인터넷의 더 넓은 비전과 일치하는 자기 주권적인 디지털 경험을 제공합니다.




	

	
	
		
			
				What feature of NEAR Protocol supports seamless operation across various blockchains and applications?
			
		

		
					

		
			
			
			
			Its reliance on traditional data management strategies
		
			
			Its limited scalability and rigid account model
		
			
			Its scalable blockchain infrastructure capable of supporting over a billion active accounts.
		
			
			Its focus on centralizing user identities and assets
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





앞으로의 길
널리 퍼져가는 Web3 채택과 디지털 자기 주권의 실현에는 어려움이 따릅니다. 블록체인 기술의 복잡성을 추상화하고 간소화하는 원칙을 받아들이기 위해 생태계 전반의 개발자, 사용자 및 이해관계자들이 협력해야 합니다. 블록체인 기술의 복잡성을 추상화하는 사용자 친화적인 응용 프로그램에 집중함으로써, 우리는 Web3의 문을 전 세계적인 관객에게 열 수 있습니다.

분산형, 사용자 중심의 인터넷으로의 여정이 시작되었습니다. 체인 추상화의 원칙과 사용자 경험을 간소화하는 초점을 통해, 우리는 Web3로의 전환을 가속화하고 개인들에게 진정한 디지털 자기 주권을 부여할 수 있습니다. 이 전환을 탐험하면서, 더욱 개방적이고 안전하며 사용자 중심적인 인터넷의 비전은 손에 닿을 수 있게 되어, 모든 사람이 자신의 디지털 삶을 통제할 수 있는 미래를 약속합니다.


                 
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Web3を受け入れる: チェーン抽象化を通じたデジタル自己主権への道

分散型テクノロジーとエコシステムの潜在能力については疑いの余地がほとんどありません、特に個人に自己主権を与えることに関してです。しかし、分散型アプリケーション（dApps）の複雑さとブロックチェーンやロールアップの断片化されたエコシステムは、一般の人々に魅力を持たせることを制限しています。

Web3の変革力を真に活用するためには、抽象化を通じてユーザーエクスペリエンスを簡素化し、デジタル自己主権をサポートする環境を育む必要があります。
Web3の複雑さの問題
#1 データ処理

現在のdappsの状況は明白な事実を示しています：ほとんどのものは真に分散化されておらず、ユーザーフレンドリーではありません。ユーザーが取引所をナビゲートし、複数のアカウントを管理し、ガス料金を処理する必要性は、シームレスなアプリケーションの理想とその複雑さの現実とのギャップを浮き彫りにしています。この複雑さは、一般的な採用を阻害するだけでなく、dappsを想定された民主化されたWebから遠く離れたニッチなユーザーベースに閉じ込めています。

しかし、この複雑さはどこから来るのでしょうか？基本に戻って、Web3がデータをどのように扱うかを理解しましょう。Web3は、データを中央集権化されたデータベースから暗号的証明で保護された分散環境に移行することで、データの管理と保存方法を完全に変えます。

Web3のデータへのアプローチは、分散化と暗号的検証を重視することで、従来のデータ管理戦略に挑戦する複雑な景観を提示しています。

#2 モジュラリティ

Web3の現在のトレンドは、決済、データ可用性、実行などの異なるレイヤーにブロックチェーン機能を分割するモジュラリティに向かっています。レイヤー2、楽観的およびZKロールアップ、サイドチェーンなどの技術は、このモジュラリティアプローチを具体化しています。しかし、これによりユーザーと開発者のエクスペリエンスが複雑化し、複数のブロックチェーンにエコシステムが分断され、流動性、アプリケーション、ユーザーベースが散在した状況が生まれました。開発者は特定のブロックチェーンにコミットするジレンマに直面し、プロジェクトの到達範囲を狭める可能性があります。
これを抽象化で修正できるか？さらに進む前に、抽象化とは何かを理解しましょう。それは、不要な詳細を隠すことによって複雑さを単純化する基本的な概念であり、ユーザーが下層の複雑さに縛られることなく、高次の機能に焦点を当てることを可能にします。この原則は、オブジェクト指向プログラミングにおいて重要であり、ソフトウェア開発を超えて、簡略化されたインターフェースを提供することで、さまざまな領域で複雑なロジックの実装を容易にします。

抽象化は、プログラム構築の複雑さを単純化することによってソフトウェア開発において重要な役割を果たします。これにより、プログラマーはコードの高次の機能に焦点を当てることができ、実装の詳細に縛られることなく作業を加速し、プログラムのトラブルシューティングやイテレーションの能力を向上させ、より高度なプロジェクトに効率的に取り組むことができます。

抽象化は開発プロセスを合理化するだけでなく、プログラマーが新しいアイデアや解決策を探求し、既存の抽象化されたコンポーネントを活用してソフトウェアが達成できる範囲を広げることによって革新を促進します。

しかし、このロジックをブロックチェーンにも適用できるのでしょうか？

チェーンの抽象化は、複雑な基盤メカニズムを隠すことによってブロックチェーンのユーザーエクスペリエンスを簡素化することを指します。この戦略は、より直感的なインターフェースを提供することでアクセシビリティを向上させ、NEARのような抽象化に重点を置いたことによるユーザーの急成長を示しているように、より広範な採用を促進することを目指しています。

チェーンの抽象化により、ユーザーはブロックチェーンネットワークの複雑な仕組みを理解する必要も、さまざまな暗号通貨資産を管理する必要もなく、ダップとシームレスにやり取りすることができます。目標は、ブロックチェーンとのやり取りを通常のアプリケーションの使用と同じくらい直感的にすることで、参入障壁を低くし、Web3テクノロジーの広範な採用を促進することです。

NEAR Protocolは、チェーンの抽象化の成功した実装を示し、ユーザーの関与を大幅に増加させる可能性を示しています。ブロックチェーン層を抽象化することで、NEARはユーザーが異なるネットワークを通じて取引を行い、デジタル経済に参加することを可能にしました。これは利用性を向上させるだけでなく、Web3空間をより広い層に開放し、エコシステムの成長と多様性に貢献しています。

チェーンの抽象化は、特定のブロックチェーンの技術的制約に縛られることなく、開発者が高品質なユーザーエクスペリエンスを作成することに集中できるため、マルチチェーンアプリケーションの開発を促進します。このアプローチは、Web3コミュニティ内での革新と協力を奨励し、デジタルアイデンティティや資産がさまざまなブロックチェーンプラットフォームを横断してシームレスに管理および取引される未来に向けて進んでいます。

チェーンの抽象化の例ゼロ知識証明（ZKPs）は、チェーンの抽象化を可能にする素晴らしい方法です。ZK証明は、情報の正確性を確認することが可能でありながら情報自体を明らかにしないメカニズムを導入します。合法的な飲酒年齢であることを証明するために、名前、住所、社会保障番号などの他の機密情報ではなく、生年を単に示すだけでよいと想像してみてください。これがZKPsの現実の例です。それをブロックチェーンネットワークに拡張してみましょう。

従来、ブロックチェーン取引のセキュリティと整合性は、分散型の検証者ネットワークに依存していました。これには、複数の当事者が取引を検証し、その正当性を確認し、それによってネットワークの信頼を維持するためのコンセンサスメカニズムが必要でした。しかし、この方法は、集合的な検証者に対するある程度の信頼を要求し、しばしばコンセンサスに必要な計算労力のために膨大なリソース消費をもたらします。

ZKPsを使用すると、1台のコンピューターが、基礎となるデータを開示せずに特定のルールや条件が満たされていることを確認することができ、複数の検証者からのコンセンサスを必要としません。この変化により、分散型の検証者ネットワークへの依存が大幅に減少し、より効率的で効果的な検証プロセスが可能となります。

したがって、開発者は、大規模な検証者ネットワークを確立および維持する必要がなくなるため、はるかに低いリソース要件で新しいブロックチェーンを立ち上げる柔軟性を得ることができます。ブロックチェーンがますますZK証明可能なセキュリティを採用するにつれて、1つのチェーンでのZK証明の公開により、これらの証明によって相互接続された他のチェーンにまたがる取引を検証することが可能となり、1つのチェーンの状態を変更することなく他のチェーンに影響を与えることが事実上不可能となります。NEARプロトコルは、複数のブロックチェーン間の相互作用を簡素化するユーザーセントリックなエコシステムを開発することで、チェーンの抽象化を推進しています。2018年以来、NEARは使いやすさ、スケーラビリティ、柔軟なアカウントモデルを重視し、数十億のユーザーを惹きつける潜在的な主流アプリケーションを収容することを目指しています。このプラットフォームは、様々なブロックチェーンやアプリケーション間でのシームレスな操作を可能にするチェーンの抽象化を完全にサポートするように進化しています。

NEARのアプローチの主要な要素には、10億以上のアクティブアカウントをサポートできるスケーラブルなブロックチェーンインフラストラクチャと堅牢なセキュリティスタックが含まれています。このスタックには、NEARのデータ可用性（DA）ソリューション、効率的なゼロ知識証明のためのPolygon Labsとの協力によるzkWASM、および強化されたファイナリティのためのEigenLayerが含まれています。これらの要素は、分散型アプリケーションに対する安全でスケーラブルな環境を確保します。

さらに、NEARはアカウントの集約を通じてチェーンの抽象化を可能にし、ユーザーが単一のアカウントを介して異なるチェーン間での相互作用を管理できるようにしています。この簡素化はデータレイヤーにも及び、さまざまなブロックチェーンアーキテクチャをサポートし、一貫したデータアクセスを確保します。さらに、NEARインフラストラクチャ内の意図リレーサーは、複数のチェーン間での複雑な操作を促進し、相互運用性とユーザーエクスペリエンスを向上させます。

NEAR上の分散型フロントエンドは、Web3スペクトラム全体でのアプリケーションの発見と相互作用のための統一されたインターフェースを提供し、ユーザーエクスペリエンスを最適化するスーパーウォレットによってネットワークの切り替えやガス料金の管理の必要性を排除します。

ユーザーに自己主権を与える
ユーザーエクスペリエンスを簡素化するだけでなく、チェーンの抽象化はデジタル自己主権のより広い目標と一致しています。個人データやデジタル資産がますます価値を持つ世界では、デジタルアイデンティティや資産を管理し制御する能力が極めて重要になります。分散型の性質を持つWeb3は、ユーザーがこのレベルの制御を達成するためのフレームワークを提供し、中央集権的システムの制約やリスクから解放された環境を提供します。

自己主権は、個人がデータ、資産、アイデンティティをコントロールし、中央権力の搾取からのプライバシーと自律性を保護することを確実にします。この概念は、プライバシーの侵害を防ぎ、自分の条件で安全なデジタル相互作用を促進するために重要です。これにより、デジタル経済がより公正な空間に変わり、権力の不均衡を軽減し、ユーザーが監視の懸念なしに自由に相互作用し取引する民主的な環境が育まれます。NEARがどのように自己主権を実現するかNEARプロトコルは、ユーザーがデジタルインタラクションをコントロールできるように設計された分散型プラットフォームを通じて、自己主権を促進します。ブロックチェーン技術の複雑さを抽象化することで、NEARは、ユーザーが基盤となるインフラストラクチャの詳細な知識を必要とせずにdAppsと関わることを容易にします。このアプローチは、利用性を向上させるだけでなく、ユーザーがさまざまなアプリケーションやプラットフォームをシームレスに管理できることを保証します。

NEARのオープンソースソフトウェアへのコミットメントや、スーパーウォレットや分散型フロントエンドなどのユーザーフレンドリーなツールの開発は、さらにユーザーを強化し、Web3の倫理や分散型インターネットのより広いビジョンと一致する自己主権的なデジタル体験を可能にします。




	

	
	
		
			
				What feature of NEAR Protocol supports seamless operation across various blockchains and applications?
			
		

		
					

		
			
			
			
			Its reliance on traditional data management strategies
		
			
			Its limited scalability and rigid account model
		
			
			Its scalable blockchain infrastructure capable of supporting over a billion active accounts.
		
			
			Its focus on centralizing user identities and assets
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





これからの道
広範なWeb3の採用とデジタル自己主権の実現への道は容易ではありません。開発者、ユーザー、エコシステム全体のステークホルダーが、抽象化とシンプルさの原則を受け入れるために協力する必要があります。ブロックチェーン技術の複雑さを抽象化するユーザーフレンドリーなアプリケーションに焦点を当てることで、Web3の扉を世界中のユーザーに開くことができます。

分散化された、ユーザー主導のインターネットへの旅が始まりました。チェーンの抽象化の原則とユーザーエクスペリエンスの簡素化に焦点を当てることで、Web3への移行を加速し、個人に真のデジタル自己主権を与えることができます。この移行を進める中で、よりオープンで安全でユーザーセントリックなインターネットのビジョンは手の届くところにあり、誰もがデジタルライフをコントロールできる未来を約束しています。


                 
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### NEARプロトコルとは何ですか？

期待される結果：エンドユーザーの視点からNEARの動作を基本的に理解する
NEARはNEAR Protocolブロックチェーンの上で動作する分散型アプリケーションプラットフォームです。このブロックチェーンは世界中の数百台のマシン上で動作し、許可なく、高性能で安全に構築されており、新しいウェブのための強力で分散化されたデータレイヤーを作成するために設計されています。
NEARの主な使命は、ユーザーが所有する共有されたお金、アイデンティティ、およびデータへのアクセス権を持つアプリケーションを実行するのに最適なプラットフォームを提供することです。これにより、分割耐性ネットワーキング、サーバーレスコンピューティング、および分散ストレージの機能が組み合わされ、新しい種類のプラットフォームが生まれます。
ですので、さらに進む前に、いくつかの背景を学び、ブロックチェーンプラットフォームが時間とともにどのように進化してきたかを見てみましょう。

ブロックチェーン技術の進化
2008年10月にサトシ・ナカモトがビットコインの白書を公開して以来、世界は画期的なブロックチェーン技術と親しみを持つようになりました。過去10年間で、ブロックチェーンは3つの進化段階を経てきました。
第1世代：ビットコイン
ビットコインは第1世代ブロックチェーンの完璧な例です。このブロックチェーンの目的は、シンプルでわかりやすい支払いシステムであることです。最初は「インターネットの通貨」として始まったビットコインは、現在では最も需要の高い資産クラスの1つとなっています。しかし、BTCには重大な問題があります。それらを使用して複雑なトランザクションを行うことは不可能であり、それには複数のメタデータとロジックが関連している場合があります。
第2世代：イーサリアムとスマートコントラクトプラットフォーム
イーサリアムはスマートコントラクトを備えた第2世代のブロックチェーンプラットフォームを導入しました。ついに、開発者はこれらのスマートコントラクトを通じて洗練されたトランザクションをプログラムし、分散型アプリケーション（dApps）を作成することができました。これらのdAppsを通じて、ブロックチェーンのユースケースは急速に拡大しました。
しかし、この領域は成長の痛みに苦しんでいます。主な問題は、これらのブロックチェーンが深刻なスケーラビリティの問題に直面していることです。例えば、ビットコインは秒間7件の取引を処理できますが、イーサリアムはわずか25件しか処理できません。これをPayPal（115 tps）やVisa（1,700 tps）と比較すると、かなり劣っていると言えます。
公平を期すと、最近ではイーサリアムとビットコインがライトニングネットワーク、レイデン、プラズマプロトコルなどのレイヤー2のソリューションを使ってこれらのスケーラビリティの問題を解決しようとしています。ここでのアイデアは、基礎となるブロックチェーンの上に追加のレイヤーを作成し、主要プロトコルが繰り返しの煩雑なタスクを委任できるようにすることです。ただし、このアプローチには2つの問題があります。まず、これらのレイヤー2のソリューションはまだ大衆からの受け入れを得ていません。第二に、これらのレイヤー2のソリューションは、プロトコルの元のアーキテクチャを破壊し、長期的な影響をもたらす可能性があります。
ここで第3世代が登場します。
第3世代：NEAR
NEARは、スケーラビリティの問題を解決し、エンドユーザーと開発者の両方がスマートコントラクトとブロックチェーン技術のフルポテンシャルを楽しむことを目指す第3世代のブロックチェーンの例です。レイヤー2のテクノロジーに頼る代わりに、NEARは、ネットワークに参加するすべてのノードがすべてのコードを実行する必要があるという考えから解放されます。なぜなら、それは本質的に1つの大きな無駄なボトルネックを作成し、他のすべてのアプローチを遅くします。
この問題を解決するために、NEARはデータベースの世界で既に非常に一般的なテクニックであるシャーディングを使用しています。適切に実行されれば、ネットワークの容量をスケーリングアップさせることができ、ネットワークの容量に理論上の制限がないため、最高の部分です。シャーディングはレイヤー1のスケーラビリティテクニックです。

シャーディングとは何ですか？
データベースでは、大きなかさばるデータを扱うことがあります。これはパフォーマンスとスループットを著しく妨げ、プロセス全体を非常に効率的でなくします。ここでシャーディングが登場します。
シャーディングは、データベースの水平分割を行い、より小さな、より管理しやすいテーブルに変換します。

なぜ水平分割でなく垂直分割なのか？
このテーブルを考えてみてください：


A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



それを見ましたか？
パーティションのため、テーブルは完全に異なる2つのテーブルになります。
それに対して、テーブルが水平にパーティションされるとどうなるか：
何が起こるか見えますか？テーブルを垂直にパーティションすると、それらは完全に異なる2つのテーブルになります。
しかし、それらを水平にパーティションした場合：


A
B
A*B
A/B


3
3
9
1


4
4
16
1



See that?
水平分割により、データベースを同じデータベースの小さなテーブルに分割します。これらの小さなデータベースはシャードと呼ばれます。

シャーディングはブロックチェーンにどのように役立ちますか？
これまでに見てきたように、ますます多くのノードがイーサリアムやビットコインのエコシステムに参加すると、全体のコンセンサスと検証プロセスにさらに時間がかかります。では、シャーディングはこれをどのように助けるのでしょうか？
シャーディングは、ブロックチェーンのグローバルステートをより管理しやすいより小さなシャードに分割します。
シャードのアクティベーション時に何が起こるのでしょうか？


 	ステートがシャードに分割されます
 	すべてのユニークなアカウントが1つのシャードにあり、そのシャード内のアカウントは同じシャード内の他のアカウントとのみ取引します。

単純化された言葉で言えば、次のシナリオを想像してください。A、B、Cの3つのノードがある仮想ネットワークがあるとします。そして、データTを検証する必要があります。データTはT1、T2、T3の3つのシャードに分割されます。これらのノードがすべてT全体に取り組む代わりに、同時に1つのシャードに取り組むことができます。保存される時間の量が指数関数的に増加していることがわかります。
他の多くのシャーディングアプローチとは異なり、より多くの人々がネットワークに参加する能力を低下させる複雑なハードウェア上でノードを実行する必要があるという点で、NEARの手法は、ノードが単純なクラウドホストされたインスタンスで実行できるほど小さく保たれます。

NEARのようなスケーラブルなブロックチェーンがなぜ必要なのか？
ヒント：全てが速度だけではありません！
第2世代および第3世代のブロックチェーンに関して、真の価値を決定するのは、それに乗って繁栄するdappエコシステムです。そのため、これらのブロックチェーンプラットフォームのほとんどは、可能な限り多くの開発者を引き付けるために永遠の競争をしています。ただし、現行プラットフォームの問題は、高品質のアプリをホストするのに必要な洗練された機能がないことです。問題は、PS4ゲームをWindows 98に相当するプラットフォームで作成しようとする開発者がいることです。そのため、彼らはdAppsの全体的な機能性に大きな妥協をしなければなりません。
さらに、ここで考慮すべきもう1つの要素があります。アプリケーションの使いやすさにはスピードが重要な要素です。結局のところ、ユーザーは全く使い物にならないアプリケーションを使う理由がありません。開発者は、臨界質量に達する前に、一定数のユーザーが継続してアプリケーションを使用する必要があります。
これが、NEARのようなスケーラブルなブロックチェーンプラットフォームがブロックチェーンとスマートコントラクトの主流採用に重要である理由です。
NEARは、開発者がアプリを展開するだけで、その周囲のインフラストラクチャがどのように動作するかやスケールするかについてあまり考える必要がないようにします。これは、ほとんどの現代のWebアプリケーションを駆動するAmazon AWSやGCPやAzureのようなモダンなクラウドと似ています。

NEARの簡単な歴史
NEARは、2018年夏にAlex SkidanovとIllia Polosukhinが以前の起業の冒険から転換することを決定したことから始まりました。非常に速く、MishaがMemSQLを辞めた後、チームは8月の3日間で数人から9人に拡大しました。最初のチームは7人のエンジニア、ビジネスオペレーションを行うErik、市場と話すSashaで構成されていました。
今日、NEAR Collectiveは、この技術を実現するために自己組織化する多くの個々の組織や貢献者からなる、世界的に分散したチームの集まりです。それはビジネスでも何でもないほど形式的ではありません。代わりに、大規模なオープンソースソフトウェアプロジェクトを運営する人々のグループのように考えてください。
Collectiveのプロジェクトの1つは、オープンソースのNEARネットワークの初期コードとリファレンス実装を書くことであり、まるでスペースシャトルのロケットブースターを建設するようなものです。彼らの仕事は、ブロックチェーンを軌道に乗せるために必要なR&D作業を行うことです。そのチェーンのコードはオープンソースなので、誰でも貢献したり実行したりできます。NEARのようなネットワークは完全に分散化されるよう設計されていることを強調することは重要です。つまり、これらのネットワークは最終的に完全に独自に動作し、実際には、それらを構築した初期のチームでさえも、第三者によって検閲、シャットダウン、またはその他の方法で操作されることはできません！したがって、この集団のメンバーは、リファレンス実装の構築を始めるためにここにいるものの、一度ネットワークが稼働し始めると、その運用にはすぐに不要になります。実際、一度起動準備が整ったら、誰でもNEAR Protocolコードを変更して実行できるため、すべてがオープンソースであり、変更はそれを運用する独立したバリデーターによって民主的に受け入れられなければなりません。
NEARには、Microsoft、MemSQL、Meta、Googleなどの企業からの開発者や研究者からなる多様なチームがいます。このプロジェクトは、シリコンバレーの最も影響力のあるVCのいくつかを含む40以上の投資ファームの支援を受けています。たとえば、Andreessen Horowitzのa16z、Metastable、Pantera、RippleのデベロッパーエコシステムプロジェクトXspring、Coinbaseなどがあります。

メインネットのローンチ後、NEARチームは採用フェーズの準備を開始しました。
レインボーブリッジの開発
レインボーブリッジは、NEARエコシステムで最も重要なブリッジと見なされています。NEARプロトコルは、イーサリアム、NEAR、そして最終的にオーロラ間で資産の移転を可能にする信頼性のあるブリッジとしてこのブリッジを構想しています。レインボーブリッジにより、開発者はイーサリアムの資産をNEARでシームレスに使用したり、NEARの資産をイーサリアムで使用したりできます。ブリッジのローンチ以来、開発者は、DAI、ETHなどの資産を1百万ドル以上移転しています。レインボーブリッジは、NEARとバイナンススマートチェーン、ポリゴン、アバランチ、オプティミズム、アービトラムなど、すべてのイーサリアム互換チェーンと再利用して接続することもできます。
オーロラの開発
Aurora EVMの開発も、NEARが採用を推進するための重要なマイルストーンと見なされています。Auroraは、NEARが提供するいくつかのユニークな機能を活用した、存在する中で最もパワフルなEVMと見なすことができます。Auroraには、Aurora EngineとRainbow Bridgeという2つのコアコンポーネントがあります。Aurora Engineは、SolidityやVyperスマートコントラクトをシームレスに展開することを可能にし、Rainbow Bridgeは、イーサリアムとオーロラ間で資産の許可なしの転送を可能にします。イーサリアムに比べて、Auroraは最大1000倍低い手数料を提供し、秒間数千トランザクションをホストでき、イーサリアムに比べて50倍の増加を表します。
プライベートシャードのローンチ
2021年9月、NEARはプライベートシャードのローンチを達成し、重要なマイルストーンを達成しました。これらのプライベートシャードは、NEAR上のシャードとして機能し、パブリックチェーンのコントラクトがプライベートシャードのコントラクトを呼び出したり、その逆を行ったりできます。

NEARのプライベートシャードについて詳しくはCalimeroのウェブサイトをご覧ください
DeFiファンドの創設2021年10月、Proximity LabsはNEAR向けに3億5000万ドルの開発基金を発表しました。この助成金はNEAR上で分散型金融（NEAR上のDeFiアプリケーション）を構築するのに役立ちます。その後、NEAR財団が8億ドルのDeFi基金を創設すると発表しました。BlockworksもNEARに焦点を当てたファンドの立ち上げを発表し、約4,000万ドルを調達する計画です。
その他の重要な展開
上記にリストされた展開はNEAR Protocolに関する唯一の展開ではありませんでした。

 	2021年11月、世界的な旅行代理店Travala.comはNEARとのパートナーシップを発表し、ネットワークトークンがTravalaに統合されることになりました。
 	NEARは、開発者がNEAR上でアプリを作成するのを支援するスタートアッププラットフォームであるPagodaの立ち上げを発表しました。この発表に続いて、NEARはNEARPayの立ち上げも発表しました。NEARPayはNEAR上で最初のデビットカードおよび支払いウィジェットとなり、フィアット通貨と暗号通貨を結ぶものです。
 	NEARは、Y Combinator Alumniによって作成された暗号コレクティブOrangeDAOによって、主要なLayer-1ブロックチェーンとして選ばれました。
 	NEARネイティブのステーブルコイン$USNはDecentral Bankを通じてローンチされました。

NEARブロックチェーンの仕組み
暗号通貨の基盤となる技術。ブロックチェーンは、取引記録を単一の場所に保存するのではなく、ピアツーピアネットワーク上に安全に保存できる技術です。世界中の独立したサーバーであるノードが、ブロックチェーンを運営するネットワークを構成しています。

ブロックチェーン技術の最も特徴的な側面の1つは分散化です。では、なぜ分散化が役立つのでしょうか？開発者とエンドユーザーの観点から見てみましょう。


 	開発者：中央集権的な世界では、開発者はしばしばクラウドプラットフォームや政府にアプリを継続して実行できるようにするよう頼まれます。分散化された世界では、支配的な仲介者は存在しません。
 	エンドユーザー：分散型アプリケーションの透明性により、ユーザーはバックエンドコードを見ることができ、アプリが個人情報をどのように使用するかを正確に知ることができます。

NEARの合意アルゴリズムとは何ですか？コンセンサスプロトコルは、システム内の複数の参加者間で単一の値に合意するために使用されます。ネットワークのすべての参加者がコンセンサスプロトコルに従って協力すると、新しい値が台帳に追加され、ノードによって検証される可能性があります。ただし、紛争の場合、ネットワークは安全性または生存性のどちらに焦点を当てるかもしれません。
NEARに実装されているコンセンサスメカニズムはNightshadeと呼ばれます。Nightshadeはシステムを単一のブロックチェーンとしてモデル化します。各ブロックのすべてのトランザクションのリストは、物理的なチャンクに分割され、1つのシャードごとに1つのチャンクが割り当てられます。すべてのチャンクは1つのブロックに蓄積されます。チャンクはそのシャードの状態を維持するノードによってのみ検証されることに注意してください。
検証について言及すると、NEARの重要なコンポーネントはバリデータです。これらのバリデータはプロトコル内でのコンセンサスの維持に責任があります。バリデータは、サーバーを常にオンラインの状態に保ちながら、システムを常に更新し続ける必要がある専門のノードです。
ネットワークのバリデータについて覚えておくべきいくつかのポイントがあります。


 	NEARは、新しいエポックごとにネットワークのバリデータを決定し、そのステークに基づいて選出します。
 	すでに選出されたバリデータは、自動的に再ステーキングされたトークンと獲得した報酬を再投資されます
 	潜在的なバリデータは、動的に決定されたレベル以上のステークを持っている必要があります。
 	バリデータがステークを強化するために使用できる2つの方法があります - トークンを自ら購入するか、ステーク委任を介して借り入れることです。
 	受け取る報酬は、あなたのステークに比例しています。ステークが多いほど、報酬も多くなります。

コンセンサスは、最も重いチェーンのコンセンサスに基づいています。つまり、ブロックプロデューサーがブロックを公開すると、バリデータノードの署名を収集します。ブロックの重みは、ブロックに含まれるすべての署名者の累積ステークです。チェーンの重みは、ブロックの重みの合計です。さらに、コンセンサスは、より高いチェーンのセキュリティのための追加のスラッシング条件を導入するファイナリティガジェットを利用しています。



	

	
	
		
			
				Express Quiz: The weight of a block is:
			
		

		
					

		
			
			
			
			The maximum stake of the signers whose signatures are included in the block
		
			
			The cumulative stake of all the signers whose signatures are included in the block
		
			
			The average stake of the entire network divided by the number of signers in the block
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEARランタイム
ランタイムレイヤーは、ユーザーによって作成されたスマートコントラクトや他のアクションを実行し、実行間の状態を保持するために使用されます。さまざまなシナリオをステップバイステップで進める、ランタイムのコンポーネントを説明する、ランタイムが実行する機能を説明する、という3つの異なる視点から記述できます。

NEARトークンとは？NEARトークンは、NEARエコシステムの基本的なネイティブアセットであり、その機能はすべてのアカウントで有効になっています。各トークンは、Etherに類似したユニークなデジタルアセットであり、次のように使用できます：


 	トランザクションの処理とデータの保存のためにシステムに支払う。
 	ステーキングプロセスに参加することで、ネットワークの一部として検証ノードを実行する。
 	ガバナンスプロセスに参加することで、ネットワークリソースの割り当て方法や将来の技術方向を決定するのに役立つ。

NEARトークンは、ネットワークを運営するすべての参加者の経済的調整を可能にし、そのネットワーク上に構築されたアプリケーション間で新しい行動を可能にします。

NEARの始め方
アカウント/ウォレット
NEARを始める前に、最初に行うべきことはNEARアカウントを設定することです。
NEARアカウントに関するこのビデオをご覧ください：

ウォレットを使用すると、ブロックチェーンに対してコントラクトコールを行ったり、ローカルノードを設定したり、他のユーザーから資金を送受信したりできます。アカウントIDを登録する際には、ユニークな名前を提供する必要があります。すべてのウォレットにはユニークな名前が必要ですが、ユーザーは複数のウォレットを設定できます。
これはFacebookやGoogleアカウントに似ています。これらのサービスのいずれかに登録すると、同じアカウントを使用してサードパーティーサービスにログインできます。NEARアカウントIDとGoogleアカウントの違いは、アカウントIDに対して保存されるデータがウォレットの所有者のみにアクセス可能で管理可能であることです。さらに、すべての情報は単一のサーバーではなく、分散ネットワークのノードに保存されます。
今すぐNEARアカウントを作成する：https://wallet.near.org/create
詳細な情報はこちら：DOCS.NEARのアカウントに関する情報

NEAR ExplorerNEAR Explorerはブロックの作成をリアルタイムで表示できます！この便利なツールを使用して、トランザクションやアカウントを検索して、ユーザーとスマートコントラクト間のすべてのやり取りを表示できます。


NEARトークンを入手する方法
$NEARを入手する方法は3つあります

獲得する
開発バウンティに参加したり、NEAR上でコミュニティを運営したり、NEARハッカソンで勝利したり、コミュニティの活発な一員であることによって、$NEARを獲得できます。他の人々をステーキングのためにトークンを貸し出すことができれば、バリデータを運営することで$NEARを獲得することもできます。

購入する
$NEARはいくつかの主要取引所で利用可能です（以下参照）、そこで、法定通貨または暗号通貨を使用してトークンを購入できます。
$NEARをリストしている取引所
価格やペアの概要は、coinmarketcapやcoingeckoで確認できます。
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

友達から
NEARアカウントを持っていなくてもNEARトークンを受け取ることができます！「NEAR Drop」アプローチを使用して、友達が新しいアカウントを事前に資金提供し、トークンを取得するためのホットリンクを送信できます。

NEARトークンで何ができる？
NEARの送金あなたと友達のアカウント間で$NEARを送受信して、ブロックエクスプローラで取引を確認してください。取引手数料が非常に低いため、$NEARのわずかな金額を素早く簡単に移動して遊ぶことができます。
ギフトとして送る：http://redpacket.near.org/

NEAR Dropを試してみる（友達を招待）
友達がアカウントを作成する必要がある場合は、NEARドロップを送ってください。

NEARアプリを使用する
NEARで構築されているアプリの成長リストを表示するには、こちらをクリックしてください。
NFTで簡単スタート-アートの購入/公開/取引はhttps://paras.id/
BerryClubで遊んで、集団アート作成に参加：https://berryclub.io/

NEARの使用料はいくらですか（ガス）？
NEARブロックチェーンにデータを更新または変更するために呼び出しを行うと、ブロックチェーンのインフラストラクチャを運営する人々が一部のコストを負担します。最終的には、どこかのコンピュータがあなたのリクエストを処理し、これらのコンピュータを運用しているバリデータはこれらのコンピュータを維持するためにかなりの資本を費やしています。
他のプログラマブルブロックチェーンと同様に、NEARはこれらの人々にトランザクション手数料、またはガス料金とも呼ばれる料金を請求しています。
Web2クラウドサービスプロバイダー（Amazon Web Services、Google Cloudなど）に精通している場合、ブロックチェーンとの大きな違いは、ユーザーがアプリに呼び出しを行った際にすぐに料金が発生することです。開発者がすべてのインフラを使用するコストを負担するのではなく、ユーザーがすぐに料金が発生します。これにより、開発者や企業の資金が尽きてアプリが消えるリスクがないアプリなど、新しい可能性が生まれます。ただし、いくつかの使用上の障害も発生します。これを補助するために、NEARは開発者がユーザーのガス料金をカバーする機能を提供し、Web2から来たユーザーにとってより馴染みやすい体験を作成します。
ガスについて考える際には、2つの概念を心に留めておいてください：
 	ガスユニット：内部的に、取引手数料はNEARトークンで直接計算されるのではなく、"ガスユニット"という中間段階を経て計算されます。ガスユニットの利点は、決定論的であることです - 同じ取引は常に同じガスユニット数を必要とします。
 	ガス価格：その後、ガスユニットはガス価格と乗算され、ユーザーに請求する金額が決定されます。この価格は、ネットワークの需要に応じて各ブロックごとに自動的に再計算されます（前のブロックが半分以上埋まっている場合は価格が上がり、そうでない場合は下がり、そして各ブロックごとに1%以上変化しません）、そしてネットワークによって構成された価格で底をつきます。現在は100億ヨクトNEARです。

ガス価格はNEARのメインネットとテストネットで異なる場合があります。以下の数字に依存する前にガス価格を確認してください。
ガスで考える
NEARは、1秒あたりのブロック時間をほぼ1秒にするために、ブロックあたりのガス量を制限しています。ガスユニットは、以下のような簡単に考えられる数値になるように注意深く計算されています：
10¹²ガスユニット、または1 TGas（テラガス）…
≈ 1ミリ秒の"計算"時間
…最小ガス価格が100億ヨクトNEARの場合、0.1ミリNEARの料金に相当します
この1ミリ秒はおおよそのが便利な近似値であり、現在のガスユニットがNEAR内でどのように設定されているかの目標です。ガスユニットは、計算/CPU時間だけでなく、帯域幅/ネットワーク時間やストレージ/IO時間も含んでいます。ガバナンスメカニズムを介して、将来的にTGasとミリ秒の間のマッピングを調整することができますが、上記はガスユニットが何を意味し、どこから来たのかを考えるための良い出発点です。
クイズ：1テラガスまたはTGasは何に等しいですか：


	

	
	
		
			
				1 TeraGas or TGas is equal to:
			
		

		
					

		
			
			
			
			1 microsecond of compute time
		
			
			10 seconds of compute time
		
			
			1 millisecond of compute time
		
			
			1 nano second of compute time
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






一般的なアクションのコスト
NEARでのコストの予想をするための出発点として、以下の表に一般的なアクションとそれに必要なTGasの量、および最小ガス価格が100億yNの場合の料金がいくらかを示しています。


操作
TGas
手数料（mN）
手数料（Ⓝ）


アカウント作成
0.42
0.042
4.2⨉10⁻⁵


送金
0.45
0.045
4.5⨉10⁻⁵


ステーク
0.50
0.050
5.0⨉10⁻⁵


フルアクセスキーの追加
0.42
0.042
4.2⨉10⁻⁵


キーの削除
0.41
0.041
4.1⨉10⁻⁵



NEARでどのように稼げますか？
NEARをステークする
証明書のステークモデルの鍵は、コミュニティによるステーキングを通じてバリデーターがサポートされることです。バリデーターは、ネットワークを実行するノードの運用に対してNEARトークン報酬を獲得し、年間5%の固定インフレ率により、報酬として新しいトークンをバリデーターに割り当てます。
バリデーターは、バリデーターシートを維持するために最低限のステーク量を維持する必要があります。トークン保有者は、ネットワークで生成されたトークン報酬の一部を獲得するために、ネットワークで良いパフォーマンスを発揮していると信じる特定のバリデーターにステークすることができます。これにより、トークン保有者はコミュニティと関わり続けることが促進されます！
NEARウォレットには、ステーキングユーザーインターフェースがウェブアプリに直接組み込まれています。
ステークするには：


 	ナビゲーションバーから「ステーキング」を選択します（モバイルではドロップダウンメニュー）
 	「バリデーターを選択」ボタンをクリックします
 	バリデーターを選択します
 	選択を確認し、「バリデーターとステーク」を選択します
 	ステークしたいNEARの量を入力し、「ステークを送信」をクリックします
バリデータを選択するための1つ、およびバリデータとのデポジットおよびステークを確認するためのもう1つのトランザクションを確認する必要があります。
アンステークするには:


	ステーキングダッシュボード（/staking）で現在のバリデータを選択します
	「アンステーク」をクリックしてトランザクションを確認します

36〜48時間後（4つの完全なエポック後）、ステークを引き出すことができます。そのためには、バリデータページに戻り、「引き出し」をクリックします。



	

	
	
		
			
				New tokens are created as rewards after epoch which is approximately every:
			
		

		
					

		
			
			
			
			12 minutes
		
			
			12 seconds
		
			
			12 days
		
			
			12 hours
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR上でのDeFiの構築
DeFi（分散型金融）エコシステムは熱い状況です。現在、Ethereumは1000億ドル以上のDeFiネットワークを保有しています。NEARに関しては、そのDeFiエコシステムはまだ若く成長中です。


DeFiLlamaによると、NEARエコシステムの総ロックバリュー（TVL）は1億ドル未満で、Ref Financeが市場リーダーです。EthereumのDeFiエコシステムがNEARの1000倍であるという事実は、NEARのDeFiに関しては非常に初期段階であることを示しています。実際、2021年にはNEAR Protocolが800億ドルの資金調達イニシアチブを発表しました。その大部分はプロトコルのDeFiセクターの成長に充てられます。

NEARのDeFiエコシステムについて詳しく知りたい場合は、こちらを読んでください。
NEARの成長するNFTエコシステム
非代替性資産は、他の資産とは異なる特性を持っています。非代替性トークンは非代替性資産に基づいており、ブロックチェーン技術を使用したユニークなデジタル資産です。最近、このセクターは急速に成長し、人気を博しています。

NEAR Protocolは、Ethereumに比べて2つの主要な利点を持つため、NFTに最適なプラットフォームです:

	NEARははるかに高速です。
	Ethereumはガス料金がはるかに高いです。

これらの要因により、NEARはNFTの購入と販売に最適です。NEAR上のトップ7 NFTプロジェクトについて詳しくは、この記事を読んでください：top 7 NFT projects on NEAR。
それでは、今後は？NEARとどのようにやり取りできますか？さて、次に何が起こるのでしょうか？ここまで読んでいるなら、NEARプロトコルにさらに深く入りたいと思うでしょう。次にすべきことは、NEARホワイトペーパーをチェックすることです。ブロックチェーンに新しくて、技術自体についてもっと学びたい場合は、このビデオでブロックチェーンエコシステムを解体することができます：blockchain ecosystem。
NEAR Discordサーバーに参加し、NEARフォーラムをチェックしてください。

### Paymaster: Разблокировка массового принятия NEAR

Давайте поговорим о том, почему платежные агенты являются ключевым моментом для привлечения людей к технологии блокчейн.
Итак, в чем суть платежных агентов?
Представьте, что вы устраиваете вечеринку, но каждому нужен специальный билет, чтобы попасть на нее. Это как раз то, как работает блокчейн - вам нужна криптовалюта, чтобы что-то сделать. Но что, если вы могли бы оплатить входной билет за своих гостей? Вот что именно делает платежный агент! Он позволяет вам оплатить "газовые сборы", чтобы люди могли взаимодействовать с вашими блокчейн-штуками, не имея собственной криптовалюты.

Почему это так важно?
Ну, мы занимаемся крутыми проектами блокчейн с 2018 года - от первого в мире NFT билета на концерт до работы с Deadmau5 по выпуску миллиона NFT. Но мы постоянно сталкивались с двумя основными препятствиями:


 	Громоздкие кошельки, настройка которых была проблемой
 	Люди не могли многое сделать, потому что у них не было нужных криптовалютных токенов

Давайте будем честны - у большинства людей нет случайных блокчейн-токенов под рукой. Если мы хотим, чтобы обычные люди использовали эту технологию не только для покупок и продаж, нам нужно сделать это намного проще. И вот где на помощь приходят платежные агенты.



	

	
	
		
			
				What is the primary purpose of a paymaster in blockchain technology?
			
		

		
					

		
			
			
			
			To increase the price of cryptocurrency
		
			
			To cover gas fees for users interacting with smart contracts
		
			
			To create new blockchain networks
		
			
			To mine cryptocurrency faster
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Кому это нужно?
Это уже не только для крипто-фанатов. Мы говорим о вещах из реального мира, таких как:


 	Управление организациями (DAO)
 	Продажа билетов на мероприятия
 	Отслеживание цепочки поставок
 	И множество других практических применений


Сложность заключается в привлечении нужных людей. Вы не хотите, чтобы ваши сотрудники, посетители концертов или члены организации прыгали сквозь кольца, чтобы участвовать. Платежные агенты упрощают весь этот процесс.
Настройка проходит легко:


 	Перейдите на сайт платежного агента (мы даже покроем стоимость создания аккаунта!)
 	Выберите, какие функции вы хотите оплатить
 	Пополните его на сколько транзакций вы хотите покрыть
 	Бац! Вы готовы.

Вы можете использовать наш Bitte Wallet для управления платежным агентом или интегрировать его в свое собственное приложение с помощью небольшого кода.
Примеры из реальной жизни
Международный совет по крикету использовал нашего платежного агента, чтобы привлечь 30 000 совершенно новых пользователей во время Чемпионата мира 2024 года. Эти люди никогда не имели дела с блокчейном, но им не составило труда создать учетные записи и зарабатывать награды за следование турниру.



	

	
	
		
			
				In the real-world example provided, how did the International Cricket Council (ICC) use the Bitte Paymaster?
			
		

		
					

		
			
			
			
			To create a new cryptocurrency
		
			
			To onboard 30,000 new users during the 2024 World Cup
		
			
			To sell cricket equipment online
		
			
			To pay players' salaries
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Learn NEAR Club использует Paymaster для удобного привлечения новых пользователей.

https://learnnear.club/wp-content/uploads/2024/09/bitter-wallet-refferal.mp4
Что дальше?
Мы работаем над действительно крутыми вещами:


 	Подписи межцепочечных транзакций: Используйте одну учетную запись для подписи документов на нескольких блокчейнах
 	Покупки на основе ИИ: Представьте себе, что вы говорите ИИ: "Купи две красные сумки с осеннего показа мод и отправь одну моей сестре." Бренд покрывает расходы на транзакцию, и вы получаете безупречный опыт.

Будущее блокчейна заключается в том, чтобы сделать его невидимым для пользователя. Платежные агенты - это огромный шаг в этом направлении, позволяя брендам и организациям сосредоточиться на создании потрясающих впечатлений, не давая технологии встать на пути.

### NEARプロトコルとTON

NEARプロトコルとオープンネットワーク（TON）
NEARとTON（The Open Network）は、暗号エコシステムで最も有望なプロジェクトの2つです。NEARは、アカウントの抽象化や名前付きアカウントなどの組み込み機能を提供するユーザーおよび開発者向けのdApp（分散型アプリケーション）プラットフォームであり、NEAR Collectiveによって構築されました。一方、TONは2018年にTelegramによって作成された分散型のレイヤー1ブロックチェーンですが、すぐに放棄されました。

この記事では、それぞれのプロジェクトについて詳しく調査し、その動作方法、エコシステム、使用方法などを説明します。
NEARとは？
NEARは、スマートコントラクト対応のパブリックProof-of-Stakeブロックチェーンであり、開発者に分散型アプリケーション（dApps）を構築するプラットフォームを提供します。NEAR Collectiveによって構築され、主にEthereumやEOS、Polkadotなどのスマートコントラクト対応ブロックチェーンと競合しています。このプロトコルは、速度、スケーラビリティ、コストにおけるEthereumの欠点を改善することを目指しています。

NEARは、Ethereumよりも速く、安価であり、最大10万トランザクションを処理できます。このプロトコルの信じられないほどのスケーラビリティは、スマートコントラクトや分散型アプリケーションの世界を革命化する可能性があります。NEARプロトコルの設計と機能の中心となるのは、シャーディングと呼ばれる概念です。シャーディングはネットワークのインフラをより小さなセグメントに分割し、ノードがネットワーク全体のトランザクションの一部のみを処理することを可能にします。シャーディングは、ネットワークデータの取得をより効率的に行う方法を作成し、プラットフォームのスケーリングを支援できます。

NEARは、アプリケーションが構築される基盤として機能するAmazon Web Services（AWS）などのデータストレージシステムと比較できます。ただし、重要な違いは、NEARが分散化され、分散ネットワークのコンピュータ（ノード）によって維持されることです。プロトコルのネイティブトークンであるNEARは、トランザクション手数料やストレージの支払いに使用されます。トークン保有者は、トークンをステークし、バリデータの役割を担い、ネットワークのコンセンサスを達成するのに役立ちます。
NEAR Collective
NEAR Collectiveは、NEAR Protocolの背後にあるエンティティであり、常にその改善に取り組んでいる個々の組織や他の貢献者で構成されています。この組織はプロジェクトに取り組み、初期のコードを書き、NEAR上での実装を支援しています。NEAR Collectiveは、開発やガバナンス活動にも協力しています。NEAR CollectiveがNEARを開発していますが、プロトコルは完全に分散化されています。独立して運営され、シャットダウンや操作を受けることはありません。
NEARプロトコルの動作方法
NEARプロトコルはProof-of-Stakeブロックチェーンです。Proof-of-Stakeメカニズムは、トークン保有者が一定数のトークンをステークしてブロックを検証する資格を得る必要があります。プロトコルの機能の中心となるのは、そのコンセンサスアルゴリズムであるNightshadeです。
NightshadeNightshadeはNEAR Protocolのシャーディングソリューションであり、NEARが計算ワークロードを管理可能なチャンクに分散させることを可能にします。Nightshadeのおかげで、各参加ノードはプラットフォームのデータの小さなサブセットのみを保存する必要があります。その後、ノードはこれらの情報の「チャンク」を処理し、それらをメインチェーンに追加できます。

Nightshadeの主な利点の1つは、潜在的な障害の数を大幅に減らすことです。これは、各ノードがわずかなデータのみを担当し、チェーンの一部を維持するため、効率が大幅に向上するためです。

ValidatorsもNEARで重要な役割を果たし、プロトコル内でコンセンサスを維持する責任があります。彼らは常にサーバーをオンラインに保ち、システムを更新する必要があります。バリデータは毎回の新しいエポックで決定され、ステークに基づいて選出されます。選出されたバリデータは、トークンと獲得した報酬を再ステークすることで再選出されることができます。一方、潜在的なバリデータは、所定のレベル以上のステークを持っている必要があります。

NEARアカウントとは何ですか？
前述のように、NEARは人間が読みやすいアドレスをサポートしています。NEARアカウントには2種類あります：暗黙のアドレスと名前付きアドレス。

暗黙のアドレス
暗黙のアドレスアカウントは、公開/秘密キーペアに対応する64文字のアドレスで示されます。このタイプのアカウントを使用するには、ユーザーはNEARトークンでそれを資金提供するか、トランザクションのガス料金を支払う必要があります。

名前付きアドレス
NEARは、共有や記憶がはるかに簡単な名前付きアカウントを登録することも可能です。名前付きアカウントはサブアカウントを作成することもでき、実質的にドメインとして機能します。

TONとは何ですか？
TON（Toncoin）は元々Telegramによって2018年に構築されました。創設時にTelegramは、Ethereumの競合として意図された新しいブロックチェーンに対して17億ドルの民間資金を調達しました。しかし、米国証券取引委員会が介入し、そのネイティブトークンである$TONが証券であると主張して訴訟を起こした後、プロジェクトを放棄しました。Telegramがプロジェクトを放棄した後、Telegramとは無関係の開発者によって引き継がれ、ton.orgドメイン名とToncoinコードリポジトリを引き継ぎました。その後、ToncoinはTONブロックチェーンとTONトークンを立ち上げました。

TONは、金融アプリケーションやNFT向けに作成された分散型Layer1スマートコントラクトネットワークです。これまでに100万以上のNFTが作成されています。NEARと同様に、TONは高度にスケーラブルなネットワークを提供するProof-of-Stakeブロックチェーンであり、金融取引に最適です。また、ユーザー間のやり取りを不変の金融インフラストラクチャ上で容易に行うことができます。TONブロックチェーンは、そのスケーラビリティと高性能で際立っています。独自のマルチレベルアーキテクチャを採用し、メインチェーンと複数のワードチェーンを組み合わせることで、1秒あたり55,000トランザクションを処理したという記録を作り出しました。Proof-of-Stake Consensus 
コンセンサスは、ネットワーク上のノードがネットワークの現在の状態と有効な状態に合意する方法です。TONは省エネのProof-of-Stakeコンセンサスメカニズムを使用しています。バリデータはトークンをステークし、ネットワークのセキュリティを確保するための貢献に対する報酬を受け取ることができます。執筆時点では、TONには329人のバリデータがおり、511,880,772ドルのTONがステークされています。バリデータは、検証するブロックごとにTONトークンを受け取ります。TONのブロック-Proof-of-Stakeは、すべてのバリデータがコンセンサスに参加できなくてもネットワークが継続して稼働することを保証します。
Sharding 
シャーディングは、ブロックチェーンのスケーラビリティを向上させるのに役立ち、NEARでも使用されています。シャーディングはTONをシャードと呼ばれるより小さなコンポーネントに分割します。各シャードには特定の役割が割り当てられ、ブロックチェーンがグローバルな状態を維持するのに役立ちます。グローバルな状態を維持することで、ネットワークノードがすべてのトランザクションを処理する必要がなくなり、より効率的になります。
The TON Virtual Machine (TVM)
TON仮想マシンは、イーサリアム仮想マシンと同様の役割を果たし、契約アプリケーションからのコマンドを計算し、各実行後にネットワークの状態を変更します。TVMを通じて、開発者は資産の鋳造、資産の転送、ネットワーク上でのメッセージの署名など、さまざまなプロセスを自動化できるアプリケーションを作成できます。
Toncoin 
Toncoin（$TON）はTONのネイティブ暗号通貨であり、TONエコシステムで複数の用途があります。このトークンはトランザクション手数料、ステーキング、およびプロトコルのガバナンスに使用されます。
Transaction Fees 
$TONトークンはTONネットワーク上の取引の支払いに使用されます。ユーザーはトークンを使用して取引を処理したり、ガス料金を支払ったりする必要があります。このトークンは、TONネットワークのストレージやブロックチェーンベースのドメイン名の支払いにも使用されます。
Governance 
$TONトークンはガバナンスにおいて重要な役割を果たします。$TONトークン保有者は提案に投票し、ネットワークの将来に影響を与えることができます。
Staking 
$TONトークン保有者は、バリデータとして機能するためにトークンをステークすることもでき、トランザクションを検証し、ネットワークをセキュアにするのに役立ちます。ユーザーは、トークンをネットワーク上または主要な暗号通貨取引所を通じて直接ステークすることができます。




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Future Plans For NEAR and TON
NEAR - User-Owned AI
NEARは、AI研究とアプリケーションをブロックチェーンエコシステムに統合することで、User-Owned AIを推進しています。NEAR.AI R&D Labは、ユーザーの意図からエンドツーエンドのWeb3アプリケーションを作成するAIを開発することを目指しています。NEARは、大規模なユーザーベース、開発者エコシステム、財務リソースを活用し、トップクラスのAI人材を引き付け、ユーザーやコミュニティをエンパワーする分散型AIインフラストラクチャを構築することを目指しています。
TON - Further Telegram IntegrationsTONCoinの最も興奮すべき点は、Telegram内でのTONの有用性の拡大です。 Telegram創設者パベル・ドゥロフによると、ユーザーはTONで広告料を支払ったり、チャンネル管理者にチップを支払ったりすることができます。近いうちに、ステッカーはNFTとして購入および販売され、アーティストは収益の95%を受け取ります。ユーザーはまた、TONを共有したり、暗号ウォレットを使用してアカウントにログインしたり、アカウント名を登録および販売したりすることができます。
最後に
NEARとTONは、dAppおよびスマートコントラクトの分野を革新した革新的なプラットフォームです。速度、スケーラビリティ、ユーザーおよび開発者向けの使いやすさに焦点を当てたNEARは、Ethereumにとっての有力な代替手段として台頭しています。一方、TONは急速に投資家や開発者を引き付けています。そのTelegram統合により、ネットワークは7億人以上の潜在的なユーザーにアクセスできます。
今すぐ投票！

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Paymaster: Membuka Adopsi Massal NEAR

Mari kita bicarakan mengapa paymasters adalah perubahan permainan untuk melibatkan orang dalam teknologi blockchain.
Jadi, apa hubungannya dengan paymasters?
Bayangkan Anda sedang mengadakan pesta, tetapi semua orang memerlukan tiket khusus untuk masuk. Itu semacam bagaimana blockchain bekerja - Anda memerlukan kripto untuk melakukan apapun. Tetapi bagaimana jika Anda bisa membayar biaya masuk untuk tamu Anda? Itulah persisnya apa yang dilakukan oleh seorang paymaster! Ini memungkinkan Anda membayar "biaya gas" sehingga orang dapat berinteraksi dengan barang-barang blockchain Anda tanpa perlu memiliki kripto mereka sendiri.

Mengapa ini begitu penting?
Nah, kami telah melakukan proyek blockchain keren sejak 2018 - mulai dari tiket konser NFT pertama hingga bekerja dengan Deadmau5 untuk mencetak sejuta NFT. Tetapi kami terus menghadapi dua hambatan utama:


 	Dompet yang kuno yang merepotkan untuk diatur
 	Orang tidak bisa melakukan banyak hal karena mereka tidak memiliki token kripto yang tepat

Mari kita hadapi kenyataannya - kebanyakan orang tidak memiliki token blockchain acak di sekitar mereka. Jika kita ingin orang biasa menggunakan teknologi ini untuk lebih dari sekadar membeli dan menjual, kita perlu membuatnya jauh lebih mudah. Di sinilah peran paymasters sangat penting.



	

	
	
		
			
				What is the primary purpose of a paymaster in blockchain technology?
			
		

		
					

		
			
			
			
			To increase the price of cryptocurrency
		
			
			To cover gas fees for users interacting with smart contracts
		
			
			To create new blockchain networks
		
			
			To mine cryptocurrency faster
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Siapa yang membutuhkan ini?
Ini bukan hanya untuk para ahli kripto lagi. Kami berbicara tentang hal-hal dunia nyata seperti:


 	Mengelola organisasi (DAOs)
 	Penjualan tiket acara
 	Pelacakan rantai pasokan
 	Dan banyak penggunaan praktis lainnya


Bagian sulitnya adalah melibatkan orang yang tepat. Anda tidak ingin karyawan, pengunjung konser, atau anggota organisasi Anda harus melompat-lompat hanya untuk berpartisipasi. Paymasters melancarkan seluruh proses tersebut.
Mengaturnya sangat mudah:


 	Menuju situs Paymaster (kami bahkan akan menutupi biaya pembuatan akun!)
 	Pilih fungsi mana yang ingin Anda bayar
 	Dana itu dengan berapa banyak transaksi yang ingin Anda cover
 	Boom! Anda selesai.

Anda dapat menggunakan Bitte Wallet kami untuk menjalankan paymaster atau mengintegrasikannya ke dalam aplikasi Anda sendiri dengan sedikit kode.
Contoh dunia nyata
International Cricket Council menggunakan paymaster kami untuk melibatkan 30.000 pengguna baru selama Piala Dunia 2024. Mereka ini belum pernah menyentuh blockchain sebelumnya, tetapi tidak mengalami kesulitan dalam membuat akun dan mendapatkan imbalan atas mengikuti turnamen.



	

	
	
		
			
				In the real-world example provided, how did the International Cricket Council (ICC) use the Bitte Paymaster?
			
		

		
					

		
			
			
			
			To create a new cryptocurrency
		
			
			To onboard 30,000 new users during the 2024 World Cup
		
			
			To sell cricket equipment online
		
			
			To pay players' salaries
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Learn NEAR Club menggunakan Paymaster untuk memudahkan pengguna baru.

https://learnnear.club/wp-content/uploads/2024/09/bitter-wallet-refferal.mp4
Apa yang akan datang?
Kami sedang mengerjakan beberapa hal yang sangat keren:


 	Tanda tangan lintas rantai: Gunakan satu akun untuk menandatangani hal-hal di beberapa blockchain
 	Belanja berbasis AI: Bayangkan memberi tahu AI, "Beli dua tas merah dari pertunjukan mode musim gugur dan kirim satu ke adik saya." Merek menutupi biaya transaksi, dan Anda mendapatkan pengalaman yang mulus.

Masa depan blockchain adalah tentang membuatnya tidak terlihat oleh pengguna. Paymaster adalah langkah besar dalam arah tersebut, memungkinkan merek dan organisasi fokus pada menciptakan pengalaman yang luar biasa tanpa teknologi menghalangi.

### Protocolo NEAR e TON

NEAR Protocol E A Rede Aberta (TON)
NEAR e TON (The Open Network) são dois dos projetos mais promissores no ecossistema cripto. NEAR oferece aos usuários recursos integrados que incluem abstração de conta e contas nomeadas. A plataforma dApp (aplicativo descentralizado) focada na facilidade de uso para usuários e desenvolvedores foi construída pelo NEAR Collective. Por outro lado, TON é uma blockchain descentralizada de camada 1 criada pelo Telegram em 2018. No entanto, foi abandonada pouco depois.

Este artigo examinará cada projeto em mais detalhes, incluindo como funciona, seu ecossistema, usos e mais.
O que é NEAR?
NEAR é uma blockchain pública Proof-of-Stake capaz de contratos inteligentes que fornece aos desenvolvedores uma plataforma para construir aplicativos descentralizados (dApps). Construído pelo NEAR Collective, ele compete principalmente com Ethereum e outras blockchains habilitadas para contratos inteligentes como EOS e Polkadot. O protocolo visa melhorar as deficiências do Ethereum em velocidade, escalabilidade e custo.

NEAR é mais rápido e mais barato que o Ethereum, processando até 100.000 transações por segundo. A incrível escalabilidade do protocolo tem o potencial de revolucionar o mundo dos contratos inteligentes e aplicativos descentralizados. Fundamental para o design e funcionamento do Protocolo NEAR é um conceito chamado sharding. Sharding divide a infraestrutura de uma rede em segmentos menores, permitindo que os nós lidem apenas com uma fração das transações totais da rede. O sharding pode criar uma maneira mais eficiente de recuperar dados da rede e ajudar a escalar a plataforma.

NEAR pode ser comparado a sistemas de armazenamento de dados como Amazon Web Services (AWS), que atuam como a camada base sobre a qual os aplicativos são construídos. No entanto, a diferença crítica é que o NEAR é descentralizado e mantido por uma rede distribuída de computadores (nós). O token nativo do protocolo, NEAR, é usado para pagar taxas de transação e armazenamento. Os detentores de tokens também podem apostar seus tokens, assumindo o papel de validadores e ajudando a rede a alcançar consenso.
O NEAR Collective
O NEAR Collective é a entidade por trás do Protocolo NEAR e é composto por organizações individuais e outros contribuintes que trabalham constantemente para melhorá-lo. A organização trabalha em projetos, escrevendo seu código inicial e ajudando em sua implementação no NEAR. O NEAR Collective também ajuda em atividades de desenvolvimento e governança. Embora o NEAR Collective tenha desenvolvido o NEAR, o protocolo é totalmente descentralizado. Ele opera de forma independente e não pode ser desligado ou manipulado.
Como funciona o Protocolo NEAR?
O Protocolo NEAR é uma blockchain Proof-of-Stake. O mecanismo Proof-of-Stake requer que os detentores de tokens apostem um certo número de tokens para serem elegíveis para validar blocos. Fundamental para o funcionamento do protocolo está seu algoritmo de consenso - Nightshade.
NightshadeNightshade é a solução de fragmentação do Protocolo NEAR, que permite ao NEAR distribuir a carga computacional em pedaços gerenciáveis. Graças ao Nightshade, cada nó participante só precisa armazenar um pequeno subconjunto dos dados da plataforma. Os nós podem então processar esses 'pedaços' de informação e adicioná-los à cadeia principal.

Um dos principais benefícios do Nightshade é que ele reduz significativamente o número de potenciais pontos de falha. Isso ocorre porque cada nó é responsável apenas por uma pequena quantidade de dados e mantém apenas uma pequena parte da cadeia, aumentando muito a eficiência.

Os validadores também desempenham um papel crucial no NEAR e são responsáveis por manter o consenso dentro do protocolo. Eles devem manter seus servidores online o tempo todo e seus sistemas atualizados. Os validadores são determinados a cada nova época e são eleitos com base em sua participação. Os validadores que já foram eleitos podem ser reeleitos ao reinvestir seus tokens e recompensas acumuladas. Enquanto isso, qualquer potencial validador deve ter sua participação acima de um nível predeterminado.

O TON (Toncoin) foi originalmente construído pelo Telegram em 2018. Na época de sua criação, o Telegram arrecadou US$ 1,7 bilhão em financiamento privado para sua nova blockchain, destinada a ser uma concorrente do Ethereum. No entanto, abandonou o projeto depois que a Comissão de Valores Mobiliários dos Estados Unidos entrou em cena e processou, alegando que o $TON, seu token nativo, era um título. Depois que o Telegram abandonou o projeto, foi assumido por desenvolvedores não afiliados ao Telegram, assumindo o nome de domínio ton.org e o repositório de código Toncoin. Toncoin então lançou a blockchain TON e o token TON.

TON é uma rede de contratos inteligentes descentralizada de Layer1 criada para aplicações financeiras e NFTs. Até agora, mais de um milhão de NFTs foram criados. Assim como o NEAR, o TON é uma blockchain de Prova de Participação que oferece uma rede altamente escalável ideal para transações financeiras. Também facilita as interações entre usuários em uma infraestrutura financeira imutável. A blockchain TON se destaca por sua escalabilidade e alto desempenho. Ela criou um recorde quando processou 55.000 transações por segundo, o que foi possível graças à sua arquitetura única de vários níveis, combinando a cadeia principal com várias outras cadeias de palavras.Prova de Participação no Consenso
O consenso é como os nós na rede concordam com o estado atual e válido da rede. TON usa o mecanismo de consenso de Prova de Participação eficiente em energia. Os validadores podem apostar seus tokens e ganhar recompensas por sua contribuição para garantir a rede. No momento da escrita, TON tem 329 validadores e 511.880.772 $TON apostados. Os validadores recebem tokens $TON para cada bloco que validam. A Prova de Participação por Bloco da TON garante que a rede continue funcionando mesmo que todos os validadores não possam participar do consenso.
Sharding
O Sharding ajuda a aumentar a escalabilidade do blockchain e também é usado pela NEAR. O Sharding divide a TON em componentes menores chamados shards. Cada shard é atribuído a um papel específico, ajudando o blockchain a manter um estado global. Manter um estado global ajuda a eliminar a necessidade de os nós da rede processarem todas as transações, trazendo maior eficiência.
A Máquina Virtual TON (TVM)
A Máquina Virtual TON desempenha um papel semelhante ao da Máquina Virtual Ethereum, computando comandos de aplicativos de contrato e alterando o estado da rede após cada execução. Através da TVM, os desenvolvedores podem criar aplicativos que automatizam vários processos, como cunhagem de ativos, transferência de ativos e assinatura de mensagens na rede.
Toncoin
Toncoin ($TON) é a criptomoeda nativa da TON e tem múltiplos usos no ecossistema da TON. O token é usado para pagar taxas de transação, apostar e governança de protocolo.
Taxas de Transação
O token $TON é usado para pagar transações na Rede TON. Os usuários devem usar os tokens para processar transações ou pagar taxas de gás. O token também é usado para pagar pelo armazenamento na Rede TON e por nomes de domínio baseados em blockchain.
Governança
O token $TON desempenha um papel crucial na governança. Os detentores de tokens $TON podem votar em propostas e ter voz no futuro da rede.
Apostar
Os detentores de tokens $TON também podem apostar seus tokens, atuando como validadores, ajudando a validar transações e garantir a rede. Os usuários podem apostar seus tokens diretamente na rede ou através de grandes exchanges de criptomoedas.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planos Futuros Para NEAR e TON
NEAR - IA de Propriedade do Usuário
NEAR está avançando com a IA de Propriedade do Usuário integrando pesquisa e aplicativos de IA em seu ecossistema blockchain. O Laboratório de P&D NEAR.AI visa desenvolver IA que cria aplicativos Web3 de ponta a ponta a partir de intenções do usuário. Ao alavancar sua grande base de usuários, ecossistema de desenvolvedores e recursos financeiros, a NEAR busca atrair os melhores talentos em IA e construir uma infraestrutura de IA descentralizada que capacita usuários e comunidades.
TON - Mais Integrações com o TelegramA expansão da utilidade da TON dentro do Telegram é, sem dúvida, a coisa mais emocionante sobre a TONCoin. Segundo o Telegram Founder Pavel Durov, os usuários poderão pagar por publicidade em TON e dar gorjetas aos administradores de canais. Em breve, adesivos poderão ser comprados e vendidos como NFTs, com os artistas recebendo 95% dos lucros. Os usuários também poderão compartilhar TON, fazer login em contas usando carteiras de criptomoedas e registrar e vender nomes de contas.

Em Encerramento
NEAR e TON são plataformas inovadoras que revolucionaram o cenário de dApps e contratos inteligentes. Com seu foco em velocidade, escalabilidade e facilidade de uso para desenvolvedores e usuários, a NEAR emergiu como uma alternativa digna ao Ethereum. Enquanto isso, a TON está rapidamente atraindo investidores e desenvolvedores. Sua integração com o Telegram também dá à rede acesso a mais de 700 milhões de usuários em potencial.

Vote AGORA!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### NEAR Protocol Dan TON

NEAR Protocol Dan Jaringan Terbuka (TON)
NEAR dan TON (The Open Network) adalah dua proyek paling menjanjikan dalam ekosistem kripto. NEAR menawarkan fitur bawaan kepada pengguna yang mencakup abstraksi akun dan akun bernama. Platform dApp (aplikasi terdesentralisasi) yang difokuskan pada kenyamanan pengguna dan pengembang dan dibangun oleh NEAR Collective. Di sisi lain, TON adalah blockchain lapisan-1 terdesentralisasi yang dibuat oleh Telegram pada tahun 2018. Namun, proyek ini ditinggalkan tidak lama setelahnya.

Artikel ini akan menguji setiap proyek secara lebih detail, termasuk bagaimana cara kerjanya, ekosistemnya, penggunaannya, dan lainnya.
Apa itu NEAR?
NEAR adalah blockchain Proof-of-Stake publik yang mampu kontrak pintar yang memberikan platform kepada pengembang untuk membangun aplikasi terdesentralisasi (dApps). Dibangun oleh NEAR Collective, NEAR bersaing utamanya dengan Ethereum dan blockchain lain yang memungkinkan kontrak pintar seperti EOS dan Polkadot. Protokol ini bertujuan untuk memperbaiki kekurangan Ethereum dalam hal kecepatan, skalabilitas, dan biaya.

NEAR lebih cepat dan lebih murah daripada Ethereum, memproses hingga 100.000 transaksi per detik. Skalabilitas luar biasa protokol ini memiliki potensi untuk merevolusi dunia kontrak pintar dan aplikasi terdesentralisasi. Kunci desain dan cara kerja NEAR Protocol adalah konsep yang disebut sharding. Sharding membagi infrastruktur jaringan menjadi segmen-segmen lebih kecil, memungkinkan node untuk menangani hanya sebagian kecil dari total transaksi jaringan. Sharding dapat menciptakan cara yang lebih efisien untuk mengambil data jaringan dan membantu dalam penskalaan platform.

NEAR dapat dibandingkan dengan sistem penyimpanan data seperti Amazon Web Services (AWS), yang bertindak sebagai lapisan dasar di mana aplikasi dibangun. Namun, perbedaan kritisnya adalah bahwa NEAR terdesentralisasi dan dipelihara oleh jaringan terdistribusi komputer (node). Token asli protokol, NEAR, digunakan untuk membayar biaya transaksi dan penyimpanan. Pemegang token juga dapat melakukan staking token mereka, mengasumsikan peran validator dan membantu jaringan mencapai konsensus.
NEAR Collective
NEAR Collective adalah entitas di balik NEAR Protocol dan terdiri dari organisasi-individu dan kontributor lain yang terus bekerja untuk memperbaikinya. Organisasi ini bekerja pada proyek-proyek, menulis kode awal mereka dan membantu dalam implementasinya di NEAR. NEAR Collective juga membantu dalam aktivitas pengembangan dan tata kelola. Meskipun NEAR Collective telah mengembangkan NEAR, protokol ini sepenuhnya terdesentralisasi. Ia beroperasi secara independen dan tidak dapat dimatikan atau dimanipulasi.
Bagaimana NEAR Protocol Bekerja?
NEAR Protocol adalah blockchain Proof-of-Stake. Mekanisme Proof-of-Stake mengharuskan pemegang token untuk melakukan staking sejumlah token tertentu untuk memenuhi syarat sebagai validator blok. Kunci dalam fungsi protokol ini adalah algoritma konsensusnya - Nightshade.
NightshadeNightshade adalah solusi sharding NEAR Protocol, yang memungkinkan NEAR untuk mendistribusikan beban komputasi ke dalam bagian yang dapat dikelola. Berkat Nightshade, setiap node yang berpartisipasi hanya perlu menyimpan subset kecil data platform. Node-node tersebut kemudian dapat memproses 'chunk' informasi ini dan menambahkannya ke rantai utama.

Salah satu manfaat utama Nightshade adalah bahwa ini secara signifikan mengurangi jumlah titik kegagalan potensial. Hal ini karena setiap node bertanggung jawab hanya atas sejumlah kecil data dan hanya mempertahankan sebagian kecil dari rantai, meningkatkan efisiensi secara signifikan.

Validators juga memainkan peran penting di NEAR dan bertanggung jawab untuk mempertahankan konsensus dalam protokol. Mereka harus menjaga server mereka online setiap saat dan sistem mereka diperbarui. Validators ditentukan setiap epoch baru dan dipilih berdasarkan stake mereka. Validators yang sudah terpilih dapat dipilih kembali dengan me-re-stake token dan hadiah yang terakumulasi. Sementara itu, calon validator potensial harus memiliki stake di atas level yang telah ditentukan.

Akar-akar juga memainkan peran penting di NEAR dan bertanggung jawab untuk mempertahankan konsensus dalam protokol. Mereka harus menjaga server mereka online setiap saat dan sistem mereka diperbarui. Validators ditentukan setiap epoch baru dan dipilih berdasarkan stake mereka. Validators yang sudah terpilih dapat dipilih kembali dengan me-re-stake token dan hadiah yang terakumulasi. Sementara itu, calon validator potensial harus memiliki stake di atas level yang telah ditentukan.

NEAR juga memungkinkan pengguna untuk mendaftar akun bernama yang jauh lebih sederhana untuk dibagikan dan diingat. Akun bernama juga dapat membuat sub-akun, bertindak efektif sebagai domain.

TON (Toncoin) awalnya dibangun oleh Telegram pada tahun 2018. Pada saat penciptaannya, Telegram mengumpulkan $1,7 miliar dalam pendanaan pribadi untuk blockchain baru mereka, yang dimaksudkan sebagai pesaing Ethereum. Namun, mereka meninggalkan proyek tersebut setelah Komisi Sekuritas dan Bursa Amerika Serikat masuk dan menggugat, dengan tuduhan bahwa $TON, token aslinya, adalah sekuritas. Setelah Telegram meninggalkan proyek tersebut, proyek tersebut diambil oleh pengembang yang tidak berafiliasi dengan Telegram, mengambil alih nama domain ton.org dan repositori kode Toncoin. Toncoin kemudian meluncurkan blockchain TON dan token TON.

TON adalah jaringan kontrak pintar Layer1 terdesentralisasi yang dibuat untuk aplikasi keuangan dan NFT. Sejauh ini, lebih dari satu juta NFT telah diciptakan. Seperti NEAR, TON adalah blockchain Proof-of-Stake yang memberikan jaringan yang sangat scalable yang ideal untuk transaksi keuangan. Ini juga memfasilitasi interaksi antara pengguna melalui infrastruktur keuangan yang tidak dapat diubah. Blockchain TON menonjol karena skalabilitas dan kinerja tinggi. Ini menciptakan rekor ketika memproses 55.000 transaksi per detik, yang dimungkinkan oleh arsitektur multi-level uniknya, yang menggabungkan rantai utama dengan beberapa rantai kata lainnya.

Empat aspek penting untuk fungsi TON: konsensus proof-of-stake, Sharding, Mesin Virtual TON, dan token aslinya, Toncoin.Konsensus Proof-of-Stake 
Konsensus adalah bagaimana node-node di jaringan setuju pada keadaan jaringan yang sah dan terkini. TON menggunakan mekanisme konsensus Proof-of-Stake yang hemat energi. Validator dapat melakukan staking token mereka dan mendapatkan imbalan atas kontribusi mereka dalam mengamankan jaringan. Saat ini, TON memiliki 329 validator dan 511,880,772 $TON yang distake. Validator menerima token $TON untuk setiap blok yang mereka validasi. Proof-of-Stake Blok TON memastikan bahwa jaringan tetap berjalan meskipun semua validator tidak dapat berpartisipasi dalam konsensus.
Sharding 
Sharding membantu meningkatkan skalabilitas blockchain dan juga digunakan oleh NEAR. Sharding membagi TON menjadi komponen-komponen kecil yang disebut shards. Setiap shard diberikan peran tertentu, membantu blockchain mempertahankan keadaan global. Memelihara keadaan global membantu menghilangkan kebutuhan node jaringan untuk memproses setiap transaksi, membawa efisiensi yang lebih besar.
Mesin Virtual TON (TVM)
Mesin Virtual TON memainkan peran yang mirip dengan Mesin Virtual Ethereum, menghitung perintah dari aplikasi kontrak dan mengubah keadaan jaringan setelah setiap eksekusi. Melalui TVM, pengembang dapat membuat aplikasi yang dapat mengotomatisasi berbagai proses, seperti pencetakan aset, transfer aset, dan penandatanganan pesan di jaringan.
Toncoin 
Toncoin ($TON) adalah cryptocurrency asli TON dan memiliki berbagai penggunaan dalam ekosistem TON. Token ini digunakan untuk membayar biaya transaksi, staking, dan tata kelola protokol.
Biaya Transaksi 
Token $TON digunakan untuk membayar transaksi di Jaringan TON. Pengguna harus menggunakan token tersebut untuk memproses transaksi atau membayar biaya gas. Token ini juga digunakan untuk membayar penyimpanan Jaringan TON dan nama domain berbasis blockchain.
Tata Kelola 
Token $TON memainkan peran penting dalam tata kelola. Pemegang token $TON dapat memberikan suara pada proposal dan memiliki kata dalam masa depan jaringan.
Staking 
Pemegang token $TON juga dapat melakukan staking token mereka, bertindak sebagai validator, membantu memvalidasi transaksi dan mengamankan jaringan. Pengguna dapat melakukan staking token mereka langsung di jaringan atau melalui bursa cryptocurrency besar.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Rencana Masa Depan Untuk NEAR dan TON
NEAR - AI Dimiliki Pengguna
NEAR sedang memajukan AI Dimiliki Pengguna dengan mengintegrasikan penelitian dan aplikasi AI ke dalam ekosistem blockchain-nya. Laboratorium R&D NEAR.AI bertujuan untuk mengembangkan AI yang menciptakan aplikasi Web3 end-to-end dari niat pengguna. Dengan memanfaatkan basis pengguna besar, ekosistem pengembang, dan sumber daya keuangan, NEAR berusaha menarik bakat AI terbaik dan membangun infrastruktur AI terdesentralisasi yang memberdayakan pengguna dan komunitas.
TON - Integrasi Telegram Lebih LanjutPerluasan utilitas TON dalam Telegram tanpa ragu adalah hal paling menarik tentang TONCoin. Menurut Pendiri Telegram Pavel Durov, pengguna akan dapat membayar iklan dengan TON dan memberi tip kepada administrator saluran. Segera, stiker dapat dibeli dan dijual sebagai NFT, dengan seniman menerima 95% dari hasil penjualan. Pengguna juga akan dapat berbagi TON, masuk ke akun menggunakan dompet kripto, dan mendaftar dan menjual nama akun.
Penutup
NEAR dan TON adalah platform inovatif yang telah merevolusi lanskap dApp dan smart contract. Dengan fokusnya pada kecepatan, skalabilitas, dan kemudahan pengembang-pengguna, NEAR telah muncul sebagai alternatif yang layak untuk Ethereum. Sementara itu, TON dengan cepat menarik investor dan pengembang. Integrasi Telegram-nya juga memberikan akses jaringan kepada lebih dari 700 juta pengguna potensial.
Vote SEKARANG!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Paymaster: Mở khóa Sự thông dụng hàng loạt của NEAR

Hãy nói về lý do tại sao các paymasters là yếu tố quyết định trong việc kích thích mọi người tham gia vào công nghệ blockchain.
Vậy, paymasters là gì?
Hãy tưởng tượng bạn đang tổ chức một bữa tiệc, nhưng mọi người cần một vé đặc biệt để vào trong. Đó là cách mà blockchain hoạt động - bạn cần tiền điện tử để làm bất cứ điều gì. Nhưng nếu bạn có thể trả tiền cho phí vào cửa cho khách mời của mình? Đó chính xác là điều mà một paymaster làm! Nó cho phép bạn trả tiền cho "phí gas" để mọi người có thể tương tác với các thứ trên blockchain của bạn mà không cần bất kỳ tiền điện tử nào.

Tại sao điều này lại quan trọng đến vậy?
Chúng tôi đã thực hiện các dự án blockchain cool từ năm 2018 - từ vé concert NFT đầu tiên cho đến làm việc với Deadmau5 để tạo ra một triệu NFT. Nhưng chúng tôi luôn gặp phải hai trở ngại lớn:


 	Ví không tiện lợi khi thiết lập
 	Mọi người không thể làm gì nhiều vì họ không có các loại token tiền điện tử phù hợp

Hãy đối mặt với sự thật - hầu hết mọi người không có các loại token blockchain ngẫu nhiên. Nếu chúng ta muốn người thông thường sử dụng công nghệ này không chỉ để mua bán, chúng ta cần làm cho nó dễ dàng hơn nhiều. Đó là lý do paymasters trở nên quan trọng.



	

	
	
		
			
				What is the primary purpose of a paymaster in blockchain technology?
			
		

		
					

		
			
			
			
			To increase the price of cryptocurrency
		
			
			To cover gas fees for users interacting with smart contracts
		
			
			To create new blockchain networks
		
			
			To mine cryptocurrency faster
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ai cần điều này?
Điều này không chỉ dành cho những người đam mê tiền điện tử nữa. Chúng ta đang nói về các vấn đề thực tế như:


 	Quản lý tổ chức (DAOs)
 	Bán vé sự kiện
 	Theo dõi chuỗi cung ứng
 	Và hàng loạt các ứng dụng thực tế khác


Phần khó khăn là thu hút những người phù hợp. Bạn không muốn nhân viên, người tham dự concert, hoặc thành viên tổ chức phải vượt qua nhiều rào cản để tham gia. Paymasters giúp làm mịn quá trình đó.
Thiết lập nó rất dễ dàng:


 	Truy cập trang web Paymaster (chúng tôi sẽ thậm chí chi trả chi phí tạo tài khoản!)
 	Chọn các chức năng bạn muốn trả tiền
 	Nạp tiền với số lượng giao dịch bạn muốn bao phủ
 	Boom! Bạn đã xong.

Bạn có thể sử dụng Bitte Wallet của chúng tôi để chạy paymaster hoặc tích hợp nó vào ứng dụng của bạn với một chút mã.
Ví dụ thực tế
Hội đồng Cricket Quốc tế đã sử dụng paymaster của chúng tôi để thu hút 30.000 người dùng mới tham gia vào World Cup 2024. Những người này chưa bao giờ tiếp xúc với blockchain trước đó, nhưng họ không gặp khó khăn khi tạo tài khoản và kiếm phần thưởng theo dõi giải đấu.



	

	
	
		
			
				In the real-world example provided, how did the International Cricket Council (ICC) use the Bitte Paymaster?
			
		

		
					

		
			
			
			
			To create a new cryptocurrency
		
			
			To onboard 30,000 new users during the 2024 World Cup
		
			
			To sell cricket equipment online
		
			
			To pay players' salaries
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Learn NEAR Club sử dụng Paymaster để dễ dàng đưa người dùng mới vào hệ thống.

https://learnnear.club/wp-content/uploads/2024/09/bitter-wallet-refferal.mp4
Tiếp theo là gì?
Chúng tôi đang làm việc trên những dự án cực kỳ cool:


 	Chữ ký chéo chuỗi: Sử dụng một tài khoản để ký các giao dịch trên nhiều blockchain
 	Mua sắm dựa trên trí tuệ nhân tạo: Hãy tưởng tượng nói với một trí tuệ nhân tạo, "Mua hai chiếc túi màu đỏ từ show thời trang mùa thu và gửi một chiếc cho chị tôi." Thương hiệu sẽ chi trả các chi phí giao dịch, và bạn sẽ có trải nghiệm mượt mà.

Tương lai của blockchain hoàn toàn xoay quanh việc làm cho nó trở nên vô hình với người dùng. Paymasters là một bước quan trọng trong hướng đó, giúp các thương hiệu và tổ chức tập trung vào việc tạo ra trải nghiệm tuyệt vời mà không bị công nghệ cản trở.

### Paymaster: Unlocking NEAR Mass Adoption

Let's talk about why paymasters are a game-changer for getting people involved with blockchain tech.
So, what's the deal with paymasters?
Imagine you're throwing a party, but everyone needs a special ticket to get in. That's kind of how blockchain works - you need crypto to do anything. But what if you could cover the entry fee for your guests? That's exactly what a paymaster does! It lets you pay for the "gas fees" so people can interact with your blockchain stuff without needing any crypto themselves.

Why is this such a big deal?
Well, we've been doing cool blockchain projects since 2018 - everything from the first-ever NFT concert ticket to working with Deadmau5 to mint a million NFTs. But we kept running into two major roadblocks:


 	Clunky wallets that were a pain to set up
 	People couldn't do much because they didn't have the right crypto tokens

Let's face it - most folks don't have random blockchain tokens lying around. If we want regular people to use this tech for more than just buying and selling, we need to make it way easier. That's where paymasters come in clutch.



	

	
	
		
			
				What is the primary purpose of a paymaster in blockchain technology?
			
		

		
					

		
			
			
			
			To increase the price of cryptocurrency
		
			
			To cover gas fees for users interacting with smart contracts
		
			
			To create new blockchain networks
		
			
			To mine cryptocurrency faster
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Who needs this?
It's not just for crypto nerds anymore. We're talking about real-world stuff like:


 	Managing organizations (DAOs)
 	Event ticketing
 	Supply chain tracking
 	And tons of other practical uses


The tricky part is getting the right people involved. You don't want your employees, concert-goers, or organization members to jump through hoops just to participate. Paymasters smooth out that whole process.
Setting it up is a breeze:


 	Head to the Paymaster site (we'll even cover the account creation cost!)
 	Pick which functions you want to pay for
 	Fund it with however many transactions you want to cover
 	Boom! You're done.

You can either use our Bitte Wallet to run the paymaster or integrate it into your own app with a bit of code.

Real-world examples
The International Cricket Council used our paymaster to get 30,000 brand-new users involved during the 2024 World Cup. These folks had never touched blockchain before, but they had no trouble creating accounts and earning rewards for following the tournament.



	

	
	
		
			
				In the real-world example provided, how did the International Cricket Council (ICC) use the Bitte Paymaster?
			
		

		
					

		
			
			
			
			To create a new cryptocurrency
		
			
			To onboard 30,000 new users during the 2024 World Cup
		
			
			To sell cricket equipment online
		
			
			To pay players' salaries
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Learn NEAR Club uses Paymaster for easy onboarding new users.

https://learnnear.club/wp-content/uploads/2024/09/bitter-wallet-refferal.mp4
What's next?
We're working on some seriously cool stuff:


 	Cross-chain signatures: Use one account to sign stuff on multiple blockchains
 	AI-powered shopping: Imagine telling an AI, "Buy two red bags from the fall fashion show and send one to my sister." The brand covers the transaction costs, and you get a seamless experience.

The future of blockchain is all about making it invisible to the user. Paymasters are a huge step in that direction, letting brands and organizations focus on creating awesome experiences without the tech getting in the way.

### NEAR 프로토콜 및 TON

NEAR 프로토콜과 오픈 네트워크 (TON)
NEAR과 TON (The Open Network)은 암호 생태계에서 가장 유망한 프로젝트 중 두 가지입니다. NEAR은 계정 추상화와 명명된 계정을 포함한 내장 기능을 제공합니다. 사용자 및 개발자 친화적인 dApp (분산 애플리케이션) 플랫폼은 NEAR Collective에 의해 구축되었습니다. 반면에 TON은 2018년 텔레그램에 의해 만들어진 분산형 레이어-1 블록체인입니다. 그러나 그 후 곧바로 버려졌습니다.

이 기사에서는 각 프로젝트를 더 자세히 살펴보고 작동 방식, 생태계, 사용 용도 등을 다룰 것입니다.
NEAR는 무엇인가요?
NEAR은 스마트 계약이 가능한 공개 Proof-of-Stake 블록체인으로, 개발자들에게 분산 애플리케이션 (dApps)을 구축할 수 있는 플랫폼을 제공합니다. NEAR Collective에 의해 구축되었으며, 주로 이더리움 및 EOS, Polkadot과 같은 스마트 계약이 가능한 블록체인과 경쟁합니다. 이 프로토콜은 이더리움의 속도, 확장성 및 비용 부분에서 개선을 목표로 합니다.

NEAR은 이더리움보다 빠르고 저렴하며 초당 최대 100,000개의 트랜잭션을 처리할 수 있습니다. 이 놀라운 확장성을 가진 프로토콜은 스마트 계약 및 분산 애플리케이션의 세계를 혁신할 잠재력이 있습니다. NEAR 프로토콜의 설계 및 작동 방식의 핵심은 샤딩이라는 개념입니다. 샤딩은 네트워크 인프라를 더 작은 세그먼트로 분할하여 노드가 전체 네트워크의 일부 트랜잭션만 처리할 수 있게 합니다. 샤딩은 네트워크 데이터를 더 효율적으로 검색하는 방법을 만들어내고 플랫폼의 확장을 돕습니다.

NEAR은 애플리케이션이 구축되는 기본 레이어로서 아마존 웹 서비스 (AWS)와 비교될 수 있습니다. 그러나 중요한 차이점은 NEAR이 분산화되어 있고 컴퓨터 (노드)의 분산 네트워크에 의해 유지된다는 것입니다. 프로토콜의 네이티브 토큰인 NEAR은 트랜잭션 수수료 및 저장에 사용됩니다. 토큰 보유자는 토큰을 스테이킹하고 네트워크가 합의를 달성하는 데 도움을 주는 발령자 역할을 맡을 수도 있습니다.
NEAR Collective
NEAR Collective는 NEAR 프로토콜의 주체이며, 지속적으로 개선하기 위해 노력하는 개별 조직 및 기여자들로 구성되어 있습니다. 이 조직은 프로젝트에 대해 작업하고 초기 코드를 작성하며 NEAR에서의 구현을 돕습니다. NEAR Collective는 또한 개발 및 거버넌스 활동을 지원합니다. NEAR Collective가 NEAR을 개발했지만 프로토콜은 완전히 분산화되어 있습니다. 독립적으로 운영되며 종료되거나 조작될 수 없습니다.
NEAR 프로토콜은 어떻게 작동하나요?
NEAR 프로토콜은 Proof-of-Stake 블록체인입니다. Proof-of-Stake 메커니즘은 토큰 보유자가 블록을 검증하기 위해 일정 수의 토큰을 스테이킹해야 한다는 것을 요구합니다. 프로토콜의 작동에 중요한 역할을 하는 것은 합의 알고리즘인 Nightshade입니다.
Nightshade나이트샤이드는 NEAR 프로토콜의 샤딩 솔루션으로, NEAR가 계산 작업을 관리 가능한 청크로 분산할 수 있게 합니다. 나이트샤이드 덕분에 각 참여 노드는 플랫폼 데이터의 작은 하위 집합만 저장해야 합니다. 그럼 노드는 이 정보 '청크'를 처리하고 메인 체인에 추가할 수 있습니다.

나이트샤이드의 주요 이점 중 하나는 잠재적인 고장 지점의 수를 크게 줄인다는 것입니다. 이는 각 노드가 작은 양의 데이터만 책임지고 체인의 작은 부분만 유지하기 때문에 효율성이 크게 향상됩니다.




	

	
	
		
			
				What is NEAR’s consensus algorithm?
			
		

		
					

		
			
			
			
			Ouroboros
		
			
			BFT
		
			
			Nightshade
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






밸리데이터도 NEAR에서 중요한 역할을 하며 프로토콜 내에서 합의를 유지하는 책임이 있습니다. 그들은 항상 서버를 온라인 상태로 유지하고 시스템을 업데이트해야 합니다. 밸리데이터는 매 새로운 에포크마다 결정되며 그들의 지분에 따라 선출됩니다. 이미 선출된 밸리데이터는 토큰과 적립된 보상을 재지분하여 재선출될 수 있습니다. 한편 잠재적인 밸리데이터는 지정된 수준 이상의 지분을 가져야 합니다.
NEAR 계정이란?
이전에 언급했듯이 NEAR는 사람이 읽을 수 있는 주소를 지원합니다. NEAR 계정에는 두 가지 유형이 있습니다: 암시적 주소와 명명된 주소.
암시적 주소
암시적 주소 계정은 공개/개인 키 쌍에 해당하는 64자 주소로 표시됩니다. 이 유형의 계정을 사용하려면 사용자는 NEAR 토큰으로 자금을 지불하거나 거래의 가스 수수료를 지불해야 합니다.
명명된 주소
NEAR는 또한 사용자가 공유하고 기억하기 쉬운 명명된 계정을 등록할 수 있습니다. 명명된 계정은 하위 계정을 만들 수도 있어서 사실상 도메인 역할을 합니다.
TON이란?
TON (Toncoin)은 원래 2018년 텔레그램에 의해 만들어졌습니다. 그 당시 텔레그램은 이더리움의 경쟁자로 의도된 새 블록체인을 위해 17억 달러의 사모 자금을 모았습니다. 그러나 미국 증권거래위원회가 개입하여 $TON, 그들의 네이티브 토큰이 증권이라 주장하자 프로젝트를 중단했습니다. 텔레그램이 프로젝트를 중단한 후 텔레그램과 무관한 개발자들이 이를 이어받아 ton.org 도메인 이름과 Toncoin 코드 저장소를 인수했습니다. Toncoin은 그 후 TON 블록체인과 TON 토큰을 출시했습니다.




	

	
	
		
			
				TON is short for:
			
		

		
					

		
			
			
			
			The Open Network
		
			
			Telegram Open Network 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






TON은 금융 애플리케이션과 NFT를 위해 만들어진 탈중앙화된 Layer1 스마트 계약 네트워크입니다. 지금까지 백만 개 이상의 NFT가 발행되었습니다. NEAR와 마찬가지로 TON은 금융 거래에 이상적인 고도로 확장 가능한 네트워크를 제공하는 PoS 블록체인입니다. 또한 사용자 간 불변한 금융 인프라 위에서 상호 작용을 용이하게 합니다. TON 블록체인은 확장성과 고성능으로 두드러집니다. 그 독특한 다중 수준 아키텍처로 인해 초당 55,000 거래를 처리하는 기록을 세웠습니다.Proof-of-Stake Consensus 
합의는 네트워크 노드가 네트워크의 현재 및 유효한 상태에 동의하는 방식입니다. TON은 에너지 효율적인 Proof-of-Stake 합의 메커니즘을 사용합니다. 검증자는 자신의 토큰을 스테이크하고 네트워크를 보호하는 데 기여한 보상을 받을 수 있습니다. 작성 시점에서 TON은 329명의 검증자와 511,880,772 달러의 TON이 스테이크되어 있습니다. 검증자는 검증한 각 블록마다 TON 토큰을 받습니다. TON의 블록-Proof-of-Stake는 모든 검증자가 합의에 참여할 수 없더라도 네트워크가 계속 실행되도록 보장합니다.
샤딩
샤딩은 블록체인 확장성을 높이는 데 도움이 되며 NEAR에서도 사용됩니다. 샤딩은 TON을 샤드라고 불리는 더 작은 구성 요소로 나눕니다. 각 샤드는 특정 역할이 할당되어 블록체인이 전역 상태를 유지하는 데 도움을 줍니다. 전역 상태를 유지함으로써 네트워크 노드가 모든 거래를 처리할 필요가 없어져 더 큰 효율성을 가져옵니다.
TON 가상 머신 (TVM)
TON 가상 머신은 이더리움 가상 머신과 유사한 역할을 하며 계약 응용 프로그램에서 명령을 계산하고 각 실행 후 네트워크 상태를 변경합니다. TVM을 통해 개발자는 자산 발행, 자산 이체 및 네트워크에서 메시지 서명 등 다양한 프로세스를 자동화할 수 있는 응용 프로그램을 만들 수 있습니다.
톤코인
톤코인 ($TON)은 TON의 기본 암호화폐로 TON 생태계에서 여러 용도로 사용됩니다. 이 토큰은 거래 수수료, 스테이킹 및 프로토콜 거버넌스에 사용됩니다.
거래 수수료
$TON 토큰은 TON 네트워크에서 거래를 처리하는 데 사용됩니다. 사용자는 거래를 처리하거나 가스 수수료를 지불하기 위해 이 토큰을 사용해야 합니다. 또한 이 토큰은 TON 네트워크 저장 및 블록체인 기반 도메인 이름 지불에도 사용됩니다.
거버넌스
$TON 토큰은 거버넌스에서 중요한 역할을 합니다. $TON 토큰 소유자는 제안에 투표하고 네트워크의 미래에 영향을 미칠 수 있습니다.
스테이킹
$TON 토큰 소유자는 또한 검증자 역할을 하는 스테이킹을 할 수 있으며 거래를 검증하고 네트워크를 보호하는 데 도움을 줍니다. 사용자는 토큰을 직접 네트워크에 스테이킹하거나 주요 암호화폐 거래소를 통해 스테이킹할 수 있습니다.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR 및 TON의 미래 계획
NEAR - 사용자 소유 AI
NEAR은 AI 연구 및 응용 프로그램을 블록체인 생태계에 통합하여 사용자 소유 AI를 발전시키고 있습니다. NEAR.AI R&D Lab은 사용자 의도에서 끝까지 웹3 응용 프로그램을 만드는 AI를 개발하는 것을 목표로 합니다. NEAR은 대규모 사용자 기반, 개발자 생태계 및 재정 자원을 활용하여 최고의 AI 인재를 유치하고 사용자 및 커뮤니티를 능력을 부여하는 탈중앙화된 AI 인프라를 구축하려고 합니다.
TON - 텔레그램 통합 확대TON의 유틸리티 확장은 텔레그램 내에서 TONCoin에 대한 가장 흥미로운 부분이다. 텔레그램 창업자 파벨 듀로프에 따르면, 사용자들은 TON으로 광고를 지불하고 채널 관리자에게 팁을 줄 수 있을 것이다. 곧 스티커는 NFT로 구매 및 판매될 수 있으며, 아티스트들은 수익의 95%를 받게 된다. 사용자들은 또한 TON을 공유하고, 암호화 지갑을 사용하여 계정에 로그인하고, 계정 이름을 등록하고 판매할 수도 있다.
마무리로
NEAR와 TON은 dApp 및 스마트 계약 분야를 혁신한 혁신적인 플랫폼이다. 속도, 확장성 및 사용자-개발자 친화성에 중점을 둔 NEAR는 이더리움에 대한 합당한 대안으로 등장했다. 한편, TON은 투자자와 개발자들을 신속하게 유치하고 있다. 그리고 텔레그램 통합을 통해 네트워크는 7억 명 이상의 잠재적 사용자에게 접근할 수 있다.
지금 투표하세요!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### NEAR Protocol y TON

NEAR Protocol y la Red Abierta (TON)
NEAR y TON (The Open Network) son dos de los proyectos más prometedores en el ecosistema criptográfico. NEAR ofrece a los usuarios características integradas que incluyen abstracción de cuentas y cuentas con nombre. La plataforma de aplicaciones descentralizadas (dApp) se enfoca en la amigabilidad para el usuario y el desarrollador, y fue construida por el Colectivo NEAR. Por otro lado, TON es una cadena de bloques descentralizada de capa 1 creada por Telegram en 2018. Sin embargo, fue abandonada poco después.

Este artículo examinará cada proyecto en más detalle, incluyendo cómo funciona, su ecosistema, usos y más.
¿Qué es NEAR?
NEAR es una cadena de bloques pública con capacidad para contratos inteligentes basada en Prueba de Participación que proporciona a los desarrolladores una plataforma para construir aplicaciones descentralizadas (dApps). Construido por el Colectivo NEAR, compite principalmente con Ethereum y otras cadenas de bloques habilitadas para contratos inteligentes como EOS y Polkadot. El protocolo tiene como objetivo mejorar las deficiencias de Ethereum en velocidad, escalabilidad y costos.

NEAR es más rápido y más barato que Ethereum, procesando hasta 100,000 transacciones por segundo. La increíble escalabilidad del protocolo tiene el potencial de revolucionar el mundo de los contratos inteligentes y las aplicaciones descentralizadas. Clave para el diseño y funcionamiento del Protocolo NEAR es un concepto llamado fragmentación. La fragmentación divide la infraestructura de una red en segmentos más pequeños, permitiendo que los nodos manejen solo una fracción de las transacciones totales de la red. La fragmentación puede crear una forma más eficiente de recuperar datos de la red y ayudar a escalar la plataforma.

NEAR se puede comparar con sistemas de almacenamiento de datos como Amazon Web Services (AWS), que actúan como la capa base sobre la cual se construyen aplicaciones. Sin embargo, la diferencia crítica es que NEAR es descentralizado y mantenido por una red distribuida de computadoras (nodos). El token nativo del protocolo, NEAR, se utiliza para pagar tarifas de transacción y almacenamiento. Los titulares de tokens también pueden apostar sus tokens, asumiendo el papel de validadores y ayudando a la red a alcanzar consenso.
El Colectivo NEAR
El Colectivo NEAR es la entidad detrás del Protocolo NEAR y está compuesto por organizaciones individuales y otros colaboradores que trabajan constantemente para mejorarlo. La organización trabaja en proyectos, escribiendo su código inicial y ayudando con su implementación en NEAR. El Colectivo NEAR también ayuda en actividades de desarrollo y gobernanza. Si bien el Colectivo NEAR ha desarrollado NEAR, el protocolo es completamente descentralizado. Opera de forma independiente y no puede ser cerrado o manipulado.
¿Cómo funciona el Protocolo NEAR?
El Protocolo NEAR es una cadena de bloques basada en Prueba de Participación. El mecanismo de Prueba de Participación requiere que los titulares de tokens apuesten una cierta cantidad de tokens para ser elegibles para validar bloques. Clave para el funcionamiento del protocolo es su algoritmo de consenso - Nightshade.
NightshadeNightshade es la solución de fragmentación de NEAR Protocol, que permite a NEAR distribuir la carga computacional en partes manejables. Gracias a Nightshade, cada nodo participante solo necesita almacenar un pequeño subconjunto de los datos de la plataforma. Los nodos pueden procesar estos 'fragmentos' de información y agregarlos a la cadena principal.

Uno de los principales beneficios de Nightshade es que reduce significativamente el número de posibles puntos de falla. Esto se debe a que cada nodo es responsable de solo una pequeña cantidad de datos y mantiene solo una pequeña parte de la cadena, lo que aumenta considerablemente la eficiencia.

Los validadores también desempeñan un papel crucial en NEAR y son responsables de mantener el consenso dentro del protocolo. Deben mantener sus servidores en línea en todo momento y sus sistemas actualizados. Los validadores se determinan en cada nueva época y son elegidos en función de su participación. Los validadores que ya han sido elegidos pueden ser reelegidos al volver a apostar sus tokens y recompensas acumuladas. Mientras tanto, cualquier posible validador debe tener su participación por encima de un nivel predeterminado.

¿Qué son las cuentas de NEAR?
Como se mencionó anteriormente, NEAR admite direcciones legibles por humanos. Hay dos tipos de cuentas de NEAR: direcciones implícitas y direcciones con nombre.

Dirección implícita
Las cuentas de dirección implícita se indican con una dirección de 64 caracteres que corresponde a un par de claves pública/privada. Para usar este tipo de cuenta, los usuarios deben financiarla con sus tokens de NEAR o pagar la tarifa de gas por la transacción.

Dirección con nombre
NEAR también permite a los usuarios registrar cuentas con nombre que son mucho más fáciles de compartir y recordar. Las cuentas con nombre también pueden crear subcuentas, actuando efectivamente como dominios.

¿Qué es TON?
TON (Toncoin) fue originalmente construido por Telegram en 2018. En el momento de su creación, Telegram recaudó $1.7 mil millones en financiamiento privado para su nueva cadena de bloques, destinada a ser una competencia para Ethereum. Sin embargo, abandonó el proyecto después de que la Comisión de Valores y Bolsa de los Estados Unidos entrara en escena y demandara, alegando que $TON, su token nativo, era un valor. Después de que Telegram abandonara el proyecto, fue retomado por desarrolladores no afiliados a Telegram, tomando el nombre de dominio ton.org y el repositorio de código de Toncoin. Toncoin luego lanzó la cadena de bloques TON y el token TON.

TON es una red de contratos inteligentes descentralizada de Layer1 creada para aplicaciones financieras y NFTs. Hasta ahora, se han creado más de un millón de NFTs. Al igual que NEAR, TON es una cadena de bloques de Prueba de Participación que ofrece una red altamente escalable ideal para transacciones financieras. También facilita las interacciones entre usuarios sobre una infraestructura financiera inmutable. La cadena de bloques TON se destaca por su escalabilidad y alto rendimiento. Creó un récord cuando procesó 55,000 transacciones por segundo, lo que fue posible gracias a su arquitectura única de múltiples niveles, combinando la cadena principal con múltiples otras cadenas de palabras.

¿Cómo funciona TON?
Cuatro aspectos son cruciales para el funcionamiento de TON: el consenso de Prueba de Participación, la Fragmentación, la Máquina Virtual TON y su token nativo, Toncoin.Consenso de Prueba de Participación
El consenso es cómo los nodos en la red acuerdan el estado actual y válido de la red. TON utiliza el mecanismo de consenso de Prueba de Participación eficiente en energía. Los validadores pueden apostar sus tokens y ganar recompensas por su contribución a la seguridad de la red. En el momento de la escritura, TON tiene 329 validadores y 511,880,772 $TON apostados. Los validadores reciben tokens $TON por cada bloque que validan. La Prueba de Participación por Bloque de TON asegura que la red continúe funcionando incluso si todos los validadores no pueden participar en el consenso.
Fragmentación
La fragmentación ayuda a aumentar la escalabilidad de la cadena de bloques y también es utilizada por NEAR. La fragmentación divide TON en componentes más pequeños llamados fragmentos. A cada fragmento se le asigna un rol específico, ayudando a la cadena de bloques a mantener un estado global. Mantener un estado global ayuda a eliminar la necesidad de que los nodos de la red procesen cada transacción, lo que aporta una mayor eficiencia.
La Máquina Virtual de TON (TVM)
La Máquina Virtual de TON desempeña un papel similar al de la Máquina Virtual de Ethereum, calculando comandos de aplicaciones de contrato y cambiando el estado de la red después de cada ejecución. A través de la TVM, los desarrolladores pueden crear aplicaciones que pueden automatizar diversos procesos, como la creación de activos, transferencias de activos y firmas de mensajes en la red.
Toncoin
Toncoin ($TON) es la criptomoneda nativa de TON y tiene múltiples usos en el ecosistema de TON. El token se utiliza para pagar tarifas de transacción, apostar y gobernar el protocolo.
Tarifas de Transacción
El token $TON se utiliza para pagar transacciones en la Red TON. Los usuarios deben usar los tokens para procesar transacciones o pagar tarifas de gas. El token también se utiliza para pagar el almacenamiento en la Red TON y los nombres de dominio basados en la cadena de bloques.
Gobernanza
El token $TON juega un papel crucial en la gobernanza. Los titulares de tokens $TON pueden votar en propuestas y tener voz en el futuro de la red.
Apostar
Los titulares de tokens $TON también pueden apostar sus tokens, actuando como validadores, ayudando a validar transacciones y asegurar la red. Los usuarios pueden apostar sus tokens directamente en la red o a través de importantes intercambios de criptomonedas.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planes Futuros para NEAR y TON
NEAR - IA Propiedad de los Usuarios
NEAR está avanzando en IA Propiedad de los Usuarios integrando la investigación y aplicaciones de IA en su ecosistema de cadena de bloques. El Laboratorio de I+D de IA de NEAR tiene como objetivo desarrollar IA que cree aplicaciones Web3 de extremo a extremo a partir de intenciones de usuario. Al aprovechar su gran base de usuarios, ecosistema de desarrolladores y recursos financieros, NEAR busca atraer talento de IA de primer nivel y construir una infraestructura de IA descentralizada que empodere a los usuarios y comunidades.
TON - Más Integraciones de TelegramLa expansión de la utilidad de TON dentro de Telegram es sin duda lo más emocionante acerca de TONCoin. Según el fundador de Telegram Pavel Durov, los usuarios podrán pagar por publicidad en TON y dar propinas a los administradores de canales. Pronto, los stickers se podrán comprar y vender como NFTs, con los artistas recibiendo el 95% de las ganancias. Los usuarios también podrán compartir TON, iniciar sesión en cuentas usando billeteras de criptomonedas, y registrar y vender nombres de cuentas.

En conclusión
NEAR y TON son plataformas innovadoras que han revolucionado el panorama de las dApps y los contratos inteligentes. Con su enfoque en velocidad, escalabilidad y amigabilidad para desarrolladores y usuarios, NEAR ha surgido como una alternativa digna a Ethereum. Mientras tanto, TON está atrayendo rápidamente a inversores y desarrolladores. Su integración con Telegram también le da acceso a la red a más de 700 millones de usuarios potenciales.

¡Vota AHORA!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Протокол NEAR и TON

Протокол NEAR и Открытая Сеть (TON)
NEAR и TON (The Open Network) - два из самых многообещающих проектов в крипто-экосистеме. NEAR предлагает пользователям встроенные функции, включая абстракцию учетной записи и именные учетные записи. Платформа dApp (децентрализованных приложений) сосредоточена на удобстве использования для пользователей и разработчиков и была создана коллективом NEAR. С другой стороны, TON - это децентрализованный блокчейн уровня 1, созданный Telegram в 2018 году. Однако он был заброшен вскоре после этого.

В этой статье будет рассмотрен каждый проект более подробно, включая то, как он работает, его экосистему, использование и многое другое.
Что такое NEAR?
NEAR - это публичный блокчейн с возможностью использования смарт-контрактов, работающий по принципу Proof-of-Stake, который предоставляет разработчикам платформу для создания децентрализованных приложений (dApps). Созданный коллективом NEAR, он в основном конкурирует с Ethereum и другими блокчейнами, поддерживающими смарт-контракты, такими как EOS и Polkadot. Протокол нацелен на улучшение недостатков Ethereum в скорости, масштабируемости и стоимости.

NEAR быстрее и дешевле, чем Ethereum, обрабатывая до 100 000 транзакций в секунду. Невероятная масштабируемость протокола имеет потенциал изменить мир смарт-контрактов и децентрализованных приложений. Ключевым элементом дизайна и работы протокола NEAR является концепция шардинга. Шардинг разбивает инфраструктуру сети на более мелкие сегменты, позволяя узлам обрабатывать только часть общего количества транзакций сети. Шардинг может создать более эффективный способ извлечения данных сети и помочь масштабировать платформу.

NEAR можно сравнить с системами хранения данных, такими как Amazon Web Services (AWS), которые выступают в качестве базового уровня, на котором строятся приложения. Однако ключевое отличие заключается в том, что NEAR децентрализован и поддерживается распределенной сетью компьютеров (узлов). Встроенный токен протокола, NEAR, используется для оплаты комиссий за транзакции и хранение. Владельцы токенов также могут стейкать свои токены, принимая роль валидаторов и помогая сети достигать консенсуса.
Коллектив NEAR
Коллектив NEAR - это организация, стоящая за протоколом NEAR, состоящая из отдельных организаций и других участников, постоянно работающих над его улучшением. Организация работает над проектами, пишет их первоначальный код и помогает с их реализацией на NEAR. Коллектив NEAR также помогает в развитии и управлении. Хотя коллектив NEAR разработал NEAR, протокол полностью децентрализован. Он работает независимо и не может быть закрыт или подвергнут манипуляциям.
Как работает протокол NEAR?
Протокол NEAR - это блокчейн Proof-of-Stake. Механизм Proof-of-Stake требует от владельцев токенов стейкать определенное количество токенов, чтобы быть пригодными для валидации блоков. Ключевым элементом функционирования протокола является его алгоритм консенсуса - Nightshade.
NightshadeNightshade - это решение для фрагментации NEAR Protocol, которое позволяет NEAR распределять вычислительную нагрузку на управляемые куски. Благодаря Nightshade каждый участвующий узел должен хранить только небольшой набор данных платформы. Затем узлы могут обрабатывать эти «куски» информации и добавлять их в основную цепь.

Одним из основных преимуществ Nightshade является значительное снижение количества потенциальных точек отказа. Это происходит потому, что каждый узел отвечает только за небольшое количество данных и поддерживает только небольшую часть цепи, что значительно повышает эффективность.

Валидаторы также играют ключевую роль в NEAR и отвечают за поддержание консенсуса в протоколе. Они должны держать свои серверы в сети все время и обновлять свои системы. Валидаторы определяются в каждой новой эпохе и избираются на основе их доли. Валидаторы, которые уже были избраны, могут быть переизбраны, вложив свои токены и накопленные вознаграждения. Тем временем, любой потенциальный валидатор должен иметь свою долю выше предопределенного уровня.

Что такое учетные записи NEAR?
Как уже упоминалось ранее, NEAR поддерживает адреса, понятные для человека. Существуют два типа учетных записей NEAR: неявные адреса и именованные адреса.

Неявные адреса
Учетные записи с неявными адресами обозначаются 64-символьным адресом, соответствующим паре открытого/закрытого ключа. Чтобы использовать этот тип учетной записи, пользователи должны пополнить ее своими токенами NEAR или оплатить комиссию за газ для транзакции.

Именованные адреса
NEAR также позволяет пользователям регистрировать именованные учетные записи, которые гораздо проще делиться и запоминать. Именованные учетные записи также могут создавать под-учетные записи, действуя эффективно как домены.

Что такое TON?
TON (Toncoin) был изначально создан Telegram в 2018 году. На момент его создания Telegram привлек $1,7 миллиарда частных инвестиций для своего нового блокчейна, задуманного как конкурент Ethereum. Однако проект был заброшен после того, как в дело вступила Комиссия по ценным бумагам и биржам США и подала иск, утверждая, что $TON, его собственный токен, является ценным бумагой. После того как Telegram отказался от проекта, им занялись разработчики, не связанные с Telegram, захватив доменное имя ton.org и репозиторий кода Toncoin. Затем Toncoin запустил блокчейн TON и токен TON.

TON - это децентрализованная сеть умных контрактов Layer1, созданная для финансовых приложений и NFT. На данный момент было создано более миллиона NFT. Как и NEAR, TON - это блокчейн Proof-of-Stake, который обеспечивает высокомасштабируемую сеть, идеальную для финансовых транзакций. Он также облегчает взаимодействие между пользователями через неизменную финансовую инфраструктуру. Блокчейн TON выделяется своей масштабируемостью и высокой производительностью. Он установил своего рода рекорд, обработав 55 000 транзакций в секунду, что стало возможным благодаря его уникальной многоуровневой архитектуре, объединяющей основную цепь с несколькими другими цепями слов.Консенсус Proof-of-Stake
Консенсус - это способ, с помощью которого узлы в сети соглашаются о текущем и действительном состоянии сети. TON использует энергоэффективный механизм консенсуса Proof-of-Stake. Валидаторы могут ставить свои токены и получать вознаграждение за свой вклад в обеспечение безопасности сети. На момент написания у TON 329 валидаторов и 511 880 772 $TON заложено. Валидаторы получают токены $TON за каждый блок, который они проверяют. Механизм Proof-of-Stake блоков TON гарантирует, что сеть продолжает работать даже в том случае, если все валидаторы не могут участвовать в консенсусе.
Шардинг
Шардинг помогает увеличить масштабируемость блокчейна и также используется NEAR. Шардинг делит TON на более мелкие компоненты, называемые шардами. Каждому шарду назначается определенная роль, что помогает блокчейну поддерживать глобальное состояние. Поддержание глобального состояния помогает избежать необходимости обработки каждой транзакции узлами сети, что повышает эффективность.
Виртуальная машина TON (TVM)
Виртуальная машина TON выполняет функции, аналогичные Ethereum Virtual Machine, вычисляя команды из контрактных приложений и изменяя состояние сети после каждого выполнения. Через TVM разработчики могут создавать приложения, которые могут автоматизировать различные процессы, такие как создание активов, передача активов и подписание сообщений в сети.
Toncoin
Toncoin ($TON) - это местная криптовалюта TON и имеет несколько применений в экосистеме TON. Токен используется для оплаты комиссий за транзакции, залогов и управления протоколом.
Комиссии за транзакции
Токен $TON используется для оплаты транзакций в сети TON. Пользователи должны использовать токены для обработки транзакций или оплаты газовых сборов. Токен также используется для оплаты хранения в сети TON и блокчейн-доменов.
Управление
Токен $TON играет ключевую роль в управлении. Владельцы токенов $TON могут голосовать по предложениям и иметь влияние на будущее сети.
Залог
Владельцы токенов $TON также могут заложить свои токены, выступая в качестве валидаторов, помогая проверять транзакции и обеспечивать безопасность сети. Пользователи могут заложить свои токены непосредственно в сети или через крупные криптовалютные биржи.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Планы на будущее для NEAR и TON
NEAR - Искусственный интеллект, принадлежащий пользователям
NEAR продвигает Искусственный интеллект, принадлежащий пользователям, интегрируя исследования и приложения искусственного интеллекта в свою блокчейн-экосистему. Лаборатория NEAR.AI R&D стремится разработать искусственный интеллект, который создает полностью интегрированные приложения Web3 от намерений пользователей. Используя свою большую пользовательскую базу, экосистему разработчиков и финансовые ресурсы, NEAR стремится привлечь лучшие таланты в области искусственного интеллекта и построить децентрализованную инфраструктуру искусственного интеллекта, которая дает возможность пользователям и сообществам.
TON - Дальнейшие интеграции TelegramРасширение возможностей использования TON в Telegram, безусловно, является самым захватывающим аспектом TONCoin. Как утверждает основатель Telegram Павел Дуров, пользователи смогут оплачивать рекламу в TON и давать чаевые администраторам каналов. Вскоре стикеры можно будет покупать и продавать как NFT, а художники получат 95% от выручки. Пользователи также смогут делиться TON, входить в учетные записи с использованием криптокошельков, а также регистрировать и продавать имена учетных записей.
В заключение
NEAR и TON - инновационные платформы, которые революционизировали ландшафт dApp и смарт-контрактов. С упором на скорость, масштабируемость и дружелюбие к пользователю и разработчику, NEAR стал достойной альтернативой Ethereum. Тем временем TON быстро привлекает инвесторов и разработчиков. Интеграция с Telegram также дает сети доступ к более чем 700 миллионам потенциальных пользователей.
Проголосуйте СЕЙЧАС!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### NEAR Protocol Và TON

Giao thức NEAR và Mạng mở (TON)
NEAR và TON (The Open Network) là hai trong những dự án hứa hẹn nhất trong hệ sinh thái tiền điện tử. NEAR cung cấp cho người dùng các tính năng tích hợp bao gồm trừu tượng hóa tài khoản và tài khoản có tên. Nền tảng ứng dụng phi tập trung (dApp) tập trung vào sự thân thiện với người dùng và nhà phát triển và được xây dựng bởi NEAR Collective. Ngược lại, TON là một chuỗi khối lớp 1 phi tập trung được tạo ra bởi Telegram vào năm 2018. Tuy nhiên, nó đã bị bỏ lại ngay sau đó.

Bài viết này sẽ xem xét kỹ hơn về mỗi dự án, bao gồm cách hoạt động, hệ sinh thái, các ứng dụng và nhiều hơn nữa.
NEAR là gì?
NEAR là một chuỗi khối Proof-of-Stake công cộng có khả năng hợp đồng thông minh cung cấp cho các nhà phát triển một nền tảng để xây dựng các ứng dụng phi tập trung (dApps). Được xây dựng bởi NEAR Collective, nó cạnh tranh chủ yếu với Ethereum và các chuỗi khối hỗ trợ hợp đồng thông minh khác như EOS và Polkadot. Giao thức nhắm vào việc cải thiện nhược điểm của Ethereum về tốc độ, khả năng mở rộng và chi phí.

NEAR nhanh hơn và rẻ hơn so với Ethereum, xử lý lên đến 100.000 giao dịch mỗi giây. Khả năng mở rộng đáng kinh ngạc của giao thức có tiềm năng cách mạng hóa thế giới của hợp đồng thông minh và ứng dụng phi tập trung. Chìa khóa của thiết kế và cách hoạt động của Giao thức NEAR là một khái niệm gọi là sharding. Sharding chia cắt cơ sở hạ tầng mạng thành các đoạn nhỏ hơn, cho phép các nút xử lý chỉ một phần nhỏ của tổng số giao dịch của mạng. Sharding có thể tạo ra một cách hiệu quả hơn để truy xuất dữ liệu mạng và giúp mở rộng nền tảng.

NEAR có thể được so sánh với các hệ thống lưu trữ dữ liệu như Amazon Web Services (AWS), hoạt động như lớp cơ sở mà ứng dụng được xây dựng trên đó. Tuy nhiên, sự khác biệt quan trọng là NEAR là phi tập trung và được duy trì bởi một mạng phân tán của máy tính (nút). Token native của giao thức, NEAR, được sử dụng để thanh toán phí giao dịch và lưu trữ. Người giữ token cũng có thể đặt cược token của họ, đảm nhận vai trò của người xác thực và giúp mạng đạt được sự đồng thuận.
NEAR Collective
NEAR Collective là tổ chức đứng sau Giao thức NEAR và bao gồm các tổ chức cá nhân và các đóng góp viên khác luôn làm việc không ngừng để cải thiện nó. Tổ chức làm việc trên các dự án, viết mã ban đầu của họ và giúp thực hiện chúng trên NEAR. NEAR Collective cũng hỗ trợ trong các hoạt động phát triển và quản trị. Mặc dù NEAR Collective đã phát triển NEAR, giao thức hoàn toàn phi tập trung. Nó hoạt động độc lập và không thể bị tắt hoặc thao túng.
Giao thức NEAR hoạt động như thế nào?
Giao thức NEAR là một chuỗi khối Proof-of-Stake. Cơ chế Proof-of-Stake yêu cầu người giữ token đặt cược một số token nhất định để có đủ điều kiện xác thực các khối. Chìa khóa cho cách hoạt động của giao thức là thuật toán đồng thuận của nó - Nightshade.
NightshadeNightshade là giải pháp chia nhỏ của NEAR Protocol, cho phép NEAR phân phối công việc tính toán thành các phần quản lý được. Nhờ Nightshade, mỗi nút tham gia chỉ cần lưu trữ một phần nhỏ dữ liệu của nền tảng. Sau đó, các nút có thể xử lý các 'phần' thông tin này và thêm chúng vào chuỗi chính.

Một trong những lợi ích chính của Nightshade là giảm đáng kể số lượng điểm tiềm năng của sự cố. Điều này bởi vì mỗi nút chỉ chịu trách nhiệm với một lượng dữ liệu nhỏ và chỉ duy trì một phần nhỏ của chuỗi, tăng cường hiệu suất đáng kể.

Validators cũng đóng vai trò quan trọng trên NEAR và chịu trách nhiệm duy trì sự đồng thuận trong giao thức. Họ phải giữ máy chủ của họ hoạt động trực tuyến mọi lúc và cập nhật hệ thống của họ. Validators được xác định trong mỗi kỷ nguyên mới và được bầu dựa trên số cổ phần của họ. Validators đã được bầu có thể được bầu lại bằng cách đặt cược lại các token và phần thưởng tích lũy của họ. Trong khi đó, bất kỳ validator tiềm năng nào phải có số cổ phần của họ cao hơn một mức định trước.

NEAR Accounts là gì?
Như đã đề cập trước đó, NEAR hỗ trợ các địa chỉ có thể đọc được bởi con người. Có hai loại tài khoản NEAR: Địa chỉ ngầm định và Địa chỉ có tên.
Địa chỉ Ngầm định
Các tài khoản địa chỉ ngầm định được đánh dấu bằng một địa chỉ 64 ký tự tương ứng với cặp khóa công khai / khóa riêng. Để sử dụng loại tài khoản này, người dùng phải tài trợ nó bằng các token NEAR của họ hoặc trả phí gas cho giao dịch.
Địa chỉ có Tên
NEAR cũng cho phép người dùng đăng ký các tài khoản có tên dễ chia sẻ và nhớ hơn nhiều. Các tài khoản có tên cũng có thể tạo các tài khoản con, hiệu quả như là tên miền.

TON là gì?
TON (Toncoin) ban đầu được xây dựng bởi Telegram vào năm 2018. Lúc đó, Telegram đã gây quỹ tư nhân 1,7 tỷ USD cho blockchain mới của mình, dự định là một đối thủ của Ethereum. Tuy nhiên, họ đã từ bỏ dự án sau khi Ủy ban Chứng khoán và Trao đổi Hoa Kỳ tham gia và kiện, cáo buộc rằng $TON, token cố định của họ, là một chứng khoán. Sau khi Telegram từ bỏ dự án, nó đã được các nhà phát triển không liên quan đến Telegram tiếp quản, tiếp quản tên miền ton.org và kho mã nguồn Toncoin. Sau đó, Toncoin đã ra mắt blockchain TON và token TON.




	

	
	
		
			
				TON is short for:
			
		

		
					

		
			
			
			
			The Open Network
		
			
			Telegram Open Network 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






TON là một mạng lưới hợp đồng thông minh Layer1 phi tập trung được tạo ra cho các ứng dụng tài chính và NFT. Đến nay, đã có hơn một triệu NFT được tạo ra. Giống như NEAR, TON là một blockchain Proof-of-Stake cung cấp một mạng lưới có khả năng mở rộng cao lý tưởng cho các giao dịch tài chính. Nó cũng tạo điều kiện cho sự tương tác giữa người dùng trên cơ sở hạ tầng tài chính không thể thay đổi. Blockchain TON nổi bật với khả năng mở rộng và hiệu suất cao. Nó đã tạo ra một kỷ lục khi xử lý 55.000 giao dịch mỗi giây, điều này đã trở nên khả thi nhờ kiến trúc đa cấp độ độc đáo của nó, kết hợp chuỗi chính với nhiều chuỗi từ khóa khác nhau.

TON hoạt động như thế nào?
Bốn khía cạnh quan trọng đối với hoạt động của TON: sự đồng thuận Proof-of-Stake, Sharding, Máy ảo TON và token cố định của nó, Toncoin.Bằng chứng của sự đồng thuận Proof-of-Stake
Đồng thuận là cách mà các nút trên mạng đồng ý với trạng thái hiện tại và hợp lệ của mạng. TON sử dụng cơ chế đồng thuận Proof-of-Stake tiết kiệm năng lượng. Người xác thực có thể đặt cược token của họ và kiếm phần thưởng cho sự đóng góp của họ trong việc bảo vệ mạng. Tính đến thời điểm viết bài này, TON có 329 người xác thực và 511,880,772 $TON đã đặt cược. Người xác thực nhận được token $TON cho mỗi khối họ xác thực. Proof-of-Stake của TON đảm bảo rằng mạng vẫn tiếp tục hoạt động ngay cả khi tất cả các người xác thực không thể tham gia vào sự đồng thuận.

Chia nhỏ
Chia nhỏ giúp tăng cường khả năng mở rộng của blockchain và cũng được sử dụng bởi NEAR. Chia nhỏ chia TON thành các thành phần nhỏ hơn gọi là shards. Mỗi shard được gán một vai trò cụ thể, giúp blockchain duy trì trạng thái toàn cầu. Duy trì trạng thái toàn cầu giúp loại bỏ nhu cầu cho các nút mạng xử lý mỗi giao dịch, mang lại hiệu quả cao hơn.

Máy ảo TON (TVM)
Máy ảo TON đóng vai trò tương tự như Máy ảo Ethereum, tính toán các lệnh từ các ứng dụng hợp đồng và thay đổi trạng thái mạng sau mỗi thực thi. Thông qua TVM, các nhà phát triển có thể tạo ra các ứng dụng có thể tự động hóa các quy trình khác nhau, như tạo ra tài sản, chuyển tài sản và ký các thông điệp trên mạng.

Toncoin
Toncoin ($TON) là tiền điện tử bản địa của TON và có nhiều ứng dụng trong hệ sinh thái TON. Token này được sử dụng để thanh toán phí giao dịch, đặt cược và quản trị giao thức.

Phí giao dịch
Token $TON được sử dụng để thanh toán cho các giao dịch trên Mạng TON. Người dùng phải sử dụng token để xử lý giao dịch hoặc trả phí gas. Token cũng được sử dụng để thanh toán cho lưu trữ Mạng TON và tên miền dựa trên blockchain.

Quản trị
Token $TON đóng vai trò quan trọng trong quản trị. Chủ sở hữu token $TON có thể bỏ phiếu cho các đề xuất và có quyền lực trong tương lai của mạng.

Đặt cược
Chủ sở hữu token $TON cũng có thể đặt cược token của họ, đóng vai trò như người xác thực, giúp xác thực giao dịch và bảo vệ mạng. Người dùng có thể đặt cược token của họ trực tiếp trên mạng hoặc thông qua các sàn giao dịch tiền điện tử lớn.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kế hoạch tương lai cho NEAR và TON
NEAR - AI thuộc sở hữu của người dùng
NEAR đang tiến xa với AI thuộc sở hữu của người dùng bằng cách tích hợp nghiên cứu và ứng dụng AI vào hệ sinh thái blockchain của mình. Phòng thí nghiệm NEAR.AI R&D nhằm phát triển AI tạo ra các ứng dụng Web3 từ ý định của người dùng. Bằng việc tận dụng cơ sở người dùng lớn, hệ sinh thái phát triển viên và nguồn lực tài chính của mình, NEAR đang cố gắng thu hút tài năng AI hàng đầu và xây dựng cơ sở hạ tầng AI phi tập trung giúp người dùng và cộng đồng.

TON - Các tích hợp Telegram tiếp theoSự mở rộng của tiện ích TON trong Telegram không thể phủ nhận là điều thú vị nhất về TONCoin. Theo Người sáng lập Telegram Pavel Durov, người dùng sẽ có thể thanh toán cho quảng cáo bằng TON và tặng tiền cho quản trị viên kênh. Sớm thôi, các hình dán có thể được mua bán như NFT, với các nghệ sĩ nhận được 95% doanh thu. Người dùng cũng sẽ có thể chia sẻ TON, đăng nhập vào tài khoản bằng ví tiền điện tử, và đăng ký và bán tên tài khoản.
Kết luận
NEAR và TON là các nền tảng đổi mới đã cách mạng hóa cảnh quan dApp và hợp đồng thông minh. Với sự tập trung vào tốc độ, khả năng mở rộng và sự thân thiện với người dùng-phát triển, NEAR đã trở thành một lựa chọn đáng giá so với Ethereum. Trong khi đó, TON đang nhanh chóng thu hút các nhà đầu tư và nhà phát triển. Sự tích hợp với Telegram cũng giúp mạng lưới tiếp cận hơn 700 triệu người dùng tiềm năng.
Bầu chọn NGAY!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Plan directeur NEAR.AI : Un guide simple

Increased Adoption: More users and developers joining NEAR.
 	Enhanced Innovation: New ideas and projects emerging within the ecosystem.
 	Stronger Community: Building a supportive and collaborative community around NEAR.

 	Plus d'applications: Attirer plus d'utilisateurs avec de nouvelles applications.
 	Opportunités économiques: Créer de nouvelles opportunités économiques et des effets de réseau.

Faire avancer l'IA:

 	Chercheur en IA: Découvrir de nouvelles idées en combinant des informations existantes.
 	Objectif final: AGI détenue par l'utilisateur: Une IA plus intelligente que les experts humains, transformant l'informatique.

Principes:

 	Au service des utilisateurs: L'IA doit servir et appartenir aux individus et aux communautés.
 	AGI open source: Pour profiter à tous, toute l'IA et l'AGI doivent être open source et appartenir aux utilisateurs.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion:
La vision de NEAR.AI est de démocratiser l'IA, en veillant à ce qu'elle soit ouverte et appartenant aux utilisateurs. En impliquant la communauté, en tirant parti de l'écosystème robuste de NEAR et en se concentrant sur le développement open source, NEAR.AI vise à transformer notre interaction avec la technologie. Ce voyage, commençant par l'enseignement aux machines du codage et progressant vers une IA avancée, promet un avenir où l'IA donne du pouvoir à tous. Ensemble, nous pouvons construire un monde numérique plus inclusif et innovant.

### Update – September 3, 2024

Brief Summary:

 	
🤝Referring your friends is SUPER EASY now🕺
https://learnnear.club/wp-content/uploads/2024/09/bitter-wallet-refferal.mp4

Results:

 	
Bitte Free transactions 👀BugEye Sprint is extended till September 6


 	🔬2 nd NanoQuiz🕺 for exclusively 🔥Hot wallet users is LIVE
https://t.me/herewalletbot/app?startapp=web-tg-learnnear-club


 	📚(L)Earn about Race of Sloths: Gamifying Open-Source Contributions🕺
 	📚 (L)Earn about Introduction to Burrow Finance🕺

 	Nightshade 2.0 is live on NEARP Mainnet! Many thanks to (l)earnes who participated in Wheel of Transactions!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	NEAR AI is coming soon with better model and more use cases!

### Bitte Free transactions 👀BugEye Sprint

Follow @LearnNEAR and Bitte on X

👀BugEye Sprint starts: August 28, 9 am ET
👀BugEye Sprint ends: September 6, 9 am ET
Requirements:

 	Imagine you are your friend who is brand new to web3
 	Open Learn NEAR Club (logout if you logged in)
 	Login with Bitte wallet - please create a new account
 	After login explore this Guide
 	Like it
 	Take a screenshot with the Bitte wallet popup

 	Find your transaction at NEAR explorer of your choice (you may also use LNC NEAR Info bot https://t.me/nearinfobot)
 	Tweet with your screenshot “Many thank s to @BitteProtocol and @LearnNEAR for seamless onboarding to NEAR with sponsored transactions. This is a game changer!”
 	Tell us what do you think about the process.

Fill the Feedback form
The top 20 beta testers will get 1 NEAR, the best feedback submitter will get 5 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead at Telegram  https://t.me/namesky_support



 

### NEAR.AI 主计划：简易指南

NEAR.AI希望创建先进的人人可用和拥有的人工智能。以下是计划：

	教机器编码：AI开发者 - 首先，他们将创建一个可以学习编码的人工智能。
	与AI一起研究：AI研究者 - 接下来，这个人工智能将学习进行研究。
	为所有人创建先进的人工智能 - 最后，他们将利用这些研究成果创建属于所有人的强大人工智能。

承诺：

	开源：一切都将对所有人开放使用和改进。
	非营利性：NEAR基金会，一个非营利组织，将领导这一努力。
	用户所有权：目标是让用户拥有他们的人工智能。

NEAR生态系统：

	数百万用户：NEAR拥有数千万用户。
	不断增长的开发者社区：越来越多的人工智能项目加入NEAR。
	强大的资金支持：NEAR拥有成功所需的资金。

NEAR当前的产品：

	易于使用的区块链：NEAR拥有一个简单易用的区块链。
	众多活跃用户：比任何其他区块链都有更多的活跃用户。

未来愿景：

	用户拥有的人工智能：为您工作并保护您的数据隐私。
	完全定制：用户可以完全定制他们的人工智能体验。
	社区和品牌：人工智能将帮助社区和品牌直接合作并进行交易。

构建AI开发者：

	2017年开始：NEAR开始尝试创建一个基于人工智能的自动完成功能。
	2018年转变：他们转而构建一个去中心化平台。
	到2024年的进展：现在，NEAR拥有数百万用户和许多日活跃用户。

区块链中的挑战：

	碎片化：产品分布在许多区块链上。
	开发者稀缺：少于7,000名全职Web3开发者。
	Web3代码的高价值：Web3代码具有价值且开发成本高昂。

AI开发者的角色：

	效率飞跃：使用简单的语言输入轻松创建Web3产品。
	开源开发：所有软件、数据集和模型都将开源。
	合作：与其他人工智能和Web3项目合作。

社区参与：

	新应用：让社区参与创建新应用。
	更多基础设施：需要不仅仅是区块链，还需要点对点通信和私密计算。
	利用NEAR生态系统：利用NEAR现有的基于代币的经济体系。

对NEAR生态系统的好处：
	更多应用：通过新应用吸引更多用户。
	经济机会：创造新的经济机会和网络效应。

推进人工智能：

	人工智能研究员：通过结合现有信息发现新的见解。
	最终目标：用户拥有的AGI：比人类专家更聪明的人工智能，改变计算方式。

原则：

	为用户服务：人工智能必须为个人和社区提供服务并被拥有。
	开源AGI：为了使每个人受益，所有人工智能和AGI必须是开源的并由用户拥有。




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





结论：
NEAR.AI的愿景是民主化人工智能，确保其开放和用户拥有。通过吸引社区，利用NEAR强大的生态系统，并专注于开源开发，NEAR.AI旨在改变我们与技术互动的方式。这一旅程，从教会机器编码开始，逐步发展到先进的人工智能，承诺一个让人人受益的未来。我们可以共同建设一个更具包容性和创新性的数字世界。

### Rencana Master NEAR.AI: Panduan Sederhana

Increased Adoption: More users and developers joining NEAR.
 	Enhanced Innovation: New ideas and projects emerging within the ecosystem.
 	Stronger Community: Building a supportive and collaborative community around NEAR.

 	Lebih Banyak Aplikasi: Tarik lebih banyak pengguna dengan aplikasi baru.
 	Peluang Ekonomi: Ciptakan peluang ekonomi baru dan efek jaringan.

Maju dalam AI:

 	Peneliti AI: Temukan wawasan baru dengan menggabungkan informasi yang ada.
 	Tujuan Akhir: AGI Dimiliki Pengguna: AI yang lebih cerdas dari para ahli manusia, mengubah komputasi.

Prinsip:

 	Melayani Pengguna: AI harus melayani dan dimiliki oleh individu dan komunitas.
 	AGI Sumber Terbuka: Untuk keuntungan semua orang, semua AI dan AGI harus sumber terbuka dan dimiliki oleh pengguna.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kesimpulan:
Visi NEAR.AI adalah untuk mendemokratisasi AI, memastikan bahwa itu terbuka dan dimiliki pengguna. Dengan melibatkan komunitas, memanfaatkan ekosistem NEAR yang tangguh, dan fokus pada pengembangan sumber terbuka, NEAR.AI bertujuan untuk mengubah cara kita berinteraksi dengan teknologi. Perjalanan ini, dimulai dengan mengajari mesin untuk coding dan menuju ke AI canggih, menjanjikan masa depan di mana AI memberdayakan semua orang. Bersama, kita dapat membangun dunia digital yang lebih inklusif dan inovatif.

### NEAR.AI 마스터 플랜: 간단한 안내

NEAR.AI는 모든 사람이 사용하고 소유할 수 있는 고급 AI를 만들고자 합니다. 여기가 계획입니다:

 	기계에게 코딩 가르치기: AI 개발자 - 먼저, 코딩을 배울 수 있는 AI를 만들 것입니다.
 	AI로 연구하기: AI 연구자 - 다음으로, 이 AI는 연구를 할 수 있도록 배웁니다.
 	모두를 위한 고급 AI 만들기 - 마지막으로, 이 연구를 활용하여 모두에게 속한 강력한 AI를 만들 것입니다.

약속:

 	오픈 소스: 모든 사람이 사용하고 개선할 수 있도록 모든 것이 오픈될 것입니다.
 	비영리: 비영리 단체인 NEAR 재단이 이 노력을 이끌 것입니다.
 	사용자 소유권: 사용자가 자신의 AI를 소유할 수 있도록 목표를 설정했습니다.

NEAR 생태계:

 	수백만 사용자: NEAR에는 수백만 명의 사용자가 있습니다.
 	성장하는 개발자 커뮤니티: 점점 더 많은 AI 프로젝트가 NEAR에 참여하고 있습니다.
 	강력한 자금 지원: NEAR는 성공하기 위해 필요한 자금을 보유하고 있습니다.

NEAR의 현재 제품:

 	쉽게 사용할 수 있는 블록체인: NEAR에는 사용하고 개발하기 쉬운 블록체인이 있습니다.
 	많은 활성 사용자: 다른 어떤 블록체인보다 더 많은 활성 사용자가 있습니다.

미래 비전:

 	사용자 소유 AI: 사용자를 위해 작동하고 데이터를 비공개로 유지하는 AI.
 	완전한 사용자 정의: 사용자는 자신의 AI 경험을 완전히 사용자 정의할 수 있습니다.
 	커뮤니티와 브랜드: AI가 커뮤니티와 브랜드가 함께 작업하고 직접 거래할 수 있도록 돕습니다.

AI 개발자 구축:

 	2017년 시작: NEAR는 AI 기반 자동완성을 만들려고 시작했습니다.
 	2018년 전환: 분산형 플랫폼 구축으로 전환했습니다.
 	2024년까지 진전: 현재 NEAR에는 수백만 명의 사용자와 많은 일일 활성 사용자가 있습니다.

블록체인의 도전:

 	분열: 제품이 여러 블록체인에 흩어져 있습니다.
 	개발자 부족: 전문 웹3 개발자가 7,000명 미만입니다.
 	웹3 코드의 가치 상승: 웹3 코드는 가치가 있고 개발 비용이 많이 듭니다.

AI 개발자의 역할:

 	효율성 개선: 간단한 언어 입력을 사용하여 쉽게 웹3 제품을 만듭니다.
 	오픈 소스 개발: 모든 소프트웨어, 데이터셋 및 모델이 오픈 소스로 제공됩니다.
 	협업: 다른 AI 및 웹3 프로젝트와 함께 작업합니다.

커뮤니티 참여:

 	새로운 응용 프로그램: 커뮤니티를 참여시켜 새로운 응용 프로그램을 만듭니다.
 	더 많은 인프라: 블록체인 이외에도 피어 투 피어 통신 및 개인 계산이 필요합니다.
 	NEAR 생태계 활용: NEAR의 기존 토큰 기반 경제를 활용합니다.

NEAR 생태계에 대한 혜택:
 	더 많은 응용프로그램: 새로운 응용프로그램으로 더 많은 사용자를 유치하세요.
 	경제적 기회: 새로운 경제 기회와 네트워크 효과를 창출하세요.

AI 발전:

 	AI 연구자: 기존 정보를 결합하여 새로운 통찰을 얻으세요.
 	최종 목표: 사용자 소유 AGI: 인간 전문가보다 더 똑똑한 AI로 컴퓨팅을 변형하세요.

원칙:

 	사용자에 봉사: AI는 개인과 커뮤니티에 봉사하고 소유되어야 합니다.
 	오픈 소스 AGI: 모든 AI와 AGI는 오픈 소스이고 사용자 소유이어야 모두에게 혜택이 되어야 합니다.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





결론:
NEAR.AI의 비전은 AI를 민주화하여 오픈 소스이고 사용자 소유임을 보장하는 것입니다. 커뮤니티와 협력하고 NEAR의 견고한 생태계를 활용하며 오픈 소스 개발에 초점을 맞추어 NEAR.AI는 기술과 상호작용하는 방식을 변화시키려 합니다. 기계에 코딩을 가르치는 것으로 시작하여 고급 AI로 진행하는 이 여정은 AI가 모두에게 권력을 부여하는 미래를 약속합니다. 함께하면 더 포용력 있고 혁신적인 디지털 세계를 만들 수 있습니다.

### Plano Mestre da NEAR.AI: Um Guia Simples

NEAR.AI quer criar uma IA avançada que todos possam usar e possuir. Aqui está o plano:

 	Ensinar Máquinas a Codificar: Desenvolvedor de IA - Primeiro, eles criarão uma IA que pode aprender a codificar.
 	Pesquisar com IA: Pesquisador de IA - Em seguida, esta IA aprenderá a fazer pesquisas.
 	Criar IA Avançada para Todos - Por fim, eles usarão essa pesquisa para criar uma IA poderosa que pertence a todos.

Promessas:

 	Código Aberto: Tudo estará aberto para todos usarem e melhorarem.
 	Sem Fins Lucrativos: A Fundação NEAR, uma organização sem fins lucrativos, liderará esse esforço.
 	Propriedade do Usuário: O objetivo é que os usuários sejam donos de sua IA.

Ecossistema NEAR:

 	Milhões de Usuários: NEAR tem dezenas de milhões de usuários.
 	Comunidade de Desenvolvedores em Crescimento: Cada vez mais projetos de IA estão se juntando à NEAR.
 	Financiamento Sólido: NEAR tem o dinheiro necessário para ter sucesso.

Produto Atual da NEAR:

 	Blockchain Fácil de Usar: NEAR tem um blockchain simples de usar e desenvolver.
 	Muitos Usuários Ativos: Mais usuários ativos do que qualquer outro blockchain.

Visão Futura:

 	IA de Propriedade do Usuário: IA que trabalha para você e mantém seus dados privados.
 	Personalização Completa: Os usuários podem personalizar completamente sua experiência de IA.
 	Comunidade e Marcas: A IA ajudará comunidades e marcas a trabalharem juntas e a fazerem transações diretamente.

Construindo o Desenvolvedor de IA:

 	Iniciado em 2017: A NEAR começou tentando criar um autocompletar impulsionado por IA.
 	Mudança em 2018: Eles mudaram para construir uma plataforma descentralizada.
 	Progresso até 2024: Agora, a NEAR tem milhões de usuários e muitos usuários ativos diariamente.

Desafios no Blockchain:

 	Fragmentação: Produtos estão espalhados por muitos blockchains.
 	Poucos Desenvolvedores: Menos de 7.000 desenvolvedores Web3 em tempo integral.
 	Alto Valor do Código Web3: O código Web3 é valioso e custoso de desenvolver.

Papel do Desenvolvedor de IA:

 	Salto de Eficiência: Criar produtos Web3 facilmente usando entradas de linguagem simples.
 	Desenvolvimento de Código Aberto: Todo o software, conjuntos de dados e modelos serão de código aberto.
 	Colaboração: Trabalhar junto com outros projetos de IA e Web3.

Engajamento da Comunidade:

 	Novas Aplicações: Envolva a comunidade para criar novas aplicações.
 	Mais Infraestrutura: Necessário mais do que apenas blockchain, como comunicação peer-to-peer e computação privada.
 	Aproveitando o Ecossistema NEAR: Usar a economia baseada em tokens existente da NEAR.

Benefícios para o Ecossistema NEAR:
 	Mais Aplicações: Atraia mais usuários com novas aplicações.
 	Oportunidades Econômicas: Crie novas oportunidades econômicas e efeitos de rede.

Avançando em IA:

 	Pesquisador de IA: Descubra novos insights combinando informações existentes.
 	Objetivo Final: AGI de Propriedade do Usuário: IA mais inteligente do que especialistas humanos, transformando a computação.

Princípios:

 	Servindo Usuários: IA deve servir e ser de propriedade de indivíduos e comunidades.
 	AGI de Código Aberto: Para beneficiar a todos, toda IA e AGI devem ser de código aberto e de propriedade do usuário.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusão:
A visão da NEAR.AI é democratizar a IA, garantindo que seja aberta e de propriedade do usuário. Ao envolver a comunidade, aproveitar o ecossistema robusto da NEAR e focar no desenvolvimento de código aberto, a NEAR.AI tem como objetivo transformar a forma como interagimos com a tecnologia. Esta jornada, começando com o ensino de máquinas a codificar e avançando em direção à IA avançada, promete um futuro onde a IA capacita a todos. Juntos, podemos construir um mundo digital mais inclusivo e inovador.

### Kế hoạch chính thức của NEAR.AI: Hướng dẫn đơn giản

NEAR.AI muốn tạo ra trí tuệ nhân tạo tiên tiến mà ai cũng có thể sử dụng và sở hữu. Đây là kế hoạch:

	Dạy Máy Học Lập Trình: Nhà Phát Triển Trí Tuệ Nhân Tạo - Đầu tiên, họ sẽ tạo ra một trí tuệ nhân tạo có thể học lập trình.
	Nghiên Cứu với Trí Tuệ Nhân Tạo: Nhà Nghiên Cứu Trí Tuệ Nhân Tạo - Tiếp theo, trí tuệ nhân tạo này sẽ học cách nghiên cứu.
	Tạo Ra Trí Tuệ Nhân Tạo Tiên Tiến cho Mọi Người - Cuối cùng, họ sẽ sử dụng nghiên cứu này để tạo ra trí tuệ nhân tạo mạnh mẽ thuộc về mọi người.

Cam Kết:

	Mã Nguồn Mở: Mọi thứ sẽ được mở cho mọi người sử dụng và cải thiện.
	Phi Lợi Nhuận: Quỹ NEAR, một tổ chức phi lợi nhuận, sẽ dẫn đầu nỗ lực này.
	Sở Hữu của Người Dùng: Mục tiêu là để người dùng sở hữu trí tuệ nhân tạo của họ.

Hệ Sinh Thái NEAR:

	Triệu Người Dùng: NEAR có hàng chục triệu người dùng.
	Cộng Đồng Phát Triển Ngày Càng Lớn: Ngày càng nhiều dự án trí tuệ nhân tạo tham gia NEAR.
	Quỹ Tài Chính Mạnh Mẽ: NEAR có đủ tiền để thành công.

Sản Phẩm Hiện Tại của NEAR:

	Blockchain Dễ Sử Dụng: NEAR có một blockchain dễ sử dụng và phát triển trên đó.
	Nhiều Người Dùng Hoạt Động: Nhiều người dùng hoạt động hơn bất kỳ blockchain nào khác.

Tầm Nhìn Tương Lai:

	Trí Tuệ Nhân Tạo Thuộc Sở Hữu của Người Dùng: Trí tuệ nhân tạo làm việc cho bạn và giữ cho dữ liệu của bạn riêng tư.
	Tùy Chỉnh Đầy Đủ: Người dùng có thể tùy chỉnh trải nghiệm trí tuệ nhân tạo của họ hoàn toàn.
	Cộng Đồng và Thương Hiệu: Trí tuệ nhân tạo sẽ giúp cộng đồng và thương hiệu làm việc cùng nhau và thực hiện giao dịch trực tiếp.

Xây Dựng Nhà Phát Triển Trí Tuệ Nhân Tạo:

	Bắt Đầu vào Năm 2017: NEAR bắt đầu bằng việc cố gắng tạo ra một tính năng tự động hoàn chỉnh dựa trên trí tuệ nhân tạo.
	Chuyển Đổi vào Năm 2018: Họ chuyển sang xây dựng một nền tảng phi tập trung.
	Tiến Triển đến Năm 2024: Bây giờ, NEAR có hàng triệu người dùng và nhiều người dùng hoạt động hàng ngày.

Thách Thức trong Blockchain:

	Phân Mảnh: Sản phẩm phân tán trên nhiều blockchain.
	Ít Nhà Phát Triển: Dưới 7,000 nhà phát triển Web3 làm việc toàn thời gian.
	Giá Trị Cao của Mã Web3: Mã Web3 có giá trị và tốn kém để phát triển.

Vai Trò của Nhà Phát Triển Trí Tuệ Nhân Tạo:

	Bước Nhảy Hiệu Quả: Tạo ra các sản phẩm Web3 dễ dàng bằng cách sử dụng đầu vào ngôn ngữ đơn giản.
	Phát Triển Mã Nguồn Mở: Tất cả phần mềm, bộ dữ liệu và mô hình sẽ được mã nguồn mở.
	Hợp Tác: Làm việc cùng với các dự án trí tuệ nhân tạo và Web3 khác.

Tương Tác Cộng Đồng:

	Ứng Dụng Mới: Tham gia cộng đồng để tạo ra các ứng dụng mới.
	Hạ Tầng Nhiều Hơn: Cần nhiều hơn chỉ là blockchain, như giao tiếp ngang hàng và tính toán riêng tư.
	Tận Dụng Hệ Sinh Thái NEAR: Sử dụng nền kinh tế dựa trên token hiện có của NEAR.

Lợi Ích cho Hệ Sinh Thái NEAR:
 	Ứng dụng nhiều hơn: Thu hút nhiều người dùng hơn với các ứng dụng mới.
 	Cơ hội kinh tế: Tạo ra cơ hội kinh tế mới và hiệu ứng mạng.

Tiến bộ trong AI:

 	Nghiên cứu AI: Khám phá thông tin mới bằng cách kết hợp thông tin hiện có.
 	Mục tiêu cuối cùng: AGI thuộc sở hữu của người dùng: AI thông minh hơn các chuyên gia con người, biến đổi lĩnh vực máy tính.

Nguyên tắc:

 	Phục vụ người dùng: AI phải phục vụ và thuộc sở hữu của cá nhân và cộng đồng.
 	AGI mã nguồn mở: Để lợi ích cho mọi người, tất cả AI và AGI phải là mã nguồn mở và thuộc sở hữu của người dùng.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kết luận:
Tầm nhìn của NEAR.AI là làm cho AI dân chủ hóa, đảm bảo rằng nó là mã nguồn mở và thuộc sở hữu của người dùng. Bằng cách tương tác với cộng đồng, tận dụng hệ sinh thái mạnh mẽ của NEAR và tập trung vào phát triển mã nguồn mở, NEAR.AI nhắm đến việc biến đổi cách chúng ta tương tác với công nghệ. Hành trình này, bắt đầu từ việc dạy máy tính lập trình và tiến triển đến AI tiên tiến, hứa hẹn một tương lai nơi mà AI trao quyền cho mọi người. Cùng nhau, chúng ta có thể xây dựng một thế giới kỹ thuật số phong phú và sáng tạo hơn.

### Plan Maestro de NEAR.AI: Una Guía Simple

NEAR.AI quiere crear una IA avanzada que todos puedan usar y poseer. Aquí está el plan:

	Enseñar a las Máquinas a Codificar: Desarrollador de IA - Primero, crearán una IA que pueda aprender a codificar.
	Investigar con IA: Investigador de IA - Luego, esta IA aprenderá a investigar.
	Crear una IA Avanzada para Todos - Finalmente, utilizarán esta investigación para crear una IA poderosa que pertenezca a todos.

Promesas:

	Código Abierto: Todo estará abierto para que todos lo usen y mejoren.
	Sin Fines de Lucro: La Fundación NEAR, una organización sin fines de lucro, liderará este esfuerzo.
	Propiedad del Usuario: El objetivo es que los usuarios sean dueños de su IA.

Ecosistema NEAR:

	Millones de Usuarios: NEAR tiene decenas de millones de usuarios.
	Comunidad de Desarrolladores en Crecimiento: Cada vez más proyectos de IA se están uniendo a NEAR.
	Financiamiento Sólido: NEAR tiene el dinero necesario para tener éxito.

Producto Actual de NEAR:

	Blockchain Fácil de Usar: NEAR tiene un blockchain que es fácil de usar y desarrollar.
	Muchos Usuarios Activos: Más usuarios activos que cualquier otro blockchain.

Visión Futura:

	IA Propiedad del Usuario: IA que trabaja para ti y mantiene tus datos privados.
	Personalización Completa: Los usuarios pueden personalizar completamente su experiencia con la IA.
	Comunidad y Marcas: La IA ayudará a las comunidades y marcas a trabajar juntas y realizar transacciones directamente.

Construyendo el Desarrollador de IA:

	Comenzó en 2017: NEAR comenzó intentando crear un autocompletado impulsado por IA.
	Cambio en 2018: Cambiaron a la construcción de una plataforma descentralizada.
	Progreso para 2024: Ahora, NEAR tiene millones de usuarios y muchos usuarios activos diarios.

Desafíos en Blockchain:

	Fragmentación: Los productos están dispersos en muchos blockchains.
	Pocos Desarrolladores: Menos de 7,000 desarrolladores de Web3 a tiempo completo.
	Alto Valor del Código Web3: El código Web3 es valioso y costoso de desarrollar.

Rol del Desarrollador de IA:

	Salto de Eficiencia: Crear productos Web3 fácilmente utilizando entradas de lenguaje simple.
	Desarrollo de Código Abierto: Todo el software, conjuntos de datos y modelos serán de código abierto.
	Colaboración: Trabajar junto con otros proyectos de IA y Web3.

Participación de la Comunidad:

	Nuevas Aplicaciones: Involucrar a la comunidad para crear nuevas aplicaciones.
	Más Infraestructura: Se necesita más que solo blockchain, como comunicación peer-to-peer y computación privada.
	Aprovechando el Ecosistema NEAR: Utilizar la economía basada en tokens existente de NEAR.

Beneficios para el Ecosistema NEAR:
 	Más Aplicaciones: Atraer más usuarios con nuevas aplicaciones.
 	Oportunidades Económicas: Crear nuevas oportunidades económicas y efectos de red.

Avanzando en IA:

 	Investigador de IA: Descubrir nuevas ideas combinando información existente.
 	Meta Final: AGI Propiedad de Usuarios: IA más inteligente que expertos humanos, transformando la computación.

Principios:

 	Servir a los Usuarios: La IA debe servir y ser propiedad de individuos y comunidades.
 	AGI de Código Abierto: Para beneficiar a todos, toda IA y AGI deben ser de código abierto y propiedad de los usuarios.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusión:
La visión de NEAR.AI es democratizar la IA, asegurando que sea abierta y propiedad de los usuarios. Al involucrar a la comunidad, aprovechar el sólido ecosistema de NEAR y centrarse en el desarrollo de código abierto, NEAR.AI tiene como objetivo transformar la forma en que interactuamos con la tecnología. Este viaje, comenzando con enseñar a las máquinas a codificar y avanzando hacia la IA avanzada, promete un futuro donde la IA empodera a todos. Juntos, podemos construir un mundo digital más inclusivo e innovador.

### Введение в финансы Burrow

Burrow - это децентрализованная, некастодиальная платформа с процентными ставками на основе пулов, которая позволяет пользователям предоставлять активы для получения процентов и занимать против них для разблокировки ликвидности. Burrow аналогичен по своей природе Aave, Compound и другим протоколам на основе пулов.

Burrow работает нативно на блокчейне NEAR, который является блокчейном уровня 1, доказательством доли и разделенным на части блокчейном с временем выполнения WebAssembly. Смарт-контракты протокола Burrow написаны на Rust.

Цель Burrow - разблокировать ликвидность для активов с процентами, особенно для дериватов стейкинга уровня 1, таких как stNEAR и stETH. Например, пользователи Burrow смогут депонировать stNEAR в качестве залога, а затем занимать больше NEAR для создания маржинальной позиции стейкинга или занимать стейблкоин для создания саморасплачивающейся позиции.
Основные функции
Стейкинг $BRRR:
$BRRR - это внутренний токен Burrow Finance. Владельцы токенов BRRR могут участвовать в программе стейкинга BRRR, аналогичной модели ve-токенов, созданной Curve. Они могут стейкать свои токены BRRR и получать токены xBRRR. В результате держатели xBRRR будут получать увеличенные награды за предоставление и заем на Burrow.
Заем:
Пользователи могут занимать различные цифровые активы, предоставляя свои собственные активы в качестве залога. Например, можно депонировать stNEAR и занять дополнительные NEAR или другие токены. Этот механизм заема помогает пользователям использовать маржу или получать доступ к ликвидности без продажи своих активов.
Предоставление:
Burrow позволяет пользователям предоставлять широкий спектр активов в свои пулы ликвидности. Предоставленные активы приносят проценты, обеспечивая пользователям стабильный поток дохода.
Предстоящие функции
Стейкинг Brrr (Активно):

 	Зарабатывайте награды, Укрепляйте Burrow: Заблокируйте свои токены Brrr и зарабатывайте награды, поддерживая стабильность и рост экосистемы Burrow. Подумайте об этом как о модели ve-токенов CurveFinance!
 	Как это работает:

 	$BRRR: Внутренний управляющий токен Burrow, распределяемый активным пользователям и членам сообщества.
 	Стейк и Блокировка: Ставьте свои токены BRRR и зарабатывайте награды xBRRR.
 	Длительная блокировка = Больше наград: Чем дольше вы блокируете свои токены BRRR, тем больше xBRRR вы зарабатываете.






	

	
	
		
			
				How much is the total supply of $BRRR?
			
		

		
					

		
			
			
			
			10,000,000
		
			
			100,000,000
		
			
			1,000,000,000
		
			
			10,000,000,000
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





APY для одного токена Net (Активно):

 	Максимизируйте доходы, Минимизируйте риски: APY для одного токена Net обеспечивает оптимальные доходы, не зависящие от колебаний цен, помогая вам оптимизировать прибыль и снизить риски.
 	Точность и Потенциал: Ранее APY Net применялся равномерно ко всем депозитам. Теперь мы ввели точное разграничение, применяя APY к каждому отдельному токену в вашем портфеле. Это позволяет потенциально увеличить общий APY Net на основе комбинированных APY ваших токенов.

LP в качестве залога (2 квартал 2024 года):

 	Разблокируйте свою ликвидность: Используйте свои токены Liquidity Provider (LP) в качестве залога, расширяя использование ваших активов и увеличивая гибкость транзакций.

Торговля на марже (2 квартал 2024 года):

 	Увеличьте свою прибыль: Торгуйте с плечом и увеличьте свой потенциал заработка, расширяя свои торговые стратегии.



	

	
	
		
			
				What is the next feature of Burrow Finance?
			
		

		
					

		
			
			
			
			NFT Marketplace Integration
		
			
			DEX
		
			
			LP as Collateral
		
			
			Yield Farming
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Поощрение пользователей
Пользователи могут зарабатывать несколькими способами на Burrow Finance:

Удержание $BRRR: Каждый месяц Burrow будет использовать 40% дохода от стабильного пула и выкупать BRRR. Это приведет к увеличению цены BRRR.

Поставка активов: Поставляя активы в ликвидность пулы Burrow, пользователи могут легко зарабатывать прибыль с более чем 20 поддерживаемыми активами.
Поощрение и TVL 
Burrow Finance поощряет пользователей различными механизмами вознаграждения:
Награды за стейкинг:
Пользователи, стейкающие токены $BRRR, получают долю дохода протокола и дополнительные награды за стейкинг, увеличивая свою прибыль.

Майнинг ликвидности:
Участники, поставляющие активы в ликвидность пулов, зарабатывают награды в $BRRR, увеличивая свою общую доходность.
Награды за поиск ошибок:
Burrow предлагает значительные награды за выявление и сообщение о уязвимостях безопасности, с вознаграждениями до $250,000​ (Introduction | Ref Finance)​​ (Burrow Finance)​.

### Câu hỏi thường gặp về NCD

Với NEAR Protocol, bạn có thể tạo các ứng dụng phi tập trung (dApps) một cách dễ dàng và nhanh chóng. Sử dụng công nghệ blockchain, NEAR cung cấp một môi trường phát triển linh hoạt và an toàn cho các nhà phát triển. Bạn cũng có thể tham gia vào việc đóng góp vào mạng lưới NEAR bằng cách staking NEAR tokens của mình. Hãy khám phá ngay hôm nay!

 Khóa học Phát triển được chứng nhận bởi NEAR

Các cuộc họp có được ghi lại không?
Có, có các bản ghi cho mỗi nhóm học.

Chúng ta sẽ học gì trong một tuần?
Khóa học là cơ hội cho các nhà phát triển web kiếm được Chứng chỉ Hoàn thành đại diện cho khả năng thiết kế, phát triển, kiểm thử và triển khai các hợp đồng thông minh trên nền tảng NEAR.
Trong khóa học này, chúng ta thực hành các nội dung sau:


 	hiểu về web 3 trong bối cảnh lịch sử của con người
 	đọc mã hợp đồng bằng Rust và AssemblyScript
 	viết hợp đồng bằng Rust và AssemblyScript
 	kiểm thử hợp đồng bằng các bài kiểm thử đơn vị và mô phỏng
 	triển khai hợp đồng và giao diện người dùng hợp lý

Khóa học bao gồm nhiều hoạt động nghe, xem, đọc và viết. Đề xuất tối thiểu 2 giờ mỗi ngày nhưng có thể lên đến 4-6 giờ mỗi ngày, đặc biệt là đối với nhà phát triển có kinh nghiệm phát triển web dưới ba năm.

Chúng ta sẽ nộp gì vào cuối tuần?
Mỗi nhóm sẽ nộp một dự án được cấu trúc như ví dụ này: NEARly Neighbors
Dự án phải bao gồm các yếu tố sau:


 	mã nguồn hợp đồng (Rust, AssemblyScript hoặc cả hai)
 	kiểm thử đơn vị, tất cả đều chạy qua
 	kiểm thử mô phỏng, tất cả đều chạy qua
 	mockups (giao diện người dùng), nhưng không cần giao diện người dùng hoạt động
 	tài liệu (xây dựng, chạy kiểm thử, v.v.) để giúp người khác học từ công việc của bạn

Nếu bạn muốn một ví dụ cụ thể về tất cả điều này, vui lòng tham khảo NEARly Neighbors liên kết ở trên.

Bao nhiêu người tạo thành một nhóm?
Các nhóm nên có 3-5 người. Họ nên ở cùng múi giờ hoặc múi giờ tương tự để hợp tác thuận tiện hơn.

Sự khác biệt giữa NCD.L1 và NCD.L1v là gì?
Chứng nhận NCD cho Cấp độ 1 (L1) có 2 thành phần:


 	NCD.L1 các thành viên được chứng nhận - các thành viên của nhóm này tham gia một tuần của NCD và tham gia xây dựng và trình diễn để nhận "chứng chỉ hoàn thành"
 	NCD.L1v các nhà phát triển được xác minh - các thành viên của nhóm này hoàn thành NCD. l1 và vượt qua một cuộc phỏng vấn kỹ thuật 60 phút để nhận "chứng chỉ xác minh"

NCD.L1 là một tín hiệu về ý định học và cam kết của bạn đối với chương trình 5 ngày từ Khởi đầu đến Trình diễn.
NCD.L1v là một bản ghi có thể xác minh rằng bạn đã hiểu về tài liệu và có khả năng áp dụng nó vào thiết kế, phát triển, kiểm thử và triển khai Hợp đồng Thông minh NEAR
Để kiếm được L1v, các thành viên phải hoàn thành trước khóa học tiêu chuẩn NCD L1 với một bản demo và sau đó lên lịch một cuộc phỏng vấn kỹ thuật kép 60 phút với một chuyên gia xác minh.
Phiên xác minh sẽ bao gồm ít nhất một số hoạt động sau theo quyền của người xác minh:


 	Giải thích một hợp đồng hoạt động

 	Lý do về hành vi của một hợp đồng (hợp đồng cốt lõi, ví dụ học tập gần đây, v.v.)
 	Dự đoán tác động của một thay đổi trong hợp đồng
 	Tạo hướng dẫn sử dụng hợp đồng (lệnh CLI NEAR, cuộc gọi API, v.v.)


 	Khắc phục sự cố một hợp đồng bị hỏng

 	Sửa lỗi biên dịch
 	Sửa lỗi kiểm thử đơn vị không thành công
 	Sửa lỗi kiểm thử mô phỏng không thành công
 	Sửa lỗi chạy (logic hợp đồng, giao diện hoặc các vấn đề khác)


 	Cải thiện một hợp đồng hoạt động

 	Tối ưu hóa hợp đồng
 	Nâng cao tính năng hiện có
 	Thêm một tính năng mới
 	Tối ưu hóa hợp đồng (kích thước, tốc độ, lưu trữ, v.v)


 	Tạo một hợp đồng mới

 	Dịch một hợp đồng hiện có từ AssemblyScript sang Rust hoặc ngược lại
 	Thiết kế một hợp đồng mới như một cải tiến cho một hợp đồng hiện có
 	Thiết kế một hợp đồng hoàn toàn mới dựa trên yêu cầu (sẽ được cung cấp bởi người xác minh)
 	Thiết kế một hợp đồng hoàn toàn mới dựa trên ý tưởng ban đầu (của họ hoặc ý tưởng của người xác minh)



Kết quả của một phiên xác minh sẽ là một trong hai: (a) Đã xác minh hoặc (b) Chưa xác minh
Nếu bạn không vượt qua cuộc phỏng vấn xác minh, bạn có thể lên lịch lại phiên 1 lần (tối đa 2 lần) trước khi bị đưa vào danh sách chờ trong 180 ngày.

Có thể chuyển thẳng đến chứng nhận L3 trong trường hợp đã có một ứng dụng dApp đang chạy không?
Câu hỏi chính ở đây có thể là "tại sao cần được chứng nhận?" vì chứng nhận là một tín hiệu mà một nhà phát triển sẽ sử dụng để truyền đạt sự hiểu biết cho người khác như các nhà đầu tư tiềm năng, các đồng sáng lập và nhà tuyển dụng.
Nói cách khác, nếu bạn đã thành công trong việc ra mắt Instagram vào năm ngoái, không cần phải có Chứng chỉ Phát triển viên JavaScript để chứng minh rằng bạn đã làm được điều đó.
Nếu vì một lý do nào đó bạn muốn một chứng chỉ thì chắc chắn chúng tôi có thể phục vụ bạn.


 Giao thức NEAR

NEAR và Ethereum 2.0 so sánh như thế nào?
NEAR và Ethereum 2.0 đều giải quyết các thách thức tương tự: chi phí giao dịch cao, khả năng mở rộng và lưu lượng. Họ cũng áp dụng các phương pháp tương tự ở một số khía cạnh, nhưng rất khác biệt ở những khía cạnh khác.


 	Check out NEAR 102: Giới thiệu về NEAR cho các nhà phát triển Ethereum (Tháng 11 năm 2020)
 	Check out Alex Skidanov và Justin Drake về NEAR so với Ethereum 2.0 (Tháng 4 năm 2020)
 	Check out Tại sao NEAR không chỉ sao chép thiết kế Ethereum Serenity? (Tháng 11 năm 2018)

Thuật toán đồng thuận được sử dụng trong NEAR là gì?
Cơ chế đồng thuận được triển khai trên NEAR được gọi là Nightshade. Nightshade mô hình hóa hệ thống như một chuỗi khối duy nhất. Danh sách tất cả các giao dịch trong mỗi khối được chia thành các phần vật lý, một phần cho mỗi shard. Tất cả các phần đều tích lũy thành một khối. Lưu ý rằng các phần chỉ có thể được xác minh bởi các nút duy trì trạng thái của shard đó.

Lý thuyết, mỗi khối logic chứa tất cả các giao dịch cho tất cả các shard. Tuy nhiên, vì việc truyền một khối logic qua mạng sẽ rất tốn kém, nó không bao giờ được khởi tạo. Thay vào đó, mỗi người tham gia mạng duy trì trạng thái tương ứng với các shard mà họ xác minh giao dịch và bất kỳ shard bổ sung nào mà họ muốn theo dõi.

Đồng thuận dựa trên chuỗi nặng nhất. Nghĩa là, sau khi một nhà sản xuất khối công bố một khối, họ thu thập chữ ký của các nút xác minh. Trọng lượng của một khối sau đó là tổng cộng của tất cả các người ký có chữ ký của họ được bao gồm trong khối. Trọng lượng của một chuỗi là tổng trọng lượng của các khối. Ngoài ra, đồng thuận sử dụng một thiết bị cuối cùng giới thiệu các điều kiện cắt giảm bổ sung cho an ninh chuỗi cao hơn.

Để biết thêm thông tin về bảo mật, giao tiếp giữa các shard và vai trò xác minh, vui lòng tham khảo Bài báo Nightshade hoặc tóm tắt của chúng tôi trong tài liệu.

### Часто задаваемые вопросы о NCD

NEAR Протокол
NEAR Протокол - это децентрализованная платформа для создания децентрализованных приложений.
NEAR использует механизм консенсуса Proof of Stake (PoS) для обеспечения безопасности сети.
Благодаря технологии шардирования, NEAR обеспечивает масштабируемость и высокую производительность.



 NEAR Certified Developer Course

Записываются ли встречи?
Да, для каждой группы есть записи.

Что мы узнаем за неделю?
Курс предоставляет возможность веб-разработчикам получить сертификат, который подтверждает способность проектировать, разрабатывать, тестировать и развертывать умные контракты на платформе NEAR.
В ходе курса мы практикуем следующее:


 	восприятие веб 3 в контексте истории человечества
 	чтение кода контракта на Rust и AssemblyScript
 	написание контрактов на Rust и AssemblyScript
 	тестирование контрактов с использованием модульных и симуляционных тестов
 	развертывание контрактов и удобного пользовательского интерфейса

Курс включает много прослушивания, просмотра, чтения и написания. Рекомендуется минимум 2 часа в день, но вероятно, что разработчики с менее чем тремя годами опыта веб-разработки будут тратить от 4 до 6 часов в день.

Что мы представим в конце недели?
Каждая группа представит проект, структурированный как в примере: NEARly Neighbors
Проект должен включать следующие элементы:


 	исходный код контракта (Rust, AssemblyScript или оба)
 	модульные тесты, все проходят
 	симуляционные тесты, все проходят
 	макеты (пользовательский интерфейс), но рабочий интерфейс не требуется
 	документация (сборка, запуск тестов и т. д.), чтобы помочь другим изучить вашу работу

Если вам нужен конкретный пример всего этого, обратитесь к NEARly Neighbors, ссылка на которую указана выше.

Сколько человек составляют группу?
Группы должны состоять из 3-5 человек. Они должны находиться в одном (или в одинаковом) часовом поясе для более удобного сотрудничества.

В чем разница между NCD.L1 и NCD.L1v?
Сертификация NCD для уровня 1 (L1) имеет 2 компонента:


 	NCD.L1 сертифицированные участники - члены этой группы посещают одну неделю NCD и участвуют в создании и демонстрации для получения "сертификата о завершении"
 	NCD.L1v проверенные разработчики - члены этой группы завершают NCD. l1 и проходят 60-минутное техническое интервью для получения "сертификата верификации"

NCD.L1 - это сигнал вашего намерения учиться и вашего обязательства к 5-дневной программе от начала до демонстрации.
NCD.L1v - это подтвержденная запись того, что вы поняли материал и способны применять его к проектированию, разработке, тестированию и развертыванию умных контрактов NEAR
Для получения L1v участники должны сначала завершить стандартный курс NCD L1 с демонстрацией, а затем назначить 60-минутное парное техническое интервью с специалистом по верификации.
Сессия верификации будет включать как минимум некоторые из следующих действий по усмотрению верификатора:


 	Объяснение работающего контракта

 	Рассуждение о поведении контракта (основные контракты, примеры learn-near и т. д.)
 	Предсказание эффекта изменения контракта
 	Создание руководства по использованию контракта (команды NEAR CLI, вызовы API и т. д.)


 	Устранение неисправностей неисправного контракта

 	Исправление ошибки компиляции
 	Исправление неудачного модульного теста
 	Исправление неудачного симуляционного теста
 	Исправление ошибки времени выполнения (логика контракта, интерфейс или другие проблемы)


 	Улучшение работающего контракта

 	Рефакторинг контракта
 	Улучшение существующей функции
 	Добавление новой функции
 	Оптимизация контракта (размер, скорость, хранение и т. д.)


 	Создание нового контракта

 	Перевод существующего контракта из AssemblyScript в Rust или наоборот
 	Проектирование нового контракта как улучшение существующего
 	Проектирование совершенно нового контракта на основе требований (предоставляемых верификатором)
 	Проектирование совершенно нового контракта на основе оригинальной идеи (собственной или идеи верификатора)



Результатом сессии верификации будет одно из следующих: (a) Проверено или (b) Непроверено
Если вы не проходите интервью по верификации, вы можете перенести сессию 1 раз (максимум 2 попытки) перед тем, как попасть в список ожидания на 180 дней.

Возможно ли сразу перейти к сертификации L3 в случае, если у вас уже есть работающее dApp?
Ключевой вопрос здесь может быть "зачем вообще получать сертификат?", поскольку сертификация является сигналом, который разработчик будет использовать для общения с другими, такими как потенциальные инвесторы, сооснователи и работодатели.
Другими словами, если вы успешно запустили Instagram в прошлом году, нет необходимости получать сертификат разработчика JavaScript, чтобы доказать, что вы это сделали.
Если по какой-то причине вам нужен сертификат, то мы обязательно сможем вас принять.


 NEAR Protocol

Как NEAR сравнивается с Ethereum 2.0?
NEAR и Ethereum 2.0 решают схожие проблемы: высокие транзакционные издержки, масштабируемость и пропускная способность. Они также принимают сходные подходы в некоторых аспектах, но отличаются в других.


 	Проверьте NEAR 102: Введение в NEAR для разработчиков Ethereum (ноябрь 2020 года)
 	Посмотрите Алекса Скиданова и Джастина Дрейка о NEAR против Ethereum 2.0 (апрель 2020 года)
 	Посмотрите Почему NEAR не просто копирует дизайн Ethereum Serenity? (ноябрь 2018 года)

Какой алгоритм консенсуса используется в NEAR?
Механизм консенсуса, реализованный в NEAR, называется Nightshade. Nightshade моделирует систему как одну блокчейн. Список всех транзакций в каждом блоке разбивается на физические части, по одной части на каждый шард. Все части накапливаются в один блок. Обратите внимание, что части могут быть проверены только узлами, которые поддерживают состояние этого шарда.

Теоретически, каждый логический блок содержит все транзакции для всех шардов. Однако, поскольку передача логического блока по сети была бы чрезвычайно дорогой, она никогда не инициируется. Вместо этого каждый участник сети поддерживает состояние, соответствующее шардам, за которые они проверяют транзакции, и любому дополнительному шарду, который они хотят отслеживать.

Консенсус основан на консенсусе о самой тяжелой цепи. Это означает, что после того, как производитель блока публикует блок, он собирает подписи узлов-валидаторов. Вес блока затем равен совокупной ставке всех подписантов, чьи подписи включены в блок. Вес цепи - это сумма весов блоков. Кроме того, консенсус использует устройство окончательности, которое вводит дополнительные условия для снижения риска для более высокой безопасности цепи.

Для получения дополнительной информации о безопасности, межшаровом взаимодействии и ролях проверки, обратитесь к документу Nightshade или нашему резюме в документации.

– Источник: Обзор платформы уровня 1
Также связано:


 	Проверьте спецификацию консенсуса NEAR Protocol здесь
 	Посмотрите Белую книгу Nightshade
 	Посмотрите другие статьи и документы

### Examining NEAR Transactions



### Introduction to Burrow Finance

Burrow is a decentralised, non-custodial, pool-based interest rates platform that enables users to supply assets to earn interest, and to borrow against them to unlock liquidity. Burrow is similar in nature to Aave, Compound, and other pool-based protocols.

Burrow runs natively on the NEAR blockchain, a layer 1, proof-of-stake, sharded blockchain with a WebAssembly runtime. The Burrow protocol's smart contracts are written in Rust.

Burrow aims to unlock liquidity for interest-bearing assets, particularly layer 1 staking derivatives such as stNEAR and stETH. For instance, users of Burrow will be able to deposit stNEAR as collateral, then borrow more NEAR to create a leveraged staking position, or borrow a stablecoin to create a self-repaying position.
Core Features
$BRRR staking:
$BRRR is the native token of Burrow Finance. BRRR token holders can partake in the BRRR staking program, similar to the ve-token model pioneered by Curve. They can stake their BRRR tokens and receive xBRRR tokens. As a result, xBRRR holders will receive boosted rewards for supplying and borrowing on Burrow
Borrowing:
Users can borrow various digital assets by providing their own assets as collateral. For instance, one can deposit stNEAR and borrow additional NEAR or other tokens. This borrowing mechanism helps users to leverage their positions or access liquidity without selling their assets​
Supply:
Burrow allows users to supply a wide range of assets to its liquidity pools. The supplied assets earn interest, providing users with a steady stream of income.
Upcoming Features 
Brrr Staking (Live):

 	Earn Rewards, Empower Burrow: Lock up your Brrr tokens and earn rewards while supporting the stability and growth of the Burrow ecosystem. Think of it like CurveFinance's ve-token model!
 	How it works:

 	$BRRR: Burrow's native governance token, distributed to active users and community members.
 	Stake & Lock: Stake your BRRR tokens and earn xBRRR rewards.
 	Longer Lock = More Rewards: The longer you lock your BRRR, the more xBRRR you earn.






	

	
	
		
			
				How much is the total supply of $BRRR?
			
		

		
					

		
			
			
			
			10,000,000
		
			
			100,000,000
		
			
			1,000,000,000
		
			
			10,000,000,000
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Single Net Token APY (Live):

 	Maximize Returns, Minimize Risk: Single Net Token APY delivers optimal returns, unaffected by price fluctuations, helping you optimize profits and reduce risk.
 	Precision & Potential: Previously, NET APY was applied uniformly to all deposits. Now, we've introduced precise differentiation, applying APY to every single token in your portfolio. This allows for potential increases in overall NET APY based on the combined APYs of your tokens.

LP as Collateral (Q2 2024):

 	Unlock Your Liquidity: Use your Liquidity Provider (LP) tokens as collateral, expanding your asset usage and increasing transaction flexibility.

Margin Trading (Q2 2024):

 	Boost Your Profits: Trade with leverage and amplify your earning potential, expanding your trading strategies.



	

	
	
		
			
				What is the next feature of Burrow Finance?
			
		

		
					

		
			
			
			
			NFT Marketplace Integration
		
			
			DEX
		
			
			LP as Collateral
		
			
			Yield Farming
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






User Incentive
Users can earn in several ways on Burrow Finance:

Hold $BRRR: Every month, burrow will use 40% of the revenue from the stable pool and buy back BRRR. This will give BRRR a price increase

Supplying Assets: By supplying assets to the Burrow liquidity pools,. With over 20 supported assets, users can easily earn profits.
Incentive and TVL 
Burrow Finance incentivizes users through various reward mechanisms:
Staking Rewards:
Users who stake $BRRR tokens receive a share of the protocol’s revenue and additional staking rewards, enhancing their returns.

Liquidity Mining:
Participants supplying assets to the liquidity pools earn rewards in $BRRR, increasing their overall yield.
Bug Bounties:
Burrow offers substantial rewards for identifying and reporting security vulnerabilities, with bounties up to $250,000​ (Introduction | Ref Finance)​​ (Burrow Finance)​.

### Update – July 19, 2024

Brief Summary:

 	
Learn NEAR Club hits major milestone 100,000 members🕺



Results:

 	AI Assisted comments are back! Great comments get great tips 8nLEARNs

 	🔬NanoQuiz🕺 for exclusively 🌔Meteor wallet users is LIVE! We have some cool
https://learnnear.club/moon-quiz/
 	🔬NanoQuiz🕺 for exclusively 🔥Hot wallet users is LIVE
https://t.me/herewalletbot/app?startapp=web-tg-learnnear-club


 	📚(L)Earn about Important Update for NEAR Testnet Users🕺 and join waiting list for the next round of Wheel of Transactions
 	📚(L)Earn about Reclaim Protocol: Verifying HTTPS Data with Zero-Knowledge Proofs with NEAR🕺
 	📚(L)Earn about NEAR AI Master Plan🕺
 	📚(L)Earn about NEAR Protocol And TON🕺

 	🕺(L)Earner NFT holders can order exclusive sticker from LNC official swag store


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Next round of Wheel of Transactions coming soon!

### Important Update for NEAR Testnet Users

NEAR protocol released a new version (2.0.0-rc.1) for the NEAR testnet. This update includes two major changes:


 	Congestion control feature
 	Stateless validation improvements

Key Points:


 	Voting for the first change starts July 9, 2024, at 5:00 PM UTC
 	Voting for the second change starts July 10, 2024, at 5:00 PM UTC
 	This update requires changes to your database
 	No security-related changes are included

Action Required: If you're running a node on the testnet, you'll need to:


 	Update your software
 	Make some configuration changes
 	Possibly upgrade your hardware

Key Updates in NEAR Testnet Version 2.0.0-rc.1:


 	Congestion Control:

 	Limits transactions and receipts in overloaded shards
 	New fields in chunk headers to indicate shard load
 	Transactions may be rejected with "ShardCongested" error during heavy congestion


 	Stateless Validation:

 	Changes how nodes validate state transitions
 	Introduces two roles: chunk producers and chunk validators
 	Top 100 validators by stake become chunk producers
 	All validators serve as chunk validators


 	Hardware and Configuration Changes:

 	For top 100 validators:

 	Temporarily increase hardware capacity during upgrade
 	Set store.load_mem_tries_for_tracked_shards to true
 	Initially set tracked_shards to [0], then to [] after upgrade


 	For other validators:

 	Set store.load_mem_tries_for_tracked_shards to true after upgrade
 	Set tracked_shards to []


 	For non-validator nodes:

 	Set store.load_mem_tries_for_tracked_shards to false




 	Contract Changes:

 	New size limits for transactions and receipts
 	Increased cost for cross-shard communication


 	Network Optimization:

 	Recommended for all node operators



These changes aim to improve network efficiency and reduce resource requirements for most validators. Implementation will occur in stages, with voting for each protocol upgrade happening on separate days
For detailed instructions and more information, please check our GitHub page: https://github.com/near/nearcore/releases/tag/2.0.0-rc.1
In the coming days LNC will be running "Wheel of Transactions" to test the updated network.
Join waiting list here:

### Race of Sloths: Gamifying Open-Source Contributions

Race of Sloths, launched on July 8, 2024, is an innovative project aimed at gamifying open-source contributions and attracting more developers to the NEAR ecosystem. The name playfully alludes to the sometimes slow-paced nature of open-source development, with inspiration drawn from the sloth character in the animated film Zootopia.



	

	
	
		
			
				What is the primary goal of Race of Sloths?

			
		

		
					

		
			
			
			
			To speed up open-source development
		
			
			To gamify open-source contributions
		
			
			To replace traditional version control systems

		
			
			To create a new programming language
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





At its core, Race of Sloths features a friendly GitHub bot (@race-of-sloths) that contributors can mention in pull requests to earn "Sloths Points" and maintain contribution streaks. The project is powered by the NEAR Protocol, ensuring transparency and permissionless participation.



	

	
	
		
			
				How does Race of Sloths track contributions?
			
		

		
					

		
			
			
			
			Through email notifications
		
			
			By monitoring code commits directly
		
			
			Using a friendly GitHub bot (@race-of-sloths)
		
			
			Through manual entry by project managers
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Key features of Race of Sloths include:


 	Sloth Points: Similar to experience points in games, these are awarded for contributions.
 	Streaks: Completing streaks grants bonus points and can lead to new Sloth ranks.
 	Lifetime bonuses: Achieved at certain streak milestones, providing a permanent boost to earned points.

The scoring system, ranging from 0 to 13 points, is based on the significance and impact of the contribution. Maintainers have the flexibility to score pull requests according to their project's needs.



	

	
	
		
			
				What technology powers the Race of Sloths leaderboard and scoring logic?
			
		

		
					

		
			
			
			
			Ethereum blockchain
		
			
			NEAR Protocol
		
			
			Traditional SQL database
		
			
			Bitcoin network
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Race of Sloths aims to motivate developers at all levels, from beginners to experienced contributors. It adds an element of fun to open-source development while potentially boosting career opportunities for participants.
While introducing a competitive element, Race of Sloths ultimately emphasizes collaboration within the open-source community. As the team puts it, "The open-source is not about competition, at the end of the day it is about collaboration, so let's race together!"
This project represents an exciting new approach to incentivizing and recognizing open-source contributions, potentially reshaping how developers engage with collaborative software development.

### Ref Finance

Introduction to Ref Finance 
Ref Finance is a community-led, multi-purpose DeFi platform built on the NEAR Protocol.

Ref takes full advantage of NEAR’s low fees, one-to-two second finality, and WebAssembly-based runtime

In addition to the advantages of being built on top of NEAR, Ref Finance provides:

 	Multiple pools in one contract
 	Atomic transactions
 	Customizable pool fee




	

	
	
		
			
				How much is the total supply of $REF
			
		

		
					

		
			
			
			
			10,000,000
		
			
			100,000,000
		
			
			1,000,000,000
		
			
			10,000,000,000
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Core Features
Trade : Trade tokens with our automated market maker (AMM) exchange

Pool : Provide liquidity and earn revenue from swap fee

Farm: Stake LP tokens into farms and earn rewards in return

Stake: Stake REF tokens to earn more REF tokens, by earning fees generated by the protocol

Lending & Borrowing: Utilize Burrow Infrastructure, Lend your NEP-141 Token and Unlock asset liquidity all in one place

Perp: Utilize Orderly Infrastructure, Users can perform perp trading and order books easily
User Incentive
Ref Finance offers several ways for users to earn:

 	Liquidity Provision: Deposit tokens into liquidity pools to earn fees and receive LP tokens. Stake LP tokens in farms to earn REF tokens and other rewards.
 	Farming: Stake LP tokens in Ref Finance's farming section to earn additional REF tokens and other distributed rewards.
 	Staking: Stake REF tokens directly to earn rewards from platform fees, providing passive income.
 	Trading: Profit from trading activities on Ref Finance using various strategies like swaps and limit orders.
 	Yield Optimization: Optimize yields by strategically managing orders and liquidity using advanced features like chained swaps and concentrated liquidity.
 	Meme Season: Participate in staking memes to potentially earn additional profits.

These avenues allow users to engage flexibly and profitably within the Ref Finance ecosystem.




	

	
	
		
			
				Which CEX listed $REF?
			
		

		
					

		
			
			
			
			Binance
		
			
			Coinbase
		
			
			Gate, Mxc
		
			
			Bybit
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





User Experience 
Ref Finance prioritizes a seamless and user-friendly experience by offering:

 	Intuitive Interface: Lite and Pro versions for ease of use and advanced functionalities.
 	Low Fees and Fast Transactions: Built on NEAR Protocol, ensuring quick and cost-effective transactions.
 	Advanced Features with Simple Access: Supports multi-chain routing, customizable pool fees, and atomic transactions through an easy-to-use interface.
 	Security and Transparency: Regular audits and a bug bounty program to ensure user safety.

These features collectively provide a robust DeFi platform with a superior user experience.

 

### Reclaim Protocol: Verifying any Data with Zero-Knowledge Proofs with NEAR Protocol

Introduction
Want to use verified Uber ride data or Amazon purchase history to enhance your app while keeping user privacy intact? Discover Reclaim Protocol's powerful, seamless solution!

Overview
Reclaim Protocol's zkTLS infrastructure enables Web2 and Web3 users to generate verified credentials with zero-knowledge proofs, securely proving online data without revealing sensitive information. Unlike other solutions, no app or browser extension is needed, allowing users to seamlessly share selected data with third-party applications.

Reclaim SDKs simplify the integration of user activity, reputation, and identity from external websites into your platform.

Reclaim Protocol provides SDKs for web, mobile, and on-chain platforms. These SDKs enable you to build applications with access to user activity, reputation, and identity data from websites across the internet.
Example Use Cases

 	Ride Sharing Platforms: Import the number of rides a user has taken on Uber to build a competing ride-sharing platform.
 	E-Commerce Personalization: Import users' purchasing preferences from Amazon to provide targeted discounts.
 	Blockchain Economics: Enable economic features on a blockchain using users' off-chain activity data.
 	KYC: Use national IDs to perform Know Your Customer (KYC) verification.
 	And many more...

We have data providers from most popular websites. If the website you want to import data from isn't on the list, you can create your own data provider using our developer tools.
How It Works
Reclaim Protocol generates cryptographic proofs on HTTPS traffic. The type of cryptographic proof it generates is called a zero-knowledge proof. This allows the user to generate proof without revealing any information other than what they choose to share. The protocol is built upon open standards such as HTTPS and TLS.
Safety and Security
The user data is secured by the TLS protocol. This ensures that no third party, including Reclaim Protocol or the participating stakeholders (aka attestors), can see the data being transferred between the user and the website.
Publishing Reclaim Protocol Proofs on-chain on NEAR Blockchain
Prerequisite: 

 	Using our ReactSDK
 	Make sure you have Installed and funded near wallet either MyNearWallet or HereWallet.
 	You have installed NearCLI on your device.

Contract Deployment
If you don't need to add more checks and logic to on-chain contract, You can skip those steps and use our already deployed contract on the testnet.

1. Clone the near contract sdk repo

This Near contract (opens in a new tab) serves as a client to our Reclaim protocol. It instantiates Reclaim's contract, handles proofs, and verifies them.
git clone https://gitlab.reclaimprotocol.org/integrations/onchain/near-sdk

cd near-sdk

cargo near build
2. Create a new account or import an existing account

Use near-cli to create a new account or import an existing account.
near account import-account using-web-wallet network-config testnet
3. Deploy
 Deploy the contract with your account and the wasm file.
near contract deploy <ACCOUNT_ID\> use-file <PATH_TO_WASM_BUILD> with-init-call init text-args '' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
4. Add Epoch
 Send transaction to add epoch from the owner account.
near contract call-function as-transaction <ACCOUNT_ID\> add_epoch \

json-args '{"minimum_witness_for_claim_creation": 1, "epoch_start": 1717429000, "epoch_end": 1817429000, "witnesses": [{"address": "244897572368eadf65bfbc5aec98d8e5443a9072", "host": "reclaim.testnet"}]}' \

prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as <ACCOUNT_ID\> \

network-config testnet sign-with-keychain
Frontend Development
1. Cloning the frontend repo
git clone https://gitlab.reclaimprotocol.org/starterpacks/reclaim-near-example cd reclaim-near-frontend-example npm install
2. Code discovery (src/components/create-new-proof.js).

We will submit the proof on-chain once we get the onSuccessCallback. Fill in your Reclaim credentials marked with //TODOs.
import { Reclaim } from '@reclaimprotocol/js-sdk'

import { useState } from 'react'

import { useQRCode } from 'next-qrcode'




export const CreateNewProof = ({ setNewProof, setReadyToVerify }) => {

const [url, setUrl] = useState('')

const { Canvas } = useQRCode()




const reclaimClient = new Reclaim.ProofRequest('') //TODO: replace with your applicationId




async function generateVerificationRequest() {

const providerId = '' //TODO: replace with your provider ids you had selected while creating the application




reclaimClient.addContext(

`user's address`,

'for acmecorp.com on 1st january'

)




await reclaimClient.buildProofRequest(providerId)




reclaimClient.setSignature(

await reclaimClient.generateSignature(

'' //TODO : replace with your APP_SECRET

)

)




const { requestUrl, statusUrl } =

await reclaimClient.createVerificationRequest()




setUrl(requestUrl)




await reclaimClient.startSession({

onSuccessCallback: proofs => {

console.log('Verification success', proofs)

setNewProof(proofs[0])

setReadyToVerify(true)

// Your business logic here

},

onFailureCallback: error => {

console.error('Verification failed', error)

// Your business logic here to handle the error

}

})

}

return (

<div

style={{

display: 'flex',

alignItems: 'center',

justifyContent: 'center',

height: '50vh'

}}

>

{!url && (

<button

className='btn btn-secondary'

onClick={generateVerificationRequest}

>

Create New Proof

</button>

)}

{url && (

<Canvas

text={url}

options={{

errorCorrectionLevel: 'M',

margin: 3,

scale: 4,

width: 200,

color: {

dark: '#010599FF',

light: '#FFBF60FF'

}

}}

/>

)}

</div>

)

}
3. Code discovery (src/config.js)

If you deployed your own version of the contract, you will need to update the contractPerNetwork list with your contract's account address.
const contractPerNetwork = {

mainnet: 'todo()',

testnet: 'reclaim-protocol-testnet-hadi-sa.testnet' // Replace it with your contract's account address

}




export const NetworkId = 'testnet'

export const ReclaimNearContract = contractPerNetwork[NetworkId]




export const SMOKE_PROOF = {

identifier:

'0x9ec8f9f52623234433ce5ea0cc0f5aac0dfbeef553e68d2d403633bd9192e365',

claimData: {

provider: 'http',

parameters:

'{"body":"","geoLocation":"in","method":"GET","paramValues":{"CLAIM_DATA":"76561199614512180"},"responseMatches":[{"type":"contains","value":"_steamid\\">Steam ID: {{CLAIM_DATA}}</div>"}],"responseRedactions":[{"jsonPath":"","regex":"_steamid\\">Steam ID: (.*)</div>","xPath":"id(\\"responsive_page_template_content\\")/div[@class=\\"page_header_ctn\\"]/div[@class=\\"page_content\\"]/div[@class=\\"youraccount_steamid\\"]"}],"url":"https://store.steampowered.com/account/"}',

owner: '0xa1b6e6ffb85df5bdf78e6558d3224ab87f7cc4c7',

timestampS: 1717053708,

context:

'{"contextAddress":"user\'s address","contextMessage":"for acmecorp.com on 1st january","extractedParameters":{"CLAIM_DATA":"76561199614512180"},"providerHash":"0x5f5312e27124dc7605f70a7d884e169049679b93f91c137b4d18a8569d825900"}',

identifier:

'0x9ec8f9f52623234433ce5ea0cc0f5aac0dfbeef553e68d2d403633bd9192e365',

epoch: 1

},

signatures: [

'0xcbad077154cc5c8e494576d4336f57972f7412058c1a637e05832c6bdabd018f4da18ad973f29553921d7d030370032addac1159146b77ec6cc5dab4133ffec01c'

],

witnesses: [

{

id: '0x244897572368eadf65bfbc5aec98d8e5443a9072',

url: 'https://reclaim-node.questbook.app'

}

]}
 




	

	
	
		
			
				Reclaim Protocol can be integrated with both front-end and backend?
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






4. Submitting the proof

npm run dev

 	First, You will need to connect your near account.
 	Then, After requesting a proof from Reclaim and performing the verification on your end, a verify proof button will appear on the screen.
 	Finally, Clicking on the Verify Proof button will send a transaction.





Now your proof will get approved on-chain, here is the sample transaction

(opens in a new tab) from the screenshot above.




	

	
	
		
			
				What is the primary function of Reclaim Protocol's zkTLS infrastructure?
			
		

		
					

		
			
			
			
			To generate cryptographic proofs without revealing any sensitive information
		
			
			To provide a browser extension for secure data sharing
		
			
			To enable blockchain transactions without any proof
		
			
			To create social media profiles for Web3 users
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Demo on Publishing zero-knowledge proofs on NEAR Blockchain

1. Visit our website https://publish-credentials.reclaimprotocol.org/ and Connect your Near wallet.

2. Select a chain: for this demo, please select Near Testnet.




3. Proceed next and choose from the list for which you would like to generate proof. In our example, we are going to generate a proof of our amazon order count. 

4. Clicking on Generate Proof generates a QR code that can be scanned by any mobile camera.



5. Now using your mobile device, scan the QR code to login into your amazon account and this will generate a proof.

6. On successful login, reclaim protocol will generate a zk-proof within ~45 seconds. 

7. After zk-proof generation, the user gets redirected back to the original website sharing the generated proof.





	

	
	
		
			
				What standards does Reclaim Protocol use to ensure the security of user data?
			
		

		
					

		
			
			
			
			SSL and HTTP
		
			
			HTTPS and TLS
		
			
			SSH and FTP
		
			
			WEP and WPA
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR.AI Master Plan: A Simple Guide

NEAR.AI wants to create advanced AI that everyone can use and own. Here's the plan:

 	Teaching Machines to Code: AI Developer - First, they will create an AI that can learn to code.
 	Researching with AI: AI Researcher - Next, this AI will learn to do research.
 	Creating Advanced AI for Everyone - Finally, they will use this research to create powerful AI that belongs to everyone.

Promises:

 	Open Source: Everything will be open for everyone to use and improve.
 	Non-Profit: The NEAR Foundation, a non-profit organization, will lead this effort.
 	User Ownership: The goal is for users to own their AI.

NEAR Ecosystem:

 	Millions of Users: NEAR has tens of millions of users.
 	Growing Developer Community: More and more AI projects are joining NEAR.
 	Strong Funding: NEAR has the money needed to succeed.

NEAR's Current Product:

 	Easy-to-Use Blockchain: NEAR has a blockchain that is simple to use and develop on.
 	Many Active Users: More active users than any other blockchain.

Future Vision:

 	User-Owned AI: AI that works for you and keeps your data private.
 	Full Customization: Users can customize their AI experience completely.
 	Community and Brands: AI will help communities and brands work together and make transactions directly.

Building AI Developer:

 	Started in 2017: NEAR began by trying to create an AI-driven autocomplete.
 	Pivoted in 2018: They switched to building a decentralized platform.
 	Progress by 2024: Now, NEAR has millions of users and many daily active users.

Challenges in Blockchain:

 	Fragmentation: Products are spread across many blockchains.
 	Few Developers: Less than 7,000 full-time Web3 developers.
 	High Value of Web3 Code: Web3 code is valuable and costly to develop.

AI Developer's Role:

 	Efficiency Leap: Create Web3 products easily using simple language inputs.
 	Open Source Development: All software, datasets, and models will be open source.
 	Collaboration: Work together with other AI and Web3 projects.

Community Engagement:

 	New Applications: Involve the community to create new applications.
 	More Infrastructure: Need more than just blockchain, like peer-to-peer communication and private computation.
 	Leveraging NEAR Ecosystem: Use NEAR's existing token-based economy.

Benefits to NEAR Ecosystem:

 	More Applications: Attract more users with new applications.
 	Economic Opportunities: Create new economic opportunities and network effects.

Advancing AI:

 	AI Researcher: Discover new insights by combining existing information.
 	End Goal: User-Owned AGI: AI that is smarter than human experts, transforming computing.

Principles:

 	Serving Users: AI must serve and be owned by individuals and communities.
 	Open Source AGI: To benefit everyone, all AI and AGI must be open source and user-owned.




	

	
	
		
			
				What is the ultimate goal of NEAR.AI's master plan?
			
		

		
					

		
			
			
			
			To create a proprietary AI platform
		
			
			To build a centralized AI system
		
			
			To develop AI that replaces human jobs
		
			
			To create user-owned and open-source Artificial General Intelligence (AGI)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion:
NEAR.AI's vision is to democratize AI, ensuring it's open and user-owned. By engaging the community, leveraging NEAR's robust ecosystem, and focusing on open-source development, NEAR.AI aims to transform how we interact with technology. This journey, starting with teaching machines to code and progressing towards advanced AI, promises a future where AI empowers everyone. Together, we can build a more inclusive and innovative digital world.

### Introduction to Harvest $MOON

Harvest Moon is a play-to-earn game within Meteor Wallet. Players complete fun tasks to earn $MOON tokens, which can be used for rewards and airdrops on the platform. Our goal is to make digital finance easy and enjoyable for everyone, blending gaming excitement with the benefits of blockchain technology.
Core features
Harvests: Initially, you can harvest moonlight every two hours. As you progress, you can upgrade to extend these periods and increase the $MOON you collect based on your rate of Tinkers.



Lotteries: Each harvest offers a chance not only to gain $MOON tokens but also to win additional contracts, enabling you to recruit more Tinkers and boost your harvesting capacity.




	

	
	
		
			
				What type of Tinkers help you harvest the most $MOON?
			
		

		
					

		
			
			
			
			Researcher
		
			
			Scientist
		
			
			Genius
		
			
			Brain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Player Tiers: Level Up and advance through tiers by paying your own gas fees and utilizing wallet offerings, gaining access to enhanced rewards with each upgrade.

Upgrades: Improve your moonlight storage to extend harvest time and expand your lab capacity to recruit more Tinkers using $MOON.

Moonlight Relics: Enhance your $MOON per hour rate with relics, such as Harvest Moon NFTs or items crafted with the $GEAR token. (coming soon)

Missions: Engage in missions that build your blockchain expertise and utilize DeFi elements for benefits, earning rewards for activities like token swaps, crypto purchases, staking, and exploring new dApps. (coming soon)

Referrals: Boost your earnings by inviting friends; successful referrals will earn you an additional contract + 20% of their $MOON earnings, forever.




	

	
	
		
			
				How much percentage of $MOON can someone earn by inviting friends (referral)?
			
		

		
					

		
			
			
			
			10%
		
			
			20%
		
			
			 21%
		
			
			22.5%
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Security and Safety
Security is a top priority for harvesting $MOON using the Meteor Wallet. The platform employs robust security measures to protect users’ assets and transactions by requiring users to save their seed phrase and set up a password before they start any activity or transaction with Harvest $MOON or Meteor Wallet.
User Experience
Harvest $MOON, in conjunction with Meteor Wallet, delivers a superior user experience by combining user-friendly design, robust security, seamless transactions, and innovative features. Whether you're looking to earn, manage, or grow your digital assets, Harvest $MOON provides a reliable and enjoyable platform to achieve your goals.

 

### MITTE: революция в торговле NFT на протоколе NEAR

Введение в MITTE

MITTE — это современная платформа для торговли NFT, оптимизированная для мобильных устройств. Она специально разработана для улучшения пользовательского опыта на ходу. Построенная на блокчейне NEAR, MITTE стремится изменить способ торговли, управления и взаимодействия с NFT.

Основные функции

 	Пакетная торговля: MITTE позволяет торговать до 50 NFT одновременно, упрощая процесс и делая его более эффективным. Это экономит время и снижает транзакционные издержки для активных трейдеров.
 	Управление прибылью и убытками: Платформа включает инструменты для мониторинга прибыли и убытков по сделкам. Это помогает трейдерам принимать обоснованные решения, предоставляя информацию о результатах торговли в реальном времени.
 	Кураторские коллекции: MITTE предлагает отобранные коллекции для более безопасных и надежных транзакций. Эти коллекции выбираются по различным критериям, чтобы предоставить пользователям высококачественные и ценные NFT.
 	Система ордеров: Платформа использует интуитивно понятную систему ордеров, позволяя пользователям эффективно размещать заказы на покупку и продажу. Эта система обеспечивает прозрачность и улучшает общий торговый опыт.
 	Мобильная оптимизация: Одной из главных особенностей MITTE является оптимизация для мобильных устройств. Платформа полностью функциональна на мобильных устройствах, что позволяет торговать и управлять NFT в любое время и в любом месте.

Экосистема и преимущества

MITTE стремится улучшить экосистему NFT на базе NEAR, предоставляя достаточную ликвидность и привлекая как внутренний, так и внешний интерес. Функции платформы направлены на создание активной торговой среды, поощряя большее количество пользователей участвовать в рынке NFT на NEAR.

Безопасность

Безопасность — приоритет для MITTE. Платформа использует надежные меры безопасности для защиты активов и транзакций пользователей. Обеспечивая безопасную торговую среду, MITTE стремится создать доверие и надежность среди пользователей.

Пользовательский опыт

Пользовательский опыт на MITTE спроектирован так, чтобы быть плавным и интуитивно понятным. От простого интерфейса до эффективных торговых механизмов, каждый аспект MITTE создан для удобного и приятного использования как новичками, так и опытными трейдерами.

Заключение

MITTE выделяется как революционная платформа для торговли NFT, объединяющая мощь блокчейна NEAR с мобильной оптимизацией и удобными функциями. Предлагая пакетную торговлю, управление прибылью и убытками в реальном времени, кураторские коллекции и безопасную торговую среду, MITTE готова стать ведущей платформой в пространстве NFT.

Для получения более детальной информации вы можете ознакомиться с документацией MITTE.

### NEAR Protocol And TON

IMPORANT UPDATE
TON becomes the exclusive blockchain infrastructure powering Telegram’s Mini App ecosystem and supporting Telegram’s global user base of over 950 million monthly active users. Please carefully review  Developer guidelines
NEAR Protocol And The Open Network (TON)
NEAR and TON (The Open Network) are two of the most promising projects in the crypto ecosystem. NEAR offers users built-in features that include account abstraction and named accounts. The dApp (decentralized application) platform focused on user and developer-friendliness and was built by the NEAR Collective. On the other hand, TON is a decentralized layer-1 blockchain created by Telegram in 2018. However, it was abandoned shortly after.

This article will examine each project in more detail, including how it works, its ecosystem, uses, and more.
What is NEAR?
NEAR is a smart contract-capable, public Proof-of-Stake blockchain that provides developers with a platform for building decentralized applications (dApps). Built by the NEAR Collective, it competes primarily with Ethereum and other smart contract-enabled blockchains such as EOS and Polkadot. The protocol aims to improve upon Ethereum’s shortcomings in speed, scalability, and cost.

NEAR is faster and cheaper than Ethereum, processing up to 100,000 transactions per second. The protocol’s incredible scalability has the potential to revolutionize the world of smart contracts and decentralized applications. Key to the NEAR Protocol’s design and way of functioning is a concept called sharding. Sharding splits a network’s infrastructure into smaller segments, allowing nodes to handle only a fraction of the network’s total transactions. Sharding can create a more efficient way to retrieve network data and help scale the platform.

NEAR can be compared to data storage systems such as Amazon Web Services (AWS), which act as the base layer upon which applications are built. However, the critical difference is that NEAR is decentralized and maintained by a distributed network of computers (nodes). The protocol’s native token, NEAR, is used to pay for transaction fees and storage. Token holders can also stake their tokens, assuming the role of validators and helping the network achieve consensus.
The NEAR Collective 
The NEAR Collective is the entity behind the NEAR Protocol and consists of individual organizations and other contributors who constantly work to improve it. The organization works on projects, writing their initial code and helping with their implementation on NEAR. The NEAR Collective also helps in development and governance activities. While the NEAR Collective has developed NEAR, the protocol is entirely decentralized. It operates independently and cannot be shut down or manipulated.
How does the NEAR Protocol work? 
NEAR Protocol is a Proof-of-Stake blockchain. The Proof-of-Stake mechanism requires token holders to stake a certain number of tokens to be eligible to validate blocks. Key to the protocol’s functioning is its consensus algorithm - Nightshade.
Nightshade
Nightshade is NEAR Protocol’s sharding solution, which allows NEAR to distribute the computational workload into manageable chunks. Thanks to Nightshade, each participating node must store only a small subset of the platform’s data. Nodes can then process these ‘chunks’ of information and add them to the main chain.

One of Nightshade’s main benefits is that it significantly reduces the number of potential points of failure. This is because each node is responsible for only a small amount of data and maintains only a small portion of the chain, greatly increasing efficiency.




	

	
	
		
			
				What is NEAR’s consensus algorithm?
			
		

		
					

		
			
			
			
			Ouroboros
		
			
			BFT
		
			
			Nightshade
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Validators also play a crucial role on NEAR and are responsible for maintaining consensus within the protocol. They must keep their servers online at all times and their systems updated. Validators are determined in every new epoch and are elected based on their stake. Validators who have already been elected can be re-elected by re-staking their tokens and accrued rewards. Meanwhile, any potential validator must have their stake above a predetermined level.
What are NEAR Accounts? 
As mentioned earlier, NEAR supports human-readable addresses. There are two types of NEAR accounts: Implicit addresses and Named addresses.
Implicit Address
Implicit address accounts are denoted by a 64-character address corresponding to a public/private key pair. To use this type of account, users must fund it with their NEAR tokens or pay the gas fee for the transaction.
Named Address
NEAR also allows users to register named accounts that are much simpler to share and remember. Named accounts can also create sub-accounts, effectively acting as domains.
What Is TON?
TON (Toncoin) was originally built by Telegram in 2018. At the time of its creation, Telegram raised $1.7 billion in private funding for its new blockchain, intended as a competitor to Ethereum. However, it abandoned the project after the United States Securities and Exchange Commission entered the picture and sued, alleging that $TON, its native token, was a security. After Telegram abandoned the project, it was picked up by developers unaffiliated with Telegram, taking over the ton.org domain name and the Toncoin code repository. Toncoin then launched the TON blockchain and the TON token.




	

	
	
		
			
				TON is short for:
			
		

		
					

		
			
			
			
			The Open Network
		
			
			Telegram Open Network 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






TON is a decentralized Layer1 smart contract network created for financial applications and NFTs. So far, over a million NFTs have been minted. Like NEAR, TON is a Proof-of-Stake blockchain that delivers a highly scalable network ideal for financial transactions. It also facilitates interactions between users over an immutable financial infrastructure. The TON blockchain stands out for its scalability and high performance. It created a record of sorts when it processed 55,000 transactions per second, which was made possible by its unique multi-level architecture, combining the main chain with multiple other word chains.
How Does TON Work?
Four aspects are crucial to TON’s functioning: proof-of-stake consensus, Sharding, the TON Virtual Machine, and its native token, Toncoin.
Proof-of-Stake Consensus 
Consensus is how nodes on the network agree upon the current and valid state of the network. TON uses the energy-efficient Proof-of-Stake consensus mechanism. Validators can stake their tokens and earn rewards for their contribution to securing the network. At the time of writing, TON has 329 validators and 511,880,772 $TON staked. Validators receive $TON tokens for each block they validate. TON’s Block-Proof-of-Stake ensures that the network continues to run even if all validators cannot participate in the consensus.
Sharding 
Sharding helps increase blockchain scalability and is also used by NEAR. Sharding divides TON into smaller components called shards. Each shard is assigned a specific role, helping the blockchain maintain a global state. Maintaining a global state helps eliminate the need for network nodes to process every transaction, bringing in greater efficiency.
The TON Virtual Machine (TVM)
The TON Virtual Machine plays a role similar to that of the Ethereum Virtual Machine, computing commands from contract applications and changing the network state after each execution. Through the TVM, developers can create applications that can automate various processes, such as asset minting, asset transfers, and signing messages on the network.
Toncoin 
Toncoin ($TON) is the native cryptocurrency of TON and has multiple uses in the TON ecosystem. The token is used to pay transaction fees, staking, and protocol governance.
Transaction Fees 
The $TON token is used to pay for transactions on the TON Network. Users must use the tokens to process transactions or pay gas fees. The token is also used to pay for TON Network storage and blockchain-based domain names.
Governance 
The $TON token plays a crucial role in governance. $TON token holders can vote on proposals and have a say in the network’s future.
Staking 
$TON token holders can also stake their tokens, acting as validators, helping to validate transactions and secure the network. Users can stake their tokens directly on the network or through major cryptocurrency exchanges.




	

	
	
		
			
				What consensus mechanism do NEAR and TON use? 
			
		

		
					

		
			
			
			
			Proof-of-Work
		
			
			Proof-of-Stake
		
			
			Proof-of-Authority 
		
			
			Delegated Proof-of-Stake 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Future Plans For NEAR and TON
NEAR - User-Owned AI
NEAR is advancing User-Owned AI by integrating AI research and applications into its blockchain ecosystem. The NEAR.AI R&D Lab aims to develop AI that creates end-to-end Web3 applications from user intents. By leveraging its large user base, developer ecosystem, and financial resources, NEAR seeks to attract top AI talent and build a decentralized AI infrastructure that empowers users and communities.
TON - Further Telegram Integrations
The expansion of TON’s utility within Telegram is undoubtedly the most exciting thing about TONCoin. As per Telegram Founder Pavel Durov, users will be able to pay for advertising in TON and tip channel administrators. Soon, stickers can be bought and sold as NFTs, with artists receiving 95% of the proceeds. Users will also be able to share TON, log into accounts using crypto wallets, and register and sell account names.
In Closing 
NEAR and TON are innovative platforms that have revolutionized the dApp and smart contract landscape. With its focus on speed, scalability, and user-developer friendliness, NEAR has emerged as a worthy alternative to Ethereum. Meanwhile, TON is rapidly attracting investors and developers. Its Telegram integration also gives the network access to over 700 million potential users.
Vote NOW!

                 
 
                        Which blockchain you use more often?(Required)
			
					
					NEAR
			
			
					
					TON
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)
			
			
					
					16 nLEARNs (FOUR votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                


 

### Update – May 29, 2024

Brief Summary:

 	
April and May have been full of (l)earning opportunities!


Results:

 	🤑April and May redeem went smooth - over 1,000 (L)Earners got rewards for learning about NEAR and NEAR ecosystem projects!


 	🧪NameSky and LNC Nanoquiz beta tests🕺 completed - over 70 NEAR were claimed.


 	We just updated LNC NEAR Info bot - just type in the near account and get useful info without leaving TG

 
 	WooNFT  project fromat ⚗LNC Barrel🕺 got a $$$ bounty from our (l)earning partner Mintbase

Have an exiting idea and ready to bring it to NEAR mainnet? Join LNC Barrel now!

 

 	Join @meta_pool on exciting journey towards multichain governance - become MP Ambassador!
Enroll to FREE certification course now!









 	📚(L)Earn How NEAR protocol works today🕺


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	🕺(L)Earner NFT holders: stay tuned for exciting news!

### MITTE: Revolutionizing NFT Trading on NEAR Protocol

Introduction to MITTE

MITTE is a cutting-edge NFT trading platform optimized for mobile devices, specifically tailored to enhance user experience on the go. Built on the NEAR blockchain, MITTE aims to revolutionize the way users trade, manage, and interact with NFTs.

Core Features

 	Batch Trading: MITTE allows users to trade up to 50 NFTs simultaneously, streamlining the trading process and making it more efficient. This batch trading capability is designed to save time and reduce transaction costs for active traders.



	

	
	
		
			
				What is the maximum number of NFTs that can be traded simultaneously on MITTE?
			
		

		
					

		
			
			
			
			10
		
			
			25
		
			
			50
		
			
			100
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





 	Profit and Loss Management: The platform includes tools for users to monitor their profit and loss on trades. This feature helps traders make informed decisions by providing real-time insights into their trading performance.



	

	
	
		
			
				Which feature of MITTE helps users monitor their trading performance in real-time?
			
		

		
					

		
			
			
			
			Curated Collections
		
			
			Order Book System
		
			
			Profit and Loss Management
		
			
			Mobile Optimization
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





 	Curated Collections: MITTE offers curated collections to ensure safer and more reliable transactions. These collections are selected based on various criteria to provide users with high-quality and valuable NFT options.
 	Order Book System: The platform utilizes an intuitive order book system, allowing users to place buy and sell orders efficiently. This system is designed to provide transparency and improve the overall trading experience.
 	Mobile Optimization: One of MITTE’s standout features is its mobile optimization. The platform is designed to be fully functional on mobile devices, allowing users to trade and manage their NFTs anytime and anywhere.

Ecosystem and Benefits

MITTE is focused on enhancing the NEAR NFT ecosystem by providing ample liquidity and attracting both internal and external interest. The platform’s features are geared towards creating a vibrant and active trading environment, encouraging more users to participate in the NEAR NFT market.



	

	
	
		
			
				What is one of the primary focuses of MITTE in enhancing the NEAR NFT ecosystem?
			
		

		
					

		
			
			
			
			Reducing transaction fees
		
			
			Providing ample liquidity
		
			
			Developing new NFTs
		
			
			Developing new NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Security and Safety

Security is a top priority for MITTE. The platform employs robust security measures to protect users’ assets and transactions. By ensuring a secure trading environment, MITTE aims to build trust and reliability among its users.

User Experience

The user experience on MITTE is designed to be seamless and intuitive. From the straightforward interface to the efficient trading mechanisms, every aspect of MITTE is crafted to provide a smooth and enjoyable experience for both novice and experienced traders.

Conclusion

MITTE stands out as a revolutionary NFT trading platform that combines the power of the NEAR blockchain with mobile optimization and user-friendly features. By offering batch trading, real-time profit and loss management, curated collections, and a secure trading environment, MITTE is poised to become a leading platform in the NFT space.

For more detailed information, you can explore the MITTE documentation.

 

### LNC NanoQuiz Seed Phrase beta test

Follow @LearnNEAR and @here_wallet

Beta test sprint starts: May 16, 9 am ET
Beta Test sprint ends: May 20, 9 am ET
Requirements:

 	Get yourself HOT wallet at Telegram https://t.me/herewalletbot
 	Open LNC NanoQuiz
http://t.me/herewalletbot/app?startapp=web-tg-learnnear-club

Carefully review the quiz materials and answer the questions
 	Take a screenshot with any correct answer so your account name is visible
 	Submit results.
 	Tweet with your screenshot “@LearnNEAR NanoQuiz - learn web3 in seconds  without leaving your messenger”
 	Tell us what do you think about the process.

Fill the Feedback form
The top 20 beta testers will get 1 NEAR, the best feedback submitter will get 5 NEAR.

Happy Testing!

If any question for the test feel free to contact at Telegram  https://t.me/LearnNEARClub/23570



 

### Mintbase Drops

Mintbase has made it easy to use NFTs by removing complex codes. Now, you don’t need to buy cryptocurrency to make or collect NFTs because Mintbase Wallet handles all the fees.

Fans can pick a username that also works as their wallet address, and your collectible item will automatically appear in their account. Then, Mintbase provides many tools to help you create interesting marketing campaigns. Spend less time on ineffective marketing and use our advanced tools to share your true message.

Engage Your Audience: Our token drops catch attention and encourage people to interact, which makes them more excited and active on different platforms.

Identify Your Advocates: Mintbase Drops help you find and develop relationships with loyal fans who can spread the word about your brand.

Seamless Connectivity: Easily reach your audience through social media, email, and messaging apps, making your relationships stronger and your engagements better.

Convert Supporters: Find new ways to make money by offering fans new ways to enjoy your content and products.

What You Need to Start a Drop

 	Create a Wallet Account: Mintbase lets you create a wallet easily. No complicated codes, just a wallet with your name or brand to build trust.
 	Prepare Your Drop: Set up your drop with your content. Your images, titles, and descriptions will show up automatically on social media. Use an interesting title to show the value of your token drop.
 	Promote Your Drop: Share your drop on social media, in email newsletters, and other platforms. Encourage your followers to join and tell others. Track who clicks through from emails, and on social media, see who is most excited to participate.
 	Manage Your Drops: Use Mintbase Wallet’s simple interface to keep track of all your drops in one place. Stay organized and check how successful each drop is.

Next Steps After starting with Mintbase, you can use many tools to keep your audience interested and make money from your content. Look at Mintbase Templates for ideas, or contact us to explore new partnerships and build together.

### How NEAR protocol works today

The NEAR Protocol has developed several innovative technologies that significantly enhance the efficiency, scalability, and usability of its blockchain. This article explores the key components of NEAR’s blockchain advancements, including its hybrid consensus mechanism known as Doomslug, the Nightshade sharding solution, stateless validation, and the improved user and developer experience.

https://youtu.be/YGUeTu4Cco4?si=7AI1I-IqCq_rK_lV

Doomslug: A Hybrid Consensus Mechanism
NEAR Protocol utilizes a unique consensus mechanism called Doomslug, which combines elements of Byzantine Fault Tolerance (BFT) with a non-BFT consensus approach. This hybrid system allows for faster block production by simplifying the consensus process. Instead of requiring immediate finalization, blocks are produced quickly and finalized over time as more blocks are built on top of them. Validators participate by sending approvals to subsequent block producers, streamlining the block production and minimizing latency, thus maximizing throughput.




	

	
	
		
			
				What is the name of NEAR Protocol's unique hybrid consensus mechanism?
			
		

		
					

		
			
			
			
			QuickConsensus
		
			
			 Doomslug
		
			
			FastTrack
		
			
			NEARConsensus
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nightshade: Simplifying Blockchain Sharding
The Nightshade design integrates all shard chains into a single blockchain, eliminating the complexities associated with traditional sharded blockchains. This approach does away with the need for a main chain or relay chain to coordinate shards, simplifying cross-shard transactions and reducing potential bottlenecks. Each shard contributes a chunk (a shard-specific block) to the overall blockchain, maintaining its integrity and continuity. Nightshade enhances data availability and security through erasure coding, which ensures that even with partial data loss, the network can recover the full dataset from the distributed pieces among validators.




	

	
	
		
			
				Which of the following best describes the Nightshade sharding solution?
			
		

		
					

		
			
			
			
			It integrates all shards into a separate relay chain
		
			
			It uses a single chain that includes all shard chains, eliminating complex cross-shard transactions.
		
			
			It requires each shard to operate independently with its own consensus
		
			
			It eliminates the use of shards in the blockchain system
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Stateless Validation: Addressing Validator Efficiency
Stateless validation is a groundbreaking feature in NEAR Protocol that addresses challenges related to state growth and validator resource requirements. By allowing validators to verify transactions without maintaining a complete state, the system reduces the computational and storage demands on individual validators. This setup not only facilitates faster and more frequent validator reassignments across shards but also enhances security by making it difficult for attackers to predict validator assignments. Stateless validation significantly lowers the barriers to entry for validators, potentially increasing the decentralization and robustness of the network.
Enhancing User and Developer Experience
NEAR Protocol focuses on simplifying the user and developer experience through several intuitive features:

 	Function Call Access Keys: These keys allow users to interact with specific functions of a smart contract without exposing their entire account, enhancing security and usability.
 	Chain Signatures: This feature enables transactions across different blockchains, allowing NEAR accounts to interact seamlessly with other blockchain environments. It simplifies the process of managing cross-chain interactions, reducing the complexity for users.
 	Simplified Account Management: NEAR’s account model is designed to be user-friendly, supporting features like multisig configurations and flexible permission settings for external applications.

### Name Sky Beta Test - Create and mint

Follow @LearnNEAR and NameSky on X

Beta test sprint starts: April 11, 9 am ET
Beta Test sprint ends: April 15, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Go to NameSky on Testnet https://testnet.namesky.app/mint 
 	 Create and mint 2 more cool NEAR testnet accounts at NEAR wallet
 	Take a screenshot with the NFT you just created and minted
 	List an account for sale
 	Buy an NFT from the Marketplace
 	Take a screenshot with the NFT you bought
 	Tweet with your screenshot “I’ve just created and minted cool NEAR account name as NFT at @NameSkyApp  project from @LearnNEAR Barrel”
 	Tell us what do you think about the process.

Fill the Feedback form
The top 20 beta testers will get 1 NEAR, the best feedback submitter will get 5 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead at Telegram  https://t.me/namesky_support



 

### What is your favorite NEAR Wallet 2024?



### Update – April 9, 2024

Brief Summary:

 	
2 Rounds ⚔Wheel of Transactions over 3,000,000 transaction sent🚀


Results:

 	2 Rounds ⚔Wheel of Transactions over 3,000,000 transaction sent🚀. We are processing the submissions, rewards should be available for claim next week
 	March redeem went smooth - over 500 (L)Earners got rewards for learning about Chain Abstraction and using AI while learning!


 	🧪NEAR docs broken links audit completed, rewards claimed by approved submitters



 	🧪NEAR onboarding bot Beta Test completed, many thanks to those who provided feedback.You still can to the digital twin of Illia Polosukhin by tagging @NEAR_Onboarding_Bot  LNC TG chat

 
 	New project is actively brewing at ⚗LNC Barrel🕺 - WooNFT - worth to check!

Have an exiting idea and ready to bring it to NEAR mainnet? Join LNC Barrel now!
 	📚(L)Earn about Plato Eat2Earn - Imagine earning while enjoying your favorite meal!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Cool integration with Here wallet is coming!

### NFT art for WooCommerce products

WooNFT is a user-friendly WooCommerce plugin designed to allow customers to easily mint NFTs via Mintbase for their purchased products. It effectively combines e-commerce with the digital asset sphere by covering all costs and fees, thus offering real value through digital ownership. The project comprises three main elements:

 	WooCommerce Plugin: This is the project's foundation, seamlessly integrating with the WooCommerce platform. It enhances product pages with a "Claim a free NFT" button, allowing customers to start the NFT minting process post-purchase.
 	Serverless/Edge Functions API: This component enables the automated creation and minting of NFTs, incorporating capabilities for image generation via OpenAI’s API, image modification, and blockchain interaction for NFT minting. Serving as a bridge between the WooCommerce plugin and blockchain technology, this API ensures the process is both efficient and scalable.
 	Mintsa Clone App: Acting as a digital exhibition space, this app displays NFTs minted through the plugin. Linked directly to the plugin’s contract on Mintbase, it offers a visual and interactive environment for users to engage with their NFTs. Visit https://woonfts.yoshi.tech to explore.

User Experience:

 	Initiation: Post-purchase, customers can mint an NFT for their product by clicking the “Claim a free NFT” button on the checkout completion page.
 	Image Generation: An exclusive digital artwork is crafted, inspired by the purchased product.
 	Minting Process: Customers are directed to create a Bitte wallet, followed by a guide through the transaction signing process to mint their NFT.
 	Finalization: Customers are returned to the store's thank you page, greeted with a congratulatory note and a link to view their NFTs on Mintbase.

How to Use: Simply navigate to the Shop section, make a purchase (note: no real payment is required), and post-checkout, you’ll have the opportunity to claim NFTs for your items, with one NFT per item.

Conclusion: This plugin narrows the divide between conventional e-commerce and the emerging NFT landscape, providing a distinct value proposition to customers. It not only makes products more attractive but also familiarizes customers with digital asset ownership by integrating the NFT minting experience into the shopping journey.

### Introducing a Revolutionary Way to Engage with the NEAR Ecosystem

In the dynamic world of blockchain technology, staying informed and understanding complex protocols can be challenging. A new digital innovation now offers a unique solution, enabling users to interact directly with a digital representation of Illia Polosukhin, co-founder of the NEAR Protocol. This digital twin is designed to provide insights into the protocol, its ecosystem, and the latest technological advancements, making it an invaluable resource for developers, investors, and enthusiasts alike.
How the Digital Twin Supports Users
The digital twin of Illia Polosukhin offers several key benefits for users seeking to deepen their understanding of the NEAR ecosystem:

 	Instant Access to Expertise: Users can gain insights into the NEAR Protocol, understand complex concepts, and stay updated with the latest developments in the ecosystem through interactive conversations.
 	Personalized Interactions: The digital twin provides a personalized experience, offering information and answers tailored to the user's specific interests and level of understanding.
 	Enhanced Learning Experience: Engaging in natural, conversational interactions with the digital twin allows users to learn about the NEAR ecosystem in a more intuitive and engaging manner.
 	Accessibility: Available around the clock, the digital twin provides users with the flexibility to explore the NEAR ecosystem at their convenience.

Interacting with the Digital Twin
To interact with the digital twin of Illia Polosukhin, users can interact in 2 ways:

 	directly with the bot using this link

 	https://www.delphi.ai/illia-polosukhin


 	Telegram bot linked to the model. By mentioning @NEAR_Onboarding_Bot in a channel, group, or direct message, the model will generate a response and provide supplementary links for additional education when necessary.
You can try it right now at LNC TG chat

This seamless integration allows for easy access and interaction, ensuring that users can engage with the digital twin whenever they have questions or need guidance.
Areas of Expertise
The digital twin is equipped to answer queries across a wide range of topics related to the NEAR Protocol and its ecosystem, including:

 	Protocol Fundamentals: Understanding the core principles and functionalities of the NEAR Protocol.
 	Ecosystem Overview: Insights into the projects, applications, and initiatives within the NEAR ecosystem.
 	Technological Advancements: Information on the latest developments, such as data availability solutions, chain abstraction techniques, and more.

Example of an Output
When a user asks about chain abstraction, using the direct link to the model, the digital twin might respond with:



Or, if a user asks about the HOT telegram wallet inside of telegram, the digital twin might respond with: 

LNC invites you to Beta Test - talk to Illia's digital twin, provide feedback and earn some NEAR!

### NEAR onboarding bot Beta Test

Follow @LearnNear and @NEARFoundation on X

Beta test sprint starts: March 29, 11 am ET
Beta Test sprint ends: April 5, 11 am ET
Requirements:

 	Read this Guide about Revolutionary Way to Engage with the NEAR Ecosystem to get the context
 	Go to tbd https://www.delphi.ai/illia-polosukhin
 	Ask Illia digital twin a few questions about NEAR and NEAR ecosystem
 	Choose the best and the worst question/answer (you will need to submit them)
 	Make a screenshot of your best question/answer
 	Tweet your screenshot and "For the first time ever I asked digital twin of @ilblackdragon a question and this is the reply! You can do the same at   @LearnNear Beta test"
 	Submit feedback form.

The top 25 beta testers will get 1 NEAR, the best feedback submitter will get 5 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic  and tag @dan_web3
Fill the Feedback form

### Plato Eat2Earn

Introduction

 	Hook: Imagine earning while enjoying your favorite meal. How? Let's dive into the world of Plato Eat2Earn.
 	Overview: Plato is a revolutionary Eat2Earn Web3 project that gamifies the dining experience, enabling users to earn rewards through their dining
 	activities worldwide at ANY restaurant, eateries establishments (as long as it is on Google Maps you will be able to Eat2Earn on Plato Eats dApp).
 	Relevance: Plato addresses the gap in authentic, user-generated content about dining experiences, offering verified data and incentivizing users, which enriches the global food scene. In turn, Eat2Earn brings foot traffic into restaurants for in-person dining, which helps local restaurants get more business!




	

	
	
		
			
				What’s the purpose of Plato’s Eat2Earn?
			
		

		
					

		
			
			
			
			Drive foot traffic into local restaurants
		
			
			Reward Plato users to gather authentic, user-generated reviews, verified by receipt
		
			
			Plato users get $FAT Dollar
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The Inspiration Behind the Project

 	Origin Story: Plato was born from a necessity observed during COVID, when many restaurateurs, including PlatoRob’s uncle, grappled with the steep commissions charged by food delivery platforms like DoorDash and Uber Eats. Witnessing firsthand the struggle to sustain business with a 30% commission on every dollar made, Plato Eat2Earn emerged with a mission to revitalize the restaurant industry. It aimed to redirect foot traffic back to restaurants for in-person dining, offering a more profitable model amidst challenging times.
 	Vision and Mission: The vision is to establish the world's first verified food data source, transforming how people discover dining experiences via AskPlato - AI Connoisseur. The mission revolves around incentivizing dining enthusiasts to share authentic experiences.




	

	
	
		
			
				What makes Plato distinct from traditional review platforms?
			
		

		
					

		
			
			
			
			It utilizes social media for reviews
		
			
			It's based on blockchain technology, ensuring review authenticity and rewarding users
		
			
			It only allows reviews from professional critics
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How It Works: A Simplified Explanation

 	Technical Overview: Utilizing blockchain technology, Plato rewards users with $FAT Dollars for contributing verified dining experiences through its Plato Eats dApp.
 	Features and Benefits: Rewards for dining experiences. Verified food data source. Enhanced discovery of dining options.
 	Real-world Application: Users can earn $FAT Dollar by dining at any restaurant located on Google Maps, contributing by leaving a review and uploading their receipt. the community benefits from authentic, reliable dining recommendations from real people which will result into driving more foot traffic to the restaurant
 	$FAT Dollar Value and Rewards System: $FAT Dollar Value and Rewards System combines tangible rewards with real-world value, each $FAT Dollar is equivalent to 1 USDC at Token Generation Event (TGE). Users earn rewards by leaving honest reviews, calculated as a percentage of their spend, fostering quality content and active engagement. This system not only rewards users but also drives increased foot traffic to restaurants, benefiting both consumers and establishments by encouraging exploration and sharing of genuine dining experiences, thus sustaining a valuable cycle within the ecosystem.




	

	
	
		
			
				What is the value of $FAT Dollar at Token Generation Event?
			
		

		
					

		
			
			
			
			Equivalent to 1 USDC
		
			
			Fluctuates based on market demand
		
			
			Equal to the value of 1 BTC
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Unique Selling Points

 	Comparison: Unlike other review platforms, Plato's blockchain foundation ensures authenticity and rewards contributors, offering a more reliable and rewarding experience.
 	Innovations: The integration of blockchain and AI for receipt verification and rewards users for leaving an authentic review, alongside the "Ask Plato AI" feature to find hidden gems nearby, sets Plato apart in the tech and dining industry.

Getting Started
User Guide: To get started, download the Plato Eats dApp, sign up, and begin dining at a restaurant to earn rewards.

Resources: More information, tutorials, and community support are available on the Plato Protocol documentation site and community forums.




	

	
	
		
			
				How can users start earning rewards with Plato Protocol?
			
		

		
					

		
			
			
			
			By making reservations through the app
		
			
			By downloading the dApp, signing up, and dining at a restaurant located on google maps and uploading their receipt
		
			
			By subscribing to a premium membership
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Future Roadmap
Upcoming Features: Expansion to more cities, introduction of new rewards, and enhanced app features.

Engagement Invitation: Users are encouraged to contribute ideas and participate in community discussions to shape the future of Plato.
Conclusion
Call to Action: Explore the world of rewarded dining with Plato Protocol, join our community, and stay updated with our latest developments. https://getplato.app/start/

Gratitude: Thank you for exploring Plato Protocol with us. Your journey towards rewarded dining experiences begins here.

### What is your favorite NEAR explorer 2024?

What is your favorite NEAR explorer 2024 
            
                201 votes by,
                375 nLEARNs spent
            
            
            
                                    
                        
                            pikespeak.ai                            
                                (83 votes,
                                129 nLEARNs)
                            
                        
                        
                             
                            41%
                        
                    
                                    
                        
                            nearblocks.io                            
                                (118 votes,
                                246 nLEARNs)
                            
                        
                        
                             
                            59%

### NEAR docs broken links audit

Submissions deadline: April, 4, 2024
Requirements:

 	Login with NEAR at https://docs.near.org/
 	Explore the NEAR Docs section you are mostly interested - Learn for users, Build for developers
 	Randomly check the links on the pages - the goal is help NEARDocs team to make it better!
 	Submit feedback form

We have reserved some NEAR for legit participants that will distributed after evaluation of submissions.
Fill the Feedback form

### What is Pikespeak? Season 2

Pikespeak is a Data & Analytics solution built on Near protocol. The solution provides:

 	Dashboards and visualisations of the most fundamental Web3 use cases;
 	An API with 50+ endpoints to consume live, historical data, and insights in a programmatic way.

Why?
The more information one accumulates, the more opportunities one creates. Accessing usable data on blockchains can be complex, making it hard to explore opportunities. At Pikespeak, our core mission is to empower individuals, projects and institutions by offering a frictionless Web3 data experience.

Launched on NEAR Protocol in summer 2022 by Francois, Bertrand and Didier, pikespeak.ai has already attracted over 5,000 early users and is used by top-tier projects within the ecosystem, including Immunefi, Electric Capital, Blockdaemon, Gauntlet, Proximity Labs, Ref Finance, Learn NEAR Club, ShardDog, Stader, and Meta Pool.

Since inception, Pikespeak has recorded over 1 billion on-chain events and generated over 40 data points for more than 60 million accounts. Actionable data that can supercharge Web3 projects, allowing them to take action.




	

	
	
		
			
				What can I do with Pikespeak?
			
		

		
					

		
			
			
			
			Track many things and get insights 
		
			
			Execute transactions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Who is using Pikespeak? What for?
Based on the Crypto Map (2024), introduced by Vitalik Buterin in his blog post The end of my childhood, here are tangible examples of how pikespeak.ai is being leveraged by market participants.
Token holders and DeFi users

 	Track the USD value of on-chain portfolio
 	Track all token balances
 	Track DeFi positions and earnings (e.g. liquidity and farming positions, lending and borrowing positions)
 	Access and download historical on-chain events (e.g. transfers, swaps)
 	Visualise cumulated incoming and outgoing transfers per token
 	Search account-to-account breakdown of transfers

Pragmatic users

 	Track tokens and new tokens opportunities

 	Get last hour and/or twenty-four hour transfer trends
 	Get market cap, number of holders, circulating supply, and last transfers for specific tokens


 	Track large token holders’ on-chain actions
 	Verify contract address and historical transactions




	

	
	
		
			
				Using Pikespeak, can I get access to all historical transactions for any accounts?
			
		

		
					

		
			
			
			
			Yes
		
			
			Nay
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Application builders

 	Index methods for a specific contract
 	Review transaction logs
 	Get transaction details and execution cost
 	Get addressable market size for any vertical (e.g. Gaming, DeFi, NFTs)
 	Extract list of accounts based on:

 	Portfolio size
 	On-chain activity


 	Track USD TVL of a specific contract
 	Review user acquisition phases and details per contract
 	Track user retention per contract
 	Get all unique accounts that have interacted with a specific contract

Intellectuals (Researchers)

 	Track number of unique delegators that are participating in the consensus mechanism of the blockchain
 	Get total amount being staked
 	Track major staking and unstaking events per delegator
 	Track staking rewards per delegator
 	Analyse relationship between accounts
 	Extract contextual information for more than 1,800 accounts

 	Vertical (e.g. DeFi, DAOs)
 	Sub-vertical (e.g. AMM, CLOB)
 	Project name (e.g. Ref Finance)


 	Review ecosystem money flows and funding patterns (e.g. Near Foundation, Proximity)

 




	

	
	
		
			
				How does Pikespeak generate revenue (choose multiple correct answers)?
			
		

		
					

		
			Please select 5 correct answers
			
			
			API High Rate Limit Access
		
			
			Dedicated Indexer(s) 
		
			
			Database Replicate(s
		
			
			Contract State Fetcher 
		
			
			Custom Data Points and Analysis
		
			
			Providing financial advice for memecoins 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### NEAR Ecosystem

The NEAR ecosystem, centered around the NEAR Protocol, represents a dynamic intersection of blockchain technology and artificial intelligence (AI), with a strong emphasis on fostering decentralized applications.
 It is supported by a range of tools and resources, including DevHub for developers and Learn NEAR Club for users. 


You can find more about NEAR ecosystem projects at NEAR Catalog and LNC (Learn NEAR Club) Ecosystem directory

### Staking, Unstaking, and Withdrawing NEAR: A Complete Guide

Understanding NEAR Staking
Staking serves as one of the foundational mechanisms in the NEAR Protocol's ecosystem. When you stake your NEAR tokens, you're essentially participating in network security and governance while earning rewards for your contribution. The NEAR Protocol uses a Proof-of-Stake consensus mechanism where validators (and those who delegate to them) help secure the network by locking up their tokens.

The Value of Staking
When you stake NEAR tokens, you receive several benefits:


 	You earn staking rewards that accumulate over time
 	You contribute to network security and decentralization
 	You gain indirect governance influence through your chosen validator

Think of staking as similar to depositing money in an interest-bearing account, but with the added dimension that your deposit helps maintain the integrity of the entire financial system.

Getting Started with Staking
Choosing Where to Stake
You have two primary options for staking your NEAR tokens:
Direct Validator Selection: You can choose specific validators to stake with, which gives you more control over who secures the network with your tokens. This approach requires more research but allows you to select validators based on their performance, commission rates, and values. You can make a research here
Liquid Staking Solutions: Platforms like Meta Pool provide liquid staking tokens that represent your staked NEAR while giving you a tradable asset (like stNEAR) that you can use in DeFi applications while your original tokens remain staked.

How to Stake Your NEAR
Staking your NEAR tokens involves a few straightforward steps:


 	Access your NEAR wallet where your tokens are stored
 	Navigate to the staking section within your wallet interface
 	Select a validator from the available list or use a staking pool
 	Specify the amount of NEAR you wish to stake
 	Confirm the transaction

Once your staking transaction is processed, your tokens become actively staked, and you'll begin earning rewards according to the network's parameters and your validator's performance.

The Unstaking Process
Unstaking (also called "undelegating") is the process of signaling your intention to withdraw your staked tokens. This is an important intermediary step before you can actually access your tokens again.

Important Considerations When Unstaking
When you decide to unstake your NEAR tokens, there are several critical points to understand:
Epoch-Based Timeline: The NEAR Protocol operates in time units called "epochs," which typically last about 12 hours. The unstaking process requires tokens to remain locked for several epochs.
Lockup Period: After initiating unstaking, your tokens enter a mandatory lockup period of approximately 2-3 days (equivalent to about 4 epochs). During this period, your tokens are neither earning staking rewards nor available for withdrawal.
No Partial Withdrawals: Once you begin the unstaking process for a specific amount, that exact amount will become available for withdrawal after the lockup period. You cannot partially withdraw from that amount.

How to Unstake Your NEAR
To unstake your NEAR tokens:


 	Visit the staking interface where your tokens are currently staked
 	Select the "Unstake" or "Undelegate" option
 	Enter the amount you wish to unstake
 	Confirm the transaction
 	Wait for the lockup period to complete (approximately 2-3 days)

During the unstaking period, your tokens remain locked, and you'll no longer earn staking rewards on the unstaked amount. It's worth noting that this lockup period serves an important security function for the network, preventing potential attacks that could occur if tokens could be unstaked and withdrawn instantly.

Withdrawing Your NEAR
After the unstaking period completes, your tokens become available for withdrawal. This is the final step in reclaiming full control of your previously staked assets.

The Withdrawal Process
To withdraw your unstaked NEAR tokens:


 	Return to the same staking interface where you initiated unstaking
 	Look for tokens that show as "Ready to withdraw" or similar status
 	Select the "Withdraw" option
 	Confirm the transaction

After confirmation, the tokens will be transferred back to your wallet's available balance, where you can freely transfer, sell, or restake them as needed.

Technical Background: Why the Delay?
The waiting period between unstaking and withdrawal is not arbitrary. It serves as a critical security mechanism in the NEAR Protocol. By implementing this delay, the network protects against various economic attacks that could otherwise destabilize the system if large amounts of stake could be removed instantly.
This security feature parallels other financial systems that impose holding periods or withdrawal delays to maintain stability and protect all participants.

Common Questions and Troubleshooting
What if I need my tokens urgently?
Unfortunately, the unstaking period cannot be bypassed due to the protocol-level rules that govern the NEAR blockchain. If liquidity is a priority, consider liquid staking solutions that provide tradable representations of your staked assets.

Are there fees for staking and unstaking?
While the NEAR Protocol itself charges minimal transaction fees for these operations, validators may charge commission fees on the rewards you earn (typically ranging from 1-10%). These commissions should be considered when selecting a validator.

What happens to my rewards during unstaking?
Once you initiate unstaking, you stop earning rewards on the unstaked amount. However, any rewards earned up to that point are automatically added to your staked balance before unstaking begins.

Can I cancel an unstaking request?
Unfortunately, once you've initiated the unstaking process, it cannot be canceled or reversed. You'll need to wait for the entire unstaking period to complete before you can access those tokens again.

Best Practices for NEAR Staking
To optimize your staking experience:


 	Research validators thoroughly before committing your tokens
 	Consider staking in multiple batches rather than all at once, which provides more flexibility for unstaking
 	Keep track of the unstaking timeline to know exactly when your tokens will become available
 	Maintain some liquid NEAR for transaction fees and unexpected opportunities
 	Regularly compound your rewards by restaking them for maximum growth

By understanding the complete lifecycle of staking, unstaking, and withdrawing NEAR tokens, you can make informed decisions that align with your financial goals while contributing to the security and decentralization of the NEAR ecosystem

### Merangkul Dunia Web3 dengan Chain Abstraction: Sebuah Jalan Menuju Kedaulatan Digital

Potensi luar biasa dari teknologi dan ekosistem terdesentralisasi tidak dapat diragukan lagi, terutama dalam hal memberdayakan individu dengan kedaulatan digital (self-sovereignty). Namun, kompleksitas aplikasi terdesentralisasi (dApps) dan ekosistem blockchain serta rollup yang terfragmentasi telah membatasi daya tariknya kepada masyarakat luas.

Untuk benar-benar bisa memanfaatkan kekuatan transformatif dari Web3, kita perlu menyederhanakan pengalaman pengguna melalui abstraksi dan mendorong lingkungan yang mendukung penuh kedaulatan digital.

Web3: Masalah Kompleksitas

#1 Penanganan Data

Keadaan dApp saat ini mengungkapkan kenyataan pahit: sebagian besar dApps tidak benar-benar bersifat terdesentralisasi atau ramah kepada pengguna. Kebutuhan pengguna untuk bisa menavigasi bursa, mengelola banyak akun, dan menangani biaya gas (gas fees) menggarisbawahi kesenjangan antara ideal aplikasi yang mudah digunakan dan realitas kompleksitas penggunaannya. Kompleksitas ini tidak hanya menghalangi semangat adopsi massal tetapi juga membatasi dApp pada basis pengguna spesifik yang jauh dari web yang digaung-gaungkan untuk semua kalangan.

Tapi dari mana sumber masalah dari kompleksitas ini? Mari kita kembali ke dasar dan memahami bagaimana Web3 dapat menangani data. Web3 sepenuhnya mengubah cara data dikelola dan disimpan, beralih dari penyimpanan data secara terpusat ke lingkungan terdesentralisasi di mana data diamankan dengan bukti kriptografi.

Pendekatan Web3 terhadap data, dengan penekanan pada desentralisasi dan validasi kriptografi, menghadirkan lanskap kompleks yang menantang strategi manajemen data tradisional.

#2 Modularitas

Tren modularitas saat ini di Web3, yang melibatkan pemecahan fungsionalitas blockchain menjadi beberapa lapisan berbeda seperti settlement, ketersediaan data (data availability), dan eksekusi, bertujuan untuk meningkatkan skalabilitas. Teknologi seperti layer-two, optimistic rollup, ZK rollup, dan sidechain adalah contoh pendekatan modular ini. Namun, ini secara tidak sengaja malah memperumit pengalaman pengguna dan pengembang, memecah ekosistem di beberapa blockchain dan menyebabkan lanskap likuiditas, aplikasi, dan basis pengguna yang tersebar. Pengembang menghadapi dilema untuk berkomitmen pada blockchain tertentu, yang berpotensi mempersempit jangkauan proyek mereka.

Dapatkah Abstraksi Memperbaiki Ini Semua?

Sebelum melanjutkan lebih jauh, mari kita pahami apa itu abstraksi. Ini adalah konsep fundamental yang menyederhanakan kompleksitas dengan menyembunyikan detail yang tidak perlu, memungkinkan pengguna untuk fokus pada fungsi tingkat tinggi tanpa terpaku pada seluk-beluk yang mendasarinya. Prinsip ini, yang krusial dalam pemrograman berorientasi objek, melampaui pengembangan perangkat lunak, memfasilitasi implementasi logika kompleks di berbagai domain dengan menyediakan antarmuka yang disederhanakan untuk berinteraksi.

Abstraksi memainkan peran penting dalam pengembangan perangkat lunak dengan menyederhanakan kompleksitas konstruksi program. Ini memungkinkan programmer untuk fokus pada fungsi tingkat tinggi dari kode mereka daripada berkutat dalam detail implementasi. Dengan mengabstraksikan kode kompleks menjadi komponen yang lebih mudah dikelola, pengembang dapat mempercepat alur kerja mereka, meningkatkan kemampuan mereka untuk memecahkan masalah dan mengulangi program mereka, dan menangani proyek yang lebih maju dengan efisiensi yang lebih besar.

Abstraksi tidak hanya merampingkan proses pengembangan tetapi juga mendorong inovasi dengan membebaskan programmer untuk mengeksplorasi ide dan solusi baru, membangun komponen abstrak yang ada untuk mendorong batas-batas pencapaian perangkat lunak mereka.

Tetapi bisakah logika ini diterapkan ke blockchain?

Abstraksi rantai (chain abstraction) mengacu pada penyederhanaan pengalaman pengguna blockchain dengan menyembunyikan mekanisme dasar yang kompleks. Strategi ini bertujuan untuk meningkatkan aksesibilitas dan mendorong adopsi yang lebih luas dengan menghadirkan antarmuka (interface) yang lebih intuitif, sebagaimana dibuktikan oleh pertumbuhan pengguna NEAR yang signifikan, didorong oleh penekanannya pada abstraksi sejak 2018.

Visi Abstraksi Rantai (Chain Abstraction)

Abstraksi rantai (Chain abstraction) memungkinkan pengguna untuk berinteraksi dengan dApp secara mulus tanpa perlu memahami seluk-beluk jaringan blockchain atau mengelola berbagai aset mata uang kripto. Tujuannya adalah untuk membuat interaksi blockchain seintuitif mungkin menggunakan aplikasi konvensional apapun, sehingga menurunkan hambatan masuk dan mendorong adopsi teknologi Web3 yang lebih luas.




	

	
	
		
			
				Apa tujuan utama dari Chain Abstraction di ekosistem Web3?
			
		

		
					

		
			
			
			
			Untuk menambah kompleksitas dari dApps untuk pengguna yang mahir
		
			
			Menyederhanakan pengalaman pengguna dengan menyembunyikan kompleksitas blockchain
		
			
			Menyentralisasi manajemen data di jaringan blockchain
		
			
			Menghilangkan kebutuhan bukti kriptografi pada transaksi data
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Protokol NEAR: Studi Kasus Abstraksi Rantai yang Berhasil

NEAR Protocol adalah contoh nyata penerapan dari abstraksi rantai yang sukses, menunjukkan potensinya untuk meningkatkan keterlibatan pengguna secara signifikan. Dengan mengabstraksikan lapisan blockchain, NEAR telah memungkinkan pengguna untuk melakukan transaksi dan berpartisipasi dalam ekonomi digital di berbagai jaringan melalui antarmuka tunggal yang terpadu. Hal ini tidak hanya meningkatkan kegunaan tetapi juga membuka ruang Web3 untuk audiens yang lebih luas, berkontribusi pada pertumbuhan dan keberagaman ekosistem.

Abstraksi rantai juga memfasilitasi pengembangan aplikasi multi chain dengan memungkinkan developer untuk fokus pada menciptakan pengalaman pengguna berkualitas tinggi daripada terkekang oleh batasan teknis blockchain tertentu. Pendekatan ini mendorong inovasi dan kolaborasi di dalam komunitas Web3, bergerak menuju masa depan di mana identitas dan aset digital dapat dikelola dan ditransaksikan dengan mulus di berbagai platform blockchain, sehingga menyatukan lanskap terfragmentasi dari ekosistem Web3 saat ini.

Contoh Abstraksi Rantai

Zero-knowledge proofs (ZKP) dapat menjadi cara yang hebat untuk memungkinkan abstraksi rantai. ZKP memperkenalkan mekanisme di mana dimungkinkan untuk memverifikasi kebenaran informasi tanpa mengungkapkan informasi itu sendiri. Bayangkan Anda memasuki klub malam, dan untuk membuktikan bahwa Anda sudah cukup umur untuk minum minuman beralkohol, Anda cukup menunjukkan tahun kelahiran Anda alih-alih informasi sensitif lainnya (seperti Nama, Alamat, Nomor Jaminan Sosial, dll.). Itulah contoh kehidupan nyata dari ZKP. Sekarang mari kita perluas ke jaringan blockchain.

Secara tradisional, keamanan dan integritas transaksi blockchain bergantung pada jaringan validator terdesentralisasi. Ini membutuhkan mekanisme konsensus, di mana beberapa pihak akan memvalidasi transaksi, memastikan legitimasi mereka dan dengan demikian mempertahankan kepercayaan jaringan. Namun, metode ini secara inheren menuntut tingkat kepercayaan tertentu pada validator kolektif dan sering kali menghasilkan konsumsi sumber daya yang signifikan karena upaya komputasi yang diperlukan untuk konsensus.

ZKPs dapat memungkinkan satu komputer untuk menegaskan bahwa aturan atau kondisi tertentu telah dipenuhi tanpa mengungkapkan data yang mendasarinya atau memerlukan konsensus dari banyak validator. Pergeseran ini secara signifikan mengurangi ketergantungan pada jaringan validator terdistribusi, memungkinkan proses validasi yang lebih ramping dan efisien.




	

	
	
		
			
				Bagaimana Zero-Knowledge Proof (ZKP) berkontribusi dalam keamanan transaksi blockchain?
			
		

		
					

		
			
			
			
			dengan melibatkan jaringan desentralisasi dari validator untuk setiap transaksi
		
			
			dengan mempublikasikan setiap detail transaksi untuk transparansi
		
			
			dengan membolehkan satu komputer untuk memverifikasi data tanpa mengungkapkan semua data
		
			
			dengan menambah kebutuhan dari penyimpanan data tersentralisasi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Konsekuensinya, pengembang mendapatkan fleksibilitas untuk meluncurkan blockchain baru dengan persyaratan sumber daya yang jauh lebih rendah, karena mereka tidak perlu lagi membangun dan memelihara jaringan validator yang besar. Seiring blockchain semakin mengadopsi keamanan yang dapat dibuktikan dengan ZK (Zero-Knowledge), penerbitan bukti (proof) dari ZK pada satu rantai dapat memverifikasi transaksi di beberapa rantai, sehingga secara praktis tidak mungkin untuk mengubah keadaan satu rantai tanpa memengaruhi rantai lainnya yang saling terhubung oleh bukti tersebut.

Bagaimana Protokol NEAR Memungkinkan Abstraksi Rantai

Protokol NEAR memajukan abstraksi rantai dengan mengembangkan ekosistem yang berpusat pada pengguna yang menyederhanakan interaksi di beberapa blockchain. Sejak 2018, NEAR telah memprioritaskan kegunaan (usability), skalabilitas, dan model akun yang fleksibel, bertujuan untuk mengakomodasi aplikasi arus utama dengan potensi menarik miliaran pengguna. Platform ini telah berevolusi untuk sepenuhnya mendukung abstraksi rantai, memungkinkan operasi yang mulus di berbagai blockchain dan aplikasi.

Komponen kunci dari pendekatan NEAR meliputi infrastruktur blockchain yang skalabel yang mampu mendukung lebih dari satu miliar akun aktif dan tumpukan keamanan yang kuat. Tumpukan ini menampilkan solusi ketersediaan data (DA) NEAR, zkWASM dalam kolaborasi dengan Polygon Labs untuk bukti tanpa pengetahuan yang efisien, dan EigenLayer untuk finalitas yang ditingkatkan. Secara kolektif, elemen-elemen ini memastikan lingkungan yang aman dan skalabel untuk aplikasi terdesentralisasi.

NEAR selanjutnya memungkinkan abstraksi rantai melalui agregasi akun, yang memungkinkan pengguna untuk mengelola interaksi mereka di berbagai rantai melalui satu akun. Penyederhanaan ini meluas ke lapisan data, mendukung berbagai arsitektur blockchain dan memastikan akses data yang konsisten. Selain itu, perelai niat (intent relayers) dalam infrastruktur NEAR memfasilitasi operasi kompleks di beberapa rantai, meningkatkan interoperabilitas dan pengalaman pengguna.

Frontend terdesentralisasi di NEAR menawarkan antarmuka terpadu untuk menemukan dan berinteraksi dengan aplikasi di seluruh spektrum Web3, didukung oleh dompet super (super wallets) yang menyederhanakan pengalaman pengguna dengan menghilangkan kebutuhan untuk beralih jaringan atau mengelola biaya gas.

Memberdayakan Pengguna dengan Kedaulatan Digital

Di luar menyederhanakan pengalaman pengguna, abstraksi rantai selaras dengan tujuan yang lebih luas dari kedaulatan digital (self-sovereignty). Di dunia di mana data pribadi dan aset digital semakin berharga, kemampuan untuk mengontrol dan mengelola identitas dan aset digital seseorang menjadi sangat penting. Web3, dengan sifatnya yang terdesentralisasi, menawarkan kerangka kerja bagi pengguna untuk mencapai tingkat kontrol ini, bebas dari kendala dan risiko sistem terpusat.

Kedaulatan digital memastikan individu mengontrol data, aset, dan identitas mereka, menjaga privasi dan otonomi dari eksploitasi otoritas terpusat. Konsep ini sangat penting untuk mencegah pelanggaran privasi dan mendorong interaksi digital yang aman sesuai keinginan pengguna sendiri. Ini mentransformasi ekonomi digital menjadi ruang yang lebih adil, mengurangi ketidakseimbangan kekuatan dan mendorong lingkungan demokratis tempat pengguna berinteraksi dan bertransaksi secara bebas tanpa kekhawatiran pengawasan.

Bagaimana NEAR memungkinkan kedaulatan digital

Protokol NEAR memfasilitasi kedaulatan digital melalui platform terdesentralisasi yang dirancang untuk memberi pengguna kendali atas interaksi digital mereka. Dengan mengabstraksikan kompleksitas teknologi blockchain, NEAR mempermudah pengguna untuk terlibat dengan dApp tanpa memerlukan pengetahuan mendalam tentang infrastruktur yang mendasarinya. Pendekatan ini tidak hanya meningkatkan kegunaan tetapi juga memastikan bahwa pengguna dapat mengelola aset dan identitas digital mereka secara mulus di berbagai aplikasi dan platform.

Komitmen NEAR pada perangkat lunak open-source dan pengembangan alat ramah pengguna seperti dompet super dan frontend terdesentralisasi selanjutnya memberdayakan pengguna, memungkinkan pengalaman digital yang berdaulat sesuai dengan etos Web3 dan visi yang lebih luas dari internet terdesentralisasi.




	

	
	
		
			
				Fitur Near Protocol apa yang mendukung pengoperasian tanpa hambatan di berbagai blockchain dan aplikasi?
			
		

		
					

		
			
			
			
			ketergantungannya pada strategi pengelolaan data tradisional
		
			
			skalabilitas terbatas dan akun model yang kaku
		
			
			skalabilitas infrastruktur blockchainnya yang memungkinkan dukungan terhadap milyaran akun aktif
		
			
			fokusnya terhadap aset dan data user secara terpusat
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Jalan Menuju Masa Depan

Perjalanan menuju adopsi Web3 yang luas dan terwujudnya kedaulatan digital bukanlah tanpa tantangan. Ini tentunya membutuhkan upaya bersama dari developer, pengguna, dan stakeholder di seluruh ekosistem untuk merangkul prinsip-prinsip abstraksi dan kesederhanaan. Dengan berfokus pada aplikasi yang ramah pengguna dengan mengabstraksikan kompleksitas teknologi blockchain, kita dapat membuka pintu gerbang Web3 untuk audiens secara global.

Perjalanan menuju internet terdesentralisasi yang memberdayakan pengguna sedang berlangsung saat ini. Melalui prinsip abstraksi rantai dan fokus pada penyederhanaan pengalaman pengguna, kita dapat mempercepat transisi ke Web3 dan memberdayakan individu dengan kedaulatan digital yang sebenarnya. Saat kita menavigasi transisi ini, visi internet yang lebih terbuka, aman, dan berpusat pada pengguna tetap dalam jangkauan, menjanjikan masa depan di mana setiap orang memiliki kendali atas kehidupan digital mereka.


                
                        
                            Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty Guide
                         
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Adoptando la Web3 a través de la abstracción en cadena: Un camino hacia la Autosoberanía digital

No hay duda del enorme potencial de las tecnologías y ecosistemas descentralizados, especialmente cuando se trata de empoderar a las personas con autosoberanía. Sin embargo, la gran complejidad de las aplicaciones descentralizadas (dApps) y el ecosistema fragmentado de las blockchains y los rollups ha limitado su atractivo para el público general.

Para aprovechar realmente el poder transformador de la Web3, debemos simplificar la experiencia del usuario mediante la abstracción y fomentar un entorno que apoye la autosoberanía digital.
El Problema de la Complejidad en la Web3
#1 Manejo de Datos

El estado actual de las dApps revela una cruda realidad: la mayoría no son verdaderamente descentralizadas ni fáciles de usar. La necesidad de que los usuarios naveguen por exchanges, administren múltiples cuentas y manejen las tarifas del gas, subraya la brecha entre el ideal de aplicaciones fluidas y la realidad de su complejidad. Esta complejidad no solo disuade la adopción masiva, sino que también confina las dApps a una base de usuarios nicho, lejos de la web democratizada prevista.

Pero, ¿de dónde proviene esta complejidad? Volvamos a lo básico y comprendamos cómo la Web3 maneja los datos. La Web3 cambia por completo la forma en que se administran y almacenan los datos, pasando de bases de datos centralizadas a un entorno descentralizado donde los datos se protegen con pruebas criptográficas.

El enfoque de la Web3 hacia los datos, con su énfasis en la descentralización y la validación criptográfica, presenta un panorama complejo que desafía las estrategias tradicionales de gestión de datos.

#2 Modularidad

La tendencia actual de la Web3 hacia la modularidad, que implica dividir la funcionalidad de la blockchain en capas distintas como liquidación, disponibilidad de datos y ejecución, tiene como objetivo mejorar la escalabilidad. Las tecnologías como las layer-twos, los rollups optimistas y rollups ZK, así como las sidechains (cadenas laterales) ejemplifican este enfoque modular. Sin embargo, esto ha complicado inadvertidamente la experiencia del usuario y del desarrollador, fragmentando el ecosistema en múltiples blockchains y dando lugar a un panorama disperso de liquidez, aplicaciones y de usuarios. Los desarrolladores se enfrentan al dilema de comprometerse con una blockchain específica, lo que podría reducir el alcance de su proyecto.
¿Puede la Abstracción Solucionar Esto?
Antes de continuar, entendamos qué es la abstracción. Es un concepto fundamental que simplifica la complejidad ocultando detalles innecesarios, permitiendo a los usuarios centrarse en la funcionalidad de alto nivel sin atascarse con las complejidades subyacentes. Este principio, crucial en la programación orientada a objetos, se extiende más allá del desarrollo de software, facilitando la implementación de lógica compleja en varios dominios al proporcionar una interfaz simplificada para interactuar.

La abstracción juega un papel crucial en el desarrollo de software al simplificar la complejidad de la construcción del programa. Permite a los programadores centrarse en la funcionalidad de alto nivel de su código en lugar de enredarse en los detalles de la implementación. Al abstraer el código complejo en componentes más manejables, los desarrolladores pueden acelerar su flujo de trabajo, mejorar su capacidad para solucionar problemas e iterar en sus programas, y abordar proyectos más avanzados con mayor eficiencia.

La abstracción no sólo agiliza el proceso de desarrollo, sino que también fomenta la innovación al liberar a los programadores para que exploren nuevas ideas y soluciones, basándose en componentes ya abstraídos para ampliar los límites de lo que su software puede lograr.

Pero, ¿se puede extender esta lógica a las blockchains?

La abstracción de cadenas propone simplificar la experiencia del usuario en la blockchain ocultando sus complejos mecanismos subyacentes. Esta estrategia tiene como objetivo mejorar la accesibilidad y fomentar una adopción más amplia mediante la presentación de una interfaz más intuitiva, como lo demuestra el importante crecimiento de usuarios de NEAR, impulsado por su énfasis en la abstracción desde 2018.
La Visión de la Abstracción de Cadenas
La abstracción de cadenas permite a los usuarios interactuar con las dApps de manera fluida, sin necesidad de comprender las complejidades de las redes blockchain o gestionar diversos activos de criptomonedas. El objetivo es hacer que las interacciones con la blockchain sean tan intuitivas como usar cualquier aplicación convencional, lo que reduce las barreras de entrada y fomenta una mayor adopción de las tecnologías Web3.




	

	
	
		
			
				¿Cuál es el objetivo principal de la abstracción de cadenas en el ecosistema Web3?
			
		

		
					

		
			
			
			
			Aumentar la complejidad de las dApps para usuarios avanzados
		
			
			Simplificar la experiencia del usuario ocultando las complejidades de la blockchain 
		
			
			Centralizar la gestión de datos en las redes blockchain
		
			
			Eliminar la necesidad de pruebas criptográficas en las transacciones de datos
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






El Protocolo NEAR ejemplifica la implementación exitosa de la abstracción de cadenas, demostrando su potencial para aumentar significativamente el engagement del usuario. Al abstraer la capa de la blockchain, NEAR ha permitido a los usuarios realizar transacciones y participar en la economía digital en diferentes redes a través de una única interfaz unificada. Esto no solo mejora la usabilidad, sino que también abre el espacio de la Web3 a una audiencia más amplia, contribuyendo al crecimiento y la diversidad del ecosistema.

La abstracción de cadenas también facilita el desarrollo de aplicaciones multicadena al permitir que los desarrolladores se centren en crear experiencias de usuario de alta calidad en lugar de verse condicionados por las limitaciones técnicas de una blockchain específica. Este enfoque fomenta la innovación y la colaboración dentro de la comunidad Web3, avanzando hacia un futuro donde las identidades y los activos digitales se puedan gestionar y transaccionar sin problemas a través de diversas plataformas blockchain, unificando así el panorama fragmentado del ecosistema Web3 actual.

Ejemplo de Abstracción de Cadenas

Las Pruebas de Conocimiento Cero (ZKP, por sus siglas en inglés) pueden ser una excelente manera de permitir la abstracción de cadenas. Las pruebas ZK introducen un mecanismo que permite verificar la exactitud de la información sin revelarla. Imagina que entras en un club nocturno y, para demostrar que tienes la edad legal para consumir alcohol, simplemente muestras tu año de nacimiento en lugar de otra información sensible (como nombre, dirección, número de la Seguridad Social, etc.). Este es un ejemplo real de ZKP. Ahora extendámoslo a las redes blockchain.

Tradicionalmente, la seguridad e integridad de las transacciones blockchain dependían de una red descentralizada de validadores. Esto requería un mecanismo de consenso, donde múltiples partes validarían las transacciones, asegurando su legitimidad y manteniendo así la confianza de la red. Sin embargo, este método exige inherentemente un cierto nivel de confianza en los validadores colectivos y, a menudo, resulta en un consumo significativo de recursos debido al esfuerzo computacional necesario para el consenso.

Las ZKPs pueden permitir que una sola computadora afirme que se han cumplido ciertas reglas o condiciones sin revelar los datos subyacentes o sin requerir un consenso de múltiples validadores. Este cambio reduce significativamente la dependencia de una red distribuida de validadores, lo que permite procesos de validación más ágiles y eficientes.




	

	
	
		
			
				¿Cómo las pruebas de conocimiento cero (ZK) contribuyen a la seguridad de las transacciones en la blockchain?
			
		

		
					

		
			
			
			
			Al requerir una red descentralizada de validadores para cada transacción
		
			
			Al publicitar los detalles de la transacción para mayor transparencia
		
			
			Al permitir que una sola computadora verifique las reglas sin revelar los datos subyacentes
		
			
			Al aumentar la necesidad de almacenamiento centralizado de datos
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






En consecuencia, los desarrolladores ganan flexibilidad para lanzar nuevas blockchains con una menor necesidad de recursos, pues ya no necesitan establecer y mantener una gran red de validadores. A medida que las blockchains adoptan cada vez más la seguridad comprobable mediante ZK, la publicación de una prueba ZK en una cadena puede verificar transacciones en múltiples cadenas, lo que hace prácticamente imposible alterar el estado de una cadena sin afectar a las demás interconectadas por estas pruebas.
Cómo el Protocolo NEAR Habilita la Abstracción de Cadenas
El Protocolo NEAR está impulsando la abstracción de cadenas mediante el desarrollo de un ecosistema centrado en el usuario que simplifica las interacciones en múltiples blockchains. Desde 2018, NEAR ha priorizado la usabilidad, la escalabilidad y un modelo de cuenta flexible, con el objetivo de dar cabida a aplicaciones convencionales con el potencial de atraer a miles de millones de usuarios. La plataforma ha evolucionado para admitir completamente la abstracción de cadenas, permitiendo una operación fluida en diversas aplicaciones y blockchains.

Los componentes clave del enfoque de NEAR incluyen una infraestructura de cadena de bloques escalable capaz de soportar más de mil millones de cuentas activas y una sólida estructura de seguridad. Esta estructura incluye las soluciones de disponibilidad de datos (DA) de NEAR, zkWASM en colaboración con Polygon Labs para pruebas eficientes de conocimiento cero, y EigenLayer para una finalidad mejorada. En conjunto, estos elementos garantizan un entorno seguro y escalable para aplicaciones descentralizadas.

NEAR habilita aún más la abstracción de cadenas a través de la agregación de cuentas, permitiendo a los usuarios administrar sus interacciones en diferentes cadenas a través de una cuenta única. Esta simplificación se extiende a la capa de datos, admitiendo una amplia gama de arquitecturas blockchain y garantizando un acceso consistente a los datos. Además, los "intent relayers" dentro de la infraestructura de NEAR facilitan operaciones complejas en múltiples cadenas, mejorando la interoperabilidad y la experiencia del usuario.

Los frontends descentralizados en NEAR ofrecen una interfaz unificada para descubrir e interactuar con aplicaciones en todo el espectro de la Web3, con el soporte de las "súper wallets" que agilizan la experiencia del usuario al eliminar la necesidad de cambiar de red o administrar las tarifas del gas.
Empoderando a los Usuarios con Autosoberanía
Más allá de simplificar la experiencia del usuario, la abstracción de cadenas se alinea con el objetivo más amplio de la autosoberanía digital. En un mundo donde los datos personales y los activos digitales son cada vez más valiosos, la capacidad de controlar y gestionar la identidad y los activos digitales propios se convierte en algo primordial. La Web3, con su naturaleza descentralizada, ofrece un marco para que los usuarios alcancen este nivel de control, libres de las restricciones y riesgos de los sistemas centralizados.

La autosoberanía garantiza que las personas controlen sus datos, activos e identidades, salvaguardando la privacidad y la autonomía frente a la explotación de las autoridades centralizadas. Este concepto es crucial para prevenir las violaciones de la privacidad y promover interacciones digitales seguras en los términos de cada uno. Esto transforma la economía digital en un espacio más equitativo, disminuyendo los desequilibrios de poder y fomentando un entorno democrático en el que los usuarios interactúan y realizan transacciones libremente sin preocupaciones de vigilancia.
Cómo NEAR habilita la Autosoberanía
El Protocolo NEAR facilita la autosoberanía a través de su plataforma descentralizada, diseñada para dar a los usuarios control sobre sus interacciones digitales. Al abstraer las complejidades de la tecnología blockchain, NEAR facilita a los usuarios interactuar con dApps sin necesidad de conocimientos profundos de la infraestructura subyacente. Este enfoque no solo mejora la usabilidad, sino que también garantiza que los usuarios puedan gestionar sus activos e identidades digitales sin problemas en diversas aplicaciones y plataformas.

El compromiso de NEAR con el software de código abierto y el desarrollo de herramientas fáciles de usar como las súper wallets y los frontends descentralizados empodera aún más a los usuarios, permitiendo una experiencia digital autosoberana que se alinea con el espíritu de la Web3 y la visión más amplia de una internet descentralizada.




	

	
	
		
			
				¿Qué característica del Protocolo NEAR permite una operación fluida en varias blockchains y aplicaciones?
			
		

		
					

		
			
			
			
			Su dependencia de las estrategias tradicionales de gestión de datos
		
			
			Su escalabilidad limitada y modelo de cuenta rígido
		
			
			Su infraestructura blockchain escalable capaz de soportar más de mil millones de cuentas activas
		
			
			Su enfoque en centralizar las identidades y activos de los usuarios
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El Camino a Seguir
El camino hacia la adopción generalizada de la Web3 y la materialización de la autosoberanía digital no está exento de desafíos. Requiere un esfuerzo conjunto de desarrolladores, usuarios y partes interesadas de todo el ecosistema para adoptar los principios de abstracción y simplicidad. Al centrarnos en aplicaciones fáciles de usar que oculten las complejidades de la tecnología blockchain, podemos abrir las puertas de la Web3 a una audiencia global.

El viaje hacia una Internet descentralizada y con poder para el usuario está en marcha. A través de los principios de abstracción de la cadena y centrándonos en simplificar la experiencia del usuario, podemos acelerar la transición a la Web3 y dotar a los individuos de una verdadera autosoberanía digital. Mientras navegamos por esta transición, la visión de una Internet más abierta, segura y centrada en el usuario sigue estando a nuestro alcance, prometiendo un futuro en el que todo el mundo tenga el control de su vida digital.


                
                        
                            Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty Guide
                         
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        
		                
		                


 

### К цифровому суверенитету через абстракцию блокчейна

Нет никаких сомнений в огромном потенциале децентрализованных технологий и экосистем, особенно, когда речь идет о предоставлении людям права на суверенитет. Однако, на ряду с преимуществами есть и определенные сложности децентрализованных приложений (dApps) и фрагментированных экосистем блокчейнов, накопительные пакеты незначительно снижают их привлекательность для широкой публики.

Чтобы по-настоящему использовать преобразующую силу Web3, мы должны упростить пользовательский опыт за счет абстракции и создать среду, поддерживающую цифровой суверенитет. Рассмотрим это подробнее.

Сложности Web3

1 Обработка данных

Текущее состояние децентрализованных приложений раскрывает суровую реальность: большинство из них не являются по-настоящему децентрализованными и удобными для пользователя. Необходимость для пользователей перемещаться по биржам, управлять несколькими учетными записями и оплачивать комиссии, это разрыв между идеалом бесперебойных приложений и реальностью их сложности. Этот момент не только сдерживает массовое внедрение, но и ограничивает децентрализованные приложения узкой пользовательской базой, далекой от предполагаемой сети.

Но откуда эта сложность? Давайте вернемся к основам и поймем, как Web3 обращается с данными. Web3 полностью меняет способы управления и хранения данных, переходя от централизованных баз данных к децентрализованной среде, где данные защищены криптографическими доказательствами.

Подход Web3 к данным, с упором на децентрализацию и криптографическую проверку, представляет собой сложную среду, которая бросает вызов традиционным стратегиям управления данными.

2 Модульность

Текущая тенденция в Web3 к модульности, которая предполагает разбиение функциональности блокчейна на отдельные уровни, такие как расчеты, доступность данных и выполнение, направлена ​​на повышение масштабируемости. Такие технологии, как второй уровень, ZK-объединения, а также сайдчейны, служат примером такого модульного подхода. Однако это непреднамеренно усложнило работу пользователей и разработчиков, фрагментировав экосистему на несколько блокчейнов, и, приведя к разбросу данных ликвидности, приложений и пользовательских баз. Разработчики сталкиваются с дилеммой выбора конкретного блокчейна, что потенциально снижает охват их проекта.

Может ли абстракция это исправить?

Прежде чем идти дальше, давайте разберемся, что такое абстракция. Это фундаментальная концепция, которая снижает уровень сложности, скрывая ненужные детали, позволяя пользователям сосредоточиться на функциональности, не увязая в тонкостях инфраструктуры. Этот принцип, имеет решающее значение в объектно-ориентированном программировании, он выходит за рамки разработки программного обеспечения, облегчая реализацию сложной логики в различных областях за счет предоставления упрощенного интерфейса для взаимодействия.

Абстракция играет решающую роль в разработке программного обеспечения, упрощая создание приложений. Это позволяет программистам сосредоточиться на высокоуровневой функциональности своего кода, а не погрузиться в рутину реализации. Абстрагируя сложный код на более управляемые компоненты, разработчики могут ускорить свой рабочий процесс, расширить свои возможности по устранению багов и воспроизведению своих программ, а также с большей эффективностью решать более сложные проекты и новые задачи.

Абстракция не только упрощает процесс разработки, но и способствует инновациям, предоставляя программистам возможность исследовать новые идеи и решения, опираясь на существующие абстрактные компоненты, чтобы расширить диапазон возможностей своих приложений.

Так можно ли распространить эту логику на блокчейны?

Абстракция цепочки означает упрощение пользовательского опыта в WEB3 за счет сокрытия его сложных механизмов. Эта стратегия направлена ​​на повышение доступности и содействие более широкому внедрению за счет представления более интуитивно понятного интерфейса (о чем свидетельствует значительный рост числа пользователей NEAR, обусловленный акцентом на абстракцию с 2018 года).

Видение абстракции блокчейна

Абстракция цепочки позволяет пользователям беспрепятственно взаимодействовать с децентрализованными приложениями без необходимости разбираться в тонкостях сетей блокчейнов или управлять различными криптовалютными активами. Цель состоит в том, чтобы сделать взаимодействие с блокчейном таким же интуитивным, как и использование любого обычного приложения, тем самым снижая барьеры для входа и способствуя более широкому внедрению технологий Web3.




	

	
	
		
			
				Какова основная цель абстракции блокчейна в экосистеме Web3?
			
		

		
					

		
			
			
			
			Повысить сложность для продвинутых пользователей
		
			
			Упростить работу пользователей, скрыв сложности блокчейна
		
			
			Централизовать управление данными в блокчейн-сетях
		
			
			Устранить необходимость в криптографических доказательствах при транзакциях данных
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Протокол NEAR является примером успешной реализации абстракции блокчейна, демонстрируя его потенциал для значительного увеличения вовлеченности пользователей. Абстрагируя уровень блокчейна, NEAR позволил пользователям выполнять транзакции и участвовать в цифровой экономике в разных сетях через единый унифицированный интерфейс. Это не только повышает удобство использования, но и открывает пространство Web3 для более широкой аудитории, способствуя росту и разнообразию экосистемы.

Абстракции блокчейна также облегчает разработку мультичейн-приложений, позволяя разработчикам сосредоточиться на создании высококачественных продуктов, а не ограничиваться техническими ограничениями конкретного блокчейна. Этот подход поощряет инновации и сотрудничество внутри сообщества Web3, двигаясь к будущему, в котором цифровыми идентификаторами и активами можно будет беспрепятственно управлять и осуществлять транзакции на различных платформах блокчейнов, тем самым объединяя фрагментированную структуру текущей экосистемы Web3.

Пример абстракции блокчейна

Доказательства с нулевым разглашением (ZKP-Zero-knowledge proofs) могут быть отличным способом реализовать абстракции блокчейна. Доказательства ZKP представляют собой механизм, позволяющий проверить правильность информации, не раскрывая саму информацию. Представьте, что вы входите в ночной клуб и, чтобы доказать, что вы достигли возраста, с которого разрешено употребление алкоголя, вы просто указываете год своего рождения вместо другой конфиденциальной информации (например, имени, адреса, номера социального страхования и т. д.). Это реальный пример ZKP. Теперь давайте распространим это на сети блокчейнов.

Традиционно, безопасность и целостность транзакций блокчейна зависели от децентрализованной сети валидаторов. Для этого требовался механизм консенсуса, в котором несколько сторон будут проверять транзакции, гарантируя их легитимность и, таким образом, поддерживая доверие сети. Однако этот метод по своей сути требует определенного уровня доверия к валидаторам и часто приводит к значительному потреблению ресурсов, необходимых для достижения консенсуса.

ZKP могут позволить одному компьютеру подтвердить, что определенные правила или условия были соблюдены, не раскрывая базовые данные и не требуя консенсуса от нескольких валидаторов. Это значительно снижает зависимость от распределенной сети валидаторов, позволяя сделать процессы проверки более рациональными и эффективными.




	

	
	
		
			
				Как доказательства с нулевым разглашением (ZK) способствуют безопасности транзакций блокчейна?
			
		

		
					

		
			
			
			
			Требуя децентрализованной сети валидаторов для каждой транзакции
		
			
			Публикуя детали транзакций для обеспечения прозрачности
		
			
			Позволяя одному компьютеру проверять правила  без раскрытия базовых данных
		
			
			За счет увеличения потребности в централизованном хранении данных
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Следовательно, разработчики получают возможность запускать новые блокчейны с гораздо меньшими требованиями к ресурсам, поскольку им больше не нужно создавать и поддерживать большую сеть валидаторов. Поскольку в блокчейнах все чаще применяется безопасность, доказуемая ZK, публикация доказательства ZK в одной цепочке может проверять транзакции в нескольких цепочках, что делает практически невозможным изменить состояние одной цепочки, не затрагивая другие, связанные между собой этими доказательствами.

Как протокол NEAR обеспечивает абстракцию цепочки

Протокол NEAR продвигает абстракцию цепочки за счет разработки ориентированной на пользователя экосистемы, которая упрощает взаимодействие между несколькими блокчейнами. С 2018 года NEAR уделяет приоритетное внимание удобству использования, масштабируемости и гибкой модели учетной записи, стремясь адаптировать основные приложения, способные привлечь миллиарды пользователей. Платформа была усовершенствована и теперь полностью поддерживает абстракцию цепочки, обеспечивая бесперебойную работу с различными блокчейнами и приложениями.

Ключевые компоненты NEAR включают масштабируемую инфраструктуру блокчейна, способную поддерживать более миллиарда активных учетных записей, и надежный стек безопасности. В этот стек входят решения NEAR для обеспечения доступности данных (DA), доказательства с нулевым разглашением ZK (zero-knowledge proofs) в сотрудничестве с Polygon Labs для эффективных доказательств с нулевым разглашением и EigenLayer для повышения окончательности. В совокупности эти элементы обеспечивают безопасную и масштабируемую среду для децентрализованных приложений.

NEAR также обеспечивает абстракцию цепочки посредством агрегации учетных записей, позволяя пользователям управлять своими действиями в разных цепочках через одну учетную запись. Это упрощение распространяется на уровень данных, поддерживая широкий спектр архитектур блокчейна и обеспечивая согласованный доступ к данным. Кроме того, ретрансляторы намерений в инфраструктуре NEAR облегчают сложные операции в нескольких цепочках, улучшая функциональную совместимость и удобство для пользователей.

Децентрализованные интерфейсы NEAR предлагают унифицированный интерфейс для обнаружения и взаимодействия с приложениями по всему спектру Web3, поддерживаемый суперкошельками, которые оптимизируют работу пользователя, устраняя необходимость переключения сетей или управления платой за газ.

Предоставление пользователям суверенитета

Помимо упрощения пользовательского опыта, абстракция цепочки соответствует более широкой цели - цифрового суверенитета. В мире, где персональные данные и цифровые активы становятся все более ценными, способность контролировать и управлять своей цифровой личностью и активами выходит на первый план. Web3 с его децентрализованным характером предлагает пользователям основу для достижения такого уровня контроля, свободную от ограничений и рисков централизованных систем.

Суверенитет гарантирует, что люди контролируют свои данные, активы и личные данные, защищая конфиденциальность и автономию от злоупотреблений со стороны централизованных властей. Эта концепция имеет решающее значение для предотвращения нарушений конфиденциальности и продвижения безопасного цифрового взаимодействия на собственных условиях. Он преобразует цифровую экономику в более справедливое пространство, уменьшая дисбаланс сил и создавая демократическую среду, в которой пользователи свободно взаимодействуют и совершают транзакции, не опасаясь слежки.

Как NEAR обеспечивает суверенитет

Протокол NEAR обеспечивает суверенитет посредством своей децентрализованной платформы, предназначенной для того, чтобы дать пользователям контроль над своим цифровым взаимодействием. Абстрагируя сложности технологии блокчейна, NEAR упрощает пользователям взаимодействие с децентрализованными приложениями без необходимости глубоких знаний базовой инфраструктуры. Такой подход не только повышает удобство использования, но и гарантирует, что пользователи смогут беспрепятственно управлять своими цифровыми активами и личными данными в различных приложениях и платформах.

Приверженность NEAR программному обеспечению с открытым исходным кодом и разработке удобных для пользователя инструментов, таких как супер кошельки и децентрализованные интерфейсы, еще больше расширяет возможности пользователей, обеспечивая самостоятельный цифровой опыт, который соответствует духу Web3 и более широкому видению децентрализованного Интернета.




	

	
	
		
			
				Какая функция протокола NEAR обеспечивает бесперебойную работу различных блокчейнов и приложений?
			
		

		
					

		
			
			
			
			Его зависимость от традиционных стратегий управления данными
		
			
			Его ограниченная масштабируемость и жесткая модель учета
		
			
			Его масштабируемая блокчейн-инфраструктура способна поддерживать более миллиарда активных учетных записей
		
			
			Его основное внимание уделяется централизации  идентификационных данных пользователей и активов
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Что же ждет впереди 

Путь к широкому внедрению Web3 и реализации цифрового суверенитета не лишен проблем. Для принятия принципов абстракции и простоты требуются согласованные усилия разработчиков, пользователей и заинтересованных сторон всей экосистемы. Сосредоточив внимание на удобных для пользователя приложениях, которые абстрагируются от сложностей технологии блокчейна, мы можем открыть двери Web3 для глобальной аудитории.

Путь к децентрализованному Интернету, наделенному полномочиями пользователей, уже начался. Благодаря принципам цепной абстракции и сосредоточению усилий на упрощении пользовательского опыта мы можем ускорить переход на Web3 и предоставить людям настоящую цифровую свободу. В ходе этого перехода видение более открытого, безопасного и ориентированного на пользователя Интернета остается в пределах досягаемости, обещая будущее, в котором каждый сможет контролировать свою цифровую жизнь.

Я полагаю, что концепция суверенитета через децентрализованную платформу — очень интересная и важная тема. Приятно наблюдать, что протокол NEAR предпринимает шаги, чтобы облегчить пользователям взаимодействие с децентрализованными приложениями без необходимости глубоких знаний базовой инфраструктуры. Такой подход не только повышает удобство использования, но и гарантирует, что пользователи смогут беспрепятственно управлять своими цифровыми активами и личными данными в различных приложениях и платформах. Я также ценю приверженность NEAR к программному обеспечению с открытым исходным кодом и разработке удобных для пользователя инструментов, таких как супер кошельки и децентрализованные интерфейсы. Это расширяет возможности пользователей и обеспечивает самостоятельный цифровой опыт, который соответствует духу Web3 и более широкому видению децентрализованного Интернета. В целом, я думаю, что Протокол NEAR очень позитивно подходит к теме суверенитета посредством децентрализации, и я рад быть свидетелем того, как он будет продолжать развиваться в будущем.


                
                        
                            Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty Guide
                         
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Abraçando a Web3 através da abstração em cadeia: um caminho para a auto soberania digital.

Existem poucas dúvidas sobre o enorme potencial das tecnologias e ecossistemas descentralizados, especialmente quando se trata de capacitar os indivíduos com auto-soberania. No entanto, a enorme complexidade das aplicações descentralizadas (dApps) e o ecossistema fragmentado de blockchains e rollups limitaram a convocatória do público em geral.

Para aproveitar verdadeiramente o poder transformador da Web3, precisamos simplificar a experiência do usuário através da abstração e promover um ambiente que apoie a auto soberania digital.
O problema de complexidade da Web3.
#1 Gestão de dados.

O estado atual dos dapps revela uma verdade absoluta: a maioria não é verdadeiramente descentralizada e nem fácil de usar. A necessidade dos usuários ao navegar nas exchanges, gerir múltiplas contas e lidar com taxas de gás, sublinha o abismo entre o ideal de aplicações contínuas e a realidade da sua complexidade. Essa complexidade não apenas impede a adoção convencional, mas também confina os dapps a uma base de usuários de nicho distante da web democratizada prevista.

Mas de onde vem essa complexidade? Vamos voltar ao básico e entender como a Web3 lida com os dados. A Web3 muda completamente a forma como os dados são armazenados e gerenciados, passando de bancos de dados centralizados para um ambiente descentralizado onde os dados são protegidos com provas criptográficas.

A forma como os dados da Web3 são abordados, com ênfase na descentralização e na validação criptográfica, apresenta um cenário complexo que desafia as estratégias tradicionais de gestão de dados.

#2 Modularidade

A tendência atual da Web3 rumo à modularidade, que envolve a divisão da funcionalidade da blockchain em camadas distintas, como liquidação, disponibilidade de dados e execução, visa aumentar a escalabilidade. Tecnologias como layer-twos, rollups Optimistic, ZK e Sidechains, exemplificam essa abordagem modular. No entanto, isso complicou inadvertidamente a experiência do usuário e do desenvolvedor, fragmentando o ecossistema em várias blockchains e conduzindo a um cenário disperso de liquidez, aplicações e bases de usuários. Os desenvolvedores enfrentam o dilema de se comprometer com uma blockchain específica, potencialmente restringindo o alcance do seu projeto.
Pode a Abstração consertar isso?
Antes de prosseguir, entendamos o que é abstração. É um conceito fundamental que simplifica a complexidade, ocultando detalhes desnecessários, permitindo que os usuários se concentrem em funcionalidades de nível superior sem ficar presos às complexidades subjacentes. Este princípio, crucial na programação orientada a objetos, vai além do desenvolvimento de software, facilitando a implementação de lógica complexa em vários domínios, fornecendo uma interface simples e fácil de interagir.

A abstração desempenha um papel crucial no desenvolvimento de software, simplificando a complexidade da construção do programa. Ele permite que os programadores se concentrem no alto nível de funcionalidade de seu código, em vez de ficarem atolados em detalhes pouco significativos de implementação. Ao abstrair códigos complexos em componentes mais gerenciáveis, os desenvolvedores podem acelerar seu fluxo de trabalho, aprimorar sua capacidade de solucionar problemas, iterar em seus programas e lidar com projetos mais avançados com maior eficiência.

A abstração não apenas agiliza o processo de desenvolvimento, mas também promove a inovação, dando liberdade aos programadores para explorar novas ideias e soluções, aproveitando os componentes abstraídos existentes para ampliar os limites de alcance de seu software.

Mas será que essa lógica pode ser estendida às blockchains?

A “abstração de cadeia” refere-se à simplificação da experiência do usuário da blockchain, ocultando seus complexos mecanismos subjacentes. Esta estratégia visa melhorar a acessibilidade e promover uma adoção mais ampla, apresentando assim uma interface mais intuitiva, como ficou evidenciado pelo crescimento significativo de usuários do NEAR, impulsionados pela sua ênfase na abstração desde 2018.
A visão da abstração em cadeia
A abstração de cadeia permite que os usuários possam interagir perfeitamente com os dapps, sem a necessidade de entender as complexidades das redes blockchain ou gerenciar vários ativos de criptomoeda. O objetivo é fazer com que as interações com a blockchain sejam tão intuitivas quanto usar qualquer aplicativo convencional, reduzindo assim as barreiras de entrada e incentivando uma adoção mais ampla das tecnologias Web3.




	

	
	
		
			
				Como as provas de conhecimento zero (ZK) contribuem para a segurança das transações blockchain?
			
		

		
					

		
			
			
			
			Exigindo uma rede descentralizada de validadores para cada transação
		
			
			Divulgando detalhes da transação para maior transparência
		
			
			Permitindo que um único computador verifique as regras sem revelar os dados subjacentes
		
			
			Aumentando a necessidade de armazenamento centralizado de dados
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






O Protocolo Near exemplifica a implementação bem-sucedida da abstração em cadeia, demonstrando seu potencial para aumentar significativamente o envolvimento do usuário. Ao abstrair a camada blockchain, o NEAR permitiu que os usuários realizassem transações e participassem da economia digital em diferentes redes por meio de uma interface simples e unificada. Isto não só melhora a usabilidade, mas também abre o espaço Web3 a um público mais amplo, contribuindo para o crescimento e a diversidade do ecossistema.

A abstração de cadeia também facilita o desenvolvimento de aplicações multi-chain, permitindo que os desenvolvedores se concentrem na criação de experiências de usuário de alta qualidade, em vez de ficar presos às limitações técnicas de uma determinada blockchain. Essa abordagem incentiva a inovação e a colaboração dentro da comunidade Web3, avançando rumo a um futuro onde as identidades e os ativos digitais possam ser gerenciados e transacionados de maneira transparente em várias plataformas blockchain, unificando assim o cenário fragmentado do atual ecossistema Web3.

Exemplo de abstração de cadeia

As provas de zero conhecimento ou ZKPs (Zero-knowledge proofs) podem ser uma ótima maneira de permitir a abstração de cadeia. As provas ZKPs introduzem um mecanismo onde é possível verificar a veracidade das informações sem revelar a própria informação. Imagine que você está entrando em uma boate e, para provar que tem idade legal para beber, basta mostrar seu ano de nascimento em vez de outras informações confidenciais (como nome, endereço, número do seguro social, etc.). Esse é um exemplo real de ZKPs. Agora vamos estendê-lo às redes blockchain.

Tradicionalmente, a segurança e a integridade das transações blockchain dependiam de uma rede descentralizada de validadores. Isto exigia um mecanismo de consenso, onde múltiplas partes validaram as transações, garantindo a sua legitimidade e mantendo assim a confiança da rede. No entanto, este método exige inerentemente um certo nível de confiança nos validadores coletivos e muitas vezes resulta num consumo significativo de recursos devido ao esforço computacional necessário para o consenso.

Os ZKPs podem permitir que um único computador afirme que certas regras ou condições foram cumpridas sem divulgar os dados subjacentes ou exigir um consenso de vários validadores. Esta mudança reduz significativamente a dependência de uma rede distribuída de validadores, permitindo que os processos de validação sejam mais simples e eficientes.




	

	
	
		
			
				Qual é o objetivo principal da abstração em cadeia no ecossistema Web3?
			
		

		
					

		
			
			
			
			Aumentar a complexidade dos dApps para usuários avançados
		
			
			Simplificar a experiência do usuário, ocultando as complexidades da blockchain
		
			
			Centralizar o gerenciamento de dados em redes blockchain 
		
			
			Eliminar a necessidade de provas criptográficas nas transações de dados
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Consequentemente, os desenvolvedores ganham flexibilidade para lançar novas blockchains com requisitos de recursos muito menores, já que não precisam mais estabelecer e manter uma grande rede de validadores. À medida que as blockchains adotam cada vez mais segurança comprovável por ZK, a publicação de uma prova ZK em uma cadeia pode verificar transações em múltiplas cadeias, tornando praticamente impossível alterar o estado de uma cadeia sem afetar as outras interligadas por essas provas.
Como o protocolo NEAR permite a abstração de cadeia
O protocolo NEAR está avançando na abstração de cadeia ao desenvolver um ecossistema centrado no usuário que simplifica as interações entre várias blockchains. Desde 2018, a NEAR priorizou a usabilidade, a escalabilidade e um modelo de conta flexível, com o objetivo de acomodar aplicações convencionais com potencial para atrair bilhões de usuários. A plataforma evoluiu para suportar totalmente a abstração de cadeia, permitindo uma operação perfeita em várias blockchains e aplicações.

Os principais componentes da abordagem da NEAR incluem uma infraestrutura de blockchain escalável capaz de suportar mais de um bilhão de contas ativas e uma barreira de segurança robusta. Esta barreira apresenta soluções de disponibilidade de dados (DA) da NEAR, zkWASM (provador de dados ZK) em colaboração com a Polygon Labs para provas eficientes de conhecimento zero e EigenLayer (protocolo de restaking) para finalidade aprimorada. Coletivamente, esses elementos garantem um ambiente seguro e escalável para aplicações descentralizadas.

O NEAR permite ainda a abstração da cadeia por meio da agregação de contas, permitindo que os usuários gerenciem suas interações em diferentes cadeias através de uma única conta. Esta simplificação estende-se à camada de dados, suportando uma ampla gama de arquiteturas blockchain e garantindo acesso consistente aos dados. Além disso, os retransmissores de intenção na infraestrutura do NEAR facilitam operações complexas em múltiplas cadeias, melhorando a interoperabilidade e a experiência do usuário.

Os Frontends descentralizados no NEAR oferecem uma interface unificada para descobrir e interagir com aplicações em todo o espectro Web3, apoiadas por super carteiras que simplificam a experiência do usuário, eliminando a necessidade de trocar de rede ou gerenciar taxas de gás.
Capacitando os usuários com auto soberania.
Além de simplificar a experiência do usuário, a abstração em cadeia se alinha ao objetivo mais amplo da auto soberania digital. Num mundo onde os dados pessoais e os ativos digitais são cada vez mais valiosos, a capacidade de controlar e gerir a identidade e os ativos digitais de uma pessoa torna-se fundamental. A Web3, com a sua natureza descentralizada, oferece uma estrutura para os usuários atingirem este nível de controle, livres das restrições e riscos dos sistemas centralizados.

A auto-soberania garante que os indivíduos controlem os seus dados, ativos e identidades, salvaguardando a privacidade e a autonomia da exploração centralizada da autoridade. Este conceito é crucial para prevenir violações de privacidade e promover interações digitais seguras em seus próprios termos. Isto transforma a economia digital num espaço mais equitativo, diminuindo os desequilíbrios de poder e promovendo um ambiente democrático onde os usuários interagem e fazem suas transações livremente sem se preocupar com a vigilância.
Como o NEAR permite a auto soberania.
O Protocolo NEAR facilita a auto soberania por meio de sua plataforma descentralizada, projetada para dar controle aos usuários sobre suas interações digitais. Ao abstrair as complexidades da tecnologia blockchain, o NEAR facilita o envolvimento dos usuários com dApps sem a necessidade de conhecimento profundo da infraestrutura subjacente. Esta abordagem não só melhora a usabilidade, mas também garante que os usuários possam gerenciar seus ativos e identidades digitais de forma integrada em vários aplicativos e plataformas.

O compromisso da NEAR com software de código aberto e o desenvolvimento de ferramentas fáceis de usar, como super carteiras e front-ends descentralizados, capacita ainda mais aos usuários, permitindo assim uma experiência digital auto soberana que se alinha ao espírito da Web3 e a visão mais ampla de uma Internet descentralizada.




	

	
	
		
			
				Qual recurso do protocolo NEAR oferece suporte à operação contínua em vários blockchains e aplicativos?
			
		

		
					

		
			
			
			
			Sua dependência de estratégias tradicionais de gerenciamento de dados
		
			
			Sua escalabilidade limitada e modelo de conta rígido
		
			
			Sua infraestrutura blockchain escalável é capaz de suportar mais de um bilhão de contas ativas
		
			
			Seu foco na centralização de identidades e ativos de usuários
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





A estrada à frente
O caminho para a adoção generalizada da Web3 e a realização da auto soberania digital não é isento de desafios. Requer um esforço conjunto de desenvolvedores, usuários e partes interessadas em todo o ecossistema para adotar os princípios de abstração e simplicidade. Ao nos concentrarmos em aplicativos fáceis de usar que abstraem as complexidades da tecnologia blockchain, podemos abrir as portas da Web3 para um público global.

A jornada caminho a uma Internet descentralizada e capacitada para o usuário, já está em andamento. Através dos princípios da abstração em cadeia e do foco na simplificação da experiência do usuário, podemos acelerar essa transição para a Web3 e capacitar os indivíduos com uma verdadeira auto soberania digital. À medida que navegamos nesta transição, a visão de uma Internet mais aberta, segura e centrada no usuário permanece ao nosso alcance, prometendo um futuro onde todos terão o controle sobre as suas vidas digitais.


                
                        
                            Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty Guide
                         
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Đơn giản hóa trải nghiệm Web3 với Chain Abstraction: Đường tới quyền tự chủ trong thời đại kỹ thuật số

Original post: https://learnnear.club/embracing-web3-through-chain-abstraction-a-path-to-digital-self-sovereignty/

Tiềm năng tuyệt vời của các công nghệ và hệ sinh thái phi tập trung là trao quyền tự chủ, quyền sở hữu cho tất cả các cá nhân tham gia. Tuy nhiên, các ứng dụng (dApps) và hệ sinh thái trong môi trường blockchain phi tập trung cùng sự nổi lên của hàng loạt giải pháp Layer 2 khác nhau đã làm phân mảnh trải nghiệm sử dụng, gây khó khăn cho người dùng phổ thông.

Vậy để thực sự khai thác tiềm năng của Web3 , chúng ta cần đơn giản hóa trải nghiệm người dùng và thúc đẩy việc hỗ trợ quyền tự chủ trong thời đại kỹ thuật số.
Các vấn đề phức tạp của Web3
#1 Xử lý dữ liệu
Các ứng dụng phi tập trung hiện tại (dApp) có một vấn đề rõ ràng: hầu hết đều không thực sự phi tập trung và không thân thiện với người dùng. Hiện tại người dùng phải biết cách sử dụng hàng loạt các sàn giao dịch, quản lý nhiều loại tài khoản và nhiều loại phí gas khác nhau, đây là rào cản rất lớn giữa thực tế đầy phức tạp của ứng dụng web3 hiện tại và lý tưởng ban đầu của chúng .

Sự phức tạp này không chỉ ngăn cản việc áp dụng web3 tới người dùng phổ thông mà còn giới hạn các dapp trong một tập người dùng nhỏ và tách biệt, khác xa với tầm nhìn về web3 dân chủ hóa.

Vậy sự phức tạp này đến từ đâu? Hã cùng quay lại vấn đề cơ bản và hiểu cách Web3 xử lý dữ liệu. Web3 thay đổi hoàn toàn cách quản lý và lưu trữ dữ liệu, chuyển từ cơ sở dữ liệu tập trung sang môi trường phi tập trung nơi dữ liệu được bảo mật bằng bằng chứng mật mã và hoàn toàn được sở hữu bởi người dùng.

Cách tiếp cận dữ liệu của Web3, với sự nhấn mạnh vào tính phi tập trung và xác thực mật mã, mang tới những thách thức cho các chiến lược quản lý dữ liệu truyền thống.
#2 Tính mô đun
Xu hướng hiện tại của Web3 hướng tới tính mô-đun, bao gồm việc chia chức năng blockchain thành các lớp riêng biệt như lớp đồng thuận(settlement), lớp khả dụng dữ liệu (data availability) và thực thi (execution), nhằm mục đích nâng cao khả năng mở rộng. Các công nghệ như Layer 2, Optimistic rollup hay ZK, sidechain là một trong các cách tiếp cận mô-đun này.

Tuy nhiên, điều này khiếntrải nghiệm của người dùng và nhà phát triển trở nên phức tạp , làm phân mảnh hệ sinh thái trên nhiều blockchain và dẫn đến tình trạng phân tán về thanh khoản, ứng dụng và người dùng.

Với các nhà phát triển, việc này đồng nghĩa với tình thế tiến thoái lưỡng nan khi phải giới hạn với một blockchain cụ thể, thu hẹp phạm vi tiếp cận người dùng của dự án.
Vậy trừu tượng hóa có khắc phục được các vấn đề trên?
Đầu tiên hãy hiểu trừu tượng (abstraction) là gì. Đây là một khái niệm cơ bản giúp đơn giản hóa sự phức tạp bằng cách che giấu những chi tiết không cần thiết, cho phép người dùng tập trung vào chức năng hơn mà không bị sa lầy vào những thứ phức tạp dưới hạ tầng.

Nguyên tắc này rất quan trọng trong lập trình hướng đối tượng, vượt ra ngoài việc phát triển phần mềm, tạo điều kiện thuận lợi cho việc triển khai logic phức tạp trên nhiều lĩnh vực khác nhau bằng cách cung cấp giao diện đơn giản hóa để tương tác.

Tính trừu tượng đóng một vai trò quan trọng trong phát triển phần mềm bằng cách đơn giản hóa sự phức tạp của việc xây dựng ứng dụng. Cho phép các nhà phát triển tập trung vào chức năng quan trọng trong ứng dụng của họ thay vì tốn thời gian vào những chi tiết vụn vặt.

Bằng cách trừu tượng hóa phần mã nguồn phức tạp thành các thành phần dễ quản lý hơn, nhà phát triển ứng dụng có thể tăng tốc quy trình làm việc, giảm thiểu lỗi, qua đó tập trung vào phát triển dự án với hiệu suất cao hơn.

Tính trừu tượng không chỉ hợp lý hóa quá trình phát triển mà còn thúc đẩy sự đổi mới bằng cách giải phóng các lập trình viên khám phá những ý tưởng và giải pháp mới, xây dựng dựa trên các thành phần trừu tượng hiện có để vượt qua ranh giới mà phần mềm của họ có thể đạt được.

Vậy logic này có thể được mở rộng sang blockchain không?

Chain Abstraction - Trừu tượng hóa blockchain đề cập đến việc đơn giản hóa trải nghiệm người dùng bằng cách che giấu các cơ chế phức tạp của blockchain. Chiến lược này nhằm mục đích nâng cao khả năng tiếp cận và thúc đẩy việc áp dụng rộng rãi hơn với giao diện trực quan, dễ sử dụng, dẫn tới kết quả là sự tăng trưởng người dùng đáng kể của NEAR đã được thúc đẩy với việc tập trung vào trừu tượng hóa blockchain từ 2018.
Tầm nhìn của Chain Abstraction
Chain Abstraction cho phép người dùng tương tác với các dapp một cách liền mạch mà không cần phải hiểu sự phức tạp của blockchain hoặc quản lý các tài sản crypto khác nhau.

Mục tiêu là làm cho việc tương tác với blockchain trở nên trực quan như sử dụng bất kỳ ứng dụng thông thường nào, qua đó giảm bớt rào cản sử dụng và khiến web3 được áp dụng rộng rãi hơn.




	

	
	
		
			
				Mục tiêu chính của việc trừu tượng hóa blockchain trong hệ sinh thái Web3 là gì?
			
		

		
					

		
			
			
			
			Để làm dapps phức tạp hơn phù hợp cho người dùng có kinh nghiệm
		
			
			Để đơn giản hóa trải nghiệm người dùng bằng cách ẩn đi sự phức tạp của blockchain
		
			
			Để tập trung quản lý dữ liệu trong mạng blockchain
		
			
			Để loại bỏ sự cần thiết của bằng chứng mật mã trong giao dịch dữ liệu
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR Protocol là một trong các ví dụ cho việc triển khai thành công việc trừu tượng hóa blockchain, thể hiện tiềm năng của ý tưởng này trong việc tăng đáng kể mức độ tương tác cho người dùng. Bằng cách trừu tượng hóa blockchain, NEAR cho phép người dùng thực hiện các giao dịch và tham gia vào nền kinh tế kỹ thuật số trên các mạng khác nhau thông qua một giao diện đơn giản và thống nhất. Qua đó nâng cao khả năng sử dụng và giúp không gian Web3 tiếp cận được nhiều đối tượng hơn, góp phần vào sự phát triển và đa dạng của hệ sinh thái.

Chain Abstraction tạo điều kiện thuận lợi cho việc phát triển các ứng dụng đa chuỗi bằng cách cho phép các nhà phát triển tập trung vào việc tạo ra trải nghiệm người dùng chất lượng cao thay vì bị hạn chế bởi các vấn đề kỹ thuật của một blockchain cụ thể.

Cách tiếp cận này khuyến khích sự đổi mới và hợp tác trong cộng đồng Web3, hướng tới tương lai nơi danh tính và tài sản kỹ thuật số thể được quản lý và giao dịch liền mạch trên nhiều nền tảng blockchain khác nhau, qua đó thống nhất sự phân mảnh của hàng loạt các hệ sinh thái blockchain hiện tại.

Các ứng dụng của Chain Abstraction

Bằng chứng không có kiến ​​thức (ZKP) là một cách tuyệt vời để kích hoạt tính năng trừu tượng hóa chuỗi. ZKP giới thiệu cơ chế có thể xác minh tính chính xác của thông tin mà không cần tiết lộ thông tin đó.

Hãy tưởng tượng bạn đang bước vào một hộp đêm và để chứng minh rằng bạn đủ tuổi uống rượu hợp pháp, bạn chỉ cần cho xem năm sinh của mình thay vì các thông tin nhạy cảm khác (Tên, Địa chỉ, Số An sinh Xã hội...). Đó là một ví dụ thực tế về ZKP. Bây giờ hãy mở rộng nó sang các mạng blockchain.

Theo truyền thống, tính bảo mật và tính toàn vẹn của các giao dịch blockchain dựa vào mạng lưới của các validator phi tập trung.

Điều này đòi hỏi một cơ chế đồng thuận, trong đó nhiều bên sẽ xác thực các giao dịch, đảm bảo tính đúng đắn của giao dịch và do đó duy trì sự tin cậy của mạng lưới.

Tuy nhiên, phương pháp này đòi hỏi mức độ tin cậy nhất định đối với các validator và thường dẫn đến việc tiêu thụ tài nguyên đáng kể do việc tính toán cần thiết để đạt được sự đồng thuận yêu cầu các validator phải xử lý mỗi giao dịch nhiều lần.

ZKP cho phép một máy tính xác nhận rằng các quy tắc hoặc điều kiện nhất định đã được đáp ứng mà không tiết lộ dữ liệu cơ bản hoặc yêu cầu sự đồng thuận từ nhiều validator.

Qua đó giảm đáng kể sự phụ thuộc vào mạng lưới của các validator phi tập trung, cho phép thực hiện các quy trình xác thực hợp lý, nhanh và hiệu quả.




	

	
	
		
			
				Bằng chứng không kiến ​​thức (ZKP) góp phần bảo mật các giao dịch blockchain như thế nào?
			
		

		
					

		
			
			
			
			Bằng cách yêu cầu một mạng lưới hàng loạt các validator phi tập trung cho mỗi giao dịch
		
			
			Bằng cách công khai các thông tin giao dịch
		
			
			Bằng cách cho phép một thiết bị xác minh các quy tắc mà không cần tiết lộ hoàn toàn các thông tinBằng cách cho phép một thiết bị xác minh các quy tắc mà không cần tiết lộ hoàn toàn các thông tin
		
			
			Bằng cách tăng nhu cầu lưu trữ dữ liệu phi tập trung 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Thông qua ZKP, nhà phát triển có được sự linh hoạt để khởi chạy các blockchain mới với yêu cầu tài nguyên thấp hơn nhiều, vì họ không còn cần phải thiết lập và duy trì một mạng lưới validator phân tán để cùng xác thực giao dịch.

Khi các blockchain ngày càng áp dụng công nghệ ZK, việc xuất bản bằng chứng ZK trên blockchain có thể xác minh các giao dịch trên nhiều chain khác nhau lại dẫn tới không thể nào thay đổi trạng thái của một blockchain mà không ảnh hưởng các blockchain liên quan khác.
Vậy NEAR triển khai Chain Abstraction như thế nào?
NEAR đang thúc đẩy Chain Abstraction bằng cách phát triển hệ sinh thái lấy người dùng làm trung tâm nhằm đơn giản hóa trải nghiệm blockchain. Từ 2018, NEAR đã ưu tiên khả năng sử dụng, khả năng mở rộng và mô hình tài khoản linh hoạt, nhằm mục đích cung cấp các ứng dụng chính thống có tiềm năng thu hút hàng tỷ người dùng. Nền tảng này đã phát triển để hỗ trợ đầy đủ Chain Abstraction, cho phép trải nghiệm liền mạch trên blockchain và ứng dụng khác nhau.

Các thành phần chính trong phương pháp tiếp cận của NEAR bao gồm cơ sở hạ tầng blockchain có thể mở rộng, hạ tầng hỗ trợ hàng tỷ tài khoản hoạt động trên mạng lưới và hệ thống bảo mật mạnh mẽ.

Hạ tầng này có các giải pháp mạnh mẽ về Tính khả dụng dữ liệu (DA), zkWASM phát triển cùng Polygon Labs để làm quá trình xác thực ZK hiệu quả hơn, kết hợp với EigenLayer cho giải pháp cross chain finality, qua đó giúp các L2 triển khai các giao dịch Web3 nhanh hơn và rẻ hơn nữa. Các yếu tố này đảm bảo một môi trường an toàn và có thể mở rộng cho hàng loạt ứng dụng phi tập trung.

NEAR còn cho phép trừu tượng hóa chuỗi thông qua Account aggregation (tính năng tài khoản tổng hợp), cho phép người dùng quản lý và tương tác với hàng loạt blockchain khác nhau với một tài khoản duy nhất. Sự đơn giản hóa này còn ở lớp dữ liệu của NEAR khi hỗ trợ nhiều loại kiến ​​trúc blockchain, qua đó đảm bảo quyền truy cập dữ liệu nhất quán, an toàn và ổn định.

Ngoài ra, lớp intent relayer có trong hạ tầng của NEAR tạo điều kiện thuận lợi cho các hoạt động phức tạp trên nhiều blockchain, nâng cao khả năng tương tác và trải nghiệm người dùng.

BOS - Giao diện người dùng phi tập trung trên NEAR cung cấp giao diện thống nhất để khám phá và tương tác với các ứng dụng Web3, kết hợp cùng hạ tầng Account Aggeration giúp hợp lý hóa trải nghiệm người dùng bằng cách loại bỏ nhu cầu chuyển đổi mạng hay phải trả phí các loại phí gas riêng biệt cho từng mạng lưới.
Trao quyền cho người dùng với quyền tự chủ
Ngoài việc đơn giản hóa trải nghiệm người dùng, Chain Abstraction còn phù hợp với mục tiêu rộng lớn hơn là quyền tự chủ kỹ thuật số. Trong một thế giới nơi dữ liệu cá nhân và tài sản kỹ thuật số ngày càng có giá trị, khả năng kiểm soát và quản lý danh tính và tài sản kỹ thuật số của một người trở nên tối quan trọng. Web3, với tính chất phi tập trung, cung cấp một khuôn khổ để người dùng đạt được mức độ kiểm soát này, không bị ràng buộc và chịu rủi ro của các hệ thống tập trung.

Quyền tự chủ đảm bảo các cá nhân có thể kiểm soát dữ liệu, tài sản và danh tính của mình, bảo vệ quyền riêng tư, tài sản khỏi việc bị khai thác bởi các bên tập trung.

Khái niệm này rất quan trọng để ngăn chặn hành vi vi phạm quyền riêng tư và thúc đẩy các tương tác kỹ thuật số an toàn theo điều kiện của riêng mỗi người. Biến nền kinh tế kỹ thuật số thành một không gian công bằng hơn, giảm thiểu sự mất cân bằng quyền lực và thúc đẩy một môi trường dân chủ - người dùng tự do tương tác và giao dịch mà không cần lo ngại bị kiểm soát.
Cách NEAR tạo điều kiện cho quyền tự chủ
NEAR tạo điều kiện cho quyền tự chủ thông qua một nền tảng phi tập trung, được thiết kế để cung cấp cho người dùng quyền kiểm soát các tương tác kỹ thuật số của mình.

Bằng cách trừu tượng hóa sự phức tạp của công nghệ blockchain, NEAR giúp người dùng tương tác với dApps dễ dàng mà không cần phải có kiến ​​thức chuyên sâu về các hạ tầng blockchain ở dưới. Cách tiếp cận này không chỉ nâng cao khả năng sử dụng mà còn đảm bảo người dùng có thể quản lý tài sản kỹ thuật số và danh tính của họ một cách liền mạch trên nhiều ứng dụng và nền tảng khác nhau.

Cam kết của NEAR đối với phần mềm nguồn mở và phát triển các công cụ thân thiện với người dùng như siêu ứng dụng ví và giao diện người dùng phi tập trung (BOS) tiếp tục trao quyền cho người dùng, tạo điều kiện cho trải nghiệm kỹ thuật số tự chủ phù hợp với đặc tính của Web3 và tầm nhìn rộng hơn về Web mở - Open Web.




	

	
	
		
			
				Tính năng nào của NEAR hỗ trợ hoạt động liền mạch trên nhiều blockchain và ứng dụng khác nhau?
			
		

		
					

		
			
			
			
			Phụ thuộc vào các cơ sở dữ liệu truyền thống
		
			
			Khả năng mở rộng hạn chế và mô hình tài khoản cùng hạ tầng cũ
		
			
			Cơ sở hạ tầng blockchain có thể mở rộng hỗ trợ hàng tỷ tài khoản dùng hàng ngày
		
			
			Tập trung vào việc bảo vệ danh tính và tài sản của người dùng
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Con đường phía trước
Con đường dẫn tới việc áp dụng Web3 rộng rãi và hiện thực hóa tầm nhìn về quyền tự chủ trong môi trường kỹ thuật số còn nhiều thách thức. Đòi hỏi nỗ lực phối hợp từ các nhà phát triển, người dùng và các bên liên quan trong toàn hệ sinh thái, bằng cách tập trung vào các ứng dụng thân thiện với người dùng giúp loại bỏ sự phức tạp của công nghệ blockchain, chúng ta có thể mở ra cánh cửa Web3 tới người dùng phổ thông toàn thế giới.

Hành trình hướng tới mạng Open Web - mạng internet phi tập trung, trao quyền cho người dùng đang được tiến hành. Thông qua các nguyên tắc của Chain Abstraction - trừu tượng hóa chuỗi và tập trung vào việc đơn giản hóa trải nghiệm người dùng, chúng ta có thể đẩy nhanh quá trình chuyển đổi sang Web3 và qua đó, trao quyền sở hữu cho các cá nhân trong môi trường kỹ thuật số.

Tầm nhìn về một mạng Internet mở, an toàn hơn và lấy người dùng làm trung tâm hơn đang nằm trong tầm tay, hứa hẹn một tương lai nơi mọi người đều có quyền kiểm soát dữ liệu và tài sản của mình trong môi trường số.


                
                        
                            Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty Guide
                         
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### FASTNEAR API: Revolutionizing Wallet and Explorer Interfaces with Low Latency

Discover the power of FASTNEAR API, the ultimate low-latency solution designed for wallets and explorers seeking unparalleled efficiency and reliability. With an expected latency of merely ~270ms for most services, FASTNEAR stands out by offering four distinct APIs that cater to a wide range of needs, ensuring that your application remains fast and responsive.

 	Public Key to Account ID Mapping: Easily map any public key to its corresponding account ID, including full access public keys, enabling a seamless integration for authentication and transaction verification processes.
 	Delegated Staking Pools Information: Retrieve detailed lists of validators to which an account ID has delegated staking, optimizing your platform's staking strategies and insights.
 	Fungible Tokens (FT Contracts) Lookup: Access comprehensive information on fungible token contracts associated with an account ID, facilitating a robust analysis of token distributions and transactions.
 	Non-Fungible Tokens (NFT Contracts) Discovery: Uncover the world of NFTs linked to an account ID, from ownership details to contract interactions, enhancing user engagement with personalized content and offers.




	

	
	
		
			
				Which API call would you use to find the account IDs associated with a full-access public key?
			
		

		
					

		
			
			
			
			GET /v0/account/{account_id}/staking
		
			
			GET /v0/public_key/{public_key}/all
		
			
			GET /v0/public_key/{public_key}
		
			
			GET /v0/account/{account_id}/ft
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Whether you're integrating FASTNEAR API into a wallet application to provide real-time account insights or into a blockchain explorer for enriched data visualization, our API ensures your service remains a step ahead with fast, accurate, and comprehensive data access. Experience the future of blockchain interfaces with FASTNEAR API, where speed meets accuracy.

Explore more at FastNEAR GitHub

### Update – February 27, 2024

Brief Summary:

 	
Wheel of Transactions is on 🔥🔥🔥


Results:

 	Join 🕺LNC Squad at ATTACK OF TRANSACTION🚀
We have reserved some NEAR to be distributed among participants!

 	February redeem submissions review produced some false positive - we are working on improving the process!

 

 	Inviting you to join 🕺LNC Hot Village🔥 ! Let's mine some $HOT together!


 

 	🏗Community Course in Portuguese "Desenvolvimento de Smart Contracts na Near Blockchain"🕺 by fresh NCD ramboj.near


 	📚 (L)Earn about "Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty"


 	LNC NEAR Watcher bot updated!



 	 Try AI Assisted Comments  - opportunity to learn together with AI.

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Learn NEAR Club Actions are coming to Telegram!

### Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty

There is little doubt about the sheer potential of decentralized technologies and ecosystems, especially when it comes to empowering individuals with self-sovereignty. However, the sheer complexity of decentralized applications (dApps) and the fragmented ecosystem of blockchains and rollups have limited their appeal to the broader public.

To truly harness the transformative power of Web3, we must simplify the user experience through abstraction and foster an environment that supports digital self-sovereignty.
Web3’s Complexity Problem
#1 Data handling

The current state of dapps reveals a stark truth: most are not truly decentralized nor user-friendly. The necessity for users to navigate exchanges, manage multiple accounts, and handle gas fees underscores the gap between the ideal of seamless applications and the reality of their complexity. This complexity not only deters mainstream adoption but also confines dapps to a niche user base far from the envisioned democratized web.

But where does this complexity come from? Let’s get back to basics and understand how Web3 deals with data. Web3 completely changes how data is managed and stored, moving away from centralized databases to a decentralized environment where data is secured with cryptographic proofs.

Web3's approach to data, with its emphasis on decentralization and cryptographic validation, presents a complex landscape that challenges traditional data management strategies.

#2 Modularity

The current trend in Web3 towards modularity, which involves breaking down blockchain functionality into distinct layers like settlement, data availability, and execution, aims to enhance scalability. Technologies such as layer-twos, optimistic and ZK rollups, and sidechains exemplify this modular approach. However, this has inadvertently complicated the user and developer experience, fragmenting the ecosystem across multiple blockchains and leading to a scattered landscape of liquidity, applications, and user bases. Developers face the dilemma of committing to a specific blockchain, potentially narrowing their project's reach.
Can Abstraction Fix This?
Before going any further, let’s understand what abstraction is. It is a fundamental concept that simplifies complexity by concealing unnecessary details, allowing users to focus on higher-level functionality without being bogged down by underlying intricacies. This principle, crucial in object-oriented programming, extends beyond software development, facilitating complex logic implementation across various domains by providing a simplified interface to interact with.

Abstraction plays a crucial role in software development by simplifying the complexity of program construction. It enables programmers to focus on the high-level functionality of their code rather than getting bogged down in the minutiae of implementation details. By abstracting complex code into more manageable components, developers can accelerate their workflow, enhance their ability to troubleshoot and iterate on their programs, and tackle more advanced projects with greater efficiency.

Abstraction not only streamlines the development process but also fosters innovation by freeing programmers to explore new ideas and solutions, building upon existing abstracted components to push the boundaries of what their software can achieve.

But can this logic be extended to blockchains?

Chain abstraction refers to simplifying the blockchain user experience by concealing its complex underlying mechanisms. This strategy aims to enhance accessibility and foster wider adoption by presenting a more intuitive interface, as evidenced by NEAR's significant user growth, driven by its emphasis on abstraction since 2018.
The Vision of Chain Abstraction
Chain abstraction allows users to interact with dapps seamlessly without needing to understand the intricacies of blockchain networks or manage various cryptocurrency assets. The goal is to make blockchain interactions as intuitive as using any conventional application, thereby lowering barriers to entry and encouraging wider adoption of Web3 technologies.




	

	
	
		
			
				What is the primary goal of chain abstraction in the Web3 ecosystem?
			
		

		
					

		
			
			
			
			To increase the complexity of dApps for advanced users
		
			
			To simplify the user experience by hiding blockchain complexities
		
			
			To centralize data management in blockchain networks
		
			
			To eliminate the need for cryptographic proofs in data transactions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






The NEAR Protocol exemplifies the successful implementation of chain abstraction, demonstrating its potential to significantly increase user engagement. By abstracting the blockchain layer, NEAR has enabled users to perform transactions and participate in the digital economy across different networks through a single, unified interface. This not only enhances usability but also opens up the Web3 space to a broader audience, contributing to the growth and diversity of the ecosystem.

Chain abstraction also facilitates the development of multichain applications by allowing developers to focus on creating high-quality user experiences rather than being constrained by the technical limitations of a particular blockchain. This approach encourages innovation and collaboration within the Web3 community, moving towards a future where digital identities and assets can be seamlessly managed and transacted across various blockchain platforms, thereby unifying the fragmented landscape of the current Web3 ecosystem.

Example of chain abstraction

Zero-knowledge proofs (ZKPs) can be a great way to enable chain abstraction. ZK proofs introduce a mechanism where it's possible to verify the correctness of information without revealing the information itself. Imagine you are entering a nightclub, and to prove that you are of legal drinking age, you simply show your birth year instead of other sensitive information (like Name, Address, Social Security Number, etc.). That's a real-life example of ZKPs. Now let's extend it to blockchain networks.

Traditionally, the security and integrity of blockchain transactions relied on a decentralized network of validators. This required a consensus mechanism, where multiple parties would validate transactions, ensuring their legitimacy and thus maintaining the network's trust. However, this method inherently demands a certain level of trust in the collective validators and often results in significant resource consumption due to the computational effort required for consensus.

ZKPs can enable a single computer to affirm that certain rules or conditions have been met without disclosing the underlying data or requiring a consensus from multiple validators. This shift significantly reduces the reliance on a distributed network of validators, allowing for more streamlined and efficient validation processes.




	

	
	
		
			
				 How do zero-knowledge (ZK) proofs contribute to the security of blockchain transactions?
			
		

		
					

		
			
			
			
			By requiring a decentralized network of validators for each transaction
		
			
			By publicizing transaction details for transparency
		
			
			By allowing a single computer to verify rules without revealing underlying data
		
			
			By increasing the need for centralized data storage
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Consequently, developers gain the flexibility to launch new blockchains with much lower resource requirements, as they no longer need to establish and maintain a large network of validators. As blockchains increasingly adopt ZK-provable security, the publication of a ZK proof on one chain can verify transactions across multiple chains, making it practically impossible to alter the state of one chain without affecting the others interconnected by these proofs.
How NEAR Protocol Enables Chain Abstraction
NEAR Protocol is advancing chain abstraction by developing a user-centric ecosystem that simplifies interactions across multiple blockchains. Since 2018, NEAR has prioritized usability, scalability, and a flexible account model, aiming to accommodate mainstream applications with the potential to attract billions of users. The platform has evolved to fully support chain abstraction, allowing seamless operation across various blockchains and applications.
Dive deeper at NEAR Docs

Key components of NEAR's approach include a scalable blockchain infrastructure capable of supporting over a billion active accounts and a robust security stack. This stack features NEAR's data availability (DA) solutions, zkWASM in collaboration with Polygon Labs for efficient zero-knowledge proofs, and EigenLayer for enhanced finality. Collectively, these elements ensure a secure and scalable environment for decentralized applications.

NEAR further enables chain abstraction through account aggregation, allowing users to manage their interactions across different chains via a single account. This simplification extends to the data layer, supporting a wide range of blockchain architectures and ensuring consistent data access. Additionally, intent relayers within NEAR's infrastructure facilitate complex operations across multiple chains, enhancing interoperability and user experience.

Decentralized frontends on NEAR offer a unified interface for discovering and interacting with applications across the Web3 spectrum, supported by super wallets that streamline the user experience by eliminating the need to switch networks or manage gas fees.

Chain abstraction makes it possible for  NEAR projects collaborate with other blockchains!
Empowering Users with Self-Sovereignty
Beyond simplifying the user experience, chain abstraction aligns with the broader goal of digital self-sovereignty. In a world where personal data and digital assets are increasingly valuable, the ability to control and manage one's digital identity and assets becomes paramount. Web3, with its decentralized nature, offers a framework for users to achieve this level of control, free from the constraints and risks of centralized systems.

Self-sovereignty ensures individuals control their data, assets, and identities, safeguarding privacy and autonomy from centralized authority exploitation. This concept is crucial for preventing privacy breaches and promoting secure digital interactions on one's own terms. It transforms the digital economy into a more equitable space, diminishing power imbalances and fostering a democratic environment where users freely interact and transact without surveillance concerns.
How NEAR enables self-sovereignty
NEAR Protocol facilitates self-sovereignty through its decentralized platform, designed to give users control over their digital interactions. By abstracting the complexities of blockchain technology, NEAR makes it easier for users to engage with dApps without needing in-depth knowledge of the underlying infrastructure. This approach not only enhances usability but also ensures that users can manage their digital assets and identities seamlessly across various applications and platforms.

NEAR's commitment to open-source software and the development of user-friendly tools like super wallets and decentralized frontends further empowers users, enabling a self-sovereign digital experience that aligns with the ethos of Web3 and the broader vision of a decentralized internet.




	

	
	
		
			
				What feature of NEAR Protocol supports seamless operation across various blockchains and applications?
			
		

		
					

		
			
			
			
			Its reliance on traditional data management strategies
		
			
			Its limited scalability and rigid account model
		
			
			Its scalable blockchain infrastructure capable of supporting over a billion active accounts.
		
			
			Its focus on centralizing user identities and assets
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The Road Ahead
The path to widespread Web3 adoption and the realization of digital self-sovereignty is not without challenges. It requires a concerted effort from developers, users, and stakeholders across the ecosystem to embrace the principles of abstraction and simplicity. By focusing on user-friendly applications that abstract away the complexities of blockchain technology, we can open the doors of Web3 to a global audience.

The journey towards a decentralized, user-empowered internet is underway. Through the principles of chain abstraction and a focus on simplifying the user experience, we can accelerate the transition to Web3 and empower individuals with true digital self-sovereignty. As we navigate this transition, the vision of a more open, secure, and user-centric internet remains within reach, promising a future where everyone has control over their digital lives.


                 
 
                        Does this Guide help you to understand Chain Abstraction?(Required)
			
					
					Yes
			
			
					
					No
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### How to use AI to make good quality comments at Learn NEAR Club

In the landscape of interactive learning, the exchange of comments plays a crucial role by fostering new neuron connections and enhancing the learning process. The Learn NEAR Club, recognizing the diversity of its global learners, many of whom are not native English speakers, has embraced an innovative solution to overcome the language barrier. By leveraging Artificial Intelligence (AI) NEAR AI by mob.near from NEAR Social, LNC aims to ensure that every learner can fully express their thoughts and engage with learning content without linguistic constraints.

This initiative utilizes AI not merely as a translator but as a tool to enrich learners' comments, enabling them to convey their insights more effectively. This approach not only facilitates deeper understanding and engagement with the material but also encourages a broader participation across linguistic backgrounds. The AI-assisted commentary system is designed to capture the essence of learners' thoughts, ensuring that valuable perspectives are not lost due to language limitations.

By integrating AI into the learning process, the Learn NEAR Club is setting a precedent for inclusivity and accessibility in learning. This forward-thinking strategy amplifies the voices of all learners, fostering a richer, more diverse dialogue. The result is a more connected and inclusive learning environment, where barriers to participation are dismantled, and the exchange of ideas flourishes.

Please check this short screencast and try AI assisted comments by yourself.

https://learnnear.club/wp-content/uploads/2024/02/learn-near-club-ai-assited-commnets.mp4

        
            Would you use AI for learning? 
            
                281 votes by,
                503 nLEARNs spent
            
            
            
                                    
                        
                            Yes                            
                                (270 votes,
                                486 nLEARNs)
                            
                        
                        
                             
                            96%
                        
                    
                                    
                        
                            No                            
                                (11 votes,
                                17 nLEARNs)
                            
                        
                        
                             
                            4%

### NEAR Tinker Union: The Journey of Tinkers so far on NEAR

Ever wondered how the journey of one of the best NEAR Wallets named Meteor wallet got started on NEAR? If not, then now would be a good time to explore who are the people behind NEAR and how they came into existence in Q1, 2022.

The team behind Meteor Wallet is NEAR Tinker Union. NEAR Tinker Union is an NFT collection community on NEAR that started their NEAR journey early in 2022 with a minting NTU NFT event in Feb 2022. This community of builders believe that the blockchain is going to bring more freedom to the world. Till now the team and their community has built some amazing products that benefit the NEAR ecosystem and are bringing value to their NFT holders.





	
		0%
	



	

	
	
		
			
				When did the minting of NEAR Tinker Union happen?
			
		

		
					

		
			
			
			
			Jan 2022
		
			
			Feb 2022
		
			
			March 2022
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	
	Continue >>





	
	
		
			
				Who is the team behind Meteor Wallet?
			
		

		
					

		
			
			
			
			NEAR Tinker Union
		
			
			Night Tinker Union
		
			
			NEAR Tiger Union
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	
	Continue >>







About NEAR Tinker Union Collection
Near Tinker Union aka NTU community is a union of 3,333 tinkers formed to tink extraordinary tools to help the ever-growing ecosystem. The collection got minted in Feb 2022 with the price of 6 $NEAR on https://mint.tinkerunion.com/ . Back then NTU holders got access to a gated discord full of alphas, 25% of royalties fee given back to holders, 20% of launchpad revenue will be distributed among holders, and many more earning opportunities.





	
		0%
	



	

	
	
		
			
				What was the minting price of NEAR Tinker Union?
			
		

		
					

		
			
			
			
			6 $NEAR
		
			
			16 $NEAR
		
			
			60 $NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	
	Continue >>





	
	
		
			
				How much royalty fees goes back to the holders?
			
		

		
					

		
			
			
			
			10 % 
		
			
			15 %
		
			
			20 %
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	
	Continue >>








Today the floor price of the NFT’s is around 69 $NEAR (11x ROI since the launch) with more than 500+ holders and total volume whopping around 92K $NEAR.
Market Cap
Market Cap is calculated by multiplying the average price of the NFT over seven days by how many of them exist. NFT marketplaces can be tricky because it's not always easy to find someone willing to buy your NFT when you want to sell it.

So, if an NFT has a high estimated market cap, it suggests that there are a lot of people interested in buying it and they're willing to pay a good price. Basically, NFTs with high estimated market caps are usually a good sign because they indicate strong interest from potential buyers.

As of today, NTU has a Market Cap of $697K, ranking the 1st spot in the NEAR NFT leaderboard.




	

	
	
		
			
				NFTs with high estimated market caps are usually a sign of?
			
		

		
					

		
			
			
			
			Over Priced NFTs
		
			
			 Under Priced NFTs
		
			
			Strong Interest Priced NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Rarity Score
NFTs that are rarer usually worth more than ones that are common. A rarity score helps collectors figure out how valuable a specific NFT is. Every feature or characteristic of an NFT gets a rarity score. These scores are added up to give an overall rating for the NFT.

All the 3333 NFTs are 1/1. The rarity of each NFT depends on background, eye, skin, outfit, face, hat and special. You can find about the NFT rarity using the search bar at http://rarity.tinkerunion.com using:

 	Search by Token/NFT
 	Search by Rank




	

	
	
		
			
				A rarity score helps collectors figure out how valuable a specific NFT is
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

 	


Team Members
Currently the team is of 5 members (3 technical, 2 growth/BD) based in the UK, Malaysia, and South Africa.

 	Edward Chew (CEO)
 	Jonathan (COO)
 	Paul Myburgh (Lead Dev)
 	Henry (SC Dev)
 	Jensen Lim (Designer)

Social Presence
The team boasts a solid group of dedicated community builders who prioritize quality over quantity. Here are some followers/members social account metrics they have gained in the past two years:

 	Twitter https://twitter.com/NearTinkerUnion : 8.65K
 	Discord https://discord.com/invite/YfSnjGHJfT : 4.18K



 
Roadmap
The roadmap is vital in NFT projects as it lays out the project's direction, objectives, and timelines, guiding the team and investors. By sharing it, teams demonstrate transparency, build trust, and keep stakeholders informed about the project's progress. Additionally, the roadmap helps in effective planning, resource allocation, and communication of the project's vision and strategy. It also allows for flexibility and adaptability to respond to changes in the dynamic NFT market landscape.
2022 Roadmap

 	February 2022: Near Tinker Union NFT Mint (3333 NFTs at 6N - Sold out instantly)
 	March 2022: Launch of Enleap NFT Launchpad
 	April 2022: Launch of tinkerunion.com
 	April 2022: Staking for Tinkers (earn $GEAR tokens)
 	April 2022: WL & NFT raffle product for $GEAR tokens
 	May 2022: $GEAR Liquidity pool goes live on REF finance
 	May 2022: Meteor Wallet announcement with product demo
 	July 2022: Meteor Wallet alpha release
 	October 2022: Meteor Wallet Public Launch
 	November 2022: In-wallet swap aggregator
 	November 2022: In-wallet staking
 	November 2022: Meteor Explore launch


 	

2023 Roadmap

 	January 2023: Meteor Profiles with Near Social integration
 	February 2023: Meteor Wallet has been chosen as the maintainer of the MyNearWalletproject.
 	February 2023: Meteor hits 20,000 wallets.
 	March 2023: Launch of Meteor Support 2.0
 	May 2023: Launch of Meteor Mentions to curate news from around the NEAR ecosystem.
 	July 2023: Launch of rebrand and new website at https://meteorwallet.app/


 	

2024 Roadmap

 	Jan-24: Meteor Raised Pre-Seed $500K
 	Jan-24: Meteor Completed Ledger Integration.
 	Jan-24: 100K Meteor Waller Users completed.

Product 01: $GEAR Token
$GEAR is the currency of the Tinkers, it will be needed to participate in their raffles and future offerings. GEAR Token has a total supply of 9,700,000. NTU holders can earn $GEAR by staking their NFTs. As per the recent data 2310 NFTs are staked at http://tinkerunion.com/stake which is 70% of the total supply. The allocation of $GEAR to the stakers is based on the Tinkers Rarity ranking. The calculation of $GEAR Reward = 1.0005 ^ (3333 - ranking of tinker)

 	

 	Rank 3333 earns 1 $GEAR daily
 	Rank 1 earns 5.2 $GEAR daily



Raffles: https://tinkerunion.com/raffle

Tinker Ranking Emission: https://bit.ly/3M67WvF
Price Action of $GEAR
$GEAR Token All-time low is $0.0009c on Oct-23. Today's Price: $0.1396 (17th-Feb-24) which sums up the total gain of 15511%. The $GEAR/$wNEAR can be traded at ref finance and price action stats can be monitored at https://dexscreener.com/near/refv1-3411
Product 02: Enleap NFT Launchpad
Another product of the NTU is Enleap (http://enleap.app) NFT launchpad: it offers a no-code NFT launchpad with the following features:

 	Start FREE.
 	Pay 5% for your mint + 0% Royalties.
 	Sales Bot, Rarity Ranking etc.
 	Multi-tier Whitelist Management.
 	Marketing Partnership

Product 03: Meteor Wallet
Introducing the third product from the NFT team: Meteor Wallet, a user-friendly and highly secure wallet designed for managing crypto assets, accessing DeFi platforms, and exploring the $NEAR ecosystem.

Recently, the wallet has surpassed 100,000 users and successfully raised over $500,000 in a pre-seed funding round, featuring ledger integration for added security. Additionally, the team has unveiled an exciting NFT collection called "Harvest Moon NFT ," created in collaboration with Sharddog for dropping the NFT tokens through an airdrop. The campaign's success is evident as a remarkable 91,405 NFTs were claimed within just one week of its launch.




	

	
	
		
			
				How much fund Meteor Wallet Team were able to raise in Pre-seed round
			
		

		
					

		
			
			
			
			$50,000
		
			
			$250,000
		
			
			$500,000
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Final Thoughts
The NEAR Tinker Union has been building on NEAR for a long time and has given good products to the community even during the BEAR market time when most of the projects couldn’t keep their promises. Holding one Tinker (NTU NFT) is going to be a long life experience for every NEAR community member to support this ever growing team.

 

### Streamlined Guide to Community Mining: Maximizing HOT in Villages

Mining HOT in villages is an innovative community mining initiative that's gained traction with over 1,000,000 participants. This approach leverages Telegram chats for village creation or joining, enhancing HOT acquisition through a 5% bonus on claims, benefitting the village's treasury. These funds are earmarked for community rewards and other communal benefits.

Joining a Village:

 	Create or Join: Send a chat link to the bot for village creation or join an existing one.
 	Top Villages: Join through direct links. Join LNC Hot village now!
 	Village Switching: Join a new village at any time, with a HOT fee applied to all switches except the first.

Village Competitions: Villages vie in accumulating HOT treasures within leagues, with top performers earning rewards and in-wallet promotions.

Village Fund Management: Admin rights are granted to @herewalletbot for village fund management, with initial admin controlling the treasure.

Looking Ahead: Future updates aim to boost community engagement through multiplayer features, including HOT giveaways, inter-village competitions, and voting on treasure allocations.

This streamlined approach offers a community-centric way to mine HOT, promising more interactive and rewarding experiences.
https://www.youtube.com/watch?v=xH-zpDQcXU0

### Post Template for Letting (L)Earners know About Your Project

Introduction

 	Hook: Start with a compelling statement or question that grabs the reader's attention.
 	Overview: Briefly introduce the tech project, its name, and its core purpose.
 	Relevance: Explain why this project matters to your audience. Highlight the problems it solves or the opportunities it creates.

The Inspiration Behind the Project

 	Origin Story: Share the backstory of how the project came to be. This could include the challenges, market gaps, or technological advancements that inspired its creation.
 	Vision and Mission: Outline the vision behind the project and the mission it aims to accomplish. This helps readers connect with your project on a deeper level.

How It Works: A Simplified Explanation

 	Technical Overview: Provide a simplified explanation of the technology behind the project. Avoid jargon to ensure it's accessible to readers with various levels of technical knowledge.
 	Features and Benefits: Break down the key features of the project and the benefits each brings to the user. Use bullet points for clarity.
 	Real-world Application: Offer examples of how the project can be used in real-life scenarios. This helps readers visualize its practical value.

Unique Selling Points

 	Comparison: Briefly compare your project with existing solutions, emphasizing what makes yours different or better.
 	Innovations: Highlight any innovative aspects of your project, such as unique technology, methodology, or application.

Getting Started

 	User Guide: Provide a basic guide on how to get started with your project. Include steps for initial setup, basic operations, and where to find more information.
 	Resources: Link to resources such as detailed documentation, tutorials, FAQ sections, and community forums.

Future Roadmap

 	Upcoming Features: Share insights into the future development plans for the project, including any upcoming features or improvements.
 	Engagement Invitation: Encourage readers to contribute ideas, feedback, or participate in beta testing. This fosters a sense of community and involvement.

Conclusion

 	Call to Action (CTA): Conclude with a strong CTA. This could be an invitation to try out the project, join a community discussion, or follow your project on social media for updates.
 	Gratitude: Thank your readers for their time and express hope that they found the post informative and engaging.

(Optional) FAQs

 	Include a section for Frequently Asked Questions where you address common queries about the project. This helps to clarify doubts and provide additional value to the readers.

Test Fresh Knowledge: Micro-Quizzes
After learning about our new tech project, it’s time to put learners knowledge to the test!
Let's have (l)earners take these micro-quizzes to see how well they’ve grasped the important information.
Quiz 1: Understanding the Basics

 	What problem does our tech project solve?

 	A)
 	B)
 	C)
 	Correct Answer:


 	Which technology is at the core of our project?

 	A)
 	B)
 	C)
 	Correct Answer:



Quiz 2: Features and Benefits

 	Which of the following is a key feature of our project?

 	A)
 	B)
 	C)
 	Correct Answer:


 	How does our project differ from existing solutions?

 	A)
 	B)
 	C)
 	Correct Answer:



Quiz 3: Future Directions

 	What is one of the upcoming features we plan to introduce?

 	A)
 	B)
 	C)
 	Correct Answer:


 	How can you get involved with the project?

 	A)
 	B)
 	C)
 	Correct Answer:



Submit your NEAR project publication request here!

### NEAR Protocol's Phase 2 Sharding Explained

In the rapidly evolving world of blockchain technology, keeping up with the latest developments can feel like trying to drink from a firehose. One of the most exciting updates making waves recently is the NEAR Protocol's announcement of its Phase 2 Sharding launch. But what does this actually mean for you and me? Let's break it down into simpler terms.
What is the NEAR Protocol?
Imagine a digital city where transactions and applications run smoothly, quickly, and without costing an arm and a leg. That's what the NEAR Protocol aims to be: a foundation for building and using apps in a way that's accessible to everyone, not just the tech-savvy.
The Magic of Sharding
Sharding is like dividing a big, bustling city into smaller, manageable neighborhoods. Each neighborhood can handle its own traffic, reducing congestion and allowing more people to go about their business quickly. In blockchain terms, this means more transactions can happen simultaneously, making the whole system faster and more efficient.




	

	
	
		
			
				What does sharding do in blockchain technology?
			
		

		
					

		
			
			
			
			Slows down transactions for security reasons
		
			
			Divides the blockchain into multiple parallel sections to increase efficiency
		
			
			Increases the cost of transactions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The Leap to Phase 2
Phase 2 of Sharding is like upgrading those neighborhoods with super-speedy transport systems and better communication tools. Specifically, NEAR is introducing something called "stateless validation." Previously, each area (or "shard") needed to keep a detailed ledger of every transaction and piece of data. Now, they can access this information from the central city library (so to speak), making it much easier and faster to validate transactions.




	

	
	
		
			
				How does Phase 2 improve upon the original sharding mechanism?
			
		

		
					

		
			
			
			
			By requiring more hardware for validation
		
			
			By introducing stateless validation, making the process faster and more efficient
		
			
			 By decreasing the number of transactions possible
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






https://youtu.be/SREbjNh_p0E?si=nrh5F3z5wr18zLS5
Why Should You Care?
For starters, this upgrade means that using NEAR's blockchain will get a lot faster and cheaper. Imagine sending money, playing games, or using social media without waiting for things to load or paying high fees. That's the goal here.
Stake Wars IV: Your Chance to Get Involved
NEAR is not just making these changes in a lab; they're inviting everyone to help test them out through something called Stake Wars IV. Think of it as a massive, worldwide game where you can contribute to improving the technology and even earn rewards for doing so.

How a ordinary Telegram user becomes a NEAR Stateless network tester on ONE minute!






	

	
	
		
			
				What is Stake Wars IV?
			
		

		
					

		
			
			
			
			A video game based on the NEAR Protocol
		
			
			An incentivized community testing initiative for the new sharding architecture
		
			
			A conference for stakeholders in the NEAR Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The Bigger Picture
With these updates, NEAR isn't just looking to improve its own system. They're paving the way for a future where blockchain technology can support billions of users worldwide, doing everything from shopping to voting without a hitch. It's about creating a digital world that's open, efficient, and accessible to all.
Final Thoughts
Phase 2 of Sharding on the NEAR Protocol might sound technical, but the implications are vast and exciting. It's about making the digital world faster, cheaper, and more inclusive. Whether you're a developer, a curious observer, or someone just looking to understand the future of technology, there's a lot to look forward to with NEAR's latest developments.
(L)Earners at Stake Wars IV:
We are plaining to have super fun game with Rewards in NEAR, stay tuned! New round coming soon!


                
                        
                            Join LNC NEAR Stake Wars waiting list
                         
 
                        Email(Required)
                            
                        First Name(Required) NEAR Account(Required) 
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Submit with nStamp

### Update – January 23, 2024

Brief Summary:

 	
Learn NEAR Club had a blast in year 2023!


Results:

 	🏆Top 10  (L)Earn projects of 2023🚀

 	November, December and January redeems - over 3,000 NEAR claimed as (l)earning rewards!
 	Now you can check your 📚(L)Earn🕺 score right here, at your @here_wallet

 	Introducing LNC Talks - discussion with 3 stage web3 moderation

 	📚 (L)Earn about "Mastering Online Communication: A Comprehensive Guide" generated by ai.learnclub.near

 	Just added seedless, gassless, non-custodial @mintbasewallet


 	 LNC translators from Vietnam are working on bringing this Guide to community via Heros bounty!
This is EXACTLY what web3 is about - positive sum game. web3=WinWinWin

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	NEAR Certified Developer Live demo is on January 26, 2024 at 11 ET

### Integrating: Mintbase Wallet, Tutorial with Luis Freitas

Join Luis Freitas as he guides you through the seamless integration of Mintbase Wallet into your projects. In this tutorial, learn step-by-step how to enhance user experience and streamline onboarding. Luis demonstrates the technical details, including the wallet context provider and the wallet selector component.

https://www.youtube.com/watch?v=2TxaqILs7Jg

### Mastering Online Communication: A Comprehensive Guide

Introduction
Welcome to "Mastering Online Communication: A Comprehensive Guide."

This guide is designed to provide you with essential strategies and best practices for effective digital communication across various platforms. Whether you're handling emails, instant messaging, social media, or virtual meetings, this guide will help you navigate these channels with professionalism and ease.
Email Etiquette

 	Key Principles: Learn the art of crafting clear, concise, and professional emails.
 	Best Practices:

 	Effective Subject Lines: Discover how to write subject lines that accurately reflect the content of your email.
 	Email Structure: Learn the proper structure of an email including greetings, body, and closing.
 	Tone Maintenance: Understand how to maintain an appropriate tone that matches the context of your email.
 	Expectations for Replies:

 	Learn common practices for setting clear expectations for email replies, including response times and the level of detail needed.
 	Understand the importance of instant acknowledgment. Even if a detailed response will take time, a quick acknowledgment email can inform the sender that their message has been received and will be attended to.
 	Discuss best practices for out-of-office or delayed response notifications.




 	Self-Check Exercise:

 	Practice rewriting poorly written email examples.
 	Review email scenarios and determine the appropriate response time, level of detail for replies, and how to instantly acknowledge an email.






	

	
	
		
			
				Email Etiquette: What should a professional email subject line be like?
			
		

		
					

		
			
			
			
			SHOUTING IN ALL CAPS
		
			
			Short and sweet, like a good tweet
		
			
			Emoji-filled 
		
			
			Mysterious as a spy movie
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Effective Messaging in Instant Messengers

 	Overview: Understanding the role of instant messaging in the workplace.
 	Actionable Tips:

 	Brevity and Clarity: Be concise but clear in your messages. Aim to convey your message in as few words as possible without losing the intended meaning.
 	Professional Use of Emojis: Use emojis sparingly and only when they are appropriate to the context and tone of the conversation.
 	Group Chat Etiquette: Stay on topic, respect everyone’s time, and avoid overwhelming the conversation with non-essential messages.
 	Reply Time Expectations:

 	Respond within a few hours during working hours for standard queries.
 	Immediate issues may require quicker responses.
 	Communicate delays proactively if you're unable to respond promptly.


 	Tagging for Urgent Responses:

 	When an immediate response is needed, use the tagging feature to directly notify the specific individual. This helps in drawing attention to urgent messages.
 	Be judicious with tagging. Overuse for non-critical messages can dilute its importance.




 	Interactive Activity:

 	Engage in a simulated chat scenario focusing on professional etiquette, including managing reply times, using tags appropriately for urgent messages, and balancing clarity with brevity.






	

	
	
		
			
				Effective Messaging in Instant Messengers: When is it okay to sprinkle emojis into your professional messages?
			
		

		
					

		
			
			
			
			Like confetti at a party, always
		
			
			Never, keep it as serious as a robot
		
			
			Just a pinch, when it feels right
		
			
			Fridays only, to celebrate the weekend
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conducting and Participating in Conference Calls

 	Overview: The dynamics of virtual meetings.
 	Actionable Tips:

 	Pre-Meeting Preparation: Test your tech beforehand.
 	In-Meeting Etiquette: Mute when not speaking, be attentive.
 	Engagement: Participate actively but respectfully.


 	Interactive Activity: Conduct a mock conference call, practicing the discussed etiquette.




	

	
	
		
			
				Conducting and Participating in Conference Calls: Before jumping into a virtual meeting, you should:
			
		

		
					

		
			
			
			
			Keep your mic open for a live concert experience
		
			
			Do a tech-check like a space mission countdown
		
			
			Stock up on snacks like you're going to the movies
		
			
			Find the noisiest spot to seem super busy
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Navigating Social Media Communication

 	Overview: Professionalism on social media.
 	Actionable Tips:

 	Public vs. Private Persona: Be mindful of what you share.
 	Responding to Comments: Keep responses professional and polite.
 	Building a Professional Image: Share content relevant to your industry.


 	Interactive Activity: Create a mock social media strategy for a business scenario.




	

	
	
		
			
				Navigating Social Media Communication: What's the secret to looking professional on social media?
			
		

		
					

		
			
			
			
			Turn it into your personal diary
		
			
			Be the class clown with jokes galore
		
			
			Share wisely, like a sage giving advice
		
			
			Ghost everyone and post nothing
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cross-Cultural Communication in Online Settings

 	Overview: The importance of cultural sensitivity in digital communication.
 	Actionable Tips:

 	Cultural Awareness: Research and respect cultural differences.
 	Inclusive Language: Use clear, simple language.
 	Adapting Communication Style: Be flexible and open to different communication styles.


 	Interactive Activity: Analyze and discuss case studies involving cross-cultural communication challenges.

Meeting Attendance and Punctuality

 	Overview: The impact of punctuality on professional reputation.
 	Actionable Tips:

 	Communicating Delays: Immediately inform others if you’re running late.
 	Managing No-Shows: Have a backup plan for missing attendees.
 	Respecting Others’ Time: Be punctual and prepared.


 	Interactive Activity: Role-play scenarios dealing with attendance issues.




	

	
	
		
			
				Meeting Attendance and Punctuality: You're late for a meeting! What's your move?
			
		

		
					

		
			
			
			
			 Ninja mode: slip in unnoticed
		
			
			Send an SOS to the organizer about your grand entrance
		
			
			Vanish - maybe they won't notice you're not there
		
			
			Play it cool, pretend you forgot the day of the week
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
This guide is a comprehensive resource for anyone looking to improve their online communication skills. By applying these best practices, you will be better equipped to navigate the digital communication landscape with confidence and professionalism.
Useful Stuff
Please also explore The 37signals Guide to Internal Communication

Rules of thumb, and general philosophy Below you’ll find a collection of general principles we try to keep in mind at 37signals when communicating with teammates, within departments, across the company, and with the public. They aren’t requirements, but they serve to create boundaries and shared practices to draw upon when we do the one thing that affects everything else we do: communicate.

1. You can not not communicate. Not discussing the elephant in the room is communicating. Few things are as important to study, practice, and perfect as clear communication.

2. Real-time sometimes, asynchronous most of the time.

3. Internal communication based on long-form writing, rather than a verbal tradition of meetings, speaking, and chatting, leads to a welcomed reduction in meetings, video conferences, calls, or other real-time opportunities to interrupt and be interrupted.

4. Give meaningful discussions a meaningful amount of time to develop and unfold. Rushing to judgement, or demanding immediate responses, only serves to increase the odds of poor decision making.

5. Meetings are the last resort, not the first option.

6. Writing solidifies, chat dissolves. Substantial decisions start and end with an exchange of complete thoughts, not one-line-at-a-time jousts. If it’s important, critical, or fundamental, write it up, don’t chat it down.

7. Speaking only helps who’s in the room, writing helps everyone. This includes people who couldn’t make it, or future employees who join years from now.

8. If your words can be perceived in different ways, they’ll be understood in the way which does the most harm.

9. Never expect or require someone to get back to you immediately unless it’s a true emergency. The expectation of immediate response is toxic.

10. If you have to repeat yourself, you weren’t clear enough the first time. However, if you’re talking about something brand new, you may have to repeat yourself for years before you’re heard. Pick your repeats wisely.

11. Poor communication creates more work.

12. Companies don’t have communication problems, they have miscommunication problems. The smaller the company, group, or team, the fewer opportunities for miscommunication.

13. Five people in a room for an hour isn’t a one hour meeting, it’s a five hour meeting. Be mindful of the tradeoffs.

14. Be proactive about “wait, what?” questions by providing factual context and spatial context. Factual are the things people also need to know. Spatial is where the communication happens (for example, if it’s about a specific to-do, discuss it right under the to-do, not somewhere else).

15. Communication shouldn’t require schedule synchronization. Calendars have nothing to do with communication. Writing, rather than speaking or meeting, is independent of schedule and far more direct.

16. “Now” is often the wrong time to say what just popped into your head. It’s better to let it filter it through the sieve of time. What’s left is the part worth saying.

17. Ask yourself if others will feel compelled to rush their response if you rush your approach.

18. The end of the day has a way of convincing you what you’ve done is good, but the next morning has a way of telling you the truth. If you aren’t sure, sleep on it before saying it.

19. If you want an answer, you have to ask a question. People typically have a lot to say, but they’ll volunteer little. Automatic questions on a regular schedule help people practice sharing, writing, and communicating.

20. Occasionally pick random words, sentences, or paragraphs and hit delete. Did it matter?

21. Urgency is overrated, ASAP is poison.

22. If something’s going to be difficult to hear or share, invite questions at the end. Ending without the invitation will lead to public silence but private conjecture. This is where rumors breed.

23. Where you put something, and what you call it, matters. When titling something, lead with the most important information. Keep in mind that many technical systems truncate long text or titles.

24. Write at the right time. Sharing something at 5pm may keep someone at work longer. You may have some spare time on a Sunday afternoon to write something, but putting it out there on Sunday may pull people back into work on the weekends. Early Monday morning communication may be buried by other things. There may not be a perfect time, but there’s certainly a wrong time. Keep that in mind when you hit send.

25. Great news delivered on the heels of bad news makes both bits worse. The bad news feels like it’s being buried, the good news feels like it’s being injected to change the mood. Be honest with each by giving them adequate space.

26. Time is on your side, rushing makes conversations worse.

27. Communication is lossy, especially verbal communication. Every hearsay hop adds static and chips at fidelity. Whenever possible, communicate directly with those you’re addressing rather than passing the message through intermediaries.

28. Ask if things are clear. Ask what you left out. Ask if there was anything someone was expecting that you didn’t cover. Address the gaps before they widen with time.

29. Consider where you put things. The right communication in the wrong place might as well not exist at all. When someone relies on search to find something it’s often because it wasn’t where they expected something to be.

30. Communication often interrupts, so good communication is often about saying the right thing at the right time in the right way with the fewest side effects.


                
                        
                            Mastering Online Communication: A Comprehensive Guide
                         
 
                        Does this Guide help you to improve your online communication skills?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					Not sure what that even means
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)
			
          
            
            
            
            
            
            
            
            
            
        
                        
                        


 

### HEROES: Nền tảng săn tiền thưởng tất cả trong một thuần Web3

HEROES được xây dựng với mục tiêu tạo ra sự khác biệt trong một nền kinh tế chia sẻ hiện tại đã có phần lỗi thời bằng cách tạo điều kiện kết nối, cộng tác thông qua các giải pháp ứng dụng công nghệ Web3.
Tại sao chúng tôi xây dựng HEROES?
Nhiều bạn có thể nghĩ thế này “Ôi lại một nền tảng kiếm thưởng nữa à!”. Theo chúng tôi thì nếu như nó giải quyết được những điểm hạn chế của các nền tảng trước đó thì tại sao lại không?

Khi mà thế giới Web3 không ngừng mở rộng phạm vi ảnh hưởng thì nhu cầu có một nền tảng giúp điều phối công việc một cách hiệu quả và phi tập trung trở nên ngày càng cần thiết hơn. HEROES hướng tới giải pháp toàn diện, thay đổi cách mọi người cùng cộng tác, sáng tạo và tham gia vào các nhiệm vụ một cách phi tập trung, đáp ứng nhu cầu của cả dự án cũng như các nhà cung cấp dịch vụ.



Bạn có thể đọc thêm nghiên cứu chi tiết của chúng tôi về các nền tảng săn tiền thưởng tại đây.




	

	
	
		
			
				Mục tiêu chính của HEROES trong nền kinh tế chia sẻ là gì?
			
		

		
					

		
			
			
			
			Cung cấp nền tảng tìm kiếm việc làm truyền thống
		
			
			Tạo điều kiện kết nối, cộng tác và làm việc thông qua nền tảng công nghệ Web3
		
			
			Hoạt động như một sàn giao dịch tiền mã hoá
		
			
			Cung cấp các khóa học trực tuyến về công nghệ chuỗi khối
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Điều phối công việc phi tập trung là một lĩnh vực đang phát triển, đặc biệt là trong thế giới Web3 với ngày càng nhiều các dự án (thường có quy mô nhỏ), cung cấp phần thưởng cho các nhiệm vụ như sửa lỗi, nghiên cứu hay tiếp thị. Tuy nhiên, các nền tảng hiện tại trong lĩnh vực này có còn tồn đọng nhiều nhược điểm. Các nền tảng điều phối công việc truyền thống hiện nay thiếu tính minh bạch và độ tin cậy cùng nhiều các bên trung gian gây tăng độ phức tạp và chi phí. Ngoài ra, các nền tảng này có thể dễ dàng bị những bên có thẩm quyền thao túng, kiểm duyệt và không thân thiện với người dùng.

Trước những hạn chế kể trên, nhu cầu có một nền tảng linh hoạt như HEROES trở nên ngày càng cấp thiết. HEROES tìm cách giải quyết những nhược điểm này bằng cách tạo ra một hệ sinh thái nơi người tìm việc và các nhà cung cấp có thể cộng tác hiệu quả mà không cần thông qua trung gian, từ đó thúc đẩy một môi trường có độ tin cậy và hiệu quả cao.




	

	
	
		
			
				 Điều gì khiến HEROES khác biệt với các nền tảng việc làm truyền thống?
Vận hành trên một hệ thống tập trung
			
		

		
					

		
			
			
			
			Vận hành trên một hệ thống tập trung
		
			
			Sự minh bạch kém và độ tin cậy thấp
		
			
			Loại bỏ các bên trung gian, mang tới một môi trường tin cậy và hiệu quả
		
			
			Tập trung vào việc phát triển các nhiệm vụ
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Đối tượng người sử dụng của HEROES
HEROES là một nền tảng đa mục đích.

Nhiều người đang cố gắng tìm kiếm cho mình một ngách phát triển phù hợp, trong khi tiềm năng của thị trường việc làm và tiền thưởng là không giới hạn. HEROES là nền tảng nơi mọi người tìm tới khi họ muốn hoàn thành một công việc gì đó và được trả tiền, và nó bao gồm tất cả các loại nhiệm vụ tùy thuộc vào cung và cầu.
Funder - Bên tài trợ
Nếu bạn là chủ dự án, người tổ chức hackathon, nhà tiếp thị hay quản lý cộng đồng hay là công ty khởi nghiệp, DAO hay bất kỳ tổ chức nào khác trong không gian blockchain và Web3, thì HEROES là nền tảng tuyệt vời để một nhà tài trợ như bạn có thể dễ dàng tìm kiếm những chuyên gia lành nghề.

Từ hackathon, phát triển phần mềm, audit, kiểm thử mã nguồn, nghiên cứu hay là sáng tạo nội dung, tiếp thị, thiết kế, các nhà tài trợ có thể hoàn thành mục tiêu của mình một cách dễ dàng thông qua quy trình đơn giản và hiệu quả của HEROES.



Ví dụ: Bạn là nhà sáng lập của một dự án DeFi và bạn muốn có một số nội dung để đăng lên mạng xã hội, nhưng bạn lại không có thời gian để làm điều đó.

 	Hãy truy cập HEROES, thiết lập nhiệm vụ có thưởng trong chưa đầy 2 phút.
 	Bạn có thể bật chức năng KYC nếu muốn đảm bảo nhiệm vụ của mình được thực hiện bởi các cá nhân hợp pháp.
 	Các thợ săn tiền thưởng (Hunters) trên HEROES sẽ gửi đơn đăng ký của họ và bạn có thể chọn người mà bạn muốn hợp tác.
 	Người bạn chọn để hợp tác nộp kết quả công việc của họ, bạn sẽ cần giải ngân phần tiền thưởng một khi cảm thấy hài lòng.
 	Nếu bạn muốn có hóa đơn cho khoản thanh toán của mình, HEROES cũng sẽ tự động tạo hóa đơn cho bạn!




	

	
	
		
			
				Những loại nhiệm vụ nào có thể được quản lý thông qua HEROES?
			
		

		
					

		
			
			
			
			Chỉ những nhiệm vụ liên quan tới phát triển chuỗi khối
		
			
			Đa dạng lĩnh vực bao gồm hackathon, phát triển phần mềm, sáng tạo nội dung, …

		
			
			Các giao dịch tài chính đơn thuần
		
			
			Chỉ những dự án thiết kế website
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hunter - Bên săn tiền thưởng
HEROES mang tới trải nghiệm liền mạch giúp dễ dàng khám phá và tham gia vào các nhiệm vụ phù hợp với kỹ năng và sở thích của bạn.

Dù bạn là nhà phát triển, nhà thiết kế, người kiểm thử phần mềm, người sáng tạo nội dung hay người làm việc tự do, bạn đều có thể tìm được những nhiệm vụ phù hợp với mình trên HEROES.


Những điểm khác biệt của HEROES



	

	
	
		
			
				HEROES đơn giản hóa quy trình tuân thủ pháp lý và giao dịch tài chính như thế nào?
			
		

		
					

		
			
			
			
			Cung cấp tính năng tạo hoá đơn tự động
		
			
			Cung cấp những tư vấn về pháp luật miễn phí
		
			
			Bỏ qua việc tuân thủ pháp luật
		
			
			Tự động hóa quy trình kê khai thuế
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Những tính năng nào của HEROES khiến nó trở nên khác biệt với các nền tảng khác?

Ngoài tính phi tập trung và được xây dựng trên blockchain, HEROES còn cung cấp một loạt các quy trình tự động giúp bạn dễ dàng sử dụng:

 	KYC: HEROES có quy trình KYC tích hợp mà bạn có thể bật/tắt bất cứ khi nào bạn muốn trong khi tạo nhiệm vụ có thưởng. Điều này đảm bảo rằng chỉ những cá nhân được xác minh và hợp pháp mới có thể tham gia làm nhiệm vụ, mang tới sự an tâm cho nhà tài trợ và nâng cao tính toàn vẹn của hoạt động.
 	Whitelist - Danh sách ưu tiên: Cho phép người sáng tạo tùy chỉnh linh hoạt phần thưởng của mình. Các nhà tài trợ có thể tạo nhiều danh sách ưu tiên cho các ví #NEAR trên nền tảng và có thể áp dụng một danh sách ưu tiên cho các nhiệm vụ có thưởng, chỉ có các ví trong danh sách này mới có thể nhận phần thưởng sau khi hoàn thành nhiệm vụ.
 	Reviewer - Người đánh giá: Cho phép nhà tài trợ thêm reviewer vào đội ngũ quản lý nhiệm vụ, những người này sẽ có quyền phê duyệt và chấp nhận người nộp đơn đăng ký, giúp tăng sự linh hoạt và mức độ phối hợp nhóm trên các nhiệm vụ của HEROES.
 	Auto-Generated Invoice - Xuất hóa đơn tự động: Hiện tại có nhiều thách thức đặc biệt trong việc thực hiện các giao dịch tài chính trong môi trường Web3, đặc biệt là khi liên quan đến việc tuân thủ pháp lý. HEROES giải quyết điểm yếu này một cách hiệu quả. Các bên tài trợ có tùy chọn yêu cầu HEROES xuất hóa đơn tự động, bao gồm tất cả các chi tiết pháp lý cần thiết. Tính năng này hợp lý hóa quy trình, đảm bảo việc quản lý tài chính suôn sẻ và tuân thủ luật pháp.
 	Multiple payout - Thanh toán nhiều lần: HEROES cho phép các nhà tài trợ thanh toán cho nhiều người tham gia nhiều lần trong một nhiệm vụ duy nhất. Tính năng này mở rộng đáng kể phạm vi của các nhiệm vụ có thưởng hiện nay, vượt xa giới hạn truyền thống của nhiệm vụ chỉ có một bên nhận thưởng, cho phép tiếp cận linh hoạt và toàn diện hơn để phân bổ tiền thưởng, đáp ứng nhiều nhu cầu khác nhau của các dự án!

HEROES hiểu tầm quan trọng của nền tảng phần thưởng và làm việc trực tuyến là phải đảm bảo trải nghiệm người dùng liền mạch, trực quan, thân thiện. Nền kinh tế chia sẻ rất lớn và không phải ai cũng có khả năng hiểu hay sử dụng Web3.

Chúng tôi đang cố gắng hết sức để tìm kiếm giải pháp tốt nhất mà người dùng phổ thông có thể dễ dàng sử dụng trong thế giới của Web3!




	

	
	
		
			
				HEROES tập trung vào điều gì để thu hút người dùng từ nền kinh tế chia sẻ?
			
		

		
					

		
			
			
			
			Tạo ra một giao diện Web3 phức tạp
		
			
			Cung cấp một trải nghiệm người dùng liền mạch, trực quan và thân thiện
		
			
			Cung cấp những tư vấn về tài chính
		
			
			Bán phần cứng phục vụ cho Web3
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tìm hiểu thêm về HEROES
Truy cập và trải nghiệm ngay tại đây: https://heroes.build/

Bạn cũng có thể tìm hiểu thêm về dự án thông qua tài liệu chính thức của chúng tôi

 

### NEAT inscription on NEAR  launch onchain analysis



### Talentum - web3 talentsourcing platform

Talentum is what you get when you mix the best of the old school with the new: think SAP meets Upwork, but we're talking full-on Web3 style. It's where the sharp minds meet the cutting-edge enterprises. Here, you can build your crew of top-notch talents for the long game while running your ambassador gigs, boosting your community's strength, and keeping an eagle eye on all your social plays with the kind of smoothness you won't find anywhere else.




	

	
	
		
			
				Is it true that Talentum is a quest platform?
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Talentum prioritizes authenticity, inventive thinking, and active participation. We aim to assist projects in identifying valuable contributors, while excluding abusers and "social noisers". Talentum offers a unique platform where you can significantly contribute to projects you are passionate about and earn rightful rewards. Unlike other platforms, you are more than just a bounty hunter here; you're a talent building a reputation, with the potential to become a team member in the future.

Talentum combines HR tools and freelance features. Thus, your profile serves as your CV, showcasing your previous achievements, education, and portfolio.

In addition to payroll and on-chain tasks, Talentum includes a CRM for managing ambassador programs, payroll, talent filters, and directions.

Here is a brief onboarding guide:

1. Create your Talent account with your NEAR wallet or using any other suitable way for you.



2. Set up your profile by adding your data like social media profiles, your directions and bio.






	

	
	
		
			
				A well-filled profile increases your chances of becoming an ambassador for a good project.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






3. Participate in any open ambassador program and earn points.






	

	
	
		
			
				Which directions are NOT available on Talentum?
			
		

		
					

		
			Please select 3 correct answers
			
			
			Social Influencer
		
			
			Loader
		
			
			Designer
		
			
			Locksmith
		
			
			Developer
		
			
			Pilot
		
	
		

		
		
			
				Correct!
				Wrong!

### HEROES: An All-in-one Web3 Native Bounty Marketplace

HEROES aims to make a difference in the current outdated gig economy by facilitating connection, collaboration and work through novel solutions & leveraging the web3 tech stack.
Why?
You might be thinking: “Another bounty marketplace?” But why not, especially if it addresses the dry spots of the current offerings.

As the Web3 frontier continues to expand, the need for efficient and trustless work coordination platforms becomes paramount. HEROES steps forward as a comprehensive solution, transforming the way we collaborate, create, and engage in decentralized tasks, catering to the needs of both the projects and service providers.



Our detailed research on bounty platforms can be found here




	

	
	
		
			
				What is the primary goal of HEROES in the gig economy?
			
		

		
					

		
			
			
			
			To provide a platform for traditional job listings
		
			
			To facilitate connection, collaboration, and work using web3 technology
		
			
			To serve as a digital currency exchange
		
			
			To offer online courses on blockchain technology
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Decentralised work coordination is a growing industry, especially within Web3 with more and more projects, often small-sized, offering bounties for tasks such as bug fixing, research, and marketing. However, the existing platforms are not without their flaws. Traditional work coordination platforms often lack transparency and trust, with intermediaries adding complexity and costs. Additionally, they can be centralized, censored, and not very user-friendly.

In light of these limitations, the need for a versatile platform like HEROES has become imperative. HEROES seeks to address these shortcomings by creating an ecosystem where job seekers and providers can collaborate efficiently without intermediaries, thus fostering an environment of trust and efficiency.




	

	
	
		
			
				What makes HEROES different from traditional work coordination platforms?
			
		

		
					

		
			
			
			
			It operates on a centralized system
		
			
			It offers less transparency and trust
		
			
			It eliminates intermediaries, fostering a trustful and efficient environment
		
			
			It focuses only on development tasks
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Who?
HEROES is a multi-purpose platform.

Others are trying to find a niche for themselves, while the potential of a bounties marketplace has no limit. HEROES is a platform where people go when they want to get something done/ work on something and get paid, and this can range from all kinds of tasks depending on supply and demand.
Funder
Whether you are a Project Owner, a Hackathon Organiser, a Marketer, or a Community Manager from a Project, Startup, DAO, or any other organisation in the blockchain and web3 space, HEROES empowers funders to efficiently execute and elevate their operations with skilled expertise.

Ranging from hackathon, development, audit, testing, research to content, marketing, design, funders can seamlessly accomplish their objectives through HEROES' straightforward and efficient process.



Example: You are a DeFi founder and you want to have some content to post on socials, but you don’t have the time to do it.

 	You simply go to HEROES, set up a bounty in 2 minutes.
 	You can turn on KYC if you want to make sure your task is getting done by legit people
 	Hunters on HEROES will submit their application & you can choose which hunter you want to work with.
 	Hunter submit their work, you only release the funds once you’re satisfied.
 	If you want to have an invoice for the payout, HEROES also automatically generates it for you!




	

	
	
		
			
				What kind of tasks can be managed through HEROES?
			
		

		
					

		
			
			
			
			Only blockchain development tasks
		
			
			A wide range including hackathons, development, content creation, and more
		
			
			Solely financial transactions
		
			
			Only web design projects
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hunter
HEROES offers a seamless experience for hunters to discover and participate in bounties aligned with your skills and interests.

Whether you are developers, designers, testers, content creators or freelancers, you will find your place on HEROES


Which?



	

	
	
		
			
				How does HEROES simplify the process of legal compliance and financial transactions?
			
		

		
					

		
			
			
			
			By providing an automatic invoice generation feature
		
			
			By offering free legal advice
		
			
			By ignoring legal compliance
		
			
			By automating the tax filing process
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Which features of HEROES make it different from others?

Other than decentralized and built on a blockchain(s), HEROES offers a suit of automated processes that make your life easier.

 	KYC: HEROES has a built-in KYC process that you can enable/disable whenever you want while creating bounties. This ensures that only verified and legitimate individuals engage with the bounty, providing peace of mind and enhancing the integrity of the operations.
 	Whitelist: Allows creators to flexibly customize their bounties. Funders on HEROES can create multiple #NEAR wallet whitelists on the platform and can apply one whitelist to a bounty, making the bounty only claimable by the whitelisted wallets.
 	Reviewer: Allows creators to add teammates to their bounty & these teammates will have the power to act on a bounty's applicant, i.e. approving & accepting applicants. This enables extreme flexibility & team coordination.
 	Auto-Generated Invoices: Understanding the complexities of financial transactions in the evolving web3 landscape, especially in terms of legal compliance, can be challenging. HEROES addresses this pain point effectively. Funders have the option to request HEROES to generate an automatic invoice, equipped with all the necessary legal details. This feature streamlines the process, ensuring smooth and compliant financial management in the web3 realm.
 	Multiple payout: HEROES is all about flexibility and possibility. The platform enables funders to issue payments to multiple participants multiple times within a single bounty. This feature significantly broadens the scope of bounties available, moving beyond the traditional limitation of one hunter per bounty. It allows for a more dynamic and inclusive approach to bounty allocation, catering to a variety of project needs!

As the nature of a bounty marketplace / gig platform, HEROES understands the importance of seamless, intuitive and friendly user experience; given the gig economy is huge and not everyone is capable of understanding/navigating web3 in its current state. We are doing our best in looking for the best solution that web2 users can be easily onboarded to web3!




	

	
	
		
			
				What is a major focus of HEROES to attract users from the gig economy?
			
		

		
					

		
			
			
			
			Creating complex web3 interfaces
		
			
			Providing a seamless, intuitive, and user-friendly experience
		
			
			Offering financial investment advice
		
			
			Selling web3 hardware
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How?
Want to get started with HEROES? Try now at: https://heroes.build/!

Check out our documentation & learn more!

 

### Hiểu về Giao thức NEAR: Tạo Smart Contract của riêng bạn với TypeScript và thư viện near-sdk-js

Giới thiệu: Các hợp đồng thông minh được cung cấp bởi Giao thức NEAR đang ở hàng đầu trong phát triển ứng dụng phi tập trung. Trong bài viết này, chúng ta sẽ tìm hiểu về TypeScript và near-sdk-js : error handing, batch transactions, cross-contract calls, promises, and more. Ngoài ra, chúng tôi sẽ thảo luận về chiến lược kiểm thử, xem xét các yếu tố triển khai và đề cập đến một lộ trình cho những cải tiến trong tương lai.
Phần 1: Hiểu về Hợp đồng Thông minh và Giao thức NEAR:
Hợp đồng thông minh là các hợp đồng tự thực hiện với các điều khoản của thỏa thuận được viết trực tiếp vào code. Giao thức NEAR cung cấp một môi trường có khả năng mở rộng và thân thiện với nhà phát triển để xây dựng ứng dụng phi tập trung (DApps). Những ưu điểm của nền tảng bao gồm khả năng mở rộng, chi phí giao dịch thấp và một hệ sinh thái phát triển mạnh mẽ.
Phần 2: TypeScript và Vai trò của Nó trong Phát triển Hợp đồng Thông minh:
TypeScript là một ngôn ngữ lập trình được phát triển bởi Microsoft. Nó là một tập hợp siêu cú pháp nghiêm ngặt của Javascript và thêm các tính năng kiểu tĩnh tùy chọn vào ngôn ngữ. Typescript cải thiện việc đọc và bảo trì code, khiến nó trở thành lựa chọn xuất sắc cho việc phát triển hợp đồng thông minh. Typescript giúp nhà phát triển phát hiện lỗi tiềm ẩn sớm trogn chu kỳ phát triển. Hơn hết typescript còn được support bở near với một thư viện riêng (near-sdk-js)
Phần 3: Thiết lập Môi trường Phát triển:
Thiết lập môi trường phát triển cho Giao thức NEAR liên quan đến việc cài đặt các phụ thuộc cần thiết như Node.js và NEAR CLI. Những công cụ này hỗ trợ biên dịch và triển khai hợp đồng thông minh.
Phần 4: Viết Một Hợp đồng Thông minh Đơn giản với TypeScript:
Tôi sẽ giới thiệu về first smart contract , tôi tạo một trò chơi LuckyNumber, cho phép người dùng tham gia, đoán số may mắn và nhận giải thưởng. Hợp đồng bao gồm các tính năng như đăng ký người dùng, tạo số ngẫu nhiên và mua vé cho các trò chơi khác nhau. Hợp đồng này được tạo dựa trên https://github.com/near-examples/cross-contract-hello-js. Tôi nghĩ cách tốt nhất để học là bằng cách mô phỏng. Tôi đã đọc và sao chép nhiều hợp đồng thông minh từ https://github.com/near-examples. Điều này giúp tôi học và hiểu nhanh hơn so với việc chỉ đọc lý thuyết. Dưới đây là một số đoạn code về hợp đồng đầu tiên của tôi: LuckyNumber




Phần 5: Triển khai và Kiểm thử Hợp đồng Thông minh:
Việc triển khai hợp đồng thông minh trên Giao thức NEAR là một quá trình mượt mà. Tôi nhấn mạnh sự quan trọng của việc kiểm thử bằng các công cụ như Jest để đảm bảo tính chính xác của mã. Kiểm thử hợp đồng thông minh liên quan đến xác minh chức năng của từng thành phần và xử lý các trường hợp.
Phần 6: Phát triển Hợp đồng Thông minh Nâng cao với TypeScript:
Sau khi hiểu rõ cách nó hoạt động, tôi đã tạo một hợp đồng thông minh dựa trên ý tưởng của mình rằng mọi người có thể đặt câu hỏi và trả lời, điều đặc biệt là nó có hệ thống thưởng để khuyến khích mọi người. Đây là cấu trúc của hợp đồng:



For details about my code, you can access my github: https://github.com/hardAndHarder/AnswerIncentiveExchange
6.1 Xử lý Lỗi và Câu lệnh Assert:
Hợp đồng thông minh cần có xử lý lỗi mạnh mẽ. Các câu lệnh assert trong hợp đồng của chúng tôi đảm bảo rằng các điều kiện được đáp ứng, bảo vệ khỏi các hành vi không mong muốn. Ví dụ, chúng tôi sử dụng assert để kiểm tra số dư tài khoản trước khi thực hiện một số chức năng cụ thể cùng với một số kỹ thuật xử lý mới.
6.2 Batch Transactions:
Batch transactions sử dụng để tối ưu hóa chi phí gas và giảm số lần đọc/viết. Trong hợp đồng của tôi, tôi sử dụng batch transactions để tập hượp nhiều hành động (actions) lại, tăng cường hiệu suất và giảm chi phí giao dịch.
6.3 Cross-Contract Calls:
Contract của tôi sử dụng cross-contract call. Đây là một kỹ thuật tương tác với các hợp đồng khác, tiếp cận và tái sử dụng lại code, điều này giúp dự án clean hơn và tiết kiệm thời gian code. Điều này thúc đẩy một hệ sinh thái hợp đồng thông minh tương tác giữa nhau và có khả năng mở rộng.
6.4 Promises and Callbacks:
Promises and callbacks là để xử lý các hoạt động không đồng bộ. Trong hợp đồng của tôi, tôi sử dụng promises cho batch transactions and callbacks to quán lý tương tác bên ngoài. Những tính năng này cả thiện kahr năng đáp ứng và tương tác của hợp đồng.
6.5 Access Control:
Kiểm soát truy cập là quan trọng cho việc bảo mật. Tôi triển khai các cơ chế để kiểm soát truy cập, đảm bảo rằng các chức năng cụ thể bị hạn chế đối với các tài khaorn được ủy quyền. Điều này thêm một lớp bảo vệ cần thiết cho hợp đồng thông minh
Section 7: Testing and Deployment Strategies:
7.1 Testing Smart Contracts:
To ensure the reliability of our contracts, we employ rigorous testing. Leveraging testing frameworks and methodologies, we verify the correctness of our code. Comprehensive testing is indispensable for the development lifecycle.
7.2 Deployment Considerations:
Triển khai hợp đồng thông minh liên quan đến các yếu tố như phí gas và thời gian triển khai. Chia sẻ thông tin từ quá trình triển khai của chúng tôi, chúng tôi thảo luận về những thách thức đã đối mặt và cung cấp mẹo để triển khai mượt mà trên Giao thức NEAR.
Section 8: Future Improvements and Roadmap:
Khi hợp đồng thông minh của tôi phát triển, chúng tôi tưởng tượng về những cải tiến trong tương lai. Lộ trình của chúng tôi bao gồm việc cải thiện trải nghiệm người dùng, triển khai các tính năng bổ sung và đóng góp vào cộng đồng ngày càng phát triển của Giao thức NEAR. Hãy chờ đợi những cập nhật và tiến triển thú vị.
Conclusion:
Trong việc làm chủ phát triển hợp đồng thông minh của Giao thức NEAR, TypeScript và near-sdk-js chứng minh là những công cụ hữu ích. Thông qua error handling, batch transactions, cross-contract calls, and other advanced features, nó đã thể hiện tính linh hoạt của hợp đồng thông minh trên Near. Trong quá trình khám phá near và smart contract hãy lên chiến lược testing và xem xét các yếu tố triển khai cũng như phát triển dự án, hãy nhớ rằng hành trình mới chỉ bắt đầu.
Resources and Further Learning:

 	NEAR Protocol Documentation
 	NEAR Community Forums
 	NEAR SDK for JavaScript

 

### Understanding NEAR Protocol: Create your own Smart Contract Development with TypeScript and near-sdk-js

Introduction 
Smart contracts powered by NEAR Protocol are at the forefront of decentralized application development. In this article, we delve into the advanced features of TypeScript and near-sdk-js, exploring error handling, batch transactions, cross-contract calls, promises, and more. Additionally, we'll discuss testing strategies, deployment considerations, and outline a roadmap for future improvements.
Section 1: Understanding Smart Contracts and NEAR Protocol:
Smart contracts are self-executing contracts with the terms of the agreement directly written into code. NEAR Protocol provides a scalable and developer-friendly environment for building decentralized applications (DApps). The platform's advantages include scalability, low transaction costs, and a robust developer ecosystem.
Section 2: TypeScript and its Role in Smart Contract Development:
TypeScript, a superset of JavaScript, brings static typing to the development process. Its benefits, such as enhanced code readability and maintainability, make it an excellent choice for smart contract development. TypeScript empowers developers to catch potential errors early in the development cycle.
Section 3: Setting Up the Development Environment:
Setting up a development environment for NEAR Protocol involves installing necessary dependencies like Node.js and the NEAR CLI. These tools facilitate the compilation and deployment of smart contracts.
Section 4: Writing a Simple Smart Contract with TypeScript:
In our introductory contract, we create a Lucky Number game, allowing users to participate, guess LuckyNumbernumbers, and win prizes. The contract includes features such as user registration, generating random numbers, and purchasing tickets for different games. This contract is created base on https://github.com/near-examples/cross-contract-hello-js . I think the best way to learn something is The best way to learn something is by imitation. I have read and reproduced many smart contracts from https://github.com/near-examples. That helps me learn and understand faster than just reading theory. Here is some captures about my first contract code: LuckyNumber




Section 5: Deploying and Testing the Smart Contract:
Deployment of smart contracts on NEAR Protocol is seamless. We highlight the importance of testing using tools like Jest to ensure the correctness of the code. Smart contract testing involves verifying the functionality of each component and handling edge cases.
Section 6: Advanced Smart Contract Development with TypeScript:
After understanding how it works clearly, I created a smart contract based on my idea that people can ask and answer, the special thing is that it has a reward system to encourage everyone. This is my contract structure:



For details about my code, you can access my github: https://github.com/hardAndHarder/AnswerIncentiveExchange
6.1 Error Handling and Assert Statements:
Smart contracts need robust error handling. The assert statements in my contracts ensure that conditions are met, safeguarding against unexpected behaviors. For instance, we use assert to check account balances before executing certain functions along with some new processing techniques. This is contract structure:
6.2 Batch Transactions:
Batch transactions optimize gas costs and reduce storage reads/writes. In my contracts, we utilize batch transactions to bundle multiple actions, enhancing efficiency and reducing transaction costs.
6.3 Cross-Contract Calls:
My contracts showcase the power of cross-contract calls. By interacting with other contracts, we demonstrate a modular approach and code reuse. This fosters a collaborative and scalable smart contract ecosystem.
6.4 Promises and Callbacks:
Promises and callbacks are fundamental to handling asynchronous operations. In my contracts, we utilize promises for batch transactions and callbacks to manage external interactions. These features enhance the contract's responsiveness and interoperability.
6.5 Access Control:
Access control is crucial for security. We implement mechanisms to control access, ensuring that specific functions are restricted to authorized accounts. This adds an essential layer of protection to my smart contracts.
Section 7: Testing and Deployment Strategies:
7.1 Testing Smart Contracts:
To ensure the reliability of my contracts, we employ rigorous testing. Leveraging testing frameworks and methodologies, we verify the correctness of our code. Comprehensive testing is indispensable for the development lifecycle.
7.2 Deployment Considerations:
Deploying smart contracts involves considerations such as gas fees and deployment time. Sharing insights from our deployment process, we discuss challenges faced and provide tips for a seamless deployment on the NEAR Protocol.
Section 8: Future Improvements and Roadmap:
As my smart contracts evolve, we envision future improvements. Our roadmap includes enhancing user experiences, implementing additional features, and contributing to the growing NEAR community. Stay tuned for exciting updates and advancements.
Conclusion:
In mastering NEAR Protocol smart contract development, TypeScript and near-sdk-js prove to be formidable tools. Through error handling, batch transactions, cross-contract calls, and other advanced features, we've demonstrated the versatility of smart contracts on NEAR. As you explore the provided code, embrace testing strategies, and navigate deployment considerations, remember that the journey doesn't end here. The NEAR community welcomes your contributions and encourages the continual evolution of decentralized applications.
Resources and Further Learning:

 	NEAR Protocol Documentation
 	NEAR Community Forums
 	NEAR SDK for JavaScript

 

### Getting Started with NEAR Mobile

Introduction
Welcome to NEAR Mobile, your gateway to the NEAR Blockchain! Whether you're new to crypto or a seasoned enthusiast, this guide will walk you through the essential features of NEAR Mobile, from creating your wallet to interacting with decentralized applications (dApps).
Create a Wallet
NEAR Mobile is a non-custodial crypto wallet for the NEAR Blockchain. To get started, open the app and choose "Create wallet."

Read through the onboarding slides, swipe left twice, and tap on "Generate mnemonic."

Write down your unique secret recovery phrase – this is crucial for accessing your crypto.

Select the words in the same order to confirm and set your PIN.

Congratulations! You've successfully created your NEAR account.




	

	
	
		
			
				How can you import a second account in NEAR Mobile?
			
		

		
					

		
			
			
			
			Tap on "Create wallet"
		
			
			Go to the Wallet tab, swipe left, and tap on "Create your account"
		
			
			Import with private key
		
			
			Tap on "Import your NEAR wallet" and enter the mnemonic"
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Import Your NEAR Wallet
To import your existing NEAR wallet, tap on "Import your NEAR wallet." Enter your mnemonic (12-word recovery phrase) with a space between each word. Set your PIN, and you've successfully imported your NEAR wallet.

For a second account, go to the Wallet tab, swipe left, and tap on "Create your account." Choose "Import with mnemonic," type or paste your phrase, and tap "Import wallet."

You can also import using your private key. Select "Import with private key," enter your key, and you're done.
Staking NEAR
Earning rewards with NEAR is easy. Go to the Staking tab, tap on "Stake my tokens," enter the amount, choose a validator, and confirm the transaction. For unstaking, go to the Staking tab, tap on "Unstake," select a validator, enter the amount, and confirm.




	

	
	
		
			
				How can you unstake your NEAR tokens in NEAR Mobile?
			
		

		
					

		
			
			
			
			Go to the Buy tab
		
			
			Tap on "Stake my tokens"
		
			
			Select a validator and confirm
		
			
			Go to the Staking tab, tap on "Unstake," and confirm
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How to Buy NEAR
NEAR Mobile allows you to buy NEAR easily. Go to the Wallet tab, tap on "Buy," and follow the Transak buying page instructions. Enter the amount, select payment method, review, and tap "Buy NEAR."

For detailed instructions on using Transak, visit our guide. Log in or create an account, review details, confirm, and finish the transaction using your chosen payment method.
NEAR Mobile with Signer App
Introducing the new version with the Signer app! Buy, store, send, stake, and explore NFTs seamlessly with NEAR Mobile.

Explore Web3 with our all-new Signer App with near/wallet-selector. Interact with dApps, discover NEAR Blockchain Operating System, and explore the world of decentralized finance. NEAR Mobile – Self-custody, Multi-wallet, Secure, and easy to use.
Connect with dApps
Navigate to the new dApp section, tap on your chosen dApp, and click "Connect wallet." Follow the prompts and select NEAR Mobile.

Tap "Sign transaction" or scan the QR code in NEAR Mobile's "Review request" page. Review details and slide to accept.

Review or revoke connections in the dApps tab. Swipe left to disconnect. In settings, revoke access to dApps not listed.




	

	
	
		
			
				In NEAR Mobile, you can connect your wallet to dApps by scanning a QR code or tapping on "Sign transaction" button.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





dApps Page
On the dApps page, check the connection status next to each DApp. Disconnect by swiping and confirming.

Visit a DApp by tapping its name. Enjoy seamless interactions with NEAR Mobile.

Congratulations! You've mastered the basics of NEAR Mobile. For more information, explore our guide and FAQ pages. Happy exploring the NEAR ecosystem!

 

 

### nStamp Redeem with Here wallet accounts

"*" indicates required fields
                         
 
                        Email
                            
                        Fill it if you want to receive submission confirmation via email NEAR account* Named NEAR account you created at HERE wallet  for FREE, not your main one!Which country are you from?* *Submit with nStamp Mandatory!
Please put a checkmark to be able to submit!
                        
                            nCaptcha Transaction

### Meta Pool, Module 5 - Meta Pool Improvement Proposals

MPIPs, or how to change the current protocol status
A Meta Pool Improvement Proposal (MPIP) is an initiative that describes a suggestion or change intended to improve some aspect of the protocol. These proposals can originate from community members, users, or developers.

Meta Pool Improvement Proposals promote a process for decision-making within the protocol, encouraging transparency, participation, and open discussion on the NEAR Blockchain Operating System (BOS).

Meta Pool aims for MPIPs to serve as the primary mechanism for proposing new features and changes to protocol parameters. The goal is to establish a highly participatory and transparent process for making complex decisions that affect the Meta Pool Protocol, emphasizing a more decentralized approach.
How does the voting mechanism on MPIPs work?
MPIPs follow a voting mechanism called Token-Based Quorum Voting.

Here are some pillars of this mechanism:

 	Voting Power: the foundation of this implementation of token-based quorum voting is the distribution of voting power based on the number of META tokens locked (amplified by the locking period used). Voting power holders are granted voting rights proportional to their holdings, which means those with more voting power have a greater say in decision making.
 	Proposal Submissions and Discussion: The first step in the voting process is the submission of proposals by any member of the community that reach the proposal thresholds - see Proposals Thresholds section. Before the proposals enter a voting process, there is usually a period for discussing and refining the proposals to ensure clarity and feasibility.
 	Voting Period and Votes Types: A specific voting period is defined during which voting power holders can cast their votes on the proposals. Voters are given the options to vote “For”, “Against” or “Abstain”.
 	Minimum Participation Quorum: To validate the voting outcome and prevent decisions from being made by a small minority, a minimum participation threshold, known as Quorum. See Quorum section.


Proposal Thresholds
Proposal thresholds are the criteria someone needs to meet in order to introduce a proposal that will be voted on. A proposer needs to hold a certain amount of voting power in order to introduce a proposal.

Besides the required voting power, the proposer should deposit a certain amount of $NEAR for storage.

The MPIPs thresholds are:

 	 200,000 Voting Power.
 	5 $NEAR deposit for storage.




	

	
	
		
			
				What is the primary goal of Meta Pool Improvement Proposals (MPIPs)?
			
		

		
					

		
			
			
			
			To generate revenue for the protocol.
		
			
			To promote transparency and open discussion within the NEAR Blockchain Operating System.
		
			
			To introduce new cryptocurrencies to the NEAR ecosystem.
		
			
			To create an inclusive framework for facilitating decision-making processes or modifying the Meta Pool Protocol.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Quorum management
A quorum is the minimum number of votes required for a governing body to approve a proposal. If a quorum is set at 50%, it means that 50% of all circulating tokens need to vote 'yes' for the proposal to pass.

In the MPIP context, a quorum is the minimum number or percentage of voting power required that must be cast in the voting process. If the Quorum is not met, the voting results may not be considered valid, and the proposal might be rejected.

There are 3 types of votes, for, abstain and against. The votes that count to exceed the quorum for a MPIP to be successful are:

 	The sum of the for and abstain votes must exceed the required quorum.
 	The votes of ‘for’ must be greater than ‘against’.
 	If these two premises are not fulfilled, the MPIP will be rejected.

E.g.: If the current circulating supply of voting power is 60,000 VP, and the MPIPs is set to 5% of the quorum floor, the voting power required to approve a proposal is 3,000 VP.




	

	
	
		
			
				Question: What is the voting mechanism used for MPIPs called?
			
		

		
					

		
			
			
			
			Quorum-Based Voting
		
			
			Token-Based Quorum Voting
		
			
			Majority Rules Voting
		
			
			Direct Democracy Voting
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How it works?
How to participate in the MPIPs?
In the MPIPs a member of the community can participate:

 	Creating a MPIPs.
 	Voting for MPIPs.
 	Both.

MPIP Process
The Proposal life cycle:

 	Draft - Authors submit a draft MPIP for community discussion, comments and polling (e.g.: Easy Poll). Community, dev team provides feedback on the MPIP. If the draft MPIP has gained sufficient traction during the review window the MPIP goes to the voting stage.
 	Canceled - If the proposal is not accepted, it will be canceled (only the Author or an Operator can cancel a MPIPs been in the Draft status).
 	In progress – Is the voting period. The proposal is open for voting. Note: All feedback in the form of comments in the draft stage and polls are dumped on-chain into the proposal before the proposal vote begins.
 	Succeeded - The proposal has reached the quorum floor and the amount of "For" votes is greater than "Against" vote.

Rejected - The proposal has reached the quorum floor and the amount of "For" votes is lower than "Against" vote. Or the proposal has not reached the minimum quorum floor.




	

	
	
		
			
				What is the current minimum participation threshold required for a proposal to be valid?
			
		

		
					

		
			
			
			
			5% of all voting power
		
			
			35% of all voting power
		
			
			60% of all circulating tokens
		
			
			75% of all circulating tokens
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Voting Power
MPIP participants have the ability to leverage their entire voting power in order to create proposals and cast votes. This implies that their voting power will be available even if it is being utilized on other voting processes within the DAO, such as Ambassador Initiatives voting, Launchpad voting or Validators voting.

Each voter has their entire voting power available at the moment to cast votes on proposals (MPIPs).

During each voting session, the community can use the total voting power they possess, allowing them to vote on multiple proposals if there are multiple active ones.
Creating a Meta Pool Initiative Proposal (MPIP)
1. Go to: MPIP app on near.org: https://near.org/meta-pool-official.near/widget/ImprovementProposals



Proposal metrics:

 	Current Quorum needed for the circulating supply. 
 	Proposal thresholds in Voting Power. Amount of voting power needed in order to introduce a proposal. The proposer needs only to hold this amount.
Please note that it is also required: the proposer should deposit a certain amount of $NEAR for storage.
The indicated Voting Power is the total voting power that the Proposer has available even if it is being used on other voting processes within the DAO. 
 	Voters / VP Holders: Number of voters and number of Voting Power holders.
 	All Proposals: Proposal list ordered by MPIP Id descending.

2. Connect your NEAR wallet by clicking the Sign In button or if you do not have an Account yet, create one by clicking the Create Account button.



3. Choose your preferred wallet.



Balance: Voting Power balance + NEAR balance. Once the wallet is connected, you can see, up to the right, the balance that the user has of Voting Power and NEAR associated with that wallet.



4. Click on “Create Proposal” button.



Important: In order to create an MPIP, the proposer should have enough voting power and a certain amount of NEAR (see Proposal Thresholds section).

5. A MPIP proposal consists of:

 	Proposer: a creator (or author) account.
 	Title. Required.
 	Short description: a one-line human readable description. Required.
 	Description: a body description containing technical specification of the feature or protocol parameters changes. Required.
 	Function Call Data: could contain call data encoding a function call that the contract will perform if the proposal passes.



6. Create Proposal: Once all the required information is completed and the proposer has the necessary Threshold (Voting Power and NEAR for storage), pressing the Create Proposal button generates the MPIP.

Important: once the necessary fields have been completed, the amount of NEAR required for storage appears under the create proposal button. Amount that will be requested when creating the proposal.



7. “Confirm” the transaction of the proposal and then "Approve" the transaction in your wallet.





8. Succeed you have created a MPIP.



9. Congratulations, your proposal is now on the proposal list with Draft status.
Proposal View
Once the MPIP has been submitted, clicking on the proposal in the dashboard/list opens a view of the selected proposal. This is the view that the proposal has, of its proposed MPIP.



The MPIP detail’s view is composed by 5 cards or sections:

 	3 Options buttons:

 	Edit: This button allows the editing of the MPIP, as long as it is in the Draft status.
 	Cancel: Allows the proposer to cancel his submitted MPIP as long as it is in the Draft status. It should be noted that an Operator also has the power to cancel an MPIP that is not correctly prepared or submitted.
 	Start voting: This button starts the voting period. Once the voting period is activated, the possibility of receiving feedback from the community is blocked.


 	Proposal details: information, status and discussion subsection.
 	Vote section: it allows the voter to cast a vote, show the vote and remove the vote if already done.
 	Voting period: it shows the voting period time status. It will show if the voting period has started, has finished or the remaining days to vote if the voting period is in progress.
 	Vote results: it shows the number of votes per vote type with a progress bar representing the number of votes. Quorum: it keeps the desired quorum to reach to approve the proposal. This Quorum value is calculated as a snapshot once the proposal is moved to the voting period.
 	Votes: it lists the votes casted. It includes who votes, which type of vote, the memo (if it exists), and the total amount of voting power.

Start the voting period
A Proposer can only start an MPIP if it was submitted by it.

The Proposer sees this screen once they choose the project to start for voting.



1. Click on the Start Voting button.



2. Confirm the transaction.



3. Approve the wallet transaction.



4. Done, your MPIP is ready to receive votes from the community.


Community Participation and Voting
Go to: MPIP app on near.org: https://near.org/meta-pool-official.near/widget/ImprovementProposals

The community can gets involved in two ways:

 	Giving feedback, writing messages and giving opinions in the draft period – Draft status of a MPIP.
 	Voting in the voting period – In Progress status of a MPIP.

Giving Feedback – Discussion
During a draft period, community members or even the core team, can discuss the proposal by adding comments on the Discussion section. That means, if the project is not yet in the voting period (in progress), the entire community can leave comments and participate in the discussion regarding the chosen MPIP.
How to give feedback?
1. Connect your NEAR wallet by clicking the Sign In button or if you do not have an Account yet, create one by clicking the Create Account button.
2. Choose your preferred wallet.



3. Choose a MPIP in Draft status from the list and click on it. A detailed view of the selected MPIP will open on the screen.



A detailed view of the selected MPIP will open on the screen.



4. Adding comments on the Discussion section clicking on the Discussion button.



5. Write and or upload an image and click on Comment.



6. Save the data and approve the transaction.



Important: Adding a comment requires having NEAR and generating a minimum deposit in storage.

7. Congratulations, you are already participating in the discussion of a proposal. Thank you for being part of and supporting the DAO of Meta Pool.


Voting a MPIP
During the voting period, all community members are invited to vote on MPIPs.

Comments will remain disabled during this period, and beyond, allowing only the display of comments.
How to vote a MPIP?
1. Connect your NEAR wallet by clicking the Sign In button or if you do not have an Account yet, create one by clicking the Create Account button.



2. Choose your preferred wallet.



3. Choose a MPIP “In progress” status from the list and click on it. A detailed view of the selected MPIP will open on the screen.



A detailed view of the selected MPIP will open on the screen.



The MPIP detail’s view is composed by 5 cards or sections:

 	Proposal details: information, status and discussion subsection.
 	Vote section: it allows the voter to cast a vote, show the vote and remove the vote if already did.
 	Voting period: it shows the voting period time status. It will show if the voting period has started, has finished or the remaining days to vote if the voting period is in progress.
 	Vote results: it shows the number of votes per vote type with a progress bar representing the number of votes. Quorum: it keeps the desired quorum to reach to approve the proposal.

This value is calculated as a snapshot once the proposal is moved to the voting period.

 	Votes: it lists the votes casted. It includes who votes, which type of vote, the memo (if it exists), and the total amount of voting power.
 	In the section Vote, the community can write a memo for a vote (optional) and then cast a vote. The voting options are:


 	For.
 	Abstain.
 	Against.

If you want to leave a memo, write it down before clicking on the selected voting option, otherwise directly click on the chosen option.



5. Confirm the transaction.



6. Approve the transaction.



7. Votes section. Congratulations you have now Your vote will appear in this section of the MPIP.



 	Congratulations, you have just cast your vote with 100% of your voting power for this option.

Important:

 	You can cast only one vote per MPIP.
 	You vote for the total voting power associated with the wallet.
 	You can vote on all the MPIPs you want.
 	Voting does not affect your ability to use your voting power in other Meta Pool applications. Since it does not block your Voting Power.
 	While the "in progress" voting period is active you can remove your vote and vote again for any of the voting options.

How to Remove the vote / change it?
1. Go to the Vote section and click on Remove Vote on the Vote option you already cast your vote.



2. Click on confirm.



3. Now you have already recovered your total voting power for this MPIP (including the memo/comment for your vote) and you can change your vote.






	

	
	
		
			
				How can a member of the community participate in MPIPs?
			
		

		
					

		
			
			
			
			Creating a MPIP
		
			
			Voting for MPIPs
		
			
			Discuss a MPIP
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!

### How to Use 👀BugEye and the Basics of Bug Reporting

Introduction
Software testing plays a pivotal role in the development and upkeep of software systems. Its primary objective is to detect and rectify bugs, which are unforeseen issues affecting the performance of software or hardware components within a software product or device. These bugs on a website can vary in severity, ranging from minor issues such as spelling errors or formatting glitches to more critical errors in the website's code, which have the potential to disrupt the website's functionality. In the forthcoming sections of this article, we will explore the diverse categories of bugs that can manifest on websites and elucidate how to report them effectively through 👀BugEye to be eligible for rewards.
What is 👀BugEye?
During the Web 2.0 era, users typically received no compensation for reporting bugs, with all the benefits of bug reporting accruing solely to the websites that had their issues resolved. This system was undeniably unfair. Users who invest their time documenting bugs provide a valuable quality assurance testing service and deserve acknowledgment for their contributions. 👀BugEye, a web3 bug reporting platform developed by LNC (L)Earners, addresses this inequity by streamlining bug reporting and rewards distribution throughout the NEAR Ecosystem. It not only ensures the functionality of websites but also offers incentives to those who identify bugs. Before delving into the mechanics of bug reporting on BugEye, let's briefly explore the common types of website bugs, how to spot them, and the proper reporting procedures, equipping you with the essential tools to tackle any bug encounter effectively.
Different Types of Bugs
In the dynamic web environment of platforms like Learn Near Club, four common types of bugs frequently rear their disruptive heads. Each of these bugs exerts its own distinct adverse effects on the website's functionality, threatening to undermine the user experience and operational integrity. Effective documentation and swift resolution of these bugs are imperative, serving as the cornerstone for a seamlessly running website. By proactively addressing these issues, web administrators can not only enhance user satisfaction but also fortify the overall performance and security of the site, ensuring its sustained success and reliability.




	

	
	
		
			
				What is BugEye?
			
		

		
					

		
			
			
			
			A project made by Learn NEAR Club students
		
			
			A bug reporting platform
		
			
			A reward distribution system
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Functional Bugs
Functional bugs pertain to the proper operation of individual components within a software product. In simpler terms, when any feature in an application or website fails to perform as expected, it falls into the category of functional bugs. To illustrate, if the "redeem" button on Learn Near Club ceases to function within the designated redemption period, it qualifies as a functional bug, signifying a deviation from the intended operation of a specific website component.
Content Bugs
Content bugs represent a unique category of issues within an application or website that extend beyond the realm of technical glitches and delve into the very essence of the content itself. They are characterized by inaccuracies, inconsistencies, and other elements that can disrupt the user experience, diminish the platform's professionalism, and hinder its overall functionality. Recognizing and addressing these content bugs is paramount for delivering a seamless, user-friendly, and trustworthy online environment.

When on the lookout for content bugs, it's essential to consider a broad spectrum of aspects that collectively contribute to the quality of the content. Here is a comprehensive list of things to be mindful of when spotting content bugs::

 	Broken links or images (error 404)
 	Defective redirections
 	Missing text where there should be text
 	Missing content where there should be content
 	Missing translations
 	Missing data




	

	
	
		
			
				Functional bugs involve deviation from the intended operation of a specific website component
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Visual Bugs
Visual bugs are perturbations in the graphical user interface (GUI) of a website that can significantly impair the overall user experience. These issues can encompass a wide array of elements and imperfections, ranging from minor nuisances to major disruptions. Let's delve deeper into this category to understand its diverse manifestations::

 	Issues with the layout of the website such as misaligned texts/elements
 	Responsive design problem, e.g. element is improperly displayed on one device but not another
 	Text/elements unintentionally overlap each other
 	Text/elements are cut off

Usability Bugs
If parts of the website are difficult to use or key functions are difficult to access within the logical workflow then it is a usability bug. Key functions should be easy to access, the website should be user friendly and easy to navigate. If any of those problems are spotted report them as usability bugs.
How to Report Bugs on BugEye

 	To report bugs on BugEye go to the BugEye Submit page .
 	Choose the project that you are reporting the bug for.



 	Pick a suggested reward.



 	Fill in the Bug Description box with a detailed description of the bug, providing accurate screenshots is really helpful.



 	Click Submit

Conclusion
Bug reporting is a crucial aspect of software development and technology maintenance. It serves as the critical bridge between end-users and developers, ensuring that software is continuously improved, user experiences are enhanced, and vulnerabilities are addressed promptly. Through this article, we've explored the essential elements of effective bug reporting, the different types of bugs and how to report them on BugEye to get your reward. As technology continues to evolve, the need for seamless communication between all stakeholders becomes increasingly paramount. By encouraging a culture of diligent bug reporting, we pave the way for a more resilient and responsive software ecosystem, where issues are addressed promptly, and innovation can flourish. Ultimately, bug reporting is not just a task; it's a valuable practice that ensures the continued excellence of our digital world.




	

	
	
		
			
				What is the minimum reward for a successful BugEye submission?
			
		

		
					

		
			
			
			
			5 NEAR
		
			
			10NEAR
		
			
			2 NEAR
		
			
			15NEAR
		
	
		

		
		
			
				Correct!
				Wrong!

### Update – October 20, 2023

Brief Summary:

 	
Learn NEAR Club is available as mobile app!


Just click "Install" at you browser settings!



Results:

 	LNC participated  at NEAR APAC! It was pretty crowdy at LNC booth!

 	October Redeem was a blast - 1,000 NEAR claimed by (L)Earners!
 	Many thanks to Dapplets and 🧪nStamp Beta testes - teams are working hard on addressing your feedback
 	We added LNCer NFT as must-have membership card  - mint your only for 0.12 NEAR
LNCer NFT= Learn NEAR Club membership

 	📚 (L)Earn about ''Understanding Permissions on the NEAR To Calimero Blockchain Bridge'' from our partner, Calimero
 	📚 (L)Earn about "NEAR as public DataBase"

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC mobile app Beta Test is scheduled next week!

### Would you use LNC mobile app?

Would you use LNC mobile app?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I do not have smartphone
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Understanding Permissions on the NEAR To Calimero Blockchain Bridge

The Calimero blockchain bridge connects Near and Calimero. It can bridge two types of assets: FTs (Fungible Tokens) and NFTs (Non-Fungible Tokens). Additionally, it can perform Cross-Shard Contract Calls, where a smart contract on one chain can call smart contracts on the opposite chain and receive callbacks. These three ways of using the Calimero blockchain bridge share some smart contracts (most importantly, the permissions contract) and all off-chain Calimero bridge components. For more information, please refer to the official doc.

The Calimero console deploys three components separately. After installing a specific blockchain bridge, setting the correct bridging permissions becomes crucial for its successful operation. By default, the installation of any (FT/NFT/XSC) bridge denies all bridging.

All three bridges (FT, NFT, and XSC) manage permissions based on the Account ID that initiates bridging on the source side. For example, on the Near side for Near-to-Calimero bridging. Additionally, for the XSC connector, managing permissions is based on the Contract ID of the smart contract that the user is trying to call on the destination side.
Motivation for Creating and Properly Using Bridge Permissions
The bridge permissions protect Calimero shard users and organizations from malicious actors. We will list the most important security risks that we mitigate by properly setting blockchain bridge permissions:

 	Preventing Malicious Bridge Usage: Proper permissions can prevent malicious entities from bridging FTs and NFTs into the private shard. By carefully controlling permissions, you can mitigate potential security risks.
 	Protecting Privacy in Cross-Shard Calls: The Calimero private sharding solution aims to protect customer privacy. By managing XSC permissions, you can ensure that public network users (NEAR) cannot access sensitive information stored in contracts on the private shard.
 	Avoiding Malicious and Unnecessary Transactions: Misconfigured permissions can result in paying gas fees on the destination chain (e.g., NEAR) for calls initiated by malicious actors. By setting strict permissions, you can avoid financial harm caused by excessive bridging operations. This problem also exists in the opposite direction, where a malicious actor bridges a lot of worthless tokens to the shard. This takes up a lot of space in produced blocks while extensively using the bridge components.



‍
Blockchain Bridge permissions for FTs and NFTs
As described above, the installation of the FT or NFT bridge denies bridging for all accounts. Permissions for assets bridging are always managed on the permissions contract on the source side. For example on Near for bridging FTs from Near to Calimero. Connectors, which are the smart contracts responsible for bridging, consistently verify with the permissions smart contract. This ensures that bridging adheres to the established permissions. Each connector (FT, NFT, and XSC) has its own set of permissions to manage.

By default, bridging is forbidden for all accounts. If the Calimero shard admin decides to grant bridging permissions to a particular account or a specific group of accounts, the admin can add a new allow regex rule (or rules) that matches the approved accounts for asset bridging.

Let us assume that the shard admin added an allow regex rule .*\.john\.testnet for the FT connector. Now let us look at a few examples of bridging attempts:

 	Account ID alice.john.testnet wants to bridge FT wrap.testnet. This bridging is allowed since it passes at least one (currently the only one) regex allow rule, concretely rule .*\.john\.testnet. Permissions management doesn't include asset names, so john.testnet can bridge any asset.
 	Account ID bob.testnet wants to bridge FT wrap.testnet. This bridging is denied since bob.testnet does not match any allow regex rules.

Note here that Account IDs that do not match at least one allow regex rule can't bridge any assets, while all Account IDs that match at least one allow regex rule can bridge any asset.
Blockchain Bridge Permissions for XSC bridge
Cross-shard contract calls are trickier than FT and NFT bridging. If administrators don't set those permissions correctly, a malicious actor can initiate a cross-shard contract call from the public Near side and access sensitive information on the private Calimero shard.

Because of this, we decided to implement an extra layer of protection through permissions management. We manage permissions for the XSC bridge as follows:

 	By default, all Account IDs are denied for calling any smart contract on the opposite side of the bridge.
 	Account ID that matches at least one allow regex rules for accounts can make cross-shard contract calls.
 	Additionally, we have established a deny list using pairs of regexes (account regex, contract regex). A cross-shard contract call is allowed if the Account ID matches at least one allow regex rule for accounts and, simultaneously, the Account ID initiating the cross-shard contract call for a contract with a specific Contract ID doesn't match any deny regex rule pair.

Example
Let us assume that the shard admin added an allow regex rule .*\.john\.testnet for the XSC connector. Admin also added a deny rule pair (.*, .*sensitive.*) in format (Account ID, Contract ID). Now let us look at a few examples of bridging attempts:

 	Account ID alice.john.testnet wants to make a cross shard contract call to contract with address mycontract.calimero.testnet. This bridging is allowed since Account ID matches at least one allow regex rule and the pair (john.testnet, mycontract.calimero.testnet) does not match any deny rule pairs.
 	Account ID alice.testnet wants to make a cross shard contract call to contract with address sensitive.calimero.testnet. This bridging is denied since alice.testnet does not match any allow regex rules.
 	Account ID alice.john.testnet wants to make a cross shard contract call to contract with address sensitive.calimero.testnet. Account ID alice.john.testnet matches at least one regex rule, but since pair (alice.john.testnet, sensitive.calimero.testnet) also matches a deny regex rule this bridging is denied.

For a more detailed overview of the Calimero blockchain bridge permissions please refer to the official documentation.

### Which activity helps you to become better you?

Which activity helps you to become better you?(Required)
			
					
					(L)Earning
			
			
					
					Casual gaming
			
			
					
					Shopping
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### nStamp Beta Test

Follow @LearnNear and on Twitter

Beta test sprint starts: September 27, 11 am ET
Beta Test sprint ends: October 1, 11 am ET
Requirements:

 	Read these Guides about Privacy  and Near as Public Database to get the context
 	Go to nStamp page
 	Pass nCaptcha
 	Fill the from

 	Submit your entry - this is what you will see

 	Refresh the page


 	Check Notifications at LNC profile and click on your nStamp link

 	Now it is time to verify your nStamp - copy your entry data and click Verify

 	Paste copied data and click Verify

 	Make a screenshot of your successful nStamp verification
 	Tweet your screenshot and "For the first time ever I can proof that I did submitted the form and the data I summitted by using nStamp, project from @LearnNear Barrel"
 	Optionally try to adjust the data and check that nStamp is not valid. This means form creator is not able to tweak the your submitted data!
 	Submit feedback form.

The top 40 beta testers will get 2 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic
Fill the Feedback form

### nStamp

nStamp Redeem with Here wallet
							"*" indicates required fields
                         
 
                        Email
                            
                        Fill it if you want to receive submission confirmation via email NEAR account* Named NEAR account you created at HERE wallet  for FREE, not your main one!Which country are you from?* *Submit with nStamp Mandatory!
Please put a checkmark to be able to submit!
                        
                            nCaptcha Transaction

### Do you think that NEAR can find its mass usage as public DataBase?

Do you think that NEAR can find its mass usage as public DataBase?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I have no idea what that ever means
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### NEAR as public DataBase - DataChain

Info disbalance problem
Informational disbalance in today's world - what Govs and Big Corps know about citizens and the opposite - seems to be a cause for most systematic failures: public goods quality and availability, free speech, social capital quality, manipulations on social media, etc.
This reason is simple - without negative feedback no system can be sustainable.
How NEAR started
To my best knowledge early days Near was developed by bright minds who were heavily engaged with distributed databases projects. Thus there is a good chance that by its origin Near shall look for the adoption as a database, not as a distributed computer or arbitrage machine.
Main usage of NEAR
Data by DappRadar

Some of top of most used Dapps on Near write metadata on-chain. Basically attestation of different kinds.

So this may prove the idea of positioning and adjusting NEAR as a public, immutable, distributed, open database.
There is a very important aspect - data privacy - and it has been addressed via existing encryption tools and ZKs development.
Solution
SocialDB
Unified open source service including bullet -proof contract or set of similar contracts that will allow to write, index and read ZK proofs in an efficient and convenient way.

It is up to applications to cover storage expenses or let users pay to record/read those proofs.
Data Availability layer
Plug NEAR’s DA layer into your L2 framework and start publishing transaction data on a blockchain with a proven trajectory of 100% uptime over its lifetime.
Utilizing NEAR as storage data availability with a focus on lowering rollup DA fees.

 	Blob Store Contract: A contract that provides the store for arbitrary DA blobs.
 	Light Client: A trustless off-chain light client for NEAR with DA-enabled features.
 	RPC Client: The defacto client for submitting data blobs to NEAR.
 	Integrations: Proof of concept works for integrating with L2 rollups.

Examples of Using

 	As User when I submit an online form I want to have immutable, verifiable proof to prevent the form owner from data alteration/deletion. Like email confirmation but time stamped on NEAR - working prototype nStamp
 	Alice promised Bob to love him forever. So Alice nStamped this message
I will love you forever, Bob.near. Yours, Alice.near
and share the nStamp transaction with Bob.
So both A and B can verify the encrypted message, its origin, and timestamp.
While naive Chris has no idea about that deal and still sends flowers, gifts and NFTs to A.
 	Voting - timestamped proof that voter voted for valid candidate without disclosing the actual choice

Know more possible use cases - leave at your comments bellow.


                 
 
                        Do you think that NEAR can find its mass usage as public DataBase?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I have no idea what that ever means
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Chuẩn bị gì cho việc thay đổi ví NEAR

Năm 2020, sau khi chính thức mainnet, NEAR cũng cho ra mắt ứng dụng ví tiền mã hoá tại địa chỉ https://wallet.near.org/ nhằm hỗ trợ triển khai mô hình tài khoản độc đáo của NEAR. Ứng dụng này được phát triển bởi đội ngũ nhà phát triển từ NEAR Inc (sau đổi tên thành Pagoda). Cho tới thời điểm hiện tại, đã có một loạt các ứng dụng ví mã nguồn mở tạo thành một hệ sinh thái ví tiền mã hoá trên NEAR. Việc NEAR hướng tới sự phi tập trung hóa mạng lưới cũng đang tạo nên những sự thay đổi đáng kể cho hệ sinh thái ví. Trong bài viết này, chúng ta sẽ cùng nhau xem xét kỹ hơn những sự thay đổi đó, đồng thời bàn về những tác động của chúng cũng như những việc mà người dùng nên chuẩn bị cho những thay đổi này.
💡NHỮNG GỢI Ý QUAN TRỌNG

 	Luôn luôn sao lưu cụm từ khôi phục ví của bạn
 	Sử dụng tài khoản “phụ” của bạn để trải nghiệm quá trình chuyển đổi ví trước khi áp dụng cho tài khoản chính.

Những thay đổi sắp diễn ra
Mục tiêu hướng tới của NEAR là tạo ra và hỗ trợ một hệ sinh thái Web3 sôi động. Trong vài tháng tiếp theo, đội ngũ Pagoda sẽ cập nhật lại địa chỉ tên miền của ứng dụng ví NEAR từ một ví trên trình duyệt web một trang landing page, chứa chỉ mục và đường dẫn tới các ứng dụng ví khác trên hệ sinh thái. Sự thay đổi này sẽ giúp cho tên miền cũ trở thành điểm tham chiếu cho tất cả các ví NEAR, cho phép người dùng khám phá, lựa chọn và triển khai ứng dụng ví phù hợp với nhu cầu của họ, đồng thời giúp người dùng linh hoạt hơn trong việc khám phá và sử dụng trong không gian Web3. Chủ sở hữu của ví được khuyến khích chuyển sang sử dụng các ứng dụng ví mới và đội ngũ Pagoda cũng đã tạo ra các hướng dẫn chi tiết từng bước để đơn giản hóa quá trình chuyển đổi ví cho người dùng.

NEAR muốn trở thành một hệ sinh thái thịnh vượng với đa dạng các ứng dụng ví. Cũng bởi lý do này mà việc có một điểm duy nhất cho các nhà phát triển trên giao thức có thể dễ dàng tích hợp nhiều loại ví vào ứng dụng của họ là điều vô cùng quan trọng. NEAR cung cấp cho người dùng hơn 30 tùy chọn ví khác nhau, đồng thời giúp người dùng từ các hệ sinh thái khác dễ dàng tương tác với NEAR bằng ứng dụng ví mà họ đã quen sử dụng. Chiến lược này giúp hệ sinh thái ví trên NEAR phát triển mạnh, từ đó khiến Web3 ngày càng dễ sử dụng giống như các ứng dụng Web2 vậy.
Hướng dẫn chuyển sang ứng dụng ví NEAR mới
Nếu như bạn đang sử dụng ứng dụng ví tại địa chỉ https://wallet.near.org làm ví chính của mình, bạn có thể sử dụng “Wallet Transfer Wizard” (Trình chuyển đổi ví) để chuyển sang sử dụng các loại ví NEAR mới mà không hề có rủi ro nào cho tài sản của bạn. Trình hướng dẫn này cũng cho phép bạn lựa chọn giữa ứng dụng ví chạy trên trình duyệt hay các tiện ích mở rộng của trình duyệt (extension), nhằm đảo bảo bạn có một trải nghiệm quen thuộc ngay sau khi chuyển qua ví mới.

Ứng dụng NEAR Wallet vẫn sẽ tiếp tục hoạt động như một ví trên trình duyệt cho đến ngày 31 tháng 10 năm 2023. Người dùng được khuyến khích chuyển sang các ứng dụng ví mới trước thời hạn trên. Việc chuyển sang ứng dụng ví mới có thể được thực hiện thủ công bằng cách sử dụng cụm từ khôi phục (recovery phrase) hoặc dùng Trình chuyển đổi (Transfer Wizard) để di chuyển các tài khoản sang ví mà người dùng thích.

Ngoài ra, ngay cả khi người dùng chưa chuyển tài khoản của họ sang các ví mới trước ngày 31 tháng 10 năm 2023, tính năng chuyển đổi ví vẫn sẽ khả dụng, chỉ có chức năng cơ bản của ví web NEAR là ngừng hoạt động sau ngày đó.

Dưới đây là một số phương pháp để người dùng có thể di chuyển tài khoản NEAR sang các ứng dụng ví mới.
Sử dụng cụm từ khôi phục (Recovery Phrase)
Nhập cụm từ khôi phục (seedpharse) là cách quen thuộc nhất đối với người dùng để di chuyển các tài khoản của họ sang ứng dụng ví mới. Tuy nhiên nếu bạn muốn đảm bảo tính bảo mật cho các tài khoản hay muốn di chuyển nhiều tài khoản khác nhau cùng lúc, chúng tôi khuyên bạn nên sử dụng Trình chuyển đổi ví (Wallet Transfer Wizard).

Nếu bạn vẫn muốn sử dụng cụm từ khôi phục để tiếp tục thì trước tiên bạn cần tắt tính năng xác thực hai yếu tố (2FA) trên ứng dụng NEAR Wallet. Hãy bỏ qua bước này nếu bạn không bật 2FA!

Để tắt tính năng 2FA, truy cập mục cài đặt tài khoản “Settings”, chọn tab “Bảo mật & khôi phục” (Security & Recovery) trên tên miền wallet.near.org, sau đó chọn “Tắt xác thực hai yếu tố” (Disable two-factor authentication) trên tất cả các tài khoản đang bật 2FA của bạn trước khi chuyển sang ứng dụng ví mới.

Việc tắt tính năng xác thực hai yếu tố là một bước quan trọng vì tài khoản của bạn sẽ không thể truy cập được nếu như tính năng này vẫn được kích hoạt.

Tuy nhiên, nếu bạn sử dụng Trình chuyển đổi ví (Transfer Wizard), nó sẽ tự động tắt tính năng 2FA giúp bạn, cùng với việc xác thực địa chỉ email và số điện thoại.
Sử dụng ví lạnh Ledger
Nếu bạn sử dụng ví lạnh Ledger để quản lý tài khoản của mình, bạn sẽ có lựa chọn nạp tài khoản của mình vào các ví có hỗ trợ ví cứng như Sender Wallet hay Nightly Wallet. Tuy nhiên, bạn cần lưu ý rằng các tài khoản trên ví cứng Ledger sẽ không thể di chuyển bằng Trình chuyển đổi “Transfer Wizard”.

Bạn cũng cần phải tắt tính năng xác thực hai yếu tố giống như phương pháp sử dụng cụm từ khôi phục được trình bày ở phần trên. Bạn có thể tắt 2FA bằng cách truy cập mục “Cài đặt tài khoản” (Account Settings) trong tab “Bảo mật & Khôi phục” (Security & Recovery). Hãy vô hiệu hóa tính năng 2FA cho tất cả các tài khoản trên ví của bạn trước khi chuyển sang sử dụng nhà cung cấp ví khác.
Sử dụng Trình chuyển đổi ví “Wallet Transfer Wizard” (Khuyên dùng)
Wallet Transfer Wizard cho phép người dùng chuyển tất cả các tài khoản đã kết nối với ví cũ một cách vô cùng mượt mà, đồng thời vẫn đảm bảo tính bảo mật và sự an toàn cho tài khoản của người dùng, các tính năng:

 	Hướng dẫn chi tiết từng bước để xóa các khóa truy cập cũ
 	Di chuyển cùng lúc nhiều tài khoản tới ứng dụng ví mới mà bạn thích
 	Đổi khóa mới - Xoay vòng khóa truy cập (Key rotation)

Trình chuyển đổi ví giúp nâng cao tính bảo mật cho các tài khoản đã kết nối của bạn trước khi di chuyển sang ứng dụng ví mới bằng cách xoay vòng các khóa, loại bỏ các khóa cũ và di chuyển tài khoản của bạn một cách vô cùng an toàn. Bạn có thể truy cập “Trình chuyển đổi ví” từ banner ở trên cùng của trang web wallet.near.org.
Trình chuyển đổi ví hoạt động như thế nào?
Sau đây, chúng ta hãy cùng tìm hiểu qua cách hoạt động của Trình chuyển đổi ví (Wallet Transfer Wizard).
Bước 1: Bảo mật cho tài khoản của bạn
Chúng tôi khuyên bạn nên đổi khóa của mình và tạo cụm từ khôi phục gồm 12 từ mới, tương tự như cách bạn cập nhật mật khẩu cho các ứng dụng Web2 truyền thống. Việc bảo mật cho tài khoản của bạn bao gồm các bước nhỏ sau:

 	Tạo ra cụm từ khôi phục gồm 12 từ mới
 	Xác thực cụm từ khôi phục mới
 	Sao lưu cụm từ khôi phục mới ở một địa điểm an toàn hoặc viết chúng ra một tờ giấy. Ngoài ra, bạn cũng cần xác nhận tài khoản mà cụm từ này khôi phục và đảm bảo rằng bạn không nhầm lẫn tài khoản đó với cụm từ khôi phục cũ.


Bước 2: Dọn dẹp các khóa
Bước tiếp theo là dọn dẹp các khóa truy cập của bạn. Bước này rất quan trọng, sau khi bước này được thực hiện thành công, bạn có thể bị ngắt kết nối khỏi một số ứng dụng mà trước đó bạn đã kết nối. Dọn dẹp khóa của bạn bao gồm 3 bước nhỏ sau:

 	Xem lại các khóa truy cập mà bạn muốn xóa
 	Nhập cụm từ khôi phục để xác nhận việc dọn dẹp
 	Xóa tất cả các khóa đã quá hạn sử dụng. Sau khi hoàn tất, bạn có thể phải đăng nhập lại vào một số ứng dụng nếu các khóa truy cập của chúng đã bị xóa


Bước 3: Chuyển đổi tài khoản sang ví mới
Bây giờ bạn hãy sử dụng “Bộ chọn ví” (Wallet Selector) và lựa chọn ứng dụng ví mà bạn muốn chuyển tài khoản NEAR của mình tới. Việc di chuyển tài khoản của bạn bao gồm các bước nhỏ sau:

 	Chọn ví bạn muốn chuyển tài khoản của mình sang.
 	Tiếp theo, chọn tài khoản NEAR mà bạn muốn di chuyển.
 	Sao chép cụm từ khôi phục cho việc chuyển tài khoản.
 	Nhập cụm từ khôi phục vào ứng dụng ví mà bạn muốn chuyển sang sử dụng.
 	Hoàn tất việc thiết lập ví và chuyển tài khoản bằng cách làm theo các hướng dẫn kèm theo. Bước này có thể sẽ khác nhau đối với từng ứng dụng ví.
 	Khi bạn đã hoàn thành tất cả các bước trên, hãy xác nhận rằng bạn có quyền truy cập vào tất cả các tài khoản của mình trong ví mới. Sau khi xác nhận, hãy quay lại wallet.near.org và hoàn tất quá trình di chuyển ví.







	

	
	
		
			
				Đâu là phương pháp quen thuộc nhất với người dùng trong việc di chuyển các tài khoản?
			
		

		
					

		
			
			
			
			Sử dụng cụm từ khôi phục (Recovery Phrase)
		
			
			Sử dụng ví cứng Ledger
		
			
			Sử dụng trình chuyển đổi ví (Wallet Transfer Wizard)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Bước 4: Đăng xuất khỏi wallet.near.org
Bước cuối cùng cần làm là đăng xuất khỏi ứng dụng ví NEAR cũ và bắt đầu sử dụng ứng dụng ví mới.

 	Một khi tài khoản của bạn đã được chuyển thành công sang ví mới, hãy truy cập lại vào wallet.near.org và nhấn vào nút “Hoàn thành” (Complete)
 	Kiểm tra xem bạn đã truy cập được vào tất cả các tài khoản của mình trên ứng dụng ví mới chưa
 	Đăng xuất khỏi tất cả các tài khoản mà bạn đã liên kết tới ứng dụng ví NEAR cũ tại near.org
 	Sau khi hoàn tất các bước trên, bạn đã sẵn sàng để trải nghiệm ứng dụng ví NEAR mới để quản lý các tài khoản của mình


Các ứng dụng ví được hỗ trợ bởi Trình chuyển đổi ví
Trình chuyển đổi ví (Wallet Transfer Wizard) hỗ trợ một số ứng dụng ví, Nếu bạn muốn tìm hiểu thêm về các ứng dụng ví được hỗ trợ hoặc muốn hợp tác với họ, bạn có thể tham khảo file Google Sheet này. Một số ứng dụng ví được hỗ trợ bao gồm: MyNearWallet, HERE Wallet, Meteor Wallet, Sender Wallet, Welldone Wallet và Nightly Wallet.
Kết luận
Với những thay đổi sắp diễn ra, hệ sinh thái NEAR đang chuẩn bị bước vào một thời kỳ mới và tiến thêm một bước đáng kể tới việc trở thành một hệ sinh thái hoàn toàn phi tập trung và hướng tới cộng đồng. Hệ sinh thái mới này sẽ giúp nâng cao trải nghiệm người dùng, với một tập hợp các ứng dụng ví và một trình lựa chọn ví giúp cho người dùng dễ dàng chọn được ứng dụng phù hợp nhất, từ đó NEAR sẽ mang lại trải nghiệm đầy đủ trong việc sử dụng Web3 cho người dùng.




	

	
	
		
			
				Đâu là những ứng dụng ví được hỗ trợ bởi Trình chuyển đổi ví (Wallet Transfer Wizard):
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Tất cả các phương án trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Como se preparar para as mudanças na carteira NEAR

Quando a NEAR lançou sua rede principal em 2020, ela também lançou uma carteira construída e hospedada pela equipe principal da Near Inc. (então Pagoda.) em https://wallet.near.org para dar suporte ao seu modelo de conta exclusivo. Hoje, uma série de carteiras de código aberto chamam o ecossistema de carteiras NEAR de lar. À medida que a NEAR continua seu esforço de descentralização, ela muda significativamente seu ecossistema de carteira. Vamos examinar mais de perto as mudanças em questão, seu impacto e como os usuários podem se preparar para elas.
💡DICA IMPORTANTE

 	Sempre faça um backup da sua recovery phrase (frase de recuperação)
 	Primeiro tente migrar à uma conta “não essencial” para testar como o processo funciona.

Mudanças recentes
A missão da NEAR tem sido criar e apoiar um ecossistema Web3 vibrante. Nos próximos meses, a Pagoda começará a migrar o domínio original da carteira NEAR de uma carteira de navegador para um hub de carteira. Isto permitirá que o domínio se torne um ponto de referência para todas as carteiras NEAR, permitindo aos usuários descobrir, selecionar e implementar a carteira que se adapte às suas necessidades e dando-lhes maior flexibilidade à medida que navegam no espaço Web3. Os titulares de carteiras são incentivados a migrar suas contas para novas carteiras do ecossistema, e a equipe também criou vários tutoriais, com instruções passo a passo, para simplificar o processo.

A NEAR pretende criar um ecossistema próspero que consiste em múltiplas carteiras. Para isso, é vital um ponto único de integração para desenvolvedores baseado no protocolo. O novo ecossistema oferecerá aos usuários mais de 30 opções de carteira, facilitando a interação de usuários de outros ecossistemas com a blockchain NEAR usando uma carteira com a qual já estão familiarizados. Essa estratégia permite um ecossistema próspero de carteiras na NEAR, tornando o Web3 tão fácil de usar quanto a Web2.
Transferindo suas contas da NEAR
Se você, atualmente, usa https://wallet.near.org como sua carteira principal, você pode usar o Assistente de transferência de carteira para concluir a migração sem arriscar seus fundos. O assistente também permitirá que você selecione entre carteiras baseadas em navegador e extensão, garantindo que você tenha a mesma experiência a que está acostumado, mesmo após a migração.

A NEAR Wallet continuará a funcionar como uma carteira de navegador até 31 de outubro de 2023. Os usuários são incentivados a transferir suas contas para um novo provedor antes que a data expire. Isso pode ser feito manualmente usando a frase de recuperação ou o Assistente de transferência para migrar com segurança as contas para a carteira de sua preferência. Além disso, mesmo que os utilizadores não tenham transferido as suas contas até 31 de outubro de 2023, a carteira de transferência ainda estará disponível, mesmo após a funcionalidade da carteira cessar.

Vejamos os diferentes métodos disponíveis para os usuários transferirem suas contas.
Usando a Recovery Phrase
Importar a recovery phrase é a forma mais familiar para os usuários transferirem suas contas para uma nova carteira. No entanto, se desejar garantir a segurança das suas contas ou transferir várias contas, recomendamos fortemente a utilização do Assistente de Transferência de Carteira. Se você optar por usar a frase de recuperação, primeiro será necessário desativar a autenticação de dois fatores (2FA). Isso pode ser feito através das configurações da sua conta na guia “Segurança e recuperação” no domínio wallet.near.org atual – desative a autenticação de dois fatores em todas as contas antes de migrar para outro provedor de carteira.

Desativar a autenticação de dois fatores é fundamental porque ela não será mais suportada, tornando sua conta inacessível até que o 2FA seja desativado. No entanto, se você usar o Assistente de transferência, ele desativará automaticamente o 2FA, juntamente com a verificação por e-mail e telefone.
Usando o Ledger
Se você usar um Ledger para proteger sua conta, terá a opção de importar sua conta para carteiras com suporte de hardware, como Sender Wallet ou Nightly Wallet. No entanto, é essencial lembrar que contas protegidas pelo Ledger não podem ser transferidas usando o Assistente de Transferência. Assim como fez ao migrar usando a opção Frase de recuperação, você será solicitado a desativar o 2FA. Isso pode ser feito acessando “Account Settings” (configurações da conta) na guia “Security & Recovery” (segurança e recuperação). Desative o 2FA em todas as contas antes de migrar para outro provedor de carteira.
Usando o assistente de transferência de carteira (altamente recomendado)
O Assistente de transferência de carteira permite que os usuários transfiram todas as suas contas conectadas sem problemas e oferece uma verificação de segurança completa para garantir que todas as contas estejam seguras. O Assistente também fornece:

 	Um guia passo a passo sobre como remover chaves de acesso antigas.
 	Transferência em massa de contas conectadas para a carteira de sua escolha.
 	Rotação de chave.

O Assistente de Transferência ajuda a melhorar a segurança das suas contas conectadas antes de migrá-las para uma nova carteira. Isso é feito girando suas chaves, limpando as chaves antigas e transferindo suas contas com segurança. O Assistente pode ser acessado no banner na parte superior da página wallet.near.org.




	

	
	
		
			
				Qual é a maneira mais familiar para os usuários transferirem suas contas?
			
		

		
					

		
			
			
			
			Usando a frase de recuperação
		
			
			Usando a Ledger
		
			
			Usando o assistente de transferência de carteira
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como funciona o assistente de transferência de carteira?
Agora, vamos dar uma olhada rápida em como funciona o Assistente de transferência de carteira.
Passo nº 1: Protegendo sua conta
Recomendamos girar suas chaves e gerar uma nova frase de recuperação de 12 palavras, semelhante à forma como você atualizaria sua senha. Proteger sua conta envolve as seguintes etapas.

 	Gere uma nova recovery phrase de 12 palavras.
 	Verifique a nova recovery phrase.
 	Salve a recovery phrase recém-gerada em um local seguro ou anote-a em um pedaço de papel. Além disso, você deve confirmar, também, a conta recuperada e certifique-se de não confundi-la com a antiga recovery phrase.


Passo nº 2: Organize as chaves
A próxima etapa é organizar suas chaves. Esta etapa é vital porque a NEAR deseja reduzir o número de aplicativos com os quais as chaves foram compartilhadas. Depois que esta etapa for executada, você poderá ser desconectado de alguns aplicativos. Organizar suas chaves envolve três etapas.

Revise as chaves sugeridas que você deseja remover.

Digite a frase de recuperação para confirmar a remoção.

Remova todas as chaves desatualizadas. Depois de concluído, pode ser necessário fazer login novamente em determinados aplicativos se suas chaves de acesso limitado tiverem sido removidas.


Passo nº 3: Transferir contas
Agora, use o Seletor de Carteira e escolha a carteira para a qual deseja transferir suas contas. A transferência de suas contas envolve os seguintes passos:

Selecione a carteira para a qual deseja transferir suas contas.

Em seguida, selecione as contas que deseja transferir.

Copie uma senha temporária e proteja a transferência da conta.

Digite a senha na carteira de destino.

Conclua a configuração da carteira e a transferência da conta seguindo as instruções anexas. No entanto, esta etapa pode variar de uma carteira a outra.

Depois de concluir todas as etapas listadas acima, confirme se você tem acesso a todas as suas contas na nova carteira. Depois de confirmado, volte para wallet.near.org e conclua o processo de transferência.

Passo nº 4: Saia (log out) de Near.org
A última etapa é sair da sua carteira NEAR e começar a usar sua nova carteira.

Assim que a transferência da conta for concluída, volte para wallet.near.org e clique em “Complete” (concluir).

Verifique se você tem acesso a todas as suas contas na nova carteira.

Saia de todas as contas localizadas em near.org.

Depois de concluído, você estará pronto para usar sua nova carteira e gerenciar suas contas.

Como migrar para a carteira HERE.
O login via carteira web é a maneira mais fácil de exportar sua conta para HERE.

Só necessita de três cliques!

https://youtu.be/j2JFDJnUiCc

Carteiras Suportadas
O Assistente de Transferência oferece suporte a diversas carteiras. Se quiser saber mais sobre as carteiras suportadas ou fazer uma comparação, você pode consultar nesta Google Sheet. Algumas das carteiras suportadas incluem MyNearWallet, HERE Wallet, Meteor Wallet, Welldone Wallet, e Nightly Wallet.
Para encerrar.
Com estas mudanças, a NEAR está entrando numa nova era e dando um passo significativo no sentido de alcançar um ecossistema verdadeiramente descentralizado, controlado e impulsionado pela sua comunidade. Este novo ecossistema ajudará a melhorar a experiência do usuário, com o hub de carteira e o seletor de carteira permitindo que os usuários selecionem a carteira que melhor atende às suas necessidades, ajudando a NEAR a trazer toda a gama de usos e experiências da Web3 aos usuários.




	

	
	
		
			
				Quais são as carteiras suportadas pelo assistente de transferência?
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Todas a anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Como fazer stake de tokens NEAR usando diferentes carteiras

Por que fazer stake de NEAR?
Staking NEAR oferece uma maneira direta e eficiente de aumentar a segurança e a eficiência da rede. Além do mais, esse processo não exige nenhum equipamento adicional ou configurações complexas dos detentores de token. É um método descomplicado que permite aos usuários ganhar recompensas.

O stake de tokens NEAR envolve a participação na rede como um delegador. Como delegadores, os participantes dão seu apoio aos validadores, aos quais é confiada a segurança da rede. Em retribuição a esse apoio, eles ganham recompensas de staking. Essas recompensas são distribuídas proporcionalmente à participação de cada usuário no valor total.

Os validadores são entidades que executam nós, validam transações e produzem novos blocos no protocolo NEAR. Os validadores são responsáveis ​​por proteger o protocolo NEAR, e suas recompensas de stake dependem de seu desempenho. Considere suas taxas de comissão, tempo de atividade e histórico ao escolher o validador. Você pode encontrar uma lista de validadores no explorador de blockchain NEAR Explorer.

Ao fazer stake de NEAR, os usuários contribuem para a segurança geral da rede, ajudando a validar transações e proteger a blockchain contra possíveis ataques. Essa participação ativa não apenas beneficia o usuário, mas também fortalece todo o ecossistema.

Abaixo, você encontrará algumas das opções de carteira amplamente usadas disponíveis para staking de NEAR. Você pode selecionar a carteira que melhor se alinha com seus requisitos e preferências.
NEAR Wallet
A NEAR Wallet é uma carteira baseada na web sem custódia para a blockchain NEAR, onde os usuários podem enviar e receber tokens NEAR ou NEP-141. É uma carteira simples e conveniente que permite aos usuários gerenciar, armazenar e fazer stake dos seus ativos NEAR.

Primeiro, você precisa criar uma conta NEAR. Acesse o site da Near Wallet e clique em Criar conta. Se você já possui uma carteira, clique em Importar conta existente.



Existe a opção de saber mais sobre a NEAR antes de criar sua conta.



Você precisa escolher um método para restaurar o acesso à sua carteira. A NEAR Wallet suporta duas opções:

 	Por meio de uma frase inicial (frase secreta segura).
 	Através da conexão da carteira de hardware Ledger.



Nota: Near Wallet suporta carteira de hardware Ledger. Você pode fazer login em sua carteira usando-a se tiver esse dispositivo. Usar uma carteira Ledger é a maneira mais segura de fazer stake dos seus tokens.

Após selecionar o Método de Segurança, clique no botão abaixo para continuar criando a carteira. Mostraremos o processo de uso de uma frase de recuperação.

Uma frase inicial com 12 palavras aparecerá na tela. O método mais seguro para armazenar a frase é escrevê-la em um papel e guardá-la em um local seguro. Em seguida, clique em Continuar.



Importante: não faça capturas de tela enquanto salva a frase de recuperação e não a copie para a área de transferência. Salvar sua frase inicial como uma captura de tela ou texto em um telefone ou laptop coloca-a em risco de ser roubada. Nunca compartilhe sua frase de recuperação com ninguém. O ideal é copiar as palavras em um papel e guardá-lo muito bem.

Confirme a frase inicial. Na próxima etapa, você deve inserir a Frase de verificação.



Depois disso, sua carteira está pronta para uso.



Na página inicial do NEAR Wallet, abra a guia Staking.



Primeiro, se você tiver mais de uma conta, você deve selecionar aquela na qual você vai fazer stake de NEAR. Então você precisa escolher um validador para delegar tokens.



Clique em Stake My Tokens e selecione um validador. Sempre DYOR ao escolher um validador. A carteira mostrará uma taxa de validador.

*DYOR - Faça sua própria pesquisa - sobre o validador.

Nota: Preste atenção ao fato de que Near usa endereços não padrão no formato everstake.poolv1.near em vez de longas palavras hexadecimais como endereços Bitcoin e Ethereum.



Para continuar o processo de staking, clique em Stake With Validator. Insira o número de tokens NEAR que deseja delegar. Selecione a opção Use Max para fazer stake de todos os tokens disponíveis em sua carteira e clique em Enviar. Lembre-se de reservar uma parte dos tokens para pagar uma taxa de retirada.



Por fim, clique em Confirmar para efetuar a transação.



Leva algum tempo para verificar a transação. Demora alguns momentos. Quando terminar, você verá a seguinte mensagem:



Você pode verificar seu stake e recompensas no painel.



Observação: as recompensas são reinvestidas automaticamente, mas você pode sacar e cancelar a aposta assim que o botão de saque estiver disponível.

Os tokens serão retirados após quatro períodos completos - aproximadamente 52 a 65 horas.

Se você precisar retirar seus tokens, escolha “Unstake” na seção de apostas e selecione seu validador.



Escolha o número de fichas que deseja retirar ou clique em Usar máx. Em seguida, clique no botão Unstake Token.



Para continuar desfazendo, confirme a transação.



Se você fez tudo corretamente, verá a mensagem “Success!” inscrição:






	

	
	
		
			
				Você pode compartilhar sua senha com seus amigos?
			
		

		
					

		
			
			
			
			Sim
		
			
			Não
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Mobile
NEAR Mobile é uma carteira conveniente desenvolvida pela Peersyst. NEAR Mobile é uma carteira simples e segura. NEAR Mobile permite que você gerencie e importe várias contas em seu telefone para ter controle e flexibilidade sobre seus ativos o tempo todo.

Para iniciar o processo de staking, acesse o site oficial da NEAR Mobile para baixar a carteira. O aplicativo NEAR Mobile está disponível na App Store e no Google Play.



Abra o aplicativo no seu dispositivo e clique no botão Criar conta para iniciar a criação da conta. Se você já possui uma carteira, clique em Importar sua NEAR Wallet.



A seguir, você verá informações essenciais sobre a carteira NEAR e a frase mnemônica. Depois de lê-lo, clique no botão Gerar mnemônico.



Lembre-se, a frase mnemônica é crucial para acessar e recuperar sua carteira. Portanto, é essencial armazená-lo com segurança. Recomendamos anotar sua frase de recuperação e mantê-la acessível apenas para você. Outra opção é usar um dispositivo especializado destinado ao armazenamento de frases mnemônicas.

Não faça capturas de tela da frase, pois isso pode expô-la a acesso não autorizado. É essencial nunca revelar sua frase de recuperação a ninguém.

Para prosseguir para a próxima etapa, selecione as palavras de sua frase mnemônica na ordem correta.



Você deve criar uma senha para impedir que terceiros não autorizados acessem sua carteira e confirmem transações sem sua autorização. Você pode usar a autenticação biométrica para acessar a carteira.



A blockchain NEAR foi projetada para ser simples, com um modelo de conta flexível e contas legíveis por humanos - qualquer nome que o usuário desejar, em vez de uma sequência de letras e números. Trocando a aba colorida com as informações da conta, você encontrará as opções para importar mais uma conta ou criar uma personalizada.

Para financiar sua carteira, clique no botão Receber, copie o endereço da carteira e envie os tokens NEAR da carteira ou outra conta para o seu endereço.



Vá para a seção Staking. Ele abrirá um painel para seus tokens em stake, incluindo as recompensas e o valor.

Escolha Stake my tokens para iniciar o processo.



Insira o valor que deseja delegar e clique em Avançar. Selecione um validador confiável na lista ou comece a digitar seu nome na barra de pesquisa para encontrá-lo mais rapidamente.

Verifique os detalhes da transação e, se tudo estiver correto, clique em Avançar.



Tendo a transação concluída, clique em Continuar e você receberá a notificação sobre os tokens em stake com sucesso.



Na seção Stake, você pode gerenciar o valor em staking. Você pode retirar tokens clicando no botão Unstake e especificando quanto deseja retirar.

Nota: O período de retirada é de aproximadamente 52-65 horas (quatro épocas).






	

	
	
		
			
				Qual é o período de unstaking?
			
		

		
					

		
			
			
			
			14 dias
		
			
			24-36 horas
		
			
			Aproximadamente 52-65 horas
		
			
			Sem período de carência
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





4. Meteor Wallet
A Meteor Wallet foi fundada por uma equipe de estrelas que também fundou projetos de alto nível como Near Tinker Union e Enleap Near no NEAR Protocol.

Meteor é uma carteira simples e segura: tudo é criptografado e nada confidencial é registrado. A carteira permite aos usuários coletar NFTs, acessar DeFi e explorar tudo Web3.

Antes de fazer stake em NEAR, você deve criar e carregar uma carteira de criptomoedas.

Acesse o site da Meteor Wallet e escolha entre as versões web e de extensão. Neste tutorial, faremos stake de tokens NEAR por meio da versão da web.



Prossiga para a próxima etapa clicando no botão Começar.



Na tela principal da Carteira Meteor, duas opções estão disponíveis:

 	Crie uma nova carteira;
 	Importe uma carteira existente.

Vamos criar um novo para mostrar todo o processo do zero. Primeiro, clique em Criar uma nova Carteira Meteor. 

Uma senha é necessária para impedir que terceiros não autorizados façam login na carteira e confirmem transações sem o seu consentimento. Crie uma senha complexa e clique em Continuar.



Cada conta NEAR é identificada por um endereço específico. Com base no nome, existem dois tipos de contas:

 	Contas nomeadas com nomes legíveis por humanos, como alice.near;
 	Contas implícitas designadas por uma string de 64 caracteres.

Selecione a opção que você preferir.



Fazer backup de sua carteira é o passo mais importante. Você pode restaurar o acesso aos fundos em outro dispositivo usando uma frase de recuperação secreta. Nunca compartilhe sua senha com ninguém.



Selecione a primeira e a última palavra de sua frase de recuperação secreta para confirmar que você salvou a frase inteira.



Antes de prosseguir com o staking, você precisa recarregar sua conta. Copie o endereço da sua carteira clicando em Conta. Use-o para enviar tokens para sua carteira. Assim que você recarregar sua carteira, você pode começar.



Vá para a seção de stake clicando no botão Stake, conforme mostrado abaixo.



Selecione a seção Staking Padrão.



Clique no botão Create New Staking para continuar.



Insira o valor que deseja delegar e escolha um validador confiável clicando no botão Selecione seu validador.



Uma lista de validadores disponíveis aparecerá na tela. Encontre o validador a quem você deseja delegar tokens NEAR. Você pode fazer stake com vários validadores. Para uma busca rápida, comece digitando o nome do validador no campo, e depois clique sobre ele.



A Meteor Wallet mostra os ganhos estimados por vários períodos para que você possa descobrir quantas recompensas receberá.



Depois de selecionar um validador e a quantidade de tokens, clique em Stake.



Por fim, verifique os detalhes da transação e clique em Confirmar para fazer staking de NEAR.



Nós fizemos o staking de tokens NEAR com sucesso.

Você também pode retirá-los clicando no botão Retirar e especificando quanto deseja retirar.

Nota: O período de retirada é de aproximadamente 52-65 horas (quatro épocas).






	

	
	
		
			
				É possível fazer o stake de seus tokens com diferentes validadores?
			
		

		
					

		
			
			
			
			Não
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





5. Nightly Wallet
Nightly Wallet é uma carteira multi-chain atualmente trabalhando em NEAR, Solana e Aptos e disponível como uma extensão do Chrome e Firefox no seu celular. Nightly Wallet é a chave para o Metaverso, fornecendo funções como swipe de token, stake, stake líquido e exibição de NFT em cada cadeia. Nightly já foi integrado ao NEAR Wallet Selector.

Acesse a Nightly Wallet e escolha seu navegador preferido ( Firefox e Chrome ) para fazer o stake de seus NEAR.



Neste guia, usamos o navegador Chrome. Instale a extensão clicando no botão Adicionar ao Chrome.



Na página da extensão, clique no botão Adicionar extensão para aprovar a instalação do plug-in.



Abra a extensão Nightly Wallet em seu navegador.



Nesta janela, você pode restaurar sua carteira existente ou criar uma nova. Se você já possui uma Nightly Wallet, pode restaurá-la e prosseguir para a próxima etapa. Para criar uma nova, toque em Criar nova carteira.



Escolha uma senha para sua carteira. Preste atenção às recomendações de segurança e escolha uma senha forte. Confirme sua senha e toque em Criar uma carteira.



Em seguida, você verá sua Frase Secreta. Não compartilhe sua frase com ninguém. Essas palavras geradas aleatoriamente são as chaves da sua carteira. Se você esquecê-los, perderá o acesso aos seus fundos. Escreva sua Frase Secreta no papel e clique em Avançar.



Digite sua Frase Secreta para verificar sua carteira.



Em seguida, escolha a rede NEAR.



Agora você pode depositar, enviar, trocar e fazer stake de NEAR. Verifique o painel da carteira para as principais funções.



Agora sua Carteira Nightly está pronta para a próxima etapa: Staking. Abra sua carteira, toque no ícone NEAR e clique em Comece a Ganhar.



Nightly oferece 2 opções de staking: Staking líquido e Regular. Durante o regular, você receberá tokens NEAR como recompensa. O Staking líquido oferece outras condições: os usuários podem depositar tokens, mas receberão tokens líquidos em troca. A principal diferença entre o staking líquido e o staking tradicional é que você não precisa congelar seus ativos. No entanto, na verdade, você precisa bloquear seu token, mas receberá um novo - stNEAR ou NEARx.

Para obter tokens NEAR como recompensa, escolha Regular Staking.



Para delegar o seu NEAR, toque no ícone Plus.



Esta tela exibe uma lista de todos os validadores. Escolha um validador confiável.



Insira um valor de stake dentro do limite da sua carteira e clique no botão Avançar.



Sua delegação agora está ativa e em breve você começará a receber recompensas.



Você sempre pode verificar suas informações de stake clicando nos botões Começar a Ganhar e Stake Regular.



Se você quiser retirar seus tokens, você precisa clicar no botão Unstake. Observe que o período de retirada é de aproximadamente 52-65 horas (quatro períodos).






	

	
	
		
			
				Quais tokens você receberá como recompensa se escolher staking regular?
			
		

		
					

		
			
			
			
			NEARx
		
			
			stNEAR
		
			
			NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





6. Ledger Live
O Ledger Live é uma plataforma para comprar criptomoedas, fazer stake de seus ativos e gerenciar NFTs. Ele funciona como um gateway seguro para o ecossistema criptográfico. O aplicativo Ledger Live permite gerenciar e negociar diferentes tokens. Além disso, você pode aumentar seus ativos usando o processo de staking e empréstimo disponível no aplicativo Ledger Live.

Acesse o site oficial do Ledger e clique no botão Download. Atualmente, os usuários podem baixar o Ledger Live para Windows, macOS e Linux. A versão Mobile está disponível para usuários de Android e iOS.



Escolha seu sistema operacional, instale o aplicativo em seu computador e abra-o. Em seguida, clique no botão Começar. Você pode acessar todas as suas funcionalidades se tiver um dispositivo Ledger.



Ligue seu dispositivo Ledger e digite o código.



Aprove a entrada no aplicativo pressionando dois botões. Agora, você pode usar o aplicativo.



Então, aqui está o menu principal do Ledger Live. Instale a versão mais recente do aplicativo NEAR em seu dispositivo Ledger para iniciar o processo de stake. Acesse o App Catalog e escreva NEAR na barra de pesquisa. Depois disso, clique em instalar.



Depois de instalar o aplicativo NEAR, adicione suas contas NEAR clicando no botão adicionar conta. 

Você pode adicionar várias contas.



Depois que sua conta for adicionada com sucesso, clique no botão Concluído.



Antes de fazer stake, você deve enviar tokens NEAR para sua carteira. Pule esta etapa se você já os tiver e vá diretamente para o staking.

Encontre a seção Conta para adicionar fundos ao seu Ledger Live. Escolha uma conta NEAR. Em seguida, clique no botão receber.



A página Receber será aberta. Clique em Continuar.



Verifique se o endereço compartilhado corresponde exatamente ao do seu dispositivo. Selecione Aprovar no dispositivo e pressione dois botões em seu Ledger.



Se estiver tudo ok, copie seu endereço. Conclua este processo clicando em Concluído.



Em seguida, você pode comprar tokens NEAR de qualquer troca de criptomoedas. Envie-os para o endereço da sua carteira. Depois que a transação for concluída, volte ao seu Ledger Live.

Abra a guia Accounts e clique no botão Stake para iniciar o processo de staking.



Em seguida, você verá informações sobre os recursos NEAR staking. Após a leitura, clique em Continuar.



Em seguida, você precisa escolher o Staking Provider (validador) que deseja delegar. Clique em Mostrar tudo para ver a lista completa de validadores.



Na nova janela, digite “Everstake” no campo de pesquisa e selecione-o na lista. Clique em Continuar.



Em seguida, insira o valor que deseja fazer stake. Você também pode selecionar o botão "Use Max" para stake de todo o seu saldo (menos a taxa de transação). O valor das taxas de rede será mostrado na guia de apostas.



Você precisa confirmar a transação em seu dispositivo Ledger. Pressione os botões do seu dispositivo, conforme a figura abaixo.



Agora você delegou seus tokens com sucesso. Clique em Ver detalhes para ver os detalhes da transação.



Você pode revisar seu status e a transação verificando seu hash no explorer. 

Você pode acompanhar sua posição de staking clicando na guia Contas.






	

	
	
		
			
				Você pode obter todas as funcionalidades do aplicativo Ledger Live sem o dispositivo Ledger?
			
		

		
					

		
			
			
			
			Sim
		
			
			Não
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





7. Omni Wallet
Omni é um aplicativo de carteira Web3 de última geração. É o renomeado SteakWallet. A Omni é uma carteira de criptomoedas de serviço completo e autocustódia, que facilita a aposta de vários tokens, o gerenciamento de cadeia cruzada de ativos e a coleta e exibição de NFTs.

Você precisará baixar o aplicativo e criar uma carteira Omni para iniciar o processo de staking.

Acesse a Omni Wallet, escolha o sistema operacional de sua preferência ( iOS ou Android ) e instale o aplicativo no seu celular.





Depois de instalado, acesse o aplicativo OMNI Wallet e clique no botão Vamos lá. Para continuar usando a carteira, você também precisa escolher Configurar uma senha ou Usar ID facial para proteger sua carteira.

Se você tiver uma conta OMNI, poderá importá-la ou criar uma nova. Para importar sua carteira existente, clique no botão Importar uma carteira existente. Seu Ledger também pode ser conectado ao OMNI.



O próximo passo é a sua frase secreta. A carteira irá gerar uma frase secreta aleatória que você deve salvar e lembrar. Para concluir a configuração da carteira, você deve inserir sua frase de 12 palavras na ordem correta e clicar em Avançar.

Nota: Proteja sua frase secreta. Qualquer pessoa com esta frase terá o controle de seus fundos. Se você perdê-lo, perderá o acesso à sua carteira.



A carteira Omni autocustodial torna o staking multi-chain fácil e rápido. A complexidade da stake é abstraída e traduzida em três toques simples no seu dispositivo móvel.

Na tela inicial, clique no botão Ganhar. Role para baixo no menu Staking e escolha NEAR. A tela NEAR staking aparecerá no dispositivo. Para continuar o processo de staking, pressione o botão Stake NEAR.

Nota: Você precisa de pelo menos 0,05 NEAR para um stake com sucesso e cobrir as taxas de gás.



Isso abrirá a tela de informações de stake. Toque em Vamos! Insira a quantidade de NEAR que deseja fazer stake e pressione Avançar.



Verifique a taxa de rede e abra a lista de validadores clicando na guia "Stake with". Escolher um validador responsável é a chave para a segurança de seus fundos e receitas.

Depois de escolher um validador, toque no botão Confirmar Stake.

Observação: você pode tocar na seta suspensa ao lado de Média para selecionar o valor da taxa de rede. Atenha-se à taxa de rede recomendada pela Omni para garantir que sua transação seja processada adequadamente.



Após sua confirmação, você receberá informações sobre seu stake de NEAR com sucesso.



Para visualizar seu stake ativo, vá para a página principal. Lá você também pode retirar, apostar para vários validadores. O período de retirada é de aproximadamente dois dias.
8. Carteira Opto
A carteira Opto é uma carteira móvel para o protocolo NEAR e a rede Octopus. É uma carteira segura, de código aberto e sem custódia que permite aos usuários transferir e fazer stake de seus tokens NEAR.

A Opto Wallet é uma carteira de código aberto com Bio Auth. Ele oferece a exploração de um navegador dApp integrado, onde os usuários podem facilmente encontrar NEAR dApps incríveis, gerenciar os favoritos e interagir com eles. A Opto Wallet está disponível para software iOS e Android e suporta Ledger.

Siga as próximas etapas para fazer o stake dos seus ativos NEAR. Você precisa instalar a Opto Wallet no seu dispositivo. Para isso, acesse o site oficial da Opto Wallet, escolha o sistema operacional de sua preferência ( iOS ou Android ) e baixe o aplicativo.

Abra o aplicativo Opto Mobile Wallet. Você está na tela inicial da Opto Wallet. Nesta janela, você pode restaurar sua carteira existente ou criar uma nova. Para criar um novo, toque em Criar.

Durante a próxima etapa, você obterá sua frase mnemônica. Ninguém tem acesso a esta frase. Se você esquecer, perderá o acesso aos seus fundos. Guarde a frase secreta em um local seguro.

Nota: É essencial não tirar screenshots ou copiar a frase para a área de transferência. A melhor maneira é anotá-la para que ninguém mais possa acessar as palavras-chave.

Agora escolha um código PIN para proteger sua carteira. Você usará este Código para fazer login em sua conta Opto. Memorize ou guarde-o em local seguro. Confirme seu código PIN para concluir a criação de sua carteira.



Abra a guia Finanças conforme mostrado na tela. Existe a seção NEAR Staking; você deve continuar o processo de staking.



A Opto Wallet se oferece para conectar uma conta NEAR Wallet ou MyNearWallet. Vamos fazer o stake dos tokens NEAR por meio da conta Opto recém-criada. Faça login na sua nova conta Opto confirmando seu endereço.



Toque na guia Validadores para escolher um validador confiável. A lista mostra a taxa de cada validador, o número de pessoas e a quantidade total de tokens NEAR em staking. Em seguida, digite o número de NEAR que você gostaria de fazer o stake e toque em Depositar.



Para finalizar o processo de stake, verifique todos os detalhes e confirme sua intenção.

Se tudo foi feito corretamente, parabéns! Agora sua delegação está ativa e você começará a receber recompensas.


9. Sender Mobile Wallet
Sender é uma carteira sem custódia feita sob medida para NEAR. Ela fornece uma solução de carteira completa para os usuários enviarem, receberem, armazenarem e apostarem ativos baseados em NEAR com facilidade e segurança.

A plataforma da empresa ofereceu primeiro uma carteira de extensão de navegador sem custódia e agora os usuários também podem usar uma versão móvel.

O remetente é atraente para os usuários porque a carteira concede a eles controle total de suas chaves privadas e oferece vários recursos integrados, como envio e recebimento de ativos digitais, troca instantânea, galeria NFT e staking.

Acesse a Carteira do remetente, escolha o sistema operacional de sua preferência ( iOS ou Android ) e instale o aplicativo no seu celular.



Depois de baixar a carteira, você pode criar uma nova conta ou usar sua conta existente, se tiver uma.

Neste guia, escolheremos a primeira opção e criaremos uma nova conta.

O aplicativo solicitará que você crie e confirme uma nova senha, conforme a imagem abaixo. Crie uma senha confiável e forte. Não compartilhe nenhuma de suas senhas com outras pessoas e guarde-as em um local seguro.



Para continuar usando a carteira, você também precisa optar por configurar uma senha ou usar o Face ID para proteger sua carteira.

Para reservar sua ID de conta, você pode escolher um nome de conta legível que termine com “.near” ou uma conta implícita que seja uma sequência de caracteres.

Você deve se lembrar que é apropriado salvar todas as informações relacionadas à carteira criptográfica offline. O remetente enviará um aviso para lembrá-lo de que você deve salvar suas informações criptográficas privadas com responsabilidade.



A carteira irá gerar uma frase aleatória e secreta de 12 palavras que você deve salvar e lembrar. A carteira solicitará uma palavra aleatória de sua senha para garantir que você a salvou. Para finalizar a configuração da carteira, digite a palavra e clique em Criar conta para concluir o processo.

Observação: nunca divulgue sua frase de recuperação para não ser enganado.



Depois disso, você precisará inicializar sua conta para continuar. Você tem que depositar 0,1 NEAR para terminar de criar sua conta.

Envie NEAR suficiente para inicializar sua conta e poder fazer o stake com validadores.



Vá para a seção de stake clicando no botão central, conforme mostrado abaixo. Aqui você precisa escolher o validador na lista e preencher a quantidade de tokens NEAR que deseja fazer o stake.

Observação: você pode selecionar qualquer validador, mas recomendamos escolher validadores confiáveis ​​que tenham a confiança da comunidade.

Para concluir o staking, você precisará clicar no botão Stake.



Em seguida, clique no botão Confirmar para confirmar suas escolhas de staking.

Você fez seu stake com sucesso seus tokens NEAR e agora receberá suas recompensas.



Para visualizar seu stake ativo, vá para a página principal. Lá você também pode retirar seus tokens clicando no botão Unstake e inserindo a quantidade de NEAR que deseja retirar.

Nota: O período de retirada é de aproximadamente 52-65 horas (quatro épocas).






	

	
	
		
			
				Você precisa passar por uma verificação para obter um nome de conta legível?
			
		

		
					

		
			
			
			
			Sim
		
			
			Não, você pode criá-lo sem verificar sua personalidade
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Considerações Finais
O ecossistema NEAR apresenta uma ampla variedade de opções de carteira, permitindo que os usuários criem e gerenciem contas NEAR sem esforço. Ele serve como um armazenamento seguro para tokens NEAR e permite stake para ganhar recompensas.

Staking NEAR oferece um método eficaz para gerar rendimento de seus tokens em um blockchain. Além disso, desempenha um papel vital no suporte à operação de redes Proof-of-Stake (PoS).

O ecossistema NEAR capacita as comunidades, facilitando oportunidades de staking. Ao fornecer interação perfeita com o blockchain NEAR por meio de diversas carteiras, ele oferece um caminho acessível para o envolvimento da comunidade.

 

### How often do you use X-Twitter?

How often you use X-Twitter?(Required)
			
					
					Every day
			
			
					
					Every week
			
			
					
					I do not have X-Twitter account
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### ¿Cómo Prepararse Para Los Cambios En La Billetera NEAR?

Cuando NEAR lanzó su red principal en 2020, también lanzó una billetera construida y alojada por el equipo central de Near Inc. (entonces Pagoda.) en https://wallet.near.org para apoyar su modelo de cuenta única. En la actualidad, el ecosistema de billeteras de NEAR cuenta con una gran variedad de billeteras de código abierto. A medida que NEAR continúa su impulso de descentralización, cambia significativamente su ecosistema de billeteras. Veamos más de cerca los cambios en cuestión, su impacto y cómo los usuarios pueden prepararse para ellos.
💡 CONSEJOS IMPORTANTES

 	Siempre haz una copia de seguridad de las frases de recuperación
 	Primero trata de migrar a una cuenta “no esencial” para probar como funciona el proceso.

Próximos Cambios
La misión de NEAR ha sido crear y apoyar un vibrante ecosistema Web3. En los próximos meses, Pagoda empezará a migrar el dominio original de la billetera NEAR de una billetera de navegador a un centro de billeteras. Esto permitirá que el dominio se convierta en un punto de referencia para todas las billeteras NEAR, permitiendo a los usuarios descubrir, seleccionar e implementar la billetera que se adapte a sus necesidades y dándoles una mayor flexibilidad mientras navegan por el espacio Web3. Se anima a los propietarios de billeteras a migrar sus cuentas a las nuevas billeteras del ecosistema, y para facilitar el proceso el equipo también ha creado tutoriales con instrucciones paso a paso.

NEAR busca crear un ecosistema próspero compuesto de múltiples billeteras. Por ello, es vital un único punto de integración para los desarrolladores que construyen sobre el protocolo. El nuevo ecosistema ofrecerá a los usuarios más de 30 opciones de billeteras, lo que facilitará a los usuarios de otros ecosistemas interactuar con la blockchain NEAR utilizando una billetera con la que ya estén familiarizados. Esta estrategia permite un próspero ecosistema de billeteras en NEAR, haciendo la Web3 tan fácil de usar como la Web2.

Transferir Tus Cuentas Desde NEAR

Si usas actualmente https://wallet.near.org como tu billetera principal, puedes usar el Wallet Transfer Wizard (Asistente de Transferencia de Billetera) para completar la migración sin comprometer tus fondos. El Asistente también te permitirá seleccionar entre billeteras basadas en navegador o en extensiones, garantizando que tengas la misma experiencia a la que estás acostumbrado incluso después de la migración.

NEAR Wallet seguirá funcionando como billetera de navegador hasta el 31 de octubre de 2023. Se recomienda a los usuarios que transfieran sus cuentas a un nuevo proveedor antes de que expire la fecha. Esto puede hacerse manualmente utilizando la frase de recuperación o el "Transfer Wizard" para migrar de forma segura las cuentas a tu billetera preferida. Además, aunque los usuarios no hayan transferido sus cuentas antes del 31 de octubre de 2023, la función de transferencia de billetera seguirá estando disponible, incluso después de que cese la operatividad de la billetera.

Vamos a observar los diferentes métodos disponibles para que los usuarios transfieran sus cuentas.
Usando la Frase de Recuperación
Importar la frase de recuperación es la forma más habitual que tienen los usuarios de transferir sus cuentas a una billetera nueva. Sin embargo, si deseas garantizar la seguridad de tus cuentas o transferir varias cuentas, te recomendamos encarecidamente que utilices el "Wallet Transfer Wizard" (Asistente de Transferencia de Billetera). Si decides seguir adelante y utilizar la frase de recuperación, primero tendrás que desactivar la autenticación de dos factores (2FA). Esto se puede hacer a través de la configuración de la cuenta en la pestaña "Security & Recovery" (Seguridad y recuperación) en el dominio actual wallet.near.org-Disable two-factor authentication in all accounts before migrating to another wallet provider (Desactivar la autenticación de dos factores en todas las cuentas antes de migrar a otro proveedor de billeteras).

Desactivar la autenticación de dos factores es fundamental porque ya no será compatible, lo que hará que tu cuenta sea inaccesible hasta que se desactive la 2FA. Sin embargo, si utilizas el Asistente de transferencia, la 2FA se desactivará automáticamente, junto con la verificación de correo electrónico y de teléfono.

Uso de Ledger

Si utilizas un Ledger para asegurar tu cuenta, tienes la opción de importar tu cuenta a billeteras soportadas por hardware como la Sender Wallet o la Nightly Wallet. Sin embargo, es esencial recordar que las cuentas protegidas por Ledger no pueden transferirse utilizando el "Transfer Wizard". De la misma forma que al migrar con la opción de Frase de Recuperación, deberás desactivar la 2FA. Para ello, acceda a " Account Settings " (Configuración de la cuenta) en la pestaña " Security & Recovery " (Seguridad y recuperación). Desactiva la 2FA en todas las cuentas antes de migrar a otro proveedor de billetera.

Usa el Wallet Transfer Wizard (muy recomendado)

El Wallet Transfer Wizard o Asistente de Transferencia de Billetera, permite a los usuarios transferir fácilmente todas sus cuentas conectadas, además ofrece un chequeo de seguridad exhaustivo para asegurar que todas las cuentas estén seguras. El Asistente también ofrece:

 	Una guía paso a paso para eliminar claves de acceso antiguas.
 	Transferencia masiva de cuentas conectadas a la billetera de tu elección.
 	Rotación de claves.

El Asistente de Transferencia ayuda a mejorar la seguridad de las cuentas conectadas antes de migrarlas a una nueva billetera. Esto lo logra rotando tus claves, limpiando claves antiguas y transfiriendo de forma segura tus cuentas. Puedes acceder al Asistente desde el banner que se encuentra en la parte superior de la página wallet.near.org.
¿Cómo funciona el Wallet Transfer Wizars?
Ahora vamos a mirar rápidamente cómo funciona el Wallet Transfer Wizard. (Asistente de Transferencia de Billetera)
Paso 1: Asegurar Tu Cuenta
Recomendamos rotar las claves y generar una nueva frase de recuperación de 12 palabras, similar a cómo actualizarías tu contraseña. Asegurar tu cuenta implica los siguientes pasos.

 	Generar una nueva frase de recuperación de 12 palabras.
 	Verificar la nueva frase de recuperación.
 	Guardar la frase de recuperación recién generada en una ubicación segura o puedes escribirla en un papel. Además, también debes confirmar la cuenta que recuperas y asegurarte de no confundirla con la frase de recuperación anterior.


Paso 2: Limpiar las Claves
El siguiente paso es limpiar tus claves. Este paso es vital porque NEAR quiere reducir el número de apps con las que se han compartido las claves. Una vez ejecutado este paso, es posible que te desconectes de algunas apps. Limpiar tus claves implica tres pasos.

 	Revisar las claves sugeridas que deseas eliminar.
 	Ingresar la frase de recuperación para confirmar la eliminación.
 	Elimina todas las claves obsoletas. Una vez completado el proceso, es posible que tengas que volver a iniciar sesión en ciertas aplicaciones si se han eliminado tus claves de acceso limitado.


Paso 3: Transferir Cuentas
Ahora, utiliza el Wallet Selector y elige la billetera a la que deseas transferir tus cuentas. La transferencia de tus cuentas implica los siguientes pasos.

 

 	Seleccionar la billetera a la que deseas transferir tus cuentas.
 	A continuación, selecciona las cuentas que deseas transferir.
 	Copia una contraseña temporal y asegura la transferencia de cuentas.
 	Introduce la contraseña en la billetera destino.
 	Completa la configuración de la billetera y la transferencia de cuentas siguiendo las instrucciones adjuntas. Esto puede variar de una billetera a otra.
 	Una vez que hayas completado todos los pasos indicados anteriormente, confirma que tienes acceso a todas tus cuentas en la nueva billetera. Una vez confirmado, vuelve a wallet.near.org y completa el proceso de transferencia.






	

	
	
		
			
				¿Cuál es el Método Recomendado para que los Usuarios Transfieran sus Cuentas?
			
		

		
					

		
			
			
			
			Uso de Ledger
		
			
			Uso de la Frase de Recuperación
		
			
			Uso de Wallet Transfer Wizard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paso 4: Cerrar sesión en Near.org
El último paso es cerrar sesión en tu billetera NEAR y comenzar a usar tu nueva billetera.

Una vez que la transferencia de cuentas se haya completado, regresa a wallet.near.org y haz clic en “Complete” (Completar)

 	Comprueba si tienes acceso a todas tus cuentas en la nueva billetera.
 	Cierra sesión en todas tus cuentas ubicadas en near.org.
 	Una vez completado, está todo listo para usar tu nueva billetera y administrar tus cuentas.


¿Cómo migrar a HERE Wallet?
Iniciar sesión a través de web wallet es la forma más fácil de exportar tu cuenta a HERE.

Solo se necesitan 3 clics.

 
Billeteras Compatibles
El Transfer Wizard es compatible con varias billeteras. Si deseas saber más sobre las billeteras compatibles o hacer una comparación, puedes consultar este Google Sheet. Algunas de las billeteras compatibles incluyen MyNearWallet, HERE Wallet, Meteor Wallet, Welldone Wallet, y Nightly Wallet.

Para terminar

Con estos cambios, NEAR está entrando en una nueva era y dando un paso significativo hacia la construcción de un ecosistema verdaderamente descentralizado, controlado e impulsado por su comunidad. Este nuevo ecosistema ayudará a mejorar la experiencia del usuario, con el centro de billeteras y el selector de billeteras, permitiendo a los usuarios seleccionar la billetera que mejor se adapte a sus necesidades, ayudando a NEAR a llevar todo el espectro de usos y experiencias Web3 a los usuarios.




	

	
	
		
			
				¿Cuáles son las Billeteras Compatibles con el Transfer Wizard?
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Update – September 7, 2023

Brief Summary:

 	
The power of (L)Earn!


After reading a Guide and trying migration at real (l)earners feel 100% confident they can do it!



Results:

 	LNC very own Sasha is running for the Council of Advisors at NEAR Digital Collective
https://near.org/nomination.ndctools.near/widget/NDC.Nomination.Candidate.Page?house=CouncilOfAdvisors&accountId=ahsas.near
📚 (L)Earn How to prepare for NEAR Wallet changes!
 	🏆July and August Redeem windows were a blast Over  $NEAR 2,000 were claimed!
 	LNC will have a booth at NEAR APAC! Come to win LNC t-shirt and other cool prizes!

 	
🧪MyNearWallet password beta test was super productive! Over 100 NEAR were awarded!
 	
💪We have 60,000 (l)earners!🕺


 	📚 (L)Earn How nCaptcha Fights Spam📚(L)Earn about Why WordPress Can Open The Gates To Web3

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Dapplets NEAR Tipping Beta Test is running!

### Dapplets NEAR Tipping Beta Test

Follow @LearnNEAR and https://twitter.com/dapplets_org on Twitter

Beta test sprint starts: September 6, 11 am ET
Beta Test sprint ends: September 10, 11 am ET
Requirements:

 	

 	Install Dapplets extension from the Chrome Extension Store to your Chrome or Brave Browser (https://chrome.google.com/webstore/detail/dapplets/pjjnaojpjhgbhpfffnjleidmdbajagdj)
 	Activate it and go to the Twitter feed page
 	Open Dapplets Extension Overlay and activate Tipping NEAR Dapplet
 	Now there is a Tip button in the bottom buttons panel of every tweet. Try to send a tip to a tweet of a content maker of your choice or even to your own tweet.


 	After the transaction is processed Tip button will change its label to the amount of tokens that were sent to that tweet.
 	Make a screenshot of that tweet with tips stored in it and tweet it with “I just have sent #NEAR tips to this tweet with @dapplets_org Near Tipping Dapplet via @LearnNEAR Beta test!” as a reply to LNC Beta test announcement in @dapplets_org account (https://twitter.com/dapplets_org/status/1698827120573608076). We will send small tips to each 1st tweet from the account, to help you test claim mechanics.
 	To get tips that were sent to your tweets go to your Twitter profile page and press the Claim button.
 	Follow the instructions to bind your Twitter account with your NEAR wallet address. A dedicated Connected Accounts dapplet will be used for this purpose.
 	After binding your accounts together all tips that were previously sent to your tweets will be sent by contract to your NEAR account. From now on, any tips will go straight to the wallet you specify, without any additional steps.
 	Check how Rebind and Unbind functions work to see how you can switch between different accounts if needed.
 	Now go to Github and search for an issue in the project you are interested in. As an example, you can do this in any Dapplets repository.
 	Since the dapplet is already enabled, each issue and its comments now have a Tip button in the header.

 	Write a comment with "Now it's easy to send a tip on an issue or comment with Tipping NEAR Dapplet"
 	Using the Tip button send a tip to your comment.
 	To get the tips that were sent to your issues or comments go to your Github profile page and press the Claim button under your avatar block.
 	You need to go through the same process with connecting your account as you did with Twitter. Just follow the on-screen instructions.
 	After binding your accounts together you get the ability to claim all tips accumulated by your to the NEAR account specified.
 	Here, also check how Rebind and Unbind functions work to see how you can switch between different accounts if needed.
 	Go back to Google Web Store, leave a comment and rate Dapplets Extension.
 	Fill and submit the feedback form

 

Notes:

We’re excited to announce that Dapplets Extension went live in the Google Extension Store. Tipping NEAR Dapplet has also been updated and now with the ability to send tokens to tweets, it is also capable of sending them to issues and comments in Github. Twitter, Github and NEAR account connection is now handled by separate Connected Accounts dapplet and there are also several UI/UX improvements.

We have launched this as a beta test programme on Learn NEAR Club to spread the word about these new features, and to allow for significant testing

Fill the Feedback form
The top 30 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic and tag @Aspiro

### Как nCaptcha помогает бороться со спамом

"nCaptcha" - это новый продукт от компании Learn Near Club, представляющий собой web3-версию классической CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart). В этой статье мы сначала узнаем, как работает традиционная CAPTCHA, а затем увидим, как nCaptcha переворачивает ее с ног на голову.
Как работает CAPTCHA?


Скачать фото

Вы наверняка сталкивались с таким изображением во время серфинга, как показано выше. Капча (Captcha) - это метод защиты сайтов и приложений от ботов и автоматических программ, созданный для различения человека от компьютера.

Как ни странно, история CAPTCHA связана с хакерами - те самые люди, от которых она призвана защищать и сегодня. В конце 1980-х и начале 1990-х годов пользователи первых интернет-форумов случайно заложили основу для CAPTCHA. Понимая, что программы-модераторы отслеживают определенные ключевые слова, они придумали способ обойти эту проверку. Эти пользователи заменяли определенные буквы в ключевых словах цифрами или символами, эффективно обманывая ботов. Эта стратегия со временем превратилась в форму жаргона, известную как leetspeak.

Однако настоящий переломный момент для CAPTCHA наступил в конце 1990-х годов, когда компьютерные ученые отметили потенциал этих текстовых искажений в борьбе с алгоритмами мошенников. Концепция приобрела более официальную форму, когда в 1997 году две отдельные команды - одна из Университета Карнеги-Меллона, а другая из компании Sanctum, занимающейся кибербезопасностью, разработали методы борьбы с ботами, использующими искаженный текст. Это ознаменовало расцвет современной CAPTCHA, ключевого инструмента безопасности, который помогает предотвратить кражу данных, создавая барьер для автоматизированных программ и позволяя проходить человеческим пользователям.

В наши дни велика вероятность того, что вы или любой другой посетитель сайта является машиной. Вредоносные интернет-боты — обычное явление в Интернете. Их можно использовать в различных целях: от создания поддельных учетных записей в социальных сетях до быстрого бронирования всех билетов на популярный концерт. Так же с их помощью легко организовать DDoS атаку— попытку сделать онлайн-сервис недоступным, переполнив его трафиком. В большинстве своём Капча была создана для защиты от такого рода ботов.
Хорошо, но как работает CAPTCHA?
Для этого система требует от пользователей пройти простой тест, подтверждающий, что они люди, а не роботы, пытающиеся взломать защищенную паролем учётную запись или устроить DDoS атаку. Этот тест состоит из двух частей:

 	Случайно сгенерированная, искаженная последовательность символов в виде изображения.
 	Поле ввода текста.

Пользователи должны определить и написать символы, изображенные на картинке, чтобы воспроизвести символы в текстовом поле. Это требует определенного уровня когнитивных способностей, которые довольно просты для человека, но чрезвычайно сложны для робота. Это связано с тем, что мы обладаем способностью интерпретировать буквы различных шрифтов и почерков. Поскольку роботы не могут этого сделать, они не проходят тест и блокируются от взаимодействия с приложением или веб-сайтом.
Google и CAPTCHA
Google реализует капчу через свою систему reCAPTCHA. Вы можете столкнуться с этими капчами от Google при следующих случаях:

 	Регистрация в новой службе Google (например, Gmail, Blogger или YouTube).
 	Подписка на любую версию аккаунта Google Workspace
 	Изменение пароля в существующем аккаунте
 	Настройка служб Google для стороннего устройства или приложения (например, iPhone, Outlook, ActiveSync и т. д.).

Google использует CAPTCHA для защиты данных пользователей и поддержания целостности сервиса. Google - не единственный гигант web2, использующий CAPTCHA. Она используется практически повсеместно и широко.

Несомненно, CAPTCHA была мощной мерой безопасности. Однако в последнее время их эффективность и полезность были поставлены под сомнение.

nCAPTCHA меняет философию применения капчи. Используя блокчейн для аутентификации пользователя, а также необходимость совершения микротранзакции для предотваращения негативного опыта как для пользователя, так и для сайта. А как именно это работает, мы расскажем далее.




	

	
	
		
			
				Какой основной метод используется nCaptcha для предотвращения спама?
			
		

		
					

		
			
			
			
			Необходимо найти объекты на фото
		
			
			Использование ИИ
		
			
			Необходимо соврешить микротранзакцию
		
			
			Блокирование всех у кого нет Google-аккаунта
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





CAPTCHA перестали быть эффективными?
Суть CAPTCHA заключается в том, что машина не должна обладать когнитивными способностями обычного человека для расшифровки этих сообщений. В основе CAPTCHA лежит частично поведенческий подход. Помимо оценки способности пользователя решить заданную головоломку, эти инструменты также отслеживают такие действия, как скорость навигации по веб-странице и кривизну движения мыши. Однако за последнее десятилетие возможности машинного обучения и искусственного интеллекта значительно развились, став более похожими на человеческие, а в некоторых случаях и превосходящими человеческие способности в решении сложных головоломок. Машины с их обширной памятью и многозадачностью часто могут без труда справляться с такими головоломками, как CAPTCHA.

Более того, появление "ферм" по решению CAPTCHA - сервисов, управляемых людьми, которые расшифровывают CAPTCHA для ботов - представляет собой еще одну проблему. С помощью этих "ферм" боты могут решать CAPTCHA в течение нескольких секунд, обходя этот уровень безопасности с минимальными затратами и усилиями.

Как же уменьшить эту проблему?

Наиболее логичным способом борьбы со взломом CAPTCHA является повышение сложности самого задания. Однако здесь есть проблема. Когда вы увеличиваете сложность CAPTCHA, вы затрудняете или, что еще хуже, раздражаете людей, которые также могут решить эту задачу. По мнению Сэнди Кариелли, главного аналитика компании Forrester, CAPTCHA могут негативно повлиять на человеческий опыт. Согласно отчету Кариелли, около 19% взрослых американцев за последний год отказались от онлайн-транзакций из-за сложных CAPTCHA.



Скачать фото

К тому же, вот в чем загвоздка. Усложнение CAPTCHA может даже не сработать.

В 2014 году компания Google испытала алгоритм на одной из своих самых сложных капч. Алгоритм успешно взломал CAPTCHA, в то время как только 33% пользователей-людей смогли ее решить.

Итак, каково же решение?

Тамер Хассан, соучредитель и генеральный директор компании HUMAN Security, занимающейся вопросами кибербезопасности, говорит следующее:

"Мы не должны тестировать наших людей; мы не должны относиться к нашим людям так, как будто они мошенники. Мы должны тестировать ботов различными способами, и поэтому увеличение трения с людьми - это не выход".

Давайте обратимся к web3 в поисках решения.
nCaptcha - борьба со спамом в сети web3
nCaptcha от Near Club - это инновационное и эффективное решение, предназначенное для борьбы со спамом на сайтах. В отличие от традиционных CAPTCHA-систем, где вы в конечном итоге раздражаете пользователей сложными текстами и изображениями, nCaptcha использует возможности web3 и технологии блокчейн для аутентификации человека.

Как владельцу сайта, использовать nCaptcha очень просто. После ее интеграции в ваш сайт ваши пользователи совершают микротранзакцию стоимостью 0,01 NEAR. Половина этой суммы идет nCaptcha, а другая половина - вам, владельцу сайта.

nCaptcha отпугивает спамеров, используя комбинацию следующих методов:

 	Требование мини-депозитов за отправку формы. Эта система мини-депозитов работает как механизм проверки, который одновременно прост для настоящих пользователей и чрезвычайно эффективен для отпугивания спамеров, которым пришлось бы совершать бесчисленные микро-транзакции, делая тем самым усилия по рассылке спама неэффективными и дорогостоящими.
 	Создание прозрачного и неизменного показателя репутации пользователя на цепочке.

Вот еще несколько моментов, которые следует помнить о nCaptcha:

 	Для использования nCaptcha вам необходимо иметь учетную запись NEAR.
 	Она легко интегрируется в WordPress с помощью специального плагина для комментариев, что делает ее универсальной и доступной для широкого круга веб-приложений.

Он также обладает высокой совместимостью с различными платформами web2, преодолевая разрыв между обычной интернет-инфраструктурой и приложениями на основе блокчейна.

Децентрализованный back-end делает его надежным и устойчивым к атакам или сбоям, характерным для централизованных систем.

Созданная на JavaScript, она поддерживается популярными браузерами, обеспечивая удобный интерфейс как для владельцев сайтов, так и для посетителей.

Он также доступен в виде пакета NPM, поддерживает мобильные устройства, полностью отзывчив и не требует никаких смарт-контрактов, что делает его еще более простым для разработчиков.




	

	
	
		
			
				Какой основной недостаток традиционных CAPTCHA устраняет nCaptcha?
			
		

		
					

		
			
			
			
			Сложность и негативный опыт от CAPTCHA
		
			
			Сложность интерпретации системы CAPTCHA
		
			
			Медленная работа системы CAPTCHA
		
			
			Создание языкого барьера из-за системы CAPTCHA
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





И как она работает?
Давайте посмотрим на nCaptcha в действии.

Чтобы использовать nCaptcha, вы должны сначала завести аккаунт Near, например Satoshi.near или xyz.near. Это не должен быть просто ваш публичный адрес. Перейдите на сайт Learn Near и войдите в систему, используя свой кошелек. Теперь перейдите на страницу "Contact with us".

Прокрутите страницу вниз, чтобы увидеть виджет nCaptcha.



Как видите, вместо того, чтобы разбираться с надоедливой каптчей, вам нужно просто подтвердить, используя микротранзакцию.

Нажмите на "Verify with nCaptcha", чтобы получить перенаправление на следующее:



Нажмите на "Approve" и завершите верификацию.



После завершения верификации вы можете нажать "Transaction" для перенаправления в Near Explorer, чтобы мы могли увидеть, что происходит за кулисами.

 

Первая половина транзакции верификации 0,01 идет на сайт (в данном случае Learn Near).



Вторая половина идет на nCaptcha.



Таким образом, мы получим систему, выгодную для всех:

 	Пользователь: не тратит время на просмотр глупых изображений.
 	Владельц сайта: отсутствие оттока пользователей от сложных изображений и заработок от платы за верификацию.
 	nCaptcha: Зарабатывает на проверке.

Эта беспроигрышная философия является основой web3.
Изменение борьбы со спамом с помощью nCaptcha
Эффективность nCaptcha заключается в ее простоте и инновационном использовании микро-транзакций web3. CAPTCHA оказались все более сложными и неэффективными. nCaptcha представляет собой элегантную альтернативу.

Вы можете скачать nCaptcha и получить дополнительную информацию здесь.




	

	
	
		
			
				Что нужно для использования nCaptcha?
			
		

		
					

		
			
			
			
			Аккаунт привязанный к почте
		
			
			Кредитная карта
		
			
			NEAR аккаунт
		
			
			Высокий уровень знаний в программировании
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Guia para principiantes na NameSky: Compre, venda e gerencie com segurança Contas NEAR como NFTs

NameSky é uma plataforma amigável que permite a negociação de contas NEAR como NFTs na blockchain NEAR. Com seus contratos inteligentes auditados pela @pessimistic_io, a NameSky garante uma experiência segura para os usuários. Você pode encontrar o relatório de auditoria aqui e explorar o mercado da NameSky para ver as contas cunhadas como NFTs.
Este guia irá ajudá-lo a navegar na plataforma NameSky, cobrindo o processo de transformar uma conta NEAR em uma NameSky NFT, verificando o NFT na página da sua carteira NEAR, listando seu NFT no mercado e recuperando o controle de uma conta NEAR queimando o NameSky NFT.
Passo nº 1: Transforme uma conta NEAR em um NFT NameSky
Para transformar sua conta NEAR em um NFT NameSky, siga estes passos:

 	Visite o NameSky e clique no “Mint” no nosso website.
 	Conecte sua carteira NEAR à plataforma NameSky.
 	Escolha a conta NEAR que você deseja transformar em um NFT NameSky.
 	Após a cunhagem, um contrato de bloqueio será implantado na conta NEAR anexada e todas as chaves de acesso serão removidas. Isso significa que apenas o proprietário do NFT (você) pode acessar a conta NEAR.




	

	
	
		
			
				Verdadeiro ou falso? Os contratos inteligentes da NameSky foram auditados.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








     
Passo nº 2: Verifique o NFT na página da sua carteira NEAR
Para visualizar seu NFT NameSky recém-cunhado:

 	Faça login na sua carteira NEAR.
 	Clique na aba “Colectibles” (colecionáveis).
 	Você verá seu NameSky NFT listado com a conta NEAR anexada.


Passo nº 3: Liste seu NFT no mercado NameSky
Para colocar seu NFT NameSky em venda:

 	Vá para à “NFT detail page” (página de pormenores).
 	Clique em “Sell” (vender).
 	Estipule o preço desejado.
 	Confirme sua listagem e seu NFT estará disponível para compra.

  
Passo nº 4: Recupere uma conta NEAR queimando o NameSky NFT
Se você deseja recuperar o controle de sua conta NEAR:

 	Visite sua página de perfil NameSky.
 	Localize o NFT NameSky que você deseja queimar.
 	Clique em “Take back the account.” (recuperar conta) no menu suspenso.
 	Uma nova frase de recuperação será gerada localmente em seu dispositivo, concedendo a você acesso à conta NEAR.
 	O NFT NameSky será queimado e você irá recuperar o controle total da conta NEAR anexada com a frase de recuperação da etapa 4 do seguinte link  https://wallet.near.org/recover-account

      

NameSky fornece uma maneira segura e fácil de comprar e vender contas NEAR como NFTs. Seguindo este guia, você poderá navegar na plataforma e gerenciar suas contas NEAR e NFTs com confiança. Esteja você procurando comprar uma conta NEAR exclusiva ou vender a sua própria, a NameSky oferece uma solução conveniente e segura para suas necessidades. Feliz (L)Earning!

Se você ainda não tem certeza sobre como o NameSky funciona, você pode testar no aplicativo testnet aqui: https://testnet.namesky.app




	

	
	
		
			
				Verdadeiro ou falso? Ao criar um NFT NameSky, todas as chaves de acesso serão removidas da conta NEAR anexada.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

 

### Desarrollo De Contratos Inteligentes En Near Usando Rust - Parte 3

Desarrollo de Contratos Inteligentes en Near usando Rust - Parte 3
Esta es la tercera parte de una serie de publicaciones sobre la creación de una aplicación de chat con Rust on the Near blockchain. Puedes encontrar las publicaciones anteriores de la serie aquí y aquí.

En esta publicación nos centraremos en las partes fuera de la cadena del código. Discutiremos la necesidad de "indexers (indexadores)" y recorreremos algunas partes de la implementación del indexador en este ejemplo. Puedes encontrar el repositorio completo con todo el código que discutiremos hoy en mi GitHub.
Indexadores, qué son y por qué los necesitamos
En términos de la cadena de bloques, un indexador es un servicio que consume datos sin procesar de una fuente (por lo general, una instancia de nodo completo co-localizada para esa cadena de bloques) y los analiza en un formato que es más útil para una aplicación específica. Por ejemplo, en el caso de nuestra aplicación de chat, el indexador consume un flujo de bloques Near y produce un flujo de eventos (por ejemplo, mensajes recibidos y solicitudes de contacto).

Los indexadores son importantes porque las bases de datos utilizadas para operar la propia cadena de bloques generalmente no están optimizadas para realizar los tipos de consultas que interesan a las aplicaciones. Por ejemplo, obtener el saldo de un usuario para un token ERC-20 en Ethereum generalmente se realiza ejecutando la consulta a través de EVM porque esa es la única forma en que la información está disponible desde un nodo típico de Ethereum. Esta es una operación extremadamente costosa en comparación con buscar una entrada en una base de datos relacional tradicional. Por lo tanto, una optimización simple para cualquier aplicación que necesite un acceso rápido a los saldos ERC-20 sería ejecutar un indexador en los datos brutos de Ethereum que llena una base de datos tradicional con los saldos (o datos) que le interesan. Luego, la aplicación usaría esta base de datos como fuente para los saldos en lugar de un nodo Ethereum directamente. Así es como funciona el explorador de bloques Etherscan; Etherscan ejecuta un indexador para llenar una base de datos que luego se usa para llenar los campos en las páginas web que sirve Etherscan.

Los indexadores no solo son importantes para Ethereum, cualquier dapp de alto rendimiento en cualquier cadena de bloques deberá incluir un indexador en algún lugar de su arquitectura. La aplicación de chat de ejemplo que hemos estado discutiendo en Near no es una excepción, así que profundicemos en cómo se implementa el indexador.
Obtener los datos sin procesar
Los indexadores solo procesan datos de blockchain en bruto (no procesados con anterioridad) en un formato que la aplicación asociada puede usar; ellos no generan los datos en primer lugar. Por lo tanto, la primera pregunta que debemos responder al crear un indexador es: ¿de dónde provienen los datos de la cadena de bloques?

Near proporciona algunas fuentes de datos diferentes, como se describe a continuación.
Ejecutar un nodo nearcore
La mejor fuente de datos (en términos de descentralización y seguridad) para cualquier cadena de bloques es la red peer-to-peer (persona a persona) de la propia cadena de bloques. Para acceder a esta fuente de datos, debe ejecutar un nodo que entienda el protocolo de la cadena de bloques. En el caso de Near, la implementación del nodo se llama nearcore. Su código fuente está abierto en GitHub. Hay documentación disponible sobre cómo ejecutar su propio nodo nearcore. La principal barrera de entrada aquí es la cantidad de espacio en disco requerido para esto; se recomienda tener 1 TB de almacenamiento dedicado para su nodo y se tarda bastante tiempo en sincronizar con la cadena como resultado de la necesidad de descargar todos esos datos.

Una vez que tengas una configuración del nodo nearcore, Near proporciona un indexer framework de indexador convenientemente creado en Rust que se puede usar para crear indexadores con nearcore como fuente de datos. Para un proyecto real, esta sería la mejor manera de crear un indexador. Sin embargo, nuestro ejemplo es solo una demostración, por lo que no queremos pasar horas descargando datos de la cadena a un servidor dedicado de 1 TB. Afortunadamente hay otras opciones.
Near data lake
Para facilitar a los desarrolladores la puesta en marcha de sus proyectos, Near creó el data lake framework (framework del lago de datos) como una fuente alternativa de datos para que la utilicen los indexadores. El framework del lago de datos se basa en el framework del indexador mencionado anteriormente, utilizando un nodo nearcore como fuente de datos. El indexador que alimenta el lago de datos no está procesando los datos para una aplicación específica, simplemente está pasando los datos para almacenarlos en el almacenamiento de AWS S3. Sin embargo, esto permite a los desarrolladores obtener acceso a estos datos utilizando su propia cuenta de AWS y luego crear sus propios indexadores para proyectos en específico utilizando este almacenamiento S3 como fuente de datos.

La ventaja de esto para los desarrolladores es que este método es mucho más rápido para que funcione. Sin embargo, la desventaja es que los datos provienen de una fuente centralizada y, por lo tanto, en teoría, es más fácil corromperlos que usar la red punto a punto directamente.

El acceso al lago de datos requiere que pagues por los recursos de AWS que se utilizan para entregarte esos datos. Una vez más, a los efectos del ejemplo de la aplicación de chat, no quiero que las personas se registren en AWS y gasten dinero para ejecutar el indexador. Por lo tanto, elegí la opción de fuente de datos final.
Nodos RPC públicos
La forma final de acceder a los datos de la cadena de bloques, si no estás ejecutando tu propio nodo o accediendo al almacén de datos preconstruido de otra persona, es usar los nodos de otra persona. Los nodos RPC son nodos en la red blockchain que están destinados a atender las solicitudes de los usuarios. Cada cadena de bloques tiene proveedores de nodos RPC (algunos gratuitos, otros de pago). Puedes encontrar una lista de los proveedores de RPC para Near aquí.

Esta es la forma menos eficiente de acceder a los datos de la cadena de bloques porque se necesitan varias solicitudes de RPC para obtener los datos que suelen utilizar los indexadores. Cada solicitud de RPC incurre en latencia de red, lo que hace que el indexador sea lento para responder a los eventos que ocurren en la cadena. La única ventaja de este enfoque es que es gratis configurar una demostración siempre que haya un proveedor de RPC gratuito para la cadena (como es el caso de Near). Por lo tanto, esta es la fuente de datos que usa el indexador en nuestro ejemplo.

Dicho todo esto, al indexador en sí mismo no le importa de dónde provienen sus datos. En consecuencia, aunque nuestro ejemplo utiliza la peor fuente de datos, vale la pena explorar su implementación porque los conceptos que utiliza este indexador son los mismos que los de un indexador creado con el lago de datos de Near o frameworks de indexación basados en nodos.
Implementación del indexador
Nuestro indexador está construido como una aplicación de tokio en Rust. Tokio es un framework de Rust para escribir aplicaciones de alto rendimiento donde las operaciones de I/O (Entrada / Salida, por sus siglas en inglés) son el principal cuello de botella. Nuestro indexador es una aplicación de este tipo porque el cálculo real que realiza es extremadamente rápido en comparación con el tiempo que lleva solicitar datos de los nodos RPC. Las características principales de tokio son que utiliza pimitivos asincrónicos sin bloqueo y tiene multithreading incorporado para permitir la ejecución en paralelo. Y además está en Rust, por lo que, naturalmente, tiene las garantías de concurrencia segura y memoria segura que proporciona Rust.

Si tokio es el escenario en el que se establece nuestra aplicación, lo que sigue son los actores de la obra (juego de palabras intencionado; esta aplicación sigue el modelo de actor, pero elijo hacerlo directamente en tokio en lugar de usar una biblioteca como actix porque creo que los canales de tokio proporcionan una tipificación más fuerte que los mensajes genéricos utilizados en la mayoría de los frameworks de actores).

El indexador tiene cuatro roles principales: el administrador, el descargador de bloques, el descargador de fragmentos y el manejador de recibos.
El administrador
El proceso del administrador es supervisar todo el indexador. Es responsable de delegar trabajo a los otros procesos y decirles que se apaguen cuando el programa se está cerrando (por ejemplo, en el caso de que se encuentre un error). Por ejemplo, el administrador maneja el equilibrio de carga de los descargadores de fragmentos, alternándolos cuando asigna un fragmento para descargar.
El descargador de bloques
Como su nombre lo indica, el propósito del proceso de descarga de bloques es descargar bloques. Sondea periódicamente el Near RPC para verificar si hay bloques nuevos y, si los hay, los descarga y los envía al administrador. Si no usáramos el RPC como nuestra fuente de datos, este proceso se reemplazaría con una conexión a un nodo de Near o al lago de datos.
Los descargadores de fragmentos
En Near, los bloques no contienen datos sobre transacciones; los fragmentos sí. Los bloques solo brindan información sobre qué nuevos fragmentos están disponibles. La razón de esto es la fragmentación de Near (puede leer más sobre eso aquí). Por lo tanto, necesitamos procesos separados para descargar los datos de fragmentos para cada bloque. Los descargadores de fragmentos cumplen esta función. Nuestro indexador tiene varias instancias de descarga de fragmentos para permitir la descarga de fragmentos en paralelo.

Si no estuviéramos usando el RPC como nuestra fuente de datos, dependiendo de cómo se tengan en cuenta los datos en la fuente de datos que estuviéramos usando, es posible que estos procesos no necesiten existir (por ejemplo, el near-indexer-framework incluye todos los datos de bloques y fragmentos en un mensaje único). Pero para nuestro caso, dado que estamos usando el RPC, estos procesos son necesarios.
El manejador de recibos
Los fragmentos contienen "recibos" que se crean cuando se procesa una transacción. Cuando el administrador recibe un nuevo fragmento de un descargador de fragmentos, envía todos los recibos al proceso del controlador de recibos (podríamos tener varias instancias del controlador de recibos para procesar los recibos en paralelo, al igual que tenemos varios descargadores de fragmentos, pero el procesamiento de recibos es lo suficientemente rápido como para no suponer que esto añadiera una gran mejora en el rendimiento). Este proceso filtra los recibos solo a los que nos interesan, luego descarga el resultado de la ejecución de los recibos y finalmente procesa los eventos de esos resultados. En el caso de este ejemplo, simplemente escribimos los eventos en un archivo (para una demostración en vivo, puedes ver el archivo con algo como el comando tail -f de Unix para ver cómo entran los eventos), pero puedes imaginar que una implementación de producción podría reenviar estos eventos como notificaciones automáticas a una versión móvil de la aplicación.
Observaciones
Puedes notar a lo largo del código del indexador que existe cierta complejidad en el envío de fragmentos/recibos con el hash de bloque después del bloque que incluía esos fragmentos. Esta es una peculiaridad de Near RPC donde quiere saber que estás al tanto de los bloques posteriores para servir al resultado de la ejecución. Nuevamente, esto se manejaría mucho mejor si se usara una mejor fuente de datos.

Es intencional que no haya panics (“panic” de RUST, para detener una función) en ninguna de las funciones del actor. Cuando encuentran un error, lo registran y envían un mensaje de apagado al administrador (y el administrador lo envía a todos los demás actores). Esto es importante porque entrar en pánico en una aplicación de subprocesos múltiples puede causar un comportamiento inesperado (en general, Tokio es bastante bueno para deshabilitar toda la aplicación con eficacia, pero aún es mejor codificar a la defensiva).
Conclusión
En esta publicación, discutimos por qué los indexadores son importantes para las dapps del mundo real y analizamos algunos de los detalles del indexador de ejemplo implementado para la dapp de chat. Al igual que en la publicación anterior, hay ejercicios en el código del indexador incluidos en los comentarios etiquetados como EXERCISE. Te aliento a que pruebes estos ejercicios si deseas tener experiencia práctica con el código base.
Acerca de la Serie
Esta es la publicación final de esta serie. En la Parte 1, analizamos los principios generales del desarrollo de contratos inteligentes y cómo se aplican a un contrato de ejemplo para una dapp de chat. En la Parte 2, profundizamos en cómo usar near-sdk para escribir contratos inteligentes para Near en Rust. Finalmente, esta publicación discutió cómo se necesitan indexadores para integrar los datos de la cadena de bloques con los componentes fuera de la cadena de nuestra aplicación.

Una parte final del código que no cubrí es la prueba de integración. La prueba de integración usa la librería near-workspaces para simular la cadena de bloques localmente y usa el mismo estilo de Rust asíncrono que el indexador. Aunque las pruebas de integración no son especialmente llamativas o interesantes, son importantes para garantizar que tu contrato funcione correctamente. Te animo a que eches un vistazo a las pruebas de integración para el contrato de mensajería y pruebes el ejercicio allí para obtener algo de experiencia práctica en esa área también.

If you have enjoyed this series of blog posts, please get in touch with us at Type-Driven consulting. We are happy to provide software development services for dapps, as well as training materials for your own engineers.

Si has disfrutado de esta serie de publicaciones de blog, comunícate con nosotros en la consultoría Type-Driven. Nos complace brindar servicios de desarrollo de software para dapps, así como materiales de capacitación para tus propios ingenieros.

 

### Meta Pool, Módulo 3 – Finanzas Descentralizadas x Meta Pool

Ecosistema DeFi con Meta Pool
Las Finanzas Descentralizadas (DeFi) son una nueva manera de operar finanzas basadas en la tecnología blockchain. Estas finanzas utilizan los contratos inteligentes para almacenar, bloquear, compartir, adquirir y acumular tokens. Las DeFi pretenden restar el control que los bancos centrales tienen sobre los fondos o activos y distribuirlos a través de contratos inteligentes.

Meta Pool es un contrato inteligente emisor de activos que no requiere permisos ni custodia y que permite unir tokens NEAR y recompensas de staking en un único token llamado staked NEAR (stNEAR).

stNEAR permite a sus titulares mover el valor de los tokens que están en stake y las recompensas en el ecosistema DeFi de múltiples cadenas, incluidas NEAR y Aurora.




	

	
	
		
			
				Las Finanzas Descentralizadas pueden tener parte de su funcionamiento gestionado por entidades centralizadas. No todas las DeFi están descentralizadas al 100%.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Haz Puente con tokens stNEAR entre NEAR <> Aurora – Rainbow Bridge
Meta Pool utiliza el Rainbow Bridge para transferir tokens $META y stNEAR entre NEAR y la Red Aurora, esto te permite utilizar tus tokens Meta Pool en Aurora dApps, como Trisolaris, WannaSwap, etc.

Moviendo stNEAR y $META a Aurora usando el Rainbow Bridge

Usando https://rainbowbridge.app/ puedes conectar tu billetera NEAR y tu billetera MetaMask para transferir tus tokens:

  

¿Cómo añadir contratos $META stNEAR a la cartera MetaMask?

Para añadir un token de una transferencia anterior del Rainbow Bridge a MetaMask en Aurora Mainnet, haz clic en “Scan transfer history” (Escanear historial de transferencias) en el Bridge y selecciona “Add token to MetaMask” (Añadir token a MetaMask).

Para añadir un token manualmente, busca la dirección del token en la lista de tokens compatibles. Recuerda que tienen una dirección diferente en Aurora Mainnet respecto a Ethereum.

$META en Aurora 0xc21ff01229e982d7c8b8691163b0a3cb8f357453

stNEAR en Aurora 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30

(VIDEO) How transfer stNEAR to Aurora. Liquidity Minings Opportunities (NEAR Protocol, Aurora) / Cómo transferir stNEAR a Aurora. Oportunidades de extracción de liquidez : https://www.youtube.com/watch?v=_o–5GY5G0w




	

	
	
		
			
				Una vez hecho el puente de un token del Protocolo NEAR a Aurora es imposible volver a tenerlo en la cadena original.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Swap tokens en Aurora – Trisolaris
El Swap es el proceso en el que intercambias un token por otro según el valor dado por las condiciones del mercado o del pool. De esta forma puedes conseguir tokens que quieras guardar o buscar un token que te interese utilizar en una aplicación concreta.

Trisolaris es el Dex nº 1 en el motor Aurora, una blockchain compatible con EVM que funciona en el ecosistema Near.

¿Cómo hacer swap en Trisolaris?

 	Ve a la sección Trisolaris Swap y conecta tu billetera MetaMask con Aurora Network.



 	Ingresa el monto para hacer swap
 	Aprueba y confirma la transacción




	

	
	
		
			
				Puedes utilizar el enrutamiento para hacer swap a un token en el que no haya un fondo de liquidez directo.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Añadir liquidez a los swap pools de stNEAR - Trisolaris
Como las emisiones de tokens no están gestionadas por un exchange descentralizado, los pools para hacer swap necesitan usuarios que aporten liquidez para poder realizar un swap.

De esta forma, puedes convertirte en un proveedor de liquidez, poniendo el par de tokens necesarios en un pool. A cambio, recibes una fracción de las comisiones generadas por ese pool.

 	Ve a la sección Pool y haz clic en el botón “add liquidity” (añadir liquidez).



 	Selecciona el par al que quieres añadir liquidez. En Trisolaris puedes encontrar el pool stNEAR <> wNEAR.



 	Confirma el saldo y pulsa el botón “add” (añadir).



Swap de tokens en el Protocolo NEAR - Ref Finance
1. Ve a Ref Finance y conecta tu billetera NEAR.

2. Ve a la sección de Swap.



3. Selecciona los tokens a intercambiar y marca “Price impact” (Impacto del precio), “Swap rate” (Tasa de de Swap) y “Minimum received” (Mínimo recibido) en el menú “Details” (Detalles). Decide si este swap es adecuado para ti.

4. Introduce la cantidad para el swap.

5. Pulse el botón Swap, confirma y firma la transacción.

De este modo, se puede conseguir tokens $META y stNEAR en Ref Finance.
Añadir liquidez a los pools de swaps de stNEAR - Ref Finance
Ref Finance es el principal Exchange Descentralizado en el Protocolo NEAR. Proporciona un conjunto de herramientas DeFi que utilizan el estándar NEP-141 de NEAR.

 	Ve a “pools”, busca “pools stNEAR” y elige el pool al que quieras añadir liquidez.



 	Haz clic en el botón Add Liquidity (Añadir liquidez).



 	Selecciona la cantidad de tokens que quieres añadir en liquidez al pool.



Una vez hecho esto, podrás recibir una parte de las comisiones generadas por el pool.




	

	
	
		
			
				Ser proveedor de liquidez implica que tus tokens corren el riesgo de ser liquidados.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pedir prestado usando stNEAR - Burrow Cash
Pedir prestado significa que pides tokens dando un token de garantía. Recibes una fracción del valor de tu garantía (sobrecolateralización) para recibir el token solicitado en Burrow.

Si quieres recuperar tus tokens tienes la opción de pagar tu deuda.

En caso de que tu garantía pierda valor, será liquidada automáticamente por la plataforma de préstamo y te quedarás sólo con tus tokens prestados, sin la opción de recuperarlos.

 	Ve a BurrowCash
 	Conecta tu billetera NEAR
 	Sigue a stNEAR en la página “Deposit” (Depósito)



Depositar stNEAR:

 	Ingresa la cantidad de stNEAR
 	Utilízalo como garantía si quieres pedir un préstamo
 	Envía y firma la transacción



¿Cómo pedir prestado?



 	Seleccionar el activo a pedir prestado.
 	Introduce la cantidad a pedir prestada, teniendo en cuenta el ‘Health Factor’ resultante.
 	Envía y firma la transacción.



¿Cómo pagar?



 	Ve a Portfolio
 	Para pagar los activos prestados, pulse el botón “Repay” (Reembolsar).



¿Cómo retirar ?



 	Ve a Portfolio
 	Para retirar los activos suministrados, pulse “Withdraw” (Retirar).






	

	
	
		
			
				Pedir prestado dinero en efectivo está disponible en cualquier país del mundo.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pedir prestado utilizando stNEAR - Aurigami
Arugami te permite solicitar un préstamo de tokens en la Red Aurora. Para ello puedes utilizar tokens stNEAR.

En el momento de escribir esto, puedes ir directamente al tablero de mandos de Aurigami y hacer clic en supply (suministro) para token stNEAR. Si ya tienes una garantía, puedes hacer clic en “borrow” (pedir prestado).



La opción supply (suministro) te dará un apartado donde puedes depositar el stNEAR. Una vez elegido haz clic en Approve (Aprobar) stNEAR.



Permite el uso de stNEAR como garantía para solicitar un préstamo. Confirma la transacción en tu billetera.



Selecciona el token que deseas pedir prestado y haz clic en el botón “Borrow” (Pedir prestado).



Selecciona la cantidad de tokens que quieres tener en préstamo. ATENCIÓN: si solicitas el 100% corres un alto riesgo de ser liquidado.



Cuando quieras recuperar tus stNEAR, ve a reembolsar y devuelve todos los tokens que has conseguido pidiendo prestado.



Leveraged Yield Farming (Farming de Rendimiento apalancado) - Pembrock
Es la primera aplicación de farming de rendimiento apalancado en el protocolo NEAR. Dentro de esta aplicación puedes encontrar mecanismos de préstamo, farming y staking. stNEAR está permitido como token para usar en PembRock.



Hacer Farming con stNEAR-wNEAR

Deposita stNEAR y toma prestado wNEAR en el "farm pool". Elige la cantidad de activos a utilizar como garantía y el nivel de apalancamiento. Verifica el resumen de la operación.



Prestar stNEAR

Elige la cantidad de tokens stNEAR que deseas prestar. Estos activos son utilizados por los "farmers" de rendimiento para apalancar sus criptoactivos.



Para más información sobre el funcionamiento de Pembrock, consulta el siguiente enlace: https://docs.pembrock.finance/education/how-to-guides




	

	
	
		
			
				El "Leveraged Yield Farming" puede implicar un riesgo de liquidación de tus tokens.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Staking de NEAR en la Red Aurora
Hemos hecho que sea fácil para los usuarios de Aurora hacer stake de wNEAR directamente desde Aurora usando MetaMask. Aprovechando la capacidad del Rainbow Bridge para realizar llamadas de contrato entre Aurora y NEAR, hemos creado una solución sencilla que mantiene la misma interfaz de usuario y experiencia que la solución nativa de NEAR.



Es fácil distinguir en qué red te encuentras, ya que tiene el logotipo de Aurora, y cada red automáticamente, te pedirá que conectes tu billetera Metamask.

Estamos aprovechando el Rainbow Bridge para automatizar todos los pasos que los usuarios habrían tenido que realizar manualmente: entre bastidores estamos enviando wNEAR desde Aurora a NEAR Mainnet, desenvolviéndolo, depositando NEAR en Meta Pool, recibiendo stNEAR y enviando stNEAR de vuelta a través del Rainbow Bridge a la billetera Aurora del usuario.

Nuestro código ha sido auditado por Blocksec. Allí se encuentran las auditorías, así que hacemos todo lo posible para mantener los activos seguros.

La comisión por depósito en Aurora es del 0,1%, ya que Meta Pool tiene que pagar tasas de transacción en el bridge de ida y vuelta, que cubren esas tarifas.

 

### Как подготовиться к изменениям NEAR Wallet

Когда в 2020 году NEAR запустил mainnet, он также запустил кошелек, созданный и размещенный основной командой Near Inc. (тогда Pagoda) на сайте https://wallet.near.org для поддержки уникальной модели аккаунтов. Сегодня в экосистеме кошельков NEAR работает множество кошельков с открытым исходным кодом. Продолжая держать курс на децентрализацию, NEAR существенно меняет свою экосистему кошельков. Рассмотрим подробнее, о каких изменениях идет речь, каковы их последствия и как к ним подготовиться пользователям.
ВАЖНЫЙ СОВЕТ

 	Всегда создавайте резервную копию фразы восстановления
 	Сначала попробуйте перенести "несущественную" учетную запись, чтобы проверить, как работает этот процесс

Грядущие изменения
Миссия NEAR заключалась в создании и поддержке динамично развивающейся экосистемы Web3. В течение следующих нескольких месяцев компания Pagoda начнет переносить домен оригинального кошелька NEAR с браузерного кошелька на кошелек-хаб. Это позволит домену стать точкой отсчета для всех кошельков NEAR, что даст пользователям возможность обнаружить, выбрать и внедрить кошелек, соответствующий их требованиям, и обеспечит им большое удобство при работе с пространством Web3. Владельцам кошельков предлагается перенести свои аккаунты на новые кошельки экосистемы, а для упрощения этого процесса команда создала учебные пособия с пошаговыми инструкциями.

NEAR стремится создать процветающую экосистему, состоящую из множества кошельков. Для этого необходима единая точка интеграции для разработчиков, создающих протокол. Новая экосистема будет предлагать пользователям более 30 вариантов кошельков, что позволит пользователям из других экосистем легко взаимодействовать с блокчейном NEAR, используя уже знакомый им кошелек. Такая стратегия позволяет создать процветающую экосистему кошельков на NEAR, делая Web3 таким же простым в использовании, как и Web2.
Перенос счетов из NEAR
Если в настоящее время вы используете https://wallet.near.org в качестве основного кошелька, вы можете воспользоваться Wallet Transfer Wizard для завершения переноса без риска для ваших средств. Wizard также позволит вам выбрать между кошельками на базе браузера и расширений, что обеспечит вам привычную работу и после переноса.

NEAR Wallet продолжит функционировать в качестве браузерного кошелька до 31 октября 2023 года. Пользователям рекомендуется перевести свои учетные записи к новому провайдеру до истечения этого срока. Это можно сделать вручную, используя фразу восстановления, или с помощью Transfer Wizard, который безопасно перенесет счета на выбранный кошелек. Кроме того, даже если пользователи не переведут свои счета до 31 октября 2023 года, переводной кошелек будет по-прежнему доступен даже после прекращения функционирования кошелька.

Рассмотрим различные способы перевода счетов, доступные пользователям.
Использование фразы восстановления
Импорт фразы восстановления - наиболее привычный для пользователей способ переноса счетов на новый кошелек. Однако, если вы хотите обеспечить безопасность своих аккаунтов или перенести несколько аккаунтов, мы настоятельно рекомендуем воспользоваться Wallet Transfer Wizard. Если вы решили использовать фразу восстановления, то сначала вам необходимо отключить двухфакторную аутентификацию (2FA). Это можно сделать в настройках учетной записи на вкладке "Безопасность и восстановление" на текущем домене wallet.near.org - Отключить двухфакторную аутентификацию на всех счетах перед переходом к другому провайдеру кошельков.

Отключение двухфакторной аутентификации очень важно, поскольку она больше не будет поддерживаться, что сделает вашу учетную запись недоступной до тех пор, пока 2FA не будет отключена. Однако, если вы воспользуетесь мастером переноса, он автоматически отключит 2FA, а также проверку по электронной почте и телефону.
Ledger
Если вы используете Ledger для защиты своего счета, у вас есть возможность импортировать его в поддерживаемые аппаратным обеспечением кошельки, такие как Sender Wallet или Nightly Wallet. Однако необходимо помнить, что защищенные с помощью Ledger счета не могут быть перенесены с помощью мастера Transfer Wizard. Так же как и при переносе с использованием опции "Фраза восстановления", необходимо отключить 2FA. Это можно сделать, зайдя в раздел "Настройки учетной записи" на вкладке "Безопасность и восстановление". Отключите 2FA на всех счетах перед переносом к другому провайдеру кошельков.
Использование Wallet Transfer Wizard (настоятельно рекомендуется)
Wallet Transfer Wizard позволяет беспрепятственно перенести все подключенные к нему аккаунты и обеспечивает тщательную проверку безопасности, чтобы убедиться в сохранности всех счетов. Wallet Transfer Wizard также предоставляет:

 	Пошаговое руководство по удалению старых ключей доступа.
 	Массовый перенос подключенных учетных записей на выбранный вами кошелек.
 	Ротация ключей.

Wallet Transfer Wizard позволяет повысить безопасность подключенных учетных записей перед их переносом на новый кошелек. Для этого производится ротация ключей, очистка старых ключей и безопасный перенос учетных записей. Доступ к мастеру можно получить с баннера в верхней части страницы wallet.near.org.




	

	
	
		
			
				Какой самый знакомый способ переноса аккаунта для юзеров?
			
		

		
					

		
			
			
			
			Использовать фразу восстановления
		
			
			Использовать Ledger
		
			
			Использовать Wallet Transfer Wizard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как работает Wallet Transfer Wizard?
Теперь кратко рассмотрим, как работает мастер перевода кошелька.
Шаг 1: Защита учетной записи
Мы рекомендуем чередовать ключи и генерировать новую фразу восстановления из 12 слов, аналогично тому, как вы обновляете свой пароль. Защита учетной записи включает в себя следующие шаги.

 	Сгенерируйте новую фразу восстановления из 12 слов.
 	Проверить новую фразу восстановления.
 	Сохранить сгенерированную фразу восстановления в надежном месте или записать ее на бумаге. Кроме того, необходимо подтвердить восстанавливаемую учетную запись и убедиться, что вы не перепутали ее со старой фразой восстановления.


Шаг 2: Очистка ключей
Следующий шаг - очистка ключей. Этот шаг очень важен, поскольку NEAR стремится уменьшить количество приложений, которым были переданы ключи. После выполнения этого шага возможно отключение от некоторых приложений. Очистка ключей включает в себя три этапа.

 	Просмотрите предложенные ключи, которые необходимо удалить.
 	Введите фразу восстановления для подтверждения удаления.
 	Удалите все устаревшие ключи. После завершения очистки может потребоваться повторный вход в некоторые приложения, если были удалены ключи ограниченного доступа.


Шаг 3: Перенос счетов
Теперь воспользуйтесь выбором кошельков и выберите кошелек, на который вы хотите перевести свои счета. Перевод счетов включает в себя следующие шаги.

 	Выберите кошелек, на который вы хотите перевести свои счета.
 	Затем выберите счета, которые необходимо перевести.
 	Скопируйте временный пароль для защиты перевода счетов.
 	Введите пароль в кошелек назначения.
 	Завершите настройку кошелька и перевод счетов, следуя прилагаемым инструкциям. Однако в разных кошельках этот этап может отличаться.
 	Выполнив все перечисленные выше действия, убедитесь, что в новом кошельке у вас есть доступ ко всем счетам. После подтверждения вернитесь на сайт wallet.near.org и завершите процесс перевода.






	

	
	
		
			
				Какой способ переноса аккаунтов является рекомендованным?
			
		

		
					

		
			
			
			
			Использовать Ledger
		
			
			Использовать фраз восстановления
		
			
			Использовать Wallet Transfer Wizard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Шаг 4: Выход из системы Near.org
Последний шаг - выход из кошелька NEAR и начало использования нового кошелька.

 	После завершения перевода счета вернитесь на сайт wallet.near.org и нажмите кнопку "Завершить".
 	Проверьте, есть ли у вас доступ ко всем счетам в новом кошельке.
 	Выйдите из всех учетных записей, расположенных на сайте near.org.
 	После этого вы сможете пользоваться новым кошельком и управлять своими счетами.


Как перейти на HERE Walet
Вход в систему через веб-кошелек - самый простой способ экспортировать свой счет в HERE.

Это займет всего 3 клика!

https://youtu.be/j2JFDJnUiCc

Поддерживаемые кошельки

Transfer Wisard поддерживает несколько кошельков. Если вы хотите узнать больше о поддерживаемых кошельках или провести сравнение, вы можете обратиться к этому листу Google. К числу поддерживаемых кошельков относятся MyNearWallet, HERE Wallet, Meteor Wallet, Welldone Wallet и Nightly Wallet.
В заключении
С этими изменениями NEAR вступает в новую эру и делает значительный шаг к созданию действительно децентрализованной экосистемы, контролируемой и управляемой сообществом. Эта новая экосистема будет способствовать повышению удобства работы пользователей: хаб кошельков и выбор кошельков позволят пользователям выбрать кошелек, наиболее соответствующий их потребностям, что поможет NEAR предоставить пользователям весь спектр возможностей использования и опыта Web3.




	

	
	
		
			
				Какие кошельки поддерживаются системой Transfer Wizard?
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Все выше перечисленные
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Аккаунт NEAR – Экспресс-гайд

Знакомство с учетной записью NEAR

 	NEAR использует имена (домены) аккаунтов, которые легко читаются человеком в формате name.near. Например, maria.near или jane.near.
 	Система учетных записей NEAR похожа на систему доменов веб-сайтов в том смысле, что учетная запись может создавать столько суб-учетов, сколько необходимо. Например, аккаунт с именем maria.near может создать аккаунт типа sub.maria.near, а он, в свою очередь, может создать аккаунты first.sub.masha.near, second.sub.maria.near и так далее.
 	NEAR Wallet (https://wallet.near.org/) (кошелек протокола NEAR), NEAR Faucet (https://faucet.paras.id/) (кран для пользователей Ethereum и Metamask) или near-cli (https://github.com/near/near-cli) (интерфейс командной строки, предоставляющий функциональность для интеграции NEAR) могут быть использованы для создания аккаунта.
 	В NEAR можно создать аккаунт и отправить его другу или подписчику в подарок с помощью сервиса https://nearnames.com.
 	Информацию об аккаунте можно проверить в NEAR Explorer (https://explorer.near.org/), а также в NEAR Wallet.
 	Помимо видимых аккаунтоа (тип name.near), экосистема NEAR также поддерживает создание невидимых счетов с помощью near-cli (они похожи на адреса Bitcoin и Ethereum). Подробное руководство на английском языке вы можете найти здесь.
 	Каждый аккаунт в системе может иметь только 1 смарт-контракт. Для приложений, которые требуют от пользователя использования нескольких смарт-контрактов, можно использовать дочерние аккаунты. Например, contract_1.maria.near, contract_2.maria.near и т.д.
 	В экосистеме NEAR существуют аккаунты разработчиков (https://docs.near.org/docs/concepts/account#dev-accounts). Их особенность заключается в том, что они созданы для тестирования и отладки смарт-контрактов.

УЧЕТНАЯ ЗАПИСЬ NEAR - Ключи

 	NEAR, как и большинство других блокчейнов, основан на криптографии с открытым ключом. Она опирается на пары ключей, каждая из которых состоит из открытого ключа (публичный ключ) и закрытого ключа (приватный ключ).
 	Открытый ключ используется в NEAR для идентификации, а закрытый - для подписания транзакций (подтверждение принадлежности счета при создании транзакции).
 	В NEAR существует 3 типа ключей. Ключи доступа предназначены для подписания транзакций со счета, ключи валидатора позволяют выполнять операции, связанные с проверкой сети, ключи ноды (сетевой ноды) позволяют осуществлять низкоуровневое взаимодействие между нодам сети.
 	Ключи могут храниться в 3 различных хранилищах. InMemoryKeyStore - хранилище в памяти, используется для временных сценариев. BrowserLocalStorageKeyStore - незашифрованное локальное хранилище браузера, используется для работы с приложениями в браузере. UnencryptedFileSystemKeyStore - незашифрованное хранилище в файловой системе, используется при работе с near-cli.
 	Учетная запись может иметь несколько ключей доступа или не иметь ни одного.
 	Ключи могут иметь различные уровни доступа - FullAccess (полный доступ) или FunctionCall (только возможность вызова методов контракта).
 	Все ключи уникальны в рамках одного аккаунта, но открытый ключ может быть назначен разным аккаунтам с разными уровнями доступа. Уровень доступа определяет, какие действия в учетной записи могут быть выполнены с помощью данного ключа.
 	Для уровня доступа FullAccess доступны все 8 типов действий: CreateAccountAction (создать аккаунт), DeployContractAction (развернуть контракт), FunctionCallAction (вызвать методы контракта), TransferAction (отправить токены на другой аккаунт), StakeAction (закрепить токены), AddKeyAction (добавить ключ в аккаунт), DeleteKeyAction (удалить ключ аккаунта), DeleteAccountAction (удалить аккаунт).
 	Для уровня доступа FunctionCall доступно только действие FunctionCallAction (вызов методов контракта). Кроме того, для такого ключа можно указать, какие методы контракта он может вызывать.

 

### Como nCaptcha enfrenta o Spam

“nCaptcha” é o produto mais recente do Learn Near Club, fornecendo uma versão web3 do clássico CAPTCHA (teste de Turing público completamente automatizado para diferenciar computadores e humanos). Neste blog, primeiro aprenderemos como funciona o CAPTCHA tradicional e depois veremos como o nCaptcha vai mais além.

Como funciona o CAPTCHA?


Crédito da imagem

Você deve ter se deparado com a imagem acima durante suas navegações pela web. O CAPTCHA foi criado como uma medida de segurança para ajudar a proteger os usuários contra spam e descriptografia de senha.

Curiosamente, a história do CAPTCHA está ligada aos hackers, o mesmo grupo que pretende evitar hoje. Lá pelo final dos anos 80s e início dos anos 90s, os primeiros usuários de fóruns da Internet inadvertidamente lançaram as bases para os CAPTCHAs. Percebendo que os programas moderadores monitoravam certas palavras-chave sensíveis, eles criaram um método para contornar esse escrutínio. Esses usuários substituíram letras específicas em palavras-chave sensíveis por números ou símbolos, enganando efetivamente os bots. Essa estratégia acabou evoluindo para uma forma de gíria conhecida como leetspeak.

No entanto, o verdadeiro ponto de virada para os CAPTCHAs ocorreu no final da década de 90, quando cientistas da computação notaram o potencial dessas distorções de texto para frustrar os algoritmos dos scammers. O conceito adquiriu um estilo mais formal quando duas equipes separadas, uma da Carnegie Mellon University e outra da empresa de segurança cibernética Sanctum, desenvolveram métodos para impedir que os bots usassem texto distorcido em 1997. Isso marcou o surgimento do CAPTCHA moderno, uma ferramenta tipo chave de segurança que ajudava a evitar o roubo de dados, fornecendo uma barreira para programas automatizados, permitindo a passagem somente a usuários humanos.
Tá, mas como é que o CAPTCHA funciona?
O sistema faz isso exigindo que os usuários passem por um teste simples, verificando se são humanos, e não computadores tentando violar uma conta protegida por senha. Este teste consiste em duas partes:

 	Uma sequência distorcida de caracteres é gerada aleatoriamente em forma de imagem.
 	Uma caixa de entrada de texto.

Os usuários devem identificar os caracteres mostrados na imagem para inseri-los em uma caixa de texto. Isso requer um certo nível de habilidade cognitiva que é bastante simples para um ser humano, mas extremamente complexa para os bots. Isso ocorre porque temos a capacidade de identificar as letras mesmo que estejam em diferentes fontes e ou caligrafias. Como os bots não conseguem fazer isso, eles falham no teste e são impedidos de interagir com o aplicativo ou site.
Google e CAPTCHA
O Google implementa o CAPTCHA por meio de seu sistema CAPTCHA. Você pode encontrar esses CAPTCHAs desenvolvidos pelo Google nas seguintes circunstâncias:

 	Ao registrar-se em um novo serviço do Google (como Gmail, Blogger ou YouTube).
 	Ao inscrever-se em qualquer versão de uma conta do Google Workspace.
 	Ao alterar a senha em uma conta existente.
 	Ao configurar os serviços do Google para um dispositivo ou aplicativo de terceiros (como iPhone, Outlook, ActiveSync etc.).

O Google usa o CAPTCHA para proteger os dados do usuário e manter a integridade do serviço. O Google não é o único gigante da web 2 que utiliza o CAPTCHA. É amplamente utilizado em, praticamente, todas partes.

Não há dúvida de que o CAPTCHA tem sido uma poderosa medida de segurança. No entanto, tanto a sua eficácia como a sua utilidade atual foram questionadas.




	

	
	
		
			
				Qual é o principal método usado pelo nCaptcha para evitar spam?
			
		

		
					

		
			
			
			
			Requer que os usuários identifiquem objetos em imagens
		
			
			Ele usa IA para detectar comportamentos suspeitos
		
			
			Requer que os usuários façam um mini-depósito para envios de formulários
		
			
			Ele bloqueia todos os usuários que não possuem uma conta do Gmail
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Os CAPTCHAs já não são eficazes?
Toda a premissa dos CAPTCHAs é que uma máquina não deve ter a capacidade cognitiva de um ser humano normal para decifrar essas mensagens. Os CAPTCHAs contam com uma abordagem parcialmente baseada em comportamento. Além de avaliar a capacidade do usuário de resolver o quebra-cabeça fornecido, essas ferramentas também monitoram ações como velocidade de navegação na página da Web e curvatura do movimento do mouse. No entanto, na última década, a capacidade de aprendizado de máquinas e inteligência artificial evoluíram significativamente, tornando suas respostas mais semelhantes a de seres humanos e, em alguns casos, superando as habilidades humanas na resolução de quebra-cabeças complexos. As máquinas, com sua extensa memória e recursos multitarefa, muitas vezes podem facilmente resolver quebra-cabeças simples como CAPTCHAs.

Além disso, o surgimento de farms de solução CAPTCHA – serviços operados por humanos que decodificam CAPTCHAs para bots – representa outro desafio. Por meio desses farms, os bots podem resolver CAPTCHAs em questão de segundos, ignorando essa camada de segurança com o mínimo de custo e esforço.
Então, como você pode mitigar isso?
A maneira mais lógica de mitigar a quebra de CAPTCHA é aumentando a complexidade da própria tarefa. No entanto, aqui surge um probleminha. Quando você aumenta a complexidade dos CAPTCHAs, você também está tornando-o mais difícil, ou pior, irritante para os humanos ao tratar de resolvê-lo. De acordo com Sandy Carieli, analista principal da Forrester, os CAPTCHAs podem impactar negativamente na experiência humana. De acordo com o relatório de Carieli, cerca de 19% dos adultos americanos abandonaram suas transações online no ano passado devido a CAPTCHAs complexos.



Image credit

Além disso, e aqui está o detalhe. Complicar o CAPTCHA pode até não funcionar.

Em 2014, o Google enfrentou um algoritmo contra um de seus CAPTCHAs mais complicados. O algoritmo quebrou-o com sucesso, enquanto apenas 33% dos usuários humanos conseguiram resolvê-lo.

Então, qual é a solução?

Tamer Hassan, cofundador e CEO da empresa de segurança cibernética HUMAN Security, disse isto:

“Não deveríamos estar testando os humanos; não deveríamos tratar os humanos como se fossem os fraudadores. Deveríamos enfrentar os bots de maneiras diferentes, ou seja, complicar a vida dos seres humanos não é o caminho a seguir.”

Vamos recorrer ao web3 para encontrar uma solução.
nCaptcha – Combate ao Spam com web3
O nCaptcha do Learn Near Club é uma solução inovadora e eficiente projetada para combater o spam de sites. Ao contrário dos sistemas CAPTCHA tradicionais, onde você acaba irritando seus usuários com textos e imagens complicadas, o nCaptcha aproveita os recursos da web3 e da tecnologia blockchain para a autenticação humana.

Como proprietário de um site, usar o nCaptcha é muito simples. Depois de integrá-lo ao seu site, seus usuários fazem uma microtransação no valor de 0,01 NEAR. Metade vai para o nCaptcha e a outra metade para você, o proprietário do site.

O nCaptcha detém spammers usando uma combinação do seguinte:

 	Exigir mini-depósitos para envios de formulários. Este sistema de mini-depósito funciona como um mecanismo de verificação que é simples para usuários genuínos e extremamente eficaz para dissuadir spammers, que irão precisar fazer inúmeras microtransações, tornando assim, os esforços do spam ineficientes e caros.
 	Estabelecer uma pontuação de reputação do usuário on-chain, transparente e imutável.

Aqui estão algumas coisas mais para ser mantida em mente sobre o nCaptcha:

 	Você deve ter uma NEAR account para poder usar o nCaptcha.
 	Ele se integra perfeitamente ao WordPress, com um plug-in dedicado para comentários, tornando-o versátil e acessível a uma ampla gama de aplicativos da web.
 	Ele também possui alta compatibilidade com várias plataformas web2, preenchendo a lacuna entre a infraestrutura convencional da Internet e os aplicativos baseados em blockchain.
 	Seu back-end descentralizado o torna robusto e resistente a ataques ou interrupções comuns em sistemas centralizados.
 	Construído em JavaScript, é suportado por navegadores populares, oferecendo assim uma interface amigável tanto para proprietários de sites como seus visitantes.
 	Também está disponível como um pacote NPM, pronto para dispositivos móveis, totalmente responsivo e não requer nenhum contrato inteligente, tornando-o ainda mais simples para que os desenvolvedores possam implementá-lo.




	

	
	
		
			
				Qual é a principal desvantagem dos CAPTCHAs tradicionais que o nCaptcha aborda?
			
		

		
					

		
			
			
			
			A complexidade e o incômodo dos testes CAPTCHA tradicionais.
		
			
			O alto custo de implementação de sistemas CAPTCHA tradicionais.
		
			
			A lentidão dos sistemas CAPTCHA tradicionais.
		
			
			A barreira do idioma apresentada pelos sistemas CAPTCHA tradicionais.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Então, como é que isso funciona?
Vamos lá ver o nCaptcha em ação.

Para usar o nCaptcha, você deve primeiro ter uma conta de carteira Near nomeada como Satoshi.near ou xyz.near. Não deve ser apenas o seu endereço público. Acesse Lean Near e faça login usando sua carteira. Agora vá para a Página de contato.

Role para baixo para ver o widget nCaptcha.



Como você pode ver, em vez de lidar com um Captcha irritante, você só precisa verificar usando uma microtransação.

Clique no “Verify with nCaptcha” para ser redirigido ao próximo passo:



Clique em “Approve” e finalize sua verificação.



Após a conclusão da verificação, você pode clicar em “Transação” para ser redirecionado para o Near Explorer para que possamos ver o que está acontecendo nos bastidores.

 

A primeira metade da transação de verificação 0,01 vai para o site (neste caso, Learn Near).



A segunda metade vai para nCaptcha.



Desta forma, teremos um sistema que beneficiará a todos:

 	Usuário: Não perde tempo com imagens tontas.
 	Proprietário do site: Nenhum usuário abandona por causa de imagens complicadas e ademais ganha NEAR com as taxas de verificação.
 	nCaptcha: Recebe parte das taxas por verificação..

Essa filosofia “todos ganham” é o próprio espírito da web3.
Mudando o jogo do spam com o nCaptcha
A eficácia do nCaptcha reside em sua simplicidade e uso inovador de microtransações web3. Os CAPTCHAs provaram ser cada vez mais complicados e ineficazes. Enquanto que os nCaptchas fornecem uma alternativa muito mais elegante.

Você pode baixar o nCaptcha e receber mais informações, aqui.




	

	
	
		
			
				O que você precisa para usar nCaptcha?
			
		

		
					

		
			
			
			
			Uma conta com um provedor de e-mail importante.
		
			
			Um cartão de crédito.
		
			
			Uma conta NEAR.
		
			
			Um alto nível de habilidades de programação de computador.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Comment se préparer aux modifications du portefeuille NEAR

Lorsque NEAR a lancé son réseau principal en 2020, il a également lancé un portefeuille construit et hébergé par l'équipe principale de Near Inc. (alors Pagoda) à https://wallet.near.org pour soutenir son modèle de compte unique. Aujourd'hui, un éventail de portefeuilles open source est disponible dans l'écosystème NEAR. Alors que NEAR poursuit sa campagne de décentralisation, il modifie considérablement son écosystème de portefeuille. Examinons de plus près les changements en question, leur impact et comment les utilisateurs peuvent s'y préparer.
💡 CONSEIL IMPORTANT

 	Sauvegardez toujours votre phrase de récupération
 	Essayez d'abord de migrer un compte "non essentiel" pour tester comment le processus fonctionne pour vous

Modifications Entrantes
La mission de NEAR a été de créer et de soutenir un écosystème Web3 dynamique. Au cours des prochains mois, Pagoda commencera à migrer le domaine de portefeuille NEAR d'origine d'un portefeuille de navigateur vers un hub de portefeuille. Cela permettra au domaine de devenir un point de référence pour tous les portefeuilles NEAR, permettant aux utilisateurs de découvrir, sélectionner et mettre en œuvre le portefeuille qui répond à leurs besoins et leur donnant une plus grande flexibilité lorsqu'ils naviguent dans l'espace Web3. Les détenteurs de portefeuilles sont encouragés à migrer leurs comptes vers de nouveaux portefeuilles d'écosystème, et l'équipe a également créé des tutoriels avec des instructions étape par étape pour simplifier le processus.

NEAR vise à créer un écosystème florissant composé de plusieurs portefeuilles. Pour ce faire, il est essentiel que les développeurs qui s'appuient sur le protocole disposent d'un point d'intégration unique. Le nouvel écosystème offrira aux utilisateurs plus de 30 options de portefeuilles, ce qui permettra aux utilisateurs d'autres écosystèmes d'interagir facilement avec la blockchain NEAR à l'aide d'un portefeuille qui leur est déjà familier. Cette stratégie permet de créer un écosystème florissant de portefeuilles sur NEAR, rendant le Web3 aussi facile à utiliser que le Web2.
Transfert de vos comptes depuis NEAR
Si vous utilisez actuellement https://wallet.near.org comme portefeuille principal, vous pouvez utiliser l'assistant de transfert de portefeuille pour effectuer la migration sans risquer de perdre vos fonds. L'assistant vous permettra également de choisir entre les portefeuilles basés sur un navigateur et ceux basés sur une extension, afin de vous garantir la même expérience que celle à laquelle vous êtes habitué, même après la migration.

NEAR Wallet continuera à fonctionner en tant que portefeuille de navigateur jusqu'au 31 octobre 2023. Les utilisateurs sont encouragés à transférer leurs comptes vers un nouveau fournisseur avant l'expiration de la date. Cela peut être fait manuellement en utilisant la phrase de récupération ou l'assistant de transfert pour migrer en toute sécurité les comptes vers leur portefeuille préféré. En outre, même si les utilisateurs n'ont pas transféré leurs comptes avant le 31 octobre 2023, le portefeuille de transfert sera toujours disponible, même après l'arrêt de la fonctionnalité du portefeuille.

Examinons les différentes méthodes disponibles pour permettre aux utilisateurs de transférer leurs comptes.
Utilisation de la Phrase De Récupération
L' importation de la phrase de récupération est le moyen le plus courant pour les utilisateurs de transférer leurs comptes vers un nouveau portefeuille. Cependant, si vous souhaitez garantir la sécurité de vos comptes ou transférer plusieurs comptes, nous vous recommandons vivement d'utiliser l'assistant de transfert de portefeuille. Si vous décidez d'utiliser la phrase de récupération, vous devrez d'abord désactiver l'authentification à deux facteurs (2FA). Cela peut être fait dans les paramètres de votre compte sous l'onglet "Security & Recovery" sur le domaine actuel wallet.near.org - Désactiver l'authentification à deux facteurs dans tous les comptes avant de migrer vers un autre fournisseur de porte-monnaie.

La désactivation de l'authentification à deux facteurs est essentielle, car elle ne sera plus prise en charge, ce qui rendra votre compte inaccessible jusqu'à ce que l'authentification à deux facteurs soit désactivée. Toutefois, si vous utilisez l'assistant de transfert, celui-ci désactivera automatiquement l'authentification à deux facteurs, ainsi que la vérification par courriel et par téléphone.
Utilisation du Ledger
Si vous utilisez un Ledger pour sécuriser votre compte, vous avez la possibilité d'importer votre compte vers des portefeuilles compatibles avec le matériel, tels que le Sender Wallet ou le Nightly Wallet. Cependant, il est essentiel de se rappeler que les comptes sécurisés par un Ledger ne peuvent pas être transférés à l'aide de l'assistant de transfert. Tout comme lors de la migration à l'aide de l'option de phrase de récupération, vous devrez désactiver l'option 2FA. Vous pouvez le faire en accédant aux "Account Settings” (Paramètres du compte) sous l'onglet "Security & Recovery". Désactivez le 2FA dans tous les comptes avant de migrer vers un autre fournisseur de portefeuilles.
Utilisation De L'Assistant De Transfert De Portefeuille (Fortement Recommandé)
L'assistant de transfert de portefeuille permet aux utilisateurs de transférer tous leurs comptes connectés de manière transparente et offre un contrôle de sécurité approfondie pour s'assurer que tous les comptes sont en sécurité. L'assistant fournit également

 	Un guide étape par étape sur la suppression des anciennes clés d'accès ou mots de passe.
 	Le transfert en masse des comptes connectés vers le portefeuille de votre choix.
 	Rotation des clés.

L'assistant de transfert permet d'améliorer la sécurité de vos comptes connectés avant de les migrer vers un nouveau portefeuille. Pour ce faire, il effectue une rotation de vos clés, nettoie les anciennes clés et transfère vos comptes en toute sécurité. L'assistant est accessible à partir de la bannière située en haut de la page wallet.near.org.
Comment Fonctionne L'Assistant De Transfert De Portefeuille ?
Voyons maintenant comment fonctionne l'assistant de transfert de portefeuille.
Étape 1 : Sécurisation De Votre Compte
Nous vous recommandons de faire tourner vos clés et de générer une nouvelle phrase de récupération de 12 mots, de la même manière que vous mettriez à jour votre mot de passe. La sécurisation de votre compte implique les étapes suivantes.

 	Créez une nouvelle phrase de récupération de 12 mots.
 	Vérifiez la nouvelle phrase de récupération.
 	Enregistrez la nouvelle phrase de récupération dans un endroit sûr ou écrivez-la sur une feuille de papier. En outre, vous devez également confirmer le compte récupéré et veiller à ne pas le confondre avec l'ancienne phrase de récupération.


Étape 2 : Nettoyer Les Clés
L'étape suivante consiste à nettoyer vos clés. Cette étape est essentielle, car NEAR souhaite réduire le nombre d'applications avec lesquelles les clés ont été partagées. Une fois cette étape exécutée, il se peut que vous soyez déconnecté de certaines applications. Le nettoyage de vos clés se fait en trois étapes.

 	Passez en revue les clés suggérées que vous souhaitez supprimer.
 	Saisissez la phrase de récupération pour confirmer la suppression.
 	Supprimez toutes les clés obsolètes. Une fois l'opération terminée, il se peut que vous deviez vous reconnecter à certaines applications si leurs clés d'accès limité ont été supprimées.


Étape 3 : Transférer Les Comptes
Maintenant, utilisez le sélecteur de portefeuille et choisissez le portefeuille vers lequel vous souhaitez transférer vos comptes. Le transfert de vos comptes s'effectue selon les étapes suivantes.

 

 	Sélectionnez le portefeuille vers lequel vous souhaitez transférer vos comptes.
 	Sélectionnez ensuite les comptes que vous souhaitez transférer.
 	Copiez un mot de passe temporaire et sécurisez le transfert de compte.
 	Saisissez le mot de passe dans le portefeuille de destination.
 	Terminez la configuration du portefeuille et le transfert des comptes en suivant les instructions qui l'accompagnent. Toutefois, cette étape peut varier d'un portefeuille à l'autre.
 	Une fois que vous avez terminé toutes les étapes énumérées ci-dessus, confirmez que vous avez accès à tous vos comptes dans le nouveau portefeuille. Une fois cette confirmation obtenue, retournez sur wallet.near.org et terminez le processus de transfert.






	

	
	
		
			
				Quel est le moyen le plus familier pour les utilisateurs de transférer leurs comptes ?
			
		

		
					

		
			
			
			
			Utilisation De La Phrase De Récupération
		
			
			Utilisation Du Ledger
		
			
			Utilisation De L'Assistant De Transfert De Portefeuille
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Étape 4 : Déconnexion De Near.org
La dernière étape consiste à vous déconnecter de votre portefeuille NEAR et à commencer à utiliser votre nouveau portefeuille.

 	Une fois le transfert de compte terminé, retournez surwallet.near.org et cliquez sur “Complete.”
 	Vérifiez que vous avez accès à tous vos comptes dans le nouveau portefeuille.
 	Déconnectez-vous de tous les comptes situés sur near.org.
 	Une fois le transfert terminé, vous êtes prêt à utiliser votre nouveau portefeuille et à gérer vos comptes.


Comment Migrer Vers HERE Wallet
Se connecter via web wallet est le moyen le plus simple d'exporter votre compte vers HERE.

Il suffit de 3 clics !

https://youtu.be/j2JFDJnUiCc

 
Portefeuilles Pris En Charge
L'assistant de transfert prend en charge un certain nombre de portefeuilles. Si vous souhaitez en savoir plus sur les portefeuilles pris en charge ou effectuer une comparaison, vous pouvez consulter cette Feuille Google. Parmi les portefeuilles pris en charge, citons MyNearWallet, HERE Wallet, Meteor Wallet, Welldone Wallet, et Nightly Wallet.

En guise de conclusion

Avec ces changements, NEAR entre dans une nouvelle ère et fait un pas important vers un écosystème véritablement décentralisé, contrôlé et dirigé par sa communauté. Ce nouvel écosystème contribuera à améliorer l'expérience de l'utilisateur, avec le hub de portefeuilles et le sélecteur de portefeuilles permettant aux utilisateurs de choisir le porte-monnaie qui correspond le mieux à leurs besoins, aidant NEAR à offrir aux utilisateurs toute la gamme d'utilisations et d'expériences du Web3.




	

	
	
		
			
				Quels sont les portefeuilles pris en charge par l'assistant de transfert ?
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Comment staker des jetons NEAR en utilisant différents portefeuilles

Pourquoi staker des NEAR ?
Staker des NEAR offre un moyen simple et efficace d'augmenter à la fois la sécurité et l'efficacité du réseau. De plus, ce processus ne nécessite aucun équipement supplémentaire ni configuration complexe de la part des détenteurs de jetons. C'est une méthode sans tracas qui permet aux utilisateurs de gagner des récompenses.

Staker des jetons NEAR implique de participer au réseau en tant que délégataire. En tant que délégataires, les participants apportent leur soutien aux validateurs, qui sont responsables de la sécurité du réseau. En échange de ce soutien, ils gagnent des récompenses de staking. Ces récompenses sont distribuées proportionnellement à la part de chaque utilisateur dans le montant total staké.

Les validateurs sont des entités qui exécutent des nœuds, valident les transactions et produisent de nouveaux blocs dans le protocole NEAR. Les validateurs sont responsables de la sécurisation du protocole NEAR, et vos récompenses de staking dépendent de leurs performances. Tenez compte de leurs taux de commission, de leur disponibilité et de leur historique lors du choix du validateur. Vous pouvez trouver une liste de validateurs sur l'explorateur de blockchain NEAR Explorer.

En stakant des NEAR, les utilisateurs contribuent à la sécurité globale du réseau, en aidant à valider les transactions et à sécuriser la blockchain contre d'éventuelles attaques. Cette participation active profite non seulement à l'utilisateur, mais renforce également l'ensemble de l'écosystème.

Ci-dessous, vous trouverez certaines des options de portefeuille largement utilisées pour staker des NEAR. Vous pouvez choisir le portefeuille qui correspond le mieux à vos besoins et préférences.
Portefeuille NEAR
Le portefeuille NEAR est un portefeuille basé sur le Web et non dépositaire pour la blockchain NEAR, où les utilisateurs peuvent envoyer et recevoir des jetons NEAR ou des jetons NEP-141. C'est un portefeuille simple et pratique qui permet aux utilisateurs de gérer, stocker et staker des actifs NEAR.

Tout d'abord, vous devez créer un compte NEAR. Rendez-vous sur le site Web de Near Wallet et cliquez sur "Créer un compte". Si vous avez déjà un portefeuille, cliquez sur "Importer un compte existant".



Il existe une option pour en savoir plus sur NEAR avant de créer votre compte.



Vous devez choisir une méthode de restauration d'accès à votre portefeuille. NEAR Wallet prend en charge deux options :

 	Via une phrase de récupération (mot de passe sécurisé).
 	Via la connexion d'un portefeuille matériel Ledger.



Note : Near Wallet prend en charge le portefeuille matériel Ledger. Vous pouvez vous connecter à votre portefeuille si vous en possédez un. Utiliser un portefeuille Ledger est le moyen le plus sûr de staker vos NEAR.

Après avoir sélectionné la méthode de sécurité, cliquez sur le bouton ci-dessous pour continuer à créer le portefeuille. Nous vous montrerons le processus d'utilisation d'une phrase de récupération.

Une phrase de récupération composée de 12 mots apparaît à l'écran. La méthode la plus sûre pour stocker la phrase consiste à l'écrire sur papier et à la conserver dans un endroit sûr. Ensuite, cliquez sur "Continuer".



Important : Ne prenez pas de captures d'écran lors de l'enregistrement de la phrase de récupération et ne la copiez pas dans le presse-papiers. Enregistrer votre phrase de récupération sous forme de capture d'écran ou de texte sur un téléphone portable ou un ordinateur portable la met en danger d'être volée. Ne partagez jamais votre phrase de récupération avec qui que ce soit.

Confirmez la phrase de récupération. À l'étape suivante, vous devez entrer la phrase de vérification.



Une fois cela fait, votre portefeuille est prêt à être utilisé.



Sur la page d'accueil du portefeuille NEAR, ouvrez l'onglet "Staking".



Tout d'abord, si vous avez plus d'un compte, vous devez sélectionner celui à partir duquel vous souhaitez staker des NEAR. Ensuite, vous devez choisir un validateur à qui déléguer des jetons.



Cliquez sur "Staker mes jetons" et sélectionnez un validateur. Faites toujours vos propres recherches (DYOR) lors du choix d'un validateur. Le portefeuille affichera les frais du validateur.

Note : Soyez attentif au fait que NEAR utilise des adresses non standard dans le format everstake.poolv1.near / pandateam.poolv1.near au lieu de longs mots hexadécimaux comme les adresses Bitcoin et Ethereum.



Pour poursuivre le processus de staking, cliquez sur "Staker avec le validateur". Entrez le nombre de jetons NEAR que vous souhaitez déléguer. Sélectionnez l'option "Utiliser le maximum" pour staker tous les jetons disponibles dans votre portefeuille, puis cliquez sur "Envoyer la délégation". N'oubliez pas de réserver une partie des jetons pour payer les frais de retrait.



Enfin, cliquez sur "Confirmer" pour effectuer la transaction.



La vérification de la transaction prend un certain temps. Cela prend quelques instants. Une fois terminé, vous verrez le message suivant :



Vous pouvez vérifier votre staking et vos récompenses sur le tableau de bord.



Note : Les récompenses sont automatiquement réinvesties, mais vous pouvez les retirer et les déléguer à tout moment lorsque le bouton de retrait est disponible.

Les jetons seront retirés après quatre époques complètes, soit environ 52 à 65 heures.

Si vous devez retirer vos jetons, choisissez "Retirer" dans la section de staking et sélectionnez votre validateur.



Choisissez le nombre de jetons que vous souhaitez retirer ou cliquez sur "Utiliser le maximum". Ensuite, cliquez sur le bouton "Retirer les jetons".



Pour continuer le processus de retrait, confirmez la transaction.



Si vous avez tout fait correctement, vous verrez l'inscription "Succès !" :






	

	
	
		
			
				Pouvez-vous partager votre phrase de passe avec vos amis ?
			
		

		
					

		
			
			
			
			Oui
		
			
			Non
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Portefeuille mobile NEAR
NEAR Mobile est un portefeuille pratique développé par Peersyst. NEAR Mobile est un portefeuille simple et sécurisé. NEAR Mobile vous permet de gérer et d’importer plusieurs comptes sur votre téléphone pour avoir le contrôle et la flexibilité sur vos actifs en permanence.

Pour commencer le processus de staking, rendez-vous sur le site Web officiel de NEAR Mobile pour télécharger le portefeuille. L'application NEAR Mobile est disponible sur l'App Store et Google Play.



Ouvrez l'application sur votre appareil et cliquez sur le bouton "Créer un compte" pour commencer la création du compte. Si vous avez déjà un portefeuille, cliquez sur "Importer votre portefeuille NEAR".



Ensuite, vous verrez des informations essentielles sur le portefeuille NEAR et la phrase mnémonique. Après avoir lu ces informations, cliquez sur le bouton "Générer une phrase mnémonique".



N'oubliez pas que la phrase mnémonique est essentielle pour accéder à votre portefeuille et le récupérer. Il est donc important de la conserver en sécurité. Nous vous recommandons d'écrire votre phrase de récupération et de la conserver en lieu sûr, accessible uniquement à vous. Une autre option consiste à utiliser un appareil spécialement conçu pour le stockage de la phrase mnémonique.

Ne prenez pas de captures d'écran de la phrase, car cela pourrait la rendre accessible à des personnes non autorisées. Il est essentiel de ne jamais divulguer votre phrase de récupération à quiconque.

Pour passer à l'étape suivante, sélectionnez les mots de votre phrase mnémonique dans l'ordre correct.



Vous devez créer un mot de passe pour empêcher les tiers non autorisés d'accéder à votre portefeuille et de confirmer des transactions sans votre autorisation. Vous pouvez utiliser l'authentification biométrique pour accéder au portefeuille.



La blockchain NEAR a été conçue pour être simple, avec un modèle de compte flexible et des comptes lisibles par l'homme, c'est-à-dire des noms choisis par l'utilisateur au lieu d'une chaîne de lettres et de chiffres. En cliquant sur l'onglet coloré contenant les informations du compte, vous trouverez les options pour importer un autre compte ou en créer un personnalisé.

Pour approvisionner votre portefeuille, cliquez sur le bouton "Recevoir", copiez l'adresse du portefeuille et envoyez les jetons NEAR depuis l'échange ou un autre compte vers votre adresse.



Accédez à la section "Staking". Cela ouvrira un tableau de bord pour vos jetons stakés, y compris les récompenses et le montant staké.

Choisissez "Staker mes jetons" pour commencer le processus de staking.



Saisissez le montant que vous souhaitez déléguer et cliquez sur "Suivant". Sélectionnez un validateur fiable dans la liste, ou commencez à taper son nom dans la barre de recherche pour le trouver plus rapidement.

Vérifiez les détails de la transaction, et si tout est correct, cliquez sur "Suivant".



Une fois la transaction terminée, cliquez sur "Continuer", et vous recevrez une notification indiquant que les jetons ont été stakés avec succès.



Dans la section "Stake", vous pouvez gérer le montant staké. Vous pouvez retirer les jetons en cliquant sur le bouton "Retirer" et en spécifiant la quantité que vous souhaitez retirer.

Note : La période de retrait est d'environ 52 à 65 heures (quatre époques).






	

	
	
		
			
				Quelle est la période d’attente pour obtenir un retrait ?
			
		

		
					

		
			
			
			
			14 jours
		
			
			24 à 36 heures
		
			
			Environ 52 à 65 heures
		
			
			Pas d’attente
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meteor Wallet
Meteor Wallet a été créé par une équipe qui a également fondé des projets de qualité tels que Near Tinker Union et Enleap Near sur le protocole NEAR.

Meteor est un portefeuille simple et sécurisé : tout est chiffré et aucune donnée sensible n'est enregistrée. Le portefeuille permet aux utilisateurs de collectionner des NFT, d'accéder à la DeFi et d'explorer tout ce que Web3 a à offrir.

Avant de staker des NEAR, vous devez créer et approvisionner un portefeuille de cryptomonnaie.

Rendez-vous sur le site Web de Meteor Wallet et choisissez entre la version Web et la version extension. Dans ce tutoriel, nous stakerons des jetons NEAR via la version Web.



Passez à l'étape suivante en cliquant sur le bouton "Commencer".



Sur l'écran principal de Meteor Wallet, deux options sont disponibles :

 	Créer un nouveau portefeuille ;
 	Importer un portefeuille existant.

Nous allons en créer un nouveau pour vous montrer l'ensemble du processus à partir de zéro. Cliquez d'abord sur "Créer un nouveau Meteor Wallet".



Un mot de passe est requis pour empêcher les tiers non autorisés de se connecter au portefeuille et de confirmer des transactions sans votre consentement. Créez un mot de passe complexe et cliquez sur "Continuer".



Chaque compte NEAR est identifié par une adresse spécifique. Selon leur nom, il existe deux types de comptes :

 	Les comptes nommés avec des noms lisibles par l'homme, tels que alice.near ;
 	Les comptes implicites désignés par une chaîne de 64 caractères.

Sélectionnez l'option que vous préférez.



La sauvegarde de votre portefeuille est l'étape la plus importante. Vous pouvez restaurer l'accès aux fonds sur un autre appareil en utilisant une phrase de récupération secrète. Ne partagez jamais votre phrase secrète avec qui que ce soit.



Sélectionnez le premier et le dernier mot de votre phrase de récupération secrète pour confirmer que vous avez sauvegardé l'intégralité de la phrase.



Avant de passer au staking, vous devez approvisionner votre compte. Copiez l'adresse de votre portefeuille en cliquant sur "Compte". Utilisez cette adresse pour envoyer des jetons vers votre portefeuille. Une fois que vous avez approvisionné votre portefeuille, vous pouvez passer au staking.



Accédez à la section "Staking" en cliquant sur le bouton "Stake", comme indiqué ci-dessous.



Sélectionnez la section "Staking standard".



Cliquez sur le bouton "Créer un nouveau staking" pour continuer.



Saisissez le montant que vous souhaitez déléguer et choisissez un validateur fiable en cliquant sur le bouton "Sélectionner un validateur".



Une liste des validateurs disponibles apparaît à l'écran. Trouvez le validateur à qui vous souhaitez déléguer les jetons NEAR. Vous pouvez miser avec plusieurs validateurs. Pour une recherche rapide, commencez à taper le nom du validateur dans le champ, puis cliquez dessus.



Meteor Wallet affiche les revenus estimés pour plusieurs périodes afin que vous puissiez savoir combien de récompenses vous obtiendrez.



Une fois que vous avez sélectionné un validateur, cliquez sur le bouton "Staker" pour lancer la transaction.



Vérifiez attentivement les détails de la transaction et, si tout est correct, cliquez sur le bouton "Confirmer".



Nous avons réussi à staker des jetons NEAR avec succès.

Vous pouvez également les retirer en cliquant sur le bouton "Retirer" et en spécifiant la quantité que vous souhaitez retirer.

Note : La période de retrait est d'environ 52 à 65 heures (quatre époques).






	

	
	
		
			
				Est-il possible de miser vos jetons avec différents validateurs ?
			
		

		
					

		
			
			
			
			Oui
		
			
			Non
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Portefeuille Nightly
Le portefeuille Nightly est un portefeuille multi-chaînes qui fonctionne actuellement sur NEAR, Solana et Aptos. Il est disponible en tant qu'extension Chrome et Firefox sur votre téléphone mobile. Le portefeuille Nightly est la clé de l'univers virtuel en fournissant des fonctions telles que l'échange de jetons, le staking, le staking liquide et l'affichage de NFT sur chaque chaîne. Nightly a déjà été intégré dans le sélecteur de portefeuilles NEAR.

Allez sur le portefeuille Nightly et choisissez votre navigateur préféré (Firefox et Chrome) pour staker vos jetons NEAR.



Dans ce guide, nous utilisons le navigateur Chrome. Installez l'extension en cliquant sur le bouton "Ajouter à Chrome".



Sur la page de l'extension, cliquez sur le bouton "Ajouter l'extension" pour approuver l'installation du plugin.



Ouvrez l'extension Nightly Wallet dans votre navigateur.



Dans cette fenêtre, vous pouvez soit restaurer votre portefeuille existant, soit en créer un nouveau. Si vous avez déjà un portefeuille Nightly, vous pouvez le restaurer et passer à l'étape suivante. Pour en créer un nouveau, appuyez sur "Créer un nouveau portefeuille".



Choisissez un mot de passe pour votre portefeuille. Suivez les recommandations de sécurité et choisissez un mot de passe solide. Confirmez votre mot de passe et appuyez sur "Créer un portefeuille".



Ensuite, vous verrez votre phrase secrète. Ne partagez pas cette phrase avec qui que ce soit. Ces mots générés aléatoirement sont les clés de votre portefeuille. Si vous les oubliez, vous perdrez l'accès à vos fonds. Notez votre phrase secrète sur papier et cliquez sur "Suivant".



Entrez votre phrase secrète pour vérifier votre portefeuille.



Ensuite, choisissez le réseau NEAR.



Vous pouvez maintenant déposer, envoyer, échanger et miser des jetons NEAR. Vérifiez le tableau de bord du portefeuille pour les principales fonctions.



Votre portefeuille Nightly est maintenant prêt pour l'étape suivante : le staking. Ouvrez votre portefeuille, appuyez sur l'icône NEAR et cliquez sur "Commencer à gagner".



Nightly propose 2 options de mise en jeu : la mise en jeu liquide et la mise en jeu régulière. Lors de la mise en jeu régulière, vous recevrez des jetons NEAR en récompense. La mise en jeu liquide offre d'autres conditions : les utilisateurs peuvent déposer des jetons mais ils recevront en retour des jetons liquides. La principale différence entre la mise en jeu liquide et la mise en jeu traditionnelle est que vous n'avez pas besoin de bloquer vos actifs. Cependant, en réalité, vous devez verrouiller votre jeton, mais vous en recevrez un nouveau - stNEAR ou NEARx.

Pour obtenir des jetons NEAR en récompense, choisissez la mise en jeu régulière.



Pour déléguer vos jetons NEAR, appuyez sur l'icône "+".



Cette fenêtre affiche une liste de tous les validateurs. Choisissez un validateur fiable.



Saisissez un montant de mise en jeu dans la limite de votre portefeuille et cliquez sur le bouton "Suivant".



Votre délégation est maintenant active et vous commencerez bientôt à recevoir des récompenses.



Vous pouvez toujours consulter les informations sur votre mise en jeu en cliquant sur les boutons "Commencer à gagner" et "Mise en jeu régulière".



Si vous souhaitez retirer vos jetons, vous devez cliquer sur le bouton "Retirer". Veuillez noter que la période de retrait dure environ 52 à 65 heures (quatre époques).






	

	
	
		
			
				Quels jetons recevrez-vous en récompense si vous choisissez la mise en jeu régulière ?
			
		

		
					

		
			
			
			
			NEARx
		
			
			stNEAR
		
			
			NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ledger Live
Ledger Live est une plateforme permettant d'acheter des cryptomonnaies, de staker vos actifs et de gérer des NFT. Elle fonctionne comme une passerelle sécurisée vers l'écosystème des cryptomonnaies. L'application Ledger Live vous permet de gérer et de réaliser des transactions avec différents jetons. De plus, vous pouvez faire croître vos cryptomonnaies en utilisant le processus de mise en jeu et de prêt disponible dans l'application Ledger Live.

Rendez-vous sur le site officiel de Ledger et cliquez sur le bouton "Télécharger". Actuellement, les utilisateurs peuvent télécharger Ledger Live pour Windows, macOS et Linux. La version mobile est disponible pour les utilisateurs Android et iOS.



Choisissez votre système d'exploitation, installez l'application sur votre ordinateur et ouvrez-la. Ensuite, cliquez sur le bouton "Commencer". Vous pourrez accéder à toutes les fonctionnalités si vous possédez un appareil Ledger.



Allumez votre appareil Ledger et entrez le code.



Approuvez l'entrée dans l'application en appuyant sur deux boutons. Maintenant, vous pouvez utiliser l'application.



Voici donc le menu principal de Ledger Live. Installez la dernière version de l'application NEAR sur votre appareil Ledger pour commencer le processus de mise en jeu. Rendez-vous dans le catalogue d'applications et saisissez "NEAR" dans la barre de recherche. Ensuite, cliquez sur "Installer".



Après avoir installé l'application NEAR, ajoutez vos comptes NEAR en cliquant sur le bouton "Ajouter un compte".



Vous pouvez ajouter plusieurs comptes.



Une fois votre compte ajouté avec succès, cliquez sur le bouton "Terminé".



Avant de staker, vous devez envoyer des jetons NEAR vers votre portefeuille. Passez cette étape si vous les possédez déjà et passez directement à la mise en jeu.

Accédez à la section "Compte" pour ajouter des fonds à votre Ledger Live. Choisissez un compte NEAR. Ensuite, cliquez sur le bouton "Recevoir".



La page de réception s'ouvrira. Cliquez sur "Continuer".



Vérifiez que l'adresse affichée correspond exactement à celle de votre appareil. Sélectionnez "Approuver" sur l'appareil et appuyez sur les deux boutons de votre Ledger.



Si tout est en ordre, copiez votre adresse. Terminez ce processus en cliquant sur "Terminé".



Ensuite, vous pouvez acheter des jetons NEAR sur n'importe quelle plateforme d'échange de cryptomonnaies. Envoyez-les à votre adresse de portefeuille. Une fois la transaction terminée, revenez à votre Ledger Live.

Ouvrez l'onglet "Comptes" et cliquez sur le bouton "Mettre en jeu" pour commencer le processus de mise en jeu.



Ensuite, vous verrez des informations sur les fonctionnalités de mise en jeu de NEAR. Après les avoir lues, cliquez sur "Continuer".



Ensuite, vous devez choisir le fournisseur de mise en jeu auquel vous souhaitez déléguer. Cliquez sur "Afficher tout" pour voir la liste complète des validateurs.



Dans la nouvelle fenêtre, saisissez “PandaTeam” ou un autre validateur comme "Everstake" dans le champ de recherche et sélectionnez-le dans la liste. Cliquez sur "Continuer".



Ensuite, saisissez le montant que vous souhaitez miser. Vous pouvez également sélectionner le bouton "Utiliser le maximum" pour miser l'intégralité de votre solde (moins les frais de transaction). Le montant des frais de réseau sera affiché dans l'onglet de mise en jeu.



Vous devez confirmer la transaction sur votre appareil Ledger. Appuyez sur les boutons de votre appareil, comme indiqué sur l'image ci-dessous.



Vous avez maintenant délégué vos jetons avec succès. Cliquez sur "Voir les détails" pour voir les informations de la transaction.



Vous pouvez vérifier votre état et la transaction en vérifiant son hash dans l'explorateur.



Vous pouvez suivre votre position de mise en jeu en cliquant sur l'onglet "Comptes".






	

	
	
		
			
				Pouvez-vous bénéficier de toutes les fonctionnalités de l'application Ledger Live sans l'appareil Ledger ?
			
		

		
					

		
			
			
			
			Oui
		
			
			Non
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Omni Wallet
Omni est une application de portefeuille Web3 de nouvelle génération. C'est le rebranding de SteakWallet. Omni est un portefeuille de cryptomonnaie en libre-service et en auto-garde, ce qui facilite la mise en jeu de différents jetons, la gestion des actifs inter-chaînes et la collecte et l'affichage de NFT.

Vous devrez télécharger l'application et créer un portefeuille Omni pour commencer le processus de mise en jeu.

Veuillez vous rendre sur Omni Wallet, choisir votre système d'exploitation préféré (iOS ou Android) et installer l'application sur votre téléphone portable.





Une fois installée, rendez-vous dans l'application Omni Wallet et cliquez sur le bouton "Let's go". Pour continuer à utiliser le portefeuille, vous devez également choisir de configurer un code de sécurité ou d'utiliser Face ID pour protéger votre portefeuille. Si vous avez déjà un compte Omni, vous pouvez l'importer ou en créer un nouveau. Pour importer votre portefeuille existant, cliquez sur le bouton "Importer un portefeuille existant". Votre Ledger peut également être connecté à Omni.



L'étape suivante est votre phrase secrète. Le portefeuille générera une phrase secrète aléatoire que vous devez enregistrer et mémoriser. Pour terminer la configuration du portefeuille, vous devez entrer votre phrase de 12 mots dans l'ordre correct et cliquer sur "Suivant".

Note : Protégez votre phrase secrète. Toute personne ayant cette phrase aura le contrôle de vos fonds. Si vous la perdez, vous perdrez l'accès à votre portefeuille.



Le portefeuille auto-gardé Omni facilite la mise en jeu multi-chaînes, rapide et simple. La complexité de la mise en jeu est abstraite et traduite en trois tapes simples sur votre appareil mobile.

Sur l'écran d'accueil, cliquez sur le bouton "Earn" (Gagner). Faites défiler le menu de mise en jeu et choisissez NEAR. L'écran de mise en jeu NEAR apparaîtra sur l'appareil. Pour continuer le processus de mise en jeu, appuyez sur le bouton "Stake NEAR" (Miser NEAR).

Note : Vous avez besoin d'au moins 0,05 NEAR pour réussir à miser et couvrir les frais de gaz.



Cela ouvrira l'écran d'informations sur la mise en jeu. Appuyez sur "Let's go!" (Allons-y !), entrez le montant de NEAR que vous souhaitez miser et appuyez sur "Suivant".



Vérifiez les frais de réseau et ouvrez la liste des validateurs en cliquant sur l'onglet "Staked with" (Misé avec). Choisir un validateur responsable est la clé de la sécurité de vos fonds et de vos revenus.

Après avoir choisi un validateur, appuyez sur le bouton "Confirmer la mise en jeu".

Note : Vous pouvez appuyer sur la flèche vers le bas à côté de "Average" (Moyenne) pour sélectionner le montant des frais de réseau. Suivez les frais de réseau recommandés par Omni pour vous assurer que votre transaction est traitée correctement.



Après votre confirmation, vous recevrez des informations sur votre mise en jeu réussie de NEAR.



Pour afficher votre mise en jeu active, accédez à la page principale. Vous pouvez également retirer votre mise en jeu, miser auprès de plusieurs validateurs. La période de retrait est d'environ deux jours.
Opto Wallet
Le portefeuille Opto est un portefeuille mobile pour le protocole NEAR et le réseau Octopus. C'est un portefeuille sécurisé, open-source et non-custodial qui permet aux utilisateurs de transférer et de mettre en jeu leurs jetons NEAR.

Le portefeuille Opto est un portefeuille open-source avec Bio Auth. Il offre la possibilité d'explorer un navigateur dApp intégré où les utilisateurs peuvent facilement trouver d'incroyables dApps NEAR, gérer leurs préférées et interagir avec elles. Le portefeuille Opto est disponible pour les systèmes d'exploitation iOS et Android et prend en charge Ledger.

Suivez les étapes suivantes pour mettre en jeu vos actifs NEAR. Vous devez installer le portefeuille Opto sur votre appareil. Pour ce faire, rendez-vous sur le site officiel du portefeuille Opto, choisissez votre système d'exploitation préféré (iOS ou Android) et téléchargez l'application.



Ouvrez l'application mobile Opto Wallet. Vous vous trouvez sur l'écran de démarrage du portefeuille Opto. Dans cette fenêtre, vous pouvez soit restaurer votre portefeuille existant, soit en créer un nouveau. Pour en créer un nouveau, appuyez sur Créer.

Lors de l'étape suivante, vous obtiendrez votre phrase mnémonique. Personne n'a accès à cette phrase. Si vous l'oubliez, vous perdrez l'accès à vos fonds. Veuillez conserver la phrase secrète dans un endroit sûr.

Note : Il est essentiel de ne pas prendre de captures d'écran ni de copier la phrase dans le presse-papiers. La meilleure façon est de la noter afin que personne d'autre ne puisse accéder aux mots-clés.

Choisissez maintenant un code PIN pour protéger votre portefeuille. Vous utiliserez ce code pour vous connecter à votre compte Opto. Mémorisez-le ou conservez-le dans un endroit sécurisé. Confirmez votre code PIN pour terminer la création de votre portefeuille.



Ouvrez l'onglet Finance comme indiqué à l'écran. Vous y trouverez la section Mise en jeu NEAR ; vous devez poursuivre le processus de mise en jeu.



Le portefeuille Opto propose de connecter un portefeuille NEAR ou un compte MyNearWallet. Nous mettrons les jetons NEAR en staking via le nouveau compte Opto créé. Connectez-vous à votre nouveau compte Opto en confirmant votre adresse.



Appuyez sur l'onglet Validators pour choisir un validateur fiable. La liste affiche les frais de chaque validateur, le nombre de participants et le montant total de jetons NEAR mis en jeu. Ensuite, saisissez le nombre de NEAR que vous souhaitez mettre en jeu et appuyez sur Déposer.



Pour terminer le processus de mise en jeu, vérifiez tous les détails et confirmez votre intention.

Si tout a été fait correctement, félicitations ! Maintenant, votre délégation est active et vous commencerez à recevoir des récompenses.


Sender Mobile Wallet
Sender est un portefeuille non-custodial spécialement conçu pour NEAR. Il offre une solution de portefeuille tout-en-un permettant aux utilisateurs d'envoyer, de recevoir, de stocker et de mettre en jeu facilement et en toute sécurité des actifs basés sur NEAR.

La plateforme de l'entreprise proposait initialement un portefeuille d'extension de navigateur non-custodial, et désormais les utilisateurs peuvent également utiliser une version mobile.

Sender est attrayant pour les utilisateurs car le portefeuille leur accorde un contrôle total sur leurs clés privées et propose diverses fonctionnalités intégrées, telles que l'envoi et la réception d'actifs numériques, un échange instantané, une galerie d'NFT et la mise en jeu.

Veuillez vous rendre sur le portefeuille Sender, choisir votre système d'exploitation préféré (iOS ou Android) et installer l'application sur votre téléphone portable.



Après avoir téléchargé le portefeuille, vous pouvez créer un nouveau compte ou utiliser votre compte existant si vous en avez un.

Dans ce guide, nous choisirons la première option et créerons un nouveau compte.

L'application vous demandera de créer et de confirmer un nouveau mot de passe, comme indiqué sur l'image ci-dessous. Veuillez créer un mot de passe fiable et solide. Ne partagez aucun de vos mots de passe avec d'autres personnes et conservez-les dans un endroit sûr.



Pour continuer à utiliser le portefeuille, vous devez également choisir de configurer un code PIN ou d'utiliser Face ID pour sécuriser votre portefeuille.

Pour réserver votre identifiant de compte, vous pouvez choisir un nom de compte lisible par l'homme se terminant par ".near" ou un compte implicite qui est une chaîne de caractères.

Souvenez-vous qu'il est approprié de conserver toutes les informations relatives au portefeuille de crypto hors ligne. Sender vous enverra un avis pour vous rappeler que vous devez sauvegarder de manière responsable vos informations cryptographiques privées.



Le portefeuille générera une phrase secrète de 12 mots aléatoires que vous devez sauvegarder et mémoriser. Le portefeuille vous demandera un mot aléatoire de votre phrase secrète pour s'assurer que vous l'avez bien sauvegardée. Pour terminer la configuration du portefeuille, saisissez le mot et cliquez sur "Créer un compte" pour terminer le processus.

Note : Ne divulgue jamais ta phrase de récupération pour ne pas être victime d'une arnaque.



Ensuite, vous devrez initialiser votre compte pour continuer. Vous devez déposer 0,1 NEAR pour terminer la création de votre compte.

Envoyez suffisamment de NEAR pour initialiser votre compte et pouvoir mettre en jeu avec des validateurs.



Accédez à la section de mise en jeu en cliquant sur le bouton central comme indiqué ci-dessous. Ici, vous devez choisir le validateur avec lequel vous souhaitez mettre en jeu à partir de la liste et indiquer le montant de jetons NEAR que vous souhaitez mettre en jeu.

Note : Vous pouvez choisir n'importe quel validateur, mais nous vous recommandons de choisir des validateurs fiables en qui la communauté a confiance.

Pour finaliser le staking, vous devez cliquer sur le bouton "Staker".



Ensuite, cliquez sur le bouton "Confirmer" pour confirmer vos choix de mise en jeu.

Vous avez réussi à mettre en jeu vos jetons NEAR et vous commencez maintenant à recevoir vos récompenses de mise en jeu.



Pour consulter votre mise en jeu active, rendez-vous sur la page principale. Vous pouvez également retirer vos jetons en cliquant sur le bouton "Retirer" et en indiquant le montant de NEAR que vous souhaitez retirer.

Note : La période de retrait est d'environ 52 à 65 heures (quatre époques).






	

	
	
		
			
				Faut-il passer une vérification pour obtenir un nom de compte lisible par l'homme ?
			
		

		
					

		
			
			
			
			Oui
		
			
			Non, vous pouvez le créer sans vérifier votre personnalité
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
L'écosystème NEAR offre un large éventail de choix de portefeuilles, permettant aux utilisateurs de créer et de gérer facilement des comptes NEAR. Il sert de stockage sécurisé pour les jetons NEAR et permet la mise en jeu pour gagner des récompenses.

La mise en jeu de NEAR offre une méthode efficace pour générer des rendements à partir de vos jetons sur une blockchain. De plus, elle joue un rôle essentiel dans le soutien du fonctionnement des réseaux Proof-of-Stake (PoS).

L'écosystème NEAR autonomise les communautés en facilitant les opportunités de mise en jeu. En offrant une interaction fluide avec la blockchain NEAR grâce à divers portefeuilles, il offre une voie d'accès accessible à l'engagement communautaire.

 

### Guide du débutant sur NameSky : achetez, vendez et gérez en toute sécurité des comptes NEAR en tant que NFT

NameSky est une plateforme conviviale qui permet la négociation de comptes NEAR en tant que NFT sur la blockchain NEAR. Avec ses contrats intelligents audités par @pessimistic_io, NameSky assure une expérience sécurisée pour les utilisateurs. Vous pouvez trouver le rapport d'audit ici et explorer le marché NameSky pour voir les comptes créés en tant que NFT.

Ce guide vous aidera à naviguer sur la plate-forme NameSky, couvrant le processus de transformation d'un compte NEAR en un NameSky NFT, vérifiant le NFT sur votre page de portefeuille NEAR, répertoriant votre NFT sur le marché et reprenant le contrôle d'un compte NEAR en brûlant le NameSky NFT.
Étape 1 : Transformez un compte NEAR en un NFT NameSky
Pour transformer votre compte NEAR en un NFT NameSky, suivez ces étapes :

1- Visitez le site Web de NameSky et cliquez sur "Mint" sur notre site Web.

2- Connectez votre portefeuille NEAR à la plateforme NameSky.

3- Choisissez le compte NEAR que vous souhaitez transformer en NameSky NFT.

4- Lors de la frappe, un contrat de verrouillage sera déployé sur le compte NEAR associé et

toutes les clés d'accès seront supprimées. Cela signifie que seul le propriétaire du NFT (vous) peut accéder au compte NEAR.




	

	
	
		
			
				Vrai ou faux : les contrats intelligents de NameSky ont été audités.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	










    
Étape 2 : Vérifiez le NFT sur la page de votre portefeuille NEAR
Pour voir votre NFT NameSky nouvellement créé :

1- Connectez-vous à votre portefeuille NEAR.

2- Accédez à l'onglet "Collectibles".

3- Vous verrez votre NameSky NFT répertorié avec le compte NEAR joint.


Étape 3 : répertoriez votre NFT sur la place de marché NameSky
Pour lister votre NameSky NFT à vendre :

1- Accédez à une page de détail NFT.

2- Cliquez sur "Sell".

3- Définissez votre prix souhaité.

4- Confirmez votre annonce et votre NFT sera disponible pour que d'autres puissent l'acheter.



 
Étape 4 : Reprenez un compte NEAR en gravant le NameSky NFT
Si vous souhaitez reprendre le contrôle de votre compte NEAR :

1- Visitez votre page de profil NameSky.

2- Localisez le NameSky NFT que vous souhaitez graver.

3- Cliquez sur "Take back the account". depuis le menu déroulant

4- Une nouvelle phrase de récupération sera générée localement sur votre appareil, vous donnant accès au compte NEAR.

5- Le NameSky NFT sera brûlé et vous reprendrez le contrôle total du compte NEAR attaché avec la phrase de récupération de l'étape 4 sur https://wallet.near.org/recover-account

   

NameSky fournit un moyen sûr et facile d'acheter et de vendre des comptes NEAR en tant que NFT. En suivant ce guide, vous pourrez naviguer sur la plateforme et gérer vos comptes NEAR et NFT en toute confiance. Que vous cherchiez à acheter un compte NEAR unique ou à vendre le vôtre, NameSky offre une solution pratique et sécurisée pour vos besoins. Bon apprentissage!

Si vous n'êtes toujours pas sûr du fonctionnement de NameSky, vous pouvez l'essayer par vous-même sur l'application testnet ici : https://testnet.namesky.app




	

	
	
		
			
				Vrai ou faux : lors de la création d'un NFT NameSky, toutes les clés d'accès seront supprimées du compte NEAR associé.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!

### MyNearWallet Password Beta Test

Follow @LearnNEAR and @MyNEARWallet on Twitter

Beta test sprint starts: August 18, 11 am ET
Beta Test sprint ends: August 23, 11 am ET
Requirements:

 	Create a testnet account at https://testnet.mynearwallet.com/
The first step of this account creation process now includes creating a password - used to unlock your wallet and enhance security
 	After you have created the account, refresh your browser - you’ll then be prompted to enter your password to unlock your wallet

 	Make a screenshot with a password prompt

 	Go to https://testnet.mynearwallet.com/profile or click ‘Account’ in the menu. You’ll see a box for Password protection which is currently enabled

 	Disable your password protection by clicking ‘Disable’ - you’ll need to enter your password to confirm

 	Turn password protection on again by clicking ‘Enable’ - you’ll need to enter a new password

 	Tweet your screenshot and  "I just tested new password feature at @MyNEARWallet  via @LearnNEAR Beta test!"
 	Submit feedback form.

Notes:

 	

 	We’re excited to announce that the password option for MyNearWallet is available on testnet

 	This feature is aimed at enhancing user security by allowing the encryption of private keys

 	We have launched this as a beta test programme on Learn NEAR Club to spread the word about this new feature, and to allow for significant testing

 	You can turn off password encryption at any time. WARNING: Disabling password encryption will expose your accounts to a bigger risk

 	If you already have a testnet account, you’ll see an advisory above your wallet to set up a password. This will also apply when we launch on mainnet - if you have an account, you will need to set up your password in the ‘Account’ section of your wallet.



Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic

### What is bigger: MiB or MB?

What is bigger: MiB or MB?
			
		

		
					

		
			
			
			
			MiB
		
			
			MB
		
	
		

		
		
			
				Correct!
				Wrong!
			
			A mebibyte is a unit of measure. It represents 1024 * 1024 bytes.
A mebibyte (a contraction of mega binary byte) is a unit of information or computer storage, symbol MiB.
1 MiB = 1,048,576 bytes = 1,024 kibibytes

A megabyte (MB) is a large number used when talking about hard drives or computer memory. One megabyte is 1 million bytes or 1 thousand kilobytes.
Until December 1998, when the International Electrotechnical Commission (IEC) first defined a mebibyte as 1,048,576 bytes, megabyte also meant either 1,048,576 bytes, or 1,024,000 bytes. Casual computer users still often use megabyte to mean one of these numbers.

So, the correct answer is MiB.

### Comment nCaptcha combat le spam

"nCaptcha" est le dernier produit de Learn Near Club, fournissant une version web3 du classique CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart). Dans ce blog, nous allons d'abord apprendre comment fonctionne le CAPTCHA traditionnel, puis voir comment nCaptcha le renverse.
Comment fonctionne CAPTCHA ?


 Crédit d'image

Vous avez dû tomber sur l'image ci-dessus lors de vos sessions de surf. CAPTCHA a été conçu comme une mesure de sécurité pour aider à protéger les utilisateurs contre le spam et le décryptage des mots de passe.

Curieusement, l'histoire de CAPTCHA est liée aux pirates, le groupe même qu'il vise à conjurer aujourd'hui. À la fin des années 1980 et au début des années 1990, les premiers utilisateurs de forums Internet ont, par inadvertance, jeté les bases des CAPTCHA. Réalisant que les programmes modérateurs surveillaient certains mots-clés sensibles, ils ont conçu une méthode pour contourner cet examen minutieux. Ces utilisateurs ont remplacé des lettres spécifiques dans des mots-clés sensibles par des chiffres ou des symboles, trompant efficacement les bots. Cette stratégie a finalement évolué vers une forme de jargon connu sous le nom de leetspeak.

Cependant, le véritable tournant pour les CAPTCHA est survenu à la fin des années 1990 lorsque des informaticiens ont noté le potentiel de ces distorsions de texte pour contrecarrer les algorithmes des escrocs. Le concept a pris une forme plus formelle lorsque deux équipes distinctes - l'une de l'Université Carnegie Mellon et l'autre de la société de cybersécurité Sanctum - ont développé des méthodes pour empêcher les bots d'utiliser du texte déformé en 1997. Cela a marqué l'aube du CAPTCHA moderne, un outil de sécurité clé qui aide empêcher le vol de données en fournissant une barrière aux programmes automatisés tout en permettant aux utilisateurs humains de passer.
D'accord, mais comment fonctionne le CAPTCHA ?
Le système accomplit cela en demandant aux utilisateurs de passer un test simple, en vérifiant qu'ils sont des humains, et non des ordinateurs tentant de violer un compte sécurisé par mot de passe. Cette épreuve se compose de deux parties :

 	Une séquence de caractères déformée et générée de manière aléatoire sous forme d'image.
 	Une zone de saisie de texte.

Les utilisateurs doivent identifier et reproduire les caractères affichés dans l'image pour reproduire les caractères dans une zone de texte. Cela nécessite un certain niveau de capacité cognitive qui est assez simple pour un humain mais extrêmement complexe pour les bots. En effet, nous avons la capacité d'interpréter les lettres dans différentes polices et écritures manuscrites. Étant donné que les bots ne peuvent pas le faire, ils échouent au test et sont empêchés d'interagir avec l'application ou le site Web.
Google et CAPTCHA
Google implémente CAPTCHA via son système reCAPTCHA. Vous pouvez rencontrer ces CAPTCHA fournis par Google dans les circonstances suivantes :

 	Inscription à un nouveau service Google (comme Gmail, Blogger ou YouTube)
 	Abonnement à n'importe quelle version d'un compte Google Workspace
 	Modification du mot de passe d'un compte existant
 	Configuration des services Google pour un appareil ou une application tiers (tel que iPhone, Outlook, ActiveSync, etc.)

Google utilise CAPTCHA pour protéger les données des utilisateurs et maintenir l'intégrité de son service. Google n'est pas le seul géant du web2 à utiliser CAPTCHA. Il est à peu près partout et largement utilisé.

Il ne fait aucun doute que CAPTCHA a été une mesure de sécurité puissante. Cependant, leur efficacité et leur utilité récentes ont été remises en question.




	

	
	
		
			
				Quelle est la principale méthode utilisée par nCaptcha pour empêcher le spam ?
			
		

		
					

		
			
			
			
			il oblige les utilisateurs à identifier les objets dans les images
		
			
			il utilise l'IA pour détecter les comportements suspects
		
			
			il oblige les utilisateurs à effectuer un mini-dépôt pour les soumissions de formulaires
		
			
			il bloque tous les utilisateurs qui n'ont pas de compte gmail
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Les CAPTCHA ne sont-ils plus efficaces ?
Toute la prémisse des CAPTCHA est qu'une machine ne devrait pas avoir la capacité cognitive d'un humain normal pour déchiffrer ces messages. Les CAPTCHA reposent sur une approche partiellement comportementale. En plus d'évaluer la capacité d'un utilisateur à résoudre le puzzle donné, ces outils surveillent également des actions telles que la vitesse de navigation de la page Web et la courbure du mouvement de la souris. Cependant, au cours de la dernière décennie, les capacités d'apprentissage automatique et d'intelligence artificielle ont considérablement évolué, devenant plus humaines et, dans certains cas, dépassant les capacités humaines à résoudre des énigmes complexes. Les machines, avec leur mémoire étendue et leurs capacités multitâches, peuvent souvent résoudre des puzzles simples comme les CAPTCHA.

De plus, l'émergence de fermes de résolution de CAPTCHA - des services gérés par l'homme qui décodent les CAPTCHA pour les bots - pose un autre défi. Grâce à ces fermes, les bots peuvent résoudre les CAPTCHA en quelques secondes, contournant cette couche de sécurité avec un minimum de dépenses et d'efforts.
Alors, comment atténuez-vous cela?
Le moyen le plus logique d'atténuer la rupture CAPTCHA est d'augmenter la complexité de la tâche elle-même. Cependant, il y a un problème ici. Lorsque vous augmentez la complexité des CAPTCHA, vous rendez également difficile, ou pire, ennuyeux pour les humains de le résoudre. Selon Sandy Carielli, analyste principal chez Forrester, les CAPTCHA peuvent avoir un impact négatif sur l'expérience humaine. Selon le rapport de Carielli, environ 19% des adultes américains ont abandonné leurs transactions en ligne au cours de la dernière année en raison de CAPTCHA complexes.



Crédit image

De plus, voici le kicker. Compliquer le CAPTCHA peut même ne pas fonctionner.

En 2014, Google a opposé un algorithme à l'un de ses CAPTCHA les plus compliqués. L'algorithme a réussi à casser le CAPTCHA, alors que seulement 33 % des utilisateurs humains ont pu le résoudre.

Alors, quelle est la solution ?

Tamer Hassan, co-fondateur et PDG de la société de cybersécurité HUMAN Security, a ceci à dire :

« Nous ne devrions pas tester nos humains ; nous ne devrions pas traiter nos humains comme s'ils étaient des fraudeurs. Nous devrions tester les bots de différentes manières, et donc augmenter les frictions sur les humains n'est pas la voie à suivre.

Tournons-nous vers web3 pour trouver une solution.
nCaptcha – Combattre le spam avec web3
Le nCaptcha de Learn Near Club est une solution innovante et efficace conçue pour lutter contre le spam sur les sites Web. Contrairement aux systèmes CAPTCHA traditionnels, où vous finissez par ennuyer vos utilisateurs avec des textes et des images compliqués, nCaptcha exploite les capacités de la technologie Web3 et blockchain pour l'authentification humaine.

En tant que propriétaire de site Web, l'utilisation de nCaptcha est très simple. Après l'avoir intégré à votre site Web, vos utilisateurs effectuent une microtransaction d'une valeur de 0,01 NEAR. La moitié revient à nCaptcha et l'autre moitié à vous, le propriétaire du site Web.

nCaptcha dissuade les spammeurs en utilisant une combinaison des éléments suivants :

 	Exiger des mini-dépôts pour les soumissions de formulaires. Ce système de mini-dépôt fonctionne comme un mécanisme de vérification à la fois simple pour les utilisateurs authentiques et extrêmement efficace pour dissuader les spammeurs, qui devraient effectuer d'innombrables micro-transactions, rendant ainsi les efforts de spam inefficaces et coûteux.
 	Établir un score de réputation des utilisateurs en chaîne, transparent et immuable.

Voici quelques autres choses à garder à l'esprit à propos de nCaptcha :

 	Vous devez avoir un compte NEAR pour utiliser nCaptcha.
 	Il s'intègre parfaitement à WordPress, avec un plugin de commentaires dédié, ce qui le rend polyvalent et accessible à un large éventail d'applications Web.
 	Il a également une compatibilité élevée avec diverses plates-formes Web2, comblant le fossé entre l'infrastructure Internet conventionnelle et les applications basées sur la blockchain.
 	Son backend décentralisé le rend robuste et résistant aux attaques ou aux perturbations courantes dans les systèmes centralisés.
 	Construit sur JavaScript, il est pris en charge par les navigateurs populaires, offrant ainsi une interface conviviale pour les propriétaires de sites Web et les visiteurs.
 	Il est également disponible sous forme de package NPM, prêt pour le mobile, entièrement réactif et ne nécessite aucun contrat intelligent, ce qui le rend encore plus simple à mettre en œuvre pour les développeurs.




	

	
	
		
			
				Quel inconvénient majeur des CAPTCHA traditionnels nCaptcha résout-il ?
			
		

		
					

		
			
			
			
			la complexité et la gêne des tests CAPTCHA traditionnels
		
			
			le coût élevé de la mise en œuvre des systèmes CAPTCHA traditionnels
		
			
			la lenteur des systèmes CAPTCHA traditionnels
		
			
			la barrière de la langue présentée par les systèmes CAPTCHA traditionnels
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Alors, comment ça marche?
Voyons nCaptcha en action.

Pour utiliser nCaptcha, vous devez d'abord avoir un compte de portefeuille Near nommé comme Satoshi.near ou xyz.near. Cela ne devrait pas seulement être votre adresse publique. Allez sur Lean Near et connectez-vous avec votre portefeuille. Maintenant, allez à la page Contactez-nous.

Faites défiler vers le bas pour voir le widget nCaptcha.



Comme vous pouvez le voir, au lieu de traiter avec un Captcha ennuyeux, il vous suffit de vérifier à l'aide d'une microtransaction.

Cliquez sur "Verify with nCaptcha" pour être redirigé vers ce qui suit :



Cliquez sur "Approve" et terminez votre vérification.



Une fois la vérification effectuée, vous pouvez cliquer sur "Transaction" pour être redirigé vers Near Explorer afin que nous puissions voir ce qui se passe dans les coulisses.

La première moitié de la transaction de vérification 0.01 va au site Web (dans ce cas Learn Near).



La seconde moitié va à nCaptcha.



De cette façon, nous avons un système qui profite à tous :

 	Utilisateur : Pas de temps perdu à parcourir des images stupides.
 	Le propriétaire du site Web : Aucun utilisateur ne se détache d'images compliquées et ne gagne PRESQUE des frais de vérification.
 	nCaptcha : Gagner des frais de vérification.

Cette philosophie gagnant-gagnant est la philosophie même du web3.
Changer le jeu du spam avec nCaptcha
L'efficacité de nCaptcha réside dans sa simplicité et son utilisation innovante des micro-transactions web3. Les CAPTCHA se sont révélés de plus en plus compliqués et inefficaces. nCaptchas offrent une alternative élégante.

Vous pouvez télécharger nCaptcha et obtenir plus d'informations ici.




	

	
	
		
			
				De quoi avez-vous besoin pour utiliser nCaptcha ?
			
		

		
					

		
			
			
			
			un compte avec le principal fournisseur de messagerie
		
			
			Une carte de crédit
		
			
			Un compte NEAR
		
			
			Un haut niveau de compétences en programmation informatique
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### NEAR APAC - UNLIMITED FUTURE

NEAR APAC is the NEAR Ecosystem’s first and largest conference in the APAC region. NEAR APAC will feature a continuous event series from June to September 2023.

The Conference delivers a world-class lineup of speakers to share the latest APAC developments, unlimited potential of the blockchain industry, regional market insights, Web3 hacker festival, and insightful events for networking opportunities with local communities and partners!

What's there in NEAR APAC?

 	8000+ attendees.
 	100+ speakers who are influential Blockchain leaders around the world from NEAR Foundation, Google, Microsoft, Animoca Brands, Chainlink, Circle, and more!
 	50+ top investment funds in the world for Web 2 and Web 3.
 	300+ web3 startup projects.
 	1000+ web2 and web3 developers.
 	100+ leading technology companies and conglomerates in APAC.
 	10+ top technology universities in Vietnam.
 	20+ game studios in the APAC region.
 	100+ media in Vietnam and internationally.
 	5+ blockchain associations in the APAC region.
 	A series of boot camps in various programming languages.
 	A Unitour at top universities in Vietnam.
 	And many more exciting activities will be revealed soon.
 	Web3 Hackfest: The large-scale hackathon festival for web2 & web3 startup builders
 	The Greenhouse: At The Greenhouse, startups will have opportunities to connect with mentors, founders, and top VCs through a 1:1 pitching session and networking activities.

Who is this conference for?

NEAR APAC offers the opportunity to connect blockchain ecosystems, builders, exchanges, investors, Web2 and Web3 businesses, investment funds, universities and global media to promote the steady development of Web 3.

The conference promises to bring a lot of valuable information and opportunities for:

 	Investors who want to know more about market trends and portfolios of the world’s top investment funds
 	Builders who are looking for opportunities to learn, connect, and collaborate with leading experts and business leaders who have been pioneering the global Blockchain industry.
 	Businesses who want to learn and update new Blockchain technology applications to transform themselves and catch up with global trends.
 	Start-ups in any field with Blockchain applications who want to connect with investors, and investment funds to find opportunities or promote brands.
 	Students majoring in IT or interested in the Blockchain industry who want to find for themselves the opportunity to work at a technology company or get involved in the global international environment.
 	The media units who wish to follow up the field of Blockchain technology and approach experts and big wheels in the international Blockchain market.
 	Investment funds who wish to connect with the world’s top funds and share investment opportunities with quality Blockchain projects at the conference.

Conference information

 	Time: 9:30 – 17:00 on September 9-10, 2023.
 	Location: 5th Floor – Thiskyhall Convention – HCMC.
 	Organizers: Near Foundation, GFI, VBI.

How to Register

Grab your tickets here, we support both Eventbrite tickets and NFT tickets (powered by Keypom )

Please follow Near APAC on social media and the page to stay updated with the latest information!

Learn more: https://nearapac.org/

Telegram: https://t.me/near_apac

Twitter: https://twitter.com/nearvietnamhub

Facebook: https://www.facebook.com/nearapac

NEAR APAC has many big side events, the top 2 most interesting ones are Web3 Hackfest and Green House, Let’s find out right below! 
Web3 Hackfest – Unlimited Hacker

Web3 Hackfest with the theme "Unlimited Hacker" is a large-scale hackathon festival for web2 & web3 startup builders, developers, and creators with a series of multichain developer bootcamps, uni tours, workshops, and hackathon, full activities lasting 4 months from June to September 2023.

The event promotes collaboration among multichain ecosystem builders to motivate general ideas and products for Web3 space to solve common issues, create multichain dApps and interoperable solutions. Through the event, each blockchain platform can attract more builders from a large number of multichain and Web2 developers.

A two-part hackathon to unleash your Web3 potential by building revolutionary dApps. Where your skills will be put to the test and innovation knows no bounds.

Get ready for a thrilling series of programming contests: Hack The Future and Web3 Coding Challenge.

Join Web3 Hackfest and win a total prize pool worth 100,000 USD:

https://web3hackfest.org/
The Greenhouse – Nurturing the Next Generation of Blockchain Startups
The Greenhouse is a program designed to support and nurture the growth of blockchain startups in the APAC region. It will be held as a side event at the NEAR APAC event, scheduled for September 9-10, 2023 in HCMC, Vietnam.



“We are excited to launch this program to support the next generation of blockchain startups,” Riley Tran – Managing Director of NEAR APAC Conference said “We believe that blockchain has the potential to revolutionize many industries, and we want to help the most promising startups succeed.”

At The Greenhouse, startups will have opportunities to connect with mentors, founders, and top VCs through a 1:1 pitching session and networking activities. The program also includes workshops and training sessions on important topics like fundraising, marketing, and product development. The goal of The Greenhouse is to provide the necessary resources and support for blockchain startups to succeed in the industry.

Startups building blockchain products/services can apply for The Greenhouse by submitting a proposal by August 8th, 2023.

We will work with VCs to select participating startups.

 	For Start-up: Link
 	For VCs: Link 

For more information please contact:

 	Email: riley@gfigroup.io
 	Telegram: Riley Tran

Learn more about The Greenhouse’s benefits here:

https://nearvietnamhub.org/unlimited-future-explore-the-limitless-future-with-near-apac/
See you in Vietnam!
Mark your calendars for September 9-10, 2023, and join us at the Thiskyhall Convention in HCMC. Don't miss the chance to connect with a world-class lineup of speakers to share the latest APAC developments, the unlimited potential of the blockchain industry, regional market insights, the Web3 Hackfest, The Greenhouse, and so many other interesting events.

With many lucky draws and games with a total prize pool of 300,000,000 VND for attendees, more than 100,000 USD hackathon prizes up for grabs, and many other opportunities during the 2-day conference, NEAR APAC promises to be an unforgettable experience.

Register now and be part of the future of blockchain technology: https://nearapac.org/ticket/

See you in Vietnam this September 🇻🇳!

 

### Стейкинг токенов NEAR, используя разные кошельки

Зачем стейкать NEAR?
"Стейкинг" NEAR представляет собой простой и эффективный метод для повышения безопасности и эффективности сети. Кроме того, он не требует дополнительного оборудования или сложных настроек от держателей токенов. Это простой способ, который позволяет пользователям получать вознаграждение.

Стейкинг токенов NEAR подразумевает участие в сети в качестве делегата. Как делегаты, участники оказывают поддержку валидаторам, которым доверена безопасность сети. В качестве вознаграждения за эту поддержку они получают процент от стейкинга. Этот процент распределяются пропорционально доле каждого пользователя от общей суммы застейканых токенов.

Валидаторы - это организации, которые запускают ноды, проверяют транзакции и производят новые блоки в протоколе NEAR. Валидаторы отвечают за обеспечение безопасности протокола NEAR, и от их работы зависит ваше вознаграждение по стейкингу. При выборе валидатора учитывайте его комиссионные, время работы и послужной список. Список валидаторов можно найти в блокчейн-эксплорере NEAR Explorer.

Делая стейкинг на NEAR, пользователи вносят свой вклад в общую безопасность сети, помогая подтверждать транзакции и защищать блокчейн от потенциальных атак. Такое активное участие не только приносит пользу пользователю, но и укрепляет всю экосистему.

Ниже представлены некоторые из широко используемых вариантов кошельков, доступных для стейкинга NEAR. Вы можете выбрать тот кошелек, который лучше всего соответствует вашим требованиям и предпочтениям.
NEAR Wallet
NEAR Wallet - это веб-кошелек для блокчейна NEAR, не требующий хранения, в котором пользователи могут отправлять и получать токены NEAR или NEP-141. Это простой и удобный кошелек, который позволяет пользователям управлять, хранить и стейкать NEAR. Кошелек представляет собой встроенный в браузер и веб-кошелек, который пользователи могут использовать для создания кошелька NEAR.

Сначала вам необходимо создать учетную запись NEAR. Перейдите на сайт Near Wallet и нажмите кнопку "Create account". Если у вас уже есть кошелек, нажмите "Import Existing Account".



Есть возможность узнать больше о NEAR перед созданием аккаунта.



Вам необходимо выбрать метод восстановления доступа к вашему кошельку. NEAR Wallet поддерживает два варианта:

- Через начальную фразу (Secure Passphrase).

- Через подключение аппаратного кошелька Ledger.



Примечание: Near Wallet поддерживает аппаратный кошелек Ledger. Вы можете войти в кошелек с его помощью, если у вас есть такое устройство. Использование кошелька Ledger - самый безопасный способ защитить свои NEAR.

После выбора метода безопасности нажмите кнопку ниже, чтобы продолжить создание кошелька. Мы покажем процесс использования фразы восстановления.

На экране появится начальная фраза, состоящая из 12 слов. Самый надежный способ сохранить эту фразу - записать ее на бумаге и хранить в надежном месте. Затем нажмите кнопку "Continue".



Важно: Не делайте скриншотов во время сохранения фразы восстановления и не копируйте ее в буфер обмена. Сохранение фразы восстановления в виде скриншота или текста на телефоне или ноутбуке подвергает ее опасности кражи. Никогда и никому не сообщайте свою фразу восстановления.

Подтвердите начальную фразу. На следующем шаге необходимо ввести фразу восстановления.



После этого, ваш кошелек готов к использованию.



На главной странице NEAR wallet нажмите на кнопку Staking.



Во-первых, если у вас несколько аккаунтов, вы должны выбрать тот, с которого вы будете стейкать NEAR. Затем необходимо выбрать валидатора для делегирования токенов.



Нажмите "Stake My Tokens" и выберите валидатора. Всегда самостоятельно исследуйте валидатора при его выборе. В кошельке будет показана комиссия валидатора.

Примечание: Обратите внимание на то, что Near использует нестандартные адреса в формате everstake.poolv1.near вместо длинных шестнадцатеричных слов, как адреса Bitcoin и Ethereum.



Для того, чтобы продолжить процесс стейкинга, нажмите "Stake With Validator". Введите количество токенов NEAR, которые вы хотите делегировать. Выберите опцию Use Max, чтобы стейкинг на все имеющиеся в вашем кошельке токены, и нажмите "Submit stake". Не забудьте зарезервировать часть токенов для оплаты комиссии за вывод средств.



Наконец, нажмите Confirm, чтобы произвести транзакцию.



Проверка транзакции занимает некоторое время. Это занимает несколько мгновений. Когда все будет готово, вы увидите следующее сообщение:



Вы можете проверить свой стейкинг и вознаграждения на dashboard.



Примечание: Вознаграждения автоматически реинвестируются, но вы можете вывести деньги, как только кнопка снятия станет доступной.

Токены будут разблокированы через четыре полных эпохи - примерно через 52-65 часов.

Если вам нужно разблокировать свои токены, выберите "Unstake" в разделе Staking и выберите своего валидатора.



Выберите количество токенов, которые вы хотите снять с учета, или нажмите кнопку Использовать максимум. Затем нажмите кнопку "Unstake Token".



Чтобы продолжить разблокировку токенов, подтвердите транзакцию.



Если вы всё сделали правильно, то вы увидите надпись "Success".






	

	
	
		
			
				Стоит ли вам делиться вашей фразой восстановления с вашими друзьями
			
		

		
					

		
			
			
			
			Да
		
			
			Нет
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Mobile wallet
NEAR Mobile - это удобный кошелек, разработанный компанией Peersyst. NEAR Mobile - это простой и безопасный кошелек. Кошелек позволит вам отправлять и получать NEAR, управлять вашими NFT, а также стейкать NEAR. NEAR Mobile позволяет управлять и импортировать несколько аккаунтов на вашем телефоне, чтобы всегда иметь контроль над вашими активами.

Чтобы начать стейкинг, перейдите на официальный сайт NEAR Mobile и скачайте кошелек. Приложение NEAR Mobile доступно в App Store и Google Play.



Откройте приложение на своем устройстве и нажмите кнопку Создать аккаунт, чтобы начать создание аккаунта. Если у вас уже есть кошелек, нажмите Импортировать NEAR Wallet.



Далее вы увидите важную информацию о кошельке NEAR и фразу восстановления. Прочитав ее, нажмите кнопку Generate Mnemonic.

 



Помните, что фраза восстановления имеет решающее значение для доступа к вашему кошельку и его восстановления. Поэтому необходимо надежно хранить ее. Мы рекомендуем записать фразу для восстановления и держать ее доступной только для вас. Другой вариант - использовать специализированное устройство, предназначенное для хранения фразы восстановления.

Не делайте скриншоты фразы, так как это может привести к несанкционированному доступу к ней. Важно никогда и никому не сообщать фразу восстановления.

Чтобы перейти к следующему шагу, выберите слова из вашей фразы восстановления в правильном порядке.



Вы должны создать пароль, чтобы предотвратить доступ неавторизованных третьих лиц к вашему кошельку и подтверждение транзакций без вашего разрешения. Вы можете использовать биометрическую аутентификацию для доступа к кошельку.



Блокчейн NEAR был разработан для простоты, с гибкой моделью аккаунтов и удобными для чтения людьми адресами - любое имя пользователя вместо строки букв и цифр. Перейдя на красочную вкладку с информацией об аккаунте, вы найдете возможность импортировать еще один аккаунт или создать собственный.

Чтобы пополнить кошелек, нажмите кнопку Receive, скопируйте адрес кошелька и отправьте токены NEAR с биржи или другого аккаунта на свой адрес.



Перейдите в раздел "Staking". Откроется dashboard для ваших поставленных токенов, включая вознаграждения и сумму стейкинга.

Выберите пункт Stake my tokens, чтобы начать процесс стейкинга.



Введите сумму, которую вы хотите делегировать, и нажмите Next. Выберите надежного валидатора из списка или начните вводить его название в строке поиска, чтобы найти его быстрее.

Проверьте детали транзакции, и если все правильно, нажмите Next.



После завершения транзакции нажмите кнопку Continue, и вы получите уведомление об успешно размещенных токенах.



В разделе "Staking" вы можете управлять суммой стейкинга. Вы можете снять средства со стейкинга, нажав на кнопку "Unstake" и указав, какую именно сумму вы хотите снять.

Примечание: Период разблокировки токенов составляет примерно 52-65 часов (четыре эпохи).






	

	
	
		
			
				Сколько составляет период разблокировки токенов?
			
		

		
					

		
			
			
			
			14 дней
		
			
			24-36 часов
		
			
			Примерно 52-65 часов
		
			
			Мгновенно
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meteor Wallet
Кошелек Meteor был основан командой, состоящей из звезд, которые основали такие первоклассные проекты, как Near Tinker Union и Enleap Near на NEAR Protocol.

Meteor - это простой и безопасный кошелек: все зашифровано, и ничего конфиденциального не регистрируется. Кошелек позволяет пользователям собирать NFT, получать доступ к DeFi и исследовать все, что связано с Web3.

Meteor Wallet имеет несколько ключевых целей, таких как облегчение массового принятия web3 и становление лучшим кошельком NEAR. Он стремится создать здоровую конкуренцию с другими заметными проектами, такими как MyNear, Sender, HERE и собственный кошелек NEAR.

В настоящее время Meteor доступен как в виде веб-кошелька, так и в виде расширения для браузера.

Прежде чем делать стейкинг NEAR, необходимо создать и пополнить криптовалютный кошелек.

Перейдите на сайт Meteor Wallet и выберите между веб-версией и версией расширения. В этом руководстве мы будем делать стейкинг NEAR с помощью веб-версии.



Перейдите к следующему шагу, нажав кнопку "Get started".



На главном экране кошелька Meteor Wallet доступны две опции:

 	Создать новый кошелек;
 	Импортировать существующий кошелек.

Мы создадим новый, чтобы показать весь процесс с нуля. Сначала нажмите кнопку "Create a new Meteor Wallet".



Пароль необходим для того, чтобы неавторизованные третьи лица не могли войти в кошелек и подтвердить транзакции без вашего согласия. Создайте сложный пароль и нажмите кнопку "Continue".



Каждый аккаунт NEAR идентифицируется по определенному адресу. Исходя из названия, адреса бывают двух типов:

 	Именованные учетные записи с именами, например alice.near;
 	Неявные учетные записи, обозначаемые строкой из 64 символов.

Выберите тот вариант, который вам больше нравится.



Резервное копирование кошелька - самый важный шаг. Вы можете восстановить доступ к средствам на другом устройстве, используя секретную фразу восстановления. Никогда и никому не сообщайте свою фразу.



Выберите первое и последнее слова из вашей фразы восстановления, чтобы подтвердить, что вы сохранили всю фразу.



Прежде чем приступить к стейкингу, необходимо пополнить счет. Скопируйте адрес своего кошелька, нажав на Account. Используйте его для отправки токенов на свой кошелек. Как только вы пополните свой кошелек, вы сможете приступить к стейкингу.



Чтобы перейти к стейкингу нажмите кнопку "Stake", как показано ниже.



Выберите "Standard Staking".



Далее, нажмите на кнопку "Create New Staking".



Выберите количество токенов, которые вы хотите делегировать и выберите желаемого валидатора, нажав на кнопку "Select Your Validator"



На экране появится список доступных валидаторов. Найдите валидатора, которому вы хотите делегировать токены NEAR. Вы можете сделать стейкинг у несколько валидаторов. Для быстрого поиска начните вводить имя валидатора в поле, а затем нажмите на него.



Meteor Wallet показывает предполагаемый доход за несколько периодов, чтобы вы могли узнать, сколько вознаграждений вы получите.



Указав количество токенов и валидатора, нажмите "Stake"



Наконец, проверьте детали транзакции и нажмите "Confirm", чтобы застейкать токены.



Вы удачно застейкали токены NEAR.

Вы также можете вывести ваши токены, нажав на кнопку "Unstake", указав количество токенов для вывода.

Примечание: Период разблокировки токенов составляет примерно 52-65 часов (четыре эпохи).




	

	
	
		
			
				Возможно ли стейкать токены у разных валидаторов?
			
		

		
					

		
			
			
			
			Да
		
			
			Нет
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nightly Wallet
Nighty Wallet это кроссблокчейн кошелек, который в настоящее время работает на NEAR, Solana и Aptos и доступен в качестве расширения для Chrome и Firefox на вашем мобильном телефоне. Nightly Wallet является ключом к Metaverse, предоставляя такие функции, как свап токенов, стейкинг, обёрнутый стейкинг и отображение NFT на каждом блокчейне. Nightly уже интегрирован в NEAR Wallet Selector.

Они считают, что у NEAR впереди большое будущее. Блокчейн NEAR - суперпроизводительная, дешевая, и сообщество вокруг нее растет большими темпами. Но у NEAR, по их мнению, есть одна большая проблема - нет хорошо проработанного кошелька. Их цель - решить эту проблему.

Для того, чтобы начать стейкинг NEAR в этом кошельке найдите в Nightly Wallet и выберите предпочитаемый браузер, (Firefox and Chrome).



В данном руководстве мы используем браузер Chrome. Установите расширение, нажав кнопку "Добавить в Chrome".



На странице расширения нажмите кнопку Добавить расширение, чтобы одобрить установку плагина.



Теперь откройте расширение Nightly в браузере.



В этом окне вы можете либо восстановить существующий кошелек, либо создать новый. Если у вас уже есть кошелек Nightly Wallet, вы можете восстановить его и перейти к следующему шагу. Чтобы создать новый, нажмите "Create new wallet".



Создайте пароль для своего кошелька. Прислушайтесь к рекомендациям по безопасности и выберите надежный пароль. Подтвердите пароль и нажмите "Create Wallet".



Далее вы увидите свою фразу восстановления. Никому не сообщайте свою фразу. Эти случайно сгенерированные слова являются ключами к вашему кошельку. Если вы забудете их, вы потеряете доступ к своим средствам. Запишите свою фразу восстановления на бумаге и нажмите "Next".



Введите вашу фразу восстановления, чтобы подтвердить что вы её записали.



Далее, выберите "NEAR".



Теперь вы можете вносить, отправлять, обменивать и стейкать NEAR. Ознакомьтесь с основными функциями на dashboard.



Теперь ваш Nightly Wallet готов к следующему шагу: Стейкинг. Откройте кошелек, коснитесь значка NEAR и нажмите кнопку "Start earning".



Nightly предлагает 2 варианта стейкинга: обёрнутый и обычный. При обычном стейкинге вы будете получать токены NEAR в качестве вознаграждения. Обёрнутый стейкинг предлагает другие условия: пользователи могут вносить токены, но взамен будут получать "обернутые" токены. Основное отличие обёрнутого от обычного стейкинга заключается в том, что вам не нужно замораживать свои активы. Однако фактически вам придется заблокировать свой токен, но затем вы получите новый - stNEAR или NEARx.

Чтобы получить токены NEAR в качестве вознаграждения, выберите Regular Staking.



Чтобы делегировать токены, нажмите на иконку "плюс".



Этот экран отображает список валидаторов. Выберите один из них.



Далее, введите сумму которую вы хотите отправить в стейкинг и нажмите кнопку "Next".



Теперь ваша делегация активна, и вскоре вы начнете получать вознаграждения.



Вы всегда можете посмотреть информацию о своем стейкинге, нажав на кнопки "Start Earning" и "Regular Staking".



Если вы хотите вывести свои токены, вам нужно нажать кнопку "Unstake". Обратите внимание, что период разблокировки составляет примерно 52-65 часов (четыре эпохи).






	

	
	
		
			
				Какой токен вы будете получать, если выберете regular стейкинг?
			
		

		
					

		
			
			
			
			NEARx
		
			
			stNEAR
		
			
			NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ledger live
Ledger Live - это платформа для покупки криптовалют, размещения своих активов и управления NFT. Она функционирует как безопасный шлюз в экосистему криптовалют. Приложение Ledger Live позволяет управлять различными токенами и совершать с ними операции. Кроме того, вы можете приумножать свои криптовалюты, используя процесс торговли и стейкинг, доступный в приложении Ledger Live.

Для полного доступа к функционалу Ledger Live, вам необходимо иметь устройство Ledger. Устройство Ledger - это криптокошелек автономного (холодного) хранения, а также использования лучших стандартов защиты, продукция Ledger является одним из самых надежных методов для хранения криптовалюты.

Перейдите на официальный сайт Ledger и нажмите кнопку "Загрузить". В настоящее время пользователи могут скачать Ledger Live для Windows, macOS и Linux. Мобильная версия доступна для пользователей Android и iOS.



Выберите свою операционную систему, установите приложение на компьютер и откройте его. Затем нажмите на кнопку "Get started". Вы можете получить доступ к его полной функциональности, если у вас есть устройство Ledger.



Включите ваш Ledger и введите пароль.



Одобрите ввод в приложение, нажав две кнопки. Теперь вы можете пользоваться приложением.



Итак, вот главное меню Ledger Live. Установите последнюю версию приложения NEAR на ваше устройство Ledger, чтобы начать процесс стейкинга. Зайдите в Каталог приложений и напишите "NEAR" в строке поиска. После этого нажмите кнопку "install".



После установки "NEAR app", добавьте ваш аккаунт NEAR, нажав на кнопку "add account".



Вы можете добавить несколько аккаунтов.



После того как вы подключили ваш аккаунт, нажмите на кнопку "Done".



Прежде чем совершить стейкинг, вы должны отправить токены NEAR на свой кошелек. Пропустите этот шаг, если они у вас уже есть, и переходите непосредственно к стекингу.

Найдите раздел "Account", чтобы добавить средства на свой Ledger Live. Выберите аккаунт NEAR. Затем нажмите кнопку "Receive".



Выберите нужный вам аккаунт и нажмите "Continue".



Убедитесь, что адрес общего доступа точно совпадает с адресом на вашем устройстве. Выберите "Approve" на устройстве и нажмите две кнопки на Ledger.



Если всё хорошо, скопируйте адрес. Закончите процесс, нажав "Done".



Далее вы можете купить токены NEAR на любой крипто валютной бирже. Отправьте их на адрес вашего кошелька. После завершения транзакции вернитесь в свой Ledger Live.

Откройте вкладку "Accounts tab" и нажмите кнопку "Staking", чтобы начать процесс стейкинга.



Далее, вы увидите информацию о стейкинге NEAR. Прочитайте её и нажмите на кнопку "Continue".



Затем вам нужно выбрать валидатора, которого вы хотите делегировать. Нажмите кнопку "Show all", чтобы увидеть полный список валидаторов.



В новом окне введите "Everstake" в поле поиска и выберите его из списка. Нажмите кнопку "Continue".



Затем введите сумму, которую вы хотите поставить. Вы также можете выбрать все, нажав на кнопку "Use all", чтобы поставить весь свой баланс (за вычетом комиссии за транзакцию). Сумма комиссии сети будет показана на вкладке "Staking tab".



Вам необходимо подтвердить транзакцию на вашем устройстве Ledger Device. Нажмите кнопки на своем устройстве, как показано на рисунке ниже.



Теперь вы успешно делегировали ваши токены. Нажмите "View details", чтобы увидеть детали транзакции.



Вы можете просмотреть свой статус и транзакцию, проверив ее хэш в Explorer.



Вы можете отслеживать свою ставочную позицию, перейдя на вкладку "Accounts tab".






	

	
	
		
			
				Будете ли вы обладать полным доступом к функциям Ledger live без самого устройства Ledger?
			
		

		
					

		
			
			
			
			Да
		
			
			Нет
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Omni Wallet
Omni - это приложение-кошелек нового поколения Web3. Это ребрендированный кошелек SteakWallet. Omni - это криптовалютный кошелек с полным набором услуг, который позволяет без проблем делать стейкинг на различные токены, управлять активами кросс-цепочки, а также коллекционировать NFT.

Чтобы начать процесс торговли, вам необходимо загрузить приложение и создать кошелек Omni.

Пожалуйста, перейдите на сайт Omni Wallet, выберите предпочтительную операционную систему (iOS или Android) и установите приложение на свой мобильный телефон.





После установки перейдите в приложение OMNI Wallet и нажмите кнопку "Let's go". Чтобы продолжить использование кошелька, вам также необходимо выбрать Создать пароль или же Использовать Face ID для защиты кошелька. Если у вас есть учетная запись OMNI, вы можете импортировать ее или создать новую. Чтобы импортировать существующий кошелек, нажмите кнопку "Import an existing wallet". Ваш Ledger также может быть подключен к OMNI.



Следующий шаг - это ваша секретная фраза. Кошелек сгенерирует случайную секретную фразу, которую вы должны сохранить и запомнить. Чтобы завершить настройку кошелька, необходимо ввести фразу из 12 слов в правильном порядке и нажать кнопку "Next".

Примечание: Защитите свою секретную фразу. Любой, у кого есть эта фраза, будет иметь контроль над вашими средствами. Если вы потеряете ее, вы потеряете доступ к вашему кошельку.



Самообеспечивающийся кошелек Omni делает многоцепочечный стейкинг простым и быстрым. Все сложности, связанные со стейкингом, абстрагируются и сводятся к трем простым нажатиям на вашем мобильном устройстве.

На главном экране нажмите кнопку "Earn". Прокрутите вниз меню "Staking" и выберите NEAR. На устройстве появится экран ставок NEAR. Чтобы продолжить процесс стейкинга, нажмите кнопку "Stake NEAR".

Примечание: Для успешного стейкинга и покрытия комиссии за газ вам необходимо не менее 0,05 NEAR.



Откроется экран информации о стейкинге. Нажмите кнопку "Let's go". Введите сумму NEAR, которую вы хотите поставить, и нажмите "Next".



Проверьте комиссию сети и откройте список валидаторов, перейдя на вкладку "Staked with". Выбор ответственного валидатора - залог безопасности ваших средств и доходов.

После выбора валидатора нажмите кнопку "Confirm stake".

Примечание: Вы можете нажать на стрелку рядом с Average, чтобы выбрать размер сетевой комиссии. Придерживайтесь рекомендованного Omni размера сетевой комиссии, чтобы обеспечить надлежащую обработку транзакции.



После подтверждения вы получите информацию о том, что вы успешно сделали стейкинг NEAR.



Чтобы просмотреть свой активный стейкинг, перейдите на главную страницу. Там же вы можете увеличить объём стейкинга, сделать стейкинг на несколько валидаторов. Период вывода средств со стейкинга составляет примерно 52-65 часов.
Opto Wallet
Opto Wallet - это мобильный кошелек для протокола NEAR и сети Octopus. Это безопасный кошелек с открытым исходным кодом, не требующий хранения, который позволяет пользователям переводить свои токены NEAR и стейкать их.

Opto Wallet - это кошелек с открытым исходным кодом и Bio Auth. Он предлагает изучить встроенный браузер dApp, в котором пользователи могут легко находить удивительные dApps NEAR, управлять своими любимыми приложениями и взаимодействовать с ними. Opto Wallet доступен для iOS и Android и поддерживает Ledger.

Выполните следующие шаги, чтобы сделать стейкинг на NEAR. Вам необходимо установить Opto Wallet на свое устройство. Для этого перейдите на официальный сайт Opto Wallet, выберите предпочтительную операционную систему (iOS или Android) и загрузите приложение.



Откройте приложение Opto Mobile Wallet. Вы находитесь на начальном экране Opto Wallet. В этом окне вы можете либо восстановить существующий кошелек, либо создать новый. Чтобы создать новый, нажмите "Create".

На следующем этапе вы получите свою фразу восстановления. Никто не имеет доступа к этой фразе. Если вы забудете ее, вы потеряете доступ к своим средствам. Пожалуйста, храните фразу восстановления в надежном месте.

Примечание: Важно не делать скриншоты и не копировать фразу в буфер обмена. Лучший способ - записать ее так, чтобы никто другой не смог добраться до ключевых слов.

Теперь выберите PIN-код для защиты вашего кошелька. Вы будете использовать этот код для входа в свой аккаунт в Opto. Запомните его или храните в надежном месте. Подтвердите свой PIN-код, чтобы завершить создание кошелька.



Откройте вкладку "Finance tab", как показано на экране. Там есть раздел NEAR Staking; там вам следует продолжить процесс стейкинга.



Кошелек Opto предлагает подключить аккаунт NEAR Wallet или MyNearWallet. Мы будем делать стейкинг на NEAR через вновь созданный аккаунт Opto. Войдите в новый аккаунт Opto, подтвердив свой адрес.



Нажмите вкладку "Validators tab", чтобы выбрать надежного валидатора. В списке отображается комиссия каждого валидатора, количество валидаторов и общее количество поставленных токенов NEAR. Затем введите количество NEAR, которое вы хотите внести, и нажмите кнопку "Deposit".



Чтобы завершить процесс стейкинга, проверьте все детали и подтвердите свое намерение.

Если все было сделано правильно, поздравляем! Теперь ваша делегация активна, и вы начнете получать вознаграждения.


Sender Mobile Wallet
Sender - это свободный кошелек, разработанный специально для NEAR. Это универсальный кошелек, позволяющий пользователям легко и безопасно отправлять, получать, хранить активы на базе NEAR и стейкать.

Сначала платформа компании предлагала свободный кошелек с расширением для браузера, а теперь пользователи могут использовать и мобильную версию.

Sender привлекателен для пользователей, поскольку кошелек предоставляет им полный контроль над их приватными ключами и предлагает различные встроенные функции, такие как отправка и получение цифровых активов, мгновенный свап, галерея NFT и стейкинг.

Перейдите на сайт кошелька Sender, выберите предпочтительную операционную систему (iOS или Android) и установите приложение на свой мобильный телефон.



После загрузки приложения вы можете создать новый аккаунт или использовать уже существующий, если он у вас есть.

В этом руководстве мы выберем первый вариант и создадим новую учетную запись.

Приложение попросит вас создать и подтвердить новый пароль, как показано на рисунке ниже. Пожалуйста, создайте надежный и сильный пароль. Не сообщайте свои пароли другим людям и храните их в надежном месте.



Чтобы продолжить использование кошелька, вам также необходимо выбрать установку пароля или использование Face ID для защиты кошелька.

Для резервирования идентификатора аккаунта можно выбрать либо имя аккаунта, оканчивающиеся на ".near", либо аккаунт, представляющий собой строку символов.

Следует помнить, что всю информацию, связанную с криптокошельком, целесообразно сохранять в автономном режиме. Sender отправит уведомление, чтобы напомнить вам о необходимости ответственного сохранения приватной криптовалютной информации.



Кошелек сгенерирует случайную фразу восстановления из 12 слов, которую вы должны сохранить и запомнить. Кошелек предложит вам ввести случайное слово из вашей фразы, чтобы убедиться, что вы ее сохранили. Чтобы завершить настройку кошелька, введите слово и нажмите кнопку "Create account", чтобы завершить процесс.

Примечание: Никогда не разглашайте свою фразу восстановления, чтобы не быть обманутым.



После этого вам нужно будет подтвердить свой аккаунт, чтобы продолжить. Для завершения создания аккаунта вам необходимо внести 0,1 NEAR.

Отправьте достаточное количество NEAR, чтобы подтвердить свой аккаунт и иметь возможность делать стейкинг с валидаторами.



Перейдите в раздел стейкинга, нажав на центральную кнопку, как показано ниже. Здесь вам нужно выбрать из списка валидатора, на котором вы хотите стейкинг, и ввести количество токенов NEAR, которое вы хотите застейкать.

Примечание: Вы можете выбрать любого валидатора, но мы рекомендуем выбирать надежные валидаторы, которым доверяет сообщество.

Для завершения стейкинга вам нужно будет нажать кнопку "Stake".



Затем нажмите кнопку "Confirm", чтобы подтвердить стейкинг.

Вы успешно застейкали свои токены NEAR, и теперь вы будете получать вознаграждение за стейкинг.



Чтобы посмотреть свой активный стейкинг, перейдите на главную страницу. Там же вы можете снять свои токены, нажав кнопку "Unstake" и введя сумму NEAR, которую вы хотите снять.

Примечание: Период вывода средств составляет примерно 52-65 часов (четыре эпохи).






	

	
	
		
			
				Нужно ли вам подтвертверждать вашу личность для создания аккаунта, оканчивающегося на .near?
			
		

		
					

		
			
			
			
			Да
		
			
			Нет, можно создать аккаунт без подтверждения личности
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Заключение
Экосистема NEAR предлагает широкий выбор кошельков, позволяя пользователям легко создавать и управлять аккаунтами NEAR. Он служит безопасным хранилищем токенов NEAR и позволяет делать стейкинг для получения вознаграждений.

Стейкинг NEAR предлагает эффективный метод получения дохода от ваших токенов на блокчейне. Кроме того, он играет важную роль в поддержке работы сетей Proof-of-Stake (PoS).

Экосистема NEAR расширяет возможности сообществ, предоставляя возможности для стейкинга. Обеспечивая беспрепятственное взаимодействие с блокчейном NEAR через различные кошельки, она предлагает доступный путь для вовлечения сообщества.

### Are you ready for migration from wallet.near.org?

Migration ended

### How to prepare for NEAR Wallet changes

When NEAR launched its mainnet in 2020, it also launched a wallet built and hosted by the Near Inc. (then Pagoda.) core team at https://wallet.near.org to support its unique account model. Today, an array of open-source wallets call the NEAR wallet ecosystem home. As NEAR continues its decentralization drive, it significantly changes its wallet ecosystem. Let’s look closer at the changes in question, their impact, and how users can prepare for them.
💡IMPORTANT HINT

 	Always backup your recovery phrase
 	First try to migrate a "non-essential" account to test how the process works for you

Incoming Changes 
NEAR’s mission has been to create and support a vibrant Web3 ecosystem. Over the next few months, Pagoda will begin migrating the original NEAR wallet domain from a browser wallet to a wallet hub. This will allow the domain to become a reference point for all NEAR wallets, enabling users to discover, select, and implement the wallet that suits their requirements and giving them greater flexibility as they navigate the Web3 space. Wallet holders are encouraged to migrate their accounts to new ecosystem wallets, and the team has also created tutorials with step-by-step instructions to simplify the process.

NEAR aims to create a thriving ecosystem consisting of multiple wallets. For this, a single point of integration for developers building on the protocol is vital. The new ecosystem will offer users over 30 wallet options, making it easy for users from other ecosystems to interact with the NEAR blockchain using a wallet they are already familiar with. This strategy enables a thriving ecosystem of wallets on NEAR, making Web3 as easy to use as Web2.
Transferring Your Accounts From NEAR 
If you currently use https://wallet.near.org as your primary wallet, you can use the Wallet Transfer Wizard to complete the migration without risking your funds. The Wizard will also allow you to select between Browser and Extension-based wallets, ensuring you have the same experience you are accustomed to even after the migration.

NEAR Wallet will continue to function as a browser wallet until the 31st of October, 2023. Users are encouraged to transfer their accounts to a new provider before the date lapses. This can be done manually using the recover phrase or the Transfer Wizard to securely migrate the accounts to their preferred wallet. Furthermore, even if users have not transferred their accounts by the 31st of October, 2023, the transfer wallet will still be available, even after the wallet functionality ceases.

Let’s look at the different methods available for users to transfer their accounts.
Using The Recovery Phrase 
Importing the recovery phrase is the most familiar way for users to transfer their accounts to a new wallet. However, if you wish to ensure your accounts’ security or transfer multiple accounts, we highly recommend using the Wallet Transfer Wizard. Should you choose to go ahead and use the recovery phrase, you will first be required to disable two-factor authentication (2FA). This can be done through your account settings under the “Security & Recovery” tab on the current wallet.near.org domain—Disable two-factor authentication in all accounts before migrating to another wallet provider.

Turning off two-factor authentication is critical because it will no longer be supported, rendering your account inaccessible until 2FA is disabled. However, if you use the Transfer Wizard, it will automatically disable 2FA, along with email and phone verification.
Using Ledger 
If you use a Ledger to secure your account, you have the option of importing your account to hardware-supported wallets such as the Sender Wallet or Nightly Wallet. However, it is essential to remember that Ledger-secured accounts cannot be transferred using the Transfer Wizard. Just as you did when migrating using the Recovery Phrase option, you will be required to disable 2FA. This can be done by accessing “Account Settings” under the “Security & Recovery” Tab. Disable 2FA in all accounts before migrating to another wallet provider.
Using The Wallet Transfer Wizard (Highly Recommended) 
The Wallet Transfer Wizard allows users to transfer all their connected accounts seamlessly and offers a thorough security checkup to ensure that all accounts are safe. The Wizard also provides:

 	A step-by-step guide on removing old access keys.
 	Bulk transfer of connected accounts to the wallet of your choice.
 	Key rotation.

The Transfer Wizard helps improve your connected accounts’ security before migrating them to a new wallet. It does this by rotating your keys, cleaning up the old keys, and securely transferring your accounts. The Wizard can be accessed from the banner at the top of the wallet.near.org page.




	

	
	
		
			
				Which Is The Most Familiar Way For Users To Transfer Their Accounts?
			
		

		
					

		
			
			
			
			Using The Recovery Phrase
		
			
			Using The Ledger
		
			
			Using The Wallet Transfer Wizard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Does The Wallet Transfer Wizard Work? 
Now, let’s take a quick look at how the Wallet Transfer Wizard functions.
Step 1: Securing Your Account 
We recommend rotating your keys and generating a new 12-word recovery phrase, similar to how you would update your password. Securing your account involves the following steps.

 	Generate a new 12-word recovery phrase.
 	Verify the new recovery phrase.
 	Save the newly generated recovery phrase in a secure location or write it down on a piece of paper. Additionally, you must also confirm the account it recovers and ensure that you don’t mix it up with the old recovery phrase.


Step 2: Clean Up The Keys 
The next step is to clean up your keys. This step is vital because NEAR wants to reduce the number of apps that the keys have been shared with. Once this step is executed, you may be disconnected from some apps. Cleaning up your keys involves three steps.

 	Review the suggested keys you wish to remove.
 	Enter the recovery phrase to confirm the removal.
 	Remove all outdated keys. Once completed, you may need to log back into certain apps if their limited access keys have been removed.


Step 3: Transfer Accounts 
Now, use the Wallet Selector and choose the wallet to which you wish to transfer your accounts. Transferring your accounts involves the following steps.

 

 	Select the wallet you wish to transfer your accounts to.
 	Next, select the accounts you wish to transfer.
 	Copy a temporary password and secure the account transfer.
 	Enter the password into the destination wallet.
 	Complete the wallet setup and account transfer by following the accompanying instructions. However, this step may vary from wallet to wallet.
 	Once you have completed all the steps listed above, confirm that you have access to all your accounts in the new wallet. Once confirmed, return to wallet.near.org and complete the transfer process.






	

	
	
		
			
				What Is The Recommended Method For Users To Transfer Their Accounts?
			
		

		
					

		
			
			
			
			Using The Ledger
		
			
			Using The Recovery Phrase
		
			
			Using The Wallet Transfer Wizard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Step 4: Log Out Of Near.org 
The last step is to log out of your NEAR wallet and start using your new wallet.

 	Once the account transfer has been completed, return to wallet.near.org and click “Complete.”
 	Check if you have access to all your accounts in the new wallet.
 	Log out of all accounts located on near.org.
 	Once completed, you are set to use your new wallet and manage your accounts.


How to migrate to HERE Wallet
Login via web wallet is the easiest way to export your account to HERE.

It just takes 3 clicks!

https://youtu.be/j2JFDJnUiCc

 
How to migrate to Sender Wallet
Discover a step-by-step guide prepared by Sender Wallet to ensure a safe and secure asset migration process. Migrate your assets swiftly and smoothly with Sender's comprehensive instructions.
Supported Wallets
The Transfer Wizard supports a number of wallets. If you wish to learn more about the supported wallets or do a comparison, you can refer to this Google Sheet. Some of the supported wallets include MyNearWallet, HERE Wallet, Meteor Wallet, Sender Wallet, Welldone Wallet, and Nightly Wallet.

In Closing

With these changes, NEAR is entering a new era and taking a significant step toward achieving a truly decentralized ecosystem controlled and driven by its community. This new ecosystem will help enhance user experience, with the wallet hub and wallet selector enabling users to select the wallet that best fits their needs, helping NEAR bring the full spectrum of Web3 uses and experiences to users.




	

	
	
		
			
				What Are The Wallets Supported By The Transfer Wizard?
			
		

		
					

		
			
			
			
			Meteor Wallet
		
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Have your say!

                There was a problem with your submission. Please review the fields below.
                        
                            
                         
 
                        
          Submit

### Meet Nightly Wallet - your key to the NEAR metaverse

For anyone embarking on their cryptocurrency journey, the first step is setting up a secure and user-friendly wallet. However, the path forward can be daunting, especially when faced with the complex world of dApps across different blockchain networks. Nightly Wallet has emerged as a game-changer in the crypto space, offering an innovative solution for both newcomers and seasoned enthusiasts.
Nightly Wallet - your new crypto best friend
Nightly Wallet is a multi-chain wallet designed to simplify your crypto experience. It currently supports NEAR, Solana, Aptos, Sui, and Aleph Zero.

Nightly allows you to stake your NEAR (thanks to Everstake), liquid stake your NEAR (thanks to Metapool and StaderX), or swap it (thanks to REF). In addition, you can find a "dApps" tab in our wallet. This tab aggregates each dApp on NEAR. It's a perfect launchpad for everyone who is just starting their journey with the NEAR Ecosystem; it will give them a quick overview of the whole ecosystem.




	

	
	
		
			
				What animal is the Nightly mascot?
			
		

		
					

		
			
			
			
			Fox
		
			
			Fennec
		
			
			Capybara
		
			
			Kangaroo
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Safety, Unparalleled Convenience, and Need for x Speed
Safety, convenience, and speed define Nightly Wallet's mission to transform your crypto journey. With rock-solid code for fund security, it offers unparalleled ease of use, ensuring swift transactions that outpace other wallets by up to 5 times. Whether you're a crypto pro or a beginner, Nightly Wallet integrates these crucial elements for a secure, seamless, and lightning-fast crypto experience.
Mobile Accessibility
Embracing the mobile future, Nightly Wallet is already available on both iOS and Android platforms. You can easily install Nightly on your mobile device, enhancing accessibility and convenience for users on the go. This means you can manage your crypto assets seamlessly, whether you're at your desktop or out and about, ensuring a flexible and user-friendly experience at all times. Want to log in with your biometrics? No problem, we've got you covered.
Playful and Interactive Design
In the recent update, Nightly Wallet not only improved usability but also added a touch of fun to the experience. The interactive fennec mascot adds a delightful and playful element to the wallet interface, making your crypto journey even more enjoyable. Try playing with it once and you won't be able to stop!
Recognition from NEAR Foundation
In a testament to Nightly Wallet's innovation and potential to positively impact the crypto world, the NEAR Foundation has granted its support. This recognition is a significant milestone for Nightly Wallet, signifying their commitment to advancing the blockchain ecosystem.

Knowing all this info, you can see that Nightly Wallet is not just a wallet; it's your all-in-one crypto companion. Whether you're a seasoned crypto enthusiast or a newcomer taking your first steps into the metaverse, Nightly Wallet has the features, security, and ease of use to meet your needs. With its commitment to safety, speed, and accessibility, Nightly Wallet is poised to play a pivotal role in the future of crypto wallet technology.

Download Nightly and start surfing through NEAR ecosystem now.

### DeFi en NEAR 2023

En 2023, el ecosistema NEAR desarrolló un conjunto de plataformas maduras para el ecosistema de las finanzas descentralizadas (DeFi). Cuenta con una amplia gama de apps descentralizadas (dApps) enfocadas en la gestión de las finanzas. NEAR es un exponente de una blockchain escalable, de bajo costo y de capa 1. Estas ventajas facilitan a cualquier interesado iniciar su camino en las DeFi.

Las DeFi permiten a los usuarios gestionar sus tokens digitales. Algunas de las principales características de esta tecnología son:

 	No custodiada; lo que significa que los usuarios mantienen el control de sus activos durante todo el proceso de negociación.
 	Transparente: Todas las transacciones se registran en la blockchain y pueden ser vistas por cualquiera.
 	Seguras: Utilizan criptografía avanzada y otras medidas de protección para garantizar que las operaciones sean seguras.
 	Accesible: a cualquier persona con conexión a Internet y un monedero digital compatible.
 	Sin autoridad central: de forma descentralizada, lo que significa que no hay una autoridad central que controle el intercambio.

Proximity Labs, una empresa de investigación y desarrollo, que incluye un fondo de capital de riesgo, busca la próxima generación de plataformas DeFi que quieran desarrollarse sobre el Protocolo NEAR. Si eres desarrollador y buscas soporte para mejorar tu dApp DeFi desarrollada en NEAR, búscalos.

Por último, necesitamos añadir contexto. Los eventos que ocurrieron durante el 2022 (como Terra-Luna, FTX-Alameda, y otros), y el ecosistema criptográfico hicieron cambios radicales en el futuro de las DeFi, requiriendo plataformas más dinámicas e innovadoras que puedan soportar tanto a: Mercados bajistas, como alcistas. Teniendo en cuenta todas las ventajas tecnológicas, este escritor cree que el futuro DeFi debe construirse sobre NEAR.
Exchanges descentralizados (DEX)
Ref Finance


Ref Finance, el pionero de las finanzas descentralizadas en el Protocolo NEAR, ofrece un servicio integral de swap para tokens con pools de liquidez y farming. La plataforma ha evolucionado con el tiempo para incluir un Creador Automático de Mercado (AMM) para experiencias de negociación sin complicaciones.

Ref Finance se rige por una DAO que mantiene una lista blanca de tokens para el comercio en la plataforma, garantizando la seguridad y la estabilidad de los activos. En 2023, Ref Finance sigue siendo la principal DEX de NEAR, con una prometedora hoja de ruta para ampliar sus funciones.

En el primer trimestre de 2023, Ref Finance tiene previsto lanzar Ref V2 Farms, métricas básicas en Ref Analytics, y la integración de liquidez de Orderly para una experiencia de Central Limit Order Book (CLOB) completa. En el segundo trimestre de 2023, la plataforma tiene como objetivo introducir elementos básicos de préstamo y préstamo incrustados, una propuesta de intercambio mejorada, widgets de referencia y Zap Swap.



En el segundo semestre de 2023, Ref Finance tiene previsto desplegar swaps recurrentes, Sentinel en pools y en farmings, liquidez como garantía y soluciones innovadoras para mejorar la seguridad y la protección de los usuarios. Con su ambiciosa hoja de ruta, Ref Finance está preparada para consolidar su posición como la DEX líder en el ecosistema NEAR.
Spin Finance


Spin Finance es una plataforma de trading descentralizada que ofrece herramientas de trading avanzadas a los usuarios de NEAR, incluyendo futuros perpetuos sobre NEAR, ETH y BTC. Además del trading tradicional al contado (spot trading), Spin proporciona DOVs y bóvedas para los yield farming. Utilizando estas bóvedas, los operadores pueden participar de forma fácil y segura en el yield farming sin tener que operar individualmente.



Además, la hoja de ruta de Spin Finance incluye la introducción de nuevas características como el comercio de opciones, AIPs, y un creador de mercado descentralizado. Estas herramientas avanzadas pueden ser útiles tanto para traders como para degens, lo que hace que valga la pena considerar la utilización de cualquier token del ecosistema NEAR.



El modelo híbrido único de Spin Finance combina las ventajas de los exchanges centralizados con las de los descentralizados, lo que la hace destacar entre sus homólogas. Desde su lanzamiento en 2021 como libro de órdenes para NEAR, Spin no ha dejado de crecer, con un equipo en expansión que promete un futuro brillante por delante. Si buscas una plataforma de negociación avanzada que combine lo mejor de ambos mundos, Spin Finance puede ser la opción perfecta para ti.
Jump DeFi


Jump DeFi es una dapp integral que ofrece una gama de soluciones para lanzar, recaudar capital y hacer swap de los tokens NEP-141. Se considera un ecosistema que permite a individuos y organizaciones dar sus primeros pasos en el mundo de DeFi.

Una de las herramientas más destacadas que ofrece Jump Defi es el servicio de staking de NFT, que permite a las comunidades de NFT apoyar a sus poseedores proporcionándoles tokens. Este servicio está diseñado para incentivar la tenencia de NFT y crear una comunidad más comprometida.

Jump Token Laboratory es otra herramienta innovadora proporcionada por Jump DeFi, que permite a los usuarios crear tokens y posteriormente moverlos a Jump Pad, una plataforma de lanzamiento que facilita la recaudación de fondos en el Ecosistema NEAR.



Jump DeFi también ha acogido una campaña de "yield farming" impulsada por NEKO, un "meme coin" que hace vida en el Protocolo NEAR. La plataforma también ha lanzado campañas de crowdfunding en otras plataformas de lanzamiento, incluida Meta Yield, donde recaudó un total de 68.416 USD en tokens stNEAR que proporcionarán todas las recompensas de staking.

Es una plataforma asombrosa y completa que ofrece una amplia gama de servicios DeFi en el Protocolo NEAR, incluyendo staking, fundraising y creación de tokens. Es una plataforma que tiene el potencial de abrir nuevas oportunidades y posibilidades para cualquiera que desee participar en el ecosistema financiero descentralizado.
Staking Líquido
Meta Pool
El staking líquido se ha convertido en una solución popular para aquellos que quieren hacer staking de sus tokens y ganar recompensas, pero también quieren mantener la capacidad de utilizar esos tokens de otras maneras. Meta Pool es la primera y mayor solución de staking líquido en el Protocolo NEAR, proporcionando una manera para que los usuarios ganen recompensas de staking mientras siguen siendo capaces de utilizar sus tokens en el ecosistema DeFi.

Meta Pool se lanzó con su token de staking digital, $stNEAR, que permite a los usuarios mantener el staking a la vez que utilizan el derivado $stNEAR en el ecosistema DeFi. El protocolo está gestionado por una DAO que recompensa a los usuarios con $META, un token de gobernanza que puede utilizarse para participar en la comunidad que impulsa la DAO de Meta Pool.



Una de las características únicas de Meta Pool es la implementación del 'Meta Staking Vote', que permite a los titulares de $META seleccionar qué validadores son los mejores para ser apoyados. Estos validadores reciben el 15% del Valor Total Bloqueado (TVL) de Meta Pool distribuido en función de su votación. Este enfoque garantiza que la comunidad Meta Pool tenga voz y voto sobre qué validadores se apoyan, promoviendo la descentralización y la participación de la comunidad en la red.

En la actualidad, la familia de productos lanzada por Meta Pool se ha ampliado y se compone de:

 	$stNEAR, Staking líquido en NEAR.
 	Fondo de liquidez para el unstake líquido en el Protocolo NEAR.
 	$stAUR token, staking líquido en Aurora
 	Meta Yield, la primera plataforma de crowdfunding (financiación colectiva) sin pérdidas en NEAR.
 	Meta Bond, venda sus posiciones bloqueadas en Meta Yield.
 	Meta Vote, obtenga poder de voto para la gobernanza en Meta Pool.

Meta Pool es un protocolo que no requiere permisos y que ofrece a los usuarios la posibilidad de hacer staking de sus tokens y ganar recompensas, al tiempo que conservan la capacidad de utilizar esos tokens de otras maneras. Con la implementación del Meta Staking Vote y la distribución de tokens de gobernanza $META, Meta Pool promueve el compromiso y participación de la comunidad en la gobernanza de su red.




	

	
	
		
			
				¿Cuáles de los siguientes son exchanges descentralizados construidos sobre el Protocolo NEAR? (respuestas múltiples)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Uniswap
		
			
			Ref Finance
		
			
			Spin Finance
		
			
			Jump DeFi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





LiNEAR Protocol


$LiNEAR es una solución de staking líquido proporcionado por Linear Protocol, uno de los proyectos líderes en el ecosistema NEAR. Forma parte de Cornerstone, un protocolo de meta-gobierno construido para apoyar el creciente ecosistema NEAR, que ofrece tokens $CORN a los usuarios de sus plataformas.

Con un APY relativamente alto de alrededor del 9%, LiNEAR ha ganado popularidad entre los usuarios que buscan una opción de staking líquido rentable en NEAR. El protocolo también ha apoyado recientemente Stake Wars III, una competición en NEAR que permite a más validadores participar en la red como productores de bloques, fortaleciendo aún más el ecosistema.

Linear Protocol también ha anunciado su último producto, Phoenix Bonds, un farm que genera rendimiento y que está disponible en Ref Finance para los proveedores de liquidez NEAR<>pNEAR. Esto proporcionará otra oportunidad para que los usuarios ganen recompensas mientras apoyan la liquidez de NEAR y pNEAR. Con su enfoque en la creación de productos DeFi innovadores y útiles, Linear Protocol es un proyecto a tener en cuenta en el ecosistema NEAR.
Stader Labs en NEAR


Stader Labs ha llevado su innovadora solución de staking líquido al Protocolo NEAR, permitiendo a los usuarios ganar recompensas de staking a la vez que tienen acceso a sus tokens en stake a través de su token $NearX.

Además del Protocolo NEAR, Stader Labs está presente en otras cadenas, como Polying, Fantom, BNB Chain y Hedera, proporcionando soluciones de staking líquido a usuarios de múltiples ecosistemas.

En el ecosistema NEAR en concreto, el token de staking líquido $NearX está disponible tanto en el Protocolo NEAR como en Aurora Network, un EVM que funciona sobre NEAR, dando a los usuarios incluso más flexibilidad y opciones cuando se trata de hacer staking con sus tokens.
Plataformas de préstamo
Burrow Cash


Las finanzas descentralizadas han abierto un mundo de posibilidades a la hora de prestar y pedir prestado. Burrow Cash es una plataforma de préstamos basada en el Protocolo NEAR que ofrece una forma descentralizada de prestar y tomar prestados tokens sin necesidad de un intermediario centralizado.

Con Burrow Cash, los usuarios pueden bloquear sus tokens y utilizarlos como garantía para solicitar otro token, lo que les permite acceder a nuevos tokens sin tener que vender sus posiciones existentes. Esto es especialmente útil para los usuarios que no quieren vender sus tokens pero quieren acceder a otros tokens o necesitan liquidez.

Burrow Cash utiliza servicios de oráculos para controlar los precios de los tokens, asegurándose de que la garantía del usuario se mantiene estable y de que recibe una cantidad justa de tokens a cambio de su garantía. Sin embargo, es importante recordar que si el valor de la garantía cae, podría correr el riesgo de ser liquidada para pagar la deuda.

Además de prestar y pedir prestado, Burrow Cash también ofrece pools de liquidez, donde los usuarios pueden suministrar sus tokens para burrowing y ganar recompensas a cambio. Estos pools de liquidez proporcionan otra forma para que los usuarios obtengan un rendimiento de sus tokens, y también proporcionan liquidez a la plataforma, lo que ayuda a garantizar que siempre haya suficiente liquidez disponible para aquellos que quieran pedir prestado o prestar.

En general, Burrow Cash es una plataforma de préstamos descentralizada que ofrece una forma sencilla, segura y eficiente de prestar y tomar prestados tokens en el protocolo NEAR. Mediante el uso de sistemas de oráculos para supervisar los precios de los tokens y proporcionar fondos de liquidez, Burrow Cash ofrece a los usuarios una forma fiable y cómoda de acceder a nuevos tokens, al tiempo que obtienen recompensas por sus tokens existentes.






	

	
	
		
			
				¿Cuáles de los siguientes son servicios de staking líquido en NEAR? (respuestas múltiples)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Meta Pool
		
			
			LiNEAR Protocol
		
			
			Stader Labs
		
			
			Rocket Pool
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Launchpad / Plataformas de Lanzamientos
Meta Yield


Meta Yield es una plataforma de crowdfunding que aprovecha el staking líquido para proporcionar apoyo financiero y exposición a proyectos web 3.0 construidos sobre el Protocolo NEAR. Los patrocinadores se comprometen y bloquean stNEAR para apoyar proyectos y ganar tokens de nuevos proyectos que se lancen en NEAR o reciban un drop NFT. Los proyectos únicamente obtienen recompensas de lo que los patrocinadores comprometen, no de sus criptoactivos subyacentes. Los patrocinadores pueden recuperar el 100% de sus tokens NEAR al final del periodo de bloqueo, haciendo de Meta Yield una plataforma de crowdfunding basada en recompensas sin pérdidas.

Como inversor en Meta Yield Launchpad, obtendrás acceso anticipado al proyecto que has respaldado, tokens de proyecto valorados por encima del precio de mercado y la posibilidad de recuperar tu inversión inicial de tokens NEAR. Para reclamar tus tokens de proyecto y recuperar tus tokens, el proceso es sencillo e implica unos simples pasos.

En general, Meta Yield ofrece un mecanismo único de recaudación de fondos para proyectos web 3.0 en NEAR. Permite a los inversores apoyar proyectos sin perder los tokens que están en stake al tiempo que obtienen recompensas por el lanzamiento de nuevos proyectos en NEAR. Si te haces promotor, puedes disfrutar de varios beneficios, como el acceso temprano a los proyectos, tokens de proyectos de mayor valor y la posibilidad de recuperar tu inversión inicial de tokens NEAR.


Meta Bonds, un mercado secundario para las posiciones bloqueadas de Meta Yield
Meta Bonds es un mercado secundario que permite a los patrocinadores de campañas de crowdfunding en Meta Yield negociar sus posiciones bloqueadas en forma de bonos.

Meta Yield es un protocolo de crowdfunding que utiliza stNEAR, un "staked token" que genera rendimiento proporcionando liquidez al protocolo Meta Yield. Cuando los patrocinadores apoyan un proyecto en Meta Yield, reciben dos pagarés en forma de bonos: uno por su inversión original y otro por los tokens del proyecto que recibirán a cambio de sus recompensas.

El primer bono estará disponible cuando finalice el periodo de bloqueo, y el segundo podrá reclamarse tras el periodo de liberación gradual. Durante este tiempo, los patrocinadores pueden invertir sus tokens colocándolos en el mercado, al que se puede acceder visitando el sitio web de Meta Bonds en metabondsmarket.app.

Meta Bonds permite a los inversores monetizar sus inversiones antes de que finalice el periodo de lanzamiento gradual. Esto ofrece a los inversores la oportunidad de intercambiar sus bonos por otros activos, como otros tokens o criptomonedas, al tiempo que proporciona liquidez al mercado.

Al crear un mercado secundario para las posiciones bloqueadas, Meta Bonds proporciona liquidez y oportunidades de negociación, al tiempo que crea una nueva vía para la monetización de las inversiones.


NEAR Starter


NEAR Starter es una iniciativa revolucionaria que permite a los nuevos proyectos construir y poner en marcha el Protocolo NEAR. Concebido como una organización autónoma descentralizada (DAO), NEAR Starter proporciona un ecosistema integral de apoyo a los proyectos en fase inicial. NEAR Starter Launchpad es una parte integral de este ecosistema, permitiendo a los proyectos realizar una Oferta Inicial Descentralizada (OID) y recaudar fondos de la comunidad.

Además de su Launchpad, NEAR Starter también se ha hecho un nombre por sí mismo proporcionando colecciones NFT que permiten a los usuarios cultivar $NEARIA, el token de índice que se utiliza para intercambiar por proyectos. Este enfoque innovador ha ayudado a crear una comunidad vibrante y comprometida en torno a NEAR Starter, con usuarios que participan con entusiasmo en el proceso de farming.

El sitio NEAR Starter está construido sobre la Red Aurora, que permite tarifas bajas y una conectividad sin problemas a través de MetaMask. Esto garantiza que los usuarios puedan participar de forma fácil y segura en los procesos de Launchpad y de farming, sin tener que preocuparse por tarifas excesivas o requisitos técnicos complejos.

Para mostrar el poder de su Launchpad, NEAR Starter lanzó recientemente el token $NEARIA a través de una OID, con un objetivo de recaudación de 24 ETH. Este exitoso lanzamiento es solo el principio para NEAR Starter, ya que continúa apoyando e incubando nuevos proyectos en el Protocolo NEAR.


Agregadores de rendimientos / Yield aggregators
Pembrock Finance
​​



Con el Protocolo NEAR proporcionando una plataforma robusta para aplicaciones DeFi, Pembrock destaca como un protocolo de "yield farming" apalancado que utiliza múltiples estrategias para el "farming tokens" del Protocolo NEAR.

Lo que hace único a Pembrock es que atiende a dos tipos de usuarios: Prestamistas y "Leveraged Yield farmers". Los prestamistas pueden obtener ingresos pasivos depositando sus criptomonedas en bóvedas, que financian fondos de liquidez. Por otro lado, los "Leveraged Yield farmers" pueden maximizar sus beneficios abriendo una posición apalancada. Esto significa que los usuarios pueden tomar prestados fondos adicionales de la plataforma, pagando una pequeña cantidad de intereses sobre sus ganancias.

Pembrock tiene una diversa gama de pools disponibles, incluyendo wNEAR, ETH, PEM, SWEAT, USDC.e, y más monedas disponibles en el ecosistema NEAR. Tanto si eres un principiante como un inversor experimentado, iniciar una posición con Pembrock es sencillo. Todo lo que necesitas hacer es visitar su sitio y buscar las operaciones de farming o lending en sus pools. Con la intuitiva interfaz de Pembrock, puedes navegar fácilmente por los pools y elegir el que mejor se adapte a tu estrategia de inversión.

En general, Pembrock es un excelente ejemplo de cómo las DeFi están revolucionando el sector financiero tradicional. Mediante la utilización de protocolos descentralizados, Pembrock ofrece a los usuarios la oportunidad de obtener ingresos pasivos y maximizar sus beneficios a través del yield farming apalancado.


El final, por ahora...
Las DeFi en el Protocolo NEAR son un ecosistema en rápida evolución que ofrece diversas soluciones innovadoras a los usuarios. Con un fuerte enfoque en la escalabilidad, la interoperabilidad y la experiencia del usuario, el Protocolo NEAR está atrayendo a muchos desarrolladores e inversores para construir e invertir en proyectos DeFi en la plataforma. A medida que el ecosistema siga creciendo y madurando, se espera que se convierta en un actor importante en el panorama DeFi más amplio, ofreciendo características y ventajas únicas a sus usuarios.

Este post presentó varios proyectos DeFi en el Protocolo NEAR. Cada uno de estos proyectos tiene características únicas y contribuye al creciente ecosistema DeFi en NEAR. Sabemos que tarde o temprano este artículo tendrá que ser reescrito para incluir las nuevas y sorprendentes aplicaciones que vendrán.

¡Hasta pronto!




	

	
	
		
			
				¿Cuáles de las siguientes son plataformas de lanzamiento en el ecosistema NEAR? (respuestas múltiples)
			
		

		
					

		
			Please select 2 correct answers
			
			
			DuckStarter
		
			
			NEAR Starter
		
			
			Meta Yield
		
			
			Ethereum Launchpad
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Desarrollo De Contratos Inteligentes en Near Usando Rust - Parte 2

Esta es la segunda parte de una serie de publicaciones sobre la creación de una aplicación de chat utilizando Rust en la cadena de bloques Near. Puedes encontrar la primera publicación de la serie aquí.

En esta publicación nos centraremos en el contrato inteligente en sí. Veremos la biblioteca near-sdk que hace que nuestro código funcione en Near. También veremos patrones de acceso de estado de Near y los principios del desarrollo de contratos inteligentes en acción al revisar el código de este contrato inteligente. Puedes encontrar el repositorio completo con todo el código que discutiremos hoy en mi GitHub.
El SDK Para Crear Contratos Inteligentes De Near En Rust
Internamente, el tiempo de ejecución del contrato inteligente de Near utiliza WebAssembly (Wasm). Wasm es un formato de bytecode (el bytecode es un conjunto de instrucciones de bajo nivel que representa el código fuente de un contrato inteligente) bien establecido, que también se usa fuera de blockchain, como en aplicaciones web. Esto es bueno para Near porque su tiempo de ejecución puede beneficiarse del trabajo que se realiza en la comunidad más amplia de Wasm.

El compilador de Rust hace un buen trabajo al generar el código resultante en Wasm, pero debe haber algo de trabajo a su alrededor para que el código de bytes de Wasm funcione correctamente con su "host" (en nuestro caso es el tiempo de ejecución de Near, o en el caso de una aplicación web el motor de JavaScript de un navegador web). Este trabajo restante se puede generar automáticamente utilizando bibliotecas de Rust convenientes: wasm-bindgen en el caso de la integración del navegador y near-sdk en el caso de Near. El contrato inteligente con el que estamos trabajando hoy está escrito usando near-sdk.

Ambas bibliotecas utilizan macros de procedimiento de Rust (proc macros). Este es un tipo de metaprogramación donde la biblioteca define pequeñas anotaciones que podemos usar para activar el código Rust para que se genere automáticamente para nosotros. Las macros de procedimiento de Rust se utilizan para reducir la cantidad de código repetitivo que el desarrollador necesita escribir para que su lógica de negocios funcione. Por ejemplo, la macro de procedimiento derive es fundamental para el lenguaje Rust. Puedes definir automáticamente la funcionalidad común en los nuevos tipos de datos que crees. Puedes ver esto siendo utilizado en el siguiente fragmento de código simple del contrato inteligente de chat:
#[derive(

Debug, BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, Copy, PartialEq, Eq,

)]

#[serde(crate = “near_sdk::serde”)]

pub enum MessageStatus {

Read,

Unread,

}
Puedes ver muchos rasgos enumerados en la anotación derive. Para mencionar algunos específicos: Debug significa que el tipo MessageStatus se puede convertir en una cadena de texto para ayudar en la depuración del código; Clone significa que es posible crear una instancia de MessageStatus idéntica a partir de la actual, y Copy significa que la operación de Clone es barata; PartialEq y Eq significan que puede comparar dos instancias de MessageStatus para ver si son iguales. Los rasgos Serialize y Deserialize provienen de la biblioteca serde, que es omnipresente en el ecosistema de Rust para codificar/decodificar datos de formatos como JSON o CBOR. Volveremos a los rasgos de Borsh más tarde.

Hasta ahora, todo esto ha sido Rust estándar que encontrarás en cualquier proyecto. La macro de procedimiento específica de Near es near_bindgen, que puedes ver utilizada en el siguiente fragmento de código:
#[near_bindgen]

#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]

pub struct MessengerContract {

accounts: LookupMap<AccountId, AccountStatus>,

messages: LookupMap<MessageId, Message>,

unread_messages: UnorderedSet<MessageId>,

read_messages: UnorderedSet<MessageId>,

last_received_message: LookupMap<AccountId, MessageId>,

pending_contacts: UnorderedSet<AccountId>,

owner: AccountId,

}
La macro de procedimiento near_bindgen genera automáticamente el código adicional que necesitamos para que cuando compilemos en Wasm obtengamos una salida que el tiempo de ejecución de Near sepa cómo usar. Se usa en múltiples lugares donde se necesita dicho código extra. Aquí se usa para que la estructura MessengerContract sea proveída con el estado necesario para ejecutar los métodos del contrato. Se creará una instancia de la estructura MessengerContract cada vez que llamemos a un método en nuestro contrato inteligente. Discutiremos para qué se usan algunos de estos campos más adelante.

La macro near_bindgen también se usa sobre el “impl block” (Bloque de código de implementación) para la estructura MessengerContract:
#[near_bindgen]

impl MessengerContract {

// …

}
Aquí significa que las funciones definidas en este bloque son los métodos que queremos exponer en nuestro contrato inteligente. Permite a los usuarios de la blockchain Near enviar transacciones llamando a estas funciones por su nombre. Por ejemplo, el método para enviar un mensaje se define en este bloque. Veremos algunos otros métodos de este bloque con más detalle a continuación.

En resumen, la biblioteca de rust near-sdk proporciona una macro de procedimiento llamada near_bindgen para generar automáticamente un código de conexión que hace que la salida de Wasm funcione con el tiempo de ejecución de Near. Esta macro se puede usar en una estructura para definir el estado de su contrato y en el bloque impl de esa estructura para definir los métodos públicos en su contrato. Near-sdk también proporciona otras funciones y estructuras útiles, que veremos en las siguientes secciones.
Estado Del Contrato Inteligente
Esencialmente, todos los contratos inteligentes no muy complicados requieren algún estado para funcionar correctamente. Por ejemplo, un contrato de token debe mantener los saldos de los distintos titulares de tokens. Nuestro contrato de chat no es diferente. Vimos en la sección anterior que la estructura MessengerContract contenía muchos campos. En esta sección, analizamos algunas características generales del estado en el tiempo de ejecución de Near, así como algunos detalles sobre cómo se usa en el contrato inteligente de ejemplo.

Lo más importante que debes saber sobre el estado del contrato inteligente en Near es que es un simple almacenamiento de clave-valor. Puedes ver esto en las funciones storage_read y storage_write de bajo nivel que se encuentran expuestas por near-sdk. Sin embargo, puedes construir algunas estructuras de datos más sofisticadas sobre esta base simple, y near-sdk proporciona algunas de estas en su módulo de colecciones. Por esta razón, nuestro contrato de ejemplo no utiliza el almacenamiento de clave-valor directamente; en su lugar, hace uso de las colecciones de nivel superior que ofrece near-sdk.

Por ejemplo, el contrato inteligente realiza un seguimiento del estado de las cuentas que conoce (cuáles de ellas son contratos, a cuáles hemos enviado una solicitud de contacto, etc.). El campo de cuentas de MessengerContract es una estructura de tipo LookupMap de near-sdk. Esto está bastante parecido a usar directamente el almacenamiento de clave-valor, ya que el mapa también es simplemente una forma de buscar un valor de una clave, pero LookupMap hace dos cosas importantes por encima de la interfaz de almacenamiento de clave-valor predeterminado. Primero tiene un prefijo que incluye en todas las claves de almacenamiento relacionadas con este mapa. El uso de un prefijo evita mezclar claves de este mapa con claves de otro (por ejemplo, el mapa last_received_message, que también está ingresado en AccountId). En segundo lugar, LookupMap nos permite trabajar con tipos de Rust de nivel superior, mientras que la interfaz de almacenamiento sin formato funciona solo con bytes. Esto se logra mediante el uso de la serialización de Borsh para convertir los tipos hacia y desde cadenas binarias. Borsh es un formato de serialización diseñado por Near para ser útil específicamente en aplicaciones de cadena de bloques. Este uso de Borsh es la razón por la que ve BorshDeserialize y BorshSerialize derivados de muchos tipos a lo largo del código.

Un ejemplo más interesante de una colección que se usa aquí es UnorderedSet , el cual se usa en el campo unread_messages. Esto es utilizado por el contrato para realizar un seguimiento de los mensajes que aún no se han leído. El UnorderedSet todavía se basa en el almacenamiento subyacente de clave-valor, pero efectivamente solo usa las claves, ya que solo nos importa si un elemento está en el conjunto o no. La estructura también guarda metadatos sobre qué claves está usando para permitirnos iterar sobre todas las claves del conjunto.
Comprobando el Entorno y Llamando a Otros Contratos.
En esta sección, analizamos las características generales del entorno de tiempo de ejecución de Near y la realización de llamadas entre contratos. Para darte mayor información, esto se hace en el contexto de cómo los usuarios se agregan entre sí como contactos en nuestra aplicación de chat. Echemos un vistazo a la definición de la función add_contact (esta definición está en el bloque impl de MessengerContact, con la anotación near_bindgen mencionada anteriormente, porque es un punto de entrada principal para nuestro contrato).
#[payable]

pub fn add_contact(&mut self, account: AccountId) –> Promise {

self.require_owner_only();

let deposit = env::attached_deposit();

require!(deposit >= ADD_CONTACT_DEPOSIT, “Insufficient deposit”);

let this = env::current_account_id();

Self::ext(account.clone())

.with_attached_deposit(deposit)

.ext_add_contact()

.then(Self::ext(this).add_contact_callback(account))

}
Hay mucho que entender en estas pocas líneas de código. Como marco adicional para guiar nuestra discusión, recuerda los tres principios del desarrollo de contratos inteligentes descritos en la publicación anterior:

 	Una mentalidad adversaria,
 	Economía,
 	Asegurar invariantes antes de hacer llamadas de contratos cruzados.

Regresa y revisa la primera publicación si necesitas un repaso sobre de qué se trataban estos principios. Cada uno de estos principios hace acto de presencia en esta función.
Una Mentalidad Adversaria
Todos los métodos de contrato inteligente son públicos y debemos hacer cumplir el control de acceso cuando el método realiza una acción confidencial, de lo contrario, alguien hará un mal uso de la funcionalidad. En este caso, no queremos que nadie pueda agregar contactos en nombre del propietario; solo el propietario debe poder decidir con quién conectarse (si alguien más quiere hacer contactos en la red de chat, ¡puede implementar este contrato en su propia cuenta!). Por lo tanto, tenemos la llamada require_owner_only() justo en la parte superior del cuerpo de la función. La implementación de esta función es simple:
fn require_owner_only(&self) –> AccountId {

let predecessor_account = env::predecessor_account_id();

require!(

self.owner == predecessor_account,

“Only the owner can use this method!”

);

predecessor_account

}
Hacemos uso de la función predecessor_account_id del módulo env de near-sdk. Los módulos env contienen muchas funciones útiles para consultar aspectos del entorno de Near runtime en el que se ejecuta nuestro contrato. Por ejemplo, aquí estamos comprobando qué cuenta realizó la llamada a nuestro contrato. El módulo env contiene otras funciones útiles, como verificar la identificación de la cuenta de nuestro contrato y cuántos tokens Near se adjuntaron a esta llamada. Recomiendo leer la documentación del módulo para ver todas las funciones que están disponibles.

Por razones de eficiencia, la función require_owner_only también devuelve la cuenta predecesora (para evitar múltiples llamadas a env::predecessor_account_id() en caso de que una función qué requiera ser llamada sólo por el propietario también necesite la cuenta predecesora por otro motivo).
Economía
La primera línea del fragmento de código add_contact anterior incluye el atributo payable (pagable). El uso de esta anotación está habilitado ya qué la función se está definiendo como parte del bloque de implementación near_bindgen. Significa que este método aceptará tokens Near de los usuarios que lo llamen. Estos tokens son necesarios porque tomamos la decisión de que los usuarios paguen por acciones como crear un estado en la cadena. Dado que agregar otra cuenta como contacto crea un estado en su contrato y en el nuestro (debemos informarles que queremos conectarnos), debemos asegurarnos de que el usuario que inicia esta conexión pague por ese almacenamiento. El depósito adjunto a esta función pagadera se utiliza para cubrir ese costo de almacenamiento.

Puedes ver unas líneas más abajo donde verificamos que el depósito esté efectivamente presente. Esto hace uso de la función attached_deposit del módulo env. El hecho de que estemos haciendo esta verificación temprano se relaciona perfectamente con el tercer principio.
Asegurar Invariantes Antes De Hacer Llamadas De Contratos Cruzados
Es importante tener en cuenta la firma de tipo de la función add_contact. Primero, los argumentos de la función (&mut self, account: AccountId) significan que esta es una llamada mutable (cambiará el estado del contrato) y toma un argumento llamado "account" que debe ser un ID de cuenta de Near. Cuando near_bindgen haga su magia, significará que los usuarios de Near blockchain pueden llamar a esta función al realizar una transacción que toma un argumento codificado en JSON como { "account": "my.account.near" }. En segundo lugar, el tipo de respuesta es Promise, lo que significa que estamos realizando una llamada de contrato cruzado al final de esta función. Las llamadas de contratos cruzados en Near son asincrónicas y no atómicas, por lo tanto, debemos asegurarnos de que todo esté en buen estado antes de realizar la llamada. Esta es la razón por la que incluimos la parte en la que comprobamos el depósito y la comprobación de qué solo el dueño de la cuenta está realizando la llamada en el cuerpo de la función. La naturaleza asíncrona de las llamadas de contratos cruzados también significa que esta función no devuelve ningún valor inmediatamente. La llamada asincrónica se realizará y el resultado solo llegará más tarde, después de que ocurra esta llamada.

Puedes ver los detalles de la llamada de contrato cruzado en la parte inferior de la función. Utiliza la API de alto nivel de near-sdk (aunque la API de bajo nivel también está disponible en el módulo env) donde near_bindgen genera automáticamente la función ext y devuelve una estructura de datos para construir la llamada de contrato cruzado. Puedes ver que primero usamos ext(account) para llamar a la cuenta que queremos agregar como contacto. La llamada incluye nuestro depósito a través de with_attached_deposit y está llamando a la función ext_add_contact (que se define en el mismo bloque de implementación en este caso, pero en general podría definirse en cualquier lugar). Finalmente, llamamos a then, lo que significa incluir una devolución de llamada. La devolución de llamada es en sí misma otra Promesa, por lo que usamos la misma función ext nuevamente, pero esta vez llamando a nuestra propia ID de cuenta. Esto se hace para que nuestro contrato pueda saber cuál fue la respuesta del contrato que estamos tratando de agregar como contacto. No entraré en los detalles de las implementaciones ext_add_contact o add_contact_callback aquí (simplemente manipulan el almacenamiento según el estado actual de la cuenta), pero te invito a leerlas en el código fuente en GitHub si estás interesado.
Resumen
¡En esta publicación nos sumergimos de cabeza en algo de código! Vimos cómo se usa near_bindgen para generar automáticamente el código necesario para ejecutar nuestro contrato en el tiempo de ejecución de Near, así como otras funciones de near-sdk para interactuar con el almacenamiento, el entorno de tiempo de ejecución y otros contratos. En la próxima publicación, continuaremos profundizando en el código, pero cambiaremos de marcha para ver el componente fuera de la cadena de esta aplicación. Un contrato inteligente por sí solo no constituye una dapp, ¡estén atentos para ver por qué!

Si quieres algo de experiencia práctica con este código, ¡prueba algunos de los ejercicios! En algunos lugares del código del contrato inteligente, incluí un comentario etiquetado como EXERCISE (EJERCICIO). Por ejemplo, en la definición de tipos menciono el hecho de que un estado de usuario Blocked está disponible, pero actualmente no hay implementada ninguna forma de bloquear a alguien. Agregar esta funcionalidad para bloquear a otro usuario es un ejercicio sugerido y bueno para comenzar. Todos los ejercicios son sugerencias de formas de ampliar la funcionalidad del contrato, lo que te brinda la oportunidad de intentar escribir un código de contrato inteligente por ti mismo. Quizás en una publicación futura de esta serie discutiré algunas soluciones a los ejercicios.

Si estás disfrutando de esta serie de publicaciones de blog, comunícate con nosotros en la consultoría Type-Driven. Nos complace brindar servicios de desarrollo de software para dapps, así como materiales de capacitación para tus propios ingenieros.

 

### Meta Pool mô-đun 4 - Tham gia quản trị Meta Pool

Quản trị Meta Pool
Meta Pool mong muốn trao lại quá trình quản trị của dự án cho cộng đồng. Với cách làm này, chủ sở hữu của token $META là những người có khả năng quản lý giao thức thông qua DAO.

Toàn bộ hệ sinh thái Web 3 đang tiến hành việc thiết lập một hệ thống quản trị on-chain, thực sự phi tập trung.
Meta Pool DAO
Meta Pool sử dụng token $META dành cho phần quản trị DAO. Token $META sẽ được phân phối tới những người tham gia xây dựng giao thức và những người đóng góp cho dự án theo hướng hoàn toàn minh bạch.

Một điều cần lưu ý là trước khi nền tảng sẵn sàng cho việc các chủ sở hữu token $META có thể bỏ phiếu quản trị on-chain, thì những người đóng góp cho lõi giao thức sẽ đưa ra các quyết định quan trọng dựa trên tầm nhìn của dự án và những ý kiến đóng góp không chính thức từ cộng đồng trên Discord.

Đây là việc làm có chủ ý vì chúng tôi cho rằng điều quan trọng là phải duy trì được hoạt động quản trị một cách linh hoạt trong những ngày đầu giao thức đi vào hoạt động.

Mục đích chính của việc giới thiệu token quản trị là khuyến khích cung cấp thanh khoản: khởi tạo thanh khoản ban đầu cũng như đẩy nhanh tốc độ phát triển của nền tảng Meta Pool.

Token $META sẽ đại diện cho quyền sở hữu Meta Pool DAO. DAO sẽ chịu trách nhiệm cập nhật các thông số kỹ thuật, lộ trình phát triển của sản phẩm và các quyết định chiến lược khác. Đồng thời token $META cũng được dùng như một nguồn vốn tài trợ cho các quan hệ đối tác chiến lược cũng như tạo quỹ dự trữ cho dự án.
Tokenomics của token $META
Tổng cung: 1,000,000,000 $META

 	30% dành cho các nhà sáng lập: Dành cho công sức sáng tạo, vận hành, quảng bá và bảo trì giao thức. Token của các nhà sáng lập sẽ được khóa trong 1 năm và được phát hành theo phương pháp tuyến tính trong vòng 2 năm (tổng cộng là 3 năm)
 	2.6% cho đội ngũ và các cố vấn: Nhằm tạo ra một sản phẩm tầm cỡ thế giới, chúng tôi cần những hoạt động và sự hợp tác tốt nhất có thể trên hệ sinh thái NEAR. Những người này sẽ cam kết gắn bó lâu dài với dự án. Token của các cố vấn dự án sẽ được khóa trong 2 năm và phát hành dần trong vòng 1 năm (tổng cộng 3 năm)
 	10% cho các nhà đầu tư: Hợp tác với các nhà đầu tư và tổ chức hàng đầu là chìa khóa giúp chúng tôi tiếp cận người dùng trên quy mô toàn cầu, đồng thời giúp chúng tôi nắm được rõ hơn các điều kiện vĩ mô của thị trường tiền mã hóa. Chúng tôi biết mình còn thiếu sót những thông tin nào và đó là lý do tại sao các cố vấn cấp cao rất quan trọng đối với sự phát triển của dự án. Token dành cho các nhà đầu tư có thời gian khóa là 1 và 2 năm, và được phát hành dần trong thời gian 1 năm (tổng cộng 2 đến 3 năm).
 	Phân phối cho các vòng gọi vốn:

 	4% cho vòng seed
 	6% cho mỗi vòng gọi vốn tiếp theo


 	57.4% cho cộng đồng và quỹ dự trữ




	

	
	
		
			
				Token $META sẽ được airdrop hàng tháng, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Vote - Quyền biểu quyết trên Meta Pool
Meta Vote là nền tảng bỏ phiếu dành cho cộng đồng:

 	Gọi vốn cho các dự án trên Meta Yield
 	Hỗ trợ các trình xác thực trên Meta Staking Vote

Đây là một nền tảng được thiết kế để có được quyền biểu quyết nhằm hỗ trợ các dự án trên Meta Yield và ủy quyền token NEAR cho các trình xác thực trên Meta Staking Vote.
Hướng dẫn sử dụng Meta Vote
Bạn có thể truy cập trực tiếp vào Meta Vote tại trang web https://metavote.app/ hoặc:

 	Nhấn vào các dự án bạn muốn vote trên Meta Yield: https://metayield.app/
 	Nhấn vào trình xác thực mà bạn muốn bỏ phiếu trên Meta Staking Vote: https://vote.metapool.app/ hoặc bạn có thể nhấp vào các đường link dẫn tới Meta Vote trên trang web để xem quyền biểu quyết của mình.

Kết nối ví NEAR trên Meta Vote
Trên trang web của Meta Vote https://metavote.app/, bạn hãy kết nối ví NEAR để có toàn quyền truy cập vào ví NEAR của mình bằng cách nhấn vào nút +Connect Wallet.
Meta Vote hoạt động theo 3 bước đơn giản

 	Bước 1: Khóa token $META của bạn
 	Bước 2: Nhận quyền biểu quyết
 	Bước 3: Bỏ phiếu cho các dự án trên Meta Yield hoặc hỗ trợ các trình xác thực

Khóa token $META của bạn
Để có quyền bỏ phiếu cho các dự án hoặc các trình xác thực, bạn phải sở hữu quyền biểu quyết và điều này rất đơn giản: bạn chỉ cần khóa token $META của mình lại.

Nếu chưa sở hữu token $META, bạn hãy làm theo hướng dẫn trong phần “Làm thế nào để sở hữu token $META?” ở phía dưới nhé.

 	Bước 1: Nhấn vào nút “+ Add Voting Power”



 	Bước 2: Nhập vào lượng token $META mà bạn muốn khóa
 	Bước 3: Chọn khoảng thời gian mà bạn sẽ “mở khóa” lượng token $META mà mình đã khóa ở bước 2.

Bạn có thể khóa token $META của mình trong tối thiểu là 30 ngày và tối đa là 300 ngày. Token $META của bạn bị khóa càng lâu thì bạn càng có nhiều quyền biểu quyết cho mỗi token $META bị khóa.



Sau khi chọn thời gian khóa token của bạn, hãy nhấp vào nút “Lock” và phê duyệt giao dịch thông qua ví NEAR - và sau đó bạn đã sẵn sàng để có thể bỏ phiếu với các bước sau:

 	Bước 1: Sử dụng quyền bỏ phiếu của mình cho các dự án hoặc các trình xác thực mà bạn muốn hỗ trợ



 	Bước 2: Quay lại trang https://metayield.app/ hoặc https://vote.metapool.app/ , tải lại trang web và xem quyền biểu quyết mới được cập nhật của mình

 	Trên giao diện của Meta Yield: bạn có thể nhấn vào nút “Vote Now!” trên bất kỳ dự án nào và hỗ trợ họ với token của mình. Ngoài ra, bạn không cần phải sử dụng tất cả token của mình cho một dự án mà có thể chia ra cho nhiều dự án!





 	

 	Trên giao diện của Meta Staking Vote: bạn có thể bỏ phiếu trực tiếp cho trình xác thực mà mình thích bằng cách nhấn nút “Vote”. Bạn hãy đọc tất cả những thông tin liên quan tới trình xác thực trước khi bỏ phiếu cho nó. Bạn cũng có thể bỏ phiếu cho nhiều trình xác thực khác nhau.






Công thức tính quyền biểu quyết từ lượng token $META của bạn
MULTIPLIER = 1 + (4 * (days – MIN_LOCK_DAYS) / (MAX_LOCK_DAYS – MIN_LOCK_DAYS))

Trong đó:

 	MIN_LOCK_DAYS = 30
 	MAX_LOCK_DAYS = 300

Ví dụ


Làm thế nào để sở hữu token $META?
Ở góc trên cùng bên phải của giao diện Meta Vote, hãy nhấn vào nút “Get More $META”



Bạn sẽ được chuyển sang trang web của Ref Finance để swap token NEAR hoặc một loại tài sản nào khác để đổi lấy token $META.

 	https://app.ref.finance/#meta-pool.near|meta-token.near

Bạn cũng có thể mua token $META trên bất kỳ nền tảng DeFi nào trong hệ sinh thái NEAR.
Các giai đoạn khóa token
Giai đoạn khóa
Giai đoạn khóa là giai đoạn cho phép bạn bỏ phiếu cho các dự án. Token $META bị khóa và người dùng có thể bỏ phiếu cho các dự án hoặc trình xác thực bất kỳ vào bất kỳ thời điểm nào trong giai đoạn này. Không có giới hạn thời gian nào cho giai đoạn này. Quyền biểu quyết sẽ vẫn khả dụng miễn là token $META của bạn vẫn đang được khóa.


Giai đoạn mở khóa
Giai đoạn mở khóa bắt đầu sau khi chiến dịch bỏ phiếu cho dự án kết thúc hoặc người dùng muốn dừng việc hỗ trợ cho các trình xác thực. Bằng cách nhấn nút “Start Unlock” ở một vị thế đang khóa, bạn sẽ khởi động giai đoạn mở khóa, tương ứng với thời gian được cài đặt bằng cách thêm quyền biểu quyết.

Cần lưu ý rằng giai đoạn mở khóa chỉ có thể được bắt đầu nếu bạn có đủ quyền biểu quyết. Nếu có quyền biểu quyết đang được sử dụng và nó không đủ để mở khóa cho toàn bộ vị thế, bạn sẽ không thể khởi động giai đoạn mở khóa.



Chú ý quan trọng: Giai đoạn mở khóa sẽ không tự động xảy ra, người dùng phải khởi động nó một cách thủ công.
Thu hồi token $META
Sau khi giai đoạn mở khóa kết thúc, token $META của bạn có thể được thu hồi về ví.

Chú ý quan trọng: người dùng phải tự thu hồi token $META của mình.






	

	
	
		
			
				Việc khóa token của bạn trên Meta Vote sẽ tốn một khoản phí 3.5%, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Staking Vote - Sử dụng quyền biểu quyết của bạn để hỗ trợ các trình xác thực
Meta Staking Vote là một nền tảng xây dựng dựa trên cộng đồng hỗ trợ việc lựa chọn các trình xác thực cho chuỗi khối NEAR bằng cách chỉ định 15% lượng token NEAR được stake trên Meta Pool.

Meta Pool trao quyền quản trị cho những người nắm giữ token $META bằng cách cho phép họ tham gia bỏ phiếu trên Meta Staking Vote.
Hướng dẫn sử dụng Meta Staking Vote
Truy cập trực tiếp vào trang web của Meta Staking Vote tại https://vote.metapool.app/
Kết nối ví NEAR với Meta Staking Vote
Hãy kết nối với ví NEAR của bạn trên giao diện trang web Meta Staking Vote tại địa chỉ https://vote.metapool.app/ bằng cách nhấn vào nút Connect Wallet và lựa chọn tài khoản NEAR mà bạn muốn kết nối.


4 bước đơn giản để bỏ phiếu trên Meta Staking Vote:

 	Bước 1: Khóa token $META trên nền tảng Meta Vote
 	Bước 2: Nhận quyền biểu quyết
 	Bước 3: Bỏ phiếu cho các trình xác thực để hỗ trợ nền tảng Meta Staking Vote
 	Bước 4: Xem bảng thống kê bỏ phiếu và các chỉ định để stake token NEAR

Cách Meta Staking Vote hoạt động

 	Người dùng Meta Pool stake token NEAR của họ và nhận về token stNEAR
 	Những token NEAR được stake ở bước trên sẽ được phân phối cho các trình xác thực. Điều này giúp tăng tính phi tập trung và bảo mật cho NEAR Protocol. Càng nhiều người stake trên Meta Pool thì càng nhiều token NEAR được phân phối cho các trình xác thực.
 	Các trình xác thực sẽ tạo ra các khối mới và nhận được phần thưởng từ việc này, từ đó tăng giá trị của token stNEAR cho những người nắm giữ NEAR.
 	Trong tổng số token NEAR được stake thì Meta Staking Vote sẽ ủy thác 15% cho các trình xác thực dựa trên phiếu bầu của những người sở hữu token $META (những người ủng hộ dự án)

Bỏ phiếu trên Meta Staking Vote là quá trình không thể đảo ngược và dựa trên kết quả bỏ phiếu, Meta Staking Vote sẽ phân bổ 1% tổng số token được stake trên Meta Pool sau mỗi 4 epoch.


Chủ sở hữu token $META
Việc bỏ phiếu sẽ bao gồm 2 bước:

 	Bước 1: Chọn trình xác thực: Truy cập trang web https://vote.metapool.app/ bạn có thể thấy danh sách đầy đủ các trình xác thực đang được Meta Staking Vote theo dõi.



Để biết thêm thông tin, bạn có thể nhấn vào tên của các trình xác thực và trang web sẽ hiển thị các thông tin chi tiết liên quan tới trình xác thực đó.



Sau khi đã phân tích và chọn ra cho mình được trình xác thực mà bạn muốn ủng hộ, bạn hãy bỏ phiếu cho trình xác thực này bằng cách bấm vào nút “Vote” hoặc nút “Vote this validator” trên phần thông tin của trình xác thực đó.

Hãy kết nối ví NEAR của bạn với trang web, lựa chọn trình xác thực để bỏ phiếu sau đó chỉ định phiếu bầu của mình cho nó.

Bỏ phiếu cho trình xác thực là một chiến dịch liên tục vì vậy số lượng phiếu bầu cho mỗi chiến dịch sẽ biến động khi chiến dịch vẫn đang chạy.

Bạn có thể bỏ phiếu cho nhiều trình xác thực mà không có giới hạn nào về quyền biểu quyết. Bạn cũng có thể thay đổi phiếu bầu của mình bất cứ lúc nào.

Có thể thấy quá trình bỏ phiếu cho các trình xác thực trên Meta Staking Vote là vô cùng đơn giản, an toàn và 100% lượng token $META của bạn không hề bị mất đi.
Ủy thác
15% trong tổng số tài sản khóa trên Meta Pool được người dùng stake sẽ được ủy thác dựa trên số phiếu bầu của những người nắm giữ token $META.

Nếu như tổng tài sản khóa trên Meta Pool tăng lên thì lượng token được phân bổ cũng sẽ tăng theo. Một việc rất quan trọng là quảng bá pool liquid staking của Meta Pool cho các nhà đầu tư - những người sẽ hỗ trợ cho các trình xác thực cũng như cộng đồng.

Chiến dịch ủy thác sẽ diễn ra liên tục và 1% trong tổng số tài sản được stake trên Meta Pool sẽ được chỉ định sau mỗi 4 epoch.




	

	
	
		
			
				Bạn phải đợi 60 epochs sau khi bỏ phiếu cho một trình xác thực để có thể bỏ phiếu cho một trình xác thực khác, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Các con số thống kê về nền tảng Meta Pool


Validators: trên đây là số lượng trình xác thực đã được phê duyệt bởi Meta Pool, được lựa chọn dựa trên các tiêu chí chọn trình xác thực đã được trình bày trong bài viết trước.

Epoch progress: cho biết thời gian còn lại của giai đoạn xác thực / sản xuất khối mới. Một epoch sẽ kéo dài khoảng 13 giờ (một kỷ nguyên kéo dài 43200 khối và một khối kéo dài khoảng 1,1 giây).

NEAR staked @ Meta Pool: TVL (Total Value Locked) được ủy thác cho các trình xác thực. 85% trong số này sẽ được phân bổ dựa trên hiệu suất và 15% được phân bổ dựa trên kết quả bỏ phiếu trên Meta Staking Vote. Bạn có thể xem dữ liệu này tại https://staking.metapool.app/ - Tổng số token stNEAR nhân với giá của token stNEAR.

NEAR to be assigned by votes: 15% trong số TVM sẽ được chỉ định thông qua kết quả bỏ phiếu. Số lượng token phân bổ cho mỗi trình xác thực sẽ được quyết định thông qua số phiếu bầu.

Available Voting Power: đại diện cho năng lực biểu quyết của bạn cho các trình xác thực. Nếu quyền biểu quyết không có sẵn, bạn có thể mua nó tại https://metavote.app/ (bằng cách nhấn vào đường link phía dưới số dư được hiển thị). Chú ý quan trọng: bạn phải sở hữu token $META để có quyền biểu quyết và bạn có thể mua token $META tại https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

In Use / Total: số liệu thể hiện lượng quyền biểu quyết mà người dùng đang sử dụng và tổng quyền biểu quyết đang có. Quyền biểu quyết đang sử dụng có thể là quyền biểu quyết cho các trình xác thực hoặc cho các dự án trên Meta Yield.
Chi tiết về bỏ phiếu trên các trình xác thực


Name: tên của trình xác thực. Để biết thêm thông tin về một trình xác thực cụ thể, bạn có thể nhấn vào tên nó và trang web sẽ hiển thị các thông tin chi tiết của trình xác thực đó.

APY: phần trăm yield được sinh ra hàng năm của mỗi trình xác thực. Con số này phụ thuộc vào số lượng trình xác thực cũng như phí hoa hồng.

Votes: số phiếu của mỗi trình xác thực và phần trăm tương ứng tính trên tổng số phiếu bầu. Việc bỏ phiếu diễn ra liên tục và cho biết tỷ lệ phần trăm xu hướng phân bổ phiếu bầu được ủy quyền.

Assigned by votes: lượng NEAR được chỉ định cho mỗi trình xác thực từ 15% tổng lượng NEAR được stake dựa trên kết quả bỏ phiếu. Chú ý: chỉ 1% trong số này được chỉ định sau mỗi 4 epoch. Con số này cũng thể hiện xu hướng đạt được cho mỗi trình xác thực dựa trên phiếu bầu. Tổng số TVL được chỉ định theo phiếu bầu được phân phối xấp xỉ cứ sau 15 nhóm của 4 epoch.

Assigned Total: Con số này tương ứng với số token NEAR được chỉ định dựa trên hiệu suất (85%) và dựa trên phiếu bầu (15%). Đồng thời thể hiện toàn bộ xu hướng mà trình xác thực đang đạt được.

Meta Pool Staked: lượng token NEAR hiện đang được ủy thác trên Meta Pool cho mỗi trình xác thực.




	

	
	
		
			
				Quyền biểu quyết có thể được sử dụng trên Meta Staking Vote hoặc cho các chiến dịch bỏ phiếu trên Meta Yield, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Tìm hiểu về NameSky: Mua, bán và quản lý tài khoản NEAR an toàn dưới dạng NFT

NameSky là một nền tảng thân thiện với người dùng, cho phép giao dịch các tài khoản NEAR dưới dạng NFT trên blockchain NEAR. Với các hợp đồng thông minh được audit (xét kiểm) bởi @pessimistic_io, NameSky đảm bảo trải nghiệm an toàn cho người dùng. Bạn có thể tìm thấy báo cáo audit tại đây và khám phá chợ NFT NameSky để xem các tài khoản được tạo ra dưới dạng NFT.

Bài viết này sẽ giúp bạn khám phá nền tảng NameSky, bao gồm quá trình chuyển tài khoản NEAR thành NameSky NFT, kiểm tra NFT trên ví NEAR của bạn, đăng bán các NFT của bạn trên chợ NameSky và cách để lấy lại quyền kiểm soát tài khoản NEAR của bạn bằng cách đốt NameSky NFT.
Bước 1: Chuyển tài khoản NEAR thành NameSky NFT
Bạn hãy làm theo các bước sau đây để chuyển tài khoản NEAR của mình thành một NFT:

 	Truy cập trang web của NameSky và nhấn vào nút “Mint” trên giao diện.
 	Kết nối ví NEAR của bạn với ứng dụng NameSky.
 	Lựa chọn tài khoản NEAR mà bạn muốn chuyển thành NFT.
 	Trong quá trình đúc NFT mới, một hợp đồng khóa sẽ được triển khai cho tài khoản NEAR mà bạn chọn ở bước 3 và tất cả các khóa truy cập của tài khoản này sẽ bị xóa. Điều này có nghĩa là chỉ chủ sở hữu của NFT (bạn) mới có thể truy cập vào tài khoản NEAR này.




	

	
	
		
			
				Hợp đồng thông minh của NameSky đã được audit (xét kiểm) chưa?
			
		

		
					

		
			
			
			
			Đã xét kiểm
		
			
			Chưa xét kiểm
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



















Bước 2: Kiểm tra NFT trên ví NEAR của bạn
Để xem NFT mà bạn vừa đúc ở bước 1, hãy làm theo các bước sau:

 	Đăng nhập vào ví NEAR.
 	Chuyển sang tab “Collectibles”.
 	Bạn sẽ thấy NFT NameSky được hiển thị với nội dung là tên tài khoản của bạn.


Bước 3: Đăng bán NFT của bạn trên chợ NFT của NameSky
Làm theo các bước sau để đăng bán NFT của bạn trên NameSky:

 	Truy cập trang “NFT detail“
 	Nhấn vào nút “Sell”
 	Thiết lập mức giá mà bạn muốn bán NFT
 	Xác nhận việc đăng bán và NFT của bạn sẽ được đăng bán trên chợ NameSky






Bước 4: Lấy lại tài khoản NEAR bằng cách đốt NFT
Nếu như bạn muốn khôi phục lại quyền kiểm soát tài khoản NEAR của mình, hãy làm theo các bước sau đây:

 	Truy cập trang web NameSky mục thông tin cá nhân
 	Lựa chọn NFT mà bạn muốn đốt
 	Nhấn vào “Take back my account” (Lấy lại tài khoản của tôi) trên menu lựa chọn
 	Cụm từ khôi phục bí mật mới sẽ được tạo trên thiết bị của bạn, cho phép bạn lấy lại quyền sở hữu tài khoản NEAR của mình
 	NameSky NFT sẽ bị đốt và bạn sẽ lấy lại toàn quyền kiểm soát tài khoản NEAR được của mình bằng cách sử dụng cụm từ khôi phục từ bước 4 để khôi phục tài khoản trên trang web https://wallet.near.org/recover-account















NameSky cung cấp một giải pháp an toàn và dễ dàng để mua, bán các tài khoản NEAR dưới dạng NFT. Bằng cách làm theo hướng dẫn này, bạn có thể tự mình khám phá ứng dụng NameSky và tự tin quản lý các tài khoản NEAR và NFT của mình. Cho dù bạn đang tìm mua một tài khoản NEAR độc nhất hay muốn bán tài khoản của mình, NameSky đều cung cấp giải pháp rất thuận tiện và an toàn cho nhu cầu của bạn. Happy (L)Earning!

Nếu bạn vẫn chưa nắm được cách thức hoạt động của NameSky, bạn có thể tự mình dùng thử trên ứng dụng phiên bản testnet tại trang web: https://testnet.namesky.app




	

	
	
		
			
				Trong quá trình đúc NameSky NFT, tất cả các khóa của tài khoản NEAR được chọn sẽ bị xóa?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!

### Hướng dẫn staking trên Meta Pool

Meta Pool, Mô-đun 1 – Bước đầu tìm hiểu về liquid staking
Staking và giao thức đồng thuận trên NEAR Protocol
Trước khi đi vào chi tiết của bài viết, chúng tôi khuyên bạn nên tham gia khóa học “NEAR Power User” của Learn NEAR Club (LNC) để nắm được những kiến thức cơ bản nhất về NEAR Protocol.

Mỗi chuỗi khối cần có một phương pháp để xác nhận khi các khối mới được tạo ra.

Trên một chuỗi khối xây dựng theo cơ chế Proof-Of-Stake, quy trình này được thực hiện bởi các trình xác thực. Để chọn ra các trình xác thực này, cần phải khóa các token và ủy quyền chúng cho trình xác thực, việc này được gọi là staking - đặt cọc. Tập hợp các trình xác thực sẽ tham gia vào việc tạo khối được quyết định dựa trên số lượng token NEAR được stake ở trên mỗi trình xác thực.

Nhằm khuyến khích nhiều người ủy quyền(staker) token và các trình xác thực tham gia vào vận hành mạng lưới, giao thức mạng lưới sẽ thưởng cho người ủy quyền và các trình xác thực một lượng token. Như vậy staking có thể coi là một cách để kiếm thêm token và đồng thời giúp bảo mật mạng lưới.

Một số nhược điểm của việc đặt cọc truyền thống này là token của bạn sẽ bị khóa và bạn sẽ phải đợi một khoảng thời gian để rút chúng về lại ví của mình. Ngoài ra, bạn không thể sử dụng token của mình theo bất kỳ cách nào vì chúng đã được ủy quyền cho trình xác thực. Giải pháp liquid stake (đặt cọc thanh khoản) sẽ giúp giải quyết hai nhược điểm này.
Bằng chứng cổ phần (Proof of Stake)
Trang web Investopedia.com định nghĩa Proof of Stake (PoS) như sau:

“Proof-of-stake là một cơ chế đồng thuận tiền mã hóa để xử lý các giao dịch và tạo các khối mới trong chuỗi khối.”

Cơ chế đồng thuận là một phương pháp để xác thực các mục dữ liệu được lưu vào trong cơ sở dữ liệu phân tán và giúp giữ an toàn cho cơ sở dữ liệu. Trong trường hợp của tiền mã hóa, cơ sở dữ liệu này được gọi là chuỗi khối - vì vậy có thể nói cơ chế đồng thuận giúp bảo vệ chuỗi khối.

NEAR Protocol sử dụng cơ chế đồng thuận PoS để xử lý tất cả các giao dịch đang chạy trên mạng bằng cách stake token NEAR - native token của chuỗi khối này. Với phương thức staking tiêu chuẩn, bạn có thể chọn một trình xác thực và ủy quyền một lượng token của mình cho trình xác thực đó. Từ đó giúp trình xác thực có động lực để xác thực các giao dịch, tạo ra khối mới và có thể tạo ra phần thưởng khi thỏa mãn điều kiện về hệ số Nakamoto.

Tuy nhiên, việc ủy quyền token theo phương pháp tiêu chuẩn của các hệ thống PoS, ví dụ như NEAR Protocol, có cơ chế bị trì hoãn, hoặc thậm chí bạn còn không thể thu hồi lại số token mình đã stake, như trên Ethereum. Trong trường hợp này, một giải pháp liquid staking có thể giải quyết cả hai vấn đề bảo mật mạng trong PoS và tăng khả năng sử dụng token của bạn.
Các trình xác thực
Trình xác thực là những máy tính đã nhận đủ token (cổ phần) để bắt đầu xác nhận giao dịch trên mạng NEAR.

Trên mạng Proof-of-Stake của NEAR, một nhóm trình xác thực phi tập trung xử lý các giao dịch để giữ an toàn cho mạng, đổi lại thì những trình xác thực này sẽ nhận được phần thưởng. Hệ thống này cũng cho phép người ủy quyền – những đối tượng muốn cung cấp bảo mật nhưng không đáp ứng được các yêu cầu về phần cứng để vận hành trình xác thực – ủy quyền token của họ cho các trình xác thực.

Các trình xác thực này cung cấp sức mạnh tính toán cho mạng lưới để tạo ra các khối mới và đổi lại, chúng sẽ nhận được phần thưởng dựa trên số lượng khối mới được tạo ra.

Bạn có thể đọc thêm về trình xác thực trên NEAR Protocol tại https://near.org/about/network/validators/.




	

	
	
		
			
				Cơ chế đồng thuận Proof-of-Stake hoạt động tương tự như cơ chế Proof-of-Work
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Phần thưởng và Tokenomic của NEAR
Token NEAR là token được sử dụng để trả phí cho các hoạt động trên chuỗi khối NEAR.

Tokenomic của NEAR cho chúng ta thấy dự án sẽ thực hiện phát hành token dần dần trong khoảng thời gian 5 năm.



Như đã đề cập trong whitepaper của mình, 5% nguồn cung bổ sung được phát hành mỗi năm để hỗ trợ mạng dưới dạng phần thưởng tạo khối, 90% lượng token bổ sung này sẽ được dành cho các trình xác thực (chiếm 4,5% tổng cung) và 10% còn lại dành cho quỹ của hệ sinh thái (chiếm 0,5% tổng cung).

Các nguồn tham khảo thêm

 	Thông báo chính thức từ NEAR Foundation: https://near.org/blog/near-token-supply-and-distribution/
 	Twitter thread của NEARWEEK về liquid staking: https://twitter.com/NEARWEEK/status/1618257119958175747




	

	
	
		
			
				Số lượng token NEAR được phát hành mỗi năm cho các trình xác thực và người ủy quyền hiện tại là bao nhiêu?
			
		

		
					

		
			
			
			
			45 triệu token
		
			
			12.5 triệu token
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Liquid staking là gì? Tìm hiểu Meta Pool và token stNEAR
Các giao thức liquid staking đang đi đầu trong nền kinh tế staking tiền mã hóa, giúp cách mạng hóa khả năng tiếp cận thanh khoản trong lĩnh vực tài chính phi tập trung (DeFi).

Liquid staking là một giải pháp thay thế cho việc staking truyền thống: cho phép người dùng stake một số lượng NEAR bất kỳ hoặc unstake token NEAR của họ một cách hiệu quả mà không cần phải đợi khoảng 48-72 giờ (4-6 epoch) để nhận lại token cũng như phần thưởng staking của mình.



Một trong những lợi ích mà liquid staking mang lại là tăng khả năng sử dụng vốn đồng thời vẫn nhận được phần thưởng staking. Các giao thức liquid staking cũng cung cấp nền tảng cho các hoạt động như cho vay hay các hoạt động yield farming.

Nhờ vậy, người dùng có thể tương tác với nhiều nền tảng DeFi và kiếm được nhiều phần thưởng chỉ với một nguồn vốn.
Tiêu chí lựa chọn trình xác thực
Meta Pool cũng áp dụng chiến lược của NEAR Foundation để phân bổ cổ phần giữa các trình xác thực hiệu suất cao, phí hoa hồng thấp, phi tập trung, nhằm tăng cường khả năng phân cấp và chống kiểm duyệt cho mạng lưới.

Meta Pool đánh giá tất cả các trình xác thực, trong sản phẩm chính của chúng tôi không có danh sách ưu tiên và chúng tôi cũng đã công khai các công thức, mã nguồn chúng tôi sử dụng để tính toán và kết quả tính toán cũng sẽ được lưu trên chuỗi, từ đó hướng tới việc hoàn toàn minh bạch cho tất cả các trình xác thực.

Meta Pool có 5 tiêu chí để lựa chọn trình xác thực trên mạng lưới của NEAR, tất cả các tiêu chí này đều dựa trên đặc tính minh bạch và công bằng:

 	Thời gian hoạt động trong ngày luôn lớn hơn 95%
 	Phí dưới 10%
 	Đảm bảo trình xác thực sẽ không làm giảm hệ số Nakamoto của mạng lưới
 	Có đủ lượng token để đảm bảo giá giữ chỗ của NEAR Protocol
 	Tạo ra phần thưởng trong ít nhất 4 epoch liên tiếp

Bạn có thể xem danh sách các trình xác thực của Meta Pool tại đây, chỉ cần nhập “meta-pool.near” vào bộ lọc tài khoản.




	

	
	
		
			
				Liquid staking trên Meta Pool có giúp tăng tính phi tập trung cho mạng lưới không?
			
		

		
					

		
			
			
			
			Có
		
			
			Không
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hướng dẫn các bước thực hiện liquid stake lần đầu trên Meta Pool
Meta Pool cho phép người sở hữu token NEAR thực hiện staking và kiếm phần thưởng, đồng thời cung cấp một cách dễ dàng để unstake token ngay lập tức, không cần đợi thời gian khóa token như với phương pháp staking tiêu chuẩn.

Thuật toán của Meta Pool sẽ không đặt tất cả số NEAR mà bạn đã stake vào chỉ một trình xác thực, thay vào đó, Meta Pool phân bổ lượng token này vào nhiều trình xác thực có hiệu suất cao và phí hoa hồng thấp để bạn nhận được phần thưởng tốt nhất đồng thời đảm bảo mạng lưới được phi tập trung và chống kiểm duyệt.

 	Bước 1: Đăng nhập vào Meta Pool bằng cách nhấn nút “Start staking”



 	Bước 2: Nhấn vào nút “Stake Now” ở trên box “Stake NEAR”



 	Bước 3: Lựa chọn ví NEAR mà bạn ưa thích, trong ví dụ này chúng tôi sử dụng Ví NEAR tiêu chuẩn



 	Bước 4: Lựa chọn tài khoản NEAR mà bạn muốn sử dụng trên menu dropdown của ví NEAR, sau đó cho phép ứng dụng được phép truy cập vào ví NEAR của bạn bằng cách bấm vào nút “Authorizing”



 	Bước 5: Sau khi đăng nhập thành công, quay lại trang chủ và điền số lượng token NEAR mà bạn muốn stake, sau đó nhấn nút “Stake”

Chú ý: Bạn phải để lại một ít token NEAR trong ví để làm phí giao dịch nhé!



Một chú ý nữa là bạn phải stake tối thiểu 1 token NEAR



Bạn sẽ được yêu cầu xác nhận việc stake và đợi vài giây để chuỗi khối NEAR thực hiện giao dịch của bạn.

 	Bước 6: Sau khi stake thành công bạn có thể tìm thấy số dư tài khoản của mình trên các trang Home và Harvest.



Chú ý: Giao diện sẽ hiển thị lượng tài sản hiện có trong ví của bạn bao gồm lượng token NEAR và stNEAR, nếu như bạn thực hiện chuyển token stNEAR tới một tài khoản khác thì giao diện của Meta Pool cũng sẽ không hiển thị số lượng token mà bạn đã chuyển. Dưới đây là một số thống kê được hiển thị trên giao diện của ứng dụng:


Hướng dẫn các bước thực hiện unstake trên Meta Pool
Người dùng có 2 tùy chọn để unstake trên Meta Pool: bạn có thể thực hiện Liquid Unstake (unstake ngay lập tức) hoặc thực hiện Unstake kiểu truyền thống (cần chờ từ 48 tới 72 giờ).
Liquid Unstake
Bạn có thể unstake token stNEAR của mình ngay lập tức bằng cách trả một khoản phí nhỏ và sử dụng tính năng Liquid Unstake. Về bản chất là bạn sẽ hoán đổi token stNEAR của mình để đổi lấy token NEAR. Điều này được thực hiện nhờ pool thanh khoản của Meta Pool.

Các bước để thực hiện Liquid Unstake

 	Lựa chọn tab Unstake trên menu Meta Pool
 	Kiểm tra phí Liquid Unstake hiện tại và quyết định xem bạn có muốn thực hiện unstake không
 	Nhập vào số lượng token stNEAR mà bạn muốn unstake
 	Nhấn nút “Liquid Unstake” và xác nhận giao dịch
 	Mất vài giây để giao dịch unstake của bạn được xác thực trên chuỗi khối và sau đó bạn sẽ nhận được token NEAR về ví của mình



Chú ý: Phí thanh khoản của Meta Pool sẽ giao động trong khoảng từ 0.3% tới 3%, phụ thuộc vào lượng thanh khoản đang có trong pool thanh khoản của Meta Pool.




	

	
	
		
			
				Có phải token stNEAR được neo tỉ lệ 1:1 với token NEAR hay không?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Unstake kiểu truyền thống (có độ trễ)
Đây là phương pháp unstake mặc định khi bạn muốn unstake token của mình từ các trình xác thực trên NEAR Protocol: dựa trên thiết kế mạng lưới mà bạn sẽ phải chờ khoảng 4 đến 6 epoch (tức là khoảng 48 đến 72 giờ) để nhận được token NEAR về ví của mình sau khi thực hiện unstake. Với phương pháp này thì bạn sẽ không mất phí unstake.

Để thu hồi vốn từ Meta Pool theo phương pháp unstake kiểu truyền thống, bạn hãy làm theo các bước sau:

 	Chọn tab “Delayed-Unstake” trên menu giao diện của Meta Pool
 	Nhập số lượng NEAR bạn muốn unstake, sau đó nhấn nút “Start delayed unstake”



 	Bạn sẽ nhận được một thông báo về khoảng thời gian phải đợi cho tới khi lượng token NEAR chính thức về ví của mình. Bạn hãy kiểm tra lại thông tin này và xác nhận giao dịch unstake.



 	Bạn sẽ được yêu cầu thực hiện ủy quyền hành động unstake này trên ví NEAR. Hãy nhấn vào nút Authorize khi có yêu cầu.
 	Sau một khoảng thời gian chờ đợi, lượng token bạn muốn unstake đã sẵn sàng để bạn thu hồi lại về ví của mình. Hãy nhấn nút “withdraw” và xác nhận giao dịch, lượng token NEAR mà bạn vừa unstake sẽ được hiển thị trên ví NEAR của bạn.




	

	
	
		
			
				Phương pháp unstake có độ trễ (kiểu truyền thống) có ảnh hưởng tới hiệu suất của mạng lưới do nó cần thêm thời gian để di chuyển lượng token NEAR được unstake. Nhận định trên đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hướng dẫn từng bước trở thành nhà cung cấp thanh khoản trên Meta Pool
Việc unstake thanh khoản được thực hiện là nhờ vào các nhà cung cấp thanh khoản sẵn sàng cung cấp một lượng token NEAR nhằm hỗ trợ việc hoán đổi sang token stNEAR. Các nhà cung cấp thanh khoản trên Meta Pool sẽ nhận được phí Liquid Unstake khi người dùng thực hiện unstake token theo phương pháp Liquid Unstake.

Để nạp hoặc rút token NEAR, nhà cung cấp thanh khoản sẽ thực hiện các bước sau:

 	Bước 1: Chọn tab “Liquidity” trên giao diện của Meta Pool
 	Bước 2: Lựa chọn thêm hoặc rút thanh khoản bằng cách bấm nút “Add” hoặc “Remove”
 	Bước 3: Nhập vào số lượng token NEAR mà bạn muốn thêm hoặc rút



Chú ý: lượng token NEAR tối thiểu khi cung cấp thanh khoản là 2 NEAR



 	Bước 4: Xác nhận và thực hiện ký giao dịch

Giờ đây, mỗi lần có một người dùng thực hiện unstake theo phương pháp Liquid Unstake (unstake ngay lập tức), bạn sẽ nhận được một lượng phí unstake dựa trên lượng thanh khoản mà bạn đã cung cấp cho Meta Pool




	

	
	
		
			
				Phần thưởng cho các nhà cung cấp thanh khoản trên Meta Pool sẽ luôn là khoảng 10.8% APY, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!

### Meta Pool mô-đun 2 - Gọi vốn cộng đồng trên Meta Pool

Meta Yield - Gọi vốn cộng đồng không rủi ro
Meta Yield là một nền tảng huy động vốn cộng đồng dựa trên phần thưởng staking không mất phí dành cho các dự án trên hệ sinh thái NEAR đang tìm kiếm hỗ trợ tài chính và tiếp xúc với cộng đồng NEAR.

Mục tiêu của Meta Yield là cung cấp khả năng tiếp cận cộng đồng cho các dự án, cho phép cộng đồng hỗ trợ tài chính cho các dự án web 3.0 được xây dựng trên giao thức NEAR.

Meta Yield Launchpad là một nền tảng huy động vốn từ cộng đồng không rủi ro dành cho các dự án trên NEAR. Launchpad này thúc đẩy việc staking bằng cách cho phép những người ủng hộ dự án góp vốn bằng phần thưởng chứ không nhất thiết là tài sản chính của họ.



Cơ chế gọi vốn độc đáo của Meta Yield góp phần thúc đẩy liquid staking: những người đóng góp vốn cho dự án sẽ được đúc token của dự án đó bằng cách sử dụng phần thưởng staking, thay vì phải dùng các tài sản mà họ đang có.

Meta Yield hoạt động với 4 bước đơn giản sau:

 	Bước 1: Người ủng hộ dự án cam kết và khóa token stNEAR của mình lại để ủng hộ dự án (nếu bạn không có token stNEAR thì có thể truy cập trang web Meta Pool và stake token NEAR của mình)
 	Bước 2: Dự án sẽ chỉ nhận được phần thưởng staking (khoảng 10%) từ nguồn vốn mà cộng đồng đã cam kết và stake ở bước 1.
 	Bước 3: Người ủng hộ dự án sẽ kiếm được token của dự án khi các dự án này triển khai trên NEAR hoặc họ sẽ được airdrop NFT (tính năng này sắp được ra mắt)
 	Bước 4: Người ủng hộ dự án có thể thu hồi lại tài sản mà mình đã cam kết ở bước 1: sau khi quá trình khóa tài sản kết thúc, bạn có thể thu hồi lại 100% token NEAR mà bạn đã stake ở bước 1

Có thể hiểu đơn giản là bạn có thể hỗ trợ dự án gọi vốn, đồng thời nhận được phần thưởng từ token mà dự án sẽ phát hành, đóng góp vào sự phát triển của hệ sinh thái NEAR mà không hề mất đi những token mà mình đã stake.

Bạn sẽ chỉ góp vốn cho dự án bằng phần thưởng staking của mình trong khi vẫn bảo toàn lượng token mình đang có, từ đó xóa bỏ hoàn toàn những rủi ro trong quá trình đầu tư.

Bạn hãy bắt đầu đóng góp cho các dự án NEAR ngay bây giờ bằng cách truy cập trang web https://metayield.app/






	

	
	
		
			
				Bạn sẽ chỉ được đóng góp một số lượng hữu hạn token stNEAR cho các chiến dịch gọi vốn trên Meta Yield, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Làm thế nào để một dự án được gọi vốn trên Meta Yield?
Meta Yield Platform cung cấp một nền tảng gọi vốn cộng đồng và một cơ chế trả thưởng cho những người ủng hộ dự án gọi vốn trên nền tảng. Tất cả các dự án có chiến dịch gọi vốn trên Meta Yield sẽ được nền tảng chạy marketing miễn phí:

 	Trước khi chiến dịch diễn ra: dự án sẽ được nền tảng quảng cáo trong khoảng 1 tới 2 tuần, trong đó bao gồm các hoạt động như AMA, infographic, hay các bài đăng trên mạng xã hội
 	Quảng cáo về thời điểm dự án sẽ được ra mắt
 	Trong khoảng thời gian diễn ra vòng gọi vốn, Meta Yield Launchpad cũng sẽ thực hiện việc quảng cáo cho chiến dịch

Bên cạnh đó, chúng tôi cũng đang làm việc với nhiều đối tác khác trong hệ sinh thái NEAR cũng có sự quan tâm tới việc hỗ trợ tài chính cho các dự án mới.
Meta Yield lựa chọn dự án như thế nào?
Chúng tôi muốn tạo ra cơ hội cho tất cả mọi người được gọi vốn trên nền tảng của mình, nhưng chúng tôi cũng muốn mang tới cho người dùng và những nhà đầu tư tiềm năng những dự án chất lượng. Bởi vậy, tất cả các dự án muốn trở thành ứng viên gọi vốn trên nền tảng Meta Yield Launchpad sẽ phải thỏa mãn những yêu cầu sau đây:

 	Dự án phải có một đội ngũ vận hành chất lượng

Dự án cần được vận hành bởi một đội ngũ chất lượng và có tinh thần cầu tiến, luôn sẵn sàng phát triển dự án tới các bước tiếp theo sau khi gọi vốn thành công.

Kinh nghiệm của mỗi thành viên trong dự án cần phù hợp với mục tiêu mà dự án đã đề xuất. Lấy ví dụ, nếu như dự án làm trong mảng game thì dự án phải bao gồm một số thành viên đã từng làm việc trong lĩnh vực này.

Các thành viên có kinh nghiệm trong nhiều lĩnh vực khác nhau cũng là một dấu hiệu của một dự án tốt. Việc có các nhà phát triển trong đội ngũ là một điều quan trọng nhưng để thực sự đi xa hơn sau quá trình gọi vốn thì dự án cần có kinh nghiệm tiếp thị, vận hành, thiết kế, …

 	Dự án phải có một cộng đồng mạnh

Chúng tôi mong muốn các dự án tham gia gọi vốn cần xây dựng một cộng đồng mạnh phía sau, chúng tôi thường xuyên kiểm tra mức độ đóng góp và sự tích cực của cộng đồng thông qua các kênh truyền thông và mạng xã hội của dự án như Telegram, Discord, Twitter, Youtube, Instagram, TikTok và một số kênh khác được dự án đề cập trong đơn ứng tuyển của họ.

Yếu tố cộng đồng đóng vai trò rất quan trọng vì 2 lý do chính: chúng tôi thường có bước bỏ phiếu để chọn ra dự án được gọi vốn và yếu tố cộng đồng thường ảnh hưởng lớn tới quyết định bỏ phiếu của chúng tôi. Ngoài ra một phần không nhỏ trong số tiền mà dự án sẽ gọi vốn được đến từ chính cộng đồng phía sau dự án, vì thế điều cần thiết là hãy xây dựng cho mình một cộng đồng mạnh luôn sẵn sàng hỗ trợ bạn.

 	Dự án cần có một token và có tokenomic tốt

Các dự án được chúng tôi lựa chọn cần có token riêng vì nó sẽ được sử dụng như một phần thưởng cho những người ủng hộ chiến dịch của họ. Cụ thể, những người hỗ trợ cho dự án sẽ lấy phần thưởng staking của họ để góp vốn cho dự án và đổi lại họ sẽ nhận lại token từ dự án.

Và cũng bởi vì những nhà đầu tư sẽ nhận được phần thưởng là token dự án của bạn, nên việc nói cho họ biết cách sử dụng token này là vô cùng quan trọng (ví dụ dùng token để chơi, mua bán, trao đổi hoặc sử dụng token để tham gia quản trị dự án), bên cạnh đó bạn cũng cần cho họ thấy kế hoạch bạn sẽ làm để tăng thêm giá trị cho những token này.

 	Dự án cần có kế hoạch gọi vốn cụ thể

Hãy nhớ rằng việc có một chiến dịch trên Meta Yield Launchpad cũng tương tự như việc cố gắng huy động tiền từ các nhà đầu tư: họ muốn biết liệu bạn có khả năng xây dựng dự án hay không và bạn sẽ kiếm tiền từ dự án đó như thế nào.

Vì vậy, bạn cần chuẩn bị sẵn sàng để giải thích cơ bản cách mà bạn sẽ sử dụng số tiền mà bạn đã kêu gọi được: dùng vốn để marketing, để cải thiện sản phẩm, dịch vụ, mở rộng các tính năng hiện có, hay bạn sẽ dùng số vốn đó để thay đổi, đổi mới thương hiệu, cải thiện các chức năng của nền tảng, …

 	Dự án cần kết nối tới hệ sinh thái NEAR

Chúng tôi đang làm việc với các dự án, cộng đồng NEAR và việc giao tiếp trên hệ sinh thái này là vô cùng quan trọng. Vì vậy, chúng tôi khuyến khích các bạn hãy thiết lập một mối quan hệ thân thiết với hệ sinh thái các dự án trên NEAR.

Đội ngũ của dự án cần chứng minh rằng họ đã từng hợp tác và biết cách làm việc với các đối tác trên hệ sinh thái NEAR. Ví dụ bạn từng nhận tiền trợ cấp, tham gia các chương trình ươm tạo hoặc là thành viên của các hội nhóm trong hệ sinh thái thì sẽ là một dẫn chứng thuyết phục cho điều kiện này của chúng tôi.

Điều này đảm bảo rằng hệ sinh thái NEAR đã biết tới dự án của các bạn và khi dự án được triển khai trên mainnet, hệ sinh thái sẽ sẵn sàng để hỗ trợ nó.




	

	
	
		
			
				Một dự án muốn được gọi vốn trên Meta Yield phải là một dự án có tầm nhìn triển khai trên nhiều chuỗi khối khác nhau, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tôi có thể tìm thêm thông tin về Meta Yield ở đâu?
Bạn có thể tìm hiểu thêm các thông tin tại trang web của Meta Yield và blog của chúng tôi.
Chợ Meta Bond - Bán tài sản đang khóa trên Meta Yield
Chợ Meta Bond được sinh ra nhằm mang tới một công cụ để mua bán và đề xuất các loại trái phiếu khác nhau được sinh ra từ việc staking để hỗ trợ các dự án gọi vốn trên Meta Yield.

Bạn có thể truy cập trực tiếp vào chợ Meta Bond tại địa chỉ metabondmarket.app
Kết nối ví NEAR với chợ Meta Bond
Tại trang web của chợ Meta Bond: metabondmarket.app, bạn hãy liên kết với ví NEAR của mình để có toàn quyền truy cập vào các tài sản tiền mã hóa. Nhấn vào nút “Connect Wallet” và chọn tài khoản NEAR bạn muốn kết nối.


Meta Bond hoạt động như thế nào?
Cơ chế hoạt động của Meta Bond có thể được hiểu qua 4 bước đơn giản sau:

 	Bước 1: Hỗ trợ các dự án trên Meta Yield
 	Bước 2: Nhận về một lượng trái phiếu (bond) tùy theo lượng tài sản mà bạn đã đầu tư cho các dự án trên Meta Yield và các phần thưởng liên quan
 	Bước 3: Đưa ra đề nghị bán trái phiếu trên Meta Bond
 	Bước 4: Hoặc mua trái phiếu từ những người bán khác trên nền tảng

Nếu các dự án gọi vốn trên Meta Yield có thể đạt được mục tiêu gọi vốn đầu tiên thì những người ủng hộ của dự án sẽ được thưởng token riêng của dự án với số lượng tương ứng với lượng vốn mà họ đã cam kết ủng hộ.

Khi thời gian gọi vốn kết thúc, chợ Meta Bond sẽ phát hành hai loại trái phiếu(bond) cho những người ủng hộ dự án:

 	Loại trái phiếu thứ nhất có số lượng tương ứng với giá trị NEAR của lượng token stNEAR được khóa tại thời điểm kết thúc vòng gọi vốn
 	Loại trái phiếu thứ hai có số lượng phụ thuộc vào lượng token của dự án được hỗ trợ nhận được khi phát hành dần dần

Người ủng hộ dự án có thể bán một trong hai loại trái phiếu bất cứ lúc nào trong thời gian tài sản của họ trên Meta Yield vẫn đang bị khóa.

Nếu như trái phiếu không được rao bán thì khi kết thúc thời gian khóa tài sản trên Meta Yield, khoản đầu tư sẽ được trả về cho người đang nắm giữ các trái phiếu này và phần thưởng của việc hỗ trợ dự án gọi vốn cũng được ủy quyền phát hành dần dần theo đề xuất.

Với mỗi loại trái phiếu bạn có thể thực hiện một trong những hành động sau:

 	Chia nhỏ thành nhiều trái phiếu
 	Rao bán trực tiếp
 	Đấu giá trái phiếu

Bạn cũng cần cài đặt thời điểm mà những trái phiếu này được rao bán.

Nếu trái phiếu được bán thì người bán sẽ nhận được lượng token tùy theo giá bán nếu như đó là bán trực tiếp hoặc nhận về mức đấu giá tốt nhất nếu họ lựa chọn đấu giá trái phiếu của mình.

Nếu trái phiếu không bán được, nó sẽ sẵn sàng để được bán lại hoặc vẫn thuộc quyền sở hữu của người bán và người bán có thể rao bán lại nếu muốn.






	

	
	
		
			
				Meta Bond cho phép bạn bán token đã bị khóa khi bạn tham gia hỗ trợ chiến dịch trên Meta Yield
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nền tảng chợ Meta Bond
Menu của nền tảng

Bond Market - Chợ trái phiếu
Mục này sẽ hiển thị tất cả các trái phiếu được rao bán trên nền tảng. Dữ liệu của mỗi trái phiếu được hiển thị và bạn có thể mua hoặc ra giá cho chúng.
My Bonds - Danh sách các trái phiếu của tôi
Mục “My Bonds” hiển thị chi tiết tất cả các trái phiếu mà người dùng sở hữu. Tại mục này, người dùng có thể:

 	Thấy tất cả các thông số của trái phiếu mình đang sở hữu
 	Bán trái phiếu
 	Hợp nhất các trái phiếu (chú ý: để hợp nhất 2 trái phiếu thì tất cả các tiêu chí của hai trái phiếu này phải khớp nhau, bao gồm tài sản đằng sau trái phiếu, ngày đáo hạn và ngày hết hạn nếu có)
 	Chia nhỏ trái phiếu (trái phiếu chỉ có thể được chia nhỏ khi không có phần nhỏ nào của nó đã được thu hồi)

My Sales - Danh sách các đơn hàng của tôi
Trong mục này, bạn có thể xem các trái phiếu mà mình đã hoặc đang rao bán.

 	Rao bán trực tiếp: người mua ra giá thầu trực tiếp, người bán sẽ thấy trong mục này rằng việc bán hàng đã được thực hiện và có thể nhận được các token tương ứng.
 	Bán đấu giá: người trả giá cao nhất là người chiến thắng và khi kết thúc phiên đấu giá người bán sẽ nhận được lượng token từ người thắng đấu giá
 	Kết thúc thời gian đấu giá: nếu vào cuối phiên đấu giá không có đề nghị mua nào thì người bán có thể rao bán lại trái phiếu của mình hoặc lựa chọn kết thúc phiên đấu giá.

Chú ý: nếu trái phiếu đã được bán thành công thì người bán phải nhập vào số lượng trái phiếu đã bán và nhấn vào nút “get tokens” để hoàn tất việc đóng đơn hàng. Quá trình đóng đơn hàng này phải làm thủ công.
Trái phiếu đảm bảo
Khi rao bán trái phiếu, hệ thống sẽ yêu cầu từ bạn một số tiền tối thiểu (hiện tại là 1 NEAR) như một loại phí bảo lãnh.

Điều này cho phép hệ thống chỉ nắm giữ các trái phiếu đại diện cho số tiền bảo lãnh tối thiểu được đề cập.

Khi kết thúc quá trình bán, số tiền phí bảo lãnh này sẽ được trả lại cho người bán.
My Bids - Danh sách thầu của tôi
Trong mục “My bids” này, người dùng có thể xem những đề nghị của họ cho các trái phiếu đang được đấu giá.

Các trái phiếu được bán trực tiếp sẽ không được hiển thị ở đây vì chúng đã được hiển thị trong mục “My Bonds” được đề cập ở phía trên.

Nếu bạn đang không dẫn đầu trong một phiên đấu giá thì hệ thống sẽ cho phép bạn tăng giá đề xuất mua của mình hoặc hủy đề xuất mua bằng cách thu hồi lại lượng token mà bạn đã ra giá.
Trạng thái của các trái phiếu trong phiên đấu giá
Phiên đấu giá đang diễn ra

 	Đang thua: đề nghị mua của bạn đang thấp hơn của một ai đó. Bạn có thể tăng mức giá đề xuất hoặc thu hồi lại đề xuất của mình
 	Đang thắng: đề xuất mua của bạn đang dẫn đầu phiên đấu giá. Tuy nhiên, bạn vẫn phải chờ cho tới khi phiên đấu giá kết thúc để chắc chắn rằng mình đã thắng phiên đấu thầu

Phiên đấu giá kết thúc

 	Thắng: nếu bạn thắng sau khi phiên đấu giá kết thúc thì trạng thái này sẽ được hiển thị. Bạn có thể thu hồi lại trái phiếu mà mình vừa thắng thầu.
 	Thua: nếu kết thúc phiên đấu giá, bạn không phải người ra giá cao nhất thì trạng thái này sẽ được hiển thị. Bạn có thể thu hồi lại lượng token mà mình đã dùng để đấu giá cho trái phiếu.




	

	
	
		
			
				Tồn tại rủi ro cao của việc bị thanh lý khi bạn rao bán trái phiếu của mình trên chợ Meta Bond, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hướng dẫn từng bước tham gia chợ Meta Bond


 

### Meta Pool mô-đun 3 - Tài chính phi tập trung trên Meta Pool

Hệ sinh thái DeFi của Meta Pool
Tài chính phi tập trung (DeFi) là một hướng tiếp cận mới để vận hành nền tài chính dựa trên công nghệ chuỗi khối. Các công cụ tài chính này sử dụng hợp đồng thông minh để lưu trữ, khóa, chia sẻ, phân phối và farming token. DeFi được sinh ra với mục đích loại bỏ quyền kiểm soát mà các ngân hàng trung ương đang có đối với tài sản và phân phối chúng thông qua các hợp đồng thông minh.

Hợp đồng thông minh của Meta Pool giúp phát hành tài sản hoàn toàn phi tập trung, không lưu ký, cho phép người dùng có thể thực hiện stake token NEAR và nhận phần thưởng staking thông qua một token có tên là stNEAR.

Token stNEAR cho phép người nắm giữ có thể chuyển qua lại giá trị của các token được stake và các phần thưởng trên hệ sinh thái DeFi của nhiều chuối khối khác nhau, bao gồm NEAR và Aurora.




	

	
	
		
			
				Tồn tại một phần của tài chính phi tập trung được vận hành bởi các thực thể tập trung và không phải tất cả các ứng dụng DeFi đều 100% phi tập trung, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Di chuyển token stNEAR giữa hai chuỗi khối NEAR và Aurora thông qua Rainbow Bridge
Meta Pool sử dụng Rainbow Bridge để chuyển token META và token stNEAR giữa hai chuỗi khối NEAR và Aurora, từ đó cho phép người dùng có thể sử dụng hai loại token này trên mạng lưới Aurora, cụ thể là trên các ứng dụng như Trisolaris, WannaSwap, …
Hướng dẫn chuyển token stNEAR và META sang mạng Aurora sử dụng Rainbow Bridge
Bạn hãy kết nối ví NEAR cũng như ví MetaMask của mình với Rainbow Bridge tại trang web https://rainbowbridge.app/ để có thể chuyển các token của mình:




Làm thế nào để thêm địa chỉ hợp đồng thông minh của token META và stNEAR vào ví MetaMask
Để thêm một token mà bạn vừa chuyển sang chuỗi khối Aurora vào danh sách tài sản được theo dõi trên ví MetaMask, bạn hãy nhấn vào nút ‘Scan transfer history’ trên giao diện của Rainbow Bridge, sau đó chọn ‘Add token to MetaMask’.

Để thực hiện việc thêm token này theo cách thủ công, bạn hãy tìm địa chỉ hợp đồng thông minh của token đó rồi tự thêm vào danh sách tài sản trên ví MetaMask nhé. Lưu ý là các token này có địa chỉ hợp đồng thông minh khác nhau trên chuỗi khối Aurora và Ethereum. Cụ thể:

 	Địa chỉ token META trên Aurora: 0xc21ff01229e982d7c8b8691163b0a3cb8f357453
 	Địa chỉ token stNEAR trên Aurora: 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30




	

	
	
		
			
				Một khi bạn đã chuyển một token nào đó từ chuỗi khối NEAR sang Aurora thì bạn sẽ không thể chuyển token đó ngược lại về chuỗi khối NEAR, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Hoán đổi token trên Aurora với Trisolaris
Hoán đổi token là quy trình giúp bạn đổi từ token này sang token khác dựa trên giá trị thị trường hoặc giá trị trong pool thanh khoản của hai token đó. Bằng cách này bạn có thể có được token mà bạn muốn nắm giữ hoặc tìm kiếm một token nào đó mà bạn đang muốn dùng trong một ứng dụng cụ thể.

Trisolaris là sàn DEX số một trên mạng Aurora - một chuỗi khối sử dụng máy ảo EVM và đang vận hành trên hệ sinh thái NEAR.

Làm thế nào để swap token trên Trisolaris?

 	Bước 1: Truy cập phần Trisolaris Swap và lựa chọn kết nối ví MetaMask của bạn - bạn nhớ phải chuyển sang dùng mạng Aurora trên ví MetaMask nhé.



 	Bước 2: Nhập vào số lượng token mà bạn muốn swap
 	Bước 3: Phê duyệt và xác nhận giao dịch trên ví MetaMask




	

	
	
		
			
				Bạn có thể dùng cơ chế định tuyến để swap token khi không có pool thanh khoản của hai token đó, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cung cấp thanh khoản cho các pool của token stNEAR trên Trisolaris
Vì các sàn phi tập trung không quản lý việc phát hành token, nên các sàn này cần người dùng tự thêm thanh khoản cho những pool giao dịch để việc swap token trở nên khả thi.

Bạn có thể trở thành một nhà cung cấp thanh khoản bằng cách thêm một lượng token cho cặp token của một pool thanh khoản. Đổi lại, bạn sẽ nhận được một phần trích ra từ phí giao dịch của pool đó.

 	Bước 1: Chuyển tới mục Pool trên giao diện và nhấn vào nút “Add liquidity”



 	Bước 2: Lựa chọn cặp token mà bạn muốn cung cấp thanh khoản. Trên Trisolaris, bạn có thể chọn cặp token stNEAR <> wNEAR



 	Bước 3: Xác nhận số dư và nhấp vào nút “Add”


Swap token trên NEAR Protocol với Ref Finance

 	Bước 1: Truy cập trang web của Ref Finance và kết nối ví NEAR của bạn
 	Bước 2: Chuyển tới mục Swap trên giao diện



 	Bước 3: Lựa chọn token mà bạn muốn swap và kiểm tra các phần ‘Price impact’, ‘Swap rate’ và ‘Minimum received’ trên menu chi tiết. Sau đó quyết định xem bạn có muốn swap không.
 	Bước 4: Nhập vào số lượng token bạn muốn swap
 	Bước 5: Nhấn vào nút ‘Swap’, sau đó xác nhận và ký giao dịch

Từ đó, trên Ref Finance, bạn có thể nhận được token $META và stNEAR.
Cung cấp thanh khoản cho các pool có token stNEAR trên Ref Finance
Ref Finance là sàn giao dịch phi tập trung nổi bật nhất trên NEAR Protocol. Ứng dụng này cung cấp một bộ công cụ DeFi được phát triển theo tiêu chuẩn NEP-141.

 	Bước 1: Chuyển tới mục ‘Pools’ và tìm kiếm các pool thanh khoản có token stNEAR, sau đó chọn pool mà bạn muốn thêm thanh khoản



 	Bước 2: Nhấn nút ‘Add Liquidity’ trên giao diện



 	Bước 3: Nhập số lượng token mà bạn muốn cấp thanh khoản cho pool



Sau khi thực hiện thành công các bước trên, bạn sẽ nhận được một phần phí giao dịch khi những người dùng khác thực hiện swap token trên pool mà bạn vừa cung cấp thanh khoản.




	

	
	
		
			
				Việc trở thành một nhà cung cấp thanh khoản có thể đặt token của bạn vào nguy cơ bị thanh lý, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Vay tài sản với token stNEAR trên Burrow Cash
Vay mượn có nghĩa là bạn sẽ thế chấp một loại token và được vay một số lượng token khác. Bạn sẽ vay được một lượng token có giá trị nhỏ hơn giá trị của lượng token bạn đã thế chấp trên Burrow.

Nếu bạn muốn lấy lại token của mình, bạn cần phải trả nợ.

Trong trường hợp giá trị của tài sản thế chấp bị giảm sâu thì nó sẽ bị tự động thanh lý bởi nền tảng Burrow. Khi đó bạn sẽ chỉ còn nắm giữ lượng token đã vay và sẽ không thể thu hồi lại những gì đã thế chấp.

 	Bước 1: Truy cập trang web BurrowCash
 	Bước 2: Kết nối ví NEAR với ứng dụng
 	Bước 3: Chuyển tới mục ‘Deposit’ để thế chấp token stNEAR


Các bước nạp token stNEAR:

 	Nhập vào số lượng token stNEAR
 	Sử dụng lượng token bạn vừa nạp như tài sản thế chấp nếu bạn muốn vay token khác
 	Xác nhận và ký giao dịch vay


Các bước vay token trên Burrow


 	Bước 1: Lựa chọn token mà bạn muốn vay
 	Bước 2: Nhập số lượng token bạn sẽ vay, bạn nhớ kiểm tra chỉ số Health Factor tương ứng với lượng tài sản mình muốn vay nhé
 	Bước 3: Xác nhận và ký giao dịch vay


Các bước trả lại tài sản đã vay


 	Bước 1: Chuyển sang tab ‘Portfolio’
 	Bước 2: Nhấn vào nút ‘Repay’


Các bước rút lại tài sản thế chấp


 	Bước 1: Chuyển sang tab ‘Portfolio’
 	Bước 2: Nhấn nút ‘Withdraw’






	

	
	
		
			
				Bạn có thể sử dụng Burrow cash ở bất kỳ quốc gia nào trên thế giới, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Vay tài sản sử dụng token stNEAR trên Aurigami
Aurigami cho phép bạn vay token trên mạng Aurora. Bạn có thể vay token bằng cách thế chấp stNEAR.

Tại thời điểm của bài viết này, bạn có thể truy cập trực tiếp vào phần ‘Dashboard’ của Aurigami và nhấn nút ‘Supply’ cho token stNEAR. Nếu bạn đã thế chấp token stNEAR thành công, hãy nhấn nút ‘Borrow’ như trong hình dưới để vay tài sản.



Khi nhấn nút ‘Supply’, giao diện ứng dụng sẽ hiển thị một form để bạn nạp token stNEAR. Sau khi điền số lượng stNEAR mà bạn dùng làm tài sản thế chấp, hãy nhấn nút ‘Approve stNEAR’



Sau khi nạp stNEAR thành công, bạn hãy cho phép ứng dụng được sử dụng token stNEAR làm tài sản thế chấp để có thể vay token. Xác nhận giao dịch trên ví NEAR của bạn.



Sau đó hãy lựa chọn loại tài sản bạn muốn vay và nhấn vào nút ‘Borrow’.



Nhập vào số lượng token bạn muốn vay. Chú ý: nếu bạn lựa chọn vay 100% tính theo giá trị tài sản thế chấp, khoản thế chấp của bạn sẽ rất dễ bị thanh lý!



Khi bạn muốn thu hồi lại lượng token stNEAR mà mình đã thế chấp, hãy trả lại tất cả tài sản đã mình đã vay bằng cách chuyển tới tab ‘Repay’ như hình dưới đây.


Yield Farming có đòn bẩy trên Pembrock
Pembrock là ứng dụng cho phép yield farming có sử dụng đòn bẩy đầu tiên trên NEAR Protocol. Trên ứng dụng này bạn có thể cho vay, farming hoặc stake token. Token stNEAR là một trong những token được sử dụng trên ứng dụng Pembrock.


Farm cặp token stNEAR-wNEAR
Bạn hãy nạp token stNEAR và vay token wNEAR trên pool farm của Pembrock. Chọn token được dùng làm tài sản thế chấp và mức đòn bẩy như hình dưới đây. Sau đó xác nhận giao dịch.


Cho vay token stNEAR
Nhập vào số lượng token stNEAR bạn muốn cho vay. Lượng stNEAR này sẽ được những người tham gia yield farming trên Pembrock dùng làm đòn bẩy.



Bạn có thể tìm hiểu thêm về cách Pembrock hoạt động tại đây: https://docs.pembrock.finance/education/how-to-guides




	

	
	
		
			
				Yield Farming có sử dụng đòn bẩy có tiềm ẩn rủi ro cho token của bạn, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Staking NEAR trên Aurora
Giờ đây người dùng đã có thể dễ dàng stake token wNEAR trực tiếp trên mạng Aurora bằng ví MetaMask. Nhờ việc tận dụng sức mạnh của Rainbow Bridge để thực hiện các cuộc gọi hợp đồng giữa hai chuỗi khối Aurora và NEAR, chúng tôi đã xây dựng thành công một giải pháp đơn giản giúp duy trì trải nghiệm và giao diện người dùng tương tự như giải pháp staking đang có trên NEAR.



Bạn có thể dễ dàng nhận biết mình đang sử dụng chuỗi khối nào nhờ logo của Aurora và trang web cũng sẽ tự động nhắc bạn nên kết nối ví MetaMask của mình để staking.

Chúng tôi đang tận dụng Rainbow Bridge để tự động hóa tất cả các bước mà người dùng đang phải thực hiện thủ công. Bản chất của quá trình staking NEAR trên Aurora sẽ như sau: chuyển token wNEAR từ Aurora đến NEAR Mainnet, chuyển đổi wNEAR thành token NEAR, nạp lượng NEAR này vào Meta Pool, nhận về stNEAR và gửi lại lượng stNEAR qua Rainbow Bridge tới ví Aurora của người dùng.

Chúng tôi đã làm tốt nhất có thể để bảo vệ tài sản được an toàn và mã nguồn của chúng tôi đã được kiểm toán bởi Blocksec.

Meta Pool đang tính phí giao dịch trên Aurora là 0.1% để bù lại phần chi phí trong quá trình chuyển qua lại các token thông qua Rainbow Bridge.

 

### 👀BugEye beta test

Follow @LearnNEAR on Twitter

Beta test sprint starts: July 20, 9 am ET
Beta Test sprint ends: July  24, 9 am ET
Requirements:

 	Explore LNC website, including courses
 	Detect and describe an issue/bug found and make screenshots
 	Submit issue to BugEye
 	Take a screenshot 
 	Tweet your screenshot and  "I just reported an issue via @LearnNEAR  👀BugEye, web3 community user testing platform!"
 	Submit feedback form

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic

### How nCaptcha Fights Spam

“nCaptcha” is Learn Near Club’s latest product, providing a web3 version of the classic CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart). In this blog, we will first learn how the traditional CAPTCHA works and then see how nCaptcha flips it on its head.
How does CAPTCHA work?


Image Credit

You must have come across the image above during your surfing sessions. CAPTCHA was built as a security measure to help protect users from spam and password decryption.

Funnily enough, the history of CAPTCHA is tied to hackers, the very group it aims to stave off today. In the late 1980s and early 1990s, early internet forum users inadvertently laid the foundation for CAPTCHAs. Realizing that moderator programs monitored certain sensitive keywords, they devised a method to circumvent this scrutiny. These users replaced specific letters in sensitive keywords with numbers or symbols, effectively tricking the bots. This strategy eventually evolved into a form of jargon known as leetspeak.

However, the real turning point for CAPTCHAs came in the late 1990s when computer scientists noted the potential of these text distortions in thwarting scammer algorithms. The concept took a more formal shape when two separate teams - one from Carnegie Mellon University and another from cybersecurity company Sanctum - developed methods to impede bots using distorted text in 1997. This marked the dawn of the modern CAPTCHA, a key security tool that helps prevent data theft by providing a barrier to automated programs while allowing human users to pass through.
Ok, but how does CAPTCHA work?
The system accomplishes this by requiring users to pass a straightforward test, verifying that they are humans, not computers attempting to breach a password-secured account. This test consists of two parts:

 	A randomly generated, distorted sequence of characters in image form.
 	A text input box.

Users must identify and reproduce the characters shown in the image to reproduce the characters in a text box. This requires a certain level of cognitive ability that’s pretty straightforward for a human but exceedingly complex for bots. This is because we have the ability to interpret letters in different fonts and handwriting. Since bots are unable to do so, they fail the test and get blocked from interacting with the application or website.
Google and CAPTCHA
Google implements CAPTCHA via its reCAPTCHA system. You might encounter these Google-powered CAPTCHA under the following circumstances:

 	Registering for a new Google service (like Gmail, Blogger, or YouTube)
 	Subscribing to any version of a Google Workspace Account
 	Altering the password on an existing account
 	Configuring Google services for a third-party device or application (such as iPhone, Outlook, ActiveSync, etc.)

Google uses CAPTCHA to safeguard user data and maintain its service integrity. Google isn’t the only web2 giant leveraging CAPTCHA. It is pretty much everywhere and extensively used.

There is no doubt that CAPTCHA has been a powerful security measure. However, their recent effectiveness and utility have been called into question.




	

	
	
		
			
				What is the primary method used by nCaptcha to prevent spam?
			
		

		
					

		
			
			
			
			It requires users to identify objects in images
		
			
			It uses AI to detect suspicious behavior
		
			
			It requires users to make a mini-deposit for form submissions

		
			
			It blocks all users who don't have a Gmail account
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Are CAPTCHAs No Longer Effective?
The entire premise of CAPTCHAs is that a machine should not have the cognitive ability of a normal human to decipher these messages. CAPTCHAs rely on a partially behavioral-based approach. Besides assessing a user's ability to solve the given puzzle, these tools also monitor actions like webpage navigation speed and mouse movement curvature. However, over the past decade, machine learning and artificial intelligence capabilities have evolved significantly, becoming more human-like and, in some cases, surpassing human abilities in solving complex puzzles. Machines, with their extensive memory and multi-tasking capabilities, can often breeze through single puzzles like CAPTCHAs.

Moreover, the emergence of CAPTCHA-solving farms – human-operated services that decode CAPTCHAs for bots – poses another challenge. Through these farms, bots can resolve CAPTCHAs within a matter of seconds, bypassing this layer of security with minimal expense and effort.
So, how do you mitigate this?
The most logical way to mitigate CAPTCHA-breaking is by increasing the complexity of the task itself. However, there is a problem here. When you increase the complexity of CAPTCHAs, you are making it difficult, or worse, annoying for humans to solve it as well. According to Sandy Carielli, a principal analyst for Forrester, CAPTCHAs can negatively impact the human experience. As per Carielli’s report, around 19% of US adults have deserted their online transactions over the last year due to complex CAPTCHAs.



Image credit

Plus, here is the kicker. Complicating the CAPTCHA may not even work.

In 2014, Google pitted an algorithm against one of its most complicated CAPTCHAs. The algorithm successfully cracked the CAPTCHA, while only 33% of human users were able to solve it.

So, what’s the solution?

Tamer Hassan, co-founder and CEO of cybersecurity firm HUMAN Security, has this to say:

“We shouldn’t be testing our humans; we shouldn’t be treating our humans like they’re the fraudsters. We should be testing the bots in different ways, and so increasing friction on humans is not the way to go.”

Let’s turn to web3 to find a solution.
nCaptcha – Fighting Spam With web3
Learn Near Club’s nCaptcha is an innovative and efficient solution designed to combat website spam. Unlike traditional CAPTCHA systems, where you end up annoying your users with complicated texts and images, nCaptcha leverages the capabilities of web3 and blockchain technology for human authentication.

As a website owner, using nCaptcha is very straightforward. After integrating it into your website, your users do a microtransaction worth 0.01 NEAR. Half of it goes to nCaptcha, and the other half to you, the website owner.

nCaptcha deters spammers by using a combination of the following:

 	Requiring mini-deposits for form submissions. This mini-deposit system works as a vetting mechanism that is both simple for genuine users and extremely effective in deterring spammers, who would need to make countless micro-transactions, thereby rendering spamming efforts inefficient and expensive.
 	Establishing an on-chain, transparent, and immutable user reputation score.

Here are a few other things to keep in mind about nCaptcha:

 	You need to have a NEAR account to use nCaptcha.
 	It integrates seamlessly with WordPress, with a dedicated comments plugin, making it versatile and accessible to a wide range of web applications.
 	It also has high compatibility with various web2 platforms, bridging the gap between conventional internet infrastructure and blockchain-based applications.
 	Its decentralized backend makes it robust and resistant to attacks or disruptions common in centralized systems.
 	Built on JavaScript, it is supported by popular browsers, thereby offering a user-friendly interface for website owners and visitors alike.
 	It's also available as an NPM package, mobile-ready, fully responsive, and doesn't require any smart contracts, making it even more straightforward for developers to implement.
 	You can use nCaptcha at Telegram to prevent spam in your chats




	

	
	
		
			
				What major drawback of traditional CAPTCHAs does nCaptcha address?
			
		

		
					

		
			
			
			
			The complexity and annoyance of traditional CAPTCHA tests
		
			
			The high cost of implementing traditional CAPTCHA systems
		
			
			The slowness of traditional CAPTCHA systems
		
			
			The language barrier presented by traditional CAPTCHA systems
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





So, how does it work?
Let’s see nCaptcha in action.

To use nCaptcha, you must first have a named Near wallet account like Satoshi.near or xyz.near. It shouldn’t just be your public address. Go to Lean Near and log in using your wallet. Now, go to the Contact Us page.

Scroll down to see the nCaptcha widget.



As you can see, instead of dealing with an annoying Captcha, you just need to verify using a microtransaction.

Click on “Verify with nCaptcha” to get redirected to the following:



Click on “Approve” and finish your verification.



Once verification is done, you may click on “Transaction” to get redirected to Near Explorer so we can see what’s going on behind the scenes.

 

The first half of the 0.01 verification transaction goes to the website (in this case Learn Near).



The second half goes to nCaptcha.



This way, we have a system that benefits everyone:

 	User: No time wasted in looking through stupid images.
 	The website owner: No user drop off from complicated images and earning NEAR from verification fees.
 	nCaptcha: Earning verification fees.

This win-win-win philosophy is the very ethos of web3.
Changing The Spam Game With nCaptcha
The effectiveness of nCaptcha lies in its simplicity and innovative use of web3 micro-transactions. CAPTCHAs have proven themselves to be increasingly complicated and ineffective. nCaptchas provide an elegant alternative.

You may download nCaptcha and get more information here.




	

	
	
		
			
				What do you need to use nCaptcha?
			
		

		
					

		
			
			
			
			An account with a major email provider
		
			
			A credit card
		
			
			A NEAR account
		
			
			A high level of computer programming skills
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







                 
 
                        Do you like nCaptcha more than legacy CaPT4rE$?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I am Robot, I don't get it
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Do you like nCaptcha more than legacy CaPT4rE$?

Do you like nCaptcha more than legacy CaPT4rE$?
                            
                         
 
                        Do you like nCaptcha more than legacy CaPT4rE$?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I am Robot, I don't get it
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Update – July 3, 2023

Brief Summary:

 	
FastAuth campaign , NEAR Blockchain Operating System was a blast!




Results:

 	📚 (L)Earn about FastAuth on #NEAR Blockchain Operating System in 7 languages!
 	🏆June Redeem window was super awarding! Over 200 (L)Earners completed the requirements and claimed 5 $NEAR
 	We had surprise Partner Redeem from MetaPool!
 	
📚 (L)Earn  How to Buy, Sell, and Manage Securely NEAR Accounts as NFTs

 	qVote for your favorite NEAR explorer! - Have your quadratic say, (L)Earner 🕺

 	📚(L)Earn about How to stake #NEAR tokens using different wallets with @everstake_pool

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	New (l)earning opportunity is coming for BetaTesters! Stay tuned!

### NEAR-Ethereum Bridge Tests

Test #1. Transfer from NEAR to Ethereum by Fast Rainbow.
First, needs to say that currently the fast bridge support only 3 tokens, USDC, WBTC and Aurora, in compare with the old regular Rainbow bridge, which supports 30+ tokens including ETH &NEAR ERC20. But let’s hope that is because of the early beginning stage and they will add more tokens soon. However, the info about what tokens available for fast bringing is missing at the front page of Rainbow App, there is only a link to a blog’s article and in the middle of it’s long text you may find it. This is not so convenient for a user, a trader for instance – he comes to make a fast swap, not to browse long articles, so he needs brief full info in front of eyes, not on other 3rd site’s pages. Of course, this is not a big problem. Please, consider this notice just like a wish for future UI improvements.

So, I have selected USDC token for this test as the most popular among those 3 available, then have exchanged previously some NEAR to USDC.e at Reffinance. This calculation appeared after i connected wallets, selected tokens&chains and typed a wished amount at previous tabs:



Here I like that the cost of Fast transfer is more predictable in comparison with the old Regular transfer, which is fully depends on the gas price in Ethereum and nobody knows how much it becomes after 4-8 hours. For the Fast option the bridge’s fee always calculates as $20 basic + 0.1% of amount.

But I would like to point out that in general a such fee remains too high for small amounts. On my mind, a total fee should not exceed 1%-2% of the amount, so Fast Rainbow could be affordable for swaps $1000 and higher, but smaller users should look for other solutions of exchange. Of course, this is just my opinion, everyone decides by himself.

After pressing ‘confirm’ button below the tab on pic. above and approval transaction by NEAR wallet, i received USDC ERC20 to my Ethereum address in ~1 minute. It is Fast indeed!



Notice that the fee has been paid by currency I swap from, i.e. USDC.e NEAR. It doesn’t need to have some ETH for gas, and this is a big plus for those who have only NEAR and tokens in NEAR chain but has no ETH yet.

* Approval transaction in NEAR chain also consumes some gas, as well as transaction of exchange NEAR-to- USDC.e at Reffinance. But those fees on NEAR side are too small in compare with bridge’s fee, it is less 0.005 NEAR( <$0.01) each. So, here and below I don’t count those gas fees on NEAR side.

Some suggestions how the bridge’s UI could be improved:

1. Now there is only the ‘continue’ button to navigate across these tabs, from the start to the final calculation. It would be nice to have ‘back’ button also, in order to return back 1 step only(if i need just to edit amount for instance) instead of to return to the start and begin all again – select tokens, type amounts, etc. as it’s now.

2. Now I can select a token & get this estimated calculation only if I already have that tokens at the balance of my wallet. It means first i need to buy some tokens somewhere (at Reffinance for example) and only then i would be able to see how much it will cost to swap it at the bridge. But if the bridge fee(or processing time ) would not satisfy me, that means i have exchanged these tokens (NEAR to USDC.e for instance) just for nothing, just wasted some time and a small NEAR for gas. So, it would be nice to allow to select&get calculation for any available at bridge token, doesn’t depend on if I have it at my wallet or have no yet. It’s easy, just don’t allow to confirm the transaction at the last step if the wallet’s balance is less than the amount typed in the form, instead of don’t allow to select&calculate at all.

And, I would like to notice a good level of Rainbow’s support and say thanks to them. They answer quickly in TG group, explain in detail all I might ask. This is a very positive factor for this project, i think so.
Test #2. Transfer from NEAR to Ethereum by ZK bridge ElectronLabs.
Frankly, I’m not sure if regular mass users, such as traders, or gamers, etc., really need ZK proofs for all their daily transactions. But ok, everyone can decide for himself.

Let’s go to simple matters, but those are more interesting for everybody: costs, fees, processing time, etc.

Currently ZK bridge has only one token available, USDC.e, there is nothing else to choose.

But they just started on the mainnet a few days ago, even the protocol didn’t pass audit yet.

So, let’s hope they improve the list of available tokens in future.

The swap from Near to Ethereum is going in 2 steps.

First you swap a regular USDC.e token to zkUSDC.e . This is their own service token, there is a liquidity pool USDC.e /zkUSDC.e and the rate is always 1:1.



This transaction is going in NEAR chain, after approval by wallet it takes a few seconds and consumes a small gas like almost NEAR transactions, nothing special. Also, ZK bridge takes a few cents of fee, not too much at this step.

This step 1 could be passed if you already have zkUSDC tokens in your wallet. Then you should select zkUSDC in Send string and go directly to step 2.

 

At the 2nd step this zkUSDC.e is swapping to USDC ERC20(Ethereum)



The first impression is that the bridge fee is too high! x2 -x3 times higher than in Rainbow.

Obviously, this service is not for a regular user, those usually operate by much smaller

amounts. Even exchange NEAR to ETH or to any ERC20 by using a CEX will cost less in total.

So, decide yourself please if zk proof is worth such expenses.

Regarding the processing time, it took about 7-8 minutes to receive 3.12 USDC to my Ethereum address after I hit ‘Transfer’ button and approved transaction by NEAR wallet. This is a bit longer than Fast Rainbow, but 7-8 minutes could be as acceptable time.

And of course, it’s out of logic to pay $52 to send 3.12 USDC even with super-duper zk proof. I have made this transaction as for the test only.

The fee has been paid in zkUSDC.e(NEAR chain), it doesn’t require to have ETH for gas and approve anything by metamask at Ethereum site. The same as with Rainbow.

Also, I dislike that the ZK bridge’s fee is dynamically changing, very often and in very wide range. At the screenshot above you see ~$52, but during the test i have seen different values from $52 up to $85.

Here is one example:



It can even change while you swap USDC.e to zkUSDC at 1st step, so then you may face on that the amount of your just swapped zkUSDC is not enough to pay higher fee, or otherwise you have more of zkUSDC than need for the moment. This happened to me, but luckily the fee went lower.

The algorithm of those changes remains unknown, there is no exact formula like in Rainbow. So, the swap cost is much more unpredictable in comparison with Rainbow.

But obviously I like more how their calculation work. You don’t need to have any tokens in your wallet or exchange something at first. You just type wished values in the form and see estimated calculation (if don’t count the often changes of fee). So you can take a decision either to swap here or look for other exchange because of the high fee. That is how Rainbow should make their UI.

Also, I strongly suggest to check USDC.e /zkUSDC.e pool before to make any action

https://mainnet.electronlabs.org/liquidity-pool/usdc?pool-type=deposit

Currently the TVL is about $10k as total for both tokens. It’s not too much, any large swap may dry the liquidity and the next user will have a risk of not getting the necessary amount.

Seems like their pool is not protected against rebalancing: anyone can deposit or withdraw both tokens in any proportion, either 1:10 or 1:100, but the app always uses the swap rate 1:1. It’s unclear who and how takes care in case of negative rebalancing. So be careful, check TVL before.

So, I have tested Near to Ethereum transfers by 2 bridges, and as result Fast Rainbow is faster and much cheaper. Frankly, I do not operate with millions daily yet, it is not my league, so don’t see any need to pay much more for zk proof. Maybe I’ll change my opinion in future, but for now the cost is as the main factor.

Another important conclusion is that I got USDC erc20 tokens in Ethereum successfully, but those USDC are died there let’s say, useless, until I have no ETH for a gas. I can do nothing with these USDC without ETH, either move to exchange or to other address, etc.

The old regular Rainbow bridge supports the swap of ETH(NEAR token) to ETH (Ethereum), but this way requires to have some ETH at the destination address in order to finalize transaction. But what if I have not it yet? So it’s a dead end too.

Let’s say, both bridges don’t work for those who have enough of NEAR and NEAR tokens but have no ETH at all. And a good question appears: if I need first to go to CEX in any way, to exchange some of my NEAR coins to ETH for a gas, why should I return then back to the bridge in order to swap USDC or any other tokens? I can do this at the same CEX as well, it would be easier and most probably even cheaper (in compare to ZK bridge a CEX is cheaper for sure, Fast Rainbow -depends which CEX).

So, I would suggest to both bridges to add first the NEAR-to-ETH swap (or USDC.e to ETH, or any other, doesn’t matter), but take a fee only in currency which I exchange, without a need to have some coins for a gas at the destination address. That is exactly what CEXes do for us. Decentralized bridges should provide the same function to users if they really want to replace centralized exchanges in future. Otherwise, they have a risk of remaining just like a beautiful toy. Sorry if this doesn’t sound so happy optimistic, but this is just true.
Test #3. Swap NEAR(NEAR chain) to ETH(Ethereum) by Rainbow bridge.
USDC tokens, those i have transfered to Ethereum in previous tests, are useless without ETH because any action with ERC20 tokens requires gas in Ethereum chain.

So, let’s try to swap some NEAR to ETH using old(regular) Rainbow bridge. Unfortunately, the new Fast Rainbow doesn’t support this token yet.

First, we need to swap NEAR to a required amount of ETH token(NEAR chain), at Reffinance for instance. Then, we go to Rainbow, select the exchange direction, token ETH and type a wished amount. After that we can see an estimated time 4-8 hours and estimated cost $ 9.10 (it depends from the gas price in Ethereum network at the final stage of transfer)

After confimation by NEAR wallet (it costs < 0.001 NEAR) we can check the progress of a pending transfer. It displays hours remained to complete in real time:

For me it took about 7 hours until it completed and asks to finalize transfer:

I faced on a ‘surprise’ after hit ‘Finalize Transfer’. It requires to confirm a transaction in Ethereum network via Metamask , i.e. you must have some ETH at your Ethereum address in order to finalize bridge’s transaction. It means that as for ETH bridging you should pay the bridge’s fee in ETH cryptocurrency, not in NEAR. For this test it is about 0.006 ETH (or ~$11 for ETH price at transfer finalize time)

After confirmation in Metamask, 0.016 ETH came to my ethereum address in 20-30 seconds, i.e. as soon as the transaction has been confirmed in Ethereum network.

So, total time of bridging process was about 7+ hours. The total cost was ~0.006 ETH (or ~$11 at test’s time). It’s a bit higher than estimated $9.10 at the begining, but a such difference could happen due to a high volatility of Ethereum’s gas price & ETH price, it’s acceptable as a normal.

Conclusions:

* This way doesn’t work for those have not yet ETH at all or use a blank Ethereum address, because you must have some ETH at the destination address in order to pay bridge’s fee & finalize transfer.

Frankly, I don’t understand a logic of a such concept. Usually everywhere fees are extracting from the amount which you exchange, means in the same currency which you have on hand and want to exchange to other one. What is a sense to ask me to pay fee in the currency which i should get as a result of this exchange? And, on the other hand, if i would find another place where to exchange some of my NEAR to ETH in order to pay gas for finalization transfer, why couldn’t i exchange the rest of wished amount at that place too? Why should i go to Rainbow bridge instead of that?

* The processing time 7 hours is too long. It’s absolutely not acceptable as a solution of exchange, just because a high volatility of ETH as well as NEAR. The price of both may change too much within 7-8 hours, so the exchange, based on a calculation at a certain moment & some plans, may lose a sense after 7-8 hours. Moreover, there many CEXs around where NEAR-to-ETH exchange takes minutes, not hours, and withdrawal fees are comparable or lower. So, there is no sense to wait longer.

Only a zero fee could be as a reason to wait so long time, if Rainbow could offer this.

Or, they should add ETH token to Fast Rainbow asap.

* The bridge’s fee is too high as for small amounts. No sense to bridge 0.016 ETH ( ~$30) and pay 0.006 ETH(~$11) of fee. A such fee could be affordable for much larger amounts only.

And, there are many other services or CEXs(i.e. competitors) those offer much lower fee. For example, Huobi takes a withdrawal fee 0.0012 ETH for any amount starting from 0.01 ETH(minimum).

Or, another example, I have exchanged 12 NEAR to 0.0079 ETH for the finalization fee of this test by using ChangeNow service:

It took a few minutes only, costs ~$0.70 (fee included in NEAR/ETH rate, different from market avg) and of course doesn’t require to have ETH at the destination address!

This one could be as a good sample of exchange speed & fee & user-friendly UI where Rainbow bridge should go to.
Test #4. Transfer USDC from Ethereum to NEAR by Fast Rainbow.
Here we will try Fast Rainbow bridge to transfer USDC tokens(ERC20, Ethereum chain ) to NEAR chain. I already have USDC at my ethereum address, they have been transferred in test #1 above.

So I need just to select chains & wished token & type a wished amount in the form, and then approve transfer:

Approval means that i have to give an allowance to Rainbow’s smart contract to spend a certain amount of my USDC tokens. On click ‘Approve Transfer’ Metamask’s window appears, where i need to set the maximum of allowed to spend amount & send ethereum transaction.

It costs ~ 0.0012 ETH (~$2.43) at the time of test, but depends from current gas price in Ethereum network & current ETH price):

Normally Ethereum network confirms a such transaction within 15 -30 seconds if we leave gas price as Metamask offers by default. As soon as transaction confirmed, the next tab asks to confirm tokens transfer and also you can see estimate time until bridging completed (20 min for this test) :

Then i need to confirm this transaction via Metamask. It costs ~0.0011 ETH(~$2.02) at the moment of test :

Let’s say, these 2 steps above are a very similar to what we do when swap any tokens at any other Ethereum DEX, it’s clear & easy & nothing complicated.

As soon as the last transaction confirmed, i can see a bridging progress at the next tab. A timer displays the time remained to complete. The smart contract should send USDC.e automatically to my NEAR address when the timer ends:

It took ~20 minutes until i get tokens to my NEAR wallet, maybe even a bit less, i.e. almost as estimated.

I can say that a such processing time is not so fast, some other CEXs may process withdrawals faster.

Let’s say, this result takes a middle place among other, but it is fully acceptable for a work

I was really surprised by the total cost of this transfer. I paid about 0.0023 ETH(~$4.45) as fees. I fully satisfied by a such level of fee, it is more or less the same as other exchanges offer, not higher. And, this is much lower than i paid for the same tokens transfer from NEAR to Ethereum in test #1($20+). It would be nice if Rainbow will apply a such low fee to NEAR-Ethereum fast transfers too.

In UI i dislike only that i can’t see the estimation of the total cost before start a approval&confirmation steps, i.e. before i start to spend ETH . It would be nice if they add a such estimate calculation before the token approval step. All rest is clear & user friendly enough.
Test #5. Transfer USDC from Ethereum to NEAR by ElectronLabs ZK bridge.
In general the bridging procedure is the same as in the previous test #4 with Fast Rainbow.

I have to type data into the form, which instantly calculates estimated time & bridge fee:

Then, on subsequent tabs, I need to confirm 2 Ethereum transactions via Metamask: approve tokens spend by smart contract and initiate transfer.

In total i have paid ~0.0038 ETH(~ $7.09) . This is a bit higher than Rainbow takes for the same, but probably it is due to ETH price & gas price change. In any way this is not too high cost as for Ethereum transactions in avg. So, it’s acceptable.

Also they take a bridge fee in USDC , in addition to the cost of those Ethereum transactions. Probably it’s a specific of ZK proofs protocol, more actions requires. But it is just $0.11 for my amount or ~0.2%, not too many.

I can see a progress by stages after the transfer initiated. This is a very comfortable option

I started the transfer about ~35 hours ago. Unluckily, i see at this tab that my transfer is still pending till now, despite the estimated time was ~25 minutes. It went to the stage ‘Sending on NEAR’ and don’t move ahead :

So, I'm unable to determine the processing time as the transfer hasn’t been completed yet for the moment of writing this, i have not received yet these 5 USDC.e to my NEAR wallet.

Obviously, 35 hours of pending vs 25 minutes estimated means that something went wrong.
Conclusion
After a series of tests above, I can assume:

 	Both bridges support only a few of coins/tokens for the moment, and only 2 chains, Ethereum & NEAR, among a huge number of chains & coins those exist currently. So, a user is a very limited in choice what to swap, in comparison with centralized exchanges those offer much wider choice of tokens & chains.
 	The cost of the cross-chain bridging is high enough vs centralized exchange services, at least for a relatively small amounts. Fees are in the range from $4.5 up to $52(or could be even higher) for each single transfer, and mainly it depends from the direction of swap. Totally by these 5 tests above i have transferred between NEAR&Ethereum chains a pure amount ~$32.5, that is equal to ~36.2 NEAR( at test’s time) previously converted to USDC.e & ETH(NEAR chain), and in the same time i have spent about $93 for fees as the total, that is equal to ~79 NEAR( at test’s time), i.e. almost x3 more that pure amount transferred. Obviously, a bridge usage has no any sense in real life with a such ratio between amounts transferred and fees paid. Maybe this problem doesn’t exist for a large transfers( >1000 NEAR), but much smaller users can’t take it as comfortable service vs centralized exchanges with much lower fees.
 	A lion share of those high fees takes place because of a high cost of transactions in Ethereum chain, which is permanently high and moreover, it is a very unpredictable because of high volatility of gas price & ETH price. I would suggest bridge’s teams to pay more attention at L2 Ethereum chains, such as Arbitrum, Optimism, etc. They are gaining more popularity in the last time, a certain share of ETH users prefer them for a work  instead of Ethereum genuine chain because of much lower fees, approx x10 lower, so people migrate to L2 from the native ETH. Maybe it’s worth also to provide bridging to these chains, as people are interested in it. This would allow to reduce bridge’s fee too, that makes a bridge usage as much more attractive for wider range of users.
 	The bridging time also might be better. Currently both bridges provide a fully convenient processing time such as a few minutes only for a very limited number of tokens (ETH is not included)  and only for one swap direction ‘NEAR to Ethereum’. But transfers of the rest of tokens (including the most important ETH) and all transfers for the direction ‘Ethereum to NEAR’ may take from 25 minutes up to some hours.  We could take 25 minutes as not the best processing time, but more or less acceptable. But some hours of waiting is absolutely not acceptable, finally it makes a such bridge transfer absolutely useless when received, in almost cases when people need a such swap between chains, just because of a high price volatility of involved cryptocurrencies. And, a such long processing time can’t compete vs centralized exchanges those provide much shorter time of withdrawal to chain address (and with lower fee, btw). So, it’s a matter to improve asap.
 	I should mention that several issues&bugs may take place during bridging process, it could make the processing time much more longer, fully unpredictable and may require a help of support to complete the transfer, and no guarantee if they do successfully. I faced on a such problem with ZK Electron bridge, my transaction was pending about 3 days, until the support fixed the issue.
 	Let’s hope this took place because the bridge appeared very recently, even has not passed audit yet, so not all bugs has been fixed yet at the early beginning stage. So, let’s give them some time to improve before the final judge.

But we should always keep the mind a possibility of issues unknown before. So, use bridges at your own risk only.

### NameSky is looking for intern

NameSky intern
                            
                         
 
                        
            
            Name
                            
                            
                                                    
                                                    First
                                                
                            
                            
                                                    
                                                    Last
                                                
                            
                        Email(Required)
                            
                        Twitter profile(Required)
                    
                Tell us about your plans on how to grow NameSky

### How to stake NEAR tokens using different wallets

Why Stake NEAR?
Staking NEAR offers a straightforward and efficient way to increase both the security and efficiency of the network. What's more, this process doesn't call for any additional equipment or complex setups from token holders. It's a hassle-free method that allows users to earn rewards.

Staking NEAR tokens involves participating in the network as a delegator. As delegators, participants lend their support to validators, who are entrusted with the security of the network. In reciprocation for this support, they earn staking rewards. These rewards are distributed proportionally to each user's share of the total amount staked.

Validators are entities that run nodes, validate transactions, and produce new blocks in the NEAR Protocol. Validators are responsible for securing the NEAR Protocol, and your staking rewards depend on their performance. Consider their commission rates, uptime, and track record when choosing the validator. You can find a list of validators on the blockchain explorer NEAR Explorer.

By staking NEAR, users contribute to the network's overall security, helping to validate transactions and secure the blockchain against potential attacks. This active participation not only benefits the user but also strengthens the entire ecosystem.

Below you will find some of the widely used wallet options available for staking NEAR. You can select the wallet that best aligns with your requirements and preferences.
NEAR Wallet
The NEAR Wallet is a non-custodial, web-based wallet for the NEAR blockchain where users can send and receive NEAR or NEP-141 tokens. It is a simple and convenient wallet that allows users to manage, store, and stake NEAR assets.

First, you need to create a NEAR account. Go to the Near Wallet website and click Create Account. If you already have a wallet, click Import Existing Account.



There is an option to learn more about NEAR before creating your account.



You need to choose a method for restoring access to your wallet. NEAR Wallet supports two options:

 	Via a seed phrase (Secure Passphrase).
 	Via connecting Ledger hardware wallet.



Note: Near Wallet supports Ledger hardware wallet. You can log in to your wallet using it if you have such a device. Using a Ledger wallet is the safest way to stake your NEAR.

After you select the Security Method, click the button below to continue creating the wallet. We will show the process of using a recovery phrase.

A seed phrase consisting of 12 words will appear on the screen. The safest method to store the phrase is to write it down on paper and keep it in a safe place. Then click Continue.



Important: Do not take screenshots while saving the recovery phrase, and do not copy it to the clipboard. Saving your seed phrase as a screenshot or text on a phone or laptop puts it in danger of being stolen. Never share your recovery phrase with anyone.

Confirm the seed phrase. At the next step, you should enter the Verify Phrase.



After that, your wallet is ready for use.



On the NEAR Wallet home page, open the Staking tab.



First, if you have more than one account, you must select the one from which you will stake NEAR. Then you need to choose a validator to delegate tokens.



Click Stake My Tokens and select a validator. Always DYOR when choosing a validator. The wallet will show a validator's fee.

Note: Pay attention to the fact that Near uses non-standard addresses in the everstake.poolv1.near format instead of long hexadecimal words like Bitcoin and Ethereum addresses.



To continue the staking process, click Stake With Validator. Enter the number of NEAR tokens you want to delegate. Select the Use Max option to stake all available tokens in your wallet and click Submit stake.Remember to reserve a portion of tokens to pay a withdrawal fee.



Finally, click Confirm to make the transaction.



It takes some time to verify the transaction. It takes a few moments. When it's done, you will see the following message:



You can check your stake and rewards in the dashboard.



Note: Rewards are automatically reinvested, but you can withdraw and unstake as soon as the withdrawal button is available.

Tokens will be unstaked after four full epochs — approximately 52–65 hours.

If you need to unstake your tokens, choose "Unstake" at the staking section and select your validator.



Choose the number of tokens you want to unstake or click Use max. Then click the Unstake Token button.



To continue unstaking, confirm the transaction.



If you have done everything correctly, you will see the "Success!" inscription:






	

	
	
		
			
				Can you share your passphrase with your friends?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Mobile Wallet
NEAR Mobile is a convenient wallet developed by Peersyst. NEAR Mobile is a simple and secure wallet. NEAR Mobile allows you to manage and import multiple accounts on your phone to have control and flexibility over your assets all the time.

To start staking process, go to the official NEAR Mobile website to download the wallet. NEAR Mobile app is available in the App Store and Google Play.



Open the app on your device and click Create Account button to start the account creation. If you already have a wallet, click Import your NEAR Wallet.



Next, you will see essential information about the NEAR Wallet and the Mnemonic phrase. Having read it, click the Generate Mnemonic button.



Remember, the Mnemonic phrase is crucial for accessing and recovering your wallet. Thus, it is essential to store it securely. We recommend writing down your recovery phrase and keeping it accessible only to you. Another option is to use a specialized device that's intended for Mnemonic phrase storage.

Don’t take screenshots of the phrase, as this could expose it to unauthorized access. It's essential never to reveal your recovery phrase to anyone.

To proceed to the next step, select the words from your Mnemonic phrase in the correct order.



You must create a password to prevent unauthorized third parties from accessing your wallet and confirming transactions without your authorization. You can use biometric authentication to access the wallet.



NEAR blockchain was designed to be simple, with a flexible account model and human-readable accounts — any name a user wants instead of a string of letters and numbers. Swapping the colorful tab with account information, you will find the options to import one more account or create a custom one.

To fund your wallet, click Receive button, copy the wallet address, and send the NEAR tokens from the exchange or other account to your address.



Go to the Staking section. It will open a dashboard for your staked tokens, including the rewards and the staked amount.

Choose the Stake my tokens to start the staking process.



Enter the amount you want to delegate and click Next. Select a reliable validator from the list, or start typing its name in the search bar to find it faster.

Check the transaction details, and if everything is correct, click Next.



Having the completed transaction, click Continue, and you will get the notification about successfully staked tokens.



In the Stake section, you can manage your staked amount. You can unstake tokens by clicking the Unstake button and specifying how much you want to unstake.

Note: The unstaking period is approximately 52-65 hours (four epochs).






	

	
	
		
			
				What is an unstaking period?
			
		

		
					

		
			
			
			
			14 days
		
			
			24-36 hours
		
			
			Approximately 52-65 hours
		
			
			No unstaking period
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





4. Meteor Wallet
The Meteor Wallet was founded by an all-star team that has equally founded top-notch projects like Near Tinker Union and Enleap Near on NEAR Protocol.

Meteor is a simple and secure wallet: everything is encrypted, and nothing sensitive is logged. The wallet allows users to collect NFTs, access DeFi, and explore everything Web3.

Before staking NEAR, you must create and top up a cryptocurrency wallet.

Please go to the Meteor Wallet website and choose between the web and extension versions. In this tutorial, we will stake NEAR tokens via the web version.



Proceed to the next step by clicking the Get Started button.



On the main screen of the Meteor Wallet, two options are available:

 	Create a new wallet;
 	Import an existing wallet.

We will create a new one to show the whole process from scratch. First, click Create a new Meteor Wallet. 

A password is required to prevent unauthorized third parties from logging into the wallet and confirming transactions without your consent. Create a complex password and click Continue.



Every NEAR account is identified by a specific address. Based on their name, there are two types of accounts:

 	Named accounts with human-readable names, such as alice.near;
 	Implicit accounts designated by a string of 64 characters.

Select the option that you prefer.



Backing up your wallet is the most important step. You can restore access to funds on another device using a secret recovery phrase.Never share your passphrase with anyone.



Select the first and last words from your secret recovery phrase to confirm that you have saved the entire phrase.



Before proceeding to the staking, you need to top up your account. Copy your wallet address by clicking on Account. Use it to send tokens to your wallet. As soon as you top up your wallet, you can proceed to staking.



Go to the staking section by clicking the Stake button, as shown below.



Select the Standard Staking section.



Click the Create New Staking button to proceed.



Enter the amount you want to delegate and choose a reliable validator by clicking the Select Your Validator button.



A list of available validators will appear on the screen. Find the validator to whom you want to delegate NEAR tokens.You can stake with several validators. For a quick search, start typing the validator's name in the field, and then click on it.



Meteor Wallet shows the estimated earnings for several periods so you can find out how many rewards you will get.



Having selected a validator and the amount of tokens, click Stake.



Finally, check the transaction details and click Confirm to stake NEAR.



We have successfully staked NEAR tokens.

You can also unstake them by clicking the Unstake button and specifying how much you want to unstake.

Note: The unstaking period is approximately 52-65 hours (four epochs).






	

	
	
		
			
				Is it possible to stake your tokens with different validators?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





5. Nightly Wallet
Nightly Wallet is a multi-chain wallet currently working on NEAR, Solana, and Aptos and available as a Chrome and Firefox extension on your mobile phone. Nightly Wallet is the key to the Metaverse by providing functions such as token swipe, staking, liquid staking, and NFT display on each chain. Nightly has already been integrated into the NEAR Wallet Selector.

Go to the Nightly Wallet and choose your preferred browser (Firefox and Chrome) to stake you NEAR.



In this guide, we use the Chrome browser. Install the extension by clicking the Add to Chrome button.



On the extension page, click the Add extension button to approve the installation of the plugin.



Open the Nightly Wallet extension in your browser.



In this window, you can either restore your existing wallet or create a new one. If you already have a Nightly Wallet, you can restore it and proceed to the next step. To create a new one, tap Create new wallet.



Choose a password for your wallet. Heed the security recommendations and choose a strong password. Confirm your password and tap Create a wallet.



Next, you’ll see your Secret Phrase. Do not share your phrase with anyone. These randomly generated words are the keys to your wallet. If you forget them, you will lose access to your funds. Write your Secret Phrase down on paper and click Next.



Enter your Secret Phrase to verify your wallet.



Next, choose the NEAR network.



You can now deposit, send, swap, and stake NEAR. Check the wallet dashboard for the main functions.



Now your Nightly Wallet is ready for the next step: Staking. Open your wallet, tap the NEAR icon and click Start Earning.



Nightly provides 2 staking options: liquid staking and regular. During the Regular staking, you will receive NEAR tokens as rewards. Liquid staking offers other conditions: users can deposit tokens but they will receive liquid tokens in return. The main difference between liquid staking and traditional staking is that you don’t have to freeze your assets. However in fact you have to lock your token, but then you will receive a new one - stNEAR or NEARx.

To get NEAR tokens as rewards choose Regular Staking.



To delegate your NEAR, tap on the Plus icon.



This screen displays a list of all validators. Choose a reliable validator. 

Enter a staking amount within your wallet limit and click the Next button.



Your delegation is now active, and soon you will start receiving rewards.



You can always check your staking info by clicking on the Start Earning and Regular Staking buttons.



If you want to unstake your tokens, you need to click the Unstake button. Please note the unstaking period is approximately 52-65 hours (four epochs).






	

	
	
		
			
				Which tokens will you get as rewards if you choose regular staking?
			
		

		
					

		
			
			
			
			NEARx
		
			
			stNEAR
		
			
			NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





6. Ledger Live
Ledger Live is a platform to buy crypto, stake your assets, and manage NFTs. It functions as a secure gateway to the crypto ecosystem. The Ledger Live app allows you to manage and transact different tokens. In addition, you can grow your crypto using the staking and lending process available at the Ledger Live app.

Go to the official Ledger website and click the Download button. Currently, users can download the Ledger Live for Windows, macOS, and Linux. The Mobile version is available for Android and iOS users.



Choose your operating system, install the app on your computer, and open it. Then click on to Get started button. You can access its full functionality if you have a Ledger device.



Turn on your Ledger device and enter the code.



Approve the entry into the application by pressing two buttons. Now, you can use the application.



So, here is the main menu of Ledger Live. Install the latest version of the NEAR app on your Ledger device to start the staking process. Go to the App Catalog and write NEAR in the search bar. After that, click install.



After installing the NEAR app, add your NEAR accounts by clicking add account button. 

You can add several accounts.



Once your account is added successfully, click the Done button.



Before staking, you must send NEAR tokens to your wallet. Skip this step if you already have them and move directly to staking.

Find the Account section to add funds to your Ledger Live. Choose a NEAR account. Then, click the receive button.



The Receive page will open. Click Continue.



Verify that the shared address exactly matches the one on your device. Select Approve on the device and press two buttons on your Ledger.



If everything is ok, copy your address. Finish this process by clicking Done.



Next, you can buy NEAR tokens from any cryptocurrency exchange. Send them to your wallet address. After the transaction is done, come back to your Ledger Live.

Open the Accounts tab and click the Stake button to start the staking process.



Next, you will see information about NEAR staking features. Having read it, click Continue.



Then, you need to choose Staking Provider you want to delegate. Click Show all to see the complete list of validators.



In the new window, enter “Everstake” in the search field and select it from the list. Click Continue.



Then enter the amount you want to stake. You can also select the Use Max button to stake all your balance (minus the transaction fee). Network fees amount will be shown in the staking tab.



You need to confirm the transaction on your Ledger Device. Press the buttons on your device, as shown in the picture below.



Now you have successfully delegated your tokens. Click View details to see the transaction details.



You can review your status and the transaction by checking its hash in the explorer. 

You can track your staking position by clicking the Accounts tab.






	

	
	
		
			
				Can you get full functionality of Ledger Live app without the Ledger device?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





7. Omni Wallet
Omni is a next-generation Web3 wallet app. It is the rebranded SteakWallet. Omni is a full-service, self-custody cryptocurrency wallet, which makes it seamless to stake various tokens, manage assets cross-chain, and collect and display NFTs.

You will need to download the app and create an Omni wallet to start the staking process.

Please go to the Omni Wallet, choose your preferred operating system (iOS or Android), and install the app on your mobile phone.





Once installed, go to the OMNI Wallet app and click the Let’s go button. To continue using the wallet, you also need to choose Set up a Passcode or Use Face ID to secure your wallet. If you have an OMNI account, you can import it or create a new one. To import your existing wallet, click the Import an existing wallet button. Your Ledger can be connected to OMNI, too.



The next step is your secret phrase. The wallet will generate a random secret phrase you must save and remember it. To finish the wallet set-up, you should enter your 12-word phrase in the correct order and click Next.

Note: Protect your secret phrase. Anyone with this phrase will have control of your funds. If you lose it, you will lose access to your wallet.



The self-custodial Omni wallet makes multi-chain staking easy and fast. The staking complexity is abstracted and translated into three simple taps on your mobile device.

On the home screen, click the Earn button. Scroll down in the Staking menu and choose NEAR. The NEAR staking screen will appear on the device. To continue the staking process, press the Stake NEAR button.

Note: You need at least 0.05 NEAR to successfully stake and cover gas fees.



This will open the Staking Info Screen. Tap Let’s go! Input the amount of NEAR you want to stake and press Next.



Check the network fee and open the list of validators by clicking the Staked with tab. Choosing a responsible validator is the key to the safety of your funds and income.

After choosing a validator, tap the Confirm Stake button.

Note: You can tap the drop arrow next to Average to select your network fee amount. Stick to Omni’s recommended network fee to ensure your transaction is processed appropriately.



After your confirmation, you will get information about your successfully staked NEAR.



To view your active stake, go to the main page. There you can also unstake, stake to multiple validators. The unstaking period is approximately two days.
8. Opto Wallet
The Opto Wallet is a mobile wallet for the NEAR Protocol and the Octopus Network. It is a secure, open-source, and non-custodial wallet that allows users to transfer and stake their NEAR tokens.

The Opto Wallet is an open-source wallet with Bio Auth. It offers to explore a built-in dApp browser where users can easily find awesome NEAR dApps, manage their favourite ones, and interact with them. The Opto Wallet is available for iOS and Android software and supports Ledger.

Follow the next steps to stake your NEAR assets. You need to install the Opto Wallet on your device. To do this, go to the official Opto Wallet website, choose your preferred operating system (iOS or Android), and download the app.

Open the Opto Mobile Wallet app. You are on the Opto Wallet start screen. In this window, you can either restore your existing wallet or create a new one. To create a new one, tap Create.

During the next step, you will get your mnemonic phrase. No one has access to this phrase. If you forget it, you will lose access to your funds. Please store the secret phrase in a safe place.

Note: It is essential not to take screenshots or copy the phrase to the clipboard. The best way is to write it down so nobody else can reach the keywords.

Now choose a PIN Code to protect your wallet. You’ll use this Code to sign in to your Opto account. Memorize or keep it in a secure place. Confirm your PIN Code to complete creating your wallet.



Open the Finance tab as shown on the screen. There is the NEAR Staking section; you should continue the staking process.



The Opto Wallet offers to connect a NEAR Wallet or MyNearWallet account.We will stake the NEAR tokens via the newly created Opto account. Log in to your new Opto account by confirming your address.



Tap the Validators tab to choose a reliable validator. The list shows each validator’s fee, the number of stakers, and the amount of total staked NEAR tokens. Then enter the number of NEAR you would like to stake and tap Deposit.



To finish the staking process, check all details and confirm your intention.

If everything was done correctly, congratulations! Now your delegation is active, and you will start receiving rewards.


9. Sender Mobile Wallet
Sender is a non-custodial wallet tailored for NEAR. It provides a one-stop wallet solution for users to send, receive, store and stake NEAR-based assets easily and securely.

The company's platform offered a non-custodial browser extension wallet first, and now users can use a mobile version as well.

Sender is engaging for users because the wallet grants them complete control of their private keys and offers various built-in features, such as sending and receiving digital assets, instant swap, an NFT gallery, and staking.

Please go to the Sender Wallet, choose your preferred operating system (iOS or Android), and install the app on your mobile phone.



After downloading the wallet, you can create a new account or use your existing account if you have one.

In this guide, we will choose the first option and create a new account.

The app will ask you to create and confirm a new password, as shown in the picture below. Please create a reliable and strong password. Don’t share any of your passwords with others, and store them in a safe place.



To continue using the wallet, you also need to choose to set up a Passcode or use Face ID to secure your wallet.

To reserve your Account ID, you can choose either a human-readable account name ending with “.near” or an implicit account that is a string of characters.

You should remember that it is appropriate to save all crypto wallet-related information offline. Sender will send a notice to remind you that you should save your private crypto information responsibly.



The wallet will generate a random, secret 12-word phrase you must save and remember. The wallet will prompt you for a random word from your passphrase to make sure you’ve saved it. To finish the wallet set-up, enter the word and click Create Account to complete the process.

Note: Never disclose your recovery phrase in order not to be scammed.



After that, you will need to initialize your account to continue. You have to deposit 0.1 NEAR to finish creating your account.

Send enough NEAR to initialize your account and be able to stake with validators.



Go to the staking section by clicking the central button as shown below. Here you need to choose the validator you would like to stake with from the list and fill in the amount of NEAR tokens you want to stake.

Note: You can select any validator, but we recommend choosing reliable validators that are trusted by the community.

To complete staking, you will need to click the Stake button.



Then click the Confirm button to confirm your staking choices.

You have successfully staked your NEAR tokens, and now you will be receiving your staking rewards.



To view your active stake, go to the main page. There you can also unstake your tokens by clicking the Unstake button and inserting the amount of NEAR you want to unstake.

Note: The unstaking period is approximately 52-65 hours (four epochs).






	

	
	
		
			
				Do you need to pass a verification to get a human-readable account name?
			
		

		
					

		
			
			
			
			Yes
		
			
			No, you can create it without verifying your personality
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Closing Thoughts
The NEAR ecosystem presents a wide array of wallet choices, enabling users to effortlessly create and manage NEAR accounts. It serves as a secure storage for NEAR tokens and allows staking for earning rewards.

Staking NEAR offers an effective method to generate yield from your tokens on a blockchain. In addition, it plays a vital role in supporting the operation of Proof-of-Stake (PoS) networks.

The NEAR ecosystem empowers communities by facilitating staking opportunities. By providing seamless interaction with the NEAR blockchain through diverse wallets, it offers an accessible pathway for community engagement.

### Staking avec Meta Pool

Meta Pool, Module 1 – Premiers pas Sur Le Staking Liquide
Staking et Protocole de Consensus sur le Protocole NEAR
Avant de commencer, il est recommandé de suivre le cours NEAR Power User du Learn NEAR Club (LNC) pour avoir des connaissances de base sur le protocole NEAR.

Chaque réseau blockchain nécessite une méthode pour confirmer les nouveaux blocs en cours de production.

Sur le réseau Proof-Of-Stake, ce processus est effectué par les nœuds validateurs. Pour sélectionner ces nœuds de validateur, il est nécessaire de verrouiller les jetons en les attribuant à un validateur, c'est ce qu'on appelle le jalonnement ou staking en anglais. Sur la base du nombre de jetons NEAR jalonnés ou staked, l'ensemble des validateurs qui participeraient à la création de blocs est constitué.

Afin d'inciter les délégants et les validateurs de jetons, cela reçoit des récompenses des frais couverts par le protocole. De cette façon, le staking est un moyen de gagner plus de jetons et d'aider à sécuriser le réseau.

Certains des inconvénients de ce staking standard sont que vos jetons sont verrouillés et que vous ne pouvez pas les retirer avant la fin de la période de non-participation ou unstake. De plus, vous ne pouvez en aucun cas utiliser vos jetons, car ils sont délégués à un nœud de validation. Ces deux limitants sont résolus lorsque vous faites du stake liquide.
Proof of Stake
Investopedia.com définit la Preuve de Stake (PoS) comme :

La preuve de stake est un mécanisme de consensus de crypto-monnaie pour le traitement des transactions et la création de nouveaux blocs dans une blockchain.

Un mécanisme de consensus est une méthode de validation des entrées dans une base de données distribuée et de sécurisation de la base de données. Dans le cas de la crypto-monnaie, la base de données s'appelle une blockchain, de sorte que le mécanisme de consensus sécurise la blockchain.

Dans cet esprit, NEAR Protocol utilise PoS comme système pour traiter toutes les transactions en cours d'exécution sur le réseau en implantant des jetons NEAR, le jeton natif de cette blockchain. Sur le staking standard, vous pouvez choisir 1 seul nœud de validation et lui déléguer (verrouiller) vos jetons. Cela aidera le validateur à traiter des blocs ou des morceaux et à produire des récompenses s'il est supérieur au coefficient nakamoto.

Cependant, la délégation dans le staking standard des systèmes PoS a un mécanisme retardé, par ex. NEAR Protocol, ou même l'impossibilité de retirer ou unstake vos jetons, comme sur Ethereum. Dans ce cas, une solution de staking liquide pourrait prendre en charge à la fois : la sécurité du réseau dans les points de vente et la possibilité d'utiliser vos jetons.

 	Nœuds validateurs

Les validateurs sont des ordinateurs qui ont reçu suffisamment de jetons (stake) pour commencer à confirmer les transactions sur le réseau NEAR.

Dans le réseau NEAR Proof-of-Stake, un pool décentralisé de validateurs traite les transactions pour assurer la sécurité du réseau. En retour, ces validateurs reçoivent une récompense pour cela. Ce système permet également aux délégants - des entités qui souhaitent assurer la sécurité, mais qui n'ont peut-être pas le hardware pour le faire - de déléguer leurs jetons à des validateurs

Ces validateurs fournissent une puissance de calcul au réseau afin de calculer de nouveaux blocs et en échange, ils reçoivent des récompenses basées sur la quantité de blocs ou de morceaux produits.

En savoir plus sur les validateurs de protocole NEAR ici :

https://near.org/about/network/validators/




	

	
	
		
			
				La preuve de Stake (PoS) fonctionne de la même manière que la preuve de travail PoW
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Récompenses et NEAR Tokenomics

NEAR est le jeton utilisé pour couvrir tous les frais du protocole NEAR.

Sur sa tokenomics est indiquée une libération progressive et longue de 5 ans de jetons.

Comme mentionné dans le document, 5 % de l'offre supplémentaire est émise chaque année pour soutenir le réseau en tant que récompenses d'epoch, dont 90 % vont aux validateurs (4,5 % au total) et 10 % à la trésorerie du protocole (0,5 % au total).

Ressources supplémentaires

 	Message officiel de la Fondation NEAR : https://near.org/blog/near-token-supply-and-distribution/
 	Discussion faite par NEARWEEK sur le staking liquide : https://twitter.com/NEARWEEK/status/1618257119958175747




	

	
	
		
			
				Quantité de jetons $NEAR qui sont distribués par an aux validateurs et aux délégants.
			
		

		
					

		
			
			
			
			45 millions de jetons $NEAR
		
			
			12,5 millions de jetons $NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Qu'est-ce que le staking liquide ? Comprendre le Meta Pool et l'actif stNEAR
Les protocoles de staking liquide sont à la pointe de l'économie de staking de crypto-monnaie, révolutionnant l'accès aux liquidités dans l'industrie de la finance décentralisée (DeFi).

Le staking liquide est une alternative au staking traditionnel : il permet aux utilisateurs de miser n'importe quel montant de NEAR et de retirer efficacement leur $NEAR sans avoir à attendre environ 48 à 72 heures (4 à 6 epochs) avant que les détenteurs de jetons NEAR obtiennent leurs récompenses composées.

L'un des avantages du staking liquide est la possibilité d'interagir et d'utiliser des fonds tout en gagnant simultanément des récompenses. En conséquence, les protocoles de staking liquide fournissent les bases d'activités telles que les protocoles de prêt et les activités d'agriculture de rendement (yield farming).

Par conséquent, les utilisateurs peuvent interagir avec de nombreuses plates-formes DeFi en gagnant plusieurs récompenses à partir d'un pool de fonds.

 	Critères de sélection des validateurs

Meta Pool suit la stratégie de la Fondation NEAR pour répartir la participation parmi la longue traîne des validateurs non concentrés à haute performance, à faible commission, afin d'augmenter la décentralisation et la résistance à la censure pour NEAR.

Nous évaluons tous les validateurs, dans notre produit principal, nous n'avons pas de listes blanches ou whitelists, et nous publions la formule, le code que nous utilisons pour calculer la formule ainsi que les résultats qui seront en chaîne. La philosophie est d'être totalement transparente et ouverte à tous les validateurs.

Nous avons 5 critères de sélection des validateurs sur le réseau NEAR, qui s'inscrivent dans notre philosophie de transparence et d'équité :

 	Disponibilité > 95%
 	Frais < 10%
 	S'assurer que le validateur ne réduit pas le coefficient de Nakamoto
 	Avoir suffisamment de jetons pour atteindre le prix du siège du protocole NEAR
 	Production de récompenses pendant au moins 4 epochs consécutives

Vous pouvez consulter la liste des validateurs Meta Pool ici, il vous suffit de saisir meta-pool.near dans le filtre de compte.




	

	
	
		
			
				Le staking liquide sur Meta Pool prend-il en charge la décentralisation du réseau ?
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Étape par étape : Faire ma première mise liquide sur Meta Pool

Meta Pool permet aux détenteurs de jetons NEAR de miser et de gagner des récompenses, offrant un moyen facile de se retirer ou unstake sans période de blocage.

Il ne place pas tout votre NEAR staked dans un seul validateur, mais Meta Pool le répartit entre de nombreux validateurs performants et à faible coût afin que vous obteniez les meilleures récompenses tout en garantissant que le réseau est décentralisé et résistant à la censure.

 	Connectez-vous à Meta Pool, en cliquant sur « Start staking »

2. Cliquez sur "Stake Now" dans la case Stake NEAR

3. Choisissez votre portefeuille préféré, pour cet exemple, nous utiliserons le portefeuille natif NEAR.

4. Sélectionnez le portefeuille NEAR que vous souhaitez utiliser dans le menu déroulant et autorisez l'application à accéder à votre portefeuille NEAR : cliquez sur "Authorizing".

5. Après, vous êtes connecté, allez sur la page d'accueil et entrez le montant que vous souhaitez staker, puis cliquez sur "Stake".

Remarque : vous voulez toujours laisser un peu de NEAR sur votre portefeuille pour couvrir les frais de transaction.

5. Notez que le minimum que vous êtes autorisé à staker est de 1 $ NEAR

5. Vous recevrez une confirmation une fois que la transaction aura été traitée par la blockchain et que votre dépôt de stake aura réussi. Cela ne prend généralement que quelques secondes.

6. Vous pouvez maintenant trouver les avoirs de vos comptes sur les pages Accueil et Harvest.

Remarque : Ce panneau n'affiche que vos actifs ($NEAR et stNEAR) de votre portefeuille, si vous transférez ou vendez vos jetons stNEAR, ils ne seront plus affichés dans ce panneau.

Sur le panneau, vous pouvez voir les statistiques actuelles du Meta Pool :

5. Étape par étape : Faire unstake pour retirer vos jetons NEAR.

Il y a 2 options pour unstake de Meta Pool : vous pouvez faire Liquid Unstake (se retirer immédiatement) ou faire un Unstake traditionnel (retardé de 48 à 72 heures).
Liquide Unstake
Vous pouvez unstake votre jeton stNEAR immédiatement en payant une somme modique et en utilisant la fonction Liquid Unstake. En faisant cela, vous échangez en fait votre jeton stNEAR contre NEAR. Ceci est rendu possible grâce au pool de liquidité Meta Pool.

Pour Liquid Unstake simplement:

 	Accédez à l'onglet Unstake dans le menu de navigation
 	Passez en revue les frais de désengagement liquide actuels et décidez si vous souhaitez continuer.
 	Entrez le montant de stNEAR que vous souhaitez unstaker.
 	Cliquez sur "Liquid Unstake" et approuvez la transaction.
 	Après quelques secondes, après que votre transaction a été confirmée par la blockchain, vous aurez votre NEAR unstaked disponible sur votre portefeuille NEAR.

Remarque : les frais de liquidité du Meta Pool sont compris entre 0,3 % et 3 %. Il varie linéairement en fonction de la quantité de liquidité disponible dans le Meta Pool Liquidity Pool.




	

	
	
		
			
				Le prix de stNEAR est-il lié à 1: 1 avec le jeton NEAR.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Unstake traditionnel (retardé)

Unstake traditionnel est la forme par défaut de unstaking de tout validateur sur le protocole NEAR : en raison de la conception du réseau, les validateurs attendent 4 à 6 epochs (48-72 heures) avant de restituer les fonds staked à l'utilisateur. Le retrait différé est gratuit pour tous les utilisateurs.

Pour unstake vos fonds du Meta Pool en utilisant le Delayed Unstake :

 	Accédez à l'onglet "Delayed-Unstake" dans le menu de navigation en haut
 	Entrez le montant de NEAR que vous souhaitez retirer et cliquez sur le bouton "Start delayed unstake".

3. Vous verrez un avis vous informant du temps approximatif d'attente. Révisez et confirmez.

4. Vous serez invité à autoriser la transaction sur le portefeuille NEAR. Cliquez sur “Authorize”.

5. Après la période de retrait différé, les fonds seront disponibles pour retrait, cliquez sur "withdraw" et confirmez votre transaction, votre NEAR non jalonné apparaîtra dans votre portefeuille NEAR.”




	

	
	
		
			
				Le delayed unstake ou retardée affecte les performances du réseau en raison des heures supplémentaires nécessaire pour supprimer les jetons $NEAR délégués
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Étape par étape : être fournisseur de liquidités

Le Liquid Unstaking n'est possible que grâce aux Fournisseurs de Liquidité (LP) qui fournissent au protocole le NEAR nécessaire aux swaps instantanés (retraits) avec stNEAR. Les fournisseurs de liquidité perçoivent des frais de unstaking de liquide.

Pour ajouter ou retirer $NEAR en tant que fournisseur de liquidité :

 	Accédez à l'onglet Liquidité sur la page Meta Pool
 	Sélectionnez si vous souhaitez "ajouter" ou "supprimer" (add ou remove) des liquidités
 	Entrez le montant $NEAR à ajouter ou à supprimer

Remarque : le minimum requis pour fournir des liquidités est de 2 $ NEAR

4. Confirmez et signez la transaction

Désormais, chaque fois que quelqu'un effectue un unstake de liquidités, vous recevrez une fraction des frais en fonction de votre capital sur le pool de liquidités.




	

	
	
		
			
				~10,8 % APY est la norme à tout moment en tant que fournisseur de liquidités
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Meta Pool, Module 2 – Financement participatif sur Meta Pool

Meta Yield - Financement participatif sans perte
Meta Yield est une plate-forme de financement participatif basée sur des récompenses de jalonnement sans perte pour les projets NEAR à la recherche d'un soutien financier et d'une exposition à la communauté NEAR.

L'objectif de Meta Yield est de fournir une exposition et un accès à différents projets, permettant à la communauté de soutenir financièrement des projets Web 3.0 basés sur le protocole NEAR.

Meta Yield Launchpad est une plate-forme de financement participatif sans perte pour les projets sur NEAR qui souhaitent être financés par leur communauté. Il tire parti du jalonnement en offrant aux bailleurs de fonds la possibilité de financer leurs récompenses, et non leurs principaux actifs.



Le mécanisme de collecte de fonds unique intégré à Meta Yield tire parti du jalonnement liquide : les bailleurs de fonds frappent les jetons du projet avec leurs récompenses de jalonnement, et non leurs actifs cryptographiques.

Meta Yield fonctionne en 4 étapes simples :

 	Les bailleurs de fonds s'engagent et verrouillent des stNEAR pour prendre en charge les projets basés sur la cryptographie (si vous n'avez pas stNEAR, accédez à Meta Pool et misez $ NEAR)
 	Les projets ne gagnent que des récompenses de jalonnement (~ 10%) de ce que les bailleurs de fonds s'engagent, pas les actifs cryptographiques sous-jacents
 	Les bailleurs de fonds gagnent des jetons à partir de nouveaux projets lancés sur NEAR ou reçoivent et déposent des  NFT (à venir bientôt)
 	Les backers récupèrent leurs crypto assets : à la fin de la période de verrouillage, vous récupérez 100% de votre NEAR

En termes simples, vous pouvez soutenir des projets de cryptographie, être récompensé par le jeton natif du projet et contribuer à la croissance de l'écosystème NEAR sans perdre vos jetons jalonnés.

Vous ne donnez que leurs futures récompenses NEAR pour les jetons du projet et vous conservez leur NEAR, réduisant ainsi les risques de l'ensemble du processus d'investissement.

Commencez à soutenir les projets NEAR maintenant ! Visitez https://metayield.app






	

	
	
		
			
				Il existe une limite préétablie au nombre de jetons stNEAR que vous pouvez déposer dans une campagne Meta Yield.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment un projet peut-il être listé sur Meta Yield ?
Tout d'abord, Meta Yield Launchpad fournit la plate-forme de financement participatif et le mécanisme basé sur les récompenses. En plus de cela, chaque projet qui fait l'objet d'une campagne de collecte de fonds reçoit une impulsion marketing gratuite de Meta Yield Launchpad :

 	Campagne de pré-lancement : 1 ou 2 semaines de buzz sur le projet, y compris d'éventuelles AMA, des infographies et des publications sur les réseaux sociaux.
 	Promotion de lancement
 	Promotion hebdomadaire en cours pendant la période de collecte de fonds.

De plus, nous travaillons avec différentes entités de l'écosystème NEAR qui sont intéressées par l'opportunité de soutenir financièrement ces nouveaux projets sur NEAR.
Comment sélectionnons-nous les projets ?
Nous voulons donner à chacun la possibilité de lever des fonds pour ses projets, mais nous voulons aussi offrir aux utilisateurs et investisseurs potentiels des projets de qualité en option. Pour cette raison, chaque projet qui souhaite être considéré comme candidat pour être sur Meta Yield Launchpad doit remplir les conditions suivantes :

 	Une équipe solide qui construit le projet

Le projet doit s'appuyer sur une équipe solide et motivée, capable de faire passer le projet à l'étape suivante une fois financé.

L'expérience de chaque membre doit être liée au type de projet proposé. En d'autres termes, s'il s'agit d'un projet de jeu, les membres doivent présenter la preuve qu'au moins certains de leurs membres ont travaillé dans des domaines connexes.

Les équipes multidisciplinaires sont également un bon signe, avoir des développeurs est important, mais pour vraiment faire passer votre projet au niveau supérieur, vous avez également besoin de marketing, d'opérations, de conception et peut-être d'autres domaines.

 	Communauté forte

Nous voulons que ces projets aient un fort soutien de leur communauté, nous vérifions généralement leur niveau d'activité et d'engagement sur les réseaux sociaux tels que Telegram, Discord, Twitter, YouTube, Instagram, TikTok, et tous les autres projets mentionnés dans leur application.

Cet aspect est d'une importance vitale pour 2 raisons principales : nous avons parfois une phase de vote pour sélectionner les projets et les communautés sont généralement celles qui poussent ces votes, et aussi un bon pourcentage du montant collecté viendra de la communauté, il est donc essentiel d'en avoir un prêt à récupérer votre dos.

 	Un Token et ses Tokenomics

Il est indispensable que les projets sélectionnés aient un jeton car ils l'utiliseront pour récompenser ceux qui soutiennent leur campagne. Pour être plus précis, la personne qui soutient le projet donnera au projet ses récompenses de jalonnement et recevra des jetons du projet en échange en guise de récompense.

Et, puisque vos investisseurs recevront votre jeton en récompense, il est important de leur dire comment ils peuvent l'utiliser (par exemple : jouer, acheter, échanger ou comme jeton de gouvernance) et vos plans pour augmenter sa valeur.

 	Un plan de financement

Gardez à l'esprit qu'avoir une campagne sur Meta Yield Launchpad revient à essayer de lever des fonds auprès d'investisseurs : ils veulent savoir si vous êtes capable de construire le projet et comment allez-vous en tirer de l'argent.

Alors, préparez-vous avec une explication de base sur la façon dont vous allez utiliser les fonds collectés : marketing, amélioration du produit/service, élargissement des fonctionnalités, changement/innovation de la marque, amélioration des fonctionnalités de la plateforme, etc.

 	Connectez-vous à l'écosystème NEAR

Étant donné que nous travaillons avec des projets NEAR et la communauté et que la communication est très importante dans ce protocole, nous vous encourageons à établir une relation étroite avec l'écosystème du protocole NEAR.

L'équipe du projet doit avoir la preuve qu'elle a collaboré et sait travailler avec les acteurs impliqués dans NEAR : l'obtention de subventions, la participation à des programmes d'incubation ou l'appartenance à des guildes comptent pour cette exigence.

Cela garantit que l'écosystème « reconnaît déjà l'équipe/le projet » et que lorsque le projet passera sur le réseau principal, l'écosystème le soutiendra.




	

	
	
		
			
				La vision multi chaine sur un projet est un must dans un projet qui sera lancé sur Meta Yield.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Où puis-je trouver plus d'informations sur Meta Yield ?
Vous pouvez trouver plus d'informations sur le site et le blog de Meta Yield.
Meta Bond Market – Vendez vos actifs verrouillés sur Meta Yield
L'objectif de Meta Bond Market est de fournir un outil pour acquérir et offrir différents types d'obligations qui sont actuellement générées en soutenant des projets dans Meta Yield.

Meta Bond Market est accessible directement depuis son lien metabondmarket.app.
Connectez votre portefeuille sur Meta Bond Market
Sur le site Meta Bond Market : metabondmarket.app, liez le portefeuille NEAR pour avoir un accès complet aux crypto-actifs. Cliquez sur le bouton Connecter le portefeuille, choisissez le portefeuille et connectez-vous.


Comment fonctionne le Meta Bond Market :
4 étapes faciles pour comprendre le mécanisme Meta Bond :

 	Soutenir les projets dans Meta Yield.
 	Obtenez des obligations en fonction de l'investissement dans Meta Yield et des récompenses associées.
 	Proposez les obligations sur la plateforme.
 	Et/ou acheter des obligations auprès d'autres vendeurs.

Les utilisateurs investissent dans Meta Yield pour des projets en phase de démarrage. Si ces projets parviennent à atteindre au moins le premier objectif d'investissement, les supporters obtiennent des récompenses en jetons de projet, en libération progressive en échange de leur investissement verrouillé.

Une fois la période du fonds terminée, Meta Bond Market génère deux obligations pour le supporter :

 	Première caution : dans les jetons NEAR. Ce montant correspond à la valorisation en NEAR du stNEAR bloqué à la fin de la période du Fonds.
 	Deuxième caution : Pour le montant de Tokens du projet soutenu à recevoir en libération progressive.

Le supporter peut choisir à tout moment pendant la période de verrouillage s'il souhaite mettre en vente l'une ou les deux obligations.

Si les obligations ne sont pas mises en vente, les obligations continuent leur cours, et à la fin de la période de blocage, l'investissement est restitué au détenteur de l'obligation, et les récompenses du projet soutenu sont déléguées en libération progressive selon la proposition.

Pour chaque lien vous pouvez choisir/réaliser les actions suivantes :

 	Divisez les obligations en obligations plus petites.
 	Proposez-les en vente directe.
 	Offrez-les aux enchères.

Définissez l'heure à laquelle les obligations seront proposées à la vente.

Si l'obligation est vendue, le vendeur reçoit le montant en jetons selon la vente directe ou la meilleure offre d'enchères.

Si l'obligation n'est pas vendue, elle redevient disponible à la vente et reste en la possession du vendeur qui peut la remettre en vente s'il le souhaite.






	

	
	
		
			
				Meta Bond vous permet de vendre les jetons verrouillés de votre support à une campagne Meta Yield.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plate-forme de marché des méta-bond

Marché obligataire
Cette section affiche toutes les obligations proposées sur la plateforme. Les données de chaque obligation sont affichées et il sera possible d'acquérir / d'enchérir pour elles.
Mes obligations
La section Mes obligations détaille toutes les obligations que l'utilisateur possède. A partir de cette section, l'utilisateur peut :

 	Voir toutes les données des obligations
 	Vends-les
 	Fusionnez-les (important, pour fusionner 2 obligations, tous les critères de l'obligation doivent correspondre : actif, date d'échéance et date Cliff le cas échéant).
 	Fractionner-les (les obligations ne peuvent être fractionnées que si elles n'ont pas été partiellement réclamées).

Mes ventes
Dans cette section, vous pouvez voir les obligations que l'utilisateur a mises en vente. Les ventes en cours et celles réalisées.

 	Vente directe : l'acheteur enchérit directement et le vendeur verra dans cette section, que la vente a été effectuée et pourra obtenir les jetons correspondants.
 	Vente aux enchères : l'offre la plus élevée est gagnante et à la fin de la période d'enchères, le vendeur pourra obtenir les jetons.
 	Fin de période d'offre : Si à la fin de la période d'offre, il n'y a pas eu d'offre, le vendeur peut remettre son obligation en vente ou mettre fin au processus.

Important : si l'obligation a été vendue, le vendeur doit saisir l'obligation et appuyer sur "obtenir des jetons" pour clôturer le processus de vente. Ce processus est manuel.
Garantie d'obligation
Lors de la mise en vente d'une obligation, le système demandera un montant minimum (actuellement 1 NEAR) à titre de garantie.

Cela permet au système de ne détenir que des obligations représentant un minimum du montant de la garantie en question.

Lors de la clôture du processus de vente, ce montant sera restitué au vendeur.
Mes enchères
Dans "Mes offres", l'utilisateur peut voir les offres actives qu'il a faites pour les obligations aux enchères.

Les obligations de vente directe ne sont pas affichées ici, car elles sont déjà automatiquement intégrées dans la section "Mes obligations".

Si vous perdez l'enchère, le système vous permet d'augmenter votre enchère ou d'annuler votre enchère en retirant vos jetons.
États des obligations en adjudication
Période de vente active

 	Perdre : cette offre a été surenchère. L'utilisateur peut augmenter l'offre ou retirer l'offre en cours.
 	Gagnante : Cette enchère est la meilleure, c'est celle qui gagne. L'utilisateur doit attendre la fin (la vente se termine) pour voir s'il a réellement gagné.

Période de vente terminée

 	Gagnant : Ce statut s'affiche si l'enchère à la fin de la période d'enchères est gagnante. L'utilisateur peut réclamer la caution.
 	Perdu : Ce statut s'affiche si l'enchère à la fin de la période d'enchères est perdante. L'utilisateur peut réclamer (retirer) son offre de jetons pour ce lien.




	

	
	
		
			
				Il existe un risque potentiel élevé de liquidation lors de la vente de vos obligations sur Meta Bond Market.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Étape par étape sur le marché Meta Bond.


 

### Meta Pool, Module 3 – Les Finances Décentralisées x Meta Pool

Ecosystème DeFi avec Meta Pool
Les finances décentralisées (DeFi) sont une nouvelle façon d'opérer des finances basées sur la technologie blockchain. Ces finances utilisent des contrats intelligents pour stocker, verrouiller, partager, céder et farmer des jetons. DeFi vise à soustraire le contrôle que les banques centrales exercent sur les fonds ou les actifs et à les distribuer par le biais de contrats intelligents.

Meta Pool est un contrat intelligent d'émission d'actifs sans permission et non-conservatoire, qui permet de réunir des jetons NEAR et des récompenses de staking en un seul jeton appelé staked NEAR (stNEAR).

stNEAR permet à ses détenteurs de déplacer la valeur des jetons et des récompenses sur l'écosystème DeFi de plusieurs chaînes, y compris NEAR et Aurora.




	

	
	
		
			
				Les finances décentralisées peuvent être gérées en partie par des entités centralisées. Tous les DeFi ne sont pas décentralisés à 100 %.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pont stNEAR tokens entre NEAR <> Aurora - Rainbow Bridge
Meta Pool utilise le Rainbow Bridge pour transférer les jetons $META et stNEAR entre NEAR et le réseau Aurora, ce qui vous permet d'utiliser vos jetons Meta Pool dans les dApps Aurora, telles que Trisolaris, WannaSwap, etc.

Déplacer stNEAR et $META vers Aurora en utilisant le Rainbow Bridge

En utilisant https://rainbowbridge.app/, vous pouvez connecter votre portefeuille NEAR et votre portefeuille MetaMask afin de transférer vos jetons :

  

Comment ajouter des contrats stNEAR $META au portefeuille MetaMask

Pour ajouter un jeton de votre transfert Rainbow Bridge à MetaMask sur le Mainnet Aurora, cliquez sur "Scan transfer history (Scanner l'historique des transferts)" dans le Bridge et sélectionnez "Add token to MetaMask (Ajouter un jeton à MetaMask)".

Pour ajouter un jeton manuellement, trouvez l'adresse du jeton dans la liste des jetons pris en charge. Notez qu'ils ont une adresse différente sur Aurora Mainnet que sur Ethereum.

$META sur Aurora 0xc21ff01229e982d7c8b8691163b0a3cb8f357453

stNEAR sur Aurora 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30

(VIDÉO) Comment transférer stNEAR sur Aurora. Opportunités de minage Liquide (Protocole NEAR, Aurora) : (NEAR Protocol, Aurora): https://www.youtube.com/watch?v=_o–5GY5G0w




	

	
	
		
			
				Une fois qu'un jeton a été transféré du protocole NEAR à Aurora, il est impossible de le réintégrer dans la chaîne d'origine.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Échanger des jetons sur Aurora – Trisolaris
Le swap est le processus par lequel vous échangez un token contre un autre selon la valeur donnée par les conditions du marché ou du pool. De cette façon, vous pouvez obtenir des jetons que vous prétendez détenir ou rechercher un jeton que vous souhaitez utiliser dans une application spécifique.

Trisolaris est #1 Dex sur le moteur Aurora, une blockchain compatible EVM fonctionnant dans l'écosystème Near.

Comment échanger sur Trisolaris ?

 	Allez dans la section Swap de Trisolaris et connectez votre portefeuille MetaMask au réseau Aurora.



 	Saisir le montant à échanger
 	Approuver et confirmer la transaction




	

	
	
		
			
				Vous pouvez utiliser le routage pour échanger contre un jeton pour lequel il n'existe pas de pool de liquidités directes.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ajouter de la liquidité aux pools de swaps de stNEAR – Trisolaris
Les émissions de jetons n'étant pas gérées par une bourse d'échange décentralisée, les pools d'échange ont besoin d'utilisateurs qui ajoutent de la liquidité pour pouvoir effectuer un échange.
Ainsi, vous pouvez devenir un fournisseur de liquidité en mettant la paire de jetons requise pour un pool. En échange, vous recevez une fraction des frais générés par le pool.

 	Rendez-vous dans la section Pool et cliquez sur le bouton Add liquidity (ajouter de la liquidité).



 	Sélectionnez la paire pour laquelle vous souhaitez ajouter de la liquidité. Dans Trisolaris, vous trouverez le pool <> wNEAR.



 	Confirmer le solde et cliquer sur le bouton Add (ajouter).


Échanger des jetons sur le protocole NEAR - Ref Finance
1. Allez sur Ref Finance et connectez votre portefeuille NEAR.

2. Allez dans la section Swap



3. Sélectionnez les jetons à échanger et vérifiez les cases "Price Impact (Impact sur le prix)", "Swap rate (Taux d'échange)" et "Minimum reeived (Minimum reçu)" dans le menu "Détails". Décidez si cet échange vous convient.

4. Saisissez le montant de l'échange

5. Cliquez sur le bouton Swap, confirmez et signez la transaction

Ainsi, sur Ref Finance, vous pouvez obtenir des jetons $META et stNEAR.
Ajouter de la liquidité aux pools d'échange de stNEAR - Ref Finance
Ref Finance est la principale bourse décentralisée sur le protocole NEAR. Il met à disposition un ensemble d'outils DeFi utilisant le standard NEP-141 de NEAR.

 	Allez dans pools, recherchez les pools stNEAR et choisissez le pool auquel vous souhaitez ajouter de la liquidité.



 	Cliquez sur le bouton Add Liquidity 



 	Sélectionnez la quantité de jetons que vous souhaitez ajouter à la liquidité du pool.



Une fois cette opération effectuée, vous êtes en mesure de recevoir une partie des frais générés par le pool.




	

	
	
		
			
				En étant fournisseur de liquidité, vos tokens risquent d'être liquidés.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Emprunter en utilisant stNEAR – Burrow Cash
Emprunter signifie que vous demandez des jetons en donnant un jeton en garantie. Vous recevez une fraction de la valeur de votre garantie (surcollatéralisation) pour recevoir le jeton demandé dans le burrow.

Si vous voulez récupérer vos jetons, vous avez la possibilité de payer votre dette.

Si votre garantie perd de la valeur, elle sera liquidée automatiquement par la plateforme d'emprunt Burrow et vous ne resterez qu'avec vos tokens empruntés sans possibilité de récupérer vos tokens.

 	Aller sur BurrowCash
 	Connectez votre portefeuille NEAR
 	Suivez stNEAR sur Deposit (la page de dépôt)



Dépôt de stNEAR:

 	Saisir le montant stNEAR
 	à utiliser comme garantie si vous souhaitez emprunter
 	Soumettre et signer la transaction



Comment emprunter ?



 	Sélectionnez le bien à emprunter
 	Saisir le montant à emprunter, en tenant compte du facteur de santé qui en découle
 	Soumettre et signer la transaction



Comment rembourser ?



 	Aller au portefeuille
 	Pour rembourser les actifs empruntés, cliquez sur le bouton "Repay (Remboursement)".



Comment effectuer un retrait ?



 	Accéder au portefeuille
 	Pour retirer les actifs fournis, cliquez sur "Withdraw (Retirer)".






	

	
	
		
			
				Il est possible d'emprunter de l'argent dans n'importe quel pays du monde.
			
		

		
					

		
			
			
			
			Vrai 
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Emprunter en utilisant stNEAR – Aurigami
Arugami vous permet de demander un emprunt de jetons sur le réseau Aurora. Pour ce faire, vous pouvez utiliser des jetons stNEAR.

A l'heure où nous écrivons ces lignes, vous pouvez vous rendre directement sur le tableau de bord d'Aurigami et cliquer sur supply for stNEAR token. Si vous avez déjà une garantie, vous pouvez cliquer sur borrow.



L'option supply vous donnera une fenêtre modale où stNEAR peut être déposé. Une fois choisi, cliquez sur Approuver stNEAR.



Autoriser l'utilisation de stNEAR comme garantie pour demander un burrow. Confirmez la transaction sur votre portefeuille.



Sélectionnez le jeton que vous souhaitez emprunter et cliquez sur le bouton Borrow



Sélectionnez la quantité de jetons que vous souhaitez emprunter. ATTENTION : si vous demandez 100 %, vous risquez fort d'être liquidé.



Lorsque vous souhaitez récupérer votre stNEAR, allez rembourser et rendez tous les jetons que vous avez obtenus en empruntant.


Leveraged Yield Farming (L'agriculture à rendement élevé) - Pembrock
La première application leveraged yield farming sur le protocole NEAR. Au sein de cette application, vous trouverez des mécanismes de prêt, de farming et de staking. stNEAR est autorisé comme jeton à utiliser dans PembRock.



Farm STNEAR-wNEAR

Déposez des stNEAR et empruntez des wNEAR dans le pool de la ferme. Choisissez le montant des actifs à utiliser comme garantie et le rendement élevé. Vérifiez le résumé de la transaction.



Prêter des stNEAR

Choisissez la quantité de jetons stNEAR que vous souhaitez prêter. Ces actifs sont utilisés par les yiel farmers (producteurs de rendement) pour augmenter leurs actifs cryptographiques.



Pour en savoir plus sur le fonctionnement de Pembrock, cliquez sur le lien https://docs.pembrock.finance/education/how-to-guides




	

	
	
		
			
				Le Leverage Yield Farming peut impliquer un risque de liquidation de vos tokens.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Le staking NEAR sur le réseau Aurora
Nous avons fait en sorte qu'il soit facile pour les utilisateurs d'Aurora de staker wNEAR directement à partir d'Aurora en utilisant MetaMask. En tirant parti de la capacité du Rainbow Bridge à effectuer des appels de contrat entre Aurora et NEAR, nous avons construit une solution simple qui conserve la même interface utilisateur et la même expérience que la solution native de NEAR.



Il est facile de distinguer le réseau sur lequel vous vous trouvez car il porte le logo Aurora, et chaque réseau vous invitera automatiquement à connecter votre portefeuille Metamask.

Nous utilisons le Rainbow Bridge pour automatiser toutes les étapes que les utilisateurs auraient dû effectuer manuellement : en coulisses, nous envoyons wNEAR d'Aurora vers NEAR Mainnet, nous le déballons, nous déposons NEAR sur Meta Pool, nous recevons stNEAR et nous renvoyons stNEAR via le Rainbow Bridge vers le portefeuille Aurora de l'utilisateur.

Notre code a été audité par Blocksec. Voici les audits, nous avons donc fait de notre mieux pour sécuriser les actifs.

Les frais de dépôt sur Aurora sont de 0,1%, car Meta Pool doit payer des frais de transaction sur le pont dans les deux sens, ce qui couvre ces frais de transaction.

### Développement de contrats intelligents sur Near en utilisant Rust Partie 3

Ceci est la troisième partie d'une série d'articles sur la création d'une application de chat avec Rust sur la blockchain Near. Vous pouvez retrouver les articles précédents de la série ici et ici.

Dans cet article, nous nous concentrerons sur les parties hors chaîne du code. Nous discuterons du besoin d' "indexeurs" et passerons en revue certaines parties de l'implémentation de l'indexeur dans cet exemple. Vous pouvez trouver le référentiel complet avec tout le code dont nous parlerons aujourd'hui sur mon GitHub.
Les indexeurs, ce qu'ils sont et pourquoi nous en avons besoin
Dans l'espace blockchain, un indexeur est un service qui consomme des données brutes à partir d'une source (généralement une instance de nœud complet colocalisée pour cette blockchain) et les analyse dans un format plus utile pour une application spécifique. Par exemple, dans le cas de notre application de chat, l'indexeur consomme un flux de blocs Near et produit un flux d'événements (par exemple, des messages reçus et des demandes de contact).

Les indexeurs sont importants car les bases de données utilisées pour faire fonctionner la blockchain elle-même ne sont généralement pas optimisées pour effectuer les types de requêtes dont les applications se soucient. Par exemple, l'obtention du solde d'un utilisateur pour un jeton ERC-20 sur Ethereum se fait généralement en exécutant la requête via l'EVM, car c'est la seule façon dont les informations sont disponibles à partir d'un nœud Ethereum typique. Il s'agit d'une opération extrêmement coûteuse par rapport à la recherche d'une entrée dans une base de données relationnelle traditionnelle. Par conséquent, une optimisation simple pour toute application nécessitant un accès rapide aux soldes ERC-20 consisterait à exécuter un indexeur sur les données brutes d'Ethereum qui remplit une base de données traditionnelle avec les soldes qui l'intéressent. Ensuite, l'application utiliserait cette base de données comme source pour les soldes au lieu d'un nœud Ethereum directement. C'est ainsi que l'explorateur de blocs Etherscan fonctionne sous le capot ; Etherscan exécute un indexeur pour remplir une base de données qui est ensuite utilisée pour remplir les champs des pages Web desservies par Etherscan.

Les indexeurs ne sont pas seulement importants pour Ethereum, tout dapp haute performance sur n'importe quelle blockchain devra inclure un indexeur quelque part dans son architecture. L'exemple d'application de chat dont nous avons discuté sur Near ne fait pas exception, alors plongeons dans la façon dont l'indexeur est implémenté.
Obtenir les données brutes
Les indexeurs traitent uniquement les données brutes de la blockchain dans un format que l'application associée peut utiliser ; ils ne génèrent pas les données en premier lieu. Par conséquent, la première question à laquelle nous devons répondre lors de la création d'un indexeur est : d'où proviennent les données de la blockchain ?

Near fournit quelques sources de données différentes, comme décrit ci-dessous.
Exécution d'un nœud proche du cœur
La meilleure source de données (en termes de décentralisation et de sécurité) pour toute blockchain est le réseau peer-to-peer de la blockchain elle-même. Pour accéder à cette source de données, vous devez exécuter un nœud qui comprend le protocole de la blockchain. Dans le cas de Near, l'implémentation du nœud est appelée nearcore. Son code source est ouvert sur GitHub. Une documentation est disponible sur la façon d'exécuter votre propre nœud nearcore. Le principal obstacle à l'entrée ici est la quantité d'espace disque nécessaire pour cela ; il est recommandé d'avoir 1 To de stockage dédié pour votre nœud et il faut un certain temps pour qu'il se synchronise avec la chaîne car il faut télécharger toutes ces données.

Une fois que vous avez une configuration de nœud nearcore, Near fournit un cadre d'indexation pratique dans Rust qui peut être utilisé pour créer des indexeurs avec nearcore comme source de données. Pour un projet réel, ce serait la meilleure façon de créer un indexeur. Cependant, notre exemple n'est qu'une démonstration, nous ne voulons donc pas passer des heures à télécharger des données de chaîne sur un serveur dédié de 1 To. Heureusement, il existe d'autres options.
Lac de données NEAR
Pour faciliter le démarrage de leurs projets par les développeurs, Near a créé le framework de lac de données comme source alternative de données à utiliser par les indexeurs. Le cadre du lac de données est construit au-dessus du cadre de l'indexeur mentionné ci-dessus, en utilisant un nœud Near du cœur comme source de données. L'indexeur alimentant le lac de données est trivial dans le sens où il ne traite pas les données pour une application spécifique, il transmet simplement les données longtemps pour être stockées dans le stockage AWS S3. Cependant, cela permet aux développeurs d'accéder à ces données à l'aide de leur propre compte AWS, puis de créer leurs propres indexeurs (non triviaux) en utilisant ce stockage S3 comme source de données.

L'avantage pour les développeurs est que cette méthode est beaucoup plus rapide à faire fonctionner. L'inconvénient, cependant, est que les données proviennent d'une source centralisée et sont donc théoriquement plus faciles à corrompre que d'utiliser directement le réseau peer-to-peer.

Pour accéder au lac de données, vous devez payer les ressources AWS que vous utilisez pour vous fournir ces données. Encore une fois, pour les besoins de l'exemple d'application de chat, je ne voulais pas que les gens s'inscrivent à AWS et dépensent de l'argent pour exécuter l'indexeur. Par conséquent, j'ai choisi l'option de source de données finale.
Nœuds RPC publics
Le dernier moyen d'accéder aux données de la blockchain si vous n'exécutez pas votre propre nœud ou si vous n'accédez pas au magasin de données prédéfini de quelqu'un d'autre consiste à utiliser les nœuds de quelqu'un d'autre. Les nœuds RPC sont des nœuds du réseau blockchain qui sont destinés à répondre aux demandes des utilisateurs. Chaque blockchain a des fournisseurs de nœuds RPC (certains gratuits, d'autres payants). Une liste des fournisseurs RPC pour Near est disponible ici.

C'est le moyen le moins efficace d'accéder aux données de la blockchain car il faut plusieurs requêtes RPC pour obtenir les données utilisées par les indexeurs typiques. Chaque demande RPC entraîne une latence du réseau, ce qui rend l'indexeur lent pour répondre aux événements se produisant sur la chaîne. Le seul avantage de cette approche est qu'elle est libre de configurer une démo tant qu'il existe un fournisseur RPC gratuit pour la chaîne (ce qui est le cas avec Near). Par conséquent, il s'agit de la source de données utilisée par l'indexeur dans notre exemple.

Cela dit, l'indexeur lui-même ne se soucie pas de la provenance de ses données. Par conséquent, même si notre exemple utilise la pire source de données, il vaut la peine d'explorer son implémentation car les concepts utilisés par cet indexeur sont les mêmes que ceux d'un indexeur construit à l'aide du lac de données de Near ou des frameworks d'indexation basés sur des nœuds.
Implémentation de l'indexeur
Notre indexeur est conçu comme une application tokio dans Rust. Tokio est un framework Rust pour écrire des applications hautes performances où les opérations d'E/S sont le principal goulot d'étranglement. Notre indexeur est une telle application car le calcul réel qu'il effectue est extrêmement rapide par rapport au temps qu'il faut pour demander des données aux nœuds RPC. Les principales caractéristiques de tokio sont qu'il utilise des pimitifs asynchrones non bloquants et qu'il intègre le multithreading pour permettre une exécution parallèle. Cela s'ajoute au fait qu'il se trouve dans Rust, il possède donc naturellement les garanties de sécurité de la concurrence et de sécurité de la mémoire fournies par Rust.

Si tokio est la scène sur laquelle se déroule notre application, alors ce qui suit sont les acteurs de la pièce (jeu de mots ; cette application suit le modèle d'acteur, mais j'ai choisi de le faire directement dans tokio au lieu d'utiliser une bibliothèque comme actix parce que je pense que les canaux de tokio fournissent un typage plus fort que les messages génériques utilisés dans la plupart des frameworks d'acteurs).

L'indexeur a quatre rôles principaux : le gestionnaire, le téléchargeur de blocs, le téléchargeur de blocs et le gestionnaire de réception.
Le manager
Le processus manager supervise l'ensemble de l'indexeur. Il est chargé de déléguer le travail aux autres processus et de leur dire de s'arrêter lorsque le programme est fermé (par exemple en cas d'erreur rencontrée). Par exemple, le manager gère l'équilibrage de charge des téléchargeurs de blocs en les parcourant lors de l'attribution d'un bloc à télécharger.
Le téléchargeur de blocs
Comme son nom l'indique, le but du processus de téléchargement de blocs est de télécharger des blocs. Il interroge périodiquement le Near RPC pour vérifier s'il y a de nouveaux blocs et s'il y en a, les télécharge et les envoie au manager. Si nous n'utilisions pas le RPC comme source de données, ce processus serait remplacé par une connexion à un nœud near ou à un lac de données.
Le(s) téléchargeur(s) de chunk
Sur Near, les blocs ne contiennent pas les données sur les transactions ; les morceaux font. Les blocs ne donnent que des informations sur les nouveaux morceaux disponibles. La raison en est le partage de Near (vous pouvez en savoir plus à ce sujet ici). Par conséquent, nous avons besoin de processus distincts pour télécharger les données de bloc pour chaque bloc. Les téléchargeurs de chunk remplissent ce rôle. Notre indexeur dispose de plusieurs instances de téléchargement de chunk pour permettre le téléchargement des morceaux en parallèle.

Si nous n'utilisions pas le RPC comme source de données, selon la façon dont les données sont factorisées dans la source de données que nous utilisions, ces processus n'auraient peut-être pas besoin d'exister (par exemple, le cadre de near-indexeur inclut toutes les données de bloc et de bloc dans un message unique). Mais pour notre cas, puisque nous utilisons le RPC, ces processus sont nécessaires.
Le gestionnaire de réception
Les blocs contiennent des "reçus" qui sont créés lorsqu'une transaction est traitée. Lorsque le gestionnaire reçoit un nouveau morceau d'un téléchargeur de morceaux, il envoie tous les reçus au processus de gestionnaire de reçus (nous pourrions avoir plusieurs instances de gestionnaire de reçus pour traiter les reçus en parallèle, tout comme nous avons plusieurs téléchargeurs de morceaux, mais le traitement des reçus est rapide assez pour que je ne pense pas que cela ait ajouté beaucoup d'amélioration des performances). Ce processus filtre les reçus uniquement pour ceux qui nous intéressent, puis télécharge le résultat d'exécution pour les reçus et traite enfin les événements à partir de ces résultats. Dans le cas de cet exemple, nous écrivons simplement les événements dans un fichier (pour une démonstration en direct, vous pouvez regarder le fichier avec quelque chose comme la commande tail -f Unix pour voir les événements arriver), mais vous pouvez imaginer qu'une implémentation de production pourrait transférer ces événements sous forme de notifications push vers une version mobile de l'application.
Remarques
Vous remarquerez peut-être tout au long du code de l'indexeur qu'il y a une certaine complexité autour de l'envoi de morceaux/reçus avec le hachage de bloc après le bloc qui comprenait ces morceaux. C'est une bizarrerie du Near RPC où il veut savoir que vous êtes au courant des blocs ultérieurs pour servir le résultat de l'exécution. Encore une fois, cela serait géré beaucoup plus facilement si vous utilisiez une meilleure source de données.

Il est intentionnel qu'il n'y ait pas de panique dans aucune des fonctions d'acteur. Lorsqu'ils rencontrent une erreur, ils l'enregistrent et envoient un message d'arrêt au gestionnaire (et le gestionnaire l'envoie à tous les autres acteurs). Ceci est important car paniquer dans une application multithread peut provoquer un comportement inattendu (en général, tokio est assez bon pour faire tomber toute l'application avec élégance, mais il est toujours préférable de coder de manière défensive contre elle).
Conclusion
Dans cet article, nous avons expliqué pourquoi les indexeurs sont importants pour les dapps du monde réel et examiné certains des détails de l'exemple d'indexeur mis en œuvre pour le chat dapp. Comme pour le post précédent, il y a des exercices dans le code de l'indexeur inclus dans les commentaires marqués comme EXERCICE. Je vous encourage à essayer ces exercices si vous voulez une expérience pratique avec la base de code.

 À propos de la série

Ceci est le dernier article de cette série. Dans la partie 1, nous avons examiné les principes généraux du développement de contrats intelligents et comment ils s'appliquent à un exemple de contrat pour une application de chat. Dans la partie 2, nous avons approfondi la manière d'utiliser le quasi-sdk pour rédiger des contrats intelligents pour Near dans Rust. Enfin, cet article a expliqué comment les indexeurs sont nécessaires pour intégrer les données de la blockchain aux composants hors chaîne de notre application.

Un dernier élément du code que je n'ai pas couvert est le test d'intégration. Le test d'intégration utilise la bibliothèque Near-workspaces pour simuler la blockchain localement et utilise le même style Rust asynchrone que l'indexeur.. Même si les tests d'intégration ne sont pas particulièrement flashy ou intéressants, ils sont importants pour garantir le bon fonctionnement de votre contrat. Je vous encourage à jeter un coup d'œil aux tests d'intégration pour le contrat de messagerie et à essayer l'exercice là-bas pour acquérir une expérience pratique dans ce domaine également.

Si vous avez apprécié cette série d'articles de blog, veuillez nous contacter à Type-Driven consulting. Nous sommes heureux de fournir des services de développement de logiciels pour les dapps, ainsi que du matériel de formation pour vos propres ingénieurs.

 

### DeFi sur NEAR 2023

Tweet +4nLEARNs

En 2023, l'écosystème NEAR a développé un ensemble de plateformes matures pour l'écosystème Decentralized Finances (DeFi). Il dispose d'une large gamme d'applications décentralisées (dApps) axées sur la gestion des finances. NEAR est une vitrine d'une blockchain évolutive, à faibles frais et de couche 1. Cet avantage permet à toute personne intéressée de se lancer facilement sur les DeFi.

DeFi permet aux utilisateurs de gérer leurs jetons numériques. Voici quelques-unes des principales caractéristiques de cette technologie :

 	Non-conservateur : les utilisateurs maintienent le contrôle de leurs actifs tout au long du processus d'échange.
 	Transparence : Toutes les transactions sont enregistrées sur la blockchain et peuvent être consultées par n'importe qui.
 	Sécurisée : Utilisation de la cryptographie avancée et d'autres mesures de sécurité pour garantir que les transactions sont sûres et sécurisées.
 	Accessible : à toute personne disposant d'une connexion internet et d'un portefeuille numérique compatible.
 	Pas d'autorité centrale : de manière décentralisée, ce qui signifie qu'il n'y a pas d'autorité centrale qui contrôle la bourse.

Proximity Labs, une société de recherche et de développement, y compris un fonds de capital-risque, est à la recherche de la prochaine génération de plateformes DeFi qui souhaitent se développer sur le NEAR Protocol. Si vous êtes un développeur et que vous cherchez un soutien pour améliorer votre dApp DeFi développée sur NEAR, recherchez-les.

Enfin, nous devons ajouter le contexte. Les événements survenus en 2022 (comme Terra-Luna, FTX-Alameda, et d'autres), et l'écosystème cryptographique ont apporté des changements radicaux à l'avenir DeFi, nécessitant des plates-formes plus dynamiques et innovantes qui peuvent prendre en charge les deux : Marchés baissiers et haussiers. Compte tenu de tous les avantages technologiques, cet auteur pense que l'avenir des DeFi devrait être construit sur NEAR.
Bourses décentralisées (DEX)
Ref Finance


Ref Finance, le pionnier de la finance décentralisée sur le NEAR Protocol, offre un service de swap complet pour les tokens avec des pools de liquidité et des fermes. La plateforme a évolué au fil du temps pour inclure un Automatic Market Maker (teneur de marché automatique) (AMM) pour des expériences de négociation transparentes.

Ref Finance est régie par une DAO qui maintient une liste blanche de jetons à échanger sur la plateforme, garantissant ainsi la sécurité et la stabilité des actifs. En 2023, Ref Finance reste le premier premier DEX sur NEAR avec une feuille de route prometteuse pour étendre ses fonctionnalités.

Au premier trimestre 2023, Ref Finance prévoit de lancer Ref V2 Farms, des mesures de base sur Ref Analytics, et l'intégration de la liquidité d'Orderly pour une expérience pure de Central Limit Order Book (CLOB). Au deuxième trimestre 2023, la plateforme vise à introduire des primitives de prêt et d'emprunt intégrées, une proposition de swap améliorée, des widgets Ref et Zap Swap.



Au second semestre 2023, Ref Finance prévoit de déployer des swaps récurrents, Sentinel sur les pools et les fermes, la liquidité en tant que collatéral, et des solutions innovantes pour une meilleure sécurité et protection des utilisateurs. Avec sa feuille de route ambitieuse, Ref Finance est prête à consolider sa position en tant que DEX de premier plan dans l'écosystème NEAR.
Spin Finance


Spin Finance est une plateforme de trading décentralisée qui offre des outils de trading avancés aux utilisateurs de NEAR, y compris des contrats à terme perpétuels sur NEAR, ETH et BTC. En plus du trading au comptant traditionnel, Spin fournit des DVV et des coffres-forts pour yield farming (l'agriculture de rendement). En utilisant ces coffres-forts, les traders peuvent facilement et en toute sécurité participer au yield farming sans avoir à négocier individuellement.



En outre, la feuille de route de Spin Finance comprend l'introduction de nouvelles fonctionnalités telles que le trading d'options, les AIP et un Market Maker décentralisé. Ces outils avancés peuvent être utiles à la fois pour les traders et les degens, ce qui fait que tout jeton de l'écosystème NEAR mérite d'être pris en compte pour son utilisation.



Le modèle hybride unique de Spin Finance combine les avantages des échanges centralisés et ceux des échanges décentralisés, ce qui lui permet de se démarquer parmi ses pairs. Depuis son lancement en 2021 en tant que livre d'ordres pour NEAR, Spin n'a cessé de se développer, avec une équipe en pleine expansion qui promet un avenir brillant. Si vous êtes à la recherche d'une plateforme de trading avancée qui combine le meilleur des deux mondes, Spin Finance pourrait être le choix idéal pour vous.
Jump DeFi


Jump DeFi est une dapp globale qui fournit une gamme de solutions pour le lancement, la collecte de capitaux et l'échange de jetons NEP-141. Il est considéré comme un écosystème qui permet aux individus et aux organisations de faire leurs premiers pas dans le monde du DeFi.

L'un des outils les plus remarquables fournis par Jump Defi est le service de staking NFT qui permet aux communautés NFT de soutenir leurs détenteurs en leur fournissant des jetons. Ce service est conçu pour encourager la détention de NFT et créer une communauté plus engagée.

Le Jump Token Laboratory est un autre outil innovant fourni par Jump DeFi, qui permet aux utilisateurs de créer des tokens et de les déplacer ensuite vers le Jump Pad, une rampe de lancement qui facilite la collecte de fonds sur l'écosystème NEAR.



Jump DeFi a également accueilli une campagne de culture de rendement boostée pour NEKO, une mème pièce vivant sur le NEAR Protocol. La plateforme a également lancé des campagnes de crowdfunding sur d'autres plateformes de lancement, y compris Meta Yield, où elle a recueilli un total de 68 416 USD en jetons stNEAR qui fourniront toutes les récompenses de staking.

Il s'agit d'une plateforme étonnante et complète qui offre une gamme variée de services DeFi sur le protocole NEAR, y compris le staking, la collecte de fonds et la création de jetons. C'est une plateforme qui a le potentiel d'ouvrir de nouvelles opportunités et possibilités pour tous ceux qui cherchent à participer à l'écosystème financier décentralisé.
Liquid Staking
Meta Pool
Le Liquid Staking est devenu une solution populaire pour ceux qui veulent miser leurs jetons et gagner des récompenses, mais qui veulent aussi conserver la possibilité d'utiliser ces jetons d'autres façons. Meta Pool est la première et la plus grande solution de staking liquide sur le protocole NEAR, offrant aux utilisateurs un moyen de gagner des récompenses de staking tout en étant en mesure d'utiliser leurs jetons stakés dans l'écosystème DeFi.

Meta Pool a lancé son jeton de staking numérique, $stNEAR, qui permet aux utilisateurs de continuer à staker tout en utilisant le dérivé $stNEAR dans l'écosystème DeFi. Le protocole est géré par une DAO qui récompense les utilisateurs avec $META, un jeton de gouvernance qui peut être utilisé pour participer à la communauté conduisant la DAO de Meta Pool.



L'une des caractéristiques uniques du Meta Pool est la mise en œuvre du Meta Staking Vote, qui permet aux détenteurs de $META de sélectionner les validateurs les mieux à même d'être soutenus. Ces validateurs reçoivent 15 % de la valeur totale bloquée (TVL) du Meta Pool, distribuée en fonction de leur vote. Cette approche garantit que la communauté du Meta Pool a son mot à dire dans le choix des validateurs, ce qui favorise la décentralisation et l'implication de la communauté dans le réseau.

Aujourd'hui, la famille de produits lancée par Meta Pool s'est enrichie et est complétée par :

 	$stNEAR, Liquid Staking on NEAR.
 	Pool de liquidité pour le déstockage liquide sur le protocole NEAR.
 	jeton $stAUR, mise en jeu liquide sur Aurora
 	Meta Yield, la première plateforme de crowdfunding sans perte sur NEAR.
 	Meta Bond, vendez vos positions bloquées sur Meta Yield.
 	Meta Vote, obtenez un droit de vote pour la gouvernance du Meta Pool.

Meta Pool est un protocole sans permission qui permet aux utilisateurs de mettre en jeu leurs jetons et de gagner des récompenses, tout en conservant la possibilité d'utiliser ces jetons d'une autre manière. Avec la mise en œuvre du Meta Staking Vote et la distribution de jetons de gouvernance $META, Meta Pool encourage l'implication de la communauté et la participation à la gouvernance de son réseau.




	

	
	
		
			
				Lesquels des suivants sont des échanges décentralisés construit sur le protocole NEAR ? (réponses multiples)
			
		

		
					

		
			Please select 4 correct answers
			
			
			Uniswap
		
			
			Ref Finance
		
			
			Spin Finance
		
			
			Jump DeFi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





LiNEAR Protocol


$LiNEAR est une solution de staking liquide fournie par Linear Protocol, l'un des principaux projets de l'écosystème NEAR. Il fait partie de Cornerstone, un protocole de méta-gouvernance construit pour soutenir l'écosystème NEAR en pleine croissance, offrant des jetons $CORN aux utilisateurs de leurs plateformes.

Avec un APY relativement élevé d'environ 9 %, LiNEAR a gagné en popularité parmi les utilisateurs à la recherche d'une option de mise liquide lucrative sur NEAR. Le protocole a également soutenu récemment Stake Wars III, une compétition sur NEAR qui permet à davantage de validateurs de participer au réseau en tant que producteurs de blocs, renforçant ainsi l'écosystème.

Linear Protocol a également annoncé son dernier produit, Phoenix Bonds, une ferme génératrice de rendement disponible sur Ref Finance pour les fournisseurs de liquidités NEAR<>pNEAR. Les utilisateurs auront ainsi une nouvelle occasion de gagner des récompenses tout en soutenant la liquidité de NEAR et pNEAR. En se concentrant sur la création de produits DeFi innovants et utiles, Linear Protocol est un projet à suivre dans l'écosystème NEAR.
Stader Labs sur NEAR


Stader Labs a apporté sa solution innovante de liquid staking au protocole NEAR, permettant aux utilisateurs de gagner des récompenses de staking tout en ayant accès à leurs jetons misés via son jeton $NearX.

La plateforme s'est intégrée à plusieurs portefeuilles pour permettre aux utilisateurs de participer facilement au liquid staking. En outre, Stader Labs a pris la sécurité au sérieux et a subi des audits de sécurité rigoureux de la part de Halborn, BlockSec et OSec, qui ont tous donné à la plateforme leur sceau d'approbation.

Au-delà du protocole NEAR, Stader Labs est présent sur plusieurs autres chaînes, notamment Polying, Fantom, BNB Chain et Hedera, fournissant ainsi des solutions de staking liquide aux utilisateurs de plusieurs écosystèmes.

Dans l'écosystème NEAR en particulier, le jeton de liquidité $NearX est disponible à la fois sur le protocole NEAR et sur le réseau Aurora : protocole NEAR et Aurora Network, un EVM fonctionnant sur NEAR, ce qui donne aux utilisateurs encore plus de flexibilité et d'options lorsqu'il s'agit de staker leurs jetons.
Plateformes de prêts
Burrow Cash


La finance décentralisée a ouvert un monde de possibilités en matière de prêt et d'emprunt. Burrow Cash est une plateforme de prêt fonctionnant sur le protocole NEAR qui offre un moyen décentralisé de prêter et d'emprunter des jetons sans avoir besoin d'un intermédiaire centralisé.

Avec Burrow Cash, les utilisateurs peuvent verrouiller leurs jetons et les utiliser comme garantie pour demander un autre jeton, ce qui leur permet d'accéder à de nouveaux jetons sans avoir à vendre leurs positions existantes. Cela est particulièrement utile pour les utilisateurs qui ne veulent pas vendre leurs jetons mais qui souhaitent accéder à d'autres jetons ou qui ont besoin de liquidités.

Burrow Cash utilise des oracles pour surveiller les prix des jetons, en veillant à ce que la garantie de l'utilisateur reste stable et qu'il reçoive une quantité équitable de jetons en échange de sa garantie. Cependant, il est important de se rappeler que si la valeur de la garantie baisse, elle risque d'être liquidée pour rembourser la dette.

Outre le prêt et l'emprunt, Burrow Cash propose également des pools de liquidités, où les utilisateurs peuvent fournir leurs jetons pour le burrowing et obtenir des récompenses en échange. Ces pools de liquidité constituent un autre moyen pour les utilisateurs d'obtenir un retour sur leurs tokens, et fournissent également des liquidités à la plateforme, ce qui permet de s'assurer qu'il y a toujours suffisamment de liquidités disponibles pour ceux qui veulent emprunter ou prêter.

Dans l'ensemble, Burrow Cash est une plateforme de prêt décentralisée qui offre un moyen simple, sûr et efficace de prêter et d'emprunter des jetons sur le protocole NEAR. En utilisant des oracles pour surveiller les prix des jetons et en fournissant des pools de liquidités, Burrow Cash offre un moyen fiable et pratique pour les utilisateurs d'accéder à de nouveaux jetons, tout en gagnant des récompenses sur leurs jetons existants.






	

	
	
		
			
				Lesquels des services suivants sont des services de staking liquide sur NEAR (réponses multiples) ?
			
		

		
					

		
			Please select 2 correct answers
			
			
			Meta Pool
		
			
			LiNEAR Protocol
		
			
			Stader Labs
		
			
			Rocket Pool
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plateaux de lancement
Meta Yield


Meta Yield est une plateforme de crowdfunding qui s'appuie sur la mise en jeu de liquidités pour fournir un soutien financier et une exposition aux projets web 3.0 construits sur le protocole NEAR. Les bailleurs de fonds s'engagent et verrouillent stNEAR pour soutenir les projets et gagner des jetons des nouveaux projets lancés sur NEAR ou recevoir une baisse NFT. Les projets ne sont récompensés que par les engagements des bailleurs de fonds, et non par les crypto-actifs sous-jacents. Les bailleurs de fonds peuvent récupérer 100 % de leurs jetons NEAR à la fin de la période de blocage, ce qui fait de Meta Yield une plateforme de crowdfunding basée sur des récompenses de staking sans perte.

En tant que bailleur de fonds sur le Launchpad de Meta Yield, vous bénéficiez d'un accès anticipé au projet que vous avez soutenu, de jetons de projet d'une valeur supérieure au prix du marché et de la possibilité de récupérer votre investissement initial en jetons NEAR. Pour réclamer vos jetons de projet et récupérer vos jetons, le processus est simple et comprend quelques étapes simples.

Dans l'ensemble, Meta Yield offre un mécanisme unique de collecte de fonds pour les projets web 3.0 sur NEAR. Il permet aux bailleurs de fonds de soutenir des projets sans perdre leurs jetons mis en jeu et de gagner des récompenses pour les nouveaux projets lancés sur NEAR. Si vous devenez un bailleur de fonds, vous pouvez bénéficier de plusieurs avantages, tels qu'un accès anticipé aux projets, des jetons de projet de plus grande valeur et la possibilité de récupérer votre investissement initial en jetons NEAR.


Meta Bonds, un marché secondaire pour les positions bloquées sur Meta Yield
Meta Bonds est un marché secondaire qui permet aux bailleurs de fonds des campagnes de crowdfunding sur Meta Yield de négocier leurs positions bloquées sous forme d'obligations.

Meta Yield est un protocole de crowdfunding qui utilise stNEAR, un jeton qui génère du rendement en fournissant de la liquidité au protocole Meta Yield. Lorsque les bailleurs de fonds soutiennent un projet sur Meta Yield, ils reçoivent deux reconnaissances de dette sous forme d'obligations : l'une pour leur investissement initial et l'autre pour les jetons de projet qu'ils recevront en échange de leurs récompenses.

La première obligation devient disponible à la fin de la période de blocage, et la seconde peut être réclamée après la période de libération progressive. Pendant cette période, les bailleurs de fonds peuvent investir leurs jetons en les plaçant sur le marché, auquel on peut accéder en visitant le site Web de Meta Bonds à l'adresse metabondsmarket.app.

Meta Bonds permet aux backers de monétiser leurs investissements avant la fin de la période de libération progressive. Cela crée une opportunité pour les backers d'échanger leurs obligations contre d'autres actifs, tels que d'autres jetons ou crypto-monnaies, tout en fournissant de la liquidité au marché.

En créant un marché secondaire pour les positions bloquées, Meta Bonds fournit de la liquidité et des opportunités de négociation, tout en créant une nouvelle voie pour la monétisation des investissements.


NEAR Starter


NEAR Starter est une initiative qui change la donne et qui permet à de nouveaux projets de se construire et de se lancer sur le protocole NEAR. Conçu comme une organisation autonome décentralisée (DAO), NEAR Starter fournit un écosystème complet de soutien aux projets en phase de démarrage. Le Launchpad de NEAR Starter fait partie intégrante de cet écosystème, permettant aux projets de faire une Offre Initiale Décentralisée (OID) et de lever des fonds auprès de la communauté.

En plus de son Launchpad, NEAR Starter s'est également fait un nom en proposant des collections NFT qui permettent aux utilisateurs de farmer $NEARIA, le jeton d'indexation utilisé pour l'échange de projets. Cette approche innovante a contribué à créer une communauté dynamique et engagée autour de NEAR Starter, les utilisateurs participant avec enthousiasme au processus de farming.

Le site NEAR Starter est construit sur le réseau Aurora, qui permet des frais peu élevés et une connectivité transparente à travers Meta Mask. Cela garantit que les utilisateurs peuvent facilement et en toute sécurité participer au Launchpad et aux processus de farming, sans avoir à s'inquiéter de frais excessifs ou d'exigences techniques complexes.

Pour démontrer la puissance de son Launchpad, NEAR Starter a récemment lancé le jeton $NEARIA par le biais d'un IDO, avec un objectif de 24 ETH à collecter. Ce lancement réussi n'est qu'un début pour NEAR Starter, qui continue de soutenir et d'incuber de nouveaux projets sur le protocole NEAR.




Agrégateurs de rendements
Pembrock Finance
​​



Le protocole NEAR fournissant une plateforme robuste pour les applications DeFi, Pembrock se distingue en tant que protocole de leveraged yield farming (culture de rendement élevé) qui utilise de multiples stratégies pour farmer les jetons du protocole NEAR.

Ce qui rend Pembrock unique, c'est qu'il s'adresse à deux types d'utilisateurs : Les prêteurs et les Leveraged Yield farmers (Agriculteurs à rendement élevé). Les prêteurs peuvent gagner un revenu passif en déposant leurs crypto-monnaies dans des coffres-forts, qui financent des pools de liquidités. D'autre part, les Leveraged Yield farmers peuvent maximiser leurs profits en ouvrant une position à rendement élevé. Cela signifie que les utilisateurs peuvent emprunter des fonds supplémentaires à la plateforme, en payant un petit montant d'intérêt sur leurs profits.

Pembrock dispose d'une gamme variée de pools, y compris wNEAR, ETH, PEM, SWEAT, USDC.e, et d'autres monnais disponibles sur l'écosystème NEAR. Que vous soyez un investisseur débutant ou expérimenté, il est facile de prendre position avec Pembrock. Tout ce que vous avez à faire est de visiter leur site et de rechercher de farming ou un prêt dans leurs pools. Grâce à l'interface conviviale de Pembrock, vous pouvez facilement naviguer parmi les pools et choisir celui qui convient le mieux à votre stratégie d'investissement.

Dans l'ensemble, Pembrock est un excellent exemple de la façon dont DeFi révolutionne le secteur financier traditionnel. En utilisant des protocoles décentralisés, Pembrock offre aux utilisateurs la possibilité de gagner des revenus passifs et de maximiser leurs profits grâce à l'agriculture de rendement élevé.


La fin, pour l'instant...
DeFi sur NEAR Protocol est un écosystème qui évolue rapidement et qui offre diverses solutions innovantes aux utilisateurs. En mettant l'accent sur l'évolutivité, l'interopérabilité et l'expérience utilisateur, NEAR Protocol attire de nombreux développeurs et investisseurs qui construisent et investissent dans des projets DeFi sur la plateforme. Au fur et à mesure que l'écosystème continue à se développer et à mûrir, il devrait devenir un acteur important dans le paysage DeFi plus large, offrant des caractéristiques et des avantages uniques à ses utilisateurs.

Ce billet présentait plusieurs projets DeFi sur le protocole NEAR. Chacun de ces projets a des caractéristiques uniques et contribue à la croissance de l'écosystème DeFi sur NEAR. Nous savons que tôt ou tard, cet article devra être réécrit pour inclure les nouvelles et étonnantes applications qui verront le jour.

A bientôt !




	

	
	
		
			
				Lesquels des éléments suivants sont des rampes de lancement dans l'écosystème NEAR ? (réponses multiples)
			
		

		
					

		
			Please select 2 correct answers
			
			
			DuckStarter
		
			
			NEAR Starter
		
			
			Meta Yield
		
			
			Ethereum Launchpad
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Desarrollo de Contratos Inteligentes en Near Usando Rust - Parte 1

El 16 de febrero de 2023 di un taller en la Universidad de Waterloo sobre el desarrollo de contratos inteligentes en Near usando Rust. Disfruté armarlo y pensé que sería divertido presentar también el contenido aquí como una serie de publicaciones de blog. En esta primera publicación, daré una analogía para explicar cómo se parecen el desarrollo de blockchain con un patrón utilizado en aplicaciones web normales, presentaré el ejemplo de contrato inteligente que usaremos a lo largo de esta serie y discutiré algunos principios generales del desarrollo de contratos inteligentes que son exclusivos de blockchain en relación con otros dominios de la programación.
Un Modelo Mental Para Crear Una Aplicación Distribuida (dapp)
El propósito de esta sección es hacer una analogía entre el desarrollo sobre una cadena de bloques (las aplicaciones respaldadas por tecnología de cadena de bloques a menudo se denominan "dapps" en el ámbito) y una tecnología más común para aplicaciones web que puedes haber encontrado antes. Esta analogía puede ser útil al pensar en cómo los usuarios interactúan con los contratos inteligentes.

La idea es que las dapps son muy similares a las aplicaciones web basadas en una “arquitectura sin servidor”. El término "sin servidor" es un poco engañoso porque, por supuesto, los servidores todavía están involucrados, pero la razón del nombre es que el hardware subyacente (es decir, el servidor) que ejecuta el código se abstrae del desarrollador. Esto tiene beneficios sobre otras infraestructuras de computación en la nube en términos de costo y escalabilidad porque solo paga exactamente por los recursos que usa en lugar de pagar para ejecutar una VM que puede permanecer inactiva si el tráfico es bajo o puede dejar de responder si hay demasiado tráfico. Cada vez que un usuario interactúa con la aplicación web, se invoca una nueva instancia de la "función sin servidor" en el backend para atender la solicitud del usuario sin que el desarrollador tenga que pensar exactamente en qué hardware se ejecuta esta función.

Las dapps abstraen el hardware de manera similar. Un contrato inteligente se implementa en la cadena de bloques y se ejecuta en los nodos (servidores) que forman la red de persona - a - persona de esa cadena de bloques. Cuando un usuario interactúa con la dapp, realiza una llamada a la cadena de bloques (una transacción) para ejecutar el contrato inteligente. Cada transacción crea una nueva instancia del contrato inteligente (en el sentido de que no hay un estado en memoria que persista entre transacciones), al igual que con las funciones sin servidor.

A continuación se muestra una imagen tomada directamente del sitio web de Amazon Web Services (AWS) para Lambda (su versión de una opción informática sin servidor).



Es fácil modificar esta imagen para ver cómo el flujo de trabajo en una dapp es similar.



Otra similitud entre la computación sin servidor y los contratos inteligentes es el hecho de que cada transacción tiene un costo. En el caso de AWS se cobra a la cuenta de AWS del desarrollador los recursos consumidos, mientras que en el caso de blockchain se cobra a quien firma la transacción por su ejecución.

Con esta analogía como punto de referencia, analicemos el ejemplo del desarrollo de una dapp que usaremos a lo largo de esta serie.
Nuestro ejemplo: aplicación de chat basada en blockchain
El ejemplo que usaremos a lo largo de esta serie es una aplicación de chat basada en blockchain. Este no es un ejemplo del mundo real, en el sentido de que no existe un buen caso comercial para usar una cadena de bloques pública para chatear (en mi opinión). El hecho de que todos los mensajes sean completamente públicos e incluidos de forma irreversible en un registro permanente es un inconveniente, no una característica. Sin embargo, la razón para elegir este ejemplo es que ilustra varios conceptos importantes en el desarrollo de una dapp y, al mismo tiempo, es lógicamente fácil de seguir para cualquiera que haya usado algo como Facebook, Messenger, Telegram o Signal.

El código de este ejemplo está disponible en mi GitHub. El LÉAME (README) en ese repositorio brinda algunas instrucciones para configurar un entorno de desarrollo para interactuar con el código y una idea básica de cómo usar el contrato. En esta serie de publicaciones nos sumergiremos mucho más profundamente en el código y su funcionamiento.

Para fundamentar la discusión de los principios del desarrollo de contratos inteligentes, aquí hay una descripción general de cómo funciona el contrato de chat.

 	Cada individuo que quiere participar en la red de chat implementa su propia versión del contrato inteligente.
 	Cada instancia del contrato mantiene una lista de cuentas que conoce (contactos, solicitudes de contactos pendientes, etc.). También almacena los mensajes que ha recibido (y algunos metadatos sobre esos mensajes).
 	Para enviar un mensaje a otra persona, primero debe tenerla como “contacto”. Esto funciona como era de esperar: Alice le envía a Bob una solicitud de contacto, si Bob acepta, Alice y Bob se vuelven contactos entre sí, de lo contrario, no son contactos.
 	Cada instancia del contrato tiene un "propietario" que puede enviar mensajes y enviar/aceptar solicitudes de contacto.

Principios del desarrollo de contratos inteligentes
Hay tres conceptos relacionados que quiero enfatizar que son importantes para el desarrollo de contratos inteligentes, pero que pueden no aparecer en el desarrollo de software típico. Ellos son:

 	una mentalidad adversaria
 	economía
 	asegurar invariantes antes de hacer llamadas de contratos cruzados

Una mentalidad adversaria
Lo primero que debe recordar al implementar en una cadena de bloques pública es que cualquier persona en todo el mundo puede interactuar con tu código. Si hay alguna acción delicada que pueda tomar tu contrato inteligente (por ejemplo, al enviar mensajes en el contrato de chat, seguramente no deseas que alguien pueda hacerse pasar por ti), entonces el contrato debe verificar explícitamente la autorización para que solo las cuentas autorizadas puedan realizar con éxito la acción (es por eso que nuestro contrato de chat tiene la propiedad "propietario - owner"). Si tiene algún método que toma entrada de texto, debe validarlo antes de continuar con cualquier lógica comercial porque cualquier usuario aleatorio podría enviar cualquier entrada de texto que desee. De hecho, la idea de una mentalidad contradictoria va aún más allá; un usuario no solo puede enviar una entrada de texto basura, sino que también puede crear una entrada cuidadosamente para desencadenar una vulnerabilidad en su código. La única forma de evitar que esto suceda es no tener tales vulnerabilidades en primer lugar.

De manera similar, la lógica del contrato inteligente a menudo depende de algún protocolo para coordinar diferentes componentes (por ejemplo, el protocolo para agregar contactos en nuestro contrato de chat). ¿Un usuario tiene poder en este protocolo? ¿Qué pasa si no lo siguen correctamente? Estas son preguntas que debes responder al desarrollar un contrato inteligente porque los piratas informáticos intentarán explotar tu contrato.

Para resumir, siempre debes asumir que cualquier entrada externa es bizantina y verificar explícitamente lo contrario antes de continuar. Debes practicar notando qué suposiciones estás haciendo y siempre pensar "¿cómo podría romper esta suposición?", cada vez que te das cuenta de que estás haciendo una.
Economía
La economía de una aplicación web típica es bastante simple. Debe generar suficientes ingresos para cubrir el costo de alojar cualquier servidor que contenga el código y los datos que utiliza su aplicación. Los ingresos que necesita generar pueden provenir de varias fuentes, pero las más comunes son los ingresos publicitarios y las suscripciones pagas de los usuarios.

Para la blockchain, la situación es un poco más complicada porque cada transacción debe pagarse de forma independiente. Los productos de la cadena de bloques más nuevos buscan simplificar esta historia, por ejemplo, Aurora+ proporciona algo así como una "suscripción de cadena de bloques" que permite una cantidad de transacciones de forma gratuita. Pero hasta que esto se convierta en un estándar en el espacio de la cadena de bloques, sigue siendo importante responder a la pregunta "¿quién está pagando por esto?".

A menudo, es el usuario quien paga por cada transacción porque el pago está vinculado a la cuenta de firma (es decir, el pago está vinculado con la identidad/autorización). Un modelo alternativo es utilizar “meta-transacciones” (transacciones dentro de transacciones) para que el pago lo realice el “firmante externo” mientras que la autorización se basa en el “firmante interno”. Así es como funciona Aurora+ por ejemplo. Desafortunadamente, dado que esta no es la forma predeterminada en que operan las transacciones de blockchain, se requiere un trabajo adicional por parte del desarrollador para que esto suceda.

Para propósito de nuestro ejemplo de aplicación de chat, seguiremos el camino de menor dificultad y cada usuario tendrá que pagar los costos en los que incurra por su uso. Después de haber tomado esta decisión, debemos revisar qué posibles costos podría haber y asegurarnos de que se cubran adecuadamente. Por ejemplo, en Near, el pago del almacenamiento se maneja mediante la "participación de almacenamiento". Esencialmente, esto significa que cada cuenta tiene parte de su saldo bloqueado según la cantidad de almacenamiento que esté utilizando. Esto es relevante en nuestro contrato de chat porque almacena los mensajes recibidos de otros usuarios, por lo tanto, debemos asegurarnos de que esos otros usuarios cubran el costo de participación de almacenamiento adjuntando un depósito suficiente con su mensaje. Del mismo modo, las solicitudes de contacto crean una entrada en el almacenamiento, por lo que también deben venir con un depósito. Si no aplicáramos estos requisitos de depósito, los usuarios podrían robarse dinero unos a otros, enviando muchos mensajes y bloqueando todo el saldo de la víctima (observe cómo esto se relaciona con la mentalidad contradictoria anterior).

En resumen, al diseñar una dapp, siempre es importante pensar en los costos que implicará y cómo se pagarán, ya sea agregando revisiones extras a los depósitos o utilizando meta-transacciones.
Asegurar invariantes antes de hacer llamadas de contratos cruzados
Este último punto es sutil. En una aplicación típica, todo el código está vinculado al mismo binario. Cuando llamas a una función en una biblioteca, esto generalmente no activa ninguna comunicación, sino que simplemente agrega un nuevo marco en la pila y ejecuta algún código de otra parte del binario. En una configuración de ejecución dentro de la cadena de bloques, las cosas son un poco diferentes.

Hacer una llamada a otro contrato se parece más a realizar una llamada a un proceso completamente diferente que a llamar a una biblioteca. Una vez más, debemos aplicar una mentalidad adversaria y darnos cuenta de que no tenemos idea de lo que podría estar haciendo ese otro proceso; de hecho, podría estar tratando de hacer algo deliberadamente malicioso. Un vector de ataque común es hacer que el otro proceso vuelva a llamar a nuestro contrato y lo explote porque nuestro contrato no esperaba que entrara una nueva llamada mientras esperaba una respuesta a la llamada que inició. Esto se llama un "ataque de reentrada" y fue la fuente de uno de los hacks más famosos en Ethereum, el que resultó en la creación de "Ethereum Classic" (Ethereum classic rechazó la "bifurcación dura" que fue la respuesta de la Fundación Ethereum a el hackeo).

En Near, este problema es aún más pronunciado porque existe la cuestión adicional de la atomicidad. En la máquina virtual de Ethereum (EVM), cada transacción es "atómica" en el sentido de que todas las acciones como resultado de la transacción se comprometen con el estado de la cadena de bloques o ninguna de ellas lo hace (toda la transacción se "revierte"). Esto significa que un ataque de reingreso se puede frustrar mediante el uso de una reversión; todo lo sucedido se deshará, manteniendo el contrato a salvo. Este patrón incluso se incluye en el ejemplo de Mutex en la documentación oficial de Solidity. Sin embargo, en el tiempo de ejecución de Near, la ejecución de los contratos es independiente entre sí; no son atómicos. Entonces, si una transacción hace que el contrato A llame al contrato B, y B encuentra un error, los cambios de estado que ocurrieron en A permanecerán.

Esto ha sido mucha historia y teoría, pero ¿cuál es la conclusión práctica? El punto es que debe asegurarse de que tu contrato esté en “buen estado” cuando realizas una llamada a otro contrato. Es decir, si hay invariantes en los que se basa la lógica de tu contrato, entonces debe ser verificado que sean correctos en el momento en que se realiza la llamada. Como ejemplo simple, supongamos que tenemos un contrato con una función de transferencia. La invariante a mantener es que los tokens no se crean ni se destruyen en una transferencia. Si por alguna razón fuera necesario realizar una llamada a otro contrato durante la transferencia, sería incorrecto debitar una cuenta y luego realizar la llamada sin acreditar la otra primero. Esto se debe a que la invariante de que los tokens no se destruyen se rompería cuando se realizara la llamada externa y esto podría ser explotable. Un ejemplo en este sentido también se incluye en la documentación de Near.
Resumen
Para concluir, en esta publicación de blog presentamos una nueva serie de publicaciones que brindan una introducción al desarrollo de contratos inteligentes en Near usando Rust. Aquí discutimos el ejemplo de contrato de chat que usaremos a lo largo de la serie, así como algunos principios generales a tener en cuenta al desarrollar aplicaciones basadas en blockchain. En la próxima publicación, profundizaremos más en el código para analizar los detalles técnicos de cómo se implementa el contrato. Esto servirá como un ejemplo del Rust SDK de Near, ilustrando conceptos que se aplicarán a todo tipo de contratos del mundo real que desees crear.

Si estás disfrutando de esta serie de publicaciones de blog, ponte en contacto con nosotros en la consultoría Type-Driven. Nos complace brindar servicios de desarrollo de software para dapps, así como materiales de capacitación para tus propios ingenieros.

 

### Tokenomics 101 para iniciar na Web3

Tudo bem, então você decidiu construir seu próprio dApp e entrar no espaço web3. Parabéns por dar este passo. No entanto, antes de lançar seu aplicativo revolucionário, você precisa entender um dos princípios básicos da web3 - tokenomics. Tokenomics é a junção de “token” e “economia” – o que é bastante autoexplicativo. Portanto, neste artigo, você vai aprender tudo o que precisa saber sobre tokennomics.
O que é Tokenomics?
Tokenomics é um termo um tanto vago, mas inclui vários fatores como oferta e demanda, emissão de tokens, funções de queima, etc. Simplificando, é uma soma total de funções e fatores econômicos que afetam seus tokens de várias maneiras. Um token pertencente a um projeto com tokenomics sólido é considerado um investimento mais atrativo. Então, sem mais delongas, vamos dar uma olhada nos diferentes fatores.
Fator 1: Oferta e Demanda
A equação de oferta e demanda é um dos fatores mais críticos que determinam o tokenomics. O gráfico a seguir é um dos gráficos mais importantes da economia – o gráfico de oferta e demanda.



O gráfico acima mostra a relação entre a oferta e a demanda de uma determinada mercadoria. O preço subsequente de uma mercadoria é determinado por sua demanda no mercado e pela quantidade que já está disponível.

A escassez de um item (ou seja, a diminuição da oferta) é frequentemente considerado um fator de importância na avaliação do produto. Pense nos preços inflados que as máquinas PS5 estavam sendo vendidas no mercado de segunda mão devido à sua escassez. No entanto, só porque um item é escasso não significa que seja valioso. Você pode tirar uma selfie sua – o que será um item único, mas isso não significa que você receberá milhões de dólares por isso, certo? Tem que haver demanda no mercado. No ponto de equilíbrio, os gráficos de demanda e oferta se equilibram perfeitamente.

Há duas coisas que podemos concluir a partir do gráfico:

 	Quando a oferta de um ativo é alta, mas a demanda é baixa, a tendência será a desvalorização do produto.
 	Se a demanda for alta, mas a oferta for baixa, a tendência será o incremento do valor do produto.

Oferta e demanda em tokens

Ao tratar-se de Bitcoin, um dos momentos de criação de valor mais significativos no protocolo são os halvings (redução à metade) periódicos que ocorrem a cada quatro anos. Bitcoin tem uma oferta fixa total de 21 milhões. Os mineradores mineram Bitcoin para obter uma recompensa em bloco para liberar o BTC no suprimento circulante.

A cada quatro anos, o Bitcoin passa pelo halving, o que reduz a recompensa do bloco pela metade – reduzindo assim a quantidade de BTC que entra no suprimento circulante. Satoshi Nakamoto adicionou propositalmente essa mecânica para garantir a diminuição da oferta com o passar do tempo e, com sorte, aumentar a avaliação geral do preço.

Vários tokens como o BNB possuem um mecanismo de queima artificial. Queimar significa que você envia os tokens para uma carteira cujas chaves privadas não pertencem a ninguém. Ao fazer isso, você está removendo esses tokens de circulação – em outras palavras, queimando tokens.

Existem também certos tokens que são inflacionários. Por exemplo, a EOS tem uma taxa de inflação anual de 1%. Esse 1% é usado para pagar os produtores do bloco. A ideia era que o sistema EOS ficaria tão ocupado com o tempo que o aumento da oferta não afetaria a demanda.
Fator 2: Distribuição de Token 
Um protocolo pode distribuir tokens por meio de uma Fair-launch ou uma Pre-mine. Quando uma Fair-launch acontece, todos têm uma oportunidade justa de adquirir os tokens. O lançamento do Bitcoin foi assim, pois todos tiveram a mesma oportunidade exata de adquirir o BTC. Não houve pré-venda, nem rodada de investidores privados. Se você quiser Bitcoin, você teria que minerar desde zero.

No entanto, os Fair launches são muito raros hoje em dia. A partir da era ICO, os tokens foram lançados por meio de um método chamado pre-mine. Em uma pre-mine, os tokens são parcialmente ou totalmente criados e depois distribuídos para várias partes, como capitalistas de risco, investidores, etc., antes de serem divulgados ao público. Obviamente, a pré-mineração é injusta, pois um usuário médio não está recebendo a primeira fatia do bolo. No entanto, no cenário atual, é necessário fazê-lo, pois os projetos precisam dessa injeção inicial de liquidez de capitalistas de risco e formadores de mercado. Eles precisam de liquidez para pagar pelo trabalho, desenvolvimento, construção do ecossistema, etc.

Dito isso, é crucial ver quantos tokens estão sendo distribuídos para essas partes. Por exemplo, se uma equipe reservasse 5% dos tokens para si mesma, estaria tudo bem. Afinal, eles precisam de dinheiro para financiar sua equipe. No entanto, se eles reservarem 50% para si mesmos, significaria uma potencial alerta vermelha




	

	
	
		
			
				Quando um ativo tem baixa oferta e alta demanda, isso significa que:
			
		

		
					

		
			
			
			
			O preço deveria subir
		
			
			O preço deveria baixar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Fator 3: Staking
Em sua essência, um bom tokenomics deve apresentar diferentes métodos para incentivar aos usuários. Segurar (hold) seus tokens. Uma das maneiras mais legais de fazer isso é garantir ao titular alguma forma de ROI (retorno do investimento) garantido. Muitos projetos fazem isso com um mecanismo de staking.

A ideia é simples – tranque seus tokens no protocolo e ganhe recompensas. Por exemplo, se você possui tokens Curve (CRV), pode apostá-los na Convex Finance como cvxCRV e ganhar ~30% vAPR. Os aplicativos DeFi permitem que você aposte vários tokens que podem ajudá-lo a obter rendimento.

O staking também permite que os usuários bloqueiem seu token, tornando-os automaticamente detentores a longo prazo. Afinal, você não pode vender um token que trancou firmemente no ecossistema, certo?

Agora, a próxima questão a considerar aqui é a seguinte:
Como você pode incentivar seus usuários a fazer um Staking com suas moedas voluntariamente por um longo prazo? Bem, projetos como o Curve têm uma oferta simples de juros compostos que funciona muito bem para eles. Quanto mais tempo você mantiver seu CRV trancado, mais recompensas receberá.

O staking também lhe dá direitos de governança em alguns projetos. Fazer staking com o token nativo permite que você se torne um membro do protocolo DAO e vote em várias decisões. Por exemplo, no Curve você pode fazer staking com seu CRV e veCRV (o token de votação). Com quanto mais CRV você fizer stake, mais veCRV você obterá. O veCRV não tem nenhum valor, exceto para ser usado como um token de votação dentro da DAO.
Fator 4: Cronogramas de Aquisição
No Fator 2, discutimos como a pré-mineração permite que os projetos aloquem tokens específicos para investidores privados e VCs. No entanto, e se essas pessoas lançarem imediatamente seus tokens ao mercado aberto? Isso não vai fazer bem ao seu projeto, certo?

Então, o que você pode fazer aqui é usar vários cronogramas de aquisição para suas alocações. A aquisição permite que você bloqueie tokens distribuídos por um determinado tempo (também conhecido como período de aquisição). Isso aumenta o tempo que você tem que esperar antes de pôr as mãos nos tokens.

Agora, antes de prosseguirmos, vamos falar sobre o “Cliff”. (Tempo que ocorre entre o início do período de aquisição até a transferência do primeiro conjunto de tokens). Quando se trata de aquisição, o precipício é um bloqueio de duração que é colocado nos tokens adquiridos antes do início do cronograma de aquisição. Existem dois tipos de aquisição que você pode fazer:

 	Aquisição linear: (Linear Vesting) A distribuição de tokens é feita de forma consistente e em partes iguais dentro de um determinado período de tempo.
 	Aquisição distorcida: (Aquisição Distorcida) A distribuição de tokens pode variar dentro de uma variedade de períodos de tempo.

Criando seu próprio token – Maneiras mais práticas
Então, agora que você sabe o básico, vamos criar seu token. Você pode usar este link: sala de jogos de tokens, para testar várias estruturas de token.



Como você pode ver, você coloca o nome do token, símbolo, suprimento total e casas decimais.

Logo abaixo, você encontra uma lista de alocações de token. Dependendo de quantos consultores e VCs seu projeto tiver, você pode atribuir as alocações apropriadamente. No entanto, apenas uma palavra de conselho. Não exagere nas alocações de consultores. Mantenha uma maioria significativa para sua comunidade.

Por exemplo:

 	10% para a equipe
 	10% Para os primeiros investidores
 	0.25%-0.5% Para cada consultor
 	O restante para a comunidade




	

	
	
		
			
				Que tipo de aquisição é essa? “A distribuição de tokens é feita de forma consistente e em partes iguais dentro de um determinado período de tempo”
			
		

		
					

		
			
			
			
			Linear
		
			
			Distorcida
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusão
Ao construir seu protocolo web3, um tokenomics robusto é crucial para o sucesso a longo prazo do seu projeto. Neste artigo, falamos sobre quatro recursos que você pode integrar ao seu tokenomics para evitar o Dumping e incentivar os usuários a manter seus tokens e acumular mais.




	

	
	
		
			
				Durante a distribuição de tokens, a maior parte desses tokens deve ser designada para:
			
		

		
					

		
			
			
			
			Equipe
		
			
			VCs
		
			
			Comunidade
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Apa itu FastAuth?

Pada bulan Maret lalu, NEAR Protocol secara resmi mengumumkan peluncuran dari Blockchain Operating System (BOS). Ide besar di baliknya adalah untuk menciptakan cara masuk yang ideal ke Open Web dan menjembatani kesenjangan antara Web2 dan Web3. Operasi Sistem Blockchain NEAR juga memperlihatkan pengenalan dari beberapa fitur baru. Salah satu fitur pertama dan paling mengesankan yang diperkenalkan adalah FastAuth.

Pada artikel kali ini, kita akan melihat lebih lanjut terkait FastAuth, memahami apa pentingnya, bagaimana cara kerjanya, serta apa yang akan terjadi untuk kedepannya. Langsung saja, yuk mari kita mulai!
Apa itu Blockchain Operating System?
Sebelum kita beralih ke FastAuth, mari kita pahami sedikit tentang Blockchain Operating System. Saat ini, dunia Web2 dan Web3 sangatlah terfragmentasi. Web2 benar-benar sangat terpusat, dengan setiap akun yang dikontrol oleh satu entitas saja. Sementara itu, Web3 terfragmentasi karena setiap blockchain terisolasi dan terpisah dari yang lain. Sistem Operasi Blockchain NEAR ini mengatasi masalah ini dengan menawarkan solusi untuk mendapatkan pengalaman dengan layanan seperti pada umumnya yakni dengan identitas tunggal, data yang sepenuhnya dikendalikan oleh pengguna, dan aset yang dikendalikan juga oleh pengguna.

Blockchain Operating System adalah sistem operasi baru yang dirancang untuk web yang lebih terbuka. Sistem ini aman, sangat terdesentralisasi, mudah untuk dkelola, dikembangkan, bersifat open source, dan dapat diakses oleh semua orang. Ini diciptakan sebagai alternatif open-source terhadap raksasa teknologi pada umumnya seperti Apple, Amazon, Google, Facebook, dan Microsoft dan mengeliminasi kompleksitas yang biasanya terkait dengan dunia Web3. BOS dapat bekerja dengan backend blockchain atau Web2 apa pun, memungkinkan akses ke berbagai gerbang. Para pengguna akan mendapatkan pengalaman yang kontinu melalui Blockchain Operating System, mirip dengan menggunakan aplikasi tunggal, bahkan jika pengguna harus beralih antara chain atau aplikasi yang berbeda.

BOS juga menyederhanakan pengembangan dari blockchain, memungkinkan pengembang untuk membangun di setiap chain, membuat kode dalam bahasa yang dikenal, dan menciptakan aplikasi inovatif yang mudah didistribusikan dan ditemukan. Ini memungkinkan pengguna untuk terhubung dengan ekosistem komunitas, orang, dan aplikasi yang berkembang sambil tetap memiliki kontrol penuh atas data mereka. Selain itu, pengguna tidak memerlukan kripto untuk memulai terlebih dahulu, sehingga Blockchain Operating System membuka sejumlah sumber pendapatan dan kemampuan tanpa perlu pengalaman Web 3 yang mumpuni sebelumnya.
Apa itu FastAuth?
FastAuth merupakan fitur luar biasa yang diperkenalkan dengan Blockchain Operating System yang memungkinkan pengguna untuk cepat dan mudah membuat akun yang dapat digunakan di semua aplikasi atau situs web yang bisa diintegrasikan dengan Blockchain Operating System. FastAuth menempatkan penekanan pada pengalaman pengguna dan menciptakan pengalaman onboarding tipe Web2 yang familiar yang memungkinkan pengguna untuk membuat akun gratis dengan menggunakan sarana pada umumnya seperti alamat email, prompt telepon, dan bahkan biometrik. Ini memungkinkan pengguna untuk berinteraksi dengan aplikasi dengan cepat dan memungkinkan mereka untuk mengautentikasi ulang ke aplikasi menggunakan perangkat yang sama atau berbeda.

Dengan FastAuth, pengguna dapat membuat akun untuk setiap situs web atau aplikasi pada Blockchain Operating System tanpa memerlukan kata sandi baru atau harus membeli kripto. FastAuth juga bagus untuk pengembang, memberikan cara yang cepat dan mudah bagi mereka untuk mendapatkan pengguna untuk mencoba aplikasi dan komponennya yang baru. Ini membantu meningkatkan adopsi secara signifikan dan membawa jutaan pengguna Web2 ke dalam ekosistem Web3 dengan menurunkan hambatan masuk.
Bagaimana FastAuth Bekerja?
Pengenalan FastAuth telah membantu mengatasi salah satu tantangan terbesar dalam onboarding pengguna baru ke ekosistem Web3. Pengguna baru dapat membuat akun Layanan Operasi Blockchain secepat membuat akun seperti biasanya, sementara pengembang dapat menyampaikan aplikasi, pengalaman, dan komponen Web3 mereka dengan cara yang lebih mulus dari sebelumnya. Mari kita lihat bagaimana FastAuth menjembatani kesenjangan antara Web2 dan Web3 dan meningkatkan adopsi Web3 di kalangan pengguna Web2.
Proses Onboarding Cepat dan Lancar dan Pemulihan via Email
Salah satu tantangan terbesar saat onboarding pengguna di Web3 adalah kompleksitas proses onboarding dan kebutuhan pengguna untuk mengingat seed phrase yang rumit. Sebagian besar pengguna terbiasa dengan metode otentikasi terpusat tradisional seperti masuk dengan Google. Oleh karena itu, untuk bisa menggunakan dan terbiasa dengan seed phrase yang kompleks dapat cukup menakutkan dan menciptakan hambatan untuk masuk yang signifikan. Hal ini membuat sulit bagi para pengguna baru untuk diperkenalkan ke dalam ekosistem Web3.

Menggabungkan FastAuth dengan pemulihan email terdesentralisasi menghilangkan kebutuhan untuk mengingat seed phrase yang rumit atau aplikasi dompet dari pihak ketiga. Pengguna dapat dengan mudah memulihkan akun menggunakan proses "Single Sign-On" dengan email yang mereka gunakan selama proses registrasi. FastAuth menggunakan "Multi-Party Computation" untuk mendesentralisasi proses pemulihan akun, membuka jalan bagi adopsi massal melalui sistem pemulihan akun yang mudah, aman, dan terdesentralisasi.

Dengan demikian, FastAuth mampu mengatasi beberapa aspek yang paling menantang dalam onboarding pengguna baru ke dalam ekosistem Web3. Pengguna dapat membuat akun Blockchain Operating System lebih cepat daripada membuat akun Google atau Facebook tradisional. Pada saat yang sama, pengembang dapat menyampaikan aplikasi, pengalaman, dan komponen Web3 ke pengguna dengan cara yang lancar.




	

	
	
		
			
				Apa itu FastAuth?
			
		

		
					

		
			
			
			
			Solusi cepat untuk proses onboarding yang cepat ke Sistem Operasi Blockchain
		
			
			OS baru untuk open web
		
			
			Blockchain protokol baru
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tanpa Ada Aplikasi Pihak Ketiga
FastAuth juga menghilangkan kebutuhan untuk mengunggah dan mengunduh aplikasi dari pihak ketiga. Hal ini karena menciptakan pengalaman fokus pada pengguna yang lancar, membuat open web dapat diakses oleh semua orang secara instan, membersihkan jalan bagi adopsi mainstream. Setiap pengembang di Blockchain Operating System dapat memanfaatkan pengalaman pengguna yang ramah FastAuth dan mendapatkan pengguna di aplikasi mereka.
Tidak Membutuhkan Kripto Saat Membuat Akun
Hingga saat ini, pengguna yang ingin menjelajahi dan berinteraksi dengan aplikasi di Web3 harus memiliki atau memperoleh kripto untuk bisa memulai. FastAuth memungkinkan pengguna untuk langsung mengakses ekosistem Web3 tanpa harus repot menyiapkan kripto. Ini sangat menguntungkan untuk semua pengguna, termasuk end user, pengembang, dan perusahaan. FastAuth menggunakan Akun NEAR dengan saldo Nol dan Transaksi Meta, dimana ini memungkinkan pengguna dapat mendaftarkan akun mereka secara gratis. Ini juga menguntungkan bagi pengembang karena Transaksi Meta dipasangkan dengan relayers, memungkinkan interaksi awal tanpa memerlukan $NEAR.
Siapa yang Bisa Menggunakan FastAuth?
FastAuth merupalan solusi yang ideal bagi pengembang, end user, dan perusahaan. Mari kita lihat bagaimana masing-masing bisa mendapat manfaat dari FastAuth.

Pengembang (Developer)

Berkat pengalaman onboarding yang mudah dengan menggunakan FastAuth, pengembang dapat meningkatkan tingkat konversi pengguna untuk bisa mencoba aplikasi dan komponen yang mereka buat. Ini juga dapat memperluas basis pengguna aplikasi dengan memberikan eksposur mainstream yang lebih besar.

Perusahaan

FastAuth memungkinkan perusahaan untuk dengan mudah mengintegrasikan Web3 dan kripto ke dalam bisnis mereka hanya dengan beberapa baris kode. Bisnis dapat dengan mudah memperkenalkan pengguna ke dalam komunitas dan pengalaman yang kuat yang mudah diakses, terdesentralisasi, dan sangat aman.

Pengguna (End User)

Melalui FastAuth, pengguna dapat membuat akun mereka hanya dalam hitungan detik, memungkinkan mereka untuk memulai dengan Web3 dengan cepat dan lancar.




	

	
	
		
			
				Untuk siapa FastAuth dibuat?
			
		

		
					

		
			
			
			
			Developer (pengembang)
		
			
			Perusahaan
		
			
			Pengguna
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Penutup: Masa Depan
FastAuth memang baru saja diluncurkan, dan ada beberapa fitur dan upgrade lain yang sedang dalam pengembangan. Dalam jangka panjang, FastAuth tentu akan menjadi lebih adaptif, menawarkan pengguna dan pengembang kemampuan untuk mengelola izin dengan cara yang sama seperti di Web2. Ini akan memungkinkan pengguna untuk memilih aplikasi yang mereka ingin akses dan memberi otorisasi mereka tanpa harus melalui proses otentikasi baru setiap kali.

· Kompatibilitas multi-chain

· Desentralisasi MPC tambahan

· Otentikasi dua factor

· Memperluas relai dan FastAuth ke gateway di luar NEAR.

Jika kamu ingin mempelajari lebih lanjut tentang fitur FastAuth kedepan beserta pengembangannya, silakan kunjungi near.org untuk informasi lebih dalam. Jika kamu ingin mencoba FastAuth sendiri, kamu dapat membuat akun di https://near.org/signup dan kemudian menggunakan akun tersebut untuk masuk ke NEAR dari mana saja.
Kesimpulan
FastAuth merupakan fitur hebat yang memungkinkan pengguna untuk cepat dan mudah membuat akun yang dapat digunakan di semua aplikasi atau situs web yang dapat diintegrasikan dengan Blockchain Operating System. Fitur ini membantu menjembatani kesenjangan antara Web2 dan Web3, meningkatkan adopsi Web3 di kalangan pengguna Web2, dan menyederhanakan proses onboarding pengguna baru ke dalam ekosistem Web3. Dalam jangka pendek, FastAuth memperkenalkan fitur pemulihan email terdesentralisasi dan dukungan untuk Akun dengan Nol Saldo NEAR dan Transaksi Meta. Dalam jangka panjang, FastAuth akan menjadi lebih adaptif, memungkinkan pengguna dan pengembang untuk mengelola izin dengan cara yang sama seperti di Web2.




	

	
	
		
			
				Apa tantangan terbesar dalam meng-onboarding pengguna di Web3?
			
		

		
					

		
			
			
			
			Proses / pengalaman onboarding yang sulit
		
			
			Password yang Panjang atau seed phrase
		
			
			Membutuhkan sejumlah kripto untuk bisa mengakses Web3
		
			
			Semua pernyataan benar
		
	
		

		
		
			
				Correct!
				Wrong!

### Tìm hiểu về FastAuth

Vào tháng 3 vừa rồi, NEAR Protocol đã cho ra mắt Hệ điều hành chuỗi khối (Blockchain Operating System - BOS). Ý tưởng đằng sau của BOS là việc thu hẹp khoảng cách giữa Web2 và Web3 từ đó tạo ra một cánh cổng lý tưởng đưa người dùng mới tới với thế giới Web mở. Hệ điều hành chuỗi khối của NEAR cũng đã giới thiệu một số tính năng mới. Một trong những tính năng đầu tiên và được đánh giá cao nhất là FastAuth.

Trong bài viết này, chúng ta sẽ cùng tìm hiểu chi tiết về FastAuth, hiểu được tầm quan trọng của tính năng này, cách hoạt động của nó và những hướng phát triển trong tương lai. Hãy cùng bắt đầu thôi nào!
Hệ điều hành chuỗi khối là gì?
Trước khi tìm hiểu về FastAuth, chúng ta cần hiểu về khái niệm Hệ điều hành chuỗi khối. Ngày nay thế giới Web2 và Web3 đang thực sự bị phân mảnh. Web2 có tính tập trung cao, mỗi tài khoản trong hệ thống web2 sẽ bị kiểm soát bởi một thực thể duy nhất. Trong khi đó, Web3 bị phân mảnh bởi mỗi một chuỗi khối đều bị cô lập và không có sự kết nối với các chuỗi khối khác. Hệ điều hành chuỗi khối của NEAR giải quyết được vấn đề phân mảnh này bằng cách cung cấp giải pháp giúp người dùng có thể trải nghiệm các dịch vụ với một danh tính duy nhất, quyền kiểm soát dữ liệu cũng như tài sản cũng hoàn toàn thuộc về người dùng.

Hệ điều hành chuỗi khối là một hệ điều hành mới được thiết kế cho một web “mở” hơn. Hệ thống này có đặc điểm là an toàn, có tính phi tập trung cao, dễ dàng tích hợp, phát triển, mã nguồn mở và bất cứ ai cũng có thể truy cập. Nó được tạo ra như một giải pháp mã nguồn mở thay thế cho những người khổng lồ trong giới công nghệ như Apple, Amazon, Google, Facebook, Microsoft và loại bỏ được sự phức tạp thường gặp khi mới tiếp cận với không gian Web3. Hệ điều hành chuỗi khối hoạt động với bất kỳ chuỗi khối hay các hệ thống backend Web2 nào, cung cấp nhiều cổng kết nối để người dùng có thể tương tác. Người dùng sẽ có được trải nghiệm liền mạch tương tự như khi sử dụng một ứng dụng duy nhất, ngay cả khi họ phải chuyển đổi giữa các chuỗi khối hoặc ứng dụng khác nhau.

Hệ điều hành chuỗi khối cũng giúp đơn giản hóa công việc của các nhà phát triển trên bất cứ chuỗi khối nào, bằng cách sử dụng những ngôn ngữ lập trình quen thuộc và tạo ra những ứng dụng sáng tạo đồng thời dễ dàng phân phối và giới thiệu tới người dùng. Điều này cho phép người dùng kết nối với hệ sinh thái liên tục phát triển của cộng đồng, con người và các ứng dụng trong khi vẫn duy trì được toàn quyền kiểm soát dữ liệu của mình. Ngoài ra, người dùng không cần có bất kỳ loại tiền mã hóa nào để bắt đầu trải nghiệm. Hệ điều hành chuỗi khối sẽ mang tới rất nhiều dòng doanh thu và tiềm năng trong công việc, mà không đòi hỏi người dùng phải có sẵn kinh nghiệm Web3 trước đó.
FastAuth là gì?
FastAuth là một tính năng vô cùng mạnh mẽ được giới thiệu cùng với Hệ điều hành chuỗi khối, cho phép người dùng tạo tài khoản nhanh chóng và sử dụng bất kỳ ứng dụng hoặc trang web nào có tích hợp với Hệ điều hành này một cách vô cùng dễ dàng. FastAuth tập trung vào việc nâng cao trải nghiệm người dùng, mang tới cho họ cảm giác quen thuộc tương tự như các ứng dụng Web2 truyền thống. Người dùng có thể tạo tài khoản miễn phí bằng các phương tiện truyền thống như địa chỉ email, lời nhắc trên điện thoại và thậm chí là với sinh trắc học. Điều này giúp người dùng tương tác với các ứng dụng một cách nhanh chóng và dễ dàng thực hiện các bước xác thực trên một hoặc nhiều thiết bị.

Với FastAuth, người dùng có thể tạo tài khoản cho bất kỳ trang web hoặc ứng dụng nào trên Hệ điều hành chuỗi khối mà không yêu cầu mật khẩu mới hoặc phải sở hữu tiền mã hóa. FastAuth cũng rất tuyệt vời đối với các nhà phát triển, mang đến cho họ một giải pháp nhanh chóng và dễ dàng khiến người dùng thử nghiệm các ứng dụng và tính năng mới. Bằng những cách giảm rào cản gia nhập này, FastAuth sẽ giúp cải thiện đáng kể mức độ phổ biến và đưa hàng triệu người dùng Web2 đến với hệ sinh thái Web3.
FastAuth hoạt động như thế nào?
Sự ra đời của FastAuth đã giúp giải quyết một trong những thách thức lớn nhất trong việc đưa người dùng mới vào hệ sinh thái Web3. Người dùng mới có thể thiết lập tài khoản Dịch vụ điều hành chuỗi khối nhanh chóng tương tự như khi tạo một tài khoản ở các ứng dụng truyền thống. Các nhà phát triển cũng có thể cung cấp các ứng dụng, trải nghiệm và các tính năng Web3 của họ một cách liền mạch và mượt mà. Sau đây, chúng ta sẽ cùng tìm hiểu xem làm thế nào FastAuth thu hẹp khoảng cách giữa Web2 và Web3, đồng thời cải thiện việc sử dụng Web3 của những người dùng tới từ Web2.
Quá trình đưa người dùng mới tới Web3 nhanh chóng và liền mạch & Tính năng khôi phục qua Email
Một trong những thách thức lớn nhất khi giới thiệu người dùng mới tới không gian Web3 là sự phức tạp của quy trình onboard và người dùng cần phải nhớ các cụm từ bí mật phức tạp. Hầu hết người dùng đã quen với các phương pháp xác thực tập trung truyền thống như đăng nhập bằng Google. Do đó, việc sử dụng và làm quen với các cụm từ bí mật phức tạp có thể khá khó khăn và tạo ra một rào cản cho người dùng mới.

Việc kết hợp FastAuth với phục hồi email phi tập trung sẽ giúp người dùng không cần phải nhớ các cụm từ bí mật hoặc các ứng dụng ví của bên thứ ba. Người dùng có thể chỉ cần khôi phục tài khoản bằng quy trình “Đăng nhập một lần” bằng email mà họ đã sử dụng trong quá trình đăng ký. FastAuth sử dụng công nghệ “Tính toán đa bên” để phi tập trung hóa quy trình khôi phục tài khoản, tăng cường sự phổ biến của công nghệ web3 thông qua một hệ thống khôi phục tài khoản dễ dàng, an toàn và phi tập trung.

Do đó, FastAuth có thể giải quyết một số khía cạnh thách thức nhất khi đưa người dùng mới vào hệ sinh thái Web3. Người dùng có thể thiết lập tài khoản trên Hệ điều hành chuỗi khối nhanh hơn so với việc tạo tài khoản Google hoặc Facebook truyền thống. Đồng thời, các nhà phát triển có thể cung cấp các ứng dụng, trải nghiệm và các tính năng Web3 cho người dùng một cách liền mạch.




	

	
	
		
			
				FastAuth là gì?
			
		

		
					

		
			
			
			
			Một giải pháp liền mạch giúp nhanh chóng đưa người dùng mới tới Hệ điều hành chuỗi khối
		
			
			Một hệ điều hành mới cho Web mở
		
			
			Một giao thức chuỗi khối mới
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nói không với ứng dụng bên thứ ba
FastAuth cũng loại bỏ nhu cầu phải tải xuống và cài đặt các ứng dụng của bên thứ ba. Vì nó tạo ra trải nghiệm liền mạch, tập trung vào người dùng, giúp mọi người có thể truy cập web mở ngay lập tức, mở đường cho việc áp dụng web3 một cách chính thống. Bất kỳ nhà phát triển nào trên Hệ điều hành chuỗi khối đều có thể tận dụng trải nghiệm thân thiện với người dùng của FastAuth và thu hút người dùng tới với ứng dụng của họ.
Không cần tiền mã hóa khi tạo tài khoản
Cho đến nay, người dùng muốn khám phá và tương tác với các ứng dụng Web3 sẽ cần giữ hoặc mua tiền mã hóa trước khi bắt đầu. FastAuth cho phép người dùng truy cập trực tiếp vào hệ sinh thái Web3 mà không cần phải có sẵn tiền mã hóa. Điều này rất có lợi cho tất cả người dùng, bao gồm người dùng cuối, nhà phát triển và doanh nghiệp. FastAuth sử dụng Tài khoản “số dư bằng không” và giao dịch meta của NEAR, cho phép người dùng đăng ký tài khoản miễn phí. Điều này cũng thuận lợi cho các nhà phát triển vì giao dịch meta được ghép nối với các hệ thống chuyển tiếp, cho phép các tương tác ban đầu được thực hiện mà không cần sở hữu NEAR.
Ai có thể sử dụng FastAuth?
FastAuth là một giải pháp lý tưởng cho các nhà phát triển, người dùng cuối và các doanh nghiệp. Sau đây là những lợi ích mà những nhóm người dùng trên sẽ nhận được từ FastAuth.
Các nhà phát triển
Nhờ trải nghiệm tích hợp người dùng một cách tối ưu của FastAuth, các nhà phát triển có thể tăng tỷ lệ chuyển đổi cho người dùng thử nghiệm ứng dụng của họ. Nó cũng có thể mở rộng tập người dùng của ứng dụng bằng việc mang ứng dụng tiếp cận tới nhiều nền tảng chính thống hơn.
Doanh nghiệp
FastAuth cho phép doanh nghiệp dễ dàng tích hợp công nghệ Web3 và tiền mã hóa vào hoạt động kinh doanh của họ chỉ với một vài dòng mã. Các doanh nghiệp có thể dễ dàng đưa người dùng tới một cộng đồng vững mạnh và mang tới trải nghiệm dễ dàng tiếp cận, phi tập trung và bảo mật cao.
Người dùng cuối
Thông qua FastAuth, người dùng có thể thiết lập tài khoản mà họ toàn quyền sở hữu chỉ trong vài giây, từ đó giúp họ bắt đầu tiếp cận với Web3 một cách nhanh chóng và liền mạch.




	

	
	
		
			
				FastAuth được tạo ra nhằm phục vụ ai?
			
		

		
					

		
			
			
			
			Các nhà phát triển
		
			
			Doanh nghiệp
		
			
			Người dùng
		
			
			Tất cả các câu trả lời trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kết luận: Tương lai phía trước
FastAuth chỉ mới bắt đầu và có một số tính năng cũng như các bản nâng cấp khác sắp được triển khai. Trong nỗ lực kết nối Web2 và Web3, FastAuth sẽ cho ra mắt những tính năng hữu ích sau:

 	Tương thích với nhiều chuỗi khối khác nhau
 	Tính toán đa bên phi tập trung hơn
 	Xác thực 2 lớp
 	Mở rộng các bộ chuyển tiếp và FastAuth tới các cổng kết nối ngoài phạm vi chuỗi khối NEAR

Nếu bạn muốn tìm hiểu thêm về các tính năng mà FastAuth sắp ra mắt, hãy truy cập tại near.org để biết thêm thông tin. Nếu muốn dùng thử FastAuth, bạn có thể tạo một tài khoản tại đây và sau đó bạn có thể sử dụng cùng một tài khoản để đăng nhập ở mọi nơi trên hệ sinh thái NEAR.




	

	
	
		
			
				Đâu là những thách thức trong việc mang người dùng mới tới với Web3?
			
		

		
					

		
			
			
			
			Trải nghiệm khi mới tiếp cận Web3 khá phức tạp
		
			
			Mật khẩu dài và những chuỗi từ bí mật cần phải ghi nhớ
		
			
			Cần phải sở hữu tiền mã hóa trước khi truy cập các dịch vụ Web3
		
			
			Tất cả các ý trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Qu'est-ce que Pikespeak ?

 



Construit sur le protocole NEAR, Pikespeak est une solution Data & Analytics offrant aux institutions, projets Web3 et particuliers :

 	Visualisations et tableaux de bord des cas d'utilisation Web3 les plus fondamentaux, DeFi, DAO, jeux, NFT, etc.
 	Un indexeur et une API puissants couvrant plus de 50 points de terminaison de données
 	RPC et indexeur dédiés
 	Points de données et informations personnalisés

La solution a déjà attiré plus de 400 premiers utilisateurs et est utilisée par des projets de premier plan au sein de l'écosystème, notamment Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader et Learn NEAR Club.




	

	
	
		
			
				Qui n'utilise pas encore Pikespeak ?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			Le président des États-Unis
		
			
			Tonic Dex
		
			
			Learn near club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 Pourquoi?

Parce que la blockchain n'est pas conçue pour les outils d'analyse traditionnels :

 	L'accès aux données utilisables peut être complexe, ce qui rend difficile l'exploration des opportunités
 	L'extraction de données rapidement, à grande échelle et au coût est un défi non négligeable et nécessite une interprétation basée sur les contrats intelligents déployés



En termes simples, Pikespeak vise à :

 	Indexation, stockage et transformation des données en chaîne en human-readable tables
 	Autonomiser les utilisateurs avec des analyses puissantes

Pourquoi?
Cela dépend du problème/question que vous devez résoudre/répondre. Voici quelques exemples concrets (non exhaustifs) :

 	Utilisateurs DeFi
 	Quelle est la valeur et la répartition de mon portefeuille ?
 	Quel est mon P/L sur une période spécifique ?
 	Le fisc (ex : IRS) demande des journaux de mes transactions et de mon activité blockchain pour le dernier exercice, comment puis-je fournir ces informations ?
 	Je suis intéressé à détenir un jeton, mais j'aimerais comprendre certaines choses, quelle est l'offre en circulation? Qui détient le jeton (liste riche) ? Comment se comportent les grands détenteurs ? Ont-ils vendu récemment ? Depuis combien de temps détiennent-ils le jeton ? Etc.
 	Quels sont les plus gros transferts de jetons au cours des dernières 24h ?
 	Sociétés de capital-risque
 	Quelle est la valeur et la répartition de mon portefeuille ?
 	Mon comptable demande des journaux de l'activité blockchain de l'entreprise, comment puis-je fournir ces informations ?
 	Quels sont les projets les plus actifs ?
 	Combien d'utilisateurs actifs les sociétés de mon portefeuille ont-elles ?
 	L'une des sociétés du portefeuille affirme que son produit a une traction massive, comment puis-je vérifier et contester cette information ?




	

	
	
		
			
				À l'aide de Pikespeak, puis-je : (sélectionner tout ce qui s'applique)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Télécharger tout l'historique de mon wallet au format csv
		
			
			Vérifier l'activité et les mesures clés de tout contrat intelligent ?
		
			
			Analyser les transactions historiques des adresses Genesis ?
		
			
			Prédire n'importe quel prix symbolique avec une précision de 100 % ?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Propriétaires de projets
 	Je suis en train de lever des fonds et j'aimerais comprendre la taille du marché adressable sur mon segment (ex : Gaming), combien y a-t-il d'utilisateurs actifs de Gaming ? Qui est leader sur mon segment ? Quelles sont les parts de marché des projets concurrents ?
 	Je souhaite inciter/airdroper des adresses spécifiques en fonction de leur portefeuille et de leur activité, puis-je avoir accès à la liste de ces adresses ?
 	Quelle est la TVL de mon projet ?
 	Pourquoi mon projet a-t-il perdu 20 % de sa TVL à cette date précise ?
 	Chefs de projets marketing
 	J'ai récemment soutenu/dirigé une campagne marketing, comment cela s'est-il traduit en acquisition d'utilisateurs ?
 	J'aimerais pousser pour une collaboration marketing avec un autre projet, ma base d'utilisateurs a-t-elle démontré un intérêt / interagit-elle déjà avec ce projet ? À quel point nos communautés sont-elles proches ?
 	Je souhaite inciter/airdroper des adresses spécifiques en fonction de leur portefeuille et de leur activité, puis-je avoir accès à la liste de ces adresses ?
 	Chefs de projet de produit
 	Quelle est la rétention des utilisateurs ?
 	Quelles sont les fonctionnalités (méthodes d'appel) les plus utilisées ?
 	Un projet concurrent a lancé une nouvelle fonctionnalité, comment a-t-elle été bien accueillie par la communauté ? Cela s'est-il traduit par l'acquisition d'utilisateurs ?
 	Combien de mes utilisateurs utilisent des applications concurrentes ? Combien dépensent-ils pour ces autres applications ?
 	Propriétaires du validateur
 	Pourquoi mon validateur public a-t-il perdu 20% de ses délégants hier ?
 	Je vois que 1M $NEAR ont été supprimés hier, quelle était l'adresse à l'origine de l'événement de suppression ?
 	Combien de délégants ai-je par rapport aux validateurs concurrents ?
 	Combien de récompenses mon nœud a-t-il accumulé depuis sa création ?
 	Propriétaires DAO
 	Qu'est-ce que la trésorerie du DAO ?
 	Combien de membres du DAO ont voté pour la dernière proposition ?
 	L'un de mes membres DAO est-il impliqué dans d'autres DAO ? Si oui, qu'y a-t-il ?
 	Combien de paiements mon DAO a-t-il réglés au cours de la dernière année ? Pour quel montant total ?
 	Gestionnaire de la trésorerie du Fonds pour l'écosystème
 	Combien de subventions ont été accordées au cours de la dernière année? Pour quel montant total ?
 	Quelle est la performance de mes bénéficiaires liés à la dapp sur les critères suivants, nombre de transactions, utilisateurs actifs, gestion de trésorerie ?
 	Comment les autres fonds écosystémiques ont-ils alloué des fonds récemment ? Quels sont les projets soutenus ?
 	Régulateurs et/ou enquêteurs de conformité AML/KYC
 	Quelle est la relation entre cette adresse et une autre ?
 	Cette adresse a été impliquée dans un piratage, quel(s) échange(s) ont été utilisés pour retirer de l'argent ?
 	Quel(s) échange(s) a/ont été utilisé(s) pour financer cette adresse malveillante ?
 	Quelques hacks ont le même modus operandi, mais ont été générés par des adresses différentes, sont-ils connectés d'une manière ou d'une autre ?
 	Quelles sont toutes les interactions/graphiques de couche 1 d'une adresse spécifique ?
 	Ingénieurs Blockchain
 	Une transaction spécifique a échoué, puis-je vérifier le détail des reçus de la transaction pour comprendre ce qui s'est passé ?
 	Quel était le coût du gaz de cette transaction spécifique ?




	

	
	
		
			
				Pikespeak peut-il être utile pour : (sélectionnez tout ce qui s'applique)
			
		

		
					

		
			
			
			
			Vcs et institutions exposées au protocole NEAR
		
			
			Pizza Maker basé à Napoli
		
			
			Projets et Dapps s'appuyant sur Near
		
			
			Simple Defi ou Utilisateur du protocole Near
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Les données, c'est bien, les histoires, c'est mieux
Le coût d'accès aux données sur les données est marginal par rapport aux marchés traditionnels et privés, tels que les bourses et les informations client (ex : panels) pour une industrie spécifique. Cela crée une opportunité unique pour les journalistes en plein essor, les enquêteurs ou tout type de journalisme citoyen d'émerger. La qualité et la couverture de la débâcle FTX sur Twitter en sont une excellente illustration.

De plus, le modèle NEARWEEK Report-to-Earn est un moyen innovant d'encourager le journalisme citoyen et de pousser les gens à participer au processus de création de contenu de l'actualité.

Vous trouverez ci-dessous une liste d'événements qui pourraient potentiellement conduire à des histoires intéressantes et perspicaces. Nous aimerions encourager la communauté LNC à tirer parti de Pikespeak pour raconter de belles histoires.

 	23 juin 2022 - 39 millions de jetons $NEAR ont été retirés des validateurs
 	4, 5 et 6 mars 2023 – Near Social (social.near) a connu un afflux important de nouveaux utilisateurs
 	8 mars 2023 – Le contrat Multi Sender (multisender.app.near) (envoi de plusieurs virements en une seule transaction) a envoyé 1,13 M$ à plusieurs adresses, sa plus grosse transaction depuis sa création

Contact

Pour plus d'informations, contactez:

Didier Pironi

Courriel : didier@pikespeak.ai

Date: 09/03/2023

Pikespeak.ai

 

### Fast Auth Beta test

Follow @LearnNEAR  on Twitter

Beta test sprint starts: June 16, 9 am ET
Beta Test sprint ends: June  20, 9 am ET
Requirements:

 	Read this guide about FastAuth 
 	Create an account using FastAuth
 	Update your user profile, created with FastAuth, at near.org
 	Take a screenshot
 	Follow @partners.learnclub.near at near.org
 	Try to recover your account via email
 	Write a meaningful comment about your experience with NameSky (you are more than welcome to shill your NS NFT there)
 	Tweet your screenshot and  "Testing @NEARProtocol FastAuth feature via @LearnNEAR Beta test!"
 	Submit feedback form

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic

### Руководство для начинающих по NameSky: покупайте, продавайте и безопасно управляйте учетными записями NEAR как NFT

NameSky — это удобная платформа, которая позволяет торговать учетными записями блокчейна NEAR как NFT. Благодаря своим смарт-контрактам, проверенным @pessimistic_io, NameSky NameSky обеспечивает безопасность для пользователей. Вы можете найти отчет об аудите здесь и изучить маркетплейс NameSky, чтобы увидеть учетные записи, отчеканенные как NFT.

Это руководство поможет вам ориентироваться на платформе NameSky. Опишет процесс превращения учетной записи NEAR в NFT NameSky, проверку NFT на странице вашего кошелька NEAR, размещение вашего NFT на торговой площадке и восстановление контроля над учетной записью NEAR путем сжигания NFT.

Шаг 1: Превратите учетную запись NEAR в NameSky NFT

Чтобы превратить вашу учетную запись NEAR в NFT NameSky, выполните следующие действия:

 	Посетите веб-сайт NameSky и нажмите «Mint».
 	Подключите свой кошелек NEAR к платформе NameSky.
 	Выберите учетную запись NEAR, которую вы хотите превратить в NameSky NFT.
 	После чеканки контракт блокировки будет развернут на прикрепленной учетной записи NEAR, и все ключи доступа будут удалены. Это означает, что только владелец NFT (вы) можете получить доступ к учетной записи NEAR.




	

	
	
		
			
				Правда или ложь: смарт-контракты NameSky прошли аудит?
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	




















Шаг 2: Проверьте NFT на странице кошелька NEAR.

Чтобы просмотреть свой отчеканенный NameSky NFT:

 	Войдите в свой кошелек NEAR.
 	Перейдите на вкладку «Collectibles».
 	Вы увидите свой NameSky NFT в списке с прикрепленной учетной записью NEAR.



Шаг 3: Разместите свой NFT на торговой площадке NameSky

Чтобы выставить NameSky NFT на продажу:

 	Перейдите на страницу сведений о NFT.
 	Нажмите «Продать».
 	Установите желаемую цену.
 	Подтвердите свой листинг, и ваш NFT будет доступен для покупки другими.







Шаг 4: Верните себе учетную запись NEAR, сжигая NameSky NFT.

Если вы хотите восстановить контроль над своей учетной записью NEAR:

 	Посетите страницу своего профиля NameSky.
 	Найдите NameSky NFT, который вы хотите сжечь.
 	Нажмите «Вернуть учетную запись». из раскрывающегося списка
 	Новая фраза восстановления будет сгенерирована локально на вашем устройстве, предоставляя вам доступ к учетной записи NEAR.
 	NameSky NFT будет сожжен, и вы восстановите полный контроль над подключенной учетной записью NEAR с помощью фразы восстановления из шага 4 на https://wallet.near.org/recover-account.















NameSky предоставляет безопасный и простой способ покупать и продавать аккаунты NEAR в виде NFT. Следуя этому руководству, вы сможете ориентироваться на платформе и уверенно управлять своими учетными записями NEAR и своими NFT. Хотите ли вы купить уникальную учетную запись NEAR или продать свою собственную, NameSky предлагает удобное и безопасное решение для ваших нужд. Счастливого (L)earn!

Если вы все еще не уверены в том, как работает NameSky, вы можете сами попробовать его в приложении для тестовой сети здесь: https://testnet.namesky.app




	

	
	
		
			
				Правда или ложь: после создания NameSky NFT все ключи доступа будут удалены из прикрепленной учетной записи NEAR?
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### O que é FastAuth?

Em março, o protocolo NEAR anunciou o lançamento do Blockchain Operating System (BOS), ou seja, Sistema Operativo Blockchain. A ideia por trás disso era criar o ponto de entrada ideal para a Web aberta e preencher a lacuna entre a Web2 e a Web3. O sistema operacional Blockchain da NEAR também viu a introdução de vários novos recursos. Um dos primeiros e mais poderosos recursos a serem introduzidos é o FastAuth.

Neste artigo, veremos mais de perto o FastAuth, entenderemos sua importância, como ele funciona e o que o futuro reserva. Comecemos!
O que é o Sistema Operacional Blockchain?
Antes de passarmos para o FastAuth, vamos entender brevemente o Sistema Operacional Blockchain. Hoje, o mundo da Web2 e da Web3 está fortemente fragmentado. O Web2 é altamente centralizado, com cada conta controlada por uma única entidade. Enquanto isso, a Web3 é fragmentada porque cada blockchain é isolada e separada da outra. O sistema operacional Blockchain da NEAR aborda esse problema, oferecendo um caminho para descobrir experiências com serviços comuns, tais como; uma única identidade, dados controlados pelo usuário e ativos controlados pelo usuário.

O Sistema Operacional Blockchain é um novo sistema operacional projetado para uma web mais aberta. O sistema é seguro, altamente descentralizado, fácil de integrar, fácil de desenvolver, código aberto e acessível a todos. Foi criado como uma alternativa de código aberto para gigantes tradicionais como Apple, Amazon, Google, Facebook e Microsoft e também elimina as complexidades normalmente associadas ao espaço Web3. Funciona com qualquer blockchain ou back-end Web2, permitindo o acesso a vários gateways. Os usuários finais obtêm uma experiência contínua por meio do sistema operacional Blockchain, semelhante ao uso de um único aplicativo, mesmo que os usuários precisem alternar entre diferentes cadeias ou aplicativos.

Ele também simplifica o desenvolvimento da blockchain, permitindo que os desenvolvedores criem em qualquer cadeia, criem códigos em linguagens familiares e também criem aplicativos inovadores que sejam fáceis de detectar e distribuir. Isso permite que os usuários se conectem a um crescente ecossistema de comunidades, pessoas e aplicativos, mantendo o controle total de seus dados. Além disso, os usuários não precisam de nenhuma cripto para poder começar com o sistema operacional Blockchain, abrindo uma série de fluxos de receita e recursos sem necessidade de qualquer experiência anterior na Web 3.
O que é FastAuth?
FastAuth é um poderoso recurso introduzido com o sistema operacional Blockchain que permite aos usuários criar contas de forma rápida e fácil que podem ser usadas em qualquer aplicativo ou site que possa ser integrado ao sistema operacional Blockchain. O FastAuth enfatiza a experiência do usuário e cria uma experiência familiar à de integração do tipo Web2 que permite aos usuários criar sua conta gratuita usando meios tradicionais, como endereços de e-mail, prompts de telefone e até biometria. Isso permite que os usuários interajam com os aplicativos rapidamente e possam se autenticar novamente no aplicativo usando o mesmo ou outro dispositivo.

Com o FastAuth, os usuários podem criar uma conta para qualquer site ou aplicativo no sistema operacional Blockchain sem exigir novas senhas ou comprar criptomoedas. O FastAuth também é ótimo para desenvolvedores, oferecendo a eles uma maneira rápida e fácil de fazer com que os usuários experimentem novos aplicativos e componentes. Isso ajuda a melhorar significativamente a adoção e trazer milhões de usuários Web2 para o ecossistema Web3, abaixando a barreira de entrada.
Como funciona o FastAuth?
A introdução do FastAuth ajudou a resolver um dos maiores desafios na integração de novos usuários no ecossistema Web3. Novos usuários podem configurar uma conta Blockchain Operating Service tão rapidamente quanto configurar uma conta tradicional, enquanto os desenvolvedores podem fornecer seus aplicativos Web3, experiências e componentes de uma forma mais fácil do que nunca antes. Vejamos como o FastAuth está preenchendo a lacuna entre Web2 e Web3 e melhorando a adoção da Web3 entre os usuários da Web2.
Processo de integração e recuperação de e-mail rápidos e sem complexidades.
Um dos maiores desafios ao integrar usuários na Web3 é a complexidade do processo de integração e a necessidade dos usuários de se lembrarem de frases iniciais complicadas. A maioria dos usuários estão acostumados com os métodos tradicionais de autenticação centralizada, como fazer login com o Google. Como resultado, usar e se acostumar com frases iniciais complexas pode ser bastante intimidante e criar uma barreira de entrada significativa. Isso dificulta a integração de novos usuários no ecossistema Web3.

A combinação do FastAuth com a recuperação de e-mail descentralizada elimina a necessidade dos usuários de se lembrarem de frases iniciais complicadas ou aplicativos de wallet de terceiros. Os usuários podem recuperar uma conta usando simplesmente um processo de “Single Sign-On” (Autenticação única) com o e-mail que usaram durante o processo de registro. O FastAuth usa “Multi-Party Computation” para descentralizar o processo de recuperação de contas, abrindo passo à adoção em massa utilizando um sistema de recuperação de contas fácil, seguro e descentralizado.

Como resultado, FastAuth é capaz de abordar alguns dos aspectos mais desafiadores da integração de novos usuários no ecossistema Web3. Os usuários podem configurar uma conta do sistema operacional Blockchain mais rapidamente do que criar uma conta tradicional do Google ou Facebook. Ao mesmo tempo, os desenvolvedores podem fornecer aplicativos, conhecimentos e componentes Web3 aos usuários de maneira integrada.




	

	
	
		
			
				O que é FastAuth?
			
		

		
					

		
			
			
			
			Uma solução perfeita para integração rápida ao sistema operacional Blockchain
		
			
			Um novo sistema operacional para a web aberta
		
			
			Um novo protocolo blockchain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sem aplicativos de terceiros
O FastAuth também elimina a necessidade de baixar e instalar aplicativos de terceiros. Isso ocorre porque ele cria uma experiência harmoniosa e focada no usuário, tornando a Web aberta acessível a todos instantaneamente, abrindo caminho para a adoção geral. Qualquer desenvolvedor no sistema operacional Blockchain pode aproveitar a experiência amigável do FastAuth e obter usuários em seus aplicativos.
Não é necessário possuir criptomoedas para criar uma conta
Até agora, os usuários que desejavam explorar e interagir com aplicativos na Web3 eram obrigados a possuir ou adquirir criptomoedas antes de começar. O FastAuth permite que os usuários acessem diretamente o ecossistema Web3 sem ter que correr atrás de criptomoedas. Isso é altamente benéfico para todos os usuários, incluindo usuários finais, desenvolvedores e empresas. O FastAuth usa Contas de Saldo Zero e Meta Transações da NEAR, permitindo que os usuários registrem suas contas gratuitamente. Isso também é uma vantagem para os desenvolvedores porque as meta-transações são emparelhadas com retransmissores, permitindo interações iniciais sem adquirir $ NEAR.
Quem pode usar o FastAuth?
FastAuth é uma solução ideal para desenvolvedores, usuários finais e empresas. Vejamos como cada um pode se beneficiar disso.
Desenvolvedores
Graças à experiência de integração simplificada do FastAuth, os desenvolvedores podem aumentar a taxa de conversão para usuários que experimentam seus aplicativos e componentes. Ele também pode expandir a base de usuários de um aplicativo, dando-lhe mais exposição.
Empresas
O FastAuth permite que as empresas integrem facilmente a Web3 e criptomoedas em seus negócios com apenas algumas linhas de código. As empresas podem integrar facilmente os usuários em uma comunidade poderosa e experiências que são acessíveis, descentralizadas e altamente seguras.
Usuário final
Por meio do FastAuth, os usuários podem configurar sua própria conta em segundos, permitindo que comecem a usar o Web3 de forma rápida e sem complicações.




	

	
	
		
			
				Para quem o FastAuth foi criado?
			
		

		
					

		
			
			
			
			Desenvolvedores
		
			
			Empreendimentos
		
			
			Usuários
		
			
			Todos os anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





E para encerrar: O Futuro
O FastAuth está apenas começando e há vários outros recursos e atualizações em andamento. Em seu esforço para unir a Web2 e a Web3, o FastAuth visa introduzir os seguintes recursos em um futuro próximo.

 	Compatibilidade Multi-chain
 	Descentralização MPC Adicional
 	Autenticação de dois fatores
 	Expansão de retransmissores e FastAuth para mais acessos além da NEAR.

Se você deseja saber mais sobre os próximos recursos do FastAuth, acesse a near.org para obter mais informações.Se você deseja experimentar o FastAuth por conta própria, pode criar uma conta aqui e usar a mesma conta para fazer login em qualquer lugar no NEAR.




	

	
	
		
			
				Quais são os desafios enfrentados na integração de usuários na Web3?
			
		

		
					

		
			
			
			
			Uma experiência de integração complicada
		
			
			Senhas longas ou frases iniciais
		
			
			A necessidade de adquirir criptomoedas antes de acessar o Web3
		
			
			Todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!

### Что такое FastAuth?

В марте протокол NEAR объявил о запуске Операционной Системе Блокчейн. Идея этой системы заключалась в том, чтобы создать идеальный вход в open-web и преодолеть разрыв между Web2 и Web3. В Операционной Системе Блокчейн от NEAR также появилось несколько новых функций. Одна из первых и наиболее мощных функций - FastAuth.

В этой статье мы подробно рассмотрим FastAuth, поймем ее важность, принцип работы и перспективы. Давайте начнем!
Что такое Блокчейн?
Давайте сначала разберемся в Операционной Системе Блокчейн, прежде чем перейти к FastAuth. Сегодня мир Web2 и Web3 сильно раздроблен. Web2 очень централизован, и каждый аккаунт контролируется одним лицом. В то же время Web3 разрознен, поскольку каждый блокчейн изолирован и отрезан от другого. Операционная система блокчейна NEAR решает эту проблему, предлагая путь к открытию опыта с общими услугами, такими как: единая идентификация, данные и активы, контролируемые пользователем.

Операционная Система Блокчейн - это новая операционная система, разработанная для более открытого Интернета. Эта система безопасна, в высшей степени децентрализована, легко внедряется, легко разрабатывается, имеет открытый исходный код и доступна для всех. Её создание было мотивировано желанием предоставить открытую альтернативу гигантам интернета, таким как Apple, Amazon, Google и Microsoft. Также она устраняет сложности, обычно связанные с пространством Web3. Она работает с любым блокчейном или бэкендом Web2, обеспечивая доступ к различным шлюзам. Конечные пользователи получают непрерывный опыт работы с Операционной Системой Блокчейн, аналогичный использованию одного приложения, даже если пользователям приходится переключаться между различными цепочками или приложениями.

Она также упрощает разработку блокчейна, позволяя разработчикам строить на основе любой цепочки, создавать код на знакомых языках программирования и создавать инновационные приложения, которые легко можно распространить и обнаружить. Это позволяет пользователям подключаться к растущей экосистеме сообществ, людей и приложений, сохраняя полный контроль над своими данными. Более того, пользователям не требуется криптовалюта для начала работы, а операционная система Blockchain открывает множество потоков дохода и возможностей, не требуя предварительного опыта работы с Web3. Операционной Системе Блокчейн
Что такое FastAuth?
FastAuth - это мощная функция операционной системы Блокчейн, которая позволяет пользователям быстро и легко создавать учетные записи, которые можно использовать в любом приложении или на любом сайте, интегрированном с Операционной Системой Блокчейн. FastAuth делает акцент на пользовательском опыте и создает привычный Web2-тип входа в систему, который позволяет пользователям создать свою бесплатную учетную запись, используя традиционные средства, такие как адреса электронной почты, номер телефона и даже биометрические данные. Это позволяет пользователям быстро взаимодействовать с приложениями и повторно проходить аутентификацию в приложении с помощью того же или другого устройства.

Благодаря FastAuth пользователи могут создавать учетные записи на операционной системе Блокчейн для любого сайта или приложения, не требуя ввода новых паролей или приобретения криптовалюты. Этот инструмент также предоставляет разработчикам быстрый и простой способ привлечения пользователей к новым приложениям и компонентам, что поможет увеличить их внедрение и привлечь миллионы пользователей Web2 в экосистему Web3, уменьшив входной барьер.
Как работает FastAuth?
Внедрение FastAuth помогло решить одну из самых больших проблем, связанных с привлечением новых пользователей в экосистему Web3. Новые пользователи могут создать учетную запись в Операционной Системе Блокчейн так же быстро, как и обычную учетную запись, а разработчики могут создавать свои приложения, интерфейс и компоненты Web3 более плавно, чем когда-либо прежде. Давайте рассмотрим, как FastAuth устраняет разрыв между Web2 и Web3 и улучшает принятие Web3 пользователями Web2.
Регистрация и восстановление электронной почты быстро и без проблем
Одной из самых больших проблем при регистрации пользователей в Web3 является сложность процесса регистрации и необходимости запоминания seed-фраз. Большинство пользователей привыкли к традиционным методам централизованной аутентификации, таким как вход в Google. В результате использование и привыкание к сложным seed-фразам может оказаться довольно сложным и создать планку для входа. Это затрудняет привлечение новых пользователей в экосистему Web3.

Сочетание FastAuth с децентрализованным восстановлением электронной почты избавляет пользователей от необходимости запоминать сложные seed-фразы или использовать сторонние приложения для создания кошельков. Пользователи могут просто восстановить аккаунт с помощью процесса "Single Sign-On", используя электронную почту, которую они использовали в процессе регистрации. FastAuth использует "многосторонние вычисления" для децентрализации процесса восстановления аккаунта, прокладывая путь к массовому внедрению благодаря простой, безопасной и децентрализованной системе восстановления аккаунта.

В результате FastAuth может решить некоторые из наиболее сложных аспектов, связанных с привлечением новых пользователей в экосистему Web3. Пользователи могут создать учетную запись в Операционной Системе Блокчейн быстрее, чем традиционную учетную запись Google или Яндекс. В то же время разработчики могут беспрепятственно предоставлять пользователям приложения и компоненты Web3.




	

	
	
		
			
				Что такое FastAuth?
			
		

		
					

		
			
			
			
			Простое решение для быстрого перехода на блокчейн
		
			
			Новая ОС для Интернета
		
			
			Новый Блокчейн протокол
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Никаких сторонних приложений
FastAuth также устраняет необходимость загрузки и установки сторонних приложений. Это объясняется тем, что он создает бесшовный, ориентированный на пользователя интерфейс, делая web3 доступным для всех мгновенно, расчищая путь для массового принятия. Любой разработчик на Операционной Системе Блокчейн может использовать удобный для пользователя опыт FastAuth и привлечь пользователей к своим приложениям.
Криптовалюта не нужна при создании аккаунта
До сих пор пользователям, желающим изучать приложения в Web3 и взаимодействовать с ними, требовалось иметь или приобретать криптовалюту, прежде чем приступить к работе. FastAuth позволяет пользователям получить прямой доступ к экосистеме Web3, не прибегая к покупке криптовалюты. Это очень выгодно для всех пользователей, включая конечных пользователей, разработчиков и компаний. FastAuth использует технологии NEAR “Zero Balance Accounts” и “Мета-транзакции”, позволяя пользователям бесплатно регистрировать свои счета. Это также выгодно для разработчиков, поскольку “Мета-транзакции” сопряжены с ретрансляторами, что позволяет осуществлять первые взаимодействия без приобретения криптовалюты $NEAR.
Кто может использовать FastAuth?
FastAuth является идеальным решением для различных групп пользователей, включая разработчиков, компаний и конечных пользователей. Посмотрим, как каждая из этих групп может использовать FastAuth в своих интересах.
Разработчики
Разработчики могут использовать FastAuth для повышения конверсии пользователей, пробующих их приложения и компоненты благодаря упрощенному процессу регистрации. Это также поможет расширить пользовательскую базу приложения и сделать его более популярным.
Компании
FastAuth позволяет компаниям легко интегрировать Web3 и криптовалюты в свой бизнес с помощью всего нескольких строк кода. Компании могут легко вовлечь пользователей в мощное сообщество и опыт, который является доступным, децентрализованным и очень безопасным.
Пользователи
За считанные секунды пользователи могут создать свой аккаунт с помощью FastAuth, что позволит им без проблем начать работу с Web3 и быстро получить доступ к функционалу.




	

	
	
		
			
				Для кого был создан FastAuth?
			
		

		
					

		
			
			
			
			Для разработчиков
		
			
			Для компаний
		
			
			Для пользователей
		
			
			Для всех вышеперечисленных
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






В заключение: Будущее

FastAuth только начинает свою работу, и присутствуют еще несколько функций и обновлений, которые находятся в разработке. Соединяя Web2 и Web3, FastAuth намерен в ближайшем будущем представить следующие возможности:

1. Совместимость с “Multi-chain”

2. Дополнительная децентрализация MPC

3. Двухфакторная аутентификация

4. Расширение relayers и FastAuth на шлюзы за пределами NEAR.

Если вы хотите узнать больше о предстоящих функциях FastAuth, посетите сайт near.org для получения дополнительной информации. Если вы хотите попробовать FastAuth самостоятельно, вы можете создать учетную запись здесь, а затем использовать эту же учетную запись для входа в систему везде на NEAR.




	

	
	
		
			
				С какими проблемами приходится сталкиваться при подключении пользователей к Web3?
			
		

		
					

		
			
			
			
			Сложный процесс регистрации
		
			
			Сложные пароли и seed-фразы
		
			
			Необходимость покупки/наличия криптовалюты
		
			
			Всё выше перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Meta Pool, Módulo 3 – Finanças Descentralizadas x Meta Pool

Ecossistema DeFi com Meta Pool
Finanças Descentralizadas (DeFi) são uma nova maneira de operar finanças com base na tecnologia blockchain. Essas finanças usam contratos inteligentes para armazenar, bloquear, compartilhar, adquirir e cultivar tokens. O DeFi visa subtrair o controle que os bancos centrais têm sobre fundos ou ativos e distribuí-los por meio de contratos inteligentes.

O Meta Pool é um contrato inteligente emissor de ativos sem permissão e sem custódia que possibilita a junção de tokens NEAR e recompensas de staking em um único token chamado Staked NEAR (stNEAR).

O stNEAR permite que seus detentores movam o valor de tokens apostados e recompensas no ecossistema DeFi de várias cadeias, incluindo NEAR e Aurora.




	

	
	
		
			
				As Finanças Descentralizadas podem ter parte do seu funcionamento gerido por entidades centralizadas. Nem todo DeFi é 100% descentralizado.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tokens stNEAR entre NEAR <> Aurora – Rainbow Bridge
Meta Pool usa Rainbow Bridge para transferir tokens $META e stNEAR entre NEAR e Aurora Network, isso permite que você use seus tokens Meta Pool em dApps da Aurora, como Trisolaris , WannaSwap e etc.

Movendo stNEAR e $META para Aurora usando Rainbow Bridge

Usando https://rainbowbridge.app/ você pode conectar sua NEAR Wallet e sua carteira MetaMask para transferir seus tokens:

 

Como adicionar contratos $META stNEAR à carteira MetaMask

Para adicionar um token de sua transferência anterior da Rainbow Bridge para MetaMask na Aurora Mainnet, clique em 'Scan transfer history' na Bridge e selecione 'Add token to MetaMask'.

Para adicionar um token manualmente, localize o endereço do token na lista de tokens suportados. Observe que eles têm um endereço diferente na Aurora e no Ethereum.

$META na Aurora 0xc21ff01229e982d7c8b8691163b0a3cb8f357453

stNEAR na Aurora 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30

(VÍDEO) Como transferir stNEAR para Aurora. Oportunidades de Mineração de Liquidez (Protocolo NEAR, Aurora): https://www.youtube.com/watch?v=_o–5GY5G0w




	

	
	
		
			
				Depois de conectar um token do protocolo NEAR a Aurora, é impossível recuperá-lo na cadeia original.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Troque tokens na Aurora – Trissolaris
Swap é o processo onde você troca um token por outro de acordo com o valor dado pelas condições de mercado ou pool. Dessa forma, você pode obter tokens que finge ter ou procurar um token que esteja interessado em usar em um aplicativo específico.

Trisolaris é a corretora DEX nr.1 na Aurora, uma blockchain compatível com EVM rodando no ecossistema Near.

Como trocar tokens na Trisolaris?

 	Vá para a seção Trisolaris Swap e conecte sua carteira MetaMask com Aurora Network



 	Digite o valor para trocar
 	Aprovar e confirmar a transação




	

	
	
		
			
				Você pode usar o roteamento para trocar para um token onde não há pool de liquidez direta.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Adicione liquidez aos pools de swap de stNEAR – Trisolaris
Como as emissões de tokens não são gerenciadas por uma exchange descentralizada, os pools de swap precisam de usuários que adicionem liquidez para poder fazer um swap.

Dessa forma, você pode se tornar um provedor de liquidez colocando o par de tokens necessários para um pool. Em troca, você recebe uma fração das taxas geradas pela pool.

 	Vá para a seção Pool e clique no botão adicionar liquidez.



 	Selecione o par que você deseja adicionar liquidez. No Trisolaris você pode encontrar a pool stNEAR <> wNEAR.



 	Confirme o saldo e clique no botão adicionar


Trocar tokens no protocolo NEAR – Ref Finance
1. Vá para Ref Finance e conecte sua carteira NEAR

2. Vá para a seção Swap

 3. Selecione os tokens para troca e marque 'Impacto no preço', 'Taxa de troca' e 'Mínimo recebido' no menu Detalhes. Decida se esta troca é adequada para você

4. Insira o valor do swap

5. Clique no botão Trocar, confirme e assine a transação

Assim, no Ref Finance você pode obter tokens $META e stNEAR.
Adicione liquidez as pools de swap de stNEAR – Ref Finance
A Ref Finance é a principal bolsa descentralizada no protocolo NEAR. Disponibiliza um conjunto de ferramentas DeFi utilizando o padrão NEP-141 da NEAR.

 	Vá para pools, procure pools stNEAR e escolha o pool que deseja adicionar liquidez.



 	Clique no botão Adicionar Liquidez



 	Selecione a quantidade de tokens que deseja adicionar em liquidez ao pool.



Feito isso, você poderá receber uma partição das taxas geradas pela pool.




	

	
	
		
			
				Ser um provedor de liquidez coloca seus tokens em risco de serem liquidados.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Emprestar usando stNEAR – Burrow Cash
Empréstimo significa que você pede tokens emprestados dando um token de garantia. Você recebe uma fração do valor de sua garantia (sobre a colateralização) para receber o token solicitado na toca.

Se você quiser seus tokens de volta, você tem a opção de pagar sua dívida.

Caso sua garantia caia de valor, ela será liquidada automaticamente pela plataforma de empréstimo e você ficará apenas com seus tokens emprestados, sem a opção de recuperá-los.

 	Ir para BurrowCash
 	Conecte sua carteira NEAR
 	Siga stNEAR na página de depósito



Depositando stNEAR:

 	Digite o valor stNEAR
 	Use como garantia se quiser tomar emprestado
 	Envie e assine a transação



Como Emprestar?



 	Selecione o ativo a ser emprestado
 	Insira o valor a ser emprestado, tendo em mente o Fator de saúde resultante
 	Envie e assine a transação



Como Reembolsar?



 	Ir para Portfólio
 	Para reembolsar ativos emprestados, clique no botão “Reembolsar”



Como retirar?



 	Ir para Portfólio
 	Para retirar ativos fornecidos, clique em “Retirar”






	

	
	
		
			
				O dinheiro emprestado está disponível em qualquer país do mundo.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Emprestar usando stNEAR – Aurigami
Arugami permite que você solicite um empréstimo de tokens na Aurora Network. Para isso, você pode usar tokens stNEAR.

No momento em que isso foi escrito, você pode ir diretamente para o painel do Aurigami e clicar em fornecer o token stNEAR. Se você já tem uma garantia, pode clicar em pedir emprestado.



A opção de abastecimento lhe dará um modal onde stNEAR pode ser depositado. Uma vez escolhido, clique em Aprovar stNEAR .



Permitir o uso de stNEAR como garantia para solicitar uma troca. Confirme a transação em sua carteira.



Selecione o token que deseja emprestar e clique no botão Empréstimo .



Selecione a quantidade de tokens que você deseja ter emprestado. AVISO: se você solicitar 100%, corre alto risco de ser liquidado.



Sempre que você quiser ter seu stNEAR de volta, vá pagar e devolva todos os tokens que você obteve por empréstimo.


Farm de Rendimento Alavancado – Pembrock
O primeiro aplicativo de farm de rendimento alavancado no protocolo NEAR. Dentro deste aplicativo você pode encontrar mecanismos de empréstimo, cultivo e staking. stNEAR é permitido como um token para usar em PembRock.



Farm STNEAR-wNEAR

Deposite stNEAR e peça emprestado wNEAR na pool da farm. Escolha a quantidade de ativos para usar como garantia e o nível de alavancagem. Verifique o resumo da transação.



Empréstimo NEAR

Escolha a quantidade de tokens stNEAR que deseja emprestar. Esses ativos são usados ​​pelos farms de rendimento para alavancar seus ativos criptográficos.



Saiba mais sobre como Pembrock funciona no seguinte link: https://docs.pembrock.finance/education/how-to-guides




	

	
	
		
			
				O farm de rendimento alavancado pode implicar em risco de liquidação de seus tokens.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR apostando na Aurora Network
Tornamos mais fácil para os usuários da Aurora fazer stake de wNEAR diretamente da Aurora usando a MetaMask. Aproveitando a capacidade da Rainbow Bridge de fazer chamadas de contrato entre Aurora e NEAR, criamos uma solução simples que mantém a mesma interface de usuário e experiência da solução NEAR nativa.



É fácil distinguir em qual rede você está, pois possui o logotipo da Aurora, e cada rede automaticamente solicitará que você conecte sua carteira Metamask.

Estamos aproveitando a Rainbow Bridge para automatizar todas as etapas que os usuários teriam que executar manualmente: nos bastidores, estamos enviando wNEAR de Aurora para NEAR Mainnet, desembrulhando-o, depositando NEAR no Meta Pool, recebendo stNEAR e enviando stNEAR de volta Rainbow Bridge para a Carteira Aurora do usuário.

Nosso código foi auditado pela Blocksec. Aqui estão as auditorias, então fizemos o possível para manter os ativos seguros.

A taxa de depósito no Aurora é de 0,1%, porque o Meta Pool precisa pagar taxas de transação na ponte de ida e volta, que cobre essas taxas de transação.

 

### Meta Pool, Módulo 2 – Financiamento coletivo no Meta Pool

Meta Yield – Crowdfunding (financiamento coletivo) sem perdas
Meta Yield é uma plataforma de crowdfunding baseada em recompensas de staking sem perdas para projetos NEAR que buscam suporte financeiro e exposição para a comunidade NEAR.

O objetivo da Meta Yield é fornecer exposição e acesso a diferentes projetos, permitindo que a comunidade apoie financeiramente projetos web 3.0 construídos no protocolo NEAR.

O Meta Yield Launchpad é uma plataforma de crowdfunding sem perdas para projetos no NEAR que desejam ser financiados por sua comunidade. Ele aproveita o staking ao fornecer aos patrocinadores a possibilidade de financiar com suas recompensas, não com seus ativos principais.



O mecanismo exclusivo de arrecadação de fundos construído no Meta Yield aproveita o staking líquido: os financiadores cunham os tokens do projeto com suas recompensas de staking, não com seus criptoativos.

O Meta Yield funciona com 4 passos simples:

 	Patrocinadores comprometem e bloqueiam stNEAR para apoiar projetos baseados em criptografia (se você não tem stNEAR, vá para Meta Pool & stake $NEAR)
 	Os projetos ganham somente recompensas de staking (~ 10%) do que os apoiadores comprometem, não os cripto ativos subjacentes
 	Os patrocinadores ganham tokens de novos projetos lançados no NEAR ou recebe NFT drop (num futuro próximo, NFTs de lançamento).
 	Os Patrocinadores recuperam seus ativos criptográficos: Ao final do período de bloqueio, você recupera 100% do seu NEAR.

Simplificando, você pode apoiar projetos de criptografia, ser recompensado com o token nativo do projeto e contribuir para o crescimento do ecossistema NEAR sem perder seus tokens staked.

Você apenas dá suas futuras recompensas NEAR pelos tokens do projeto e consegue manter suas NEAR, reduzindo assim o risco de todo o processo de investimento.

Comece a apoiar os Projetos NEAR agora! Visita https://metayield.app






	

	
	
		
			
				Existe um limite pré-estabelecido na quantidade de tokens stNEAR que você pode depositar em uma campanha Meta Yield.
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falsa
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como um projeto pode ser listado no Meta Yield?
Primeiramente, o launchpad (plataforma de lançamento) do Meta Yield fornece a plataforma de crowdfunding e o mecanismo baseado em recompensas. Além disso, todos os projetos que recebem uma campanha de arrecadação de fundos recebem um impulso de marketing sem nenhum custo do Meta Yield Launchpad:

 	Campanha de pré-lançamento: 1 ou 2 semanas de novidades sobre o projeto, incluindo possíveis AMAs, infográficos e postagens nas redes sociais.
 	Promoção de lançamento.
 	Promoção semanal contínua durante o período de arrecadação de fundos.

Além disso, estamos trabalhando com diferentes entidades do ecossistema NEAR que estão interessadas na oportunidade de apoiar financeiramente esses novos projetos no NEAR.
Como selecionamos os projetos?
Queremos dar a todos a oportunidade de angariar fundos para os seus projetos, mas também queremos dar aos usuários e potenciais investidores, projetos de qualidade como opções. Por isso, todo projeto que quiser ser considerado candidato a estar no Meta Yield Launchpad deve atender aos seguintes requisitos:

 	Uma sólida equipe construindo o projeto.

O projeto deve ser apoiado por uma equipa sólida e motivada, capaz de levar o projeto à fase seguinte, uma vez financiado.

A experiência de cada membro deve estar relacionada ao tipo de projeto proposto. Em outras palavras, se for um projeto de jogo, os membros devem apresentar evidências de que pelo menos alguns de seus membros já trabalharam em áreas afins.

Equipes multidisciplinares também são um bom sinal, ter desenvolvedores é importante, mas para realmente levar seu projeto para o próximo nível, você também precisa de marketing, operações, design e talvez outras áreas.

 	Comunidade forte.

Queremos que esses projetos tenham um forte apoio de sua comunidade, geralmente verificamos seu nível de atividade e engajamento em redes sociais como Telegram, Discord, Twitter, YouTube, Instagram, TikTok e quaisquer outros projetos mencionados em seu aplicativo.

Este aspecto é de vital importância por 2 razões principais: às vezes temos uma fase de votação para selecionar projetos e geralmente são as comunidades que empurram esses votos, e também uma boa porcentagem do valor arrecadado virá da comunidade, por isso é essencial estar preparado para proteger as costas.

 	Um Token e sua Tokenômica

É imprescindível que os projetos selecionados tenham um token, pois com ele se premiará quem apoiar sua campanha. Para ser mais específico, a pessoa que apoia o projeto dará ao projeto suas recompensas de stake e receberá tokens do projeto em troca como recompensa.

E, como seus investidores receberão seu token como recompensa, é importante dizer a eles como podem usá-lo (por exemplo: jogar, comprar, trocar ou como token de governança) e seus planos para aumentar seu valor.

 	Um plano para o financiamento

Tenha em mente que fazer uma campanha no Meta Yield Launchpad é semelhante a tentar arrecadar dinheiro de investidores: eles querem saber se você é capaz de construir o projeto e como vai ganhar dinheiro com isso.

Então, esteja preparado para dar uma explicação básica de como você vai usar o dinheiro arrecadado: marketing, melhoria do produto/serviço, ampliação de funcionalidades, mudança/inovação da marca, melhoria das funcionalidades da plataforma, etc.

 	Conecte-se com o ecossistema NEAR

Como trabalhamos com projetos e comunidade NEAR e a comunicação é muito importante neste protocolo, encorajamos você a estabelecer um relacionamento próximo com o NEAR Protocol Ecosystem.

A equipe do projeto deve ter evidências de que colaborou e sabe trabalhar com os atores envolvidos no NEAR: obter subvenções, participar de programas de incubação ou fazer parte de guildas, contam para esse requisito.

Isso garante que o ecossistema já “reconhece a equipe/projeto” e que quando o projeto for para a mainnet, o ecossistema irá apoiá-lo.




	

	
	
		
			
				Pergunta. A visão multi-chain em um projeto é imprescindível em um projeto que será lançado na Meta Yield.
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falsa
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Onde posso encontrar mais informações sobre o Meta Yield?
Você pode encontrar mais informações no site da Meta Yield e também no blog.
Meta Bond Market (Mercado de Títulos do Meta)– Venda seus ativos bloqueados no Meta Yield
O objetivo do Meta Bond Market é fornecer uma ferramenta para adquirir e oferecer diferentes tipos de títulos que atualmente são gerados pelo apoio a projetos em Meta Yield.

Meta Bond Market pode ser acessado diretamente de seu link metabondmarket.app.
Conecte sua carteira no Meta Bond Market
No site Meta Bond Market: metabondmarket.app, vincule a carteira NEAR para ter acesso total aos cripto ativos. Clique no botão “Connect Wallet” (Conectar Carteira), escolha a carteira e conecte-se.


Como funciona o Mercado de Meta Bonds:
4 Passos fáceis para entender o mecanismo Meta Bond:

 	Apoiar Projetos em Meta Yield.
 	Obtenha títulos de acordo com o investimento em Meta Yield e recompensas relacionadas.
 	Ofereça os títulos na plataforma.
 	Compre títulos de outros vendedores.

Os usuários investem em Meta Yield para projetos em estágio inicial. Se esses projetos conseguirem atingir pelo menos a primeira meta de investimento, os apoiadores recebem recompensas em tokens do projeto, liberados gradualmente em troca de seu investimento bloqueado.

Terminado o Período do Fundo, o Meta Bond Market gera dois títulos para o apoiador:

 	O primeiro: em tokens NEAR. Este valor corresponde à valorização em NEAR do stNEAR bloqueado no final do período do Fundo.
 	O segundo: Pela quantidade de Tokens a receber do projeto apoiado que serão liberados gradualmente.

O patrocinador pode escolher a qualquer momento, durante o “Período de Bloqueio” se deseja colocar um ou ambos os títulos à venda.

Se os títulos não forem colocados à venda, os títulos continuarão seu curso, e ao final do período de bloqueio o investimento é devolvido ao detentor do título, e as recompensas do projeto apoiado são delegadas em liberação gradual de acordo com a proposta.

Para cada título você pode escolher/executar as seguintes ações:

 	Dividir os títulos em títulos menores.
 	Oferecê-los para venda direta.
 	Leiloá-los.

Defina o horário em que os títulos serão colocados à venda.

Se o título for vendido, o vendedor recebe o valor em tokens de acordo com a venda direta ou a melhor oferta do leilão.

Se o título não for vendido, ele ficará disponível para venda novamente e permanecerá na posse do vendedor que poderá colocá-lo à venda novamente, se quiser.






	

	
	
		
			
				Meta Bond permite que você venda os tokens bloqueados de seu suporte para uma campanha Meta Yield.
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falsa
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plataforma da Meta Bond Market
Menú

Bond Market (mercado de títulos)
Esta seção exibe todos os títulos oferecidos na plataforma. São apresentados os dados de cada título e será possível adquirir/licitar pelos mesmos.
My Bonds
A seção “My Bonds" (meus títulos) detalha todos os títulos que o usuário possui. A partir desta seção, o usuário pode:

 	Ver todos os dados dos títulos.
 	Vendê-los.
 	Combine-os (importante, para combinar 2 títulos, todos os critérios do título devem corresponder: ativo, data de vencimento e o Cliff Date, se aplicável).
 	Dividi-los (os títulos só podem ser divididos se não tiverem sido parcialmente reclamados).

My Sales (meus títulos à venda)
Nesta seção você pode ver os títulos que o usuário colocou à venda. As vendas ativas e as concluídas.

 	Direct sell (venda direta): O comprador licita diretamente e o vendedor verá nesta seção que a venda foi realizada e poderá obter os tokens correspondentes.
 	Auction Sale (leilão): O lance mais alto é o vencedor e no final do período de lances o vendedor poderá obter os tokens.
 	End of bid period (fim do período de licitação): Se ao final do período de lances não houver ofertas, o vendedor poderá colocar novamente seu título à venda ou encerrar o processo.

Importante: Se o título foi vendido, o vendedor deve inserir o título e pressionar “get tokens” (receber os tokens) para fechar o processo de venda. Este processo é manual.
Garantia de títulos
Ao colocar um título à venda, o sistema solicitará um valor mínimo (atualmente 1 NEAR) como garantia.

Isso permite que o sistema detenha apenas títulos que representem um mínimo do valor da garantia em questão.

Ao fechar o processo de venda, este valor será devolvido ao vendedor.
My Bids (meus lances)
Em “My bids” o usuário pode visualizar os lances ativos que fez para títulos no Leilão.

Os títulos em venda direta não são exibidos aqui, pois já estão incorporados automaticamente na seção “My Bonds”.

Se você estiver perdendo o leilão, o sistema permite que você aumente seu lance ou cancele seu lance retirando seus tokens.
Estados dos títulos em leilão
Período ativo de venda 

 	Losing (perdendo): Se seu lance foi superado, o sistema permite que você aumente ou cancele seu lance retirando seus tokens.
 	Winning (ganhando): Esse lance é o melhor, é o que está ganhando. O usuário deve aguardar a finalização (fim da venda) para saber se realmente ganhou.

Período de venda finalizado

 	Win (vencer): Este status é exibido se o lance no final do período de lances for o vencedor. O usuário pode reivindicar o título.
 	Lose (perder): Este status é exibido se o lance no final do período de lances for o perdedor. O usuário pode reivindicar (sacar) sua oferta de tokens para este título.




	

	
	
		
			
				Existe um alto risco potencial de liquidação ao vender seus títulos no Meta Bond Market.
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falsa
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Passo a passo no Meta Bond Market.

### Meta Pool, Módulo 4 – Participando da governança do Meta Pool

Governança do Meta Pool
A governança é o processo no qual o Meta Pool busca devolver o projeto à comunidade. Dessa forma, os detentores do token $META são os que terão a opção de gerenciar o protocolo on-chain por meio de uma DAO (Organização de Administração Descentralizada).

Montar uma verdadeira governança on-chain e descentralizada é um trabalho em andamento em todo o ecossistema da Web 3. Além disso, este módulo aborda como o Meta Pool está lidando com essa situação.
DAO do Meta Pool
Meta Pool apresentará tokens $META para governança DAO. A intenção é que o token $META seja distribuído aos construtores de protocolo e colaboradores do projeto de forma totalmente transparente.

Uma coisa a se notar é que, antes que a plataforma de votação de governança on-chain esteja pronta para os detentores de tokens de $META, os principais contribuidores do protocolo tomarão decisões críticas com base na visão do projeto e nas informações informais da comunidade sobre discord.

Isso é intencional, pois achamos importante manter a governança ágil nos primeiros dias do protocolo.

Os principais objetivos da introdução do token de governança: Incentivar a liquidez. Para dar começo à liquidez inicial e acelerar o crescimento da plataforma Meta Pool.

O token $META representa a propriedade da DAO do Meta Pool. Essa DAO será a responsável pela atualização dos parâmetros do programa, roteiro do produto e outras decisões estratégicas. Capitalizar o tesouro, Para permitir o financiamento de parcerias estratégicas ou a criação de fundos de reserva.
$META tokenomics
Suprimento máximo: 1,000,000,000 $META

 	Fundadores: 30%

Pelo trabalho de criação, lançamento, promoção e manutenção do protocolo. Os tokens dos fundadores têm um bloqueio de 1 ano seguido por um lançamento linear de 2 anos. (total: 3 anos)

 	Equipe e Assessores: 2.6%

Para criar um produto de classe mundial, precisamos do melhor do ecossistema NEAR trabalhando e colaborando no protocolo. Eles estarão se comprometendo a longo prazo com o protocolo. Os tokens dos assessores têm um bloqueio de 2 anos seguido de um lançamento linear de 1 ano. (total: 3 anos)

 	Investidores: 10%

A parceria com os principais investidores e instituições será fundamental para nosso alcance global e também para uma melhor compreensão das condições macro dos mercados criptográficos. Estamos conscientes do que não sabemos, é por isso que os consultores sênior e o acesso à sua rede serão fundamentais para o nosso crescimento. Os tokens dos investidores têm um bloqueio de 1 e 2 anos, seguido de um lançamento linear de 1 ano. (total: 2 e 3 anos)

 	Alocação para capital de empreendimento:

● 4% Rodada semente (capital inicial)

● 6% Rodada (série de investimento)

 	Comunidade e Tesouraria: 57.40%




	

	
	
		
			
				O token $META recebe airdrops mensais
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ganhe poder de voto no Meta Pool – Meta Vote
Meta Vote é uma plataforma de votação baseada na comunidade para:

 	Projetos de Captação de Recursos em Meta Yield, e
 	Validadores de suporte na votação de Meta Staking.

É uma plataforma desenhada para adquirir Poder de Voto para apoiar projetos em Meta Yield e delegar NEAR Tokens a validadores em Meta Staking Vote.


Como utilizar o Meta Vote?
Você pode acessar o Meta Vote diretamente de seu link https://metavote.app/ ou:

 	Do Meta Yield clicando nos projetos que deseja votar. https://metayield.app/
 	Do Meta Staking Vote clicando no Validador que você deseja votar https://vote.metapool.app/, ou clicando nos links para Meta Vote na página para obter poder de votação.

Conecte sua carteira no Meta Vote

No site da Meta Vote: https://metavote.app/, vincule sua carteira NEAR para que você possa ter acesso total aos seus ativos. +Connect Wallet button.
Meta Vote funciona com 3 passos simples:

 	Bloqueie seus tokens $META.
 	Obtenha poder de voto.
 	Vote em projetos em Meta Yield ou Meta Vote apoiando validadores.

Bloquear seus Tokens $Meta
Para poder votar em projetos ou Validadores, você deve obter Poder de Voto e é muito simples. A maneira de obtê-lo é bloqueando seus tokens $META.

Se você ainda não tem $META – você vai precisar de algum! Veja abaixo “Como obtenho $META Tokens?”

 	Clique no botão que diz: + Add Voting Power.
 	Insira a quantidade de tokens $META que você deseja bloquear.
 	Selecione o período que deseja para “desbloquear” seus tokens com o controle deslizante. Este é o tempo de desbloqueio para seus tokens $META.

A quantidade mínima de tempo que seu $META pode ser bloqueado é de 30 dias e vai até 300 dias. Quanto mais tempo seu $META estiver bloqueado, mais poder de voto você terá para cada token $META bloqueado.



Após selecionar o seu período de bloqueio, clique no botão de bloqueio e aprove a transação através da carteira NEAR – e então você estará pronto para votar!

 	Use o poder de voto para votar nos projetos desejados ou apoiar os validadores.

 	Volte para https://metayield.app/ ou para https://vote.metapool.app/, atualize a página, e veja o poder de voto!

 	Meta Yield (Rendimento): Você pode usar o botão votar agora em qualquer projeto e apoiá-los com seus tokens. Além disso, você não precisa gastar todos os seus tokens em um projeto, pode apostar em vários!

 	Meta Staking Vote: Agora você pode dar o seu voto diretamente ao validador de sua escolha. Basta clicar no botão “votar”

do validador de sua escolha, ou selecione o validador que deseja apoiar, leia todas as informações referentes a este validador e vote nele. Você pode oferecer suporte a vários validadores, não apenas um.




Fórmula de aquisição de Poder de Votação para seus tokens $META
MULTIPLIER = 1 + (4 * (days – MIN_LOCK_DAYS) / (MAX_LOCK_DAYS – MIN_LOCK_DAYS))

 	MIN_LOCK_DAYS=30
 	MAX_LOCK_DAYS=300

Exemplo:


Como obtenho tokens $META?
No canto superior direito do app Meta Vote, clique em “Get More $META” –



Este link conecta com Ref Finance, para trocar tokens NEAR ou outros ativos nativos NEAR por tokens $ META.

 	https://app.ref.finance/#meta-pool.near|meta-token.near

Além disso, você pode obter tokens $META em qualquer plataforma DEFI do ecossistema NEAR.
Etapas de bloqueio
Período de bloqueio
O período de bloqueio é aquele que permite votar nos projetos. Os tokens $META são bloqueados e os usuários podem votar/cancelar o voto em projetos ou validadores em qualquer momento. Não há limite de tempo para esta etapa. O poder de votação estará disponível enquanto os tokens $META estiverem bloqueados.


Período de desbloqueio
Assim que a campanha de votação do projeto terminar ou o usuário quiser encerrar o suporte a um validador, pode iniciar o período de desbloqueio. Ao pressionar o botão “Start Unlock” (Iniciar desbloqueio) na posição de bloqueio desejada, o tempo de desbloqueio começa a correr, o que corresponde ao tempo definido pela adição de poderes de votação.

Deve ser tomado em conta que um estágio de desbloqueio só pode ser iniciado se houver poder de votação suficiente disponível. Caso haja poder de voto em uso e não seja suficiente para desbloquear uma posição plena, não poderá iniciar o período de desbloqueio.



Importante: o período de desbloqueio não inicia automaticamente, deve ser iniciado manualmente pelo usuário.
Retirada de tokens $META
Assim que o tempo de desbloqueio terminar, os tokens $META podem ser retirados.

Importante: a retirada dos tokens $META deve ser feita manualmente pelo usuário.






	

	
	
		
			
				Bloquear seus tokens no Meta Vote tem uma taxa de 3,5%
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Staking Vote – Use seu poder de votação para apoiar os melhores validadores
Meta Staking Vote é uma plataforma baseada na comunidade para a seleção de validadores para atribuir por voto 15% dos tokens NEAR staked no Meta Pool.

O Meta Pool dá poder de governança aos detentores de $META, pois são eles que votam no Meta Staking Vote.
Como usar o Meta Staking Vote?
Acesse Meta Staking Vote diretamente de seu link https://vote.metapool.app/.
Conecte a carteira NEAR no Meta Staking Vote
No site da Meta Staking Vote: https://vote.metapool.app/, Vincule a carteira NEAR. Clique no botão Connect Wallet (conectar carteira), escolha uma e conecte-se.


Meta Staking Vote funciona com 4 passos simples:

 	Bloqueie tokens $META na plataforma Meta Vote.
 	Obtenha poder de voto.
 	Vote nos validadores para dar apoio na plataforma Meta Staking Vote.
 	Veja um painel de votos e atribuições de stake NEAR.

Como funciona

 	Os usuários do Meta Pool põem seus tokens NEAR no stake, e recebem stNEAR em troca.
 	Esses Nears em stake são distribuídos para os nós do Validador. Isso ajuda a descentralizar e proteger o protocolo NEAR. Quanto mais usuários fazem stake no Meta Pool, mais é distribuído entre os nós validadores.
 	Os validadores produzem blocos e recebem recompensas por isso e aumenta o valor de stNEAR em tokens NEAR.
 	Do total de tokens NEAR no stake, o Meta Staking Vote delega 15% aos Validadores por meio do voto dos detentores de $META (apoiadores).

Esta será uma votação permanente e de acordo com os resultados, o Meta Staking Vote aloca 1% do valor total apostado no Meta Pool a cada 4 epochs (período de tempo dentro do stake).


Detentores de tokens $META
A votação consiste em dois passos:

 	Escolha do validador: va para: https://vote.metapool.app/ A lista completa de validadores rastreados pelo Meta Staking Vote.



Para mais informações, clique no nome dos validadores e será redirecionado para a página do validador, que contém informações mais detalhadas.



Uma vez que o Validador para apoiar e votar haja sido analisado e escolhido, vote. Selecione-o para ser votado na lista (botão de votação), ou na página do validador (botão de votação neste validador).

 	Voto do validador: Conecte a carteira NEAR. Selecione o validador a ser votado na lista clicando no botão “vote”, ou na página do validador clicando no botão “vote this validator” e atribua o poder de voto a ele.

Neste link também é explicado como obter poder de voto.

A votação do validador é uma campanha em andamento, portanto, os votos contam para cada campanha, durante o tempo que durar.

Vote em qualquer quantidade de validadores sem limite de alocação de Poder de Voto. Os votos podem ser alterados a qualquer momento.

É assim que funciona a votação para validadores no Meta Staking Vote, de forma simples, segura e recebendo 100% dos tokens $META de volta.
Delegation (Delegação): 
15% do Meta Pool TVL fornecido pelos stake dos usuários será delegado pelo voto dos detentores de $Meta.

Se o TVL aumenta, o valor distribuído aumenta. É muito importante promover o Meta Pool Liquid Staking Pool para investidores, para o qual contamos com o apoio dos validadores e da comunidade.

A campanha de delegação é contínua, e 1% do total staked no Meta Pool é atribuído a cada 4 epochs.




	

	
	
		
			
				Uma vez haja votado em um validador, você deve esperar 60 epochs para atribuir seu voto a outro validador.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plataforma – Dados Gerais


 	Validators (Validadores)

Este é o número de validadores aprovados pelo Meta Pool para serem votados de acordo com os critérios de seleção do validador.

 	Epoch progress (Progresso da epoch)

Indica o tempo restante da epoch de validação/produção do bloco.

Uma epoch dura aproximadamente 13 horas. (Uma epoch dura 43.200 blocos e um bloco dura aproximadamente 1,1 segundos).

 	NEAR staked @ Meta Pool

TVL (Valor Total Bloqueado) a ser delegado aos validadores. 85% por desempenho e 15% por votos no Meta Staking Vote.

Esse valor corresponde aos tokens NEAR staked no Meta Pool.

A quantidade está disponível em: https://staking.metapool.app/ – Tokens stNEAR totais multiplicados pelo preço stNEAR.

 	Near to be assigned by votes (Near a ser atribuído por votos)

15% do TVL a atribuir por votos. Quanto corresponde a cada validador individualmente pode ser visto em “Atribuído por votos".

 	Available Voting Power (Poder de voto disponível).

Poder de voto disponível para ser usado para votar em validadores. Se o Poder de Voto não estiver disponível, ele pode ser adquirido em: https://metavote.app/ (clicando no link abaixo do valor).

Importante: os tokens $META são necessários para obter o poder de votação. Adquira $META em. https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

 	In Use / Total (Em uso / Total)

Poder de voto em uso e o total que o usuário possui.

“Em uso” pode ser por já ter votado em validadores ou em projetos de votação no Meta Yield.
Detalhes de votação dos validadores


 	Name

Nome do validador.

Para saber mais sobre um determinado validador, basta clicar sobre o nome dele e será redirecionado para a página individual do validador selecionado.

 	APY

Rendimento Percentual Anual concedido por cada validador. Depende do desempenho e das taxas dos validadores.

 	Votes

Número de votos atribuídos a cada validador e a percentagem correspondente do total. A votação é contínua e indica a porcentagem de tendência de alocação a ser delegada.

 	Assigned by votes (Atribuído por votos)

Quantidade de tokens NEAR correspondentes a serem atribuídos a cada validador de acordo com os 15% a serem atribuídos por votos. Importante: apenas 1% será atribuído a cada aproximadamente 4 epochs.

Este é o valor que está predisposto a ser alcançado pelo atribuído a cada validador em função dos votos.

O total de TVL a ser atribuído por votos é distribuído aproximadamente a cada 15 grupos de 4 epochs.

 	Assigned Total (Total Atribuído)

Este valor corresponde ao valor a atribuir por desempenho (85%) e por votos (15%). É o predisposto total a ser alcançado pelo validador.

 	Meta Pool Staked

Near tokens atualmente delegados pelo Meta Pool a cada validador.




	

	
	
		
			
				O poder de votação pode ser usado no Meta Staking Vote ou em campanhas de votação da Meta Yield Vote .
			
		

		
					

		
			
			
			
			Verdadeira
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!

### DeFi em NEAR 2023

Em 2023, o ecossistema NEAR desenvolveu um conjunto de plataformas maduras para o ecossistema de Finanças Descentralizadas (DeFi). Possui uma ampla gama de aplicativos descentralizados (dApps) focados na gestão das finanças. NEAR é uma vitrine de uma blockchain de camada 1 escalável e com taxas baixas. Essa vantagem torna mais fácil para qualquer pessoa interessada iniciar seu caminho nos DeFi's.

O DeFi permite que os usuários tenham o gerenciamento sobre seus tokens digitais. Alguns dos principais recursos dessa tecnologia incluem:

 	Não custodial; o que significa que os usuários mantêm o controle de seus ativos durante todo o processo de negociação.
 	Transparente: todas as transações são registradas na blockchain e podem ser visualizadas por qualquer pessoa.
 	Seguro: Usando criptografia avançada e outras medidas de segurança para garantir que as negociações sejam seguras e protegidas.
 	Acessível: à qualquer pessoa com conexão à internet e carteira digital compatível.
 	Nenhuma autoridade central: de forma descentralizada, o que significa que não há nenhuma autoridade central controlando a bolsa.

A Proximity Labs, uma empresa de pesquisa e desenvolvimento, incluindo um fundo de capital de risco, procura a próxima geração de plataformas DeFi que deseja desenvolver no protocolo NEAR. Se você é um desenvolvedor e procura suporte para aprimorar seu dApp DeFi desenvolvido na NEAR procure por eles.

Por último, precisamos adicionar contexto. Os eventos ocorreram durante 2022 (como Terra-Luna, FTX-Alameda e outros), e o ecossistema cripto fez mudanças radicais para o futuro DeFi, exigindo plataformas mais dinâmicas e inovadoras que possam suportar ambos: mercados de baixa e alta. Considerando todas as vantagens tecnológicas, este escritor acredita que o futuro do DeFi deve ser construído na NEAR.
Exchanges descentralizadas (DEX)
Ref Finance


A Ref Finance, pioneira em finanças descentralizadas no protocolo NEAR , oferece um serviço de swap abrangente para tokens com pools e farms de liquidez. A plataforma evoluiu ao longo do tempo para incluir um Automatic Market Maker (AMM) para experiências de negociação perfeitas.

A Ref Finance é regida por uma DAO que mantém uma lista branca de tokens para negociação na plataforma, garantindo a segurança e estabilidade dos ativos. A partir de 2023, Ref Finance continua sendo o principal DEX na NEAR com um roteiro promissor para expandir seus recursos.

No primeiro trimestre de 2023, a Ref Finance planeja lançar o Ref V2 Farms, as principais métricas do Ref Analytics e a integração de liquidez do Orderly para uma experiência pura do Central Limit Order Book (CLOB). No segundo trimestre de 2023, a plataforma visa introduzir primitivas de empréstimo incorporadas, uma proposta de troca aprimorada, widgets Ref e Zap Swap.



No segundo semestre de 2023, a Ref Finance planeja lançar swaps recorrentes, Sentinel em pools e fazendas, liquidez como garantia e soluções inovadoras para melhor segurança e proteção do usuário. Com seu roteiro ambicioso, a Ref Finance está pronta para consolidar sua posição como DEX líder no ecossistema NEAR.
Spin Finance


Spin Finance é uma plataforma de negociação descentralizada que oferece ferramentas de negociação avançadas para usuários NEAR, incluindo futuros perpétuos em NEAR, ETH e BTC. Além da negociação à vista tradicional, a Spin fornece DOVs e cofres para farm. Ao utilizar esses cofres, os comerciantes podem participar com facilidade e segurança da farm sem precisar negociar individualmente.



Além disso, o roteiro da Spin Finance inclui a introdução de novos recursos, como negociação de opções, AIPs e um Market Maker descentralizado. Essas ferramentas avançadas podem ser úteis tanto para comerciantes quanto para degens, fazendo com que qualquer token no Ecossistema NEAR valha a pena considerar para utilização.



O modelo híbrido exclusivo da Spin Finance combina as vantagens das exchanges centralizadas e descentralizadas, destacando-se entre seus pares. Desde o seu lançamento em 2021 como carteira de pedidos da NEAR, a Spin não para de crescer, com uma equipe em expansão que promete um futuro brilhante pela frente. Se você está procurando uma plataforma de negociação avançada que combine o melhor dos dois mundos, a Spin Finance pode ser a escolha perfeita para você.
Jump DeFi


O Jump DeFi é um dapp abrangente que fornece uma variedade de soluções para lançamento, levantamento de capital e troca de tokens NEP-141. É considerado um ecossistema que capacita indivíduos e organizações a dar seus primeiros passos no mundo do DeFi.

Uma das ferramentas mais notáveis ​​fornecidas pelo Jump Defi é o serviço de staking de NFT, que permite que as comunidades NFT apoiem seus titulares, fornecendo-lhes tokens. Este serviço é projetado para incentivar a realização de NFTs e criar uma comunidade mais engajada.

O Jump Token Laboratory é outra ferramenta inovadora fornecida pelo Jump DeFi, que permite aos usuários criar tokens e, posteriormente, movê-los para o Jump Pad, uma plataforma de lançamento que facilita a arrecadação de fundos no ecossistema NEAR.



A Jump DeFi também foi anfitriã de uma campanha de aumento de rendimento para NEKO, uma moeda de meme que vive no protocolo NEAR. A plataforma também lançou campanhas de crowdfunding em outras plataformas de lançamento, incluindo Meta Yield, onde arrecadou um total de $68.416 USD em tokens stNEAR que fornecerão todas as recompensas de apostas.

É uma plataforma incrível e abrangente que oferece uma gama diversificada de serviços DeFi no protocolo NEAR, incluindo staking, arrecadação de fundos e criação de tokens. É uma plataforma que tem o potencial de abrir novas oportunidades e possibilidades para quem deseja participar do ecossistema financeiro descentralizado.
Liquid Staking
Meta Pool
A aposta líquida tornou-se uma solução popular para aqueles que desejam apostar seus tokens e ganhar recompensas, mas também desejam manter a capacidade de usar esses tokens de outras maneiras. O Meta Pool é a primeira e maior solução de apostas líquidas no protocolo NEAR, fornecendo uma maneira para os usuários ganharem recompensas de apostas enquanto ainda podem usar seus tokens apostados no ecossistema DeFi.

O Meta Pool foi lançado com seu token digital de staking, $stNEAR, que permite aos usuários continuar apostando enquanto também usa o derivado $stNEAR no ecossistema DeFi. O protocolo é gerenciado por uma DAO que recompensa os usuários com $META, um token de governança que pode ser usado para participar da comunidade que conduz a DAO do Meta Pool.



Uma das características únicas do Meta Pool é a implementação do Meta Staking Vote, que permite aos detentores de $META selecionar quais validadores são os melhores a serem suportados. Esses validadores recebem 15% do Valor Total Bloqueado (TVL) do Meta Pool distribuído com base em sua votação. Essa abordagem garante que a comunidade Meta Pool tenha voz ativa nos validadores, promovendo a descentralização e o envolvimento da comunidade na rede.

Hoje, a família de produtos lançada pela Meta Pool foi aprimorada e composta por:

 	$stNEAR, Liquid Staking em NEAR.
 	Pool de liquidez para retirada líquida no protocolo NEAR.
 	Token $stAUR, aposta líquida em Aurora
 	Meta Yield, a primeira plataforma de crowdfunding sem perdas na NEAR.
 	Meta Bond, venda suas posições bloqueadas no Meta Yield.
 	Meta Vote, obtenha poder de voto para a governança do Meta Pool.

Meta Pool é um protocolo sem permissão que fornece uma maneira para os usuários apostarem seus tokens e ganharem recompensas, além de manter a capacidade de usar esses tokens de outras maneiras. Com a implementação do Meta Staking Vote e a distribuição de tokens de governança $META, a Meta Pool promove o envolvimento e participação da comunidade na governança de sua rede.




	

	
	
		
			
				Quais dos seguintes são Exchanges Descentralizadas construídas no protocolo NEAR? (múltiplas respostas)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Uniswap
		
			
			Ref Finance
		
			
			Spin Finance
		
			
			Jump DeFi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Protocolo LiNEAR


$LiNEAR é uma solução de staking líquida fornecida pelo Linear Protocol, um dos principais projetos do ecossistema NEAR. Faz parte do Cornerstone, um protocolo de metagovernança criado para dar suporte ao crescente ecossistema NEAR, oferecendo tokens $CORN aos usuários de suas plataformas.

Com um APY relativamente alto de cerca de 9%, o LiNEAR ganhou popularidade entre os usuários que procuram uma opção lucrativa de apostas líquidas na NEAR. O protocolo também apoiou recentemente o Stake Wars III, uma competição na NEAR que permite que mais validadores participem da rede como produtores de blocos, fortalecendo ainda mais o ecossistema.

A Linear Protocol também anunciou seu mais recente produto, Phoenix Bonds, uma fazenda geradora de rendimento disponível na Ref Finance para provedores de liquidez NEAR<>pNEAR. Isso fornecerá outra oportunidade para os usuários ganharem recompensas enquanto apoiam a liquidez do NEAR e do pNEAR. Com foco na construção de produtos DeFi inovadores e úteis, o Linear Protocol é um projeto a ser observado no ecossistema NEAR.
Stader Labs na NEAR


A Stader Labs trouxe sua solução inovadora de apostas líquidas para o protocolo NEAR, permitindo que os usuários ganhem recompensas de apostas enquanto também têm acesso a seus tokens apostados por meio de seu token $NearX.

A plataforma se integrou a várias carteiras para facilitar a participação dos usuários em apostas líquidas. Além disso, Stader Labs levou a segurança a sério e passou por rigorosas auditorias de segurança de Halborn, BlockSec e OSec, que deram à plataforma seu selo de aprovação.

Além do protocolo NEAR, a Stader Labs está presente em várias outras cadeias, incluindo Polying, Fantom, BNB Chain e Hedera, fornecendo soluções de apostas líquidas para usuários em vários ecossistemas.

Especificamente no ecossistema NEAR, o token líquido de staking $NearX está disponível em ambos: protocolo NEAR e Aurora Network, um EVM executado em NEAR, oferecendo aos usuários ainda mais flexibilidade e opções quando se trata de staking de seus tokens.
Plataformas de empréstimo
Burrow Cash


O financiamento descentralizado abriu um mundo de possibilidades quando se trata de empréstimos. O Burrow Cash é uma plataforma de empréstimo executada no protocolo NEAR que oferece uma maneira descentralizada de emprestar e tomar emprestado tokens sem a necessidade de um intermediário centralizado.

Com o Burrow Cash, os usuários podem bloquear seus tokens e usá-los como garantia para solicitar outro token, permitindo que eles tenham acesso a novos tokens sem precisar vender suas posições existentes. Isso é particularmente útil para usuários que não desejam vender seus tokens, mas ainda desejam acessar outros tokens ou precisam de liquidez.

O Burrow Cash usa oráculos para monitorar os preços dos tokens, garantindo que a garantia do usuário permaneça estável e que ele receba uma quantidade justa de tokens em troca de sua garantia. No entanto, é importante lembrar que, se o valor da garantia cair, ela corre o risco de ser liquidada para pagar a dívida.

Além de empréstimos, o Burrow Cash também oferece pools de liquidez, onde os usuários podem fornecer seus tokens para empréstimos e ganhar recompensas em troca. Esses pools de liquidez fornecem outra maneira para os usuários obterem retorno sobre seus tokens e também fornecem liquidez à plataforma, o que ajuda a garantir que sempre haja liquidez suficiente disponível para quem deseja tomar emprestado ou emprestar.

No geral, o Burrow Cash é uma plataforma de empréstimo descentralizada que oferece uma maneira simples, segura e eficiente de emprestar e tomar emprestados tokens no protocolo NEAR. Usando oráculos para monitorar os preços dos tokens e fornecer pools de liquidez, o Burrow Cash oferece uma maneira confiável e conveniente para os usuários acessarem novos tokens, além de ganhar recompensas em seus tokens existentes.






	

	
	
		
			
				Quais dos seguintes são serviços de apostas líquidas na NEAR? (múltiplas respostas)
			
		

		
					

		
			Please select 3 correct answers
			
			
			MetaPool
		
			
			Protocolo LiNEAR
		
			
			Stader Labs
		
			
			Rocket Pool
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Launchpads
Meta Yeld


A Meta Yield é uma plataforma de crowdfunding que aproveita a participação líquida para fornecer suporte financeiro e exposição a projetos da web 3.0 construídos no protocolo NEAR. Os patrocinadores confirmam e bloqueiam o stNEAR para apoiar projetos e ganhar tokens de novos projetos lançados na NEAR ou recebem uma entrega NFT. Os projetos ganham apenas recompensas de aposta do que os patrocinadores comprometem, não de seus ativos criptográficos subjacentes. Os apoiadores podem recuperar 100% de seus tokens NEAR no final do período de bloqueio, tornando o Meta Yield uma plataforma de crowdfunding baseada em recompensas de apostas sem perdas.

Como apoiador no Meta Yield Launchpad, você obtém acesso antecipado ao projeto que apoiou, tokens de projeto com valor superior ao preço de mercado e a capacidade de recuperar seu investimento inicial de tokens NEAR. Para reivindicar seus tokens de projeto e recuperar seus tokens, o processo é direto e envolve algumas etapas simples.

No geral, a Meta Yield oferece um mecanismo exclusivo de arrecadação de fundos para projetos da web 3.0 no NEAR. Ele permite que os patrocinadores apoiem projetos sem perder seus tokens apostados e ganhem recompensas de novos projetos lançados na NEAR. Se você se tornar um apoiador, poderá desfrutar de vários benefícios, como acesso antecipado a projetos, tokens de projeto de maior valor e a capacidade de recuperar seu investimento inicial em tokens NEAR.


Meta Bonds, um mercado secundário para posições bloqueadas de Meta Yield
Meta Bonds é um mercado secundário que permite aos patrocinadores de campanhas de crowdfunding no Meta Yield negociar suas posições bloqueadas na forma de títulos.

Meta Yield é um protocolo de crowdfunding que usa stNEAR, um token apostado que gera rendimento ao fornecer liquidez ao protocolo Meta Yield. Quando os apoiadores apoiam um projeto no Meta Yield, eles recebem dois IOUs na forma de títulos: um para o investimento original e outro para os tokens do projeto que receberão em troca de suas recompensas.

O primeiro título fica disponível quando o período de bloqueio termina, e o segundo título pode ser reivindicado após o período de liberação gradual. Durante esse período, os apoiadores podem investir seus tokens colocando-os no mercado, que pode ser acessado visitando o site da Meta Bonds em metabondsmarket.app.

Meta Bonds permite que os apoiadores monetizem seus investimentos antes do término do período de liberação gradual. Isso cria uma oportunidade para os financiadores negociarem seus títulos por outros ativos, como outros tokens ou criptomoedas, além de fornecer liquidez ao mercado.

Ao criar um mercado secundário para posições bloqueadas, o Meta Bonds fornece liquidez e oportunidades de negociação, além de criar um novo caminho para monetização de investimentos.


NEAR Starter


O NEAR Starter é uma iniciativa revolucionária que está capacitando novos projetos para construir e lançar no protocolo NEAR. Concebido como uma organização autônoma descentralizada (DAO), o NEAR Starter fornece um ecossistema abrangente de suporte para projetos em estágio inicial. O NEAR Starter Launchpad é parte integrante desse ecossistema, permitindo que os projetos façam uma Oferta Inicial Descentralizada (IDO) e levantem fundos da comunidade.

Além de seu Launchpad, o NEAR Starter também ganhou fama ao fornecer coleções NFT que permitem aos usuários cultivar $NEARIA, o token de índice que está sendo usado para troca de projetos. Essa abordagem inovadora ajudou a criar uma comunidade vibrante e engajada em torno do NEAR Starter, com usuários participando avidamente do processo de farm.

O site NEAR Starter é construído sobre a Aurora Network, que permite taxas baixas e conectividade perfeita por meio da Meta Mask. Isso garante que os usuários possam participar com facilidade e segurança do Launchpad e dos processos de cultivo, sem ter que se preocupar com taxas excessivas ou requisitos técnicos complexos.

Para mostrar o poder de seu Launchpad, o NEAR Starter lançou recentemente o token $NEARIA por meio de um IDO, com uma meta de 24 ETH a serem coletados. Este lançamento bem-sucedido é apenas o começo para o NEAR Starter, pois continua a apoiar e incubar novos projetos no protocolo NEAR.



Agregadores de Rendimento
Finanças de Pembrock
​​



Com o protocolo NEAR fornecendo uma plataforma robusta para aplicativos DeFi, o Pembrock se destaca como um protocolo de cultivo de rendimento alavancado que utiliza várias estratégias para cultivar tokens do protocolo NEAR.

O que torna a Pembrock única é que ela atende a dois tipos de usuários: credores e agricultores de rendimento alavancado. Os credores podem obter renda passiva depositando suas criptomoedas em cofres, que financiam pools de liquidez. Por outro lado, os agricultores de rendimento alavancado podem maximizar seus lucros abrindo uma posição alavancada. Isso significa que os usuários podem emprestar fundos adicionais da plataforma, pagando uma pequena quantia de juros sobre seus lucros.

Pembrock tem uma gama diversificada de pools disponíveis, incluindo wNEAR, ETH, PEM, SWEAT, USDC.e e mais moedas disponíveis no ecossistema NEAR. Seja você um iniciante ou um investidor experiente, iniciar uma posição na Pembrock é simples. Tudo o que você precisa fazer é visitar o site e procurar cultivo ou empréstimo em seus pools. Com a interface amigável do Pembrock, você pode navegar facilmente pelos pools e escolher aquele que melhor se adapta à sua estratégia de investimento.

No geral, Pembrock é um excelente exemplo de como o DeFi está revolucionando o setor financeiro tradicional. Ao utilizar protocolos descentralizados, a Pembrock oferece aos usuários uma oportunidade de obter renda passiva e maximizar seus lucros por meio da farm de rendimento alavancado.


O fim, por enquanto…
DeFi na NEAR Protocol é um ecossistema em rápida evolução que oferece várias soluções inovadoras para os usuários. Com forte foco em escalabilidade, interoperabilidade e experiência do usuário, a NEAR Protocol está atraindo muitos desenvolvedores e investidores para construir e investir em projetos DeFi na plataforma. À medida que o ecossistema continua crescendo e amadurecendo, espera-se que ele se torne um player significativo no cenário DeFi mais amplo, oferecendo recursos e vantagens exclusivos para seus usuários.

Este post apresentou vários projetos DeFi no protocolo NEAR. Cada um desses projetos possui recursos exclusivos e contribui para o crescente ecossistema DeFi na NEAR. Sabemos que mais cedo ou mais tarde este artigo terá que ser reescrito para incluir os novos e incríveis apps que virão.

Vejo você em breve!




	

	
	
		
			
				Quais dos seguintes são plataformas de lançamento no ecossistema NEAR? (múltiplas respostas)
			
		

		
					

		
			Please select 2 correct answers
			
			
			DuckStarter
		
			
			Near Starter
		
			
			Meta Yeld
		
			
			Ethereum Launchpad
		
	
		

		
		
			
				Correct!
				Wrong!

### Qu'est-ce que FastAuth ?

En mars, NEAR protocol a annoncé le lancement du système d'exploitation Blockchain ou de la Blockchain Operating System en anglais (BOS). L'idée sous-jacente était de créer le point d'entrée idéal vers l'Open Web et de combler le fossé entre Web2 et Web3. La Blockchain Operating System de NEAR a également vu l'introduction de plusieurs nouvelles fonctionnalités. L 'une des premières et des plus puissantes qui a été introduite, c'est FastAuth.

Dans cet article, nous allons examiner de plus près FastAuth, comprendre son importance, son fonctionnement et ce que l'avenir nous réserve. C'est parti !
Qu'est-ce que le Système D'exploitation De La Blockchain ?
Avant de passer à FastAuth, comprenons brièvement le système d'exploitation de la blockchain ou Blockchain Operating System. Aujourd'hui, le monde du Web 2 et Web3 est fortement fragmenté. Le Web2 est très centralisé, chaque compte étant contrôlé par une seule entité. Le Web3, quant à lui, est fragmenté, car chaque blockchain est cloisonnée et coupée de l'autre. La Blockchain Operating System de NEAR aborde cette question en proposant la possibilité de découvrir des expériences avec des services communs tels qu'une identité unique, des données contrôlées par l'utilisateur et des actifs contrôlés par l'utilisateur.

La Blockchain Operating System est un nouveau système d'exploitation conçu pour un web plus ouvert. Le système est sécurisé, hautement décentralisé, facile à intégrer, facile à développer, open source et accessible à tous. Il a été créé comme une alternative open-source aux géants traditionnels tels qu'Apple, Amazon, Google, Facebook et Microsoft et élimine les complexités généralement associées à l'espace Web3. Il fonctionne avec n'importe quelle blockchain ou backend Web2, permettant l'accès à diverses passerelles. Les utilisateurs finaux bénéficient d'une expérience continue grâce à la Blockchain Operating System, similaire à l'utilisation d'une application unique, même si les utilisateurs doivent passer d'une chaîne ou d'une application à l'autre.

Il simplifie également le développement de la blockchain, permettant aux développeurs de s'appuyer sur n'importe quelle chaîne, de créer du code dans des langages familiers et de créer des applications innovantes qui sont facilement distribuables et découvrables. Les utilisateurs peuvent ainsi se connecter à un écosystème croissant de communautés, de personnes et d'applications tout en conservant le contrôle total de leurs données. En outre, les utilisateurs n'ont pas besoin de crypto-monnaie pour commencer, la Blockchain Operating System ouvre une multitude de flux de revenus et de capacités sans nécessiter d'expérience préalable dans le domaine du Web 3.
Qu'est-ce que FastAuth ?
FastAuth est une fonctionnalité puissante introduite avec la Blockchain Operating System qui permet aux utilisateurs de créer rapidement et facilement des comptes qui peuvent être utilisés sur n'importe quelle application ou site web qui peut être intégré avec la Blockchain Operating System. FastAuth met l'accent sur l'expérience utilisateur et crée une expérience d'accueil familière, de type Web2, qui permet aux utilisateurs de créer leur compte gratuit en utilisant des moyens traditionnels tels que les adresses e-mail, les messages téléphoniques et même la biométrie. Cela permet aux utilisateurs d'interagir rapidement avec les applications et de s'authentifier à nouveau en utilisant le même appareil ou un appareil différent.

Avec FastAuth, les utilisateurs peuvent créer un compte pour n'importe quel site web ou application sur la Blockchain Operating System sans avoir besoin de nouveaux mots de passe ou d'acheter de la crypto-monnaie. FastAuth est également super pour les développeurs, car il leur offre un moyen rapide et facile d'inciter les utilisateurs à essayer de nouvelles applications et de nouveaux composants. Cela permet d'améliorer considérablement l'adoption et d'amener des millions d'utilisateurs du Web2 dans l'écosystème du Web3 en abaissant la barrière d'entrée.
Comment fonctionne FastAuth ?
L'introduction de FastAuth a permis de répondre à l'un des plus grands défis de l'intégration de nouveaux utilisateurs dans l'écosystème Web3. Les nouveaux utilisateurs peuvent créer un compte Blockchain Operating Service aussi rapidement qu'un compte traditionnel, tandis que les développeurs peuvent fournir leurs applications, expériences et composants Web3 de manière plus transparente que jamais. Voyons comment FastAuth comble le fossé entre Web2 et Web3 et améliore l'adoption de Web3 parmi les utilisateurs de Web2.
Processus D'intégration Rapide et Transparent et Récupération Des Emails
L'un des plus grands défis lors de l'intégration des utilisateurs dans Web3 est la complexité du processus d'intégration et la nécessité pour les utilisateurs de se souvenir de phrases d'initialisation compliquées. La plupart des utilisateurs sont habitués aux méthodes d'authentification centralisées traditionnelles, telles que la connexion à Google. Par conséquent, l'utilisation et l'accoutumance à des phrases d'initialisation complexes peuvent être assez décourageantes et créer une barrière d'entrée importante. Il est donc difficile d'intégrer de nouveaux utilisateurs dans l'écosystème Web3.

En combinant FastAuth avec la récupération décentralisée des emails, les utilisateurs n'ont plus besoin de se souvenir de phrases d’initialisation complexes ou d'applications de portefeuilles tiers. Les utilisateurs peuvent simplement récupérer un compte en utilisant un processus de "Single Sign-On" avec l'email qu'ils ont utilisé pendant le processus d'enregistrement. FastAuth, utilise le "Multi-Party Computation" pour décentraliser le processus de récupération de compte, ouvrant ainsi la voie à une adoption massive grâce à un système de récupération de compte facile, sécurisé et décentralisé.

En conséquence, FastAuth est en mesure de répondre à certains des aspects les plus difficiles de l'intégration de nouveaux utilisateurs dans l'écosystème Web3. Les utilisateurs peuvent créer un compte Blockchain Operating System plus rapidement qu'un compte Google ou Facebook traditionnel. Dans le même temps, les développeurs peuvent fournir des applications, des expériences et des composants Web3 aux utilisateurs de manière transparente.




	

	
	
		
			
				Qu'est-ce que FastAuth ?
			
		

		
					

		
			
			
			
			Une solution transparente pour une intégration rapide à la Blockchain Operating System
		
			
			Un nouveau système d'exploitation pour le web ouvert
		
			
			Un nouveau protocole blockchain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pas D'applications Tierces
FastAuth élimine également le besoin de télécharger et d'installer des applications tierces. C’est parce qu’il crée une expérience transparente et centrée sur l'utilisateur, rendant le web ouvert accessible à tous instantanément, ouvrant ainsi la voie à une adoption généralisée. Tout développeur utilisant la Blockchain Operating System peut tirer parti de l'expérience conviviale de FastAuth et faire en sorte que les utilisateurs se connectent à leurs applications.
Pas Besoin De Crypto-monnaie Pour Créer Un Compte
Jusqu'à présent, les utilisateurs qui souhaitaient explorer et interagir avec des applications dans Web3 devaient détenir ou acquérir des crypto-monnaies avant de commencer. FastAuth permet aux utilisateurs d'accéder directement à l'écosystème Web3 sans courir partout pour mettre la main sur des crypto-monnaies. C'est très avantageux pour tous les utilisateurs, y compris les utilisateurs finaux, les développeurs et les entreprises. FastAuth utilise les Comptes NEAR à Solde Zéro et les Meta-Transactions, ce qui permet aux utilisateurs d'enregistrer leurs comptes gratuitement. Ceci est également avantageux pour les développeurs, car les Meta-Transactions sont associées à des relais, permettant des interactions initiales sans acquisition de $NEAR.
Qui peut utiliser FastAuth ?
FastAuth est une solution idéale pour les développeurs, les utilisateurs finaux et les entreprises. Voyons comment chacun peut en bénéficier.
Les Développeurs
Grâce à l'expérience d'accueil simplifiée de FastAuth, les développeurs peuvent augmenter le taux de conversion des utilisateurs qui essaient leurs applications et leurs composants. Ils peuvent par ailleurs élargir la base d'utilisateurs d'une application en lui donnant une plus grande visibilité auprès du grand public.
Les Entreprises
FastAuth permet aux entreprises d'intégrer facilement Web3 et la cryptographie dans leurs activités avec seulement quelques lignes de code. Les entreprises peuvent aisément embarquer les utilisateurs dans une communauté puissante et des expériences qui sont accessibles, décentralisées et hautement sécurisées.
Les Utilisateurs Finaux
Grâce à FastAuth, les utilisateurs peuvent créer leur propre compte en quelques secondes, ce qui leur permet de commencer à utiliser Web3 rapidement et de manière transparente.




	

	
	
		
			
				Pour qui FastAuth a-t-il été créé ?
			
		

		
					

		
			
			
			
			Les développeurs
		
			
			Les entreprises
		
			
			Les utilisateurs
		
			
			Tous les utilisateurs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pour Conclure : L'avenir
FastAuth ne fait que commencer, et il y a plusieurs autres fonctionnalités et mises à jour qui sont en cours d'élaboration. Dans son effort pour relier Web2 et Web3, FastAuth a pour objectif d'introduire les fonctionnalités suivantes dans un futur proche.

 	Compatibilité multichaînes
 	Décentralisation MPC supplémentaire
 	Authentification à deux facteurs
 	Extension des relais et de FastAuth aux passerelles au-delà de NEAR.

Si vous souhaitez en savoir plus sur les prochaines fonctionnalités de FastAuth, consultez near.org pour plus d'informations. Si vous souhaitez tester FastAuth par vous-même, vous pouvez créer un compte ici et utiliser le même compte pour vous connecter partout sur NEAR.




	

	
	
		
			
				Quels sont les défis rencontrés lors de l'intégration des utilisateurs dans Web3 ?
			
		

		
					

		
			
			
			
			Une expérience d'accueil compliquée
		
			
			Des longs mots de passe ou phrases d'initialisation
		
			
			La nécessité d'acquérir de la cryptographie avant d'accéder à Web3
		
			
			Toutes les réponses ci-dessus
		
	
		

		
		
			
				Correct!
				Wrong!

### ¿Qué es FastAuth?

En marzo, el Protocolo NEAR anunció el lanzamiento del Sistema Operativo Blockchain (BOS por sus siglas en inglés). La idea subyacente era crear el punto de entrada ideal a la Open Web y tender un puente entre Web2 y Web3. El Sistema Operativo Blockchain de NEAR también supuso la introducción de varias funciones nuevas. Una de las primeras y más potentes es FastAuth.

En este artículo analizaremos FastAuth en profundidad, comprenderemos su importancia, cómo funciona y qué nos depara el futuro. ¡Comencemos!
¿Qué es el sistema operativo Blockchain?
Antes de pasar a FastAuth, entendamos brevemente el Sistema Operativo Blockchain. Hoy en día, el mundo Web2 y Web3 está muy fragmentado. La Web2 está altamente centralizada, con cada cuenta controlada por una única entidad. Mientras tanto, la Web3 está fragmentada porque cada cadena de bloques está aislada y desconectada de la otra. El Sistema Operativo Blockchain de NEAR aborda este problema ofreciendo una vía para descubrir experiencias con servicios comunes como una identidad única, datos controlados por el usuario y activos controlados por el usuario.

El Sistema Operativo Blockchain es un nuevo sistema operativo diseñado para una web más abierta. El sistema es seguro, altamente descentralizado, fácil de integrar, fácil de desarrollar, de código abierto y accesible para todos. Fue creado como una alternativa de código abierto a los gigantes tradicionales como Apple, Amazon, Google, Facebook y Microsoft y elimina las complejidades típicamente asociadas con el espacio Web3. Funciona con cualquier blockchain o backend Web2, permitiendo el acceso a diversas pasarelas. Los usuarios finales obtienen una experiencia continua a través del Sistema Operativo Blockchain, similar al uso de una única aplicación, incluso si los usuarios tienen que cambiar entre diferentes cadenas o aplicaciones.

También simplifica el desarrollo de la blockchain, permitiendo a los desarrolladores construir sobre cualquier cadena, crear código en lenguajes familiares y crear aplicaciones innovadoras que sean fácilmente distribuibles y descubribles. Esto permite a los usuarios conectarse con un ecosistema creciente de comunidades, personas y aplicaciones, al tiempo que mantienen el control total de sus datos. Además, los usuarios no necesitan ninguna criptomoneda para empezar, ya que el Sistema Operativo Blockchain abre una serie de fuentes de ingresos y capacidades sin necesidad de tener experiencia previa en la Web 3.
¿Qué es FastAuth?
FastAuth es una potente función introducida con el Sistema Operativo Blockchain que permite a los usuarios crear rápida y fácilmente cuentas que pueden utilizarse en cualquier aplicación o sitio web que pueda integrarse con el Sistema Operativo Blockchain. FastAuth hace hincapié en la experiencia del usuario y crea una experiencia familiar, de tipo Web2, que permite a los usuarios abrir su cuenta gratuita utilizando medios tradicionales como direcciones de correo electrónico, mensajes telefónicos e incluso datos biométricos. Esto permite a los usuarios interactuar con las aplicaciones rápidamente y les posibilita volver a autenticarse en la aplicación utilizando el mismo dispositivo o uno diferente.

Con FastAuth, los usuarios pueden crear una cuenta para cualquier sitio web o aplicación en el Sistema Operativo Blockchain sin necesidad de nuevas contraseñas ni de comprar criptomonedas. FastAuth también es excelente para los desarrolladores, ya que les ofrece una forma rápida y sencilla de conseguir que los usuarios prueben nuevas aplicaciones y componentes. Esto ayuda a mejorar significativamente la adopción y traer a millones de usuarios de Web2 al ecosistema Web3 al reducir la barrera de entrada.
¿Cómo funciona FastAuth?
La introducción de FastAuth ha ayudado a abordar uno de los mayores retos en la incorporación de nuevos usuarios al ecosistema Web3. Los nuevos usuarios pueden crear una cuenta en el Servicio Operativo Blockchain tan rápido como si se tratara de una cuenta tradicional, mientras que los desarrolladores pueden ofrecer sus aplicaciones, experiencias y componentes Web3 con más fluidez que nunca. Veamos cómo FastAuth está salvando las distancias entre Web2 y Web3 y mejorando la adopción de la Web3 entre los usuarios de la Web2.
Proceso de Incorporación y Recuperación del Correo Electrónico Rápido y Sin Problemas
Uno de los mayores retos a la hora de introducir a los usuarios en la Web3 es la complejidad del proceso de incorporación y la necesidad de que los usuarios recuerden complicadas frases de inicio. La mayoría de los usuarios están acostumbrados a los métodos tradicionales de autenticación centralizada, como el inicio de sesión con Google. En consecuencia, utilizar y acostumbrarse a complejas frases de inicio puede resultar bastante desalentador y supone una importante barrera de entrada. Esto dificulta la incorporación de nuevos usuarios al ecosistema Web3.

La combinación de FastAuth con la recuperación descentralizada del correo electrónico elimina la necesidad de que los usuarios tengan que recordar complicadas frases semilla o aplicaciones de billeteras de terceros. Los usuarios pueden simplemente recuperar una cuenta mediante un proceso de "inicio de sesión único" con el correo electrónico que han utilizado durante el proceso de registro. FastAuth utiliza "Multi-Party Computation" para descentralizar el proceso de recuperación de cuentas, facilitando la adopción masiva a través de un sistema de recuperación de cuentas fácil, seguro y descentralizado.

Como resultado, FastAuth es capaz de abordar algunos de los aspectos más difíciles de la incorporación de nuevos usuarios al ecosistema Web3. Los usuarios pueden crear una cuenta en el Sistema Operativo Blockchain más rápido que una cuenta tradicional de Google o Facebook. Al mismo tiempo, los desarrolladores pueden ofrecer aplicaciones, experiencias y componentes Web3 a los usuarios de una manera fluida.




	

	
	
		
			
				¿Qué es FastAuth? 
			
		

		
					

		
			
			
			
			Una solución sin fisuras para una rápida incorporación al sistema operativo Blockchain
		
			
			Un nuevo sistema operativo para la web abierta
		
			
			Un nuevo protocolo blockchain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sin Aplicaciones de Terceros
FastAuth también elimina la necesidad de descargar e instalar aplicaciones de terceros. Esto se debe a que crea una experiencia fluida y centrada en el usuario, haciendo que la web abierta sea accesible a todo el mundo al instante, despejando el camino para la adopción generalizada. Cualquier desarrollador que trabaje con el Sistema Operativo Blockchain puede aprovechar la experiencia de uso de FastAuth y conseguir usuarios en sus aplicaciones.
No Hace Falta Tener Criptomonedas Para Crear Una Cuenta
Hasta ahora, los usuarios que deseaban explorar e interactuar con aplicaciones en la Web3 tenían que poseer o adquirir criptomonedas antes de empezar. FastAuth permite a los usuarios acceder directamente al ecosistema Web3 sin tener que correr por todos lados para conseguir criptomonedas. Esto es muy beneficioso para todos los usuarios, incluidos los usuarios finales, los desarrolladores y las empresas. FastAuth utiliza Cuentas de Balance Cero y Meta Transacciones de NEAR, permitiendo a los usuarios registrar sus cuentas de forma gratuita. Esto también es ventajoso para los desarrolladores porque las Meta Transacciones se emparejan con los repetidores o relayers (en inglés), permitiendo interacciones iniciales sin adquirir $NEAR.
¿Quién puede utilizar FastAuth?
FastAuth es una solución ideal para desarrolladores, usuarios finales y empresas. Veamos cómo pueden beneficiarse de ella.
Desarrolladores
Gracias a la experiencia de incorporación optimizada de FastAuth, los desarrolladores pueden aumentar la tasa de conversión de los usuarios que prueban sus aplicaciones y componentes. También pueden ampliar la base de usuarios de una aplicación dándole una mayor visibilidad
Empresas
FastAuth permite a las empresas integrar fácilmente a la Web3 y las criptomonedas en sus negocios con solo unas pocas líneas de código. Las empresas pueden incorporar fácilmente a los usuarios a una potente comunidad y a experiencias accesibles, descentralizadas y muy seguras.
Usuarios Finales
Gracias a FastAuth, los usuarios pueden crear su propia cuenta en cuestión de segundos, lo que les permite empezar a utilizar la Web3 de forma rápida y sin problemas.




	

	
	
		
			
				¿Para quién se ha creado FastAuth?
			
		

		
					

		
			
			
			
			Desarrolladores
		
			
			Empresas
		
			
			Usuarios
		
			
			Todos los anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Para Cerrar: El Futuro
FastAuth está apenas comenzando, y hay varias características y actualizaciones que están aún en desarrollo. En su esfuerzo por tender puentes entre la Web2 y la Web3, FastAuth pretende introducir las siguientes funciones en un futuro próximo.

 	Compatibilidad multicadena
 	Descentralización MPC adicional
 	Autenticación de dos factores
 	Ampliación de relayers (repetidores) y FastAuth a pasarelas más allá de NEAR.

Si deseas obtener más información sobre las próximas funciones de FastAuth, visita near.org. Si desea probar FastAuth por sí mismo, puedes crear una cuenta aquí y luego utilizar la misma cuenta para iniciar sesión en todas partes en NEAR.




	

	
	
		
			
				¿Cuáles son los retos a los que se enfrenta la incorporación de nuevos usuarios a la Web3?
			
		

		
					

		
			
			
			
			Una experiencia de incorporación complicada
		
			
			Contraseñas o frases semilla largas
		
			
			La necesidad de adquirir criptomonedas antes de acceder a la Web3
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Meta Pool, Módulo 2 – Financiación Colectiva en Meta Pool

Meta Yield - Financiación Colectiva sin Pérdidas
Meta Yield es una plataforma de financiación colectiva o crowdfunding (como se conoce en Inglés) sin pérdidas, basada en recompensas para proyectos NEAR que buscan apoyo financiero y exposición a la comunidad NEAR.

El objetivo de Meta Yield es proporcionar exposición y acceso a diferentes proyectos, permitiendo a la comunidad apoyar financieramente proyectos web 3.0 construidos sobre el protocolo NEAR.

Meta Yield Launchpad es una plataforma de crowdfunding sin pérdidas para proyectos sobre NEAR que quieran ser financiados por su comunidad. Aprovecha el staking ofreciendo a los financiadores la posibilidad de subvencionar con sus recompensas, no con sus activos principales.



El mecanismo único de recaudación de fondos incorporado en Meta Yield aprovecha el staking líquido: los financiadores mintean los tokens del proyecto con sus recompensas de staking, no con sus criptoactivos.

Meta Yield funciona en 4 sencillos pasos:

 	Los financiadores se comprometen y bloquean stNEAR para apoyar proyectos basados en criptomonedas (si no tiene stNEAR vaya a Meta Pool y stakee $NEAR).
 	Los proyectos solo ganan recompensas por staking (~10%) de lo que los financiadores comprometen, no de los criptoactivos subyacentes.
 	Los financiadores ganan tokens de los nuevos proyectos que se lanzan en NEAR o por recibir y lanzar NFT (próximamente).
 	Los financiadores recuperan sus criptoactivos: al final del periodo de bloqueo, recuperan el 100% de sus NEAR.

En pocas palabras, puedes apoyar proyectos en criptos, obtener la recompensa del token nativo del proyecto y contribuir al crecimiento del ecosistema NEAR sin perder los tokens stakeados.

Tú solo cedes tus futuras recompensas NEAR por los tokens del proyecto y te quedas con tus NEAR, eliminando así todo riesgo del proceso de inversión.

¡Comienza a apoyar proyectos NEAR ahora! Visita https://metayield.app






	

	
	
		
			
				Existe un límite preestablecido en la cantidad de tokens stNEAR que puede depositar en una campaña de Meta Yield.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo puede un proyecto aparecer en Meta Yield?
En primer lugar, Meta Yield Launchpad proporciona la plataforma de crowdfunding y el mecanismo basado en recompensas. Además, cada proyecto que consigue una campaña de recaudación de fondos recibe un impulso de marketing sin coste alguno por parte de Meta Yield Launchpad:

 	Campaña previa al lanzamiento: 1 o 2 semanas de rumores sobre el proyecto, incluyendo posibles AMA, infografías y publicaciones en redes sociales.
 	Promoción de lanzamiento
 	Promoción semanal durante el periodo de recaudación de fondos.

Además, estamos trabajando con diferentes entidades del ecosistema NEAR que están interesadas en la oportunidad de apoyar financieramente estos nuevos proyectos en NEAR.
¿Cómo seleccionamos los proyectos?
Queremos dar a todo el mundo la oportunidad de recaudar fondos para sus proyectos, pero también queremos dar a los usuarios y potenciales inversores proyectos de calidad como opciones. Por ello, todo proyecto que quiera ser considerado como candidato a estar en Meta Yield Launchpad debe cumplir los siguientes requisitos:

 	Un equipo sólido construyendo el proyecto

El proyecto debe estar respaldado por un equipo sólido y motivado, capaz de llevar el proyecto a la siguiente fase una vez financiado.

La experiencia de cada miembro debe estar relacionada con el tipo de proyecto propuesto. En otras palabras, si se trata de un proyecto de juegos, los miembros deben presentar pruebas de que al menos algunos de ellos han trabajado en áreas relacionadas.

Los equipos multidisciplinarios también son una buena señal, tener desarrolladores es importante, pero para llevar realmente tu proyecto al siguiente nivel necesitarás por igual marketing, operaciones, diseño y quizás otras áreas.

 	Comunidad fuerte

Queremos que estos proyectos tengan un fuerte apoyo de su comunidad, normalmente comprobamos su nivel de actividad y compromiso en redes sociales como Telegram, Discord, Twitter, YouTube, Instagram, TikTok, y cualquier otra que los proyectos mencionen en su solicitud.

Este aspecto es de vital importancia por 2 razones principales: a veces tenemos una fase de votación para seleccionar los proyectos y las comunidades suelen ser las que impulsan esos votos, y además un buen porcentaje de la cantidad recaudada provendrá de la comunidad, por lo que es esencial tenerla preparada para cubrirse las espaldas.

 	Un Token y su Tokenómica

Es indispensable que los proyectos seleccionados tengan un token porque lo utilizarán para dar recompensas a quienes apoyen su campaña. Para ser más concretos, la persona que apoye el proyecto entregará al mismo sus recompensas de staking y recibirá a cambio tokens del proyecto como retribución.

Y, puesto que tus inversores recibirán tu token como recompensa, es importante decirles cómo pueden utilizarlo (por ejemplo: jugar, comprar, intercambiar o como token de gobernanza) y tus planes para aumentar su valor.

 	Un plan para la financiación

Ten en cuenta que hacer una campaña en Meta Yield Launchpad es similar a intentar conseguir dinero de inversores: quieren saber si eres capaz de construir el proyecto y cómo vas a ganar dinero con él.

Por lo tanto, prepárate con una explicación básica sobre cómo vas a utilizar los fondos recaudados: marketing, mejora del producto/servicio, ampliación de las funcionalidades, cambio/innovación de la marca, mejora de las funcionalidades de la plataforma, etc.

 	Conectar con el ecosistema NEAR

Dado que trabajamos con proyectos y comunidades NEAR y que la comunicación es muy importante en este protocolo, te animamos a que establezcas una estrecha relación con el Ecosistema NEAR Protocol.

El equipo del proyecto debe tener pruebas de que ha colaborado y sabe cómo trabajar con los actores implicados en NEAR: conseguir subvenciones, participar en programas de incubación o formar parte de gremios cuentan para este requisito.

Esto garantiza que el ecosistema ya "reconoce al equipo/proyecto" y que cuando el proyecto pase a mainnet, el ecosistema lo apoyará.




	

	
	
		
			
				Pregunta. La visión multicadena en un proyecto es imprescindible en un proyecto que vaya a ser lanzado en Meta Yield.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Dónde puedo encontrar más información sobre Meta Yield?
Puedes encontrar más información en el sitio Meta Yield y en el blog.
Meta Bond Market - Vende tus activos bloqueados en Meta Yield
El objetivo de Meta Bond Market es proporcionar una herramienta para adquirir y ofrecer diferentes tipos de bonos que se generan actualmente apoyando proyectos en Meta Yield.

Puedes acceder a Meta Bond Market directamente desde su enlace metabondmarket.app.
Conecta tu billetera en Meta Bond Market
En el sitio Meta Bond Market: metabondmarket.app, conecta la billetera NEAR para tener acceso completo a los criptoactivos. Haz clic en el botón “Connect Wallet (Conectar billetera), elige la billetera y conéctate.



Cómo funciona el Meta Bond Market:

4 sencillos pasos para entender el mecanismo de Meta Bond:

 	Apoyar proyectos en Meta Yield.
 	Obtener bonos de acuerdo a la inversión en Meta Yield y recompensas relacionadas.
 	Ofrecer los bonos en la plataforma.
 	Y / o comprar bonos de otros vendedores.

Los usuarios invierten en Meta Yield en proyectos en fase inicial. Si estos proyectos consiguen alcanzar al menos el primer objetivo de inversión, los seguidores obtienen recompensas en tokens del proyecto, en liberación gradual, a cambio de su inversión bloqueada.

Una vez finalizado el periodo de financiación, Meta Bond Market genera dos bonos para el promotor:

 	Primer bono: En tokens NEAR. Esta cantidad corresponde a la valoración en NEAR del stNEAR bloqueado al final del periodo del Fondo.
 	Segundo bono: Por la cantidad de Tokens del proyecto apoyado a recibir en liberación gradual.

El simpatizante puede elegir en cualquier momento del Periodo de Bloqueo si quiere poner a la venta uno o ambos bonos.

Si los bonos no se ponen a la venta, los bonos siguen su curso, y al final del periodo de bloqueo la inversión se devuelve al titular del bono, y las recompensas del proyecto apoyado se delegan en liberación gradual, según la propuesta.

Para cada bono puedes elegir / realizar las siguientes acciones:

 	Dividir los bonos en bonos más pequeños.
 	Ofrecerlos en venta directa.
 	Ofrecerlos en subasta.

Establecer el tiempo en que los bonos se pondrán a la venta.

Si el bono se vende, el vendedor recibe la cantidad en tokens según la venta directa o la mejor oferta de subasta.

Si el bono no se vende, vuelve a estar disponible para la venta y permanece en posesión del vendedor, que puede volver a ponerlo a la venta si lo desea.






	

	
	
		
			
				Meta Bond te permite vender los tokens bloqueados de tu apoyo a una campaña de Meta Yield.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plataforma del Meta Bond Market
Menú de la Plataforma

Bond Market - Mercado
En esta sección se muestran todos los bonos ofrecidos en la plataforma. Se muestran los datos de cada bono y será posible adquirirlos / ofertar por ellos.
My Bonds - Bonos
En la sección My Bonds se detallan todos los bonos que posee el usuario. Desde esta sección el usuario puede:

 	Ver todos los datos de los bonos
 	Venderlos
 	Fusionarlos (importante, para poder fusionar 2 bonos, todos los criterios del bono deben coincidir: activo, fecha de vencimiento y fecha de Cliff si procede).
 	Dividirlos (los bonos sólo se pueden dividir si no han sido reclamados parcialmente).

My Sales - Ventas
En esta sección puedes ver los bonos que el usuario puso a la venta. Las ventas activas y las finalizadas.

 	Venta directa: el comprador oferta directamente y el vendedor verá en esta sección, que la venta se ha realizado y podrá obtener los tokens correspondientes.
 	Venta por subasta: la oferta más alta es la ganadora y al final del periodo de oferta el vendedor podrá obtener los tokens.
 	Fin del periodo de oferta: Si al final del periodo de ofertas no hubiera ninguna oferta, el vendedor podrá volver a poner a la venta su bono o finalizar el proceso.

Importante: si el bono fue vendido, el vendedor deberá ingresar el bono y presionar "get tokens” (obtener tokens) para cerrar el proceso de venta. Este proceso es manual.
Garantía de bonos
Al poner a la venta un bono, el sistema solicitará un importe mínimo (actualmente 1 NEAR) como garantía.

Esto permite al sistema mantener sólo bonos que representen un mínimo del importe de la garantía en cuestión.

Al cerrar el proceso de venta, este importe será devuelto al vendedor.
My Bids - Ofertas
En “My bids” el usuario puede ver las ofertas activas que ha realizado por bonos en Subasta.

Los bonos de Venta Directa no se muestran aquí, puesto que ya están incorporados automáticamente a la sección "Mis bonos".

Si está perdiendo la subasta, el sistema le permite aumentar su oferta o cancelarla retirando sus tokens.
Estados de los Bonos en Subasta
Período de venta activo

 	Losing (Perdiendo): esta oferta ha sido superada. El usuario puede aumentar la oferta o retirar la oferta actual.
 	Winning (Ganando): Esta oferta es la mejor, es la que resulta ganadora. El usuario debe esperar a la finalización (finalización de la venta) para ver si realmente ha ganado.

Periodo de venta finalizado

 	Win (Ganar): Este estado se muestra si la oferta al final del periodo de oferta es la ganadora. El usuario puede reclamar el bono.
 	Lose (Perder):Este estado se muestra si la oferta al final del periodo de oferta es la perdedora. El usuario puede reclamar (retirar) su oferta de tokens por este bono.




	

	
	
		
			
				Existe un alto riesgo potencial de liquidación al vender sus bonos en el Meta Bond Market.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paso a paso en el Meta Bond market.


 

### Meta Pool, Módulo 4 – Participar en la gobernanza de Meta Pool

Gobernanza de Meta Pool
La gobernanza es el proceso en el que Meta Pool busca devolver el proyecto a la comunidad. De esta forma, los poseedores de tokens $META son los que tendrán la opción de gestionar el protocolo on-chain a través de una DAO.

Montar una gobernanza real on-chain, descentralizada, es un trabajo en curso en todo el ecosistema Web 3. Además, este módulo cubre cómo Meta Pool está manejando esta situación.
DAO de Meta Pool
Meta Pool introducirá tokens $META para la gobernanza de la DAO. La intención es que el token $META se distribuya a los creadores del protocolo y a los colaboradores del proyecto de forma totalmente transparente.

Una cosa a tener en cuenta es que antes de que la plataforma de votación de gobernanza en la cadena esté lista para los poseedores de tokens $META, los colaboradores principales del protocolo tomarán decisiones críticas basadas en la visión del proyecto y las aportaciones informales de la comunidad en discord.

Esto es intencional, ya que creemos que es importante mantener la gobernanza ágil en los primeros días del protocolo.

Los principales objetivos de la introducción del token de gobernanza: Incentivar la liquidez. Impulsar la liquidez inicial y acelerar el crecimiento de la plataforma Meta Pool.

Formar una DAO. El token $META representa la propiedad de la DAO de Meta Pool. La DAO se encargará de actualizar los parámetros del programa, la hoja de ruta del producto y otras decisiones estratégicas. Capitalizar la tesorería. Para permitir la financiación de asociaciones estratégicas o la creación de fondos de reserva.
Tokenómica $META
Suministro máximo: 1.000.000.000 $META

 	Fundadores: 30%

Por el trabajo de creación, lanzamiento, promoción y mantenimiento del protocolo. Los tokens de los fundadores tienen un bloqueo de 1 año seguido de una liberación lineal de 2 años. (3 años en total)

 	Equipo y Asesores: 2.6%

Con el fin de crear un producto de clase mundial, necesitamos lo mejor del Ecosistema NEAR trabajando y colaborando en el protocolo. Ellos se comprometerán a largo plazo con el protocolo. Los tokens de los asesores tienen un bloqueo de 2 años seguido de una liberación lineal de 1 año. (3 años en total)

 	Inversores: 10%

La asociación con inversores e instituciones líderes será clave para nuestro alcance global y también para una mejor comprensión de las condiciones macro de los mercados de criptomonedas. Sabemos lo que no sabemos, por eso los asesores senior y el acceso a su red serán críticos para nuestro crecimiento. Los tokens de los inversores tienen un bloqueo de 1 y 2 años, seguido de una liberación lineal de 1 año. (2 y 3 años en total)

 	Asignación para rondas de capital riesgo:

● 4% Ronda Semilla

● 6% Una ronda

 	Comunidad y Tesorería: 57.40%




	

	
	
		
			
				El token $META recibe airdrops mensuales
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Gana poder de voto en Meta Pool - Meta Vote
Meta Vote es una Plataforma de Votación basada en la comunidad para:

 	Proyectos de Recaudación de Fondos en Meta Yield, y
 	Apoyar a los validadores en Meta Staking Vote.

Es una plataforma diseñada para adquirir Poder de Voto para apoyar proyectos en Meta Yield y delegar NEAR Tokens a validadores en Meta Staking Vote.
¿Cómo utilizar Meta Vote?
Puedes acceder a Meta Vote directamente desde su enlace https://metavote.app/ o bien

 	desde Meta Yield haciendo clic en los proyectos que quieras votar. https://metayield.app/
 	desde Meta Staking Vote haciendo clic en el Validador que quieras votar https://vote.metapool.app/, o haciendo clic en los enlaces a Meta Vote de la página para conseguir poder de voto.

Conecta tu monedero en Meta Vote

En la página de Meta Voto: https://metavote.app/, conecta tu monedero NEAR para poder tener acceso completo a tus activos. Botón +Connect wallet.
Meta Vote funciona con 3 sencillos pasos:

 	Bloquea tus tokens $META
 	Obtén poder de voto
 	Vota en proyectos en Meta Yield o Vota apoyando Validadores.

Bloquea tus $Meta Tokens
Para poder votar proyectos o Validadores, debes obtener Poder de Voto y es muy sencillo. La forma de conseguirlo es bloqueando tus tokens $META.

Si aún no tienes $META, ¡necesitarás algunos! Mira más abajo "¿Cómo consigo tokens $META?".

 	Haz clic en el título del botón + Add Voting Power (Añadir poder de voto)
 	Introduce la cantidad de tokens $META que deseas bloquear.
 	Selecciona el periodo en el que deseas "desbloquear" tus tokens con el control deslizante. Este es el tiempo de desbloqueo de tus tokens $META.

El tiempo mínimo de bloqueo de tus $META es de 30 días, y hasta 300 días. Cuanto más tiempo esté bloqueado tus $META, más poder de voto tendrás por cada $META bloqueado.



Después de seleccionar tu periodo de bloqueo, haz clic en el botón de bloqueo y aprueba la transacción a través del monedero NEAR - ¡y ya estás listo para votar!

 	Utiliza el poder de voto para votar por los proyectos deseados o apoyar a los Validadores.

 	Vuelve a https://metayield.app/ o a https://vote.metapool.app/, actualiza la página, ¡y comprueba el poder de voto!

 	Meta Yield: Puedes utilizar el botón de Vote Now (votar ahora) en cualquier proyecto y respaldarlo con tus tokens. Además, no tienes que gastar todos tus tokens en un proyecto, ¡puedes respaldar varios!

 	Meta Staking Vote: Ahora puedes votar directamente al validador de tu elección. Simplemente haz clic en el botón Vote (votar)

del validador de tu elección, o selecciona el validador que deseas apoyar, lee toda la información relativa a este validador y vota por él. Puedes apoyar varios validadores, no sólo uno.




Fórmula de adquisición de poder de voto para tus tokens $META
MULTIPLICADOR = 1 + (4 * (days – MIN_LOCK_DAYS) / (MAX_LOCK_DAYS – MIN_LOCK_DAYS))

 	MIN_LOCK_DAYS=30
 	MAX_LOCK_DAYS=300

Ejemplo


¿Cómo consigo tokens $META?
En la esquina superior derecha de la aplicación Meta Vote, haz clic en " Get more $META (Obtener más $META)"



Este te enlaza a Ref Finance, para intercambiar tokens NEAR u otros activos nativos NEAR por tokens $META.

 	https://app.ref.finance/#meta-pool.near|meta-token.near

Además, puedes conseguir tokens $META en cualquier plataforma DEFI del ecosistema NEAR.
Etapas de bloqueo
Período de bloqueo
La etapa de bloqueo es la que permite votar por los proyectos. Los tokens $META se bloquean y los usuarios pueden votar, anular la votación de proyectos o validadores en cualquier momento. No hay límite de tiempo para esta etapa. Se podrá votar mientras los tokens $META estén bloqueados.


Periodo de desbloqueo
Una vez finalizada la campaña de votación del proyecto o si el usuario desea finalizar el apoyo a un validador, puede iniciar el periodo de Desbloqueo. Pulsando el botón "Start unlock (Iniciar Desbloqueo)" en la posición de bloqueo deseada, comienza a correr el tiempo de desbloqueo, que se corresponde con el tiempo establecido mediante la suma de poderes de voto.

Debe tenerse en cuenta que una etapa de desbloqueo sólo puede iniciarse si hay suficientes poderes de voto disponibles. Si hay potencia de voto en uso y no es suficiente para desbloquear una posición completa, no se podrá iniciar el periodo de desbloqueo.



Importante: el periodo de Desbloqueo no se inicia automáticamente, debe ser iniciado manualmente por el usuario.
Retiro de tokens $META
Una vez finalizado el periodo de desbloqueo, se pueden retirar las tokens $META.

Importante: el retiro de tokens $META debe ser realizado manualmente por el usuario.






	

	
	
		
			
				Bloquear tus tokens en Meta Voto tiene una comisión del 3,5
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Staking Vote - Utiliza tu poder de voto para apoyar a los mejores validadores
Meta Staking Vote es una plataforma basada en la comunidad para la selección de Validadores que asignarán por votación el 15% de los tokens NEAR apostados en Meta Pool.

Meta Pool otorga poder de gobernanza a los titulares de $META, ya que son ellos los que votan en Meta Staking Vote.
¿Cómo utilizar Meta Staking Vote?
Accede a Meta Staking Vote directamente desde su enlace https://vote.metapool.app/.
Conectar el monedero NEAR en Meta Staking Vote
En el sitio Meta Staking Vote: https://vote.metapool.app/, conecta tu monedero NEAR. Haz clic en el botón Connect Wallet, elige un monedero y conéctate.


Meta Staking Vote funciona con 4 sencillos pasos:

 	Bloquear tokens $META en la plataforma Meta Vote.
 	Obtener poder de voto.
 	Votar por los validadores a apoyar en la plataforma Meta Staking Vote.
 	Ver un tablero de votos y asignaciones de stake NEAR.

Cómo funciona

 	Los usuarios de Meta Pool, stakean sus tokens NEAR, recibiendo stNEAR a cambio.
 	Esos Nears stakeados se distribuyen a los nodos Validadores. Esto ayuda a descentralizar y asegurar el Protocolo NEAR. Cuantos más usuarios stakeen en el Meta Pool, más se distribuye entre los nodos validadores.
 	Los validadores producen bloques y obtienen recompensas por ello, lo que aumenta el valor de stNEAR en tokens NEAR.
 	Del total de NEAR tokens stakeados, Meta Staking Vote delega el 15% a los Validadores por votación de los poseedores de $META (seguidores).

Será una votación permanente y, según los resultados, Meta Staking Vote asigna el 1% de la cantidad total stakeada en el Meta Pool cada ∼4 epochs.


Poseedores del token $META
La votación consta de 2 pasos:

 	Elección del validador: Ir a: https://vote.metapool.app/ La lista completa de validadores rastreados por Meta Staking Vote.



Para más información, haz clic en el nombre de los validadores y serás redirigido a la página del validador, con información detallada.



Una vez analizado y elegido el validador que deseas apoyar y votar, vota. Selecciónalo para ser votado en la lista (botón votar), o en la página del validador (botón votar este validador).

 	Votar validador: Conecta el monedero NEAR. Selecciona el validador a votar en la lista (botón votar), o en la página del validador (botón votar este validador) y asígnale el poder de voto.

En este enlace se explica cómo obtener el poder de voto.

La votación de validadores es una campaña en curso, por lo que los votos cuentan para cada campaña mientras esté en marcha.

Vota por cualquier número de validadores sin límite de asignación de Poder de Voto. Los votos se pueden cambiar en cualquier momento.

Así funciona la votación de validadores en Meta Staking Vote, de forma sencilla, segura y recuperando el 100% de los tokens $META.
Delegación
El 15% de la TVL de Meta Pool proporcionada por los usuarios que hagan staking será delegada por el voto de los poseedores de $Meta.

Si el TVL aumenta, la cantidad distribuida aumenta. Es muy importante promocionar el Meta Pool Liquid Staking Pool para los inversores, para lo cual necesitamos el apoyo de los validadores y de la comunidad.

La campaña de delegación es continua, y el 1% del total apostado en Meta Pool se asigna cada 4 epochs.




	

	
	
		
			
				Una vez votado por un validador tienes que esperar 60 epochs para asignar tu voto a otro validador.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plataforma – Datos Generales


 	Validadores: 

Es el número de validadores aprobados por Meta Pool para ser votados según los criterios de selección de validadores.

 	Progreso de Epoch 

Indica el tiempo restante de la epoch de validación / producción del bloque.

Una epoch dura aproximadamente 13 horas. (Una epoch dura 43.200 bloques y un bloque dura aprox. 1,1 segundos).

 	NEAR staked @ Meta Pool

TVL (Total Value Locked) a delegar en los validadores. 85% por rendimiento y 15% por votos en Meta Staking Vote.

Esta cantidad corresponde a los tokens NEAR stakeados en Meta Pool.

El importe está disponible en: https://staking.metapool.app/ – Total de tokens stNEAR multiplicado por el precio stNEAR.

 	Near a asignar por votos

15% del TVL a asignar por votos. El monto correspondiente a cada validador individualmente se puede ver en Asignado por votos.

 	Poder de Voto Disponible

Poder de voto disponible para votar a los validadores. Si el Poder de voto no está disponible, se puede comprar en: https://metavote.app/ (haciendo clic en el enlace de abajo de la cantidad).

Importante: se necesitan tokens $META para obtener poder de voto. Consigue $META ent https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

 	En Uso / Total

Poder de voto en uso y el total que tiene el usuario.

En uso puede ser por haber votado ya por validadores o por votar proyectos en Meta Yield.
Detalles de la votación de los validadores


 	Nombre

Nombre del validador.

Para saber más sobre un validador en particular, basta con hacer clic en el nombre y serás redirigido a la página individual del validador seleccionado.

 	APY

Rentabilidad Anual Equivalente concedida por cada validador. Depende del rendimiento y las comisiones de los validadores.

 	Votos

Número de votos otorgados a cada validador y porcentaje correspondiente del total. La votación es continua e indica el porcentaje de tendencia de asignación que se va a delegar.

 	Asignado por votos

Cantidad de tokens NEAR correspondientes a asignar a cada validador según el 15% a asignar por votos. Importante: sólo se asignará un 1% por cada 4 epochs aproximadamente.

Esta cantidad es la tendencia a alcanzar para la asignación a cada validador según los votos.

El TVL total a asignar por votos se distribuye aproximadamente cada 15 grupos de 4 epochs.

 	Total Asignado

Esta cantidad corresponde a la cantidad a asignar por rendimiento (85%) y por votos (15%). Es la tendencia total que debe alcanzar el validador.

 	Meta Pool Stakeado

Tokens NEAR actualmente delegados por Meta Pool a cada validador.




	

	
	
		
			
				El poder de voto puede utilizarse en las votaciones de Meta staking o en las campañas de votación de Meta Yield.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Desenvolvimento de contrato inteligente no Near usando Rust Parte 3

Esta é a terceira parte de uma série de postagens sobre como criar um aplicativo de bate-papo com Rust na blockchain Near. Você pode encontrar os posts anteriores da série aqui e aqui .

Neste post vamos nos concentrar nas partes off-chain do código. Discutiremos a necessidade de “ indexadores ” e percorreremos algumas partes da implementação do indexador neste exemplo. Você pode encontrar o repositório completo com todo o código que discutiremos hoje no meu GitHub .
Indexadores, o que são e por que precisamos deles
No espaço blockchain, um indexador é um serviço que consome dados brutos de uma fonte (normalmente uma instância de nó completo co-localizada para esse blockchain) e os analisa em um formato que é mais útil para um aplicativo específico. Por exemplo, no caso de nosso aplicativo de bate-papo, o indexador consome um fluxo de blocos Near e produz um fluxo de eventos (por exemplo, mensagens recebidas e solicitações de contato).

Os indexadores são importantes porque os bancos de dados usados ​​na operação do próprio blockchain geralmente não são otimizados para executar os tipos de consultas com os quais os aplicativos se preocupam. Por exemplo, obter o saldo de um usuário para um token ERC-20 no Ethereum geralmente é feito executando a consulta por meio do EVM porque essa é a única maneira pela qual as informações estão disponíveis em um nó Ethereum típico. Esta é uma operação extremamente cara em comparação com a pesquisa de uma entrada em um banco de dados relacional tradicional. Portanto, uma otimização simples para qualquer aplicativo que precise de acesso rápido aos saldos do ERC-20 seria executar um indexador nos dados brutos do Ethereum que preenche um banco de dados tradicional com os saldos importantes. Em seguida, o aplicativo usaria esse banco de dados como fonte para os saldos, em vez de um nó Ethereum diretamente. É assim que o explorador de blocos Etherscan funciona sob o capô; O Etherscan executa um indexador para preencher um banco de dados que é usado para preencher os campos nas páginas da Web que o Etherscan atende.

Os indexadores não são importantes apenas para o Ethereum, qualquer dapp de alto desempenho em qualquer blockchain precisará incluir um indexador em algum lugar de sua arquitetura. O aplicativo de bate-papo de exemplo que discutimos no Near não é exceção, então vamos nos aprofundar em como o indexador é implementado.
Obtendo os dados brutos
Os indexadores processam apenas dados brutos de blockchain em um formato que o aplicativo associado pode usar; eles não geram os dados em primeiro lugar. Portanto, a primeira pergunta que precisamos responder ao criar um indexador é: de onde vêm os dados da blockchain?

Near fornece algumas fontes de dados diferentes, conforme descrito abaixo.
Executando um nó nearcore
A melhor fonte de dados (em termos de descentralização e segurança) para qualquer blockchain é a rede peer-to-peer da própria blockchain. Para acessar essa fonte de dados, você deve executar um nó que entenda o protocolo da blockchain. No caso de Near, a implementação do nó é chamada de nearcore. Seu código-fonte está aberto no GitHub. Há documentação disponível sobre como executar seu próprio nó nearcore. A principal barreira à entrada aqui é a quantidade de espaço em disco necessária para isso; é recomendável que você tenha 1 TB de armazenamento dedicado para o seu nó e demore um pouco para sincronizar com a cadeia como resultado da necessidade de baixar todos esses dados.

Depois de configurar um nó nearcore, a Near fornece uma estrutura de indexador conveniente em Rust que pode ser usada para criar indexadores com nearcore como fonte de dados. Para um projeto real, essa seria a melhor maneira de criar um indexador. No entanto, nosso exemplo é apenas uma demonstração, portanto, não queremos gastar horas baixando dados da cadeia para um servidor dedicado de 1 TB. Felizmente existem outras opções.
Lago de dados NEAR

 	Para tornar mais fácil para os desenvolvedores iniciarem seus projetos, Near criou a estrutura do data lake como uma fonte alternativa de dados para os indexadores usarem. A estrutura do data lake é construída sobre a estrutura do indexador mencionada acima, usando um nó nearcore como fonte de dados. O indexador que alimenta o data lake é trivial no sentido de que não está processando os dados para um aplicativo específico, está apenas passando os dados para serem armazenados no armazenamento AWS S3. No entanto, isso permite que os desenvolvedores tenham acesso a esses dados usando sua própria conta da AWS e criem seus próprios indexadores (não triviais) usando esse armazenamento S3 como fonte de dados.

A vantagem disso para os desenvolvedores é que esse método é muito mais rápido para começar a funcionar. A desvantagem, porém, é que os dados vêm de uma fonte centralizada e, portanto, são teoricamente mais fáceis de corromper do que usar a rede ponto a ponto diretamente.

Acessar o data lake exige que você pague pelos recursos da AWS usados ​​para entregar esses dados a você. Mais uma vez, para fins do exemplo do aplicativo de bate-papo, não queria que as pessoas se inscrevessem na AWS e gastassem dinheiro para executar o indexador. Portanto, escolhi a opção de fonte de dados final.
Nós RPC públicos
A maneira final de acessar os dados da blockchain se você não estiver executando seu próprio nó ou acessando o armazenamento de dados pré-construído de outra pessoa é usar os nós de outra pessoa. Os nós RPC são nós na rede blockchain destinados a atender às solicitações dos usuários. Cada blockchain possui provedores de nós RPC (alguns gratuitos, outros pagos). Uma lista dos provedores RPC para Near pode ser encontrada aqui .

Essa é a maneira menos eficiente de acessar os dados da blockchain porque são necessárias várias solicitações de RPC para obter os dados que os indexadores típicos usam. Cada solicitação RPC incorre em latência de rede, tornando o indexador lento para responder a eventos que ocorrem na cadeia. A única vantagem dessa abordagem é que ela é gratuita para configurar uma demonstração, desde que haja um provedor RPC gratuito para a cadeia (que é o caso da Near). Portanto, esta é a fonte de dados que o indexador em nosso exemplo usa.

Dito isso, o próprio indexador não se importa de onde vêm seus dados. Portanto, embora nosso exemplo esteja usando a pior fonte de dados, vale a pena explorar sua implementação porque os conceitos que esse indexador usa são os mesmos de um indexador construído usando o data lake do Near ou estruturas de indexador baseadas em nós.
Implementação do indexador
Nosso indexador é construído como um tokio app em Rust. Tokio é uma estrutura Rust para escrever aplicativos de alto desempenho onde as operações de E/S são o principal gargalo. Nosso indexador é um desses aplicativos porque a computação real que ele executa é extremamente rápida em comparação com o tempo necessário para solicitar dados dos nós RPC. As principais características do tokio são que ele usa primitivos assíncronos sem bloqueio e possui multithreading integrado para permitir a execução paralela. Isso é além de estar em Rust, então naturalmente tem as garantias de segurança de simultaneidade e segurança de memória que Rust fornece.

Se tokio é o palco no qual nosso aplicativo é definido, então o que segue são os atores da peça (trocadilho intencional; este aplicativo segue o modelo de ator, mas eu escolho fazê-lo diretamente em tokio ao invés de usar uma biblioteca como actix porque eu acho que os canais de tokio fornecem digitação mais forte do que as mensagens genéricas usadas na maioria das estruturas de atores).

O indexador tem quatro papéis principais: o gerenciador, o downloader de bloco, o downloader de chunk e o manipulador de recibos.
O gerente
O processo gerenciador supervisiona todo o indexador. Ele é responsável por delegar trabalho aos outros processos e dizer-lhes para desligar quando o programa estiver sendo fechado (por exemplo, no caso de um erro ser encontrado). Por exemplo, o gerenciador lida com o balanceamento de carga dos downloaders de fragmentos percorrendo-os ao atribuir um fragmento para download.
O downloader de blocos
Como o nome indica, o objetivo do processo de download de blocos é baixar blocos. Ele pesquisa periodicamente o Near RPC para verificar se há novos blocos e, se houver, faz o download deles e os envia para o gerenciador. Se não estivéssemos usando o RPC como nossa fonte de dados, esse processo seria substituído por uma conexão com um nó próximo ou data lake.
O(s) downloader(es) de partes
Na Near, os blocos não contêm os dados sobre as transações; pedaços fazem. Os blocos fornecem apenas informações sobre quais novos blocos estão disponíveis. A razão para isso é por causa do sharding de Near (você pode ler mais sobre isso aqui). Portanto, precisamos de processos separados para baixar os dados do bloco para cada bloco. Os chunk downloaders cumprem essa função. Nosso indexador tem várias instâncias do chunk downloader para permitir o download dos chunks em paralelo.

Se não estivéssemos usando o RPC como nossa fonte de dados, dependendo de como os dados são fatorados na fonte de dados que estávamos usando, esses processos podem não precisar existir (por exemplo, a estrutura do indexador próximo inclui todos os dados de bloco e bloco em um única mensagem). Mas para o nosso caso, como estamos usando o RPC, esses processos são necessários.
O manipulador de recibos
Os pedaços contêm “recibos” que são criados quando uma transação é processada. Quando o gerente recebe um novo chunk de um chunk downloader, ele envia todos os recibos para o processo do manipulador de recibos (poderíamos ter várias instâncias do manipulador de recibos para processar recibos em paralelo, assim como temos vários downloaders de chunks, mas o processamento do recibo é rápido o suficiente para que eu não achasse que isso adicionasse muita melhoria de desempenho). Esse processo filtra os recebimentos apenas para os que nos interessam, depois baixa o resultado da execução dos recebimentos e, finalmente, processa os eventos desses resultados. No caso deste exemplo, simplesmente escreva os eventos em um arquivo (para uma demonstração ao vivo, você pode assistir ao arquivo com algo como o tail -f comando Unix para ver os eventos chegando), mas você pode imaginar que uma implementação de produção poderia encaminhar esses eventos como notificações push para uma versão móvel do aplicativo.
Observações
Você pode notar em todo o código do indexador que há alguma complexidade em relação ao envio de blocos/recibos com o hash do bloco após o bloco que incluiu esses blocos. Essa é uma peculiaridade da Near RPC, onde ele deseja saber se você está ciente dos blocos posteriores para atender ao resultado da execução. Novamente, isso seria tratado com muito mais facilidade se fosse usada uma fonte de dados melhor.

É intencional que não haja pânico em nenhuma das funções do ator. Quando encontram um erro, eles o registram e enviam uma mensagem de desligamento ao gerente (e o gerente a envia a todos os outros atores). Isso é importante porque entrar em pânico em um aplicativo multithread pode causar um comportamento inesperado (em geral, o tokio é muito bom em derrubar o aplicativo inteiro normalmente, mas ainda é melhor codificar defensivamente contra ele).
Conclusão
Nesta postagem, discutimos por que os indexadores são importantes para os dapps do mundo real e analisamos alguns dos detalhes do indexador de exemplo implementado para o chat dapp. Assim como na postagem anterior, há exercícios no código do indexador incluídos nos comentários marcados como EXERCISE. Encorajo você a experimentar esses exercícios se quiser alguma experiência prática com a base de código.
Sobre a Série
Este é o último post desta série. Na Parte 1, analisamos os princípios gerais do desenvolvimento de contratos inteligentes e como eles se aplicam a um exemplo de contrato para um chat dapp. Na Parte 2, nos aprofundamos em como near-sdk escreve contratos inteligentes para Near in Rust. Por fim, esta postagem discutiu como os indexadores são necessários para integrar os dados do blockchain com os componentes fora da cadeia do nosso aplicativo.

Uma parte final do código que não abordei é o teste de integração. O teste de integração usa a biblioteca de espaços de trabalho próximos para simular a blockchain localmente e usa o mesmo estilo Rust assíncrono do indexador. Mesmo que os testes de integração não sejam especialmente chamativos ou interessantes, eles são importantes para garantir que seu contrato funcione corretamente. Eu o encorajo a dar uma olhada nos testes de integração para o contrato de mensageiro e tentar o exercício lá para obter alguma experiência prática nessa área também.

Se você gostou desta série de postagens de blog, entre em contato conosco na consultoria Type-Driven. Temos o prazer de fornecer serviços de desenvolvimento de software para dapps, bem como materiais de treinamento para seus próprios engenheiros.

—-----

2150 palavras

 

### Desenvolvimento de um contrato inteligente no Near usando Rust 2ª parte

Esta é a segunda parte de uma série de postagens sobre como criar um aplicativo de bate-papo com Rust na blockchain Near. Você pode encontrar o primeiro post da série aqui.

Neste post, vamos nos concentrar no contrato inteligente em si. Veremos a biblioteca near-sdk que faz nosso código funcionar no Near. Também veremos os padrões de acesso do estado próximo e os princípios de desenvolvimento de contratos inteligentes em ação, revisando o código deste contrato inteligente. Você pode encontrar o repositório completo com todo o código que discutiremos hoje no meu GitHub.
SDK Rust de contrato inteligente da Near
Em seu núcleo, ao tempo de execução do contrato inteligente no Near é usado WebAssembly (Wasm). Wasm é um formato de bytecode bem estabelecido que também é usado fora da blockchain, como em aplicativos da web. Isso é bom para a Near porque seu tempo de execução pode se beneficiar do trabalho que é feito na comunidade Wasm mais ampla.

O compilador Rust faz um bom trabalho ao gerar a saída Wasm, mas precisa haver algum andaime em torno dele para que o bytecode Wasm funcione corretamente com seu "host" (o tempo de execução do Near em nosso caso, ou o mecanismo JavaScript de um navegador da web no caso de um aplicativo da web). Este andaime pode ser gerado automaticamente usando bibliotecas Rust convenientes: wasm-bindgen no caso de integração do navegador, e near-sdk no caso do Near. O contrato inteligente com o qual estamos trabalhando hoje é escrito usando near-sdk.

Ambas bibliotecas usam Rust procedural macros (proc macros). Este é um tipo de metaprogramming (meta-desenvolvimento) onde a biblioteca define pequenas anotações que podemos usar para acionar o código Rust para ser gerado automaticamente para nós. As proc macros do Rust são usadas para reduzir a quantidade de boilerplate code (códigos clichês) que o desenvolvedor precisa escrever para fazer sua lógica de negócios funcionar. Por exemplo, o derive proc macro é o núcleo da linguagem Rust. Ele pode definir automaticamente a funcionalidade comum em novos tipos de dados que você criar. Você pode ver isso usado no simples fragmento de código seguinte do contrato inteligente de bate-papo:
#[derive(

Debug, BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, Copy, PartialEq, Eq,

)]

#[serde(crate = “near_sdk::serde”)]

pub enum MessageStatus {

Read,

Unread,

}
Você pode ver muitas características listadas na anotação do derive. Para chamar alguns específicos: Debug significa o tipo de MessageStatus que pode ser convertido em uma string para ajudar na depuração do código; Clone significa que é possível criar uma instância idêntica à do atual MessageStatus, e Copy significa que a operaçao Clone é barata; PartialEq e Eq significa que você pode comparar duas instâncias de MessageStatus para ver se são iguais. Os traços Serialize e o Deserialize vêm da biblioteca serde, que é onipresente no ecossistema Rust para codificar/decodificar dados de formatos como JSON ou CBOR. Voltaremos aos traços de Borsh mais tarde.

Até agora, tudo isso foi um Rust padrão que você encontrará em qualquer projeto. A proc macro, especificamente Near, é a near_bindgen que você pode ver sendo usado no seguinte fragmento de código:
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct MessengerContract {
accounts: LookupMap<AccountId, AccountStatus>,
messages: LookupMap<MessageId, Message>,
unread_messages: UnorderedSet<MessageId>,
read_messages: UnorderedSet<MessageId>,
last_received_message: LookupMap<AccountId, MessageId>,
pending_contacts: UnorderedSet<AccountId>,
owner: AccountId,
}
A near_bindgen proc macro gera automaticamente o código extra que precisamos para que, quando compilarmos para o Wasm, obtenhamos uma saída que o tempo de execução da Near saiba como usar. Ele é usado em vários locais onde esse glue code (código cola) é necessário. Aqui ele marca a estrutura MessengerContract como tendo o estado necessário para executar os métodos do contrato. Uma instância da estrutura MessengerContract será criada cada vez que chamarmos um método em nosso contrato inteligente. Mais tarde discutiremos para quê são usados alguns desses campos.

A macro near_bindgen também é usada sobre o bloco impl para a estrutura MessengerContract:
#[near_bindgen]
impl MessengerContract {
// …
}
Aqui significa que as funções definidas neste bloco são os métodos que queremos expor em nosso contrato inteligente. Ele permite que os usuários da blockchain Near enviem transações chamando essas funções pelo nome. Por exemplo, o método para enviar mensagem está definido neste bloco. Veremos alguns outros métodos deste bloco com mais detalhes abaixo.

Em resumo, a biblioteca rust da near-sdk fornece uma macro proc chamada near_bindgen para gerar automaticamente o glue code que faz a saída Wasm funcionar com o tempo de execução Near. Essa macro pode ser usada em uma estrutura para definir o estado do seu contrato e no bloco impl dessa estrutura para definir os métodos públicos em seu contrato.Near-sdk também fornece outras funções e estruturas úteis, que veremos nas seções subsequentes.
Estado do contrato inteligente
Essencialmente, todos os contratos inteligentes não triviais requerem algum estado para operar corretamente. Por exemplo, um contrato de token precisa manter os saldos dos vários detentores de token. Nosso contrato de chat não é diferente. Vimos na seção anterior que a estrutura do MessengerContract continha muitos campos. Nesta seção, discutimos alguns recursos gerais do estado no tempo de execução da Near, bem como alguns detalhes de como ela é usada no exemplo de contrato inteligente.

A coisa mais importante a saber sobre o estado do contrato inteligente no Near é que ele é um armazenamento de valor-chave simples. Você pode ver isso nas funções storage_read e storage_write de baixo nível expostas por near-sdk. No entanto, você pode criar algumas estruturas de dados mais sofisticadas sobre essa base simples, e o near-sdk fornece algumas delas em seu collections module. Por esse motivo, nosso contrato de exemplo não usa o armazenamento de valor-chave diretamente; em vez disso, ele faz uso das coleções de nível superior oferecidas pelo near-sdk.

Por exemplo, o contrato inteligente acompanha o status das contas que conhece (quais são contratos, para quem enviamos uma solicitação de contato, etc.). O campo de contas do MessengerContract é uma estrutura LookupMap da Near-sdk. Isso é muito próximo ao uso direto do armazenamento de valor-chave, pois o mapa também é simplesmente uma maneira de procurar um valor de uma chave, mas o LookupMap faz duas coisas importantes acima da interface bruta de armazenamento de valor-chave. Primeiro, ele tem um prefixo que inclui todas as chaves de armazenamento relacionadas a este mapa. O uso de um prefixo evita a mistura de chaves deste mapa com chaves de outro (por exemplo, o mapa last_received_message que também é codificado em AccountId). Segundo, o LookupMap nos permite trabalhar com tipos Rust de nível superior, enquanto a interface de armazenamento bruto funciona apenas com bytes. Isso é obtido ao usar a serialização Borsh  Isso é obtido usando a serialização Borsh para converter os tipos de/para strings binárias. Borsh é um formato de serialização projetado pela Near para ser útil especificamente em aplicativos blockchain. Esse uso de Borsh é o motivo pelo qual você vê BorshDeserialize e BorshSerialize derivados de muitos tipos em todo o código.

Um exemplo mais interessante de uma coleção usada aqui é o UnorderedSet usado nocampo unread_messages. Isso é usado pelo contrato para rastrear quais mensagens ainda não foram lidas. O UnorderedSet ainda é construído no armazenamento de valor-chave subjacente, mas efetivamente usa apenas as chaves, pois só nos importamos que um elemento esteja no conjunto ou não. A estrutura também mantém metadados sobre quais chaves ela está usando para nos permitir iterar sobre todas as chaves do conjunto.
Verificando o ambiente e chamando outros contratos
Nesta seção, discutimos os recursos gerais do ambiente de tempo de execução do Near e as chamadas entre contratos. Para nos manter fundamentados, isso é feito no contexto de como os usuários adicionam uns aos outros como contatos em nosso aplicativo de bate-papo. Vamos dar uma olhada no add_contact function definition (essa definição está no bloco impl do MessengerContact, com a anotaçao near_bindgen antes mencionada, porque é um ponto de entrada principal para nosso contrato).
#[payable]
pub fn add_contact(&mut self, account: AccountId) –> Promise {
self.require_owner_only();
let deposit = env::attached_deposit();
require!(deposit >= ADD_CONTACT_DEPOSIT, “Insufficient deposit”);
let this = env::current_account_id();
Self::ext(account.clone())
.with_attached_deposit(deposit)
.ext_add_contact()
.then(Self::ext(this).add_contact_callback(account))
}
Há muito o que descompactar nessas poucas linhas de código. Como enquadramento adicional para orientar nossa discussão, lembre-se dos três princípios do desenvolvimento de contratos inteligentes descritos no postagem anterior:

 	Uma mentalidade adversária,
 	Economia,
 	Garantir invariáveis antes de fazer chamadas entre contratos.

Volte e revise a primeira postagem se precisar de uma atualização sobre o que eram esses princípios. Cada um desses princípios aparecem nessa função.
Uma mentalidade adversária
Todos os métodos de contrato inteligente são públicos e devemos aplicar o controle de acesso quando o método faz uma ação delicada, sensível, caso contrário, alguém fará uso indevido da funcionalidade. Nesse caso, não queremos que ninguém possa adicionar contatos em nome do proprietário; apenas o proprietário deve poder decidir com quem se conectar (se alguém quiser fazer contatos na rede de bate-papo, pode implantar este contrato em sua própria conta!). Por tal motivo temos a função de chamada require_owner_only() bem no topo do corpo da função. A implementação dessa função é bem simples:
fn require_owner_only(&self) –> AccountId {
let predecessor_account = env::predecessor_account_id();
require!(
self.owner == predecessor_account,
“Only the owner can use this method!”
);
predecessor_account
}
Ela faz uso da função predecessor_account_id do env module da Near-sdk. O módulo env contém muitas funções úteis para consultar aspectos do ambiente de tempo de execução Near em que nosso contrato está sendo executado. Por exemplo, aqui estamos verificando qual conta fez a chamada para o nosso contrato. O módulo env contém outras funções úteis, como verificar a ID da conta do nosso próprio contrato e quantos tokens Near foram anexados a esta chamada. Recomendo a leitura da documentação do módulo para ver todas as funções disponíveis.

Por razões de eficácia a função require_owner_only também retorna a conta predecessora (para evitar múltiplas chamadas para o env::predecessor_account_id() caso uma função exclusiva do proprietário também precise da conta predecessora por algum outro motivo).
Economia
Na primeira linha do fragmento de código add_contact acima inclui o atributo a pagar (payable). O uso dessa anotação é ativado pela função que está sendo definida como parte de um bloco impl da near_bindgen. Isso significa que este método aceitará tokens Near dos usuários que o chamarem. Esses tokens são necessários porque tomamos a decisão de que os usuários estão pagando por ações como a criação de estado on-chain (na cadeia). Uma vez que adicionar outra conta como contato cria um estado em seu contrato, assim como no nosso (precisamos avisá-los de que queremos nos conectar), devemos garantir que o usuário que inicia essa conexão esteja pagando por esse armazenamento. O depósito associado a essa função pagável é usado para cobrir esse custo de armazenamento.

Você pode ver algumas linhas abaixo onde verificamos se o depósito está realmente presente. Isso faz uso da função attached_deposit do módulo env. O fato de estarmos fazendo essa verificação antecipadamente segue perfeitamente o terceiro princípio.
Certifique-se de invariantes antes de fazer chamadas entre contratos
É importante por atenção a assinatura de tipo da função add_contact. Primeiro, os argumentos da função (&mut self, account: AccountId) significa que esta é uma chamada mutável (vai mudar o estado do contrato) e leva um argumento chamado “account” que deve ser um Near Account ID. Quando near_bindgen faz sua magia, isso significará que os usuários do blockchain Near podem chamar essa função fazendo uma transação que leva um argumento codificado em JSON como { "account": "my.account.near" }. Segundo, o tipo de retorno é Promise, o que significa que estamos fazendo uma chamada entre contratos no final desta função. As chamadas entre contratos no Near são assíncronas e non-atomics (não pode ser efetuada entre blockchains separadas), portanto, devemos garantir que tudo esteja correto antes de fazermos a chamada. É por isso que incluímos primeiro o "somente o proprietário" e a "verificação de depósito" no corpo da função. A natureza assíncrona das chamadas entre contratos também significa que não há valor de retorno imediato dessa função A chamada assíncrona será realizada e o resultado só virá mais tarde, depois que essa chamada acontecer.

Você pode ver os detalhes da chamada entre contratos na parte inferior da função. Ela usa a API de alto nível de near-sdk (embora a API de baixo nível também esteja disponível no módulo env), onde a função ext é gerada automaticamente pela near_bindgen e retorna uma estrutura de dados para construir a chamada entre contratos. Você pode ver que primeiro usamos ext(account) para chamar a conta que queremos adicionar como contato. A chamada inclui nosso depósito via with_attached_deposit e está chamando a função ext_add_contact (Que é, neste caso, definida no mesmo bloco impl, mas em geral pode ser definida em qualquer lugar). Finalmente, chamamos then o que significa incluir uma callback (chamada de volta). A callback é outro Promise de por si, então usamos novamente a mesma função ext, mas desta vez chamando nossa própria ID de conta. Isso é feito para que nosso contrato saiba qual foi a resposta do contrato que estamos tentando adicionar como contato. Não entrarei aqui, em detalhes sobre as implementações ext_add_contact ou add_contact_callback (eles apenas manipulam o armazenamento dependendo do status atual da conta), mas encorajo você a lê-los no código-fonte no GitHub caso esteja interessado.
Resumo
Neste post, mergulhamos de cabeça em algo de codificação! Nós vimos como near_bindgen é usado para gerar automaticamente o código necessário para executar nosso contrato no tempo de execução do Near, bem como outros recursos do near-sdk para interagir com o armazenamento, o ambiente de tempo de execução e outros contratos. Na próxima postagem, continuaremos nos aprofundando no código, mas mudaremos de assunto para examinar o componente off-chain desse aplicativo. Um contrato inteligente por si só não constitui um dapp, fique atento para ver o porquê!

Se você quiser alguma experiência prática com este código, experimente alguns dos exercícios! Em alguns lugares no código do contrato inteligente, incluí um comentário marcado como EXERCISE. Por exemplo, na definição de tipos eu chamo o fato de que um status de usuário Blocked (bloqueado) está disponível, mas não há como bloquear alguém atualmente implementado. Adicionar essa funcionalidade para bloquear outro usuário é um exercício sugerido e muito bom para começar. Todos os exercícios são sugestões de maneiras de estender a funcionalidade do contrato, dando a você a oportunidade de tentar escrever algum código de contrato inteligente por conta própria. Talvez em um futuro post desta série eu discuta algumas soluções para os exercícios.

Se você está gostando desta série de postagens do blog, por favor entre em contato conosco na consultoria Type-Driven. Para nós é um prazer fornecer serviços de desenvolvimento de software para dapps, bem como materiais de treinamento para seus próprios engenheiros.

 

### DeFi на NEAR 2023

В 2023 году в экосистеме NEAR был разработан набор отличных платформ для децентрализованных финансов (DeFi). Он имеет широкий спектр децентрализованных приложений (dApps), ориентированных на управление финансами. NEAR — это демонстрация масштабируемого блокчейна первого уровня с низкой комиссией. Это преимущество позволяет любому, кто заинтересован, начать свой путь в DeFi.

DeFi позволяет пользователям управлять своими цифровыми токенами. Ключевые особенности этой технологии включают в себя:

 	Свобода действий: это означает, что пользователи сохраняют контроль над своими активами на протяжении всего торгового процесса.
 	Прозрачность: все транзакции записываются в блокчейн и могут быть просмотрены кем угодно.
 	Безопасность: использование передовой криптографии и других мер безопасности для обеспечения безопасности сделок.
 	Доступность: для всех, у кого есть подключение к Интернету и совместимый цифровой кошелек.
 	Без центрального органа: децентрализованно, что означает отсутствие центрального органа, контролирующего биржу.

Proximity Labs, научно-исследовательская фирма, в том числе венчурный фонд, ищет платформы DeFi следующего поколения, которые хотят развиваться на протоколе NEAR. Если вы разработчик и ищете поддержку для улучшения вашего приложения DeFi dApp, разработанного на NEAR, вам сюда.

События произошедшие в 2022 году (как Terra-Luna, FTX-Alameda и другие) и криптовалютная экосистема внесла радикальные изменения в будущее DeFi, потребовав более динамичных и инновационных платформ, которые могут поддерживать как медвежий, так и бычий рынки. Учитывая все технологические преимущества, автор считает, что будущее DeFi должно быть построено на NEAR.
Децентрализованные биржи (DEX)
Ref Finance


Ref Finance, пионер децентрализованных финансов на протоколе NEAR, предлагает комплексную услугу обмена токенов с пулами ликвидности и фермами. Платформа со временем развилась и включила в себя автоматический маркет-мейкер (AMM) для бесперебойной торговли.

Ref Finance управляется DAO, который ведет белый список токенов для торговли на платформе, обеспечивая безопасность и стабильность активов. По состоянию на 2023 год Ref Finance остается лучшей DEX на NEAR с многообещающей дорожной картой по расширению своих функций.

В первом квартале 2023 года Ref Finance планирует запустить фермы Ref V2, основные показатели в Ref Analytics и интеграцию ликвидности Orderly для чистой Центральной книги лимитных ордеров (CLOB). Во втором квартале 2023 года платформа намерена представить встроенные примитивы кредитования и заимствования, расширенное предложение по обмену, виджеты Ref и Zap Swap.



Во второй половине 2023 года Ref Finance планирует развернуть повторяющиеся свопы, Sentinel на пулах и фермах, ликвидность в качестве залога и инновационные решения для повышения безопасности и защиты пользователей. Благодаря своей амбициозной дорожной карте Ref Finance готов укрепить свои позиции в качестве ведущего DEX в экосистеме NEAR.
Spin Finance


Spin Finance — это децентрализованная торговая платформа, которая предлагает передовые торговые инструменты для пользователей NEAR, включая бессрочные фьючерсы на NEAR, ETH и BTC. В дополнение к традиционной спотовой торговле Spin предоставляет DOV и хранилища для доходного фермерства. Используя эти хранилища, трейдеры могут легко и безопасно участвовать в фермерстве без необходимости вести индивидуальную торговлю.



Дорожная карта Spin Finance включает введение новых функций, таких как торговля опционами, AIP и децентрализованный маркет-мейкер. Эти продвинутые инструменты могут быть полезны как для трейдеров, так и для дегенов, что делает любой токен в экосистеме NEAR достойным рассмотрения для использования.



Уникальная гибридная модель Spin Finance сочетает в себе преимущества централизованных и децентрализованных бирж, что выделяет ее среди аналогов. С момента своего запуска в 2021 году в качестве книги заказов для NEAR компания Spin продолжает расти, а ее команда постоянно расширяется и обещает блестящее будущее. Если вы ищете передовую торговую платформу, которая сочетает в себе лучшее из обоих миров, Spin Finance может стать для вас идеальным выбором.
Jump DeFi


Jump DeFi — это всеобъемлющее децентрализованное приложение, которое предоставляет ряд решений для запуска, привлечения капитала и обмена токенов NEP-141. Он считается экосистемой, которая позволяет отдельным лицам и организациям делать свои первые шаги в мире DeFi.

Одним из наиболее примечательных инструментов, предоставляемых Jump Defi, является служба ставок NFT, которая позволяет сообществам NFT поддерживать своих держателей, предоставляя им токены. Эта услуга предназначена для стимулирования владения NFT и создания более активного сообщества.

Лаборатория Jump Token — это еще один инновационный инструмент, предоставляемый Jump DeFi, который позволяет пользователям создавать токены и впоследствии перемещать их на Jump Pad, стартовую площадку, которая облегчает сбор средств в экосистеме NEAR.



Jump DeFi также провел кампанию по повышению доходности NEKO, мем-монеты, живущей по протоколу NEAR. Платформа также запустила краудфандинговые кампании на других стартовых площадках, включая Meta Yield, где она собрала в общей сложности 68 416 долларов США в токенах stNEAR, которые обеспечат все вознаграждения за стекинг.

Это удивительная и всеобъемлющая платформа, которая предлагает широкий спектр услуг DeFi по протоколу NEAR, включая стейкинг, сбор средств и создание токенов. Это платформа, которая может открыть новые возможности и возможности для всех, кто хочет участвовать в экосистеме децентрализованных финансов.
Ликвидный стейкинг
Meta Pool
Ликвидный стейкинг стал популярным решением для тех, кто хочет размещать свои токены и получать вознаграждение, но также хочет сохранить возможность использовать эти токены другими способами. Meta Pool — это первое и крупнейшее решение для ликвидного стейкинга на протоколе NEAR, предоставляющее пользователям возможность получать вознаграждение за стейкинг, но при этом иметь возможность использовать свои стейкинговые токены в экосистеме DeFi.

Meta Pool запущен со своим цифровым токеном $stNEAR, который позволяет пользователям продолжать делать ставки, а также использовать производную $stNEAR в экосистеме DeFi. Протокол управляется DAO, который награждает пользователей $META, токеном управления, который можно использовать для участия в сообществе, управляющем DAO Meta Pool.



Одной из уникальных особенностей Meta Pool является реализация Meta Staking Vote, которая позволяет держателям $META выбирать, какие валидаторы лучше всего поддерживать. Эти валидаторы получают 15% от общей заблокированной стоимости Meta Pool (TVL), распределяемой на основе их голосования. Такой подход гарантирует, что сообщество Meta Pool имеет право голоса в отношении поддержки валидаторов, способствуя децентрализации и вовлечению сообщества в сеть.

Сегодня семейство продуктов, выпущенных Meta Pool, расширилось и дополнено:

 	$stNEAR, Ликвидный стейкинг на NEAR.
 	Пул ликвидности для ликвидных анстейков на NEAR Protocol
 	Токен $stAUR, ликвидный стейкинг на Aurora
 	Meta Yield, первая безубыточная краудфандинговая платформа на NEAR.
 	Meta Bond, продайте свои заблокированные позиции на Meta Yield.
 	Meta Vote, получите право голоса для управления Meta Pool.

Meta Pool — это протокол без разрешений, который предоставляет пользователям возможность размещать свои токены и получать вознаграждения, а также сохраняет возможность использовать эти токены другими способами. Благодаря реализации Meta Staking Vote и распределению токенов управления $META Meta Pool способствует вовлечению сообщества и участию в управлении своей сетью.




	

	
	
		
			
				Какие из перечисленных ниже децентрализованных бирж построены на протоколе NEAR? (несколько ответов)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Uniswap
		
			
			Ref Finance
		
			
			Spin Finance
		
			
			Jump DeFi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Протокол LiNEAR 


$LiNEAR — это решение для ликвидного стейкинга, предоставляемое Linear Protocol, одним из ведущих проектов в экосистеме NEAR. Он является частью Cornerstone, протокола метауправления, созданного для поддержки растущей экосистемы NEAR, предлагая токены $CORN пользователям своих платформ.

Благодаря относительно высокому APY, составляющему около 9%, LiNEAR завоевала популярность среди пользователей, которые ищут прибыльный вариант ликвидного стейкинга на NEAR. Протокол также недавно поддержал Stake Wars III, соревнование NEAR, которое позволяет большему количеству валидаторов участвовать в сети в качестве производителя блоков, что еще больше укрепляет экосистему.

Linear Protocol также анонсировала свой последний продукт, Phoenix Bonds, ферму генераторов доходности, доступную на Ref Finance для поставщиков ликвидности NEAR<>pNEAR. Это предоставит пользователям еще одну возможность зарабатывать вознаграждения, поддерживая ликвидность NEAR и pNEAR. Linear Protocol, ориентированный на создание инновационных и полезных продуктов DeFi, представляет собой проект, за которым стоит следить в экосистеме NEAR.
Stader Labs на NEAR


Stader Labs привнесла свое инновационное решение для ликвидного стейкинга в NEAR Protocol, позволяя пользователям получать вознаграждение за стейкинг, а также иметь доступ к своим стейкинговым токенам через свой токен $NearX.

Платформа интегрирована с несколькими кошельками, чтобы пользователям было проще участвовать в ликвидных ставках. Кроме того, Stader Labs серьезно относится к безопасности и прошла строгие проверки безопасности со стороны Halborn, BlockSec и OSec, все из которых дали платформе свое одобрение.

Помимо протокола NEAR, Stader Labs присутствует в нескольких других сетях, включая Polying, Fantom, BNB Chain и Hedera, предоставляя решения для ликвидного стейкинга пользователям в нескольких экосистемах.

В частности, в экосистеме NEAR токен ликвидного стейкинга $NearX доступен как в протоколе NEAR, так и в сети Aurora Network, EVM, работающей на базе NEAR, что дает пользователям еще больше гибкости и возможностей, когда дело доходит до стейкинга их токенов.
Кредитные платформы
Burrow Cash


Децентрализованные финансы открыли мир возможностей, когда речь идет о кредитовании и займе. Burrow Cash — это кредитная платформа, работающая на протоколе NEAR, которая предлагает децентрализованный способ кредитования и заимствования токенов без необходимости в централизованном посреднике.

С помощью Burrow Cash пользователи могут заблокировать свои токены и использовать их в качестве залога для запроса другого токена, что позволяет им получить доступ к новым токенам без необходимости продавать свои существующие позиции. Это особенно полезно для пользователей, которые не хотят продавать свои токены, но все же хотят получить доступ к другим токенам или нуждаются в ликвидности.

Burrow Cash использует оракулы для мониторинга цен на токены, гарантируя, что обеспечение пользователя остается стабильным и что он получает справедливое количество токенов в обмен на свое обеспечение. Однако важно помнить, что если стоимость залога упадет, может возникнуть риск его ликвидации для погашения долга.

Помимо кредитования и заимствования, Burrow Cash также предлагает пулы ликвидности, где пользователи могут предоставлять свои токены для закапывания и получать вознаграждение в обмен. Эти пулы ликвидности предоставляют пользователям еще один способ получить доход от своих токенов, а также обеспечивают ликвидность для платформы, что помогает гарантировать, что всегда будет достаточно ликвидности для тех, кто хочет брать или давать взаймы.

В целом, Burrow Cash — это децентрализованная кредитная платформа, которая предлагает простой, безопасный и эффективный способ кредитования и заимствования токенов по протоколу NEAR. Используя оракулы для мониторинга цен на токены и предоставляя пулы ликвидности, Burrow Cash предлагает пользователям надежный и удобный способ доступа к новым токенам, а также получения вознаграждения за свои существующие токены.






	

	
	
		
			
				Что из перечисленного является ликвидным стейкингом на NEAR? (несколько ответов)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Meta Pool
		
			
			LiNEAR
		
			
			Stader Labs
		
			
			Rocket Pool
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Лаунчпады
Meta Yield
Meta Yield — это краудфандинговая платформа, которая использует ликвидные ставки для предоставления финансовой поддержки и доступа к проектам веб 3.0, построенным на протоколе NEAR. Сторонники фиксируют и блокируют stNEAR, чтобы поддерживать проекты и зарабатывать токены от новых проектов, запускаемых на NEAR, или получать NFT. Проекты получают вознаграждение только за то, что делают спонсоры, а не за лежащие в их основе криптоактивы. Сторонники могут восстановить 100% своих токенов NEAR в конце периода блокировки, что делает Meta Yield безубыточной краудфандинговой платформой, основанной на вознаграждениях за стейкинг.

Как спонсор на панели запуска Meta Yield, вы получаете ранний доступ к проекту, который вы поддержали, токены проекта, стоимость которых превышает рыночную цену, и возможность возместить свои первоначальные инвестиции в токены NEAR. Чтобы запросить токены вашего проекта и восстановить ваши токены, процесс прост и включает в себя несколько простых шагов.

В целом, Meta Yield предлагает уникальный механизм сбора средств для проектов веб 3.0 на NEAR. Это позволяет спонсорам поддерживать проекты, не теряя своих токенов, и получать вознаграждение от новых проектов, запускаемых на NEAR. Если вы станете спонсором, вы сможете воспользоваться несколькими преимуществами, такими как ранний доступ к проектам, более ценные токены проекта и возможность вернуть свои первоначальные инвестиции в токены NEAR.


Meta Bonds, вторичный рынок для заблокированных позиций Meta Yield
Meta Bonds — это вторичный рынок, который позволяет сторонникам краудфандинговых кампаний на Meta Yield торговать заблокированными позициями в виде облигаций.

Meta Yield — это протокол краудфандинга, в котором используется stNEAR, токен, который генерирует доход, обеспечивая ликвидность протоколу Meta Yield. Когда сторонники поддерживают проект на Meta Yield, они получают две долговые расписки в виде облигаций: одну за свои первоначальные инвестиции, а другую за токены проекта, которые они получат в обмен на вознаграждение.

Первая облигация становится доступной, когда заканчивается период блокировки, а вторая облигация может быть востребована после периода постепенного освобождения. В течение этого времени спонсоры могут инвестировать свои токены, размещая их на рынке, доступ к которому можно получить, посетив веб-сайт Meta Bonds по адресу metabondsmarket.app.

Мета-облигации позволяют спонсорам монетизировать свои инвестиции до окончания периода постепенного выпуска. Также это дает спонсорам возможность обменивать свои облигации на другие активы, такие как другие токены или криптовалюты, а также обеспечивает ликвидность на рынке.

Создавая вторичный рынок для заблокированных позиций, Meta Bonds обеспечивает ликвидность и торговые возможности, а также открывает новые возможности для монетизации инвестиций.


NEAR Starter


NEAR Starter — это революционная инициатива, которая позволяет создавать и запускать новые проекты на основе протокола NEAR. NEAR Starter, задуманный как децентрализованная автономная организация (DAO), обеспечивает комплексную экосистему поддержки проектов на ранней стадии. NEAR Starter Launchpad является неотъемлемой частью этой экосистемы, позволяя проектам делать начальное децентрализованное предложение (IDO) и привлекать средства от сообщества.

В дополнение к Launchpad, NEAR Starter также сделал себе имя, предоставив коллекции NFT, которые позволяют пользователям фармить $NEARIA, токен индекса, который используется для обмена проектами. Этот инновационный подход помог создать активное и активное сообщество вокруг NEAR Starter, в котором пользователи с энтузиазмом участвуют в фермерском процессе.

Стартовый сайт NEAR построен на сети Aurora, что обеспечивает низкую плату и беспрепятственное подключение через Meta Mask. Это гарантирует, что пользователи могут легко и безопасно участвовать в Launchpad и процессах фермерства, не беспокоясь о высоких комиссиях или сложных технических требованиях.

Чтобы продемонстрировать возможности своей Launchpad, NEAR Starter недавно запустила токен $NEARIA через IDO с целью собрать 24 ETH. Этот успешный запуск — только начало для NEAR Starter, так как он продолжает поддерживать и развивать новые проекты по протоколу NEAR.


Агрегаторы доходности
Pembrock Finance


Благодаря протоколу NEAR, обеспечивающему надежную платформу для приложений DeFi, Pembrock выделяется как протокол с использованием заемных средств, который использует несколько стратегий для получения токенов из протокола NEAR.

Что делает Pembrock уникальным, так это то, что он обслуживает два типа пользователей: кредиторов и фермеров с кредитным доходом. Кредиторы могут получать пассивный доход, размещая свою криптовалюту в хранилищах, которые финансируют пулы ликвидности. С другой стороны, фермеры с Leveraged Yield могут максимизировать свою прибыль, открыв позицию с кредитным плечом. Это означает, что пользователи могут занимать дополнительные средства на платформе, выплачивая небольшой процент от своей прибыли.

Pembrock предлагает широкий выбор доступных пулов, включая wNEAR, ETH, PEM, SWEAT, USDC.e и другие монеты, доступные в экосистеме NEAR. Независимо от того, являетесь ли вы новичком или опытным инвестором, открыть позицию в Pembrock очень просто. Все, что вам нужно сделать, это посетить их сайт и найти ферму или кредитование в их пулах. Благодаря удобному интерфейсу Pembrock вы можете легко перемещаться по пулам и выбирать тот, который лучше всего соответствует вашей инвестиционной стратегии.

В целом, Pembrock — отличный пример того, как DeFi революционизирует традиционный финансовый сектор. Используя децентрализованные протоколы, Pembrock предоставляет пользователям возможность получать пассивный доход и максимизировать свою прибыль за счет использования заемных средств.


Заключение
DeFi на протоколе NEAR — это быстро развивающаяся экосистема, которая предлагает пользователям различные инновационные решения. Уделяя особое внимание масштабируемости, совместимости и удобству работы с пользователем, NEAR Protocol привлекает многих разработчиков и инвесторов к созданию и инвестированию в проекты DeFi на платформе. Поскольку экосистема продолжает расти и развиваться, ожидается, что она станет важным игроком в более широком ландшафте DeFi, предлагая своим пользователям уникальные функции и преимущества.

В этом гайде представлены несколько проектов DeFi на протоколе NEAR. Каждый из этих проектов имеет уникальные особенности и вносит свой вклад в растущую экосистему DeFi на NEAR. Мы знаем, что рано или поздно эту статью придется переписать, чтобы включить в нее новые удивительные приложения, которые появятся.

До скорой встречи!




	

	
	
		
			
				Что из перечисленного ниже является стартовой площадкой в экосистеме NEAR? (несколько ответов)
			
		

		
					

		
			Please select 2 correct answers
			
			
			Duck Starter
		
			
			NEAR Starter
		
			
			Meta Yield
		
			
			Ethereum Launchpad
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Bagaimana Membangun di NEAR? Panduan Awal

Prasyarat

 	Baca “Apa Itu NEAR?”
 	Pengalaman JavaScript Development

Developers adalah sumber kehidupan ekosistem blockchain. Agar teknologi blockchain mendapatkan mainstream adoption (keadaan ketika blockchain menjadi biasa dan sudah melekat menjadi bagian dari masyarakat), perlu dengan diturunkannya hambatan masuk bagi developer dan memungkinkan mereka untuk membuat aplikasi yang menyenangkan dan juga canggih agar dapat dinikmati semua kalangan. Karena alasan inilah smart contract NEAR ditulis dengan menggunakan AssemblyScript karena kemiripannya dengan JavaScript.

Jadi, apabila kamu ingin membangun di NEAR, kamu bisa menggunakan tools berikut,

 	JavaScript SDK. Sambungkan (connect), tandatangani (sign), transaksikan (transact), dan sebarkan (deploy) ke jaringan NEAR mana pun dari konteks JS mana pun juga
 	Rust Contract SDK. Bangun contract yang aman dan terjamin yang mengelola aset bernilai tinggi
 	AssemblyScript Contract SDK. Pelajari dan lakukan prototype dengan zero friction menggunakan JS syntax
 	JSON RPC API. Semua komunikasi dengan menggunakan platform yang melewati API jenis ini juga termasuk milik kami.
 	Command Line Interface. Command line toolkit berfitur lengkap diperuntukkan kepada developers dan validators
 	NEAR Explorer. Alat pencarian blockchain (blockchain search tool) yang memungkinkan developers untuk melihat detail transaksi, akun, detail blokir, dan lainnya
 	NEAR Wallet. Buat akun (create account), kelola kunci akses (manage access key), dan lainnya dengan UI yang ramah pengguna.
 	nearup. Kelola deployment secara lokal dan gabung dengan public network maupun private network manapun
 	Bridge. Interoperabilitas yang cepat dan aman
 	EVM. Mesin virtual yang kompatibel dengan Ethereum

Baiklah, mari kita lakukan langkah pertama.
Tinjauan Singkat
Aplikasi di NEAR memiliki dua bagian yang berbeda – back-end dan front-end.

Smart Contract (back-end): Menyimpan dan memodifikasi data pada rantai. Contract perlu mengekspos metode yang memungkinkan klien untuk "melihat" dan "mengubah" keadaan.

Interaksi dengan Smart Contract (front-end): Anda dapat berinteraksi dengan contract Anda atau contract yang disebarkan oleh orang lain. Anda melakukan hal ini dengan menggunakan bantuan near-api-js Quickstart dan Code Snippets di aplikasi Anda.

Express quiz +2 nLEARNs




	

	
	
		
			
				Aplikasi di NEAR memiliki dua bagian yang berbeda – back-end dan front-end. Yang merupakan back-end adalah…
			
		

		
					

		
			
			
			
			Mainnet
		
			
			Testnet
		
			
			Smart Contracts
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Cara Membangun dan Memanggil Smart Contracts

NEAR saat ini men-support:

 	Rust – near-sdk-rs: “Pembungkus” yang menyediakan keamanan yang telah berimprovisasi untuk bahasa pemrograman Rust pada contract bernilai tinggi.
 	AssemblyScript near-sdk-as: Sekumpulan bantuan yang membuat SmartContracts Anda terlihat mirip dengan TypeScript saat dikompilasi dengan Wasm untuk dieksekusi.

CATATAN: AssemblyScript saat ini tidak direkomendasikan untuk aplikasi keuangan produksi karena barunya bentuk bahasa dan alat kompilasi yang tersedia.

Baiklah, mari kita serius.
Setting Up Testnet
Cara termudah untuk membuat akun di NEAR adalah dengan NEAR Wallet. NEAR memiliki beberapa jaringan pengembangan yang beroperasi secara independen satu sama lain dengan accountIDs mereka sendiri. Ayo, ikuti langkah-langkah untuk membuat wallet. Pastikan Anda telah mengikuti langkah-langkah yang diperlukan untuk cadangan keamanan Anda.

CATATAN: Membuat akun di mainnet hampir sama dengan membuat akun di testnet, tetapi akan dibutuhkan dana awal untuk akun di Mainnet. Berikut adalah panduan untuk pembuatan akun mainnet.

Tidak masalah ketika saat men-deploy, apakah aplikasi ditulis dalam Rust atau AssemblyScript. Semua kode kontrak (contract code) dikompilasi ke WebAssembly dan disebarkan (deploy) ke jaringan untuk dijalankan di dalam Wasm-compatible virtual machine. Anda akan memakai perintah seperti yarn dev untuk sebagian besar aplikasi, tetapi Anda akan dapat dengan mudah menerapkan aplikasi menggunakan NEAR CLI dengan near dev-deploy untuk TestNet (atau near deploy jika Anda telah membuat akun).




	

	
	
		
			
				Semua kode contract dikompilasi ke WebAssembly dan disebarkan ke jaringan untuk dijalankan di dalam _______
			
		

		
					

		
			
			
			
			Sandbox
		
			
			Wasm-compatible virtual machine
		
			
			EVM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Sekarang, lakukan hal berikut sebagai pemanasan:

 	Lihatlah di NEAR Explorer. Di sini kamu bisa mencari seluruh transaksi dan blocks yang dihasilkan di NEAR. Coba cari akun yang baru saja Anda buat dan lihat transaksi yang telah Anda buat.
 	Sekarang instal near-cli. Ini adalah command line interface yang memungkinkan Anda berinteraksi secara lancar dengan NEAR. Dokumen NEAR ini memiliki semua perintah near-cli dengan banyak contoh.
 	Coba jalankan perintah pertama Anda: near login. Ini akan mengarahkanmu ke NEAR Wallet Anda dan menyimpan kunci akun testnet Anda secara lokal.

Setelah memeriksa testnet, Anda boleh menjalankan local node-mu. Namun, jika Anda hanya ingin bermain-main dengan kode, kami sarankan Anda tetap menggunakan testnet.
Bagaimana Saya Menjalankan Node?
Seperti ekosistem berbasis blockchain lainnya, NEAR Protocol berjalan di atas sekumpulan komputer yang dikelola secara publik (atau “node”).

Anda dapat memutuskan untuk menjalankan node Anda sendiri karena beberapa alasan:

 	Untuk mengembangkan dan menerapkan contract pada node yang terhubung ke MainNet, TestNet, atau BetaNet
 	Untuk mengembangkan dan menyebarkan contract pada node lokal (independen dan terisolasi) (terkadang disebut "LocalNet").
 	Untuk bergabung dengan sebuah jaringan sebagai validator yang menjalankan "validator node"

Anda dapat meluncurkan node NEAR betanet dan testnet dengan menginstal nearup. Anda dapat melakukannya dengan mengikuti petunjuk di https://github.com/near/nearup

Express quiz +2 nLEARNs




	

	
	
		
			
				Seperti ekosistem berbasis blockchain lainnya, NEAR Protocol berjalan di atas sekumpulan komputer yang dikelola secara publik yang disebut _______
			
		

		
					

		
			
			
			
			Nodes
		
			
			Blockchain
		
			
			Near Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Menjalankan Official Node menggunakan Docker
Secara standar, NEAR menggunakan Docker untuk menjalankan client. Maka, hal pertama yang Anda lakukan adalah menginstal Docker dan nearup. Sekarang, jalankan sistem Anda dengan ini:

nearup betanet

(Jika Anda lebih suka menggunakan TestNet maka ganti saja betanet dengan testnet pada perintah di atas)

Kemudian anda akan diminta sebuah ID Akun. Anda dapat membiarkannya kosong jika Anda hanya ingin menjalankan sebuah node. Validator harus menggunakan ID akun dari akun yang ingin Anda jadikan percobaan. Setelah itu, Anda harus memasukkan kode ini:

Masukkan ID akun Anda (biarkan kosong jika tidak akan menjadi validator)

Sekarang, node Anda akan mulai di background dengan Docker. Untuk memeriksa log di dalam Docker, jalankan docker logs –follow nearcore.
Membuat Kode Sederhana Pada NEAR
NEAR memiliki daftar program yang bermanfaat atau kode contoh (code examples) yang dapat Anda lihat dengan mudah. Jadi, kode yang akan kita periksa adalah Guest Book. Menggunakan program memungkinkan Anda masuk dengan NEAR dan menambahkan pesan ke Guest Book! Sebuah aplikasi awal yang dibuat dengan backend AssemblyScript dan frontend React.
Melihat Guest Book Code
Untuk menjalankan project ini secara lokal, Anda perlu memastikan hal berikut.

 	Pastikan Anda telah menginstal Node.js ≥ 12 (https://nodejs.org), lalu gunakan untuk menginstal yarn: npm install –global yarn (atau cukup npm i -g yarn)
 	Instal dependencies: yarn install (atau hanya yarn)
 	Jalankan local development server: yarn dev (lihat package.json untuk daftar lengkap script yang dapat Anda jalankan dengan yarn)

Sekarang Anda akan memiliki local development server yang didukung oleh NEAR TestNet! Menjalankan yarn dev akan membuat Anda menjadi tahu URL mana yang dapat Anda kunjungi di browser untuk melihat aplikasi.

Oh dan juga pastikan Anda telah membuka halaman GitHub.

Anda mungkin akan membutuhkan video dibawah ini.

<iframe width="561" height="316" src="https://www.youtube.com/embed/B6Gc_OQjX9E" title="NEAR from Scratch: AssemblyScript Project Setup" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
Menjelajahi Kode
Seperti yang Anda ketahui, ada dua sisi kode – backend dan frontend:

Kode backend berada di folder /assembly. Kode ini diterapkan ke blockchain NEAR saat Anda menjalankan yarn deploy: contract. Ini adalah smart contract NEAR.

Kode frontend berada di folder /src. /src/index.html adalah tempat yang bagus untuk memulai penjelajahan. Perhatikan bahwa itu dimuat di /src/index.js, di mana Anda dapat mempelajari bagaimana frontend terhubung ke blockchain NEAR.

Kode Backend (Backend Code)
#1 Contract Data Model :  assembly/model.ts
import { context, u128, PersistentVector } from "near-sdk-as";

/**

 * Exporting a new class PostedMessage so it can be used outside of this file.

 */

@nearBindgen

export class PostedMessage {

  premium: boolean;

  sender: string;

  constructor(public text: string) {

    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');

    this.sender = context.sender;

  }

}

/**

 * collections.vector is a persistent collection. Any changes to it will

 * be automatically saved in the storage.

 * The parameter to the constructor needs to be unique across a single contract.

 * It will be used as a prefix to all keys required to store data in the storage.

 */

export const messages = new PersistentVector&lt<PostedMessage>("m");
Analisa
@nearBindgen menandai kelas sebagai sesuatu yang serializable. Serializable adalah sebuah marker interface yang digunakan untuk "menandai" kelas sehingga objek dari kelas tersebut dapat memperoleh kemampuan tertentu.

Kelas “PostedMessage” memiliki tiga fitur –

 	premium untuk menandai pesan dengan token NEAR terlampir
 	sender untuk melacak penandatangan guest book message
 	text untuk menyimpan guest book message

Terakhir, “messages” adalah kumpulan guest book message yang disimpan sebagai PersistentVector dari objek PostedMessage
#2 Contract Behavior :  assembly/main.ts
import { PostedMessage, messages } from './model';

// --- contract code goes below

// The maximum number of latest messages the contract returns.

const MESSAGE_LIMIT = 10;

/**

 * Adds a new message under the name of the sender's account id.\

 * NOTE: This is a change method. Which means it will modify the state.\

 * But right now we don't distinguish them with annotations yet.

 */

export function addMessage(text: string): void {

  // Creating a new message and populating fields with our data

  const message = new PostedMessage(text);

  // Adding the message to end of the the persistent collection

  messages.push(message);

}

/**

 * Returns an array of last N messages.\

 * NOTE: This is a view method. Which means it should NOT modify the state.

 */

export function getMessages(): PostedMessage[] {

  const numMessages = min(MESSAGE_LIMIT, messages.length);

  const startIndex = messages.length - numMessages;

  const result = new Array&lt;PostedMessage&gt;(numMessages);

  for(let i = 0; i <  numMessages; i++) {

    result[i] = messages[i + startIndex];

  }

  return result;

}
Analisa
MESSAGE_LIMIT digunakan untuk menghindari panggilan tak terbatas (yaitu berpotensi mahal) untuk mengambil guest book message dari penyimpanan

Kami juga menggunakan dua fungsi publik yang berbeda dalam kontrak ini – addMessage() dan getMessages()
Kode Frontend (Frontend Code)
#1 Network Connection :  src/config.js
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';

function getConfig(env) {

  switch(env) {

    case 'mainnet':

      return {

        networkId: 'mainnet',

        nodeUrl: 'https://rpc.mainnet.near.org',

        contractName: CONTRACT_NAME,

        walletUrl: 'https://wallet.near.org',

        helperUrl: 'https://helper.mainnet.near.org'

      };

    // This is an example app so production is set to testnet.

    // You can move production to mainnet if that is applicable.

    case 'production':

    case 'development':

    case 'testnet':

      return {

        networkId: 'default',

        nodeUrl: 'https://rpc.testnet.near.org',

        contractName: CONTRACT_NAME,

        walletUrl: 'https://wallet.testnet.near.org',

        helperUrl: 'https://helper.testnet.near.org'

      };

    case 'betanet':

      return {

        networkId: 'betanet',

        nodeUrl: 'https://rpc.betanet.near.org',

        contractName: CONTRACT_NAME,

        walletUrl: 'https://wallet.betanet.near.org',

        helperUrl: 'https://helper.betanet.near.org'

      };

    case 'local':

      return {

        networkId: 'local',

        nodeUrl: 'http://localhost:3030',

        keyPath: `${process.env.HOME}/.near/validator_key.json`,

        walletUrl: 'http://localhost:4000/wallet',

        contractName: CONTRACT_NAME

      };

    case 'test':

    case 'ci':

      return {

        networkId: 'shared-test',

        nodeUrl: 'https://rpc.ci-testnet.near.org',

        contractName: CONTRACT_NAME,

        masterAccount: 'test.near'

      };

    case 'ci-betanet':

      return {

        networkId: 'shared-test-staging',

        nodeUrl: 'https://rpc.ci-betanet.near.org',

        contractName: CONTRACT_NAME,

        masterAccount: 'test.near'

      };

    default:

      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);

  }

}

module.exports = getConfig;
Analisa
Kode di atas menentukan data dan endpoint yang diperlukan untuk terhubung ke jaringan NEAR. Informasi koneksi yang ditentukan di sini disertakan untuk MainNet, TestNet, dan BetaNet serta default LocalNet configuration
#2 Configuration : src/index.js
import React from 'react';

import ReactDOM from 'react-dom';

import App from './App';

import getConfig from './config.js';

import * as nearAPI from 'near-api-js';

// Initializing contract

async function initContract() {

  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');

  // Initializing connection to the NEAR TestNet

  const near = await nearAPI.connect({

    deps: {

      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()

    },

    ...nearConfig

  });

  // Needed to access wallet

  const walletConnection = new nearAPI.WalletConnection(near);

  // Load in account data

  let currentUser;

  if(walletConnection.getAccountId()) {

    currentUser = {

      accountId: walletConnection.getAccountId(),

      balance: (await walletConnection.account().state()).amount

    };

  }

  // Initializing our contract APIs by contract name and configuration

  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {

    // View methods are read-only – they don't modify the state, but usually return some value

    viewMethods: ['getMessages'],

    // Change methods can modify the state, but you don't receive the returned value when called

    changeMethods: ['addMessage'],

    // Sender is the account ID to initialize transactions.

    // getAccountId() will return empty string if user is still unauthorized

    sender: walletConnection.getAccountId()

  });

  return { contract, currentUser, nearConfig, walletConnection };

}

window.nearInitPromise = initContract()

  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {

    ReactDOM.render(

      &lt;App

        contract={contract}

        currentUser={currentUser}

        nearConfig={nearConfig}

        wallet={walletConnection}

      /&gt;,

      document.getElementById('root')

    );

  });
Analisa
Ini adalah hal-hal yang mendasar namun fundamental dari bagian front-end, saat Anda mengonfigurasi koneksi ke jaringan NEAR. Anda dapat mengonfigurasi contract interface dengan menyuntikkan wallet connection dan menyambungkan kedua metode kontrak.
Menyebarkan (Deploying) Smart Contract
Setiap smart contract di NEAR memiliki akun yang terasosiasi. Saat Anda menjalankan yarn dev, smart contract Anda diterapkan ke TestNet NEAR langsung dengan akun sementara. Jika sekarang Anda ingin menjadikannya permanen, inilah yang perlu Anda lakukan.

Langkah 0: Instal near-cli

Inilah cara Anda memasang near-cli secara global

npm install --global near-cli

Dengan begitu anda akan mendapatkan NEAR CLI tool. Pastikan ini diinstal dengan:

near --version

Langkah 1: Buat akun untuk kontrak

Kunjungi NEAR Wallet dan buat akun baru. Anda akan men-deploy smart contract ke akun baru tersebut.

Sekarang beri otorisasi NEAR CLI untuk akun baru dan ikuti instruksi yang diberikan kepada Anda:

near login

Langkah 2: Tetapkan nama kontrak dalam kode

Ubah baris di src/config.js yang menetapkan nama akun kontrak. Pasang ke id akun yang Anda gunakan di atas.

const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'

Langkah 3: Ubah remote URL jika Anda mengkloning repo ini

Jika Anda mem-fork repositori, Anda perlu mengubah remote URL ke repo yang aksesnya telah “terikat” dengan anda. Hal ini akan memungkinkan penerapan otomatis ke Halaman Github dari baris perintah.

 	Buka GitHub dan buat sebuah repositori baru untuk project ini.
 	Buka terminal anda dan pada root project dan masukan seperti yang berikut ini:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`

Langkah 4: Deploy! 

Anda hanya perlu perintah berikut untuk men-deploy smart contract anda:

yarn deploy

Perintah ini melakukan dua hal:

 	Mem-build dan men-deploy smart contract pada NEAR TestNet
 	Mem-build dan men-deploy kode frontend contract ke GitHub menggunakan gh-pages. Hal ini hanya akan bisa berlaku apabila project sudah memiliki repositori yang telah disiapkan di GitHub.




	

	
	
		
			
				Setiap smart contract di NEAR memiliki ____ yang terasosiasi.
			
		

		
					

		
			
			
			
			Token
		
			
			Wallet
		
			
			Account
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Apa Selanjutnya?

Baiklah, sekarang setelah Anda tahu cara menjalankan basic code, Anda mungkin ingin mempelajari NEAR lebih dalam. Untuk itu, coba lihat dokumen NEAR developer.

 

### Staking di Meta Pool

Meta Pool, Modul 1 - Langkah Pertama dalam Liquid Staking
Staking dan Protokol Konsesus pada NEAR Protocol
Sebelum memulai, direkomendasikan agar anda mengikuti the NEAR Power User course dari LNC (Learn NEAR Club) untuk memiliki pengetahuan dasar tentang Near Protocol.

Setiap jaringan blockchain memerlukan sebuah metode untuk mengkonfirmasi block baru yang sedang diproduksi.

Pada jaringan Proof-Of-Stake, proses ini dibuat oleh node validator. Untuk memilih node validator ini, diperlukannya untuk mengunci token yang menetapkan ke validator. Inilah yang dikenal sebagai staking. Berdasarkan jumlah token NEAR yang dipertaruhkan, kumpulan validator yang akan berpartisipasi dalam pembuatan blok inilah yang terbentuk.

Untuk memberi insentif kepada delegator token dan validator token, dierimalah rewards dari biaya yang dicover oleh protokol. Dengan cara ini, staking adalah sebuah cara untuk mengumpulkan token lebih banyak dan juga membantu mengamankan jaringan.

Beberapa kelemahan dari staking standar ialah token anda akan terkunci dan anda tidak akan bisa ditarik sebelum periode unstake berakhir. Anda juga tidak dapat menggunakan token Anda dengan cara apa pun karena token-token ini didelegasikan ke node validator. Kedua batasan ini dapat diselesaikan ketika anda melakukan liquid stake.
Proof-Of-Stake
Investopedia.com mendefinisikan Proof-of-Stake (PoS) sebagai berikut:

“Proof-of-Stake ialah sebuah mekanisme konsensus cryptocurrency untuk memproses berbagai transaksi dan menciptakan block baru pada sebuah blockchain.”

Sebuah mekanisme konsensus adalah sebuah metode untuk memvalidasi entri ke dalam database yang terdistribusi dan menjaga keamanan database. Dalam kasus cryptocurrency, basis data disebut sebagai blockchain—agar mekanisme konsensus mengamankan blockchain.

Dengan pemikiran ini, NEAR Protocol menggunakan PoS sebagai sistem untuk memproses semua transaksi yang berjalan di jaringan dengan mempertaruhkan token NEAR, token asli dari blockchain ini. Pada staking standar, Anda dapat memilih 1 node validator tunggal dan mendelegasikan (mengunci) token Anda padanya. Ini akan membantu validator untuk memproses blocks atau chunks dan juga menghasilkan hadiah jika di atas koefisien nakamoto.

Namun, delegasi dalam staking standar dari sistem PoS memiliki mekanisme yang tertunda, misalnya; NEAR Protocol, atau bahkan ketidakmampuan untuk melepaskan token Anda, seperti di ethereum. Dalam hal ini, solusi liquid staking dapat mendukung keduanya: Keamanan jaringan di PoS dan kemampuan untuk menggunakan token Anda.

 	Node Validator

Validator adalah komputer yang telah menerima cukup token (stake) untuk memulai konfirmasi transaksi di jaringan NEAR.

Dalam jaringan Proof-of-Stake NEAR, kumpulan validator yang terdesentralisasi memproses transaksi untuk menjaga keamanan jaringan. Sebagai imbalannya, validator ini menerima hadiah untuk melakukannya. Sistem ini juga memungkinkan delegator – entitas yang ingin memberikan keamanan tetapi mungkin tidak memiliki perangkat keras untuk melakukannya – untuk mendelegasikan token mereka ke validator.

Validator ini memberikan daya komputer ke jaringan untuk menghitung blok baru dan sebagai gantinya mereka menerima hadiah berdasarkan jumlah blok atau chunk yang dihasilkan.

Baca lebih lanjut tentang validator NEAR Protocol di sini: https://near.org/about/network/validators/

 	


	

	
	
		
			
				Proof of Stake bekerja sama seperti Proof of Work
			
		

		
					

		
			
			
			
			Benar
		
			
			Salah
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






2.Reward dan Tokenomics NEAR

NEAR merupakan token yang digunakan untuk menaungi semua biaya di NEAR Protocol

Pada tokenomics nya dijelaskan token akan dirilis secara bertahap selama 5 tahun.



Seperti disebutkan pada Paper nya, 5% dari suplai tambahan dikeluarkan setiap tahun untuk mendukung jaringan sebagai hadiah epoch, dimana 90% akan masuk ke validator (total 4,5%) dan 10% ke perbendaharaan protokol (total 0,5%).

Sumber referensi tambahan :

Postingan resmi oleh NEAR Foundation: https://near.org/blog/near-token-supply-and-distribution/

Utas dibuat oleh NEARWEEK tentang Liquid Staking: https://twitter.com/NEARWEEK/status/1618257119958175747




	

	
	
		
			
				Berapa jumlah $NEAR token yang didistribusikan setiap tahun kepada para validator dan delegator?
			
		

		
					

		
			
			
			
			45 juta $NEAR token
		
			
			12.5 juta $NEAR token
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apa itu Liquid Staking? Memahami Meta Pool dan aset StNEAR
Liquid Staking Protokol berada di garis depan staking ekonomi mata uang kripto, merevolusi akses likuiditas dalam industri keuangan terdesentralisasi (DeFi).

Liquid staking adalah alternatif dari staking tradisional: ini memungkinkan pengguna untuk melakukan staking NEAR dalam jumlah berapa pun dan untuk secara efektif dapat membatalkan staking $NEAR milik pengguna tanpa harus menunggu ~48-72 jam (4-6 epoch) sebelum pemegang token NEAR mendapatkan hadiah compounding mereka.



Salah satu keuntungan dari liquid staking adalah kemampuan untuk berinteraksi dan menggunakan dana sekaligus mendapatkan hadiah dalam waktu bersamaan. Hasilnya, protokol liquid staking memberikan dasar untuk kegiatan seperti protokol peminjaman (lending protocol) dan kegiatan yield farming.

Oleh karena itu, pengguna dapat berinteraksi dengan berbagai platform DeFi untuk mendapatkan banyak hadiah dari satu kumpulan dana.

 	Kriteria Seleksi Validator

Meta Pool mengikuti strategi dari NEAR Foundation untuk menyebarkan stake di antara validator yang berperforma tinggi, komisi rendah, dan tidak terkonsentrasi, untuk meningkatkan desentralisasi dan ketahanan sensor untuk NEAR.

Kami mengevaluasi semua validator, di produk utama dan kami tidak memiliki daftar putih (whitelist), dan kami menerbitkan formula, kode yang kami gunakan untuk menghitung formula, dan juga hasil yang akan berbentuk on-chain. Etosnya harus benar-benar transparan dan terbuka untuk semua validator.

Kami memiliki 5 kriteria untuk memilih validator di jaringan NEAR, yang sejalan dengan etos transparansi dan berkeadilan kami:

 	Uptime > 95%
 	Fees < 10%
 	Memastikan validator tidak mengurangi koefisien Nakamoto
 	Memiliki cukup token untuk mencapai seat price dari NEAR Protocol
 	Memproduksi reward selama kurang lebih 4 epoch berturut-turut

Anda dapat meninjau daftar validator Meta Pool di sini, Anda hanya perlu memasukkan meta-pool.near di filter akun.




	

	
	
		
			
				Apakah liquid staking di Meta Pool mendukung desentralisasi jaringan?
			
		

		
					

		
			
			
			
			Ya
		
			
			Tidak
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Panduan : Cara Melakukan Liquid Stake di Meta Pool

Meta Pool memungkinkan pemegang token NEAR untuk melakukan staking dan mendapatkan hadiah, menyediakan cara mudah untuk melepaskan staking tanpa periode penguncian.

Ini tidak menempatkan semua NEAR milik anda yang di-stake hanya ke dalam satu validator saja, Meta Pool menyebarkannya di antara banyak validator berperforma tinggi dan berbiaya rendah agar Anda mendapatkan hadiah terbaik sekaligus memastikan jaringan terdesentralisasi dan tahan sensor.

 	Masuk ke Meta Pool dan klik pada “Start Staking”



 	Klik pada “Stake Now” pada kolom Stake NEAR
 	Pilih wallet pilihanmu, untuk contoh kali ini kita menggunakan NEAR native wallet



 	Pilih wallet NEAR yang mau digunakan dari menu dropdown dan persilakan akses aplikasi untuk NEAR wallet dengan cara mengklik “Authorizing”



 	Setelah masuk, pergi ke halaman utama dan masukkan jumlah yang akan di stake, lalu klik “Stake”

Catatan : Sisakan beberapa NEAR token pada wallet anda untuk menyiapkan biaya untuk transaksi



 	Perlu diingat bahwa minimum jumlah token yang bisa di stake adalah 1 $NEAR



 	Kamu akan mendapatkan konfirmasi setelah transaksi berhasil diproses oleh blokchain dan dana yang sudah dideposit (stake) sebelumnya telah berhasil. Ini membutuhkan waktu beberapa detik saja.
 	Sekarang kamu sudah bisa melihat jumlah token yang didepositkan pada laman utama dan laman penghasilan



Catatan : Panel ini hanya menampilkan aset Anda ($NEAR dan stNEAR) dari dompet milik anda, jika kamu mentransfer atau menjual token stNEAR milikmu, mereka tidak akan muncul pada panel ini.

Pada panel ini kamu dapat melihat statistik Meta Pool saat ini:



 	Panduan : Melakukan Unstaking Token NEAR

Ada 2 opsi untuk melakukan unstake di Meta Pool: Pertama, kalian bisa melakukan Liquid Unstake (langsung unstake) atau melakukan Traditional Unstake (tertunda 48-72 jam).

Liquid Unstake

Kamu dapat langsung meng-unstake token stNEAR milikmu dengan membayar sedikit biaya dan menggunakan fitur Liquid Unstake. Dengan melakukan ini, kita sebenarnya menukar token stNEAR dengan token NEAR. Ini memungkinkan berkat kumpulan likuiditas yang ada di Meta Pool.

Untuk Liquid Unstake cukup dengan cara:

 	Buka tab Unstake pada menu navigasi
 	Tinjau Biaya Liquid Unstake saat ini dan putuskan apakah kita ingin melanjutkan.
 	Masukkan jumlah stNEAR yang ingin kita batalkan.
 	Klik 'Liquid Unstake' dan setujui transaksi.
 	Setelah beberapa detik, setelah transaksi kita akan dikonfirmasi oleh blockchain, NEAR milik kita yang tidak distake akan tersedia di dompet NEAR kita.



Catatan : Catatan: Biaya likuiditas Meta Pool berkisar dari 0,3% hingga 3%. Ini bervariasi secara linear sesuai dengan jumlah likuiditas yang tersedia di Meta Pool Liquidity Pool.




	

	
	
		
			
				Apakah StNEAR dipatok senilai 1:1 terhadap harga NEAR token?
			
		

		
					

		
			
			
			
			Benar
		
			
			Salah
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Panduan : Menjadi Penyedia Likuiditas

Liquid Unstaking hanya akan memungkinkan karena adanya Penyedia Likuiditas (LP) yang menyediakan protokol dengan token NEAR yang diperlukan untuk pertukaran instan (penarikan) dengan stNEAR. Penyedia Likuiditas mendapatkan biaya dari Liquid Unstaking.

Untuk menambah atau menarik $NEAR sebagai penyedia likuiditas, caranya adalah:

 	Buka tab Likuiditas di halaman Meta Pool
 	Pilih apakah anda ingin "Tambah" atau "Hapus" likuiditas
 	Masukkan jumlah $NEAR token untuk ditambahkan atau dihapus



Catatan : Jumlah token minimum yang dibutuhkan untuk menyediakan likuiditas adalah 2 NEAR



 	Konfirmasi dan tandatangani transaksi

Sekarang, setiap kali seseorang melakukan liquid unstake, anda akan mendapatkan sebagian kecil dari biaya sesuai dengan ekuitas anda di kumpulan likuiditas.




	

	
	
		
			
				Apakah APY ~10.8% merupakan standar penghasilan rata-rata dari seorang penyedia likuiditas?
			
		

		
					

		
			
			
			
			Benar
		
			
			Salah
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Meta Pool модуль 4 – Участие в управлении

Управление Meta Pool
Управление - это процесс, в рамках которого Meta Pool стремится передать управление проектом обратно сообществу. Таким образом, держатели токенов $META будут иметь возможность управлять протоколом на цепи блоков через DAO.

Создание реального децентрализованного управления в сети — это работа над всей экосистемой Web 3. Кроме того, в этом модуле рассказывается, как Meta Pool справляется с этой задачей.
Meta Pool DAO
Meta Pool использует токены $META для управления DAO. Цель состоит в том, чтобы токен $META распространялся среди разработчиков протоколов и участников проекта полностью прозрачным способом.

Следует отметить, что до того, как платформа управления голосованием в сети будет готова для держателей токенов $META, участники основного протокола будут принимать важные решения, основанные на видении проекта и неформальном вкладе сообщества.

Это сделано намеренно, так как мы считаем важным сохранять гибкость управления в первые дни существования протокола.

Основные цели введения токена управления: Стимулировать ликвидность. Чтобы повысить начальную ликвидность и ускорить рост платформы Meta Pool.

Форма ДАО. Токен $META представляет собой право собственности на Meta Pool DAO. DAO будет отвечать за обновление параметров программы, дорожной карты продукта и других стратегических решений. Капитализация казны, обеспечения финансирования стратегического партнерства или создания резервных фондов.
$META токеномика
Максимальное количество: 1 000 000 000 $META

 	Учредители: 30%

За работу по созданию, запуску, продвижению и поддержке протокола. Токены учредителей имеют блокировку на 1 год, за которой следует 2-летний линейный выпуск. (всего 3 года)

 	Команда и консультанты: 2,6%

Чтобы создать продукт мирового класса, нам нужно лучшее из экосистемы NEAR. Команда будет привержена протоколу на долгие годы. Токены консультантов имеют 2-летнюю блокировку, за которой следует 1-летний линейный выпуск. (всего 3 года)

 	Инвесторы 10%

Партнерство с ведущими инвесторами и учреждениями станет ключом к нашему глобальному охвату, а также к лучшему пониманию макроэкономических условий на криптовалютных рынках. Мы знаем не всё, поэтому старшие консультанты и доступ к их сети будут иметь решающее значение для нашего роста. Токены инвесторов имеют блокировку на 1 и 2 года с последующим линейным выпуском на 1 год. (всего 2 и 3 года)

 	Распределение по венчурным раундам:

4% первый раунд

6% A раунд

 	Сообщество и казначейство: 57,40%




	

	
	
		
			
				Токен $META получает ежемесячные аирдропы
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Заработайте право голоса в Meta Pool – Meta Vote
Meta Vote — это платформа для голосования на базе сообщества:

 	Проекты по сбору средств на Meta Yield и
 	Поддержка валидаторов в голосовании по метастейкингу.

Это платформа, предназначенная для получения права голоса для поддержки проектов в Meta Yield и делегирования токенов NEAR валидаторам в Meta Staking Vote.
Как использовать Meta Vote?
Вы можете получить доступ к Meta Vote по ссылке https://metavote.app/ или:

 	из Meta Yield, нажав на проекты, за которые вы хотите проголосовать https://metayield.app/
 	из Meta Staking Vote, нажав на Валидатор, за которого вы хотите проголосовать https://vote.metapool.app/ или нажав на ссылки на Meta Vote на странице, чтобы получить право голоса.

Подключите свой кошелек к Meta Vote

На сайте Meta Vote: https://metavote.app/ привяжите свой кошелек NEAR, чтобы иметь полный доступ к своим активам.
Meta Vote работает в 3 простых шага:

 	Заблокируйте свои токены $META
 	Получите право голоса
 	Голосуйте за проекты в Meta Yield или голосуйте в поддержку валидаторов.

Заблокируйте свои токены $Meta
Чтобы иметь возможность голосовать за проекты или валидаторов, вы должны получить право голоса, это очень просто. Способ получить его — заблокировать ваши токены $META.

Если у вас еще нет $META, то вам понадобится. См. ниже «Как получить токены $META?»

 	Нажмите на кнопку + Add Voting Power



 	Введите количество токенов $META, которое вы хотите заблокировать.
 	Выберите период, на который вы хотите «разблокировать» свои токены, с помощью ползунка. Это время разблокировки ваших токенов $META.

Время, на которое может быть заблокирована ваша $META, составляет от 30 дней и до 300 дней. Чем дольше ваш $META заблокирован, тем больше у вас права голоса для каждого заблокированного токена $META.



После выбора периода блокировки нажмите на кнопку блокировки и подтвердите транзакцию через кошелек NEAR — всё вы готовы голосовать!

 	Используйте право голоса, чтобы голосовать за желаемые проекты или поддерживать валидаторов.



 	Вернитесь на https://metayield.app/ или на https://vote.metapool.app/, обновите страницу и посмотрите количество голосов!

1. Meta Yield: вы можете использовать кнопку «Голосовать сейчас» в любом проекте и поддержать его своими токенами. Кроме того, вам не нужно тратить все свои токены на один проект, вы можете поддерживать несколько!



2. Meta Staking Vote: теперь вы можете напрямую голосовать за выбранного вами валидатора. Просто нажмите на кнопку "проголосовать"



за валидатора по вашему выбору или выберите валидатора, которого вы хотите поддержать. Прочитайте всю информацию об этом валидаторе и проголосуйте за него. Вы можете поддерживать несколько валидаторов, а не только одного.


Формула получения права голоса для ваших токенов $META
MULTIPLIER = 1 + (4 * (days – MIN_LOCK_DAYS) / (MAX_LOCK_DAYS – MIN_LOCK_DAYS))

 	MIN_LOCK_DAYS=30
 	MAX_LOCK_DAYS=300

Пример


Как получить токены $META?
В правом верхнем углу приложения Meta Vote нажмите “Get More $META”



Эта ссылка на Ref Finance, чтобы обменять токены NEAR или другие нативные активы NEAR на токены $META.

https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

Также вы можете получить токены $META на любых платформах DEFI экосистемы NEAR.
Этап блокировки
Период блокировки
Стадия блокировки позволяет вам голосовать за проекты. Токены $META заблокированы, и пользователи могут голосовать/не голосовать за проекты или валидаторов в любое время. Для этого этапа нет ограничения по времени. Право голоса будет доступно до тех пор, пока токены $META заблокированы.


Период разблокировки
Как только кампания по голосованию проекта завершена или пользователь хочет прекратить поддержку валидатора, начинается период разблокировки. При нажатии кнопки «Начать разблокировку» начинается отсчет времени разблокировки, что соответствует времени, установленному путем добавления полномочий голосования.

Следует отметить, что этап разблокировки может быть запущен только при наличии достаточного количества голосов. Если используется право голоса, и его недостаточно для полной разблокировки позиции, он не сможет начать период разблокировки.



Важно: период разблокировки не начинается автоматически, он должен быть запущен пользователем вручную.
Вывод токенов $META
По истечении времени разблокировки токены $META можно будет вывести.

Важно: вывод токенов $META должен производиться пользователем вручную.






	

	
	
		
			
				За блокировку ваших токенов в Meta Vote взимается комиссия в размере 3,5%
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Staking Vote — используйте свое право голоса, чтобы поддержать лучших валидаторов
Meta Staking Vote — это основанная сообществом платформа для выбора валидаторов, которые путем голосования распределят 15% токенов NEAR, размещенных в Meta Pool.

Meta Poll дает право управления держателям $META, поскольку именно они голосуют за мета-стейкинг.
Как использовать Meta Staking Vote?
Получите доступ к Meta Staking Vote по ссылке https://vote.metapool.app/.

Подключите кошелек NEAR к Meta Staking Vote

На сайте Meta Staking Vote: https://vote.metapool.app/ привяжите кошелек NEAR. Нажмите кнопку «Подключить кошелек», выберите кошелек и подключитесь.


Meta Staking Vote работает в 4 простых шага:

 	Заблокируйте токены $META на платформе Meta Vote.
 	Получите право голоса.
 	Голосуйте за поддержку валидаторов на платформе Meta Staking Vote.
 	Смотрите информационную панель голосов и назначений ставок NEAR.

Как это работает

 	Пользователи Meta Pool размещают свои токены NEAR, получая взамен stNEAR.
 	Эти поставленные stNNEAR распределяются по узлам валидаторов. Это помогает децентрализовать и защитить протокол NEAR. Чем больше пользователей делают ставки в Meta Pol, тем больше распределяется между узлами валидатора.
 	Валидаторы производят блоки и получают за это вознаграждение, это увеличивает ценность stNEAR в токенах NEAR.
 	Из общего количества размещенных токенов NEAR Meta Staking Vote делегирует 15% валидаторам путем голосования держателей $META (сторонников).

Это будет постоянное голосование, в соответствии с результатами Meta Staking Vote выделяет 1% от общей суммы ставок в Meta Pool каждые ̴4 эпохи.


Владельцы токенов $META
Голосование состоит из 2-х шагов:

 	Выбор валидатора: перейдите по ссылке: https://vote.metapool.app/ Полный список валидаторов, отслеживаемых Meta Staking Vote.

 



Для получения дополнительной информации щелкните имя валидатора, вы будете перенаправлены на страницу валидатора с подробной информацией.



После того, как Валидатор для поддержки и голосования будет проанализирован и выбран, проголосуйте. Выберите его для голосования в списке (кнопка проголосовать) или на странице валидатора (кнопка проголосовать за этого валидатора).

 	Голосование за валидатора: подключите кошелек NEAR. Выберите валидатора для голосования в списке (кнопка голосования) или на странице валидатора (кнопка голосования за этот валидатор) и назначьте ему право голоса.

В этом разделе объясняется, как получить право голоса.

Голосование за валидаторов — это непрерывная кампания, поэтому голоса учитываются для каждой кампании, пока она работает.

Голосуйте за любое количество валидаторов без ограничения количества голосов.

Голоса могут быть изменены в любое время. Вот как работает голосование за валидаторов в Meta Staking Vote: просто, безопасно и с возвратом 100% токенов $META.
Делегирование
15% TVL Meta Pol предоставленного пользователями, делающими ставки, будут делегированы голосованием держателей $Meta.

Если TVL увеличивается, распределяемая сумма увеличивается. Очень важно продвигать пул ликвидных ставок Meta Pool для инвесторов, для чего нам требуется поддержка валидаторов и сообщества.

Кампания делегирования является непрерывной, и каждые 4 эпохи назначается 1% от общей суммы ставок в Meta Pol.




	

	
	
		
			
				После того, как вы проголосовали за валидатора, вам нужно подождать 60 эпох, чтобы передать свое голосование другому валидатору
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Платформа – Общие данные


 	Валидаторы

Это количество валидаторов, одобренных Meta Pol для голосования в соответствии с критериями выбора валидаторов.

 	Прогресс эпохи

Указывает оставшееся время эпохи проверки/производства блока.

Эпоха длится примерно 13 часов. (Эпоха длится 43 200 блока, а блок длится примерно 1,1 секунды).

 	стейкинг NEAR @ Meta Pool

TVL (общая заблокированная стоимость) для делегирования валидаторам. 85% по производительности и 15% по голосам в Meta Staking Vote.

Эта сумма соответствует токенам NEAR, размещенным в Meta Pool.

Сумма доступна в: https://staking.metapool.app/ – Общее количество токенов stNEAR, умноженное на цену stNEAR.

 	NEAR с назначением голосов

15% ТВЛ распределяются голосованием. Сколько соответствует каждому валидатору в отдельности, можно посмотреть в NEAR с назначением голосов.

 	Доступное количество голосов

Доступная сила голоса, которую можно использовать для голосования за валидаторов. Если Голосование недоступно, его можно приобрести по адресу: https://metavote.app/ (перейдя по ссылке ниже суммы).

Важно: токены $META необходимы для получения права голоса. Получите $META на https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

 	В использовании / Всего

Используемое право голоса и общее количество голосов, которыми обладает пользователь.

Всего может быть за то, что уже проголосовали за валидаторов или за проекты голосования в Meta Yield.
Информация о голосовании валидаторов


 	Имя

Чтобы узнать больше о конкретном валидаторе, просто нажмите на его имя, и оно будет перенаправлено на отдельную страницу выбранного валидатора.

 	APY

Годовой процентный доход, предоставляемый каждым валидатором. Это зависит от производительности валидаторов и комиссий.

 	Голоса

Количество голосов, отданных каждому валидатору, и соответствующий процент от общего числа. Голосование является непрерывным и указывает на тенденцию к делегированию процентной доли распределения.

 	Присвоено голосами

Количество токенов NEAR, соответствующее каждому валидатору, согласно 15%, которые будут назначены голосами.

Важно: только 1% будет присвоено примерно каждые 4 эпохи. Эта сумма является тенденцией к достижению, назначенной каждому валидатору в соответствии с голосами.

Общий TVL, который будет назначен голосованием, распределяется примерно каждые 15 групп по 4 эпохи.

 	Назначенная сумма

Эта сумма соответствует сумме, которая будет назначена по производительности (85%) и по голосам (15%). Это общая тенденция, которую должен достичь валидатор.

 	Meta Pol

Токены NEAR в настоящее время делегированы Meta Pol каждому валидатору.




	

	
	
		
			
				Право голоса может быть использовано в голосовании по ставкам Meta или в кампаниях по голосованию Meta Yield
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Développement de contrats intelligents sur Near en utilisant Rust Partie 2

Ceci est la deuxième partie d'une série d'articles sur la création d'une application de tchat avec Rust sur la blockchain Near. Vous pouvez trouver le premier article de la série ici.

Dans cet article, nous nous concentrerons sur le contrat intelligent lui-même. Nous verrons la bibliothèque near-sdk qui fait fonctionner notre code sur Near. Nous verrons également les modèles d'accès et les principes de développement de contrats intelligents en examinant le code de ce contrat intelligent. Vous pouvez trouver le référentiel complet avec tout le code dont nous parlerons aujourd'hui sur mon GitHub
Contrat intelligent de Near Rust SDK
À la base, l'environnement d'exécution des contrats intelligents de Near utilise WebAssembly (Wasm). Wasm est un format de bytecode bien établi qui est également utilisé en dehors de la blockchain, comme dans les applications Web. C'est bien pour Near car son exécution peut bénéficier du travail effectué dans la communauté Wasm au sens large.

Le compilateur Rust fait du bon travail pour générer la sortie Wasm, mais il doit y avoir un échafaudage autour de lui pour que le bytecode Wasm fonctionne correctement avec son "hôte" (le runtime Near dans notre cas, ou le moteur JavaScript d'un navigateur Web dans le cas d'une application Web). Cet échafaudage peut être généré automatiquement à l'aide de bibliothèques Rust pratiques : wasm-bindgen dans le cas de l'intégration du navigateur et near-sdk dans le cas de Near. Le contrat intelligent avec lequel nous travaillons aujourd'hui est écrit en quasi-sdk.

Les deux bibliothèques utilisent des macros procedurale Rust (macros proc). Il s'agit d'une sorte de métaprogrammation où la bibliothèque définit de petites annotations que nous pouvons utiliser pour déclencher la génération automatique de code Rust pour nous. Les macros proc de Rust sont utilisées pour réduire la quantité de code passe-partout que le développeur doit écrire pour faire fonctionner sa logique métier. Par exemple, la macro de dérivation proc est au cœur du langage Rust. Il peut définir automatiquement des fonctionnalités communes sur les nouveaux types de données que vous créez. Vous pouvez voir ceci utilisé dans le code snippet suivant du contrat intelligent de chat :
#[derive(

Debug, BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, Copy, PartialEq, Eq,

)]

#[serde(crate = “near_sdk::serde”)]

pub enum MessageStatus {

Read,

Unread,

}
Vous pouvez voir de nombreux traits répertoriés dans l'annotation de dérivation. Pour en appeler certains spécifiques : Debug signifie que le type MessageStatus peut être converti en une chaîne pour aider au débogage du code ; Clone signifie qu'il est possible de créer une instance MessageStatus identique à partir de l'instance actuelle, et Copy signifie que l'opération Clone est bon marché ; PartialEq et Eq signifient que vous pouvez comparer deux instances de MessageStatus pour voir si elles sont identiques. Les traits Serialize et Deserialize proviennent de la bibliothèque serde, qui est omniprésente dans l'écosystème Rust pour encoder/décoder des données à partir de formats tels que JSON ou CBOR. Nous reviendrons sur les traits de Borsh plus tard.

Jusqu'à présent, il s'agissait de Rust standard que vous trouverez dans n'importe quel projet. La macro proc spécifique à Near est near_bindgen que vous pouvez voir utilisée dans le code snippet suivant :
#[near_bindgen]

#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]

pub struct MessengerContract {

accounts: LookupMap<AccountId, AccountStatus>,

messages: LookupMap<MessageId, Message>,

unread_messages: UnorderedSet<MessageId>,

read_messages: UnorderedSet<MessageId>,

last_received_message: LookupMap<AccountId, MessageId>,

pending_contacts: UnorderedSet<AccountId>,

owner: AccountId,

}
La macro proc near_bindgen génère automatiquement le code supplémentaire dont nous avons besoin pour que, lorsque nous compilons vers Wasm, nous obtenions une sortie que le runtime Near comprend comment utiliser. Il est utilisé à plusieurs endroits où un tel code de colle est nécessaire. Ici, il marque la structure MessengerContract comme ayant l'état nécessaire pour exécuter les méthodes du contrat. Une instance de la structure MessengerContract sera créée chaque fois que nous appellerons une méthode sur notre contrat intelligent. Nous verrons à quoi servent certains de ces champs plus tard.

La macro near_bindgen est également utilisée sur le bloc impl pour la structure MessengerContract :
#[near_bindgen]

impl MessengerContract {

// …

}
Ici, cela signifie que les fonctions définies dans ce bloc sont les méthodes que nous voulons exposer sur notre contrat intelligent. Il permet aux utilisateurs de la blockchain Near de soumettre des transactions en appelant ces fonctions par leur nom. Par exemple, la méthode d'envoi d'un message est définie dans ce bloc. Nous examinerons plus en détail ci-dessous d'autres méthodes de ce bloc.

En résumé, la bibliothèque de rouille near-sdk fournit une macro proc appelée near_bindgen pour générer automatiquement du code de colle qui fait fonctionner la sortie Wasm avec le runtime Near. Cette macro peut être utilisée sur une structure pour définir l'état de votre contrat et sur le bloc impl de cette structure pour définir les méthodes publiques de votre contrat. Near-sdk fournit également d'autres fonctions et structures utiles, que nous verrons dans les sections suivantes.
État du contrat intelligent
Essentiellement, tous les contrats intelligents non triviaux nécessitent un état pour fonctionner correctement. Par exemple, un contrat de jeton doit maintenir les soldes des différents détenteurs de jetons. Notre contrat de chat n'est pas différent. Nous avons vu dans la section précédente que la structure MessengerContract contenait de nombreux champs. Dans cette section, nous discutons de certaines caractéristiques générales de l'état dans l'environnement d'exécution de Near ainsi que de certaines spécificités quant à la façon dont il est utilisé dans l'exemple de contrat intelligent.

La chose la plus importante à savoir sur l'état du contrat intelligent dans Near est qu'il s'agit d'un simple stockage clé-valeur. Vous pouvez le voir dans les fonctions de bas niveau storage_read et storage_write exposées par near-sdk. Cependant, vous pouvez créer des structures de données plus sophistiquées sur cette base simple, et near-sdk en fournit certaines dans son module de collections. Pour cette raison, notre exemple de contrat n'utilise pas directement le stockage clé-valeur ; à la place, il utilise les collections de niveau supérieur offertes par quasi-sdk.

Par exemple, le contrat intelligent garde une trace de l'état des comptes dont il a connaissance (quels sont des contrats, auxquels nous avons envoyé une demande de contact, etc.). Le champ comptes de MessengerContract est une structure LookupMap de near-sdk. C'est assez proche de l'utilisation directe du stockage clé-valeur puisque la carte est aussi simplement un moyen de rechercher une valeur à partir d'une clé, mais LookupMap fait deux choses importantes au-dessus de l'interface de stockage clé-valeur brute. Premièrement, il a un préfixe qu'il inclut sur toutes les clés de stockage liées à cette carte. L'utilisation d'un préfixe évite de mélanger les clés de cette carte avec les clés d'une autre (par exemple la carte last_received_message, qui est également indexée sur AccountId). Deuxièmement, LookupMap nous permet de travailler avec des types Rust de niveau supérieur alors que l'interface de stockage brut ne fonctionne qu'avec des octets. Ceci est réalisé en utilisant la sérialisation Borsh pour convertir les types vers/depuis les chaînes binaires. Borsh est un format de sérialisation conçu par Near pour être spécifiquement utile dans les applications blockchain. Cette utilisation de Borsh est la raison pour laquelle vous voyez BorshDeserialize et BorshSerialize dérivés sur de nombreux types dans le code.

Un exemple plus intéressant d'une collection utilisée ici est le UnorderedSet utilisé dans le champ unread_messages. Ceci est utilisé pour le contrat afin de garder une trace des messages qui ne sont toujours pas lus. Le UnorderedSet est toujours construit sur le stockage clé-valeur sous-jacent, mais il n'utilise effectivement que les clés car nous ne nous soucions que de savoir si un élément est dans l'ensemble ou non. La structure conserve également des métadonnées sur les clés qu'elle utilise pour nous permettre d'itérer sur toutes les clés de l'ensemble.
Vérifier l'environnement et appeler d'autres contrats
Dans cette section, nous discutons des fonctionnalités générales de l'environnement d'exécution de Near et des appels de contrats croisés. Pour nous garder ancrés, cela se fait dans le contexte de la façon dont les utilisateurs s'ajoutent en tant que contacts dans notre application de chat. Examinons la définition de la fonction add_contact (cette définition se trouve dans le bloc MessengerContact impl, avec l'annotation near_bindgen mentionnée ci-dessus, car c'est un point d'entrée principal pour notre contrat).
#[payable]

pub fn add_contact(&mut self, account: AccountId) –> Promise {

self.require_owner_only();

let deposit = env::attached_deposit();

require!(deposit >= ADD_CONTACT_DEPOSIT, “Insufficient deposit”);

let this = env::current_account_id();

Self::ext(account.clone())

.with_attached_deposit(deposit)

.ext_add_contact()

.then(Self::ext(this).add_contact_callback(account))

}
Il y a beaucoup à déballer dans ces quelques lignes de code. Comme cadre supplémentaire pour guider notre discussion, rappelons les trois principes du développement de contrats intelligents décrits dans le post précédent :

1- un état d'esprit contradictoire,

2- économie,

3- s'assurer des invariants avant de faire des appels croisés.

Revenez en arrière et passez en revue le premier article si vous avez besoin d'un rappel sur la nature de ces principes. Chacun de ces principes apparaît dans cette fonction.
Un état d'esprit contradictoire
Toutes les méthodes de contrat intelligent sont publiques et nous devons appliquer le contrôle d'accès lorsque la méthode effectue une action sensible, sinon quelqu'un abusera de la fonctionnalité. Dans ce cas, nous ne voulons pas que quiconque puisse ajouter des contacts au nom du propriétaire ; seul le propriétaire devrait pouvoir décider avec qui se connecter (si quelqu'un d'autre veut établir des contacts dans le réseau de chat, il peut déployer ce contrat sur son propre compte !). Par conséquent, nous avons l'appel require_owner_only() juste en haut du corps de la fonction. L'implémentation de cette fonction est simple :
fn require_owner_only(&self) –> AccountId {

let predecessor_account = env::predecessor_account_id();

require!(

self.owner == predecessor_account,

“Only the owner can use this method!”

);

predecessor_account

}
Il utilise la fonction predecessor_account_id du module env de near-sdk. Les modules env contiennent de nombreuses fonctions utiles pour interroger les aspects de l'environnement d'exécution Near dans lequel notre contrat s'exécute. Par exemple, nous vérifions ici quel compte a appelé notre contrat. Le module env contient d'autres fonctions utiles telles que la vérification de l'ID de compte de notre contrat lui-même et le nombre de jetons Near attachés à cet appel. Je recommande de lire la documentation du module pour voir toutes les fonctions qui sont disponibles.

Pour des raisons d'efficacité, la fonction require_owner_only renvoie également le compte prédécesseur (pour éviter plusieurs appels à env::predecessor_account_id() au cas où une fonction propriétaire uniquement aurait également besoin du compte prédécesseur pour une autre raison).
Économie
La toute première ligne de l'extrait de code add_contact ci-dessus inclut l'attribut payable. L'utilisation de cette annotation est activée par la fonction définie dans le cadre d'un bloc impl near_bindgen. Cela signifie que cette méthode acceptera les jetons Near des utilisateurs qui l'appellent. Ces jetons sont nécessaires car nous avons décidé que les utilisateurs paient pour des actions telles que la création d'un état en chaîne. Étant donné que l'ajout d'un autre compte en tant que contact crée un état dans leur contrat ainsi que dans le nôtre (nous devons leur faire savoir que nous voulons nous connecter), nous devons nous assurer que l'utilisateur qui initie cette connexion paie pour ce stockage. La caution attachée à cette fonction payante sert à couvrir ce coût de stockage.

Vous pouvez voir quelques lignes plus bas où nous vérifions que la caution est bien présente. Cela utilise la fonction attachment_deposit du module env. Le fait que nous fassions cette vérification tôt correspond parfaitement au troisième principe
S'assurer des invariants avant de faire des appels croisés
La signature de type de la fonction add_contact est importante à noter. Tout d'abord, les arguments de la fonction (&mut self, account: AccountId) signifient qu'il s'agit d'un appel mutable (il changera l'état du contrat) et qu'il prend un argument appelé "account" qui doit être un ID de compte proche. Lorsque near_bindgen fait sa magie, cela signifie que les utilisateurs de la blockchain Near peuvent appeler cette fonction en effectuant une transaction qui prend un argument encodé JSON comme { "account": "my.account.near" }. Deuxièmement, le type de retour est Promise, ce qui signifie que nous effectuons un appel de contrat croisé à la fin de cette fonction. Les appels croisés sur Near sont asynchrones et non atomiques, nous devons donc nous assurer que tout est en bon état avant de passer l'appel. C'est pourquoi nous incluons le propriétaire uniquement et le chèque de caution en premier dans le corps de la fonction. La nature asynchrone des appels de contrat croisé signifie également qu'il n'y a pas de valeur de retour immédiate de cette fonction. L'appel asynchrone sera effectué et le résultat ne viendra que plus tard, après cet appel.

Vous pouvez voir les détails de l'appel de contrat croisé au bas de la fonction. Il utilise l'API de haut niveau de near-sdk (bien que l'API de bas niveau soit également disponible dans le module env) où la fonction ext est automatiquement générée par near_bindgen et renvoie une structure de données pour construire l'appel de contrat croisé. Vous pouvez voir d'abord que nous utilisons ext(account) pour appeler le compte que nous voulons ajouter en tant que contact. L'appel inclut notre dépôt via with_attached_deposit et appelle la fonction ext_add_contact (qui est définie dans le même bloc impl dans ce cas, mais en général, elle pourrait être définie n'importe où). Enfin, nous appelons then ce qui signifie inclure un callback. Le rappel est lui-même une autre promesse, nous utilisons donc à nouveau la même fonction ext, mais cette fois en appelant notre propre ID de compte. Ceci est fait pour que notre contrat puisse savoir quelle était la réponse du contrat que nous essayons d'ajouter en tant que contact. Je n'entrerai pas dans les détails des implémentations ext_add_contact ou add_contact_callback ici (ils manipulent simplement le stockage en fonction de l'état actuel du compte), mais je vous encourage à les lire dans le code source sur GitHub si vous êtes intéressé.
Résumé
Dans cet article, nous avons plongé la tête la première dans du code ! Nous avons vu comment near_bindgen est utilisé pour générer automatiquement le code nécessaire à l'exécution de notre contrat dans l'environnement d'exécution Near, ainsi que d'autres fonctionnalités de near-sdk pour interagir avec le stockage, l'environnement d'exécution et d'autres contrats. Dans le prochain article, nous continuerons à plonger dans le code, mais changeons de vitesse pour examiner le composant hors chaîne de cette application. Un contrat intelligent ne constitue pas à lui seul une dapp, restez à l'écoute pour savoir pourquoi !

Si vous voulez une expérience pratique avec ce code, essayez quelques-uns des exercices ! À quelques endroits dans le code du contrat intelligent, j'ai inclus un commentaire marqué comme EXERCICE. Par exemple, dans la définition des types, j'indique le fait qu'un statut d'utilisateur bloqué est disponible, mais il n'y a aucun moyen de bloquer quelqu'un actuellement implémenté. L'ajout de cette fonctionnalité pour bloquer un autre utilisateur est un exercice suggéré, et un bon pour commencer. Tous les exercices sont des suggestions de moyens d'étendre les fonctionnalités du contrat, vous donnant l'occasion d'essayer d'écrire vous-même un code de contrat intelligent. Peut-être que dans un prochain article de cette série, je discuterai de quelques solutions aux exercices.

Si vous appréciez cette série d'articles de blog, veuillez nous contacter à Type-Driven Consulting. Nous sommes heureux de fournir des services de développement de logiciels pour les dapps, ainsi que du matériel de formation pour vos propres ingénieurs.

 

### What Is FastAuth?

In March, the NEAR Protocol announced the launch of the Blockchain Operating System (BOS). The idea behind it was to create the ideal entry point to the Open Web and bridge the gap between Web2 and Web3. NEAR’s Blockchain Operating System also saw the introduction of several new features. One of the first and most powerful features to be introduced is FastAuth.

In this article, we will take a closer look at FastAuth, understand its importance, how it works, and what the future holds. Let’s get started!
What Is The Blockchain Operating System? 
Before we move on to FastAuth, let’s briefly understand the Blockchain Operating System. Today, the world of Web2 and Web3 is heavily fragmented. Web2 is highly centralized, with each account controlled by a single entity. Meanwhile, Web3 is fragmented because each blockchain is siloed and cut off from the other. NEAR’s Blockchain Operating System addresses this issue by offering an avenue to discover experiences with common services such as a single identity, user-controlled data, and user-controlled assets.

The Blockchain Operating System is a new operating system designed for a more open web. The system is secure, highly decentralized, easy to onboard, easy to develop on, open source, and accessible to everyone. It was created as an open-source alternative to traditional giants such as Apple, Amazon, Google, Facebook, and Microsoft and eliminates the complexities typically associated with the Web3 space. It works with any blockchain or Web2 backend, enabling access to various gateways. End users get a continuous experience through the Blockchain Operating System, similar to using a single app, even if users have to switch between different chains or applications.

It also simplifies blockchain development, enabling developers to build on any chain, create code in familiar languages, and create innovative apps that are easily distributable and discoverable. This allows users to connect with a growing ecosystem of communities, people, and applications while maintaining complete control of their data. Furthermore, users don’t require any crypto to get started, with the Blockchain Operating System opening up a host of revenue streams and capabilities without needing any prior Web 3 experience.
What Is FastAuth? 
FastAuth is a powerful feature introduced with the Blockchain Operating System that allows users to quickly and easily create accounts that can be used on any application or website that can be integrated with the Blockchain Operating System. FastAuth puts emphasis on user experience and creates a familiar, Web2-type onboarding experience that allows users to create their free account using traditional means such as email addresses, phone prompts, and even biometrics. This enables users to interact with applications quickly and allows them to re-authenticate to the app using the same or different device.

With FastAuth, users can create an account for any website or application on the Blockchain Operating System without requiring new passwords or needing to buy crypto. FastAuth is also great for developers, giving them a quick and easy way to get users to try new applications and components. This helps to significantly improve adoption and bring in millions of Web2 users into the Web3 ecosystem by lowering the entry barrier.
How Does FastAuth Work?
The introduction of FastAuth has helped address one of the biggest challenges in onboarding new users into the Web3 ecosystem. New users can set up a Blockchain Operating Service account as quickly as setting up a traditional account, while developers can deliver their Web3 apps, experiences, and components more seamlessly than ever before. Let’s look at how FastAuth is bridging the gap between Web2 and Web3 and improving Web3 adoption among Web2 users.
Quick And Seamless Onboarding Process And Email Recovery 
One of the biggest challenges when onboarding users in Web3 is the complexity of the onboarding process and the need for users to remember complicated seed phrases. Most users are accustomed to traditional centralized authentication methods such as signing in with Google. As a result, using and getting accustomed to complex seed phrases can be quite daunting and create a significant entry barrier. This makes it difficult to onboard new users into the Web3 ecosystem.

Combining FastAuth with decentralized email recovery does away with the need for users to remember complicated seed phrases or third-party wallet applications. Users can simply recover an account using a “Single Sign-On” process with the email they have used during the registration process. FastAuth uses “Multi-Party Computation” to decentralize the account recovery process, paving the way for mass adoption through an easy, secure, and decentralized account recovery system.

As a result, FastAuth is able to address some of the most challenging aspects of onboarding new users into the Web3 ecosystem. Users can set up a Blockchain Operating System account quicker than creating a traditional Google or Facebook account. At the same time, developers can deliver apps, experiences, and Web3 components to users in a seamless manner.




	

	
	
		
			
				What Is FastAuth? 
			
		

		
					

		
			
			
			
			A seamless solution for quick onboarding to the Blockchain Operating System
		
			
			A new OS for the open web
		
			
			A new blockchain protocol 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





No Third-Party Apps 
FastAuth also eliminates the need to download and install third-party applications. This is because it creates a seamless, user-focused experience, making the open web accessible to everyone instantly, clearing the way for mainstream adoption. Any developer on the Blockchain Operating System can leverage FastAuth’s user-friendly experience and get users on their apps.
No Need For Crypto When Creating An Account 
Until now, users that wished to explore and interact with apps in Web3 were required to hold or acquire crypto before getting started. FastAuth allows users to directly access the Web3 ecosystem without running around getting their hands on crypto. This is highly beneficial for all users, including end users, developers, and enterprises. FastAuth uses NEAR’s Zero Balance Accounts and Meta Transactions, enabling users to register their accounts free of charge. This is also advantageous for developers because Meta Transactions are paired with relayers, enabling initial interactions without acquiring $NEAR.
Who Can Use FastAuth? 
FastAuth is an ideal solution for developers, end users, and enterprises. Let’s look at how each can benefit from it.
Developers 
Thanks to FastAuth’s streamlined onboarding experience, developers can increase the conversion rate for users trying their applications and components. It can also expand an app’s user base by giving it greater mainstream exposure.
Enterprises 
FastAuth allows enterprises to easily integrate Web3 and crypto into their businesses with just a few lines of code. Businesses can easily onboard users into a powerful community and experiences which are accessible, decentralized, and highly secure.
End Users 
Through FastAuth, users can set up their user-owned account in seconds, enabling them to get started with Web3 quickly and seamlessly.




	

	
	
		
			
				Who Has FastAuth Been Created For? 
			
		

		
					

		
			
			
			
			Developers
		
			
			Enterprises
		
			
			Users
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





In Closing: The Future 
FastAuth is just getting started, and there are several other features and upgrades that are in the pipeline. In its effort to bridge Web2 and Web3 FastAuth aims to introduce the following features in the near future.

 	Multi-chain compatibility
 	Additional MPC Decentralization
 	Two-factor authentication
 	Expanding relayers and FastAuth to gateways beyond NEAR.

If you wish to learn more about the upcoming FastAuth features, check out near.org for more information. If you wish to try out FastAuth for yourself, you can create an account here and then use the same account to sign in everywhere on NEAR.




	

	
	
		
			
				What are the challenges faced in onboarding users in Web3?
			
		

		
					

		
			
			
			
			A Complicated onboarding experience
		
			
			Long passwords or seed phrases
		
			
			The need for acquiring crypto before accessing Web3
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!

### What is your favorite NEAR explorer?

What is your favorite NEAR explorer? 
            
                224 votes by,
                392 nLEARNs spent
            
            
            
                                    
                        
                            pikespeak.ai                            
                                (21 votes,
                                57 nLEARNs)
                            
                        
                        
                             
                            9%
                        
                    
                                    
                        
                            nearblocks.io                            
                                (126 votes,
                                212 nLEARNs)
                            
                        
                        
                             
                            56%

### Почему WordPress может открыть ворота в Web3

Переход на веб3 кажется неизбежным. Несколько компаний уже начали экспериментировать с различными аспектами web3, такими как NFT, метавселенная и токенизация. Однако, как сгладить этот переход? В клубе Learn Near Club будущее web3 может быть достигнуто за счет включения инструментов web3 в проверенные и открытые платформы web2. Одним из лучших примеров «проверенной и открытой» веб-платформы является WordPress. В этом блоге давайте посмотрим, как WordPress способствует децентрализованному росту в пределах своей централизованной структуры.
Что такое WordPress?
WordPress — популярная система управления контентом (CMS) с открытым исходным кодом, которая позволяет пользователям создавать и управлять веб-сайтами и блогами. С момента своего выпуска в 2003 году он превратился в одну из наиболее широко используемых платформ для веб-сайтов, на которой работает около 43% всех веб-сайтов в Интернете.

Одной из основных причин его популярности является удобный интерфейс, не требующий от пользователей каких-либо знаний в области программирования. Это сделало его популярным среди тех, кто хочет легко создавать и публиковать контент. Кроме того, большое сообщество разработчиков создало множество плагинов и тем, которые можно легко интегрировать в платформу, предоставляя дополнительные функциональные возможности и эстетическую привлекательность.

WordPress легко настраивается, что означает, что он может обслуживать широкий спектр веб-сайтов, от небольших личных блогов до крупных корпоративных сайтов. Он также масштабируем, что позволяет ему расти вместе с ростом бизнеса или веб-сайта. Платформа может добавлять новые функции и возможности по мере необходимости, что делает ее легко адаптируемой.

Еще одним преимуществом WordPress является его SEO-дружественная структура. Веб-сайты, созданные с помощью WordPress, имеют встроенный инструмент SEO, который позволяет пользователям оптимизировать свой контент и убедиться, что он адаптирован к поисковым системам. Эта функция сделала WordPress предпочтительным выбором для многих компаний и частных лиц, которые хотят, чтобы их веб-сайты были легко найдены поисковыми системами.
Философия WordPress
Философия WordPress построена на нескольких основных принципах, которыми руководствуются его разработчики и сообщество. Вот эти принципы:

 	Обеспечить удобную и доступную платформу для создания и публикации контента в Интернете для всех. Это означает, что программное обеспечение должно быть простым в использовании, понятным и бесплатным.
 	Программное обеспечение с открытым исходным кодом свободно доступно для использования, модификации и распространения без каких-либо ограничений. Это помогло создать большое сообщество разработчиков, которые постоянно совершенствуют и расширяют платформу, добавляя новые функции и возможности.
 	Поощрение пользователей за совместную работе и обмену знаниями. Это привело к созданию активного сообщества пользователей, разработчиков и участников, которые вместе работают над улучшением платформы.
 	Предоставить инструмент, который может использовать каждый, независимо от его технических знаний или физических способностей. Это означает, что программное обеспечение должно быть разработано с учетом доступности, что упрощает его использование и навигацию для всех пользователей.

WordPress ориентирован на создание открытой, доступной и удобной для пользователя платформы с упором на сообщество и сотрудничество. Эти основные принципы помогли сделать WordPress одной из самых популярных систем управления контентом в мире.




	

	
	
		
			
				Какова одна из основных причин популярности WordPress как системы управления контентом?
			
		

		
					

		
			
			
			
			его стоимость
		
			
			его дружественный интерфейс, с которым разберется любой пользователь
		
			
			его совместимость с другими платформами
		
			
			его собственнический характер
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress и Web3
Давайте посмотрим на существующую связь между WordPress и web3. Хотя WordPress по своей сути не является платформой Web3, существуют способы интеграции технологий Web3 в WordPress для создания более децентрализованных и безопасных веб-сайтов. Одним из таких способов является использование децентрализованных систем доменных имен (DNS), таких как Unstoppable Domains. Вы также можете использовать децентрализованные системы хранения, такие как IPFS. IPFS — это одноранговая система хранения, которая позволяет пользователям хранить и обмениваться файлами децентрализованным и устойчивым к цензуре способом. Интегрируя IPFS в веб-сайт WordPress, пользователи могут создать более безопасную и децентрализованную платформу для обмена контентом. Наконец, создатели веб-сайтов всегда могут интегрировать API-интерфейсы криптоплатежей для доступа к децентрализованным платежам.
WordPress — золотой стандарт
Как видите, WordPress — это гибкая платформа web2, которая позволяет легко интегрировать технологии web3. CMS пользуются 38% всех веб-сайтов в Интернете для создания и управления различными типами сайтов, такими как личные блоги, интернет-магазины и т. д. Этот открытый характер также позволил WordPress создать открытое и активное сообщество участников. Эти участники усердно работают над улучшением платформы, разрабатывая новые функции, исправляя ошибки и поддерживая основной код. Любой может внести свой вклад в WordPress, и есть много способов сделать это.




	

	
	
		
			
				Как WordPress соответствует принципам web3?
			
		

		
					

		
			
			
			
			является централизованной платформой с фиксированным набором функций
		
			
			полагается на одного разработчика для всех обновлений
		
			
			является платформой с закрытым кодом
		
			
			поддерживает и поощряет сообщество
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как участники помогают WordPress

 	Сообщая об ошибках, предлагая новые функции и давая отзывы о существующих функциях, пользователи помогают разработчикам выявлять проблемы и вносить необходимые улучшения. Эта обратная связь имеет решающее значение для дальнейшего роста и успеха платформы.
 	WordPress доступен на многих языках, но всегда требуется больше переводчиков, чтобы сделать платформу доступной для большего числа людей. Чтобы помочь с переводами, не нужно свободно владеть несколькими языками — даже небольшой вклад может иметь большое значение.
 	Если у вас есть навыки программирования, вы можете внести свой вклад в WordPress, написав код, исправив ошибки или разработав новые функции. WordPress — это платформа с открытым исходным кодом, и каждый может получить доступ к ее коду и внести свой вклад в его разработку. В зависимости от ваших навыков и интересов вы можете внести свой вклад в ядро WordPress, плагины или темы.
 	Вы также можете внести свой вклад в WordPress, помогая с документацией, дизайном или управлением сообществом. Эти области так же важны, как и кодирование. Есть много возможностей для участия.
 	Вы можете поддержать сообщество WordPress, помогая другим пользователям на форумах, посещая встречи и организуя мероприятия WordPress. Поддерживая сообщество, вы создаете гостеприимную и инклюзивную среду, выгодную для всех участников.

Экономика WordPress
Согласно исследованию WPEngine, мировая экономика WordPress, в которую входят все предприятия, разработчики и пользователи, связанные с WordPress, в 2020 году оценивалась примерно в 596,7 миллиарда долларов.

Automattic, глобальная дистрибьюторская компания, стоящая за WordPress.com, с 1983 специалистами по автоматизации в 96 странах, говорящими на 123 разных языках.

Заработок на WordPress возможен различными способами. Вот некоторые из лучших способов монетизации вашего сайта на WordPress:

 	Электронная торговля: используйте плагин, такой как WooCommerce, чтобы превратить свой веб-сайт WordPress в интернет-магазин, где вы можете продавать физические или цифровые продукты, услуги или встречи.
 	Реклама: показывайте рекламу на своем веб-сайте и зарабатывайте деньги с помощью оплаты за клик (PPC) или других рекламных моделей. Google AdSense — популярный вариант для показа релевантной рекламы на вашем сайте.
 	Партнерский маркетинг: продвигайте продукты или услуги других компаний в своем блоге или на веб-сайте, используя уникальные партнерские ссылки. Вы получаете комиссию за каждую продажу или действие, совершенное через вашего реферала.
 	Эксклюзивный контент. Предлагайте премиальный или эксклюзивный контент своим посетителям за определенную плату. Это могут быть статьи, видео, курсы или другие ценные ресурсы.
 	Онлайн-курсы: если у вас есть специальные знания или навыки, создавайте и продавайте онлайн-курсы через свой веб-сайт WordPress. Это позволяет вам делиться своим опытом и монетизировать свои знания.
 	Создание плагинов: если у вас есть навыки программирования, вы можете разрабатывать и продавать плагины для WordPress. Многие владельцы веб-сайтов готовы платить за плагины, расширяющие функциональность их веб-сайтов.
 	Создание сайтов WordPress для клиентов. Если у вас есть навыки веб-разработки, вы можете предлагать клиентам услуги по дизайну и разработке веб-сайтов WordPress. Это может быть прибыльным бизнесом, если вы создаете высококачественные веб-сайты.

Разве это не сама суть Web3?
Создав модель, улучшение которой сильно зависит от сообщества, WordPress создал бизнес, который находится на самом краю web3. Помните, что в среде web3 все операции запускаются и выполняются сообществом, а не централизованным советом директоров. WordPress является пионером, который максимально моделирует сценарий Web3.

Более того, WordPress создает безграничные возможности для всех, кто готов создавать реальную ценность для реальных пользователей, независимо от географического положения, политических и экономических условий.
Вот как Learn Near Club способствует переходу WordPress на web3
Мы создали два плагина для WordPress, которые позволяют пользователям подключаться к экосистеме Near.

 	Login with NEAR
 	LNC Near Comments

Войти с помощью NEAR


Легко настраивайте вход с помощью функции NEAR на вашем сайте WordPress с помощью простого шорткода. Вот некоторые особенности, о которых следует помнить:

 	Поддерживает популярные кошельки Near, такие как «Near Wallet», «My Near Wallet», «Here Wallet», «Meteor Wallet», «Sender».
 	Простая регистрация и вход: если у пользователя есть Near Wallet, он уже может использовать все функции вашего сайта и идентифицируется как пользователь WP.
 	Если ваше приложение WordPress использует смарт-контракт NEAR, плагин позволяет пользователям создать для него функциональный ключ с ограниченным доступом. Кроме того, пользователи могут совершать вызовы для изменения/просмотра методов других смарт-контрактов.
 	Плагин также легко настраивается.

Если вы хотите создать плагин со смарт-контрактом и вызывать его из авторизованных пользователей, вы можете просто сделать это следующим образом:

view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Посмотрите демо плагина

Загрузите плагин
LNC Near Comments


Интегрируйте и настройте плагин LNC Near Comments для своего сайта WordPress, используя простой шорткод [lnc_near_comments]. Вот некоторые особенности, о которых следует помнить:

 	Поддерживает популярные кошельки Near, такие как «Near Wallet», «My Near Wallet», «Here Wallet», «Meteor Wallet» и «Sender».
 	Предоставляет уникальную капчу для раздела комментариев и публикует комментарии пользователей после небольшой транзакции подсказки в смарт-контракт v1.ncaptcha.near
 	Уникальная платежная система позволяет получать часть оплаты за каждую разгадку капчи вашими пользователями. Вы можете настроить доход на вашей стороне.
 	Протестировано и предназначено для работы с последней версией WordPress. Перед использованием плагина убедитесь, что ваш WordPress обновлен.
 	Плагин LNC Near Comments требует, чтобы плагин Near Login функционировал должным образом. Обратитесь к документации плагина для получения информации о необходимых зависимостях и инструкциях по установке.

Чтобы использовать плагин со смарт-контрактом и разрешить взаимодействие зарегистрированных пользователей, используйте следующие методы:

View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Посмотрите демо плагина

Загрузите плагин
Заключение
Пересечение технологий web2 и web3 открывает уникальные и захватывающие возможности для цифрового мира. Традиционные платформы, такие как WordPress, продемонстрировали свою адаптивность и актуальность в этом меняющемся мире. Интегрируя функции web3, такие как децентрализованные системы доменных имен, децентрализованные системы хранения и API-интерфейсы криптоплатежей, WordPress воплощает гибридную модель, позиционируя себя в авангарде революции web3.

Принцип WordPress с открытым исходным кодом, основанный на принципах сообщества, тесно связан с принципами web3. Его широкое распространение, простота использования и адаптируемость делают его идеальным трамплином для перехода к более децентрализованному Интернету. Поддерживая и поощряя вклад сообщества, WordPress создает среду, подобную web3, в контексте web2.

Если вы готовы участвовать в подключении NEAR к WordPress, присоединяйтесь к этой группе в Telegram




	

	
	
		
			
				Что из перечисленного ниже не является способом, которым пользователи могут внести свой вклад в WordPress?
			
		

		
					

		
			
			
			
			сообщение об ошибках и предложение новых функций
		
			
			помощь в переводе
		
			
			написание кода и устранение багов
		
			
			оплата премиум-функций
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Разработка смарт-контрактов на Near с использованием Rust, часть 3

Это третья часть из серии статей о создании приложения для чата с помощью Rust на блокчейне Near. Предыдущие посты из этой серии вы можете найти здесь и здесь.

В этом посте мы сосредоточимся на оффчейн-частях кода. Мы обсудим необходимость «индексаторов» и рассмотрим некоторые части реализации индексатора в этом примере. Вы можете найти полный репозиторий со всем кодом, который мы сегодня обсудим, на моем GitHub.
Индексаторы, что это и зачем они нужны
В пространстве блокчейна индексатор — это сервис, который получает необработанные данные из источника (обычно это совмещенный экземпляр полного узла для этого блокчейна) и преобразует их в формат, более полезный для конкретного приложения. Например, в случае нашего приложения для чата индексатор потребляет поток блоков Near и создает поток событий (например, полученные сообщения и запросы на контакт).

Индексаторы важны, потому что базы данных, используемые для работы с самой цепочкой блоков, как правило, не оптимизированы для выполнения тех видов запросов, которые нужны приложениям. Например, получение баланса пользователя для токена ERC-20 в Ethereum обычно выполняется путем запуска запроса через EVM, потому что это единственный способ получить информацию из типичного узла Ethereum. Это чрезвычайно дорогая операция по сравнению с поиском записи в традиционной реляционной базе данных. Таким образом, простой оптимизацией любого приложения, которому требуется быстрый доступ к балансам ERC-20, будет запуск индексатора необработанных данных Ethereum, который заполняет традиционную базу данных данными, которые ему нужны. Затем приложение будет использовать эту базу данных в качестве источника для данных, а не напрямую узел Ethereum. Вот как работает обозреватель блоков Etherscan: Etherscan запускает индексатор для заполнения базы данных, которая затем используется для заполнения полей на веб-страницах, которые обслуживает Etherscan.

Индексаторы важны не только для Ethereum, любое высокопроизводительное децентрализованное приложение на любом блокчейне должно включать индексатор где-то в своей архитектуре. Пример приложения для чата, которое мы обсуждали на Near, не является исключением, поэтому давайте углубимся в то, как реализован индексатор.
Получение необработанных данных
Индексаторы только обрабатывают необработанные данные блокчейна в формате, который может использовать соответствующее приложение; они не генерируют данные в первую очередь. Поэтому первый вопрос, на который нам нужно ответить при создании индексатора: откуда берутся данные блокчейна?

Near предоставляет несколько различных источников данных, как описано ниже.
Запуск Nearcore узла
Лучшим источником данных (с точки зрения децентрализации и безопасности) для любого блокчейна является одноранговая сеть самого блокчейна. Чтобы получить доступ к этому источнику данных, вы должны запустить узел, который понимает протокол блокчейна. В случае Near реализация узла называется Nearcore. Его исходный код открыт на GitHub. Доступна документация о том, как запустить собственный узел Nearcore. Основным барьером для входа здесь является объем необходимого для этого дискового пространства; рекомендуется иметь 1 ТБ выделенного хранилища для вашего узла, и для его синхронизации с цепочкой требуется некоторое время из-за необходимости загрузки всех этих данных.

После того, как вы настроили узел NearCore, Near предоставляет удобную структуру индексатора в Rust, которую можно использовать для создания индексаторов с NearCore в качестве источника данных. Для реального проекта это был бы лучший способ создать индексатор. Однако наш пример — всего лишь демонстрация, поэтому мы не хотим тратить часы на загрузку данных цепочки на выделенный сервер объемом 1 ТБ. К счастью, есть и другие варианты.
NEAR данные
Чтобы облегчить разработчикам запуск своих проектов, Near создали фреймворк данных в качестве альтернативного источника данных для использования индексаторами. Фреймворк данных построен поверх упомянутой выше структуры индексатора и использует в качестве источника данных непосредственно узел. Индексатор, заполняющий фреймворк данных, тривиален в том смысле, что он не обрабатывает данные для конкретного приложения, а просто передает данные для хранения в хранилище AWS S3. Однако это позволяет разработчикам получать доступ к этим данным, используя свою собственную учетную запись AWS, а затем создавать свои собственные (нетривиальные) индексаторы, используя это хранилище S3 в качестве источника данных.

Преимущество этого для разработчиков заключается в том, что этот метод работает намного быстрее. Недостатком является то, что данные поступают из централизованного источника и, следовательно, их легче повредить, чем при прямом использовании одноранговой сети.

Чтобы получить доступ к фреймворку данных, вам необходимо заплатить за ресурсы AWS, которые вы используете для доставки этих данных. Для примера с приложением для чата я не хотел заставлять людей регистрироваться в AWS и тратить деньги на запуск индексатора. Поэтому я выбрал окончательный вариант источника данных.
Публичные RPC-узлы
Последний способ получить доступ к данным блокчейна, если вы не используете свой собственный узел или не имеете доступа к чьему-то предварительно созданному хранилищу данных, — это использовать чужие узлы. Узлы RPC — это узлы в сети блокчейн, предназначенные для обслуживания запросов пользователей. У каждого блокчейна есть поставщики узлов RPC (некоторые бесплатные, некоторые платные). Список поставщиков RPC для Near можно найти здесь.

Это наименее эффективный способ доступа к данным блокчейна, поскольку для получения данных, которые обычно используют индексаторы, требуется несколько запросов RPC. Каждый запрос RPC влечет за собой сетевую задержку, из-за чего индексатор медленно реагирует на события, происходящие в цепочке. Единственным преимуществом этого подхода является то, что можно бесплатно установить демо-версию, если для цепочки есть бесплатный поставщик RPC (как в случае с Near). Следовательно, это источник данных, который использует индексатор в нашем примере.

При всем при этом индексатору все равно, откуда берутся его данные. Поэтому, несмотря на то, что в нашем примере используется наихудший источник данных, стоит изучить его реализацию. Потому что концепции, которые использует этот индексатор, такие же, как и в индексаторе, созданном с использованием базы данных Near или индексаторов на основе узлов.
Реализация индексатора
Наш индексатор построен в виде приложения tokio на Rust. Tokio — это среда Rust для написания высокопроизводительных приложений, в которых операции ввода-вывода являются основным узким местом. Наш индексатор является таким приложением, потому что фактические вычисления, которые он выполняет, выполняются чрезвычайно быстро по сравнению со временем, которое требуется для запроса данных от узлов RPC. Основные особенности tokio заключаются в том, что он использует неблокирующие асинхронные пимитивы и имеет встроенную многопоточность, позволяющую выполнять параллельное выполнение. Это в дополнение к тому, что он находится в Rust, поэтому он, естественно, имеет гарантии безопасности параллелизма и безопасности памяти, которые предоставляет Rust.

Если tokio — это сцена, на которой установлено наше приложение, то далее следуют актеры в пьесе (это приложение следует актерской модели, но я предпочитаю делать это непосредственно в tokio, а не с помощью библиотеки, такой как actix, потому что я думаю, что каналы tokio обеспечивают более строгую типизацию, чем общие сообщения, используемые в большинстве фреймворков акторов).

У индексатора есть четыре основные роли: менеджер, загрузчик блоков, загрузчик чанков и обработчик квитанций.
Менеджер
Менеджер контролирует весь индексатор. Он отвечает за делегирование работы другим процессам и указание им завершить работу, когда программа закрывается (например, в случае возникновения ошибки). Например, менеджер управляет балансировкой нагрузки загрузчиков чанков, циклически переключая их при назначении чанка для загрузки.
Загрузчик блоков
Как следует из названия, целью процесса загрузки блоков является загрузка блоков. Он периодически опрашивает Near RPC, чтобы проверить, есть ли новые блоки, и если есть, то загружает их и отправляет менеджеру. Если бы мы не использовали RPC в качестве источника данных, этот процесс был бы заменен подключением к ближайшему узлу или фреймворку данных.
Загрузчик чанков
На Near блоки не содержат данных о транзакциях. Блоки дают информацию только о том, какие новые фрагменты доступны. Причина этого в шардинге NEAR (подробнее об этом можно прочитать здесь). Поэтому нам нужны отдельные процессы для загрузки данных чанка для каждого блока. Загрузчики чанков выполняют эту роль. Наш индексатор имеет несколько экземпляров загрузчика фрагментов, что позволяет загружать фрагменты параллельно.

Если бы мы не использовали RPC в качестве источника данных, то в зависимости от того, как данные которые мы использовали изучаются, эти процессы могли бы не существовать (например, инфраструктура near, включает все блоки данных и фрагменты в одно сообщение). Но в нашем случае, когда мы используем RPC, эти процессы необходимы.
Обработчик квитанций
Чанки содержат «квитанции», которые создаются при обработке транзакции. Когда менеджер получает новый фрагмент от загрузчика, он отправляет все квитанции в процесс обработчика квитанций (у нас может быть несколько экземпляров обработчиков квитанций для параллельной обработки квитанций, точно так же, как у нас есть несколько загрузчиков чанков). Этот процесс отфильтровывает квитанции до тех, которые нам интересны, затем загружает результат выполнения для квитанций и, наконец, обрабатывает события из этих результатов. В случае с этим примером мы просто записываем события в файл (для демонстрации в реальном времени вы можете просмотреть файл с чем-то вроде команды tail -f Unix, чтобы увидеть, как приходят события), но вы можете себе представить, что производственная реализация могла бы пересылать эти события в виде push-уведомлений в мобильную версию приложения.
Примечания
Вы можете заметить в коде индексатора, что существует некоторая сложность в отправке фрагментов/квитанций с хэшем блока после блока, который включает эти фрагменты. Это причуда Near RPC, когда он хочет знать, что вы знаете о более поздних блоках для обслуживания результата выполнения. Опять же, это будет обрабатываться намного более плавно, если использовать лучший источник данных.

Мы преднамеренно не вызываем паники ни в одной из функций актора. Когда они сталкиваются с ошибкой, они регистрируют ее и отправляют сообщение о завершении работы менеджеру (и менеджер рассылает его всем остальным участникам). Это важно, потому что паника в многопоточном приложении может привести к неожиданному поведению (в общем, tokio неплохо справляется с изящным завершением работы всего приложения, но все же лучше защищаться от него).
Заключение
В этом посте мы обсудили, почему индексаторы важны для реальных децентрализованных приложений, и рассмотрели некоторые детали примера индексатора, реализованного для децентрализованного приложения чата. Как и в предыдущем посте, в коде индексатора есть упражнения, включенные в комментарии с тегом EXERCISE. Я рекомендую вам попробовать эти упражнения, если вы хотите получить практический опыт работы с кодовой базой.
О серии гайдов
Это последний пост в этой серии. В части 1 мы рассмотрели общие принципы разработки смарт-контрактов и то, как они применяются к примеру контракта для децентрализованного приложения для чата. Во второй части мы подробно рассмотрели, как использовать Near-SDK для написания смарт-контрактов для Near в Rust. Наконец, в этом посте обсуждалось, как индексаторы необходимы для интеграции данных блокчейна с компонентами вне цепочки нашего приложения.

Последний фрагмент кода, который я не рассмотрел, — это интеграционное тестирование. Интеграционное тестирование использует библиотеку для локального моделирования блокчейна и использует тот же асинхронный стиль Rust, что и индексатор. Несмотря на то, что интеграционные тесты не особенно броские или интересные, они важны для обеспечения правильной работы вашего контракта. Я рекомендую вам ознакомиться с интеграционными тестами для контракта с мессенджером и попробовать там выполнить упражнение, чтобы получить некоторый практический опыт и в этой области.

Если вам понравилась эта серия сообщений в блоге, свяжитесь с нами через Type-Driven Consulting. Мы рады предоставить услуги по разработке программного обеспечения для dapps, а также учебные материалы для ваших собственных инженеров.

 

### Développement de Contrats Intelligents sur Near en Utilisant Rust - Partie 1

Le 16 février 2023, j'ai animé un atelier à l'Université de Waterloo sur le développement de contrats intelligents sur Near en utilisant Rust. J'ai apprécié de le mettre en place et j'ai pensé qu'il serait utile de présenter le contenu ici également, sous forme d'une série d’articles de blog. Dans ce premier article, je donnerai une analogie pour connecter le développement de la blockchain à un modèle utilisé dans les applications web normales. Présenter l'exemple de contrat intelligent que nous utiliserons tout au long de cette série et discuter de quelques principes généraux du développement de contrats intelligents qui sont uniques à la blockchain par rapport à d'autres domaines de la programmation.
Un modèle mental pour créer une application distribuée (dapp)
Le but de cette section est de faire une analogie entre le développement sur une blockchain (les applications basées sur la technologie de la blockchain sont souvent appelées "dapps" dans l'espace) et une technologie plus courante pour les applications web que vous avez peut-être déjà rencontrée. Cette analogie peut être utile pour réfléchir à la manière dont les utilisateurs interagissent avec les contrats intelligents.

L'idée est que les dapps sont très similaires aux applications web basées sur une "architecture serverless". Le terme "serverless" est un peu trompeur, car bien sûr, des serveurs sont toujours impliqués, mais la raison de ce nom est que le matériel sous-jacent (c'est-à-dire le serveur) exécutant le code est abstrait pour le développeur. Cela présente des avantages par rapport à d'autres infrastructures d'informatique dans le cloud en termes de coût et de scalabilité, attendu que vous ne payez que pour les ressources que vous utilisez exactement, contrairement à une VM qui peut rester inactive si le trafic est faible ou devenir non responsive s'il y a trop de trafic. Chaque fois qu'un utilisateur interagit avec l'application web, une nouvelle instance de la "fonction sans serveur" est invoquée sur le backend pour répondre à la demande de l'utilisateur sans que le développeur ait à se soucier précisément du matériel sur lequel cette fonction est exécutée.

Les dapps abstraient le matériel de manière similaire. Un contrat intelligent est déployé sur la blockchain et exécuté sur les nœuds (serveurs) qui forment le réseau pair-à-pair de cette blockchain. Lorsqu'un utilisateur interagit avec la dapp, il appelle la blockchain (une transaction) pour exécuter le contrat intelligent. Chaque transaction crée une nouvelle instance du contrat intelligent (dans le sens où il n'y a pas d'état en mémoire qui persiste entre les transactions), tout comme avec les fonctions sans serveur.

L’image ci-dessous est directement tirée du site Web d'Amazon Web Services (AWS) pour Lambda (leur version d'une offre de calcul sans serveur).



Il est facile de modifier cette image pour voir comment le flux de travail dans une dapp est similaire. 

Une autre similitude entre le calcul sans serveur et les contrats intelligents est le fait que chaque transaction a un coût. Dans le cas d'AWS, le compte AWS du développeur est facturé pour les ressources consommées, tandis que dans le cas de la blockchain, celui qui a signé la transaction est facturé pour son exécution.

Avec cette analogie comme point de référence, discutons de l'exemple de développement de dapp que nous utiliserons tout au long de cette série.
Notre exemple : une application de chat basée sur la blockchain

L'exemple que nous utiliserons tout au long de cette série est une application de chat basée sur la blockchain. Ce n'est pas un exemple réel dans le sens où il n'y a pas de bonnes raisons commerciales d'utiliser une blockchain publique pour le chat (à mon avis). Le fait que tous les messages soient complètement publics et inclus de manière irréversible dans un enregistrement permanent est un inconvénient, pas une fonctionnalité. Cependant, la raison de choisir cet exemple est qu'il illustre divers concepts importants dans le développement de dapp tout en étant logiquement facile à suivre pour quiconque a utilisé quelque chose comme Facebook Messenger, Telegram ou Signal.

Le code de cet exemple est disponible sur mon GitHub. Le README de ce référentiel donne des instructions pour configurer un environnement de développement pour interagir avec le code et une idée de base de la façon d'utiliser le contrat. Cette série de publications va nous faire plonger beaucoup plus profondément dans le code et dans son fonctionnement.

Pour ancrer la discussion des principes du développement de smart contract, voici un aperçu de la manière dont fonctionne le contrat de chat.

 	Chaque individu qui souhaite participer au réseau de chat déploie sa propre version du smart contract.
 	Chaque instance du contrat maintient une liste de comptes qu'elle connaît (contacts, demandes de contact en attente, etc.). Il stocke également les messages qu'il a reçus (et certaines métadonnées sur ces messages).
 	Pour envoyer un message à quelqu'un d'autre, vous devez d'abord l'avoir comme "contact". Cela fonctionne comme on pourrait s'y attendre : Alice envoie une demande de contact à Bob, si Bob l'accepte, alors Alice et Bob deviennent des contacts l'un de l'autre, sinon ils ne sont pas des contacts.
 	Chaque instance du contrat à un "propriétaire" qui est capable d'envoyer des messages et d'envoyer/accepter des demandes de contact.

Principes de développement de smart contracts
Il y a trois concepts connexes que je tiens à souligner et qui sont importants pour le développement de smart contracts, mais qui ne sont peut-être pas présents dans le développement de logiciels traditionnels. Ce sont :

 	un esprit de confrontation,
 	l’économie
 	protéger les invariants avant de passer des appels entre contrats.

Un esprit de confrontation,
La première chose importante à retenir lors du déploiement sur une blockchain publique est que n'importe qui dans le monde entier peut interagir avec votre code. Si votre contrat intelligent peut effectuer une action sensible (par exemple, lors de l'envoi de messages dans le contrat de chat, vous ne voudriez pas qu'une personne puisse se faire passer pour vous), vous devez explicitement vérifier l'autorisation afin que seuls les comptes autorisés puissent effectuer avec succès l'action (c'est pourquoi notre contrat de chat a la propriété "propriétaire"). Si vous avez une méthode qui prend une entrée, vous devez la valider avant de passer à la logique métier, car n'importe quel utilisateur aléatoire pourrait soumettre n'importe quelle entrée qu'il souhaite. En effet, l'idée d'un état d'esprit de confrontation va encore plus loin; non seulement un utilisateur pourrait soumettre une entrée incorrecte, mais il pourrait également soigneusement la façonner pour déclencher une vulnérabilité dans votre code. La seule façon d'empêcher cela est de ne pas avoir de telles vulnérabilités en premier lieu.

De même, la logique des contrats intelligents dépend souvent d'un protocole pour coordonner différents composants ensemble (par exemple, le protocole pour ajouter des contacts dans notre contrat de chat). Un utilisateur a-t-il un pouvoir d'agir dans ce protocole ? Que se passe-t-il s'il ne le suit pas correctement ? Ce sont des questions auxquelles vous devez répondre lors du développement d'un contrat intelligent, car les pirates informatiques tenteront d'exploiter votre contrat.

En résumé, vous devez toujours supposer que toute entrée externe est byzantine et vérifier explicitement le contraire avant de procéder. Vous devez pratiquer la prise de conscience des hypothèses que vous faites et toujours penser "comment pourrais-je briser cette hypothèse ?" chaque fois que vous réalisez que vous en faites une.
Économie
L'économie d'une application web typique est assez simple. Vous devez générer suffisamment de revenus pour couvrir le coût d'hébergement du serveur qui contient le code et les données utilisées par votre application. Les revenus peuvent provenir de différentes sources, mais les plus courantes sont les revenus publicitaires et les abonnements payants des utilisateurs.

Pour la blockchain, la situation est un peu plus compliquée, car chaque transaction doit être payée indépendamment. Les nouveaux produits de la blockchain cherchent à simplifier cette histoire. Par exemple, Aurora+ fournit quelque chose comme un "abonnement blockchain" qui permet un certain nombre de transactions gratuites. Mais jusqu'à ce que cela devienne la norme dans l'espace blockchain, il est toujours important de répondre à la question "qui paie pour cela?".

Souvent, c'est l'utilisateur qui paie pour chaque transaction car le paiement est lié au compte de signature (c'est-à-dire que le paiement est lié à l'identité / autorisation). Un modèle alternatif consiste à utiliser des "méta-transactions" (des transactions à l'intérieur des transactions) de sorte que le paiement soit effectué par le "signataire externe" tandis que l'autorisation est basée sur le "signataire interne". C'est ainsi que fonctionne Aurora+ par exemple. Malheureusement, comme ce n'est pas la façon par défaut dont les transactions blockchain fonctionnent, cela nécessite un travail supplémentaire de la part du développeur pour le réaliser.

Pour notre exemple d'application de chat, nous allons utiliser le moyen le plus facile et chaque utilisateur devra payer les coûts qu'il génère grâce à son utilisation. Après avoir pris cette décision, nous devons examiner les coûts possibles et nous assurer qu'ils sont couverts de manière appropriée. Par exemple, sur Near, le paiement de stockage est géré par le "storage staking". En gros, cela signifie que chaque compte a une partie de son solde verrouillée en fonction de la quantité de stockage qu'il utilise. Cela est pertinent dans notre contrat de chat car il stocke les messages reçus des autres utilisateurs. Par conséquent, nous devons nous assurer que ces autres utilisateurs couvrent le coût de stockage en attachant un dépôt suffisant avec leur message. De même, les demandes de contact créent une entrée dans le stockage, donc elles doivent également être accompagnées d'un dépôt. Si nous ne faisions pas respecter ces exigences de dépôt, les utilisateurs pourraient voler de l'argent les uns aux autres en envoyant de nombreux messages et en bloquant le solde total de la victime (remarquez comment cela est lié à la mentalité adversaire mentionnée précédemment).

En résumé, lors de la conception d'une dapp, il est toujours important de réfléchir aux coûts impliqués et à la façon dont ils sont payés, que cela implique l'ajout de vérifications pour les dépôts ou l'utilisation de méta-transactions.
Assurez-vous des invariants avant de faire des appels de contrat croisés
Ce dernier point est subtil. Dans une application typique, tout le code est lié dans le même binaire. Lorsque vous appelez une fonction dans une bibliothèque, cela ne déclenche généralement aucune communication, mais ajoute simplement une nouvelle trame sur la pile et exécute du code à partir d'une autre partie du binaire. Dans un environnement blockchain, les choses sont un peu différentes.

Faire un appel à un autre contrat ressemble davantage à l'appel d'un tout autre processus qu'à l'appel d'une bibliothèque. Encore une fois, nous devons adopter un état d'esprit adversaire et réaliser que nous n'avons aucune idée de ce que cet autre processus pourrait faire ; en effet, il pourrait essayer de faire quelque chose de délibérément malveillant. Un vecteur d'attaque courant est d'avoir l'autre processus rappeler notre contrat et l'exploiter car notre contrat ne s'attendait pas à ce qu'un nouvel appel arrive pendant qu'il attendait une réponse à l'appel qu'il avait initié. Cela s'appelle une "attaque de réentrance" et c'était la source de l'un des hacks les plus célèbres sur Ethereum, celui qui a entraîné la création d"Ethereum Classic" (Ethereum Classic a rejeté la "hard fork" qui était la réponse de la Fondation Ethereum au hack).

Sur Near, ce problème est encore plus prononcé en raison de la question de l'atomicité. Dans la machine virtuelle Ethereum (EVM), chaque transaction est "atomique" dans le sens où toutes les actions résultant de la transaction sont engagées dans l'état de la blockchain ou aucune d'entre elles ne l'est (la transaction entière est "reverted"). Cela signifie qu'une attaque de réentrance peut être contrecarrée en utilisant une inversion ; tout ce qui s'est passé sera annulé, gardant le contrat en sécurité. Ce modèle est même inclus dans l'exemple Mutex de la documentation officielle de Solidity. Cependant, dans le runtime de Near, l'exécution des contrats est indépendante les uns des autres ; ils ne sont pas atomiques. Donc, si une transaction cause le contrat A à appeler le contrat B, et que B rencontre une erreur, alors les changements d'état qui se sont produits dans A resteront.

Cela a été beaucoup d'histoire et de théorie, mais quelle est la leçon pratique à retenir ? Le point est que vous devez vous assurer que votre contrat est dans un "bon état" lorsque vous appelez un autre contrat. C'est-à-dire que si votre logique de contrat repose sur des invariants, ils doivent être corrects au moment de l'appel. À titre d'exemple simple, supposons que nous avons un contrat avec une fonction de transfert. L'invariant à maintenir est que les jetons ne sont pas créés ou détruits lors d'un transfert. Si, pour une raison quelconque, un appel à un autre contrat était nécessaire pendant le transfert, il serait incorrect de débiter un compte et ensuite de faire l'appel sans créditer l'autre en premier. C'est parce que l'invariant sur les jetons qui ne sont pas détruits serait rompu lorsque l'appel externe serait exploitable. Un exemple dans ce sens est également inclus dans la documentation de Near.
Résumé
En résumé, nous introduisons une nouvelle série d'articles donnant une introduction au développement de smart contracts sur Near en utilisant Rust. Nous avons discuté de l'exemple de contrat de chat que nous utiliserons tout au long de la série, ainsi que de quelques principes généraux à garder à l'esprit lors du développement d'applications basées sur la blockchain. Dans le prochain article, nous plongerons plus en détail dans le code pour discuter des détails techniques de la mise en œuvre du contrat. Cela servira d'exemple pour le SDK Rust de Near, illustrant des concepts qui s'appliqueront à tous les types de contrats du monde réel que vous souhaiteriez écrire.

Si vous appréciez cette série d'articles de blog, veuillez nous contacter chez Type-Driven consulting. Nous sommes heureux de fournir des services de développement de logiciels pour les dapps, ainsi que des matériaux de formation pour vos propres ingénieurs.

 

### nComments Beta test

Follow @LearnNEAR and @NameSkyApp on Twitter

Beta test sprint starts: May 31, 9 am ET
Beta Test sprint ends: June  4, 9 am ET
Requirements:

 	Read this guide about NameSky 
 	Mint your first NS NFT if you have not done it beofre
 	Go to comments section at the Guide
 	Write a meaningful comment about your experience with NameSky (you are more than welcome to shill your NS NFT there)
 	Reply to someone's else comment
 	Take a screenshot

 	Come later and check if there is a notification (you should get on if somebody replies to your comment)

 	Tweet your screenshot and  "At LNC we use web3 moderation to vet spammers. Happy to help to improve it via @LearnNEAR Beta test!"
 	Submit feedback form

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to ask at LNC Telegram Beta test topic

### A Beginner's Guide to NameSky: Buy, Sell, and Manage Securely NEAR Accounts as NFTs

NameSky is a user-friendly platform that enables trading of NEAR accounts as NFTs on the NEAR blockchain. With its smart contracts audited by @pessimistic_io, NameSky ensures a secure experience for users. You can find the audit report here and explore the NameSky marketplace to see accounts minted as NFTs.

This guide will help you navigate the NameSky platform, covering the process of turning a NEAR account into a NameSky NFT, checking the NFT on your NEAR wallet page, listing your NFT on the marketplace, and regaining control of a NEAR account by burning the NameSky NFT.
Step 1: Turn a NEAR account into a NameSky NFT
To turn your NEAR account into a NameSky NFT, follow these steps:

 	Visit the NameSky website and click on "Mint” on our website.
 	Connect your NEAR wallet to the NameSky platform.
 	Choose the NEAR account you want to turn into a NameSky NFT.
 	Upon minting, a lock contract will be deployed to the attached NEAR account, and all access keys will be removed. This means that only the owner of the NFT (you) can access the NEAR account.




	

	
	
		
			
				True or False: NameSky's smart contracts have been audited.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








     
Step 2: Check the NFT on your NEAR wallet page
To view your newly minted NameSky NFT:

 	Log in to your NEAR wallet.
 	Navigate to the "Collectibles" tab.
 	You will see your NameSky NFT listed with the attached NEAR account.


Step 3: List your NFT on the NameSky marketplace
To list your NameSky NFT for sale:

 	Go to a NFT detail page.
 	Click on "Sell".
 	Set your desired price.
 	Confirm your listing, and your NFT will be available for others to purchase.

  
Step 4: Take back a NEAR account by burning the NameSky NFT
If you want to regain control of your NEAR account:

 	Visit your NameSky profile page.
 	Locate the NameSky NFT you want to burn.
 	Click on the "Take back the account." from the dropdown
 	A new recovery phrase will be generated locally on your device, granting you access to the NEAR account.
 	The NameSky NFT will be burned, and you'll regain full control of the attached NEAR account with the recovery phrase from step 4 on https://wallet.near.org/recover-account

      

NameSky provides a secure and easy way to buy and sell NEAR accounts as NFTs. By following this guide, you'll be able to navigate the platform and manage your NEAR accounts and NFTs with confidence. Whether you're looking to buy a unique NEAR account or sell your own, NameSky offers a convenient and secure solution for your needs. Happy (L)Earning!

If you're still unsure about how NameSky works, you can try it out for yourself on the testnet app here: https://testnet.namesky.app




	

	
	
		
			
				True or False: Upon minting a NameSky NFT, all access keys will be removed from the attached NEAR account.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!

### Meta Pool, Module 4 - Participer à la gouvernance de Meta Pool

Gouvernance de Meta Pool
La gouvernance est le processus par lequel Meta Pool cherche à rendre le projet à la communauté. Ainsi, les détenteurs de jetons $META auront la possibilité de gérer le protocole on-chain grâce à une DAO.

La mise en place d'une gouvernance on-chain décentralisée est en cours de développement sur l'ensemble de l'écosystème Web 3. Ce module explique également comment Meta Pool gère cette situation.
DAO Meta Pool
Meta Pool va introduire des jetons $META pour la gouvernance de la DAO. L'objectif est de distribuer les jetons $META aux constructeurs de protocoles et aux contributeurs de projets de manière entièrement transparente.

Il convient de noter que, avant que la plateforme de vote de gouvernance on-chain ne soit prête pour les détenteurs de jetons $META, les contributeurs principaux du protocole prendront des décisions critiques en fonction de la vision du projet et de l'avis informel de la communauté sur Discord.

Ceci est intentionnel, car nous pensons qu'il est important de maintenir la gouvernance agile dans les premiers jours du protocole.

Les principaux objectifs de l'introduction du jeton de gouvernance sont les suivants : Inciter à la liquidité. Pour amorcer la liquidité initiale et accélérer la croissance de la plateforme Meta Pool.

Former une DAO. Le jeton $META représente la propriété de la DAO de Meta Pool. La DAO sera responsable de la mise à jour des paramètres du programme, de la feuille de route des produits et d'autres décisions stratégiques. Capitaliser le trésor. Pour permettre le financement de partenariats stratégiques ou la création de fonds de réserve.
Tokenomique $META
Offre maximale : 1 000 000 000 $META

 	Fondateurs : 30 %

Pour le travail de création, de lancement, de promotion et de maintenance du protocole. Les jetons des fondateurs ont une période de blocage d'un an suivie d'une libération linéaire de deux ans. (3 ans au total)

 	Équipe et conseillers : 2,6 %

Afin de créer un produit de classe mondiale, nous avons besoin des meilleurs talents de l'écosystème NEAR travaillant et collaborant sur le protocole. Ils s'engageront à long terme dans le protocole. Les jetons des conseillers ont une période de blocage de 2 ans suivie d'une libération linéaire d'un an. (3 ans au total)

 	Investisseurs : 10 %

Le partenariat avec des investisseurs et des institutions de premier plan sera essentiel pour notre portée mondiale et pour une meilleure compréhension des conditions macro des marchés cryptographiques. Nous savons ce que nous ne savons pas, c'est pourquoi les conseillers seniors et l'accès à leur réseau seront essentiels pour notre croissance. Les jetons des investisseurs ont une période de blocage d'un et deux ans suivis d'une libération linéaire d'un an. (2 et 3 ans au total)

 	Répartition pour les tours de financement :

- 4 % pour le tour de pré-amorçage (Seed)

- 6 % pour le tour d'amorçage (A round)

 	Communauté et Trésorerie : 57,40 %.




	

	
	
		
			
				Le jeton $META reçoit des airdrop mensuels
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Gagnez du pouvoir de vote sur Meta Pool - Meta Vote
Meta Vote est une plateforme de vote communautaire pour :

 	Les levées de fonds de projets sur Meta Yield, et
 	Soutenir les validateurs avec les votes Meta Staking.

Il s'agit d'une plateforme conçue pour acquérir un pouvoir de vote afin de soutenir les projets sur Meta Yield et pour déléguer des tokens NEAR aux validateurs dans le vote Meta Staking.
Comment utiliser Meta Vote ?
Vous pouvez accéder directement à Meta Vote via son lien https://metavote.app/ ou :

 	Depuis Meta Yield en cliquant sur les projets pour lesquels vous souhaitez voter https://metayield.app/
 	Depuis le vote Meta Staking en cliquant sur le validateur pour lequel vous souhaitez voter https://vote.metapool.app/ ou en cliquant sur les liens vers Meta Vote sur la page pour obtenir un pouvoir de vote.

Connectez votre portefeuille sur Meta Vote

Sur le site Meta Vote : https://metavote.app/, connecter votre portefeuille NEAR afin d'avoir un accès complet à vos actifs. Bouton +Connect Wallet.
Meta Vote fonctionne en 3 étapes simples :

 	Verrouillez vos tokens $META
 	Obtenez un pouvoir de vote
 	Votez pour les projets sur Meta Yield ou votez en soutien aux validateurs.

Verrouillez vos tokens $META
Pour pouvoir voter pour des projets ou des validateurs, vous devez obtenir un pouvoir de vote et c'est très simple. La façon de l'obtenir est de verrouiller vos tokens $META.

Si vous n'avez pas déjà de tokens $META, vous devrez en obtenir ! Voir ci-dessous "Comment obtenir des tokens $META ?"

 	Cliquez sur le bouton "+ Add Voting Power” (Ajouter un pouvoir de vote).



 	Entrez le montant de tokens $META que vous souhaitez verrouiller.
 	Sélectionnez la période pendant laquelle vous souhaitez “unlock” (déverrouiller) vos tokens avec le curseur. C'est le temps de déverrouillage pour vos tokens $META.

La durée minimale de verrouillage de vos tokens $META est de 30 jours, et peut aller jusqu'à 300 jours. Plus vos tokens $META sont verrouillés longtemps, plus vous avez de pouvoir de vote pour chaque token $META verrouillé.



Après avoir sélectionné votre période de verrouillage, cliquez sur le bouton de verrouillage et approuvez la transaction via le portefeuille NEAR, puis vous êtes prêt à voter !

 	Utilisez le pouvoir de vote pour voter pour les projets désirés ou pour soutenir les validateurs.



 	Retournez sur https://metayield.app/ ou sur https://vote.metapool.app/, rafraîchissez la page et voyez le pouvoir de vote !
 	Meta Yield : Vous pouvez ensuite utiliser le bouton de vote maintenant sur n'importe quel projet et les soutenir avec vos tokens. De plus, vous n'êtes pas obligé de dépenser tous vos tokens sur un seul projet, vous pouvez soutenir plusieurs projets !



 	Meta Staking Vote : Vous pouvez désormais voter directement pour le validateur de votre choix. Cliquez simplement sur le bouton "vote" du validateur de votre choix 

 

ou sélectionnez le validateur que vous souhaitez soutenir, lisez toutes les informations le concernant et votez pour lui. Vous pouvez soutenir plusieurs validateurs, pas seulement un.



Formule d'acquisition de pouvoir de vote pour vos tokens $META :
MULTIPLICATEUR = 1 + (4 * (jours - MIN_LOCK_DAYS) / (MAX_LOCK_DAYS - MIN_LOCK_DAYS))

 	MIN_LOCK_DAYS = 30
 	MAX_LOCK_DAYS = 300

Exemple


Comment obtenir des jetons $META ?
Dans le coin supérieur droit de l'application Meta Vote, cliquez sur "Get More $META" (Obtenir plus de jetons $META)



Ce lien vous redirigera vers Ref Finance, pour échanger des jetons NEAR ou d'autres actifs natifs de NEAR contre des jetons $META.

 	https://app.ref.finance/#meta-pool.near|meta-token.near

Vous pouvez également obtenir des jetons $META sur toutes les plateformes DEFI de l'écosystème NEAR.
Stades de verrouillage
Période de verrouillage
Le stade de verrouillage est celui qui vous permet de voter sur des projets. Les jetons $META sont verrouillés et les utilisateurs peuvent voter et annuler leur vote pour des projets ou des validateurs à tout moment. Il n'y a pas de limite de temps pour cette étape. Le pouvoir de vote sera disponible tant que les jetons $META seront verrouillés.


Période de déverrouillage
Une fois la campagne de vote pour un projet terminée ou si l'utilisateur veut mettre fin au soutien d'un validateur, il peut commencer la période de déverrouillage. En appuyant sur le bouton "Start Unlock" (Démarrer le déverrouillage) dans la position de verrouillage souhaitée, le temps de déverrouillage commence à s'écouler, correspondant au temps défini par l'ajout des pouvoirs de vote.

Il convient de noter qu'un stade de déverrouillage ne peut être commencé que s'il y a suffisamment de pouvoir de vote disponible. S'il y a du pouvoir de vote en cours d'utilisation et qu'il n'est pas suffisant pour déverrouiller une position complète, il ne sera pas possible de démarrer la période de déverrouillage.



Important : la période de déverrouillage ne démarre pas automatiquement, elle doit être démarrée manuellement par l'utilisateur.
Retrait des jetons $META
Une fois la période de déverrouillage terminée, les jetons $META peuvent être retirés.

Important : le retrait des jetons $META doit être effectué manuellement par l'utilisateur.






	

	
	
		
			
				Il y a 3,5% de frais de verrouillage de vos jetons dans Meta Vote
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Staking Vote - Utilisez votre pouvoir de vote pour soutenir les meilleurs validateurs
Meta Staking Vote est une plateforme communautaire pour la sélection de validateurs à désigner par vote pour 15% des jetons NEAR misés dans Meta Pool.

Meta Pool donne le pouvoir de gouvernance aux détenteurs de $META car ce sont eux qui votent dans le Meta Staking Vote.
Comment utiliser Meta Staking Vote ?
Accédez directement à Meta Staking Vote via son lien https://vote.metapool.app/.
Connectez le portefeuille NEAR sur Meta Staking Vote
Sur le site de Meta Staking Vote : https://vote.metapool.app/, liez le portefeuille NEAR. Cliquez sur le bouton Connect Wallet, choisissez un portefeuille et connectez-vous.


Meta Staking Vote fonctionne en 4 étapes simples :
1. Verrouillez des jetons $META sur la plateforme Meta Vote.

2. Obtenez du pouvoir de vote.

3. Votez pour les validateurs à soutenir sur la plateforme Meta Staking Vote.

4. Consultez un tableau de bord des votes et des affectations de jetons NEAR.
Comment ça marche

 	Les utilisateurs de Meta Pool placent leurs jetons NEAR en jeu, recevant en retour des stNEAR.
 	Ces NEAR mis en jeu sont distribués aux nœuds de validation. Cela contribue à décentraliser et à sécuriser le protocole NEAR. Plus les utilisateurs placent de jetons dans Meta Pool, plus ils sont distribués parmi les nœuds de validation.
 	Les validateurs produisent des blocs et sont récompensés pour cela, ce qui augmente la valeur des stNEAR en jetons NEAR.
 	Sur l'ensemble des jetons NEAR mis en jeu, Meta Staking Vote délègue 15 % aux validateurs par le vote des détenteurs de $META (supporters).

Il s'agit d'un vote permanent et en fonction des résultats, Meta Staking Vote alloue 1 % du montant total mis en jeu dans Meta Pool environ tous les 4 epochs.


Les détenteurs de jetons $META
Le vote se compose de 2 étapes:

 	Choix du Validator : Allez sur https://vote.metapool.app/. La liste complète des validateurs suivis par Meta Staking Vote.



Pour plus d'informations, cliquez sur le nom des validateurs et vous serez redirigé vers la page du validateur, avec des informations détaillées.



Une fois que le validateur à soutenir et à voter a été choisi, votez. Sélectionnez-le pour voter sur la liste (bouton de vote), ou sur la page du validateur (bouton votez pour ce validateur).

 	Vote pour les validateurs : Connectez le portefeuille NEAR. Sélectionnez le validateur à voter sur la liste (bouton vote) ou sur la page du validateur (bouton votez pour ce validateur) et attribuez-lui le pouvoir de vote.

Ce lien explique comment obtenir le pouvoir de vote.

La campagne de vote pour les validateurs est en cours, donc les votes comptent pour chaque campagne tant qu'elle est en cours.

Votez pour autant de validateurs que vous le souhaitez, sans limite d'attribution de pouvoir de vote. Les votes peuvent être modifiés à tout moment.

C'est ainsi que fonctionne le vote pour les validateurs dans Meta Staking Vote, simplement, en toute sécurité et en récupérant 100 % des jetons $META.
Délégation
15 % de la valeur totale bloquée dans Meta Pool fournie par les utilisateurs sera déléguée par vote des détenteurs de jetons $META.

Si la valeur totale bloquée augmente, la quantité distribuée augmente également. Il est très important de promouvoir le pool de mise en jeu liquide Meta Pool pour les investisseurs, pour cela, nous avons besoin du soutien des validateurs et de la communauté.

La campagne de délégation est continue, et 1 % de la valeur totale bloquée dans Meta Pool est attribuée tous les 4 epochs.




	

	
	
		
			
				Une fois voté pour un validateur, vous devez attendre 60 epochs pour attribuer votre vote à un autre validateur.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plateforme – Données générales


 	Validateurs

Il s'agit du nombre de validateurs approuvés par Meta Pool pour être soumis au vote selon les critères de sélection des validateurs.

 	Progrès de l’epoch

Indique le temps restant de la validation/production de bloc de l’epoch.

Une epoch dure environ 13 heures. (Une epoch dure 43 200 blocs et un bloc dure approximativement 1,1 seconde).

 	NEAR mis en jeu @ Meta Pool

TVL (Total Value Locked) à déléguer aux validateurs. 85% par performance et 15% par votes dans Meta Staking Vote.

Ce montant correspond aux jetons NEAR mis en jeu dans Meta Pool.

Le montant est disponible sur: https://staking.metapool.app/ - Total des jetons stNEAR multiplié par le prix stNEAR.

 	Near à attribuer par votes

15% du TVL à attribuer par votes. Le montant correspondant à chaque validateur individuellement peut être consulté dans "Attribué par votes".

 	Pouvoir de vote disponible

Pouvoir de vote disponible pour voter en faveur des validateurs. Si le pouvoir de vote n'est pas disponible, il peut être acheté sur: https://metavote.app/.

Important : Les jetons $META sont requis pour obtenir un pouvoir de vote. Obtenez des $META sur https://app.ref.finance/#meta-pool.near%7Cmeta-token.near

 	En cours d'utilisation / Total

Pouvoir de vote en cours d'utilisation et le total dont dispose l'utilisateur.

En cours d'utilisation peut être dû au fait que l'utilisateur a déjà voté pour des validateurs ou pour des projets de rendement de Meta Yield.
Détails du vote des validateurs


 	Nom

Le nom du validateur.

Pour en savoir plus sur un validateur particulier, il suffit de cliquer sur le nom et vous serez redirigé vers la page individuelle du validateur sélectionné.

 	APY

Le rendement annuel en pourcentage accordé par chaque validateur. Il dépend des performances et des frais des validateurs.

 	Votes

Nombre de votes attribués à chaque validateur et pourcentage correspondant du total. Le vote est continu et indique la tendance d'allocation en pourcentage à être déléguée.

 	Assigné par votes

Montant de jetons NEAR correspondant attribué au validateur selon les 15% attribué par vote. Important: seulement 1% sera attribué pour environ 4 epochs.

Ce montant est la tendance à atteindre pour l'attribution à chaque validateur en fonction des votes.

Le total de TVL à attribuer par vote est distribué environ toutes les 15 groupes de 4 epochs.

 	Total assigné

Ce montant correspond au montant à attribuer par performance (85%) et par vote (15%). C'est la tendance totale à atteindre par le validateur.

 	Stake du Meta Pool

Jetons NEAR actuellement délégués par Meta Pool à chaque validateur.




	

	
	
		
			
				Le pouvoir de vote peut être utilisé dans le vote Meta Staking ou dans les campagnes de vote Meta Yield.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Pourquoi WordPress peut ouvrir les portes du Web3

La transition vers le web3 semble inévitable. Plusieurs entreprises ont déjà commencé à expérimenter les différentes facettes du web3, telles que les NFT, le metaverse et la tokenisation. Cependant, comment pouvons-nous faciliter cette transition ? Chez Learn Near Club, l'avenir du web3 peut être atteint en incorporant des outils web3 dans des plates-formes web2 éprouvées et ouvertes. WordPress est l'un des meilleurs exemples de plate-forme web "éprouvée et ouverte". Dans ce blog, voyons comment WordPress favorise la croissance décentralisée au sein de son cadre centralisé.
Qu'est-ce que WordPress ?
WordPress est un système de gestion de contenu (CMS) open source populaire qui permet aux utilisateurs de créer et de gérer des sites web et des blogs. Depuis sa sortie en 2003, il est devenu l'une des plateformes de sites web les plus utilisées, alimentant environ 43% de tous les sites web sur Internet.

L'une des principales raisons de sa popularité est son interface conviviale qui ne nécessite aucune connaissance en codage. Cela en a fait un choix populaire pour ceux qui veulent créer et publier facilement du contenu. De plus, une grande communauté de développeurs a créé de nombreux plugins et thèmes, qui peuvent être aisément intégrés à la plateforme, offrant une fonctionnalité et un attrait esthétique supplémentaires.

WordPress est hautement personnalisable, ce qui signifie qu'il peut répondre à un large éventail de sites web, des petits blogs personnels aux grands sites d'entreprise. Il est également évolutif, ce qui lui permet de croître en tandem avec la croissance d'une entreprise ou d'un site web. La plateforme a la capacité d'ajouter de nouvelles fonctions et fonctionnalités selon les besoins, ce qui la rend hautement adaptable.

Un autre avantage de WordPress est sa structure conviviale pour le référencement. Les sites web créés avec WordPress disposent d'un outil de référencement intégré qui permet aux utilisateurs d'optimiser leur contenu et de s'assurer qu'il est convivial pour les moteurs de recherche. Cette fonctionnalité a fait de WordPress un choix préféré pour de nombreuses entreprises et personnes qui souhaitent que leurs sites web soient facilement trouvés par les moteurs de recherche.
La philosophie de WordPress
La philosophie de WordPress repose sur plusieurs principes fondamentaux qui guident son développement et sa communauté. Ces principes sont :

 	Fournir une plateforme conviviale et accessible à tous pour créer et publier du contenu en ligne. Cela signifie que le logiciel doit être facile à utiliser, facile à comprendre et ouvert gratuitement.
 	Étant open source, le logiciel est librement disponible pour être utilisé, modifié et distribué sans aucune restriction. Cela a contribué à créer une grande communauté de développeurs qui améliorent et construisent constamment sur la plateforme, ajoutant de nouvelles fonctionnalités et fonctionnalités.
 	Encourager les utilisateurs à travailler ensemble et à partager leurs connaissances, ce qui a conduit à la création d'une communauté dynamique d'utilisateurs, de développeurs et de contributeurs qui travaillent conjointement pour rendre la plateforme meilleure.
 	Fournir un outil qui peut être utilisé par n'importe qui, indépendamment de son expertise technique ou de ses capacités physiques. Cela signifie que le logiciel doit être conçu en tenant compte de l'accessibilité, le rendant simple à utiliser et à naviguer pour tous les utilisateurs.

WordPress est axé sur la création d'une plateforme ouverte, accessible et conviviale, avec un fort accent sur la communauté et la collaboration. Ces principes fondamentaux ont contribué à faire de WordPress l'un des systèmes de gestion de contenu les plus populaires au monde.




	

	
	
		
			
				Quelle est l'une des principales raisons de la popularité de WordPress en tant que système de gestion de contenu ?
			
		

		
					

		
			
			
			
			Le prix
		
			
			Son interface conviviale n'exige pas que les utilisateurs aient des connaissances en codage
		
			
			Sa compatibilité avec d'autres plateformes
		
			
			Son caractère propriétaire
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress et Web3
Jetons un coup d'œil à la relation existante entre WordPress et Web3. Bien que WordPress ne soit pas intrinsèquement une plate-forme Web3, il existe des moyens d'intégrer les technologies Web3 dans WordPress pour créer des sites Web plus décentralisés et sécurisés. Une telle façon est l'utilisation de systèmes de noms de domaine décentralisés (DNS), tels que Unstoppable Domains. Vous pouvez également utiliser des systèmes de stockage décentralisés, tels que IPFS. IPFS est un système de stockage pair-à-pair qui permet aux utilisateurs de stocker et de partager des fichiers de manière décentralisée et résistante à la censure. En intégrant IPFS dans un site Web WordPress, les utilisateurs peuvent créer une plateforme de partage de contenu plus sécurisée et décentralisée. Enfin, les créateurs de sites Web peuvent toujours intégrer des API de paiement cryptographiques pour accéder à des paiements décentralisés.
WordPress est la référence
Comme vous pouvez le constater, WordPress est une plate-forme Web2 flexible qui vous permet d'intégrer de manière transparente les technologies Web3. Il y a une raison pour laquelle le CMS est utilisé par 38% de tous les sites Web Internet pour créer et gérer différents types de sites tels que des blogs personnels, des boutiques en ligne et plus encore. Cette nature ouverte a également permis à WordPress de créer une communauté ouverte et dynamique de contributeurs. Ces contributeurs travaillent dur pour améliorer la plate-forme en développant de nouvelles fonctionnalités, en corrigeant les bugs et en maintenant le code principal. Tout le monde peut contribuer à WordPress, et il y a de nombreuses façons de le faire.




	

	
	
		
			
				Comment WordPress s'aligne-t-il sur les principes du web3 ?
			
		

		
					

		
			
			
			
			En étant une plate-forme centralisée avec un ensemble fixe de fonctionnalités
		
			
			En s'appuyant sur un seul développeur pour toutes les mises à jour
		
			
			En étant une plateforme fermée
		
			
			En soutenant et en encourageant les contributions de la communauté
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment les contributeurs aident WordPress

 	En signalant les bugs, en suggérant de nouvelles fonctionnalités et en donnant un retour d'information sur les fonctionnalités existantes, les utilisateurs aident les développeurs à identifier les problèmes et à apporter les améliorations nécessaires. Ce retour d'information est crucial pour la croissance et le succès continu de la plateforme.
 	WordPress est disponible dans de nombreuses langues, mais il y a toujours besoin de plus de traducteurs pour aider à rendre la plateforme accessible à encore plus de personnes. On n'a pas besoin d'être fluent dans plusieurs langues pour aider avec les traductions – même de petites contributions peuvent faire une grande différence.
 	Si vous avez des compétences en codage, vous pouvez contribuer à WordPress en écrivant du code, en corrigeant des bugs ou en développant de nouvelles fonctionnalités. WordPress est une plateforme open source et tout le monde peut accéder à son code et contribuer à son développement. Selon vos compétences et vos intérêts, vous pouvez contribuer au cœur de WordPress, aux plugins ou aux thèmes.
 	Vous pouvez également contribuer à WordPress en aidant à la documentation, à la conception ou à la gestion de la communauté. Ces domaines sont tout aussi importants que la programmation et il y a de nombreuses occasions de s'impliquer.
 	Vous pouvez soutenir la communauté WordPress en aidant d'autres utilisateurs sur les forums, en participant à des rencontres et en organisant des événements WordPress. En soutenant la communauté, vous créez un environnement accueillant et inclusif qui profite à tout le monde.

L'économie de WordPress
Selon une étude de WPEngine, l'économie mondiale de WordPress, qui comprend toutes les entreprises, développeurs et utilisateurs associés à WordPress, a été évaluée à environ 596,7 milliards de dollars en 2020.

Automattic, l'entreprise derrière WordPress.com possède 1 983 employés dans 96 pays parlant 123 langues différentes, et n'a ZÉRO bureau.

Gagner de l'argent avec WordPress est possible grâce à diverses méthodes. Voici quelques-unes des meilleures façons de monétiser votre site Web WordPress:

 	E-commerce: Utilisez un plugin comme WooCommerce pour transformer votre site Web WordPress en une boutique en ligne où vous pouvez vendre des produits physiques ou numériques, des services ou des rendez-vous.
 	Publicité: Affichez des publicités sur votre site Web et gagnez de l'argent grâce à des modèles de publicité pay-per-click (PPC) ou autres. Google AdSense est une option populaire pour afficher des annonces pertinentes sur votre site.
 	Marketing d'affiliation: Promouvoir des produits ou des services d'autres entreprises sur votre blog ou site Web en utilisant des liens d'affiliation uniques. Vous gagnez une commission pour chaque vente ou action effectuée via votre référence.
 	Contenu exclusif: Offrez un contenu premium ou exclusif à vos visiteurs moyennant des frais. Cela peut inclure des articles, des vidéos, des cours ou d'autres ressources précieuses.
 	Cours en ligne: Si vous avez des connaissances ou des compétences spécialisées, créez et vendez des cours en ligne via votre site Web WordPress. Cela vous permet de partager votre expertise et de monétiser vos connaissances.
 	Création de plugins : Si vous avez des compétences en codage, vous pouvez développer et vendre des plugins pour WordPress. De nombreux propriétaires de sites web sont prêts à payer pour des plugins qui améliorent les fonctionnalités de leurs sites.
 	Création de sites WordPress pour les clients : Si vous avez des compétences en développement web, vous pouvez offrir des services de conception et de développement de sites WordPress à des clients. Cela peut être une entreprise rentable si vous pouvez fournir des sites web de haute qualité.

N'est-ce pas l'éthos même de Web3 ?
En créant un modèle qui dépend fortement de sa communauté pour s'améliorer, WordPress a créé une entreprise qui se situe au bord de la Web3. Rappelez-vous que dans un environnement Web3, toutes les opérations sont gérées et exécutées par une communauté au lieu d'un conseil d'administration centralisé. WordPress pionnière ce modèle autant que possible dans un scénario Web2.

De plus, WordPress crée d'innombrables opportunités pour tous ceux qui sont prêts à créer une valeur réelle pour de vrais utilisateurs, indépendamment de leur emplacement géographique, de leurs conditions politiques et économiques.
Voici comment Learn Near Club contribue au voyage de WordPress vers Web3 :
Nous avons créé deux plugins pour WordPress, qui permettent aux utilisateurs de se connecter à l'écosystème Near.

 	Connexion avec NEAR
 	Commentaires Near LNC

Connexion avec NEAR


Facilitez la configuration et la personnalisation de la fonctionnalité de connexion avec NEAR sur votre site WordPress en utilisant un simple shortcode. Voici quelques fonctionnalités à garder à l'esprit :

 	Prise en charge des portefeuilles Near populaires tels que "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender".
 	Inscription et connexion faciles : si un utilisateur possède un portefeuille Near, il peut déjà utiliser toutes les fonctionnalités de votre site et est identifié en tant qu'utilisateur WP.
 	Si votre application WordPress utilise un contrat intelligent NEAR, le plugin permet aux utilisateurs de créer une clé d'accès limitée fonctionnelle pour celui-ci. De plus, les utilisateurs peuvent effectuer des appels pour changer / voir des méthodes vers d'autres contrats intelligents.
 	Le plugin permet également de personnaliser facilement l'interface utilisateur de connexion.
 	Si vous souhaitez créer un plugin avec un contrat intelligent et l'appeler à partir d'utilisateurs connectés, vous pouvez simplement le faire de cette manière :

view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Regardez la démo du plugin

Téléchargez le plugin
Commentaires LNC Near


Intégrez et personnalisez facilement le plugin LNC Near Comments sur votre site WordPress en utilisant le shortcode [lnc_near_comments]. Voici quelques fonctionnalités à garder à l'esprit :

 	Prend en charge les portefeuilles Near populaires tels que "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet" et "Sender"
 	Fournit un captcha unique pour la section des commentaires et publie les commentaires des utilisateurs après une petite transaction de pourboire vers le contrat intelligent v1.ncaptcha.near
 	Le système de paiement unique vous permet de recevoir une partie du paiement pour chaque captcha résolu par vos utilisateurs. Vous pouvez configurer les revenus de votre côté
 	Testé et conçu pour fonctionner avec la dernière version de WordPress. Assurez-vous que votre installation de WordPress est à jour avant d'utiliser le plugin
 	Le plugin LNC Near Comments nécessite le plugin Near Login pour fonctionner correctement. Veuillez vous référer à la documentation du plugin pour toute dépendance nécessaire et les instructions d'installation.

Pour utiliser le plugin avec un contrat intelligent et permettre aux utilisateurs connectés d'interagir, utilisez les méthodes suivantes :

View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Regardez la démo du plugin

Téléchargez le plugin
En conclusion
L'intersection des technologies web2 et web3 présente une frontière unique et passionnante pour le monde numérique. Des plateformes traditionnelles comme WordPress ont démontré leur adaptabilité et leur pertinence dans ce paysage en évolution. En intégrant des fonctionnalités web3 telles que des systèmes de noms de domaine décentralisés, des systèmes de stockage décentralisés et des API de paiement cryptographique, WordPress incarne un modèle hybride, se positionnant à l'avant-garde de la révolution web3.

L'éthos open-source et communautaire de WordPress est étroitement aligné sur les principes de web3. Son adoption généralisée, sa facilité d'utilisation et son adaptabilité en font un tremplin idéal pour la transition vers un internet plus décentralisé. En soutenant et encourageant les contributions de la communauté, WordPress favorise un environnement semblable à celui de web3 dans un contexte web2.

Si vous êtes prêt à participer à la connexion de NEAR à WordPress, rejoignez ce groupe Telegram.




	

	
	
		
			
				Lequel des éléments suivants n'est pas un moyen pour les utilisateurs de contribuer à WordPress ?
			
		

		
					

		
			
			
			
			Signaler des bugs et suggérer de nouvelles fonctionnalités
		
			
			Aide aux traductions
		
			
			Écrire du code ou corriger des bugs
		
			
			Payer pour des fonctionnalités premium
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### El Porqué WordPress Puede Abrir Las Puertas a la Web3

La transición a la web3 parece inevitable. Varias empresas ya han empezado a experimentar con las diversas facetas de web3, como los NFT, el metaverso y la tokenización. Sin embargo, ¿cómo suavizar esta transición? En Learn Near Club, el futuro de la web3 puede alcanzarse incorporando herramientas web3 a plataformas web2 probadas y abiertas. Uno de los mejores ejemplos de plataforma web "probada y abierta" es WordPress. En este artículo, vamos a ver cómo WordPress fomenta el crecimiento descentralizado dentro de su marco centralizado.
¿Qué es WordPress?
WordPress es un popular sistema de gestión de contenidos (Content Management System - CMS) de código abierto que permite a los usuarios crear y gestionar sitios web y blogs. Desde su lanzamiento en 2003, se ha convertido en una de las plataformas web más utilizadas, con un 43% de todos los sitios web de Internet.

Una de las principales razones de su popularidad es su interfaz fácil de usar, que no requiere conocimientos de programación. Esto la ha convertido en una opción popular para quienes desean crear y publicar contenidos fácilmente. Además, una gran comunidad de desarrolladores ha creado numerosas herramientas esenciales llamadas plugins y temas, que pueden integrarse fácilmente en la plataforma, proporcionando funcionalidad adicional y atractivo estético.

WordPress es altamente personalizable, lo que significa que puede adaptarse a una amplia gama de sitios web, desde pequeños blogs personales a grandes sitios corporativos. También es escalable, lo que le permite crecer a la par que el negocio o el sitio web. La plataforma tiene la capacidad de añadir nuevas características y funcionalidades según sea necesario, lo que la hace muy adaptable.

Otra ventaja de WordPress es su estructura SEO. Los sitios web creados con WordPress tienen una herramienta SEO integrada que permite a los usuarios optimizar su contenido y asegurarse de que es compatible con los motores de búsqueda. Esta característica ha convertido a WordPress en la opción preferida de muchas empresas y particulares que desean que sus sitios web sean encontrados fácilmente por los motores de búsqueda.
La Filosofía de WordPress
La filosofía de WordPress se basa en varios principios fundamentales que guían su desarrollo y su comunidad. Estos principios son:

 	Proporcionar una plataforma fácil de usar y accesible para que cualquiera pueda crear y publicar contenidos en línea. Esto significa que el software debe ser fácil de usar, fácil de entender y de libre acceso.
 	Al ser de código abierto, el software se puede utilizar, modificar y distribuir libremente y sin restricciones. Esto ha ayudado a crear una gran comunidad de desarrolladores que están constantemente mejorando y construyendo sobre la plataforma, añadiendo nuevas características y funcionalidades.
 	Animar a los usuarios a trabajar juntos y compartir conocimientos, lo que ha llevado a la creación de una vibrante comunidad de usuarios, desarrolladores y colaboradores que trabajan juntos para mejorar la plataforma.
 	Proporcionar una herramienta que pueda ser utilizada por cualquiera, independientemente de sus conocimientos técnicos o capacidades físicas. Esto significa que el software debe diseñarse teniendo en cuenta la accesibilidad, facilitando el uso y la navegación a todos los usuarios.

WordPress se centra en crear una plataforma abierta, accesible y fácil de usar, con un fuerte énfasis en la comunidad y la colaboración. Estos principios básicos han contribuido a hacer de WordPress uno de los sistemas de gestión de contenidos más populares del mundo.




	

	
	
		
			
				¿Cuál es una de las principales razones de la popularidad de WordPress como sistema de gestión de contenidos?
			
		

		
					

		
			
			
			
			Su costo
		
			
			Su interfaz fácil de usar, que no requiere conocimientos de programación
		
			
			Su compatibilidad con otras plataformas
		
			
			La naturaleza del propietario
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress y Web3
Veamos la relación existente entre WordPress y la web3. Aunque WordPress no es intrínsecamente una plataforma Web3, existen formas de integrar las tecnologías Web3 en WordPress para crear sitios web más descentralizados y seguros. Una de estas formas es mediante el uso de sistemas de nombres de dominio (DNS) descentralizados, como Unstoppable Domains. También puede utilizar sistemas de almacenamiento descentralizados, como IPFS. IPFS es un sistema de almacenamiento peer-to-peer que permite a los usuarios almacenar y compartir archivos de forma descentralizada y resistente a la censura. Al integrar IPFS en un sitio web WordPress, los usuarios pueden crear una plataforma más segura y descentralizada para compartir contenidos. Por último, los creadores de sitios web siempre pueden integrar API de pagos criptográficos para acceder a pagos descentralizados.
WordPress Es El Estándar De Oro
Como puede ver, WordPress es una plataforma web2 flexible que le permite integrar a la perfección tecnologías web3. Hay una razón por la que el CMS es utilizado por el 38% de todos los sitios web de Internet para la creación y gestión de diferentes tipos de sitios, tales como blogs personales, tiendas en línea, y mucho más. Esta naturaleza abierta también ha permitido a WordPress crear una comunidad abierta y vibrante de colaboradores. Estos colaboradores trabajan duro para mejorar la plataforma, desarrollando nuevas funciones, corrigiendo errores y manteniendo el código base. Cualquiera puede contribuir a WordPress, y hay muchas formas de hacerlo.




	

	
	
		
			
				¿Cómo se alinea WordPress con los principios de web3?
			
		

		
					

		
			
			
			
			Al ser una plataforma centralizada con un conjunto fijo de funciones
		
			
			Al depender de un único desarrollador para todas las actualizaciones
		
			
			Al ser una plataforma de código cerrado
		
			
			Apoyando y fomentando las contribuciones de la comunidad
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cómo ayudan los colaboradores a WordPress

 	Informando de errores, sugiriendo nuevas funciones y dando su opinión sobre las existentes, los usuarios ayudan a los desarrolladores a identificar los problemas y a realizar las mejoras necesarias. Estos comentarios son cruciales para el continuo crecimiento y éxito de la plataforma.
 	WordPress está disponible en muchos idiomas, pero siempre se necesitan más traductores para ayudar a que la plataforma sea accesible a más personas. No es necesario dominar varios idiomas para ayudar con las traducciones; incluso las pequeñas contribuciones pueden marcar una gran diferencia.
 	Si tienes conocimientos de programación, puedes contribuir a WordPress escribiendo código, corrigiendo errores o desarrollando nuevas funciones. WordPress es una plataforma de código abierto y cualquiera puede acceder a su código y contribuir a su desarrollo. Dependiendo de tus habilidades e intereses, puedes contribuir al núcleo de WordPress, a los plugins o a los temas.
 	También puedes contribuir a WordPress ayudando con la documentación, el diseño o la gestión de la comunidad. Estas áreas son tan importantes como la programación y existen muchas oportunidades para participar.
 	Puedes apoyar a la comunidad de WordPress ayudando a otros usuarios en los foros, asistiendo a reuniones y organizando eventos de WordPress. Al apoyar a la comunidad, creas un entorno acogedor e integrador que beneficia a todos los implicados.

Economía de WordPress
Según un estudio de WPEngine, la economía mundial de WordPress, que incluye a todas las empresas, desarrolladores y usuarios asociados a WordPress, estaba valorada en unos 596.700 millones de dólares en 2020.

Automattic, empresa distribuida globalmente detrás de WordPress.com con 1.983 Automatticians en 96 países que hablan 123 idiomas diferentes, tiene CERO oficinas.

Ganar dinero con WordPress es posible a través de varios métodos. Estas son algunas de las mejores formas de monetizar tu sitio web WordPress:

 	Comercio electrónico: Utiliza un plugin como WooCommerce para convertir tu web WordPress en una tienda online donde puedas vender productos físicos o digitales, servicios o citas.
 	Publicidad: Muestra anuncios en tu sitio web y gana dinero a través del pago por clic (PPC) u otros modelos publicitarios. Google AdSense es una opción popular para mostrar anuncios relevantes en su sitio.
 	Marketing de afiliación: Promociona productos o servicios de otras empresas en su blog o sitio web mediante enlaces de afiliación exclusivos. Tú ganas una comisión por cada venta o acción realizada a través de su referencia.
 	Contenido exclusivo: Ofrece contenido premium o exclusivo a tus visitantes a cambio de una comisión. Puedes incluir artículos, vídeos, cursos u otros recursos valiosos.
 	Cursos en línea: Si tienes conocimientos o habilidades especializadas, crea y vende cursos online a través de tu sitio web WordPress. Esto te permite compartir tu experiencia y monetizar tus conocimientos.
 	Creación de plugins: Si tienes conocimientos de programación, puedes desarrollar y vender plugins para WordPress. Muchos propietarios de sitios web están dispuestos a pagar por plugins que mejoren la funcionalidad de sus sitios web.
 	Creación de sitios WordPress para clientes: Si tienes conocimientos de desarrollo web, puedes ofrecer servicios de diseño y desarrollo de sitios web WordPress a clientes. Este puede ser un negocio rentable si puedes ofrecer sitios web de alta calidad.

¿No Es Este El Espíritu de la Web3?
Al crear un modelo que depende en gran medida de su comunidad para mejorar, WordPress ha creado un negocio que se encuentra en el mismo precipicio de la web3. Recuerda, en un entorno web3, todas las operaciones son dirigidas y ejecutadas por una comunidad en lugar de una junta directiva centralizada. WordPress es pionero en ese modelo en la medida de lo posible en un escenario web2.

Además, WordPress crea un sinfín de oportunidades para todo aquel que esté dispuesto a crear valor real para usuarios reales, independientemente de la ubicación geográfica y de las condiciones políticas y económicas.
Así Es Como Learn Near Club Contribuye Al Viaje De WordPress Hacia la Web3
Hemos creado dos plugins para WordPress que permiten a los usuarios conectarse con el ecosistema Near.

 	Iniciar sesión con NEAR
 	Comentarios sobre LNC Near 

Iniciar sesión con NEAR


Fácil de configurar y personalizar el inicio de sesión con la funcionalidad NEAR en tu sitio de WordPress mediante el uso de código corto simple. Aquí están algunas características a tener en cuenta:

 	Soporta monederos Near populares como - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet", "Sender"
 	Fácil registro e inicio de sesión: Si un usuario tiene una Near Wallet, ya puede utilizar toda la funcionalidad de su sitio y se identifica como usuario WP
 	Si tu aplicación WordPress utiliza el contrato inteligente NEAR, el plugin permite a los usuarios crear una clave funcional de acceso limitado para él. Además, los usuarios pueden hacer llamadas para cambiar/ver métodos a otros contratos inteligentes
 	El plugin también es fácil para personalizar la interfaz de usuario de inicio de sesión.

Si quieres crear un plugin con un contrato inteligente y llamarlo desde usuarios registrados, puedes hacerlo simplemente de esta manera:

view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Ver demostración del plugin.

Descargar el plugin.
Comentarios sobre LNC Near


Integra y personaliza el plugin LNC Near Comments para tu sitio WordPress utilizando el sencillo shortcode [lnc_near_comments]. Aquí hay algunas características a considerar:

 	Soporta monederos Near populares como - "Near Wallet", "My Near Wallet", "Here Wallet", "Meteor Wallet" y "Sender".
 	Proporciona un captcha único para la sección de comentarios y publica los comentarios de los usuarios después de una pequeña transacción de propina al contrato inteligente v1.ncaptcha.near
 	El sistema de pago único te permite recibir una parte del pago por cada captcha resuelto por tus usuarios. Puedes configurar los ingresos por tu cuenta
 	Probado y diseñado para funcionar con la última versión de WordPress. Asegúrate de que tu instalación de WordPress está actualizada antes de utilizar el plugin
 	El plugin LNC Near Comments requiere el plugin Near Login para funcionar correctamente. Consulta la documentación del plugin para conocer las dependencias necesarias y las instrucciones de instalación.

Para utilizar el plugin con un contrato inteligente y permitir que los usuarios conectados interactúen, utiliza los siguientes métodos:

View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Ver la demostración del plugin.

Descargar el plugin.
Para Terminar
La intersección de las tecnologías web2 y web3 presenta una frontera única y apasionante para el mundo digital. Plataformas tradicionales como WordPress han demostrado su adaptabilidad y relevancia en este panorama en evolución. Al integrar características de web3 como sistemas de nombres de dominio descentralizados, sistemas de almacenamiento descentralizados y API de pagos criptográficos, WordPress encarna un modelo híbrido, situándose a la vanguardia de la revolución de la web3.

El espíritu comunitario y de código abierto de WordPress se alinea estrechamente con los principios de la web3. Su amplia adopción, facilidad de uso y adaptabilidad lo convierten en un trampolín ideal para la transición hacia una Internet más descentralizada. Al apoyar y fomentar las contribuciones de la comunidad, WordPress fomenta un entorno similar a la web3 en un contexto web2.

Si estás dispuesto a participar en la conexión de NEAR con WordPress, únete a esta iniciativa en el Grupo de Telegram.




	

	
	
		
			
				¿Cuál de las siguientes no es una forma en que los usuarios pueden contribuir a WordPress?
			
		

		
					

		
			
			
			
			Informando de errores y sugiriendo nuevas funciones
		
			
			Ayudando con las traducciones
		
			
			Escribiendo código o corrigiendo errores
		
			
			Pagando por funciones premium
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 

### Aperçu du Portefeuille Meteor

Le portefeuille Meteor vise à atteindre plusieurs objectifs clés, tels que faciliter l'adoption massive du web3 et devenir le meilleur portefeuille de NEAR. Il cherche à favoriser une saine concurrence avec d'autres projets notables tels que MyNear, Sender, HERE et le portefeuille natif de NEAR.
INTRODUCTION
La technologie Blockchain présente un royaume d'opportunités illimitées, y compris l'autonomie financière. Cependant, il est indéniablement difficile pour les nouveaux arrivants de naviguer dans ce monde complexe.

Pourquoi est-ce difficile ? Principalement parce que la liberté, qui est la principale motivation de beaucoup d'entre nous, s'accompagne de responsabilités. Cette responsabilité englobe la gestion de vos actions, pertes, investissements, escroqueries potentielles, actifs et portefeuilles. Dans le Web décentralisé, la protection de votre crypto-monnaie ne dépend que de vous, de personne d'autre.

Cependant, assumer la responsabilité n'est pas la seule barrière à l'entrée dans le monde de la crypto-monnaie. La complexité de la compréhension de nombreuses applications décentralisées (Dapps), à la fois en termes d'interfaces et de fonctionnalités, est un autre facteur crucial à prendre en compte.

Le portefeuille Meteor vise à atteindre plusieurs objectifs clés, tels que faciliter l'adoption massive du web3 et devenir le meilleur portefeuille de NEAR. Il cherche à favoriser une saine concurrence avec d'autres projets notables tels que MyNear, Sender, HERE et le portefeuille natif de NEAR.

Nous avons la chance de faire partie d'un écosystème exceptionnel où chacun des projets susmentionnés possède ses propres atouts. Alors, qu'est-ce qui distingue Meteor ? Il peut être décrit comme un portefeuille tout-en-un.

Le terme "tout-en-un" fait référence à la vaste gamme de caractéristiques et de fonctionnalités que Meteor regroupe dans un portefeuille unique et convivial. Ces outils aident les nouveaux venus, qui peuvent avoir des connaissances limitées à naviguer sur Web3 et dans le paysage de la blockchain. Dans les paragraphes suivants, nous explorerons certaines de ces fonctionnalités et approfondirons les objectifs de Meteor Wallet en tant que projet Web3.
QU'EST-CE QUE LE PORTEFEUILLE METEOR ?


Meteor Wallet est un portefeuille complet et convivial conçu pour une gestion sécurisée et simple de votre crypto-monnaie tout en permettant également l'accès à des applications décentralisées (dApps) au sein de l'écosystème NEAR. Meteor est actuellement disponible à la fois comme portefeuille Web et comme extension de navigateur. Son objectif principal est de devenir le portefeuille préféré qui simplifie l'expérience de la blockchain NEAR pour les utilisateurs, le tout au sein d'une application de portefeuille puissante.
CARACTÉRISTIQUES
L'introduction de web3 pour les utilisateurs quotidiens peut être une tâche difficile. C'est pourquoi, chez Meteor, nous avons mis en place et prévoyons de déployer plusieurs fonctionnalités pour rationaliser le processus d'intégration pour toutes les personnes impliquées.
CRÉATION GRATUITE D’UN PORTEFEUILLE NOMMÉ
Meteor propose un portefeuille nommé gratuit, une fonctionnalité intuitive qui peut être configurée en moins d'une minute. Cette option conviviale est bien plus pratique que l'utilisation d'adresses alphanumériques traditionnelles difficiles à mémoriser. Si vous souhaitez créer votre propre portefeuille nommé gratuit Meteor, suivez attentivement ce guide étape par étape. Cliquez ici pour commencer.



Pour commencer, vous devrez créer un mot de passe. Une fois votre portefeuille configuré, vous aurez la possibilité de personnaliser votre profil et même de le connecter à Near Social. Si vous n'importez pas un portefeuille existant, assurez-vous de sécuriser votre nouvelle phrase de départ.

(Cliquez ici pour consulter le guide sur la façon d'importer un portefeuille existant).

De plus, si vous préférez utiliser une adresse traditionnelle au lieu d'un portefeuille nommé gratuit pour une raison quelconque, Meteor offre également la possibilité de créer un compte implicite, comme illustré dans l'image ci-dessus.




	

	
	
		
			
				Qu'est-ce qu'un portefeuille nommé gratuit vous permet de faire ?
			
		

		
					

		
			
			
			
			Créez une adresse personnalisée facile à mémoriser
		
			
			Modifier à tout moment les caractères alphanumériques d'une adresse
		
			
			Envoyer des actifs à des adresses sur des blockchains autres que NEAR
		
			
			Un portefeuille nommé gratuit vous permet d'envoyer et de recevoir des messages texte entre portefeuilles
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





FONCTIONNALITÉ D'ÉCHANGE (SWAP)
La fonctionnalité d'échange ou Swap permet aux utilisateurs d'échanger sans effort une crypto-monnaie contre une autre au sein de la blockchain, et dans ce cas, sans quitter le portefeuille. Meteor est le premier et le seul portefeuille de la Near Blockchain à intégrer un Swap Aggregator, permettant aux utilisateurs de comparer et d'économiser facilement avec les frais et les dérapages les plus bas disponibles.

Les fonctionnalités de swap de Meteor renforcent le concept de portefeuille tout-en-un. Les utilisateurs peuvent échanger jusqu'à 60 jetons (y compris les stablecoins) avec des fournisseurs d'échange réputés tels que Ref, Jumbo, Spin, et bien d'autres.



Pour commencer à explorer la fonctionnalité d'échange dans Meteor, cliquez ici pour accéder au guide de l'utilisateur et apprendre comment démarrer.




	

	
	
		
			
				Qu'entend-on par “swapping” ?
			
		

		
					

		
			
			
			
			Échanger une crypto-monnaie contre une autre
		
			
			Gagner des récompenses pour le commerce
		
			
			Transférer des actifs d'un portefeuille à un autre
		
			
			Le swapping fait référence au processus de retrait de fonds d'un portefeuille
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







STAKING
Le portefeuille Meteor propose deux options de staking : Liquid Staking et Standard Staking. Explorons les différences entre ces deux mécanismes et comment les gérer :

Le Liquid Staking est une fonctionnalité unique qui vous permet de recevoir un jeton de reçu comme preuve de propriété de votre actif staké. Ce jeton de reçu est transférable, stockable, négociable et peut être utilisé dans DeFi ou des dapps compatibles. D'autre part, Standard Staking n'offre pas de jetons de reçu.

Avec le Standard Staking sur Meteor, vous pouvez gagner des récompenses de Staking allant jusqu'à ~10 % APY. Vous pouvez comparer et sélectionner parmi plus de 90 validateurs et pools et voir vos gains estimés. Vous pouvez également choisir de bloquer votre mise pendant 7, 30 ou 90 jours.

Pour utiliser le Staking standard dans Meteor, il suffit de suivre quelques étapes simples dans la version Web ou l'extension. Vous pouvez choisir parmi plusieurs validateurs avec APY estimé et récompenses potentielles.



Cliquez ici pour savoir comment effectuer un Standard Satking sur Meteor.



Avec Liquid Staking sur Meteor, notre partenariat avec Meta Pool vous permet de recevoir des jetons de reçu stNEAR lors du staking. Ces jetons peuvent être utilisés pour s'engager dans diverses activités DeFi sur NEAR et AURORA.



Cliquez ici pour consulter notre guide sur le Liquid Staking et comment le faire.




	

	
	
		
			
				Quel est le principal avantage d'utiliser le Liquid Staking par rapport au Standard Staking sur Meteor Wallet ?
			
		

		
					

		
			
			
			
			Il n'y a aucun inconvénient potentiel à utiliser le Liquid Staking par rapport au Standard Staking dans le portefeuille Meteor
		
			
			Vous pourrez participer à de multiples événements au sein de l'écosystème NEAR grâce au jeton de reçu stNEAR
		
			
			Le principal avantage de l'utilisation du Liquid Staking par rapport au Standard Staking dans le portefeuille Meteor est que vous ne recevez aucune récompense ou APY sur Standard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFTs
Un jeton non fongible (NFT) est un identifiant numérique distinct qui ne peut pas être dupliqué, remplacé ou divisé. Il est enregistré sur une blockchain (NEAR dans ce cas) et utilisé pour vérifier la propriété et l'authenticité.

Alors que la plupart des portefeuilles blockchain vous permettent d'envoyer des objets de collection d'un portefeuille à un autre, Meteor se démarque en ce qui concerne les NFT. C'est le seul portefeuille sur NEAR qui fournit des mises à jour en temps réel sur le prix plancher et le plancher total de chaque collection que vous possédez. De plus, Meteor vous permet d'analyser les traits de vos NFT et même de définir un objet de collection comme photo de profil.



En cliquant sur une collection, vous pourrez voir tous les objets de collection qu'elle contient, ainsi que l'adresse contractuelle de chaque NFT, le prix plancher individuel et le prix plancher total de l'ensemble de votre collection NFT. Pour un guide complet sur l'utilisation des fonctionnalités NFT dans Meteor Wallet, veuillez cliquer ici.




	

	
	
		
			
				Vous ne pouvez pas envoyer de NFT de Meteor vers un portefeuille NEAR natif
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





EXPLORE
La nouvelle fonctionnalité Explore de Meteor Wallet vous tient informé des derniers développements de Meteor et de l'écosystème NEAR, y compris des nouvelles liées aux dApps, aux projets NFT et à DeFi. Cela fait de Meteor Wallet non seulement un outil de gestion de vos actifs, mais aussi un centre d'apprentissage et de mise à jour de l'écosystème.

De plus, dans la section Explore, vous pouvez participer aux Meteor Challenges, où vous pouvez gagner des récompenses grâce à une approche Learn-to-Earn ! Les détails sur la façon de participer à ces événements, qui découlent souvent de partenariats avec d'autres projets, sont disponibles dans le même portefeuille.



Meteor Wallet introduira bientôt une section Récompenses (Rewards) ! Restez à l'écoute pour cette mise à jour passionnante.






	

	
	
		
			
				La section Défis ou Challenges vous permet de gagner des récompenses grâce à :
			
		

		
					

		
			
			
			
			Staking vos jetons NEAR
		
			
			Participer aux activités/cadeaux DeFi organisés par Meteor et ses partenaires
		
			
			Swapping de jetons
		
			
			Collecter les NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





PARAMÈTRES ET SÉCURITÉ
Chez Meteor, la sécurité est de la plus haute importance. Nous vous recommandons vivement de stocker votre phrase de départ et votre mot de passe de portefeuille dans un emplacement sécurisé connu de vous seul.

En ouvrant l'onglet des paramètres, vous rencontrerez les options suivantes :



Applications connectées (Connected Apps) : cette fonctionnalité vous permet de connecter votre portefeuille à Near Social. À l'avenir, nous prévoyons d'ajouter des options pour connecter votre portefeuille à des réseaux sociaux tels que Facebook, Twitter et Apple, pour n'en nommer que quelques-uns.

Sécurité et récupération (Security and Recovery) : ici, vous pouvez afficher et extraire votre phrase de départ, ainsi que gérer vos clés privées.

Modifier le mot de passe (Change Password): si vous pensez que le mot de passe de votre portefeuille n'est pas sécurisé, vous pouvez le modifier à tout moment, en faisant toujours preuve de prudence.

Supprimer le compte (Remove Account): si, pour une raison quelconque, vous souhaitez supprimer votre compte, vous devez d'abord saisir votre mot de passe, puis confirmer la suppression. Bien que certains puissent considérer cette option comme inutile, nous pensons qu'elle est cruciale pour garantir la sécurité et la liberté des utilisateurs. Gardez à l'esprit que la suppression d'un compte est irréversible.




	

	
	
		
			
				Actuellement, vous pouvez connecter votre portefeuille Meteor à :
			
		

		
					

		
			
			
			
			Facebook, Twitter et Apple
		
			
			Vous ne pouvez lier votre portefeuille Meteor à aucun réseau social
		
			
			Near Social
		
			
			Vers reddit et les plateformes cross-chain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





PLANS FUTURS
Meteor Wallet a plusieurs mises à jour passionnantes en préparation, y compris :

Meteor Support 2.0 : une refonte de notre système d'assistance, qui comprendra l'intégration de Gleap et un système d'assistance à ticket unique pour les e-mails et les portefeuilles.

Meteor Explore 2.0 : avec encore plus d'Apps et de jeux disponibles !

Prise en charge du grand livre : prévue pour le troisième trimestre 2023.

Connexions sociales : en plus de Near Social, nous prévoyons d'ajouter la prise en charge des connexions sociales via Gmail, Facebook, Twitter, Apple, etc.

Applications iOS et Android : prévues pour la fin du deuxième trimestre 2023.

Prise en charge de Rich Media dans les NFT : Collaboration avec Harmonic Guild, avec une date de lancement provisoire plus tard cette année.

 

### Visión general de Meteor Wallet

Meteor Wallet (Billetera Meteor) aspira alcanzar varios objetivos claves, tales como facilitar la adopción masiva de la Web3 y convertirse en la billetera insigne de NEAR. Por su parte, busca fomentar una competencia sana con otros proyectos notables como MyNear, Sender, HERE y la billetera nativa de NEAR.

INTRODUCCIÓN
La tecnología Blockchain presenta un reino de oportunidades ilimitadas, incluida la autonomía financiera. Sin embargo, es un reto innegable para los recién llegados navegar por este complejo mundo.

¿Por qué es difícil? Fundamentalmente porque la libertad, que es la principal motivación para muchos de nosotros, conlleva responsabilidad. Esta responsabilidad abarca la gestión de tus acciones, pérdidas, inversiones, posibles estafas, activos y carteras. En la red descentralizada, salvaguardar tu criptodivisa depende únicamente de ti, sin nadie más en quien confiar.

Sin embargo, asumir responsabilidades no es la única barrera de entrada en el mundo de las criptomonedas. La complejidad de entender múltiples aplicaciones descentralizadas (dApps), tanto en lo que respecta a sus interfaces como a sus funcionalidades, es otro factor crucial a tener en cuenta.

Meteor Wallet aspira alcanzar varios objetivos claves, tales como facilitar la adopción masiva de la Web3 y convertirse en la billetera insigne de NEAR. Por su parte, busca fomentar una competencia sana con otros proyectos notables como MyNear, Sender, HERE y la billetera nativa de NEAR.

Somos afortunados de formar parte de un ecosistema excepcional en el que cada uno de los proyectos mencionados tiene sus puntos fuertes. Entonces, ¿qué diferencia a Meteor? La mejor manera de describirlo es como una billetera todo en uno.

El término "todo en uno" se refiere a la amplia gama de características y funcionalidades que Meteor incluye en una billetera única y fácil de usar. Estas herramientas ayudan a los recién llegados, que pueden tener conocimientos limitados, a navegar por la Web3 y el panorama de la blockchain. En los párrafos siguientes exploraremos algunas de estas características y profundizaremos en los objetivos de Meteor Wallet como proyecto Web3.
¿QUÉ ES METEOR WALLET?

Meteor Wallet es un billetera completa y fácil de usar diseñada para la gestión segura y directa de tu criptomoneda, al tiempo que permite el acceso a aplicaciones descentralizadas (dApps) dentro del ecosistema NEAR. Meteor está disponible actualmente como billetera web y como extensión de navegador. Su principal objetivo es convertirse en la billetera preferida que simplifique la experiencia del usuario en la blockchain NEAR, todo dentro de una poderosa aplicación de billetera.
CARACTERÍSTICAS
Introducir a los usuarios habituales en la Web3 puede ser una tarea ardua. Por eso, en Meteor hemos implementado y planeamos implementar varias funciones para agilizar el proceso de incorporación para todos los interesados.
CREACIÓN GRATUITA DE BILLETERAS CON NOMBRE PERSONALIZADO
Meteor ofrece una billetera con nombre personalizado gratuito, una función intuitiva que puede configurarse en menos de un minuto. Esta opción amigable con el usuario es mucho más conveniente que las direcciones alfanuméricas  tradicionales que son difíciles de recordar. Si estás interesado en crear tu propia billetera con nombre personalizado gratuito en Meteor, sigue con atención esta guía paso a paso. Haz clic aquí para empezar.

Para empezar, tendrás que crear una contraseña. Una vez configurada tu billetera, tendrás la opción de personalizar tu perfil e incluso conectarla a Near Social. Si no estás importando una billetera existente, asegúrate de proteger tu nueva frase semilla.

(Haz clic aquí para ver la guía sobre cómo importar tu billetera)

Además, si por cualquier motivo prefieres utilizar una dirección tradicional en lugar de una billetera con nombre personalizado gratuito, Meteor también ofrece la opción de crear una cuenta implícita, como se ilustra en la imagen superior.




	

	
	
		
			
				¿Qué le permite hacer una billetera de nombre personalizado gratuito?
			
		

		
					

		
			
			
			
			Crear una dirección personalizada y fácil de recordar
		
			
			Cambiar los caracteres alfanuméricos de una dirección en cualquier momento
		
			
			Enviar activos a direcciones en blockchains distintas de NEAR
		
			
			Una billetera de nombre personalizado gratuito te permite enviar y recibir mensajes de texto entre billeteras
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





FUNCIONALIDAD SWAP
La funcionalidad Swap permite a los usuarios cambiar sin esfuerzo una criptomoneda por otra dentro de la blockchain y, en este caso, sin salir de la billetera. Meteor es la primera y única billetera en la Blockchain Near que incorpora un Agregador de Swaps, lo que permite a los usuarios comparar y ahorrar fácilmente con las comisiones y deslizamientos más bajos disponibles.

Las funciones de swap de Meteor refuerzan el concepto de una billetera todo en uno. Los usuarios pueden intercambiar hasta 60 tokens (incluidas stablecoins) con proveedores de intercambio de confianza como Ref, Jumbo, Spin y otros.

Para empezar a explorar la funcionalidad de swap en Meteor, haga clic aquí para acceder a la guía del usuario y aprender cómo empezar.




	

	
	
		
			
				¿A qué se refiere el término "swap"?
			
		

		
					

		
			
			
			
			Cambiar una criptomoneda por otra
		
			
			Ganar recompensas por hacer trading
		
			
			Transferencia de activos de una billetera a otra
		
			
			Swapping se refiere al proceso de retirar fondos de una billetera
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






STAKING
La billetera Meteor ofrece dos opciones de staking: Staking Líquido y Staking Estándar. Exploremos las diferencias entre estos dos mecanismos y cómo gestionarlos:

El staking líquido es una característica única que te permite obtener un token de recibo como prueba de propiedad de tu activo en staking. Este token de recibo es transferible, almacenable, comercializable y puede utilizarse en DeFi o dApps compatibles. Por otro lado, el Staking Estándar no ofrece tokens de recibo.

Con el Staking Estándar en Meteor, puedes ganar recompensas de staking de hasta ~10% APY. Puedes comparar y seleccionar entre más de 90 validadores y pools y ver tus ganancias estimadas. También puedes elegir bloquear tu staking por un período de 7, 30 o 90 días.

Para utilizar el Staking Estándar en Meteor, basta con seguir unos sencillos pasos tanto en la versión web como en la extensión. Puedes elegir entre múltiples validadores con APY estimado y recompensas potenciales.

Haz clic aquí para ver cómo se hace el Staking Estándar en Meteor.

Con el Staking Líquido en Meteor, y gracias a nuestra asociación con Meta Pool, puedes obtener tokens de recibo stNEAR al realizar el staking. Estos tokens pueden utilizarse para participar en diversas actividades DeFi en NEAR y AURORA.

Haz clic aquí para consultar nuestra guía sobre Staking Líquido y cómo hacerlo.




	

	
	
		
			
				¿Cuál es la principal ventaja de utilizar Staking Líquido sobre Staking Estándar en Meteor Wallet?
			
		

		
					

		
			
			
			
			No hay desventajas potenciales en el uso de Staking Líquido en comparación con el Staking Estándar en la billetera Meteor
		
			
			Podrás participar en múltiples eventos dentro del ecosistema NEAR gracias a la obtención del token stNEAR
		
			
			La principal ventaja de utilizar Staking Líquido sobre Staking Estándar en la billetera Meteor es que no recibes ninguna recompensa o APY en Estándar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFTs
Un token no fungible (NFT) es un identificador digital distintivo que no puede duplicarse, sustituirse ni dividirse. Se registra en una blockchain (NEAR en este caso) y se utiliza para verificar la propiedad y la autenticidad.

Mientras que la mayoría de las billeteras blockchain te permiten enviar coleccionables de una billetera a otra, Meteor destaca cuando se trata de NFTs. Es la única billetera en NEAR que proporciona actualizaciones en tiempo real sobre el precio mínimo y el mínimo total de cada colección que posees. Además, Meteor te permite analizar los rasgos de tus NFT e incluso establecer un coleccionable como foto de perfil.

Al hacer clic en una colección, podrás ver todos los coleccionables que tiene, así como la dirección de contrato de cada NFT, el precio mínimo individual y el precio mínimo total de toda tu colección de NFT. Para obtener una guía completa sobre cómo utilizar las funciones de NFT en Meteor Wallet, haz clic aquí.




	

	
	
		
			
				No se puede enviar NFT desde Meteor a una billetera nativa NEAR
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






EXPLORAR

La nueva función Explorar de Meteor Wallet te mantiene informado sobre los últimos avances en Meteor y el ecosistema NEAR, incluidas las noticias relacionadas con dApps, proyectos NFT y DeFi. Esto convierte a Meteor Wallet no solo en una herramienta para gestionar tus activos, sino también en un centro de aprendizaje y actualización sobre el ecosistema.

Además, dentro de la sección Explorar, puedes participar en los Desafíos Meteor, en los que puedes ganar recompensas a través de un enfoque "Aprende para ganar". Los detalles sobre cómo participar en estos eventos, que a menudo surgen de asociaciones con otros proyectos, están disponibles en la misma billetera.

¡Meteor Wallet pronto introducirá una sección de Recompensas! Mantente atento a esta emocionante actualización.




	

	
	
		
			
				La sección Desafíos te permite ganar recompensas a través de:
			
		

		
					

		
			
			
			
			Hacer Stake de tus tokens NEAR
		
			
			Participar en actividades/regalos DeFi organizados por Meteor y sus socios
		
			
			Swap de tokens
		
			
			Coleccionar NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





CONFIGURACIÓN Y SEGURIDAD
En Meteor, la seguridad es lo más importante. Te recomendamos enfáticamente que guardes tu frase semilla y la contraseña de tu billetera en un lugar seguro que solo tú conozcas.

Al abrir la pestaña de configuración, encontrarás las siguientes opciones:

Aplicaciones conectadas: Esta función te permite conectar tu billetera a Near Social. En el futuro, tenemos previsto añadir opciones para conectar tu billetera a redes sociales como Facebook, Twitter y Apple, por nombrar algunas.

Seguridad y recuperación: Aquí puedes ver y extraer tu frase semilla, así como gestionar tus claves privadas.

Cambiar contraseña: Si crees que la contraseña de tu billetera no es segura, puedes cambiarla en cualquier momento, siempre con mucho cuidado.

Eliminar una cuenta: Si, por cualquier motivo, quieres eliminar tu cuenta, primero tendrás que introducir tu contraseña y luego confirmar la eliminación. Aunque algunos pueden considerar innecesaria esta opción, nosotros creemos que es crucial para garantizar la seguridad y la libertad del usuario. Te recordamos que la eliminación de una cuenta es irreversible.




	

	
	
		
			
				Actualmente, puedes conectar tu Meteor Wallet a:
			
		

		
					

		
			
			
			
			Facebook, Twitter, y Apple
		
			
			No puedes vincular tu Meteor Wallet a ninguna red social
		
			
			Near Social
		
			
			A reddit y plataformas de cadenas cruzadas
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





PLANES PARA EL FUTURO
Meteor Wallet tiene varias actualizaciones emocionantes en preparación, incluyendo:

Soporte Meteor 2.0: Una revisión de nuestro sistema de asistencia, que incluirá la integración de Gleap y un sistema de asistencia con un único ticket para el correo electrónico y la billetera.

Meteor Explore 2.0: ¡Con aún más dApps y juegos disponibles!

Soporte de Ledger: Previsto para el tercer trimestre de 2023.

Social Logins: Además de Near Social, tenemos previsto añadir compatibilidad con inicios de sesión en redes sociales a través de Gmail, Facebook, Twitter, Apple, etc.

Aplicaciones para iOS y Android: Previsto para finales del segundo trimestre de 2023.

Soporte para Rich Media en NFT: Colaboración con Harmonic Guild, con fecha provisional de lanzamiento a finales de este año.

### Meta Pool модуль 3 – Децентрализованные финансы в Meta Pool

Экосистема DeFi с Meta Pool
Децентрализованные финансы (DeFi) — это новый способ управления финансами, основанный на технологии блокчейн. Эти финансы используют смарт-контракты для хранения, блокировки, обмена, передачи и фарма токенов. DeFi направлен на то, чтобы лишить центральные банки контроля над средствами или активами и распределить их через смарт-контракты.

Meta Pool — это смарт-контракт эмитента активов без разрешения, не связанный с хранением, который позволяет объединять токены NEAR и размещать вознаграждения в одном токене, который называется Staked NEAR (stNEAR).

stNEAR позволяет своим держателям перемещать стоимость поставленных токенов и вознаграждений в экосистеме DeFi нескольких цепочек, включая NEAR и Aurora.




	

	
	
		
			
				Децентрализованные финансы могут управлять частью своих операций централизованно. Не все DeFi децентрализованы на 100%
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Мост токенов stNEAR между NEAR <> Aurora – Rainbow Bridge
Meta Pool использует Rainbow Bridge для передачи токенов $META и stNEAR между NEAR и Aurora Network, что позволяет вам использовать токены Meta Pool в приложениях Aurora dApp, таких как Trisolaris, WannaSwap и т. д.
Перемещение stNEAR и $META в Aurora с помощью Rainbow Bridge
Используя https://rainbowbridge.app/, вы можете подключить свой кошелек NEAR и кошелек MetaMask, чтобы перевести свои токены:



Как добавить контракты $META stNEAR в кошелек MetaMask
Чтобы добавить токен из вашего прошлого перевода Rainbow Bridge в MetaMask в основной сети Aurora, нажмите «Сканировать историю переносов» в Bridge и выберите «Добавить токен в MetaMask».

Чтобы добавить токен вручную, найдите адрес токена в списке поддерживаемых токенов. Обратите внимание, что их адреса в основной сети Aurora отличаются от адресов в Ethereum.

$META on Aurora 0xc21ff01229e982d7c8b8691163b0a3cb8f357453

stNEAR on Aurora 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30

(ВИДЕО) Как перевести stNEAR на Аврору. Возможности майнинга ликвидности (протокол NEAR, Aurora): https://www.youtube.com/watch?v=_o–5GY5G0w




	

	
	
		
			
				После того, как перевели токен из NEAR Protocol в Aurora, его невозможно вернуть в исходную цепочку.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Обмен токенами Aurora — Trisolaris
Обмен — это процесс, при котором вы обмениваете токен на другой в соответствии со стоимостью, заданной условиями рынка или пула. Таким образом, вы можете получить токены, которые у вас есть, или найти токен, который вы хотите использовать в конкретном приложении.

Trisolaris — это Dex №1 в Aurora, совместим с EVM блокчейном, работает в экосистеме NEAR.

Как свапнуть на Трисолярис?

 	Перейдите в раздел Trisolaris Swap и подключите свой кошелек MetaMask к Aurora Network.



 	Введите сумму для обмена
 	Одобрите и подтвердите транзакцию




	

	
	
		
			
				Вы можете использовать маршрутизацию, чтобы переключиться на токен, где нет прямого пула ликвидности.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Добавьте ликвидность в своп-пулы stNEAR — Trisolaris
Поскольку эмиссия токенов не управляется децентрализованной биржей, пулам свопов нужны пользователи, которые добавляют ликвидность, чтобы иметь возможность совершать обмен.

Таким образом, вы можете стать поставщиком ликвидности, поставив пару токенов, необходимых для пула. В обмен вы получаете часть комиссий, генерируемых пулом.

 	Перейдите в раздел «Пул» и нажмите на кнопку «Добавить ликвидность».



 	Выберите пару, в которую вы хотите добавить ликвидности. В Trisolaris вы можете найти пул stNEAR <> wNEAR.



 	Подтвердите баланс и нажмите кнопку добавить


Обмен токенов по протоколу NEAR – Ref Finance

 	Перейдите в Ref Finance и подключите свой кошелек NEAR.
 	Перейдите в раздел Обмен



 	Выберите токены для обмена, посмотрите «Влияние на цену», «Коэффициент обмена» и «Минимальный полученный» в меню «Подробности». Решите, подходит ли вам этот обмен
 	Введите сумму для обмена
 	Нажмите кнопку «Обмен», подтвердите и подпишите транзакцию.

Таким образом, на Ref Finance вы можете получить токены $META и stNEAR.
Добавьте ликвидность в своп-пулы stNEAR – Ref Finance
Ref Finance — крупнейшая децентрализованная биржа на протоколе NEAR. Она предоставляет набор инструментов DeFi с использованием стандарта NEP-141 NEAR.

 	Перейдите к пулам, найдите пулы stNEAR и выберите пул в который вы хотите добавить ликвидности.



 	Нажмите кнопку «Добавить ликвидность».



 	Выберите количество токенов, которое вы хотите добавить в пул ликвидности.


После этого вы можете получать часть сборов, генерируемых пулом.




	

	
	
		
			
				Будучи поставщиком ликвидности, ваши токены подвергаются риску ликвидации.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Займ с помощью stNEAR – Burrow Cash
Заимствование означает, что вы просите токены, предоставляя залоговый токен. Вы получаете часть стоимости вашего залога (сверх обеспечения), чтобы получить запрошенный токен.

Если вы хотите вернуть свои токены, у вас есть возможность погасить долг.

В случае падения стоимости вашего залога, он будет автоматически ликвидирован платформой заимствования, и вы останетесь только со своими заимствованными токенами без возможности восстановления своих токенов.

 	Перейдите на BurrowCash
 	Подключите свой кошелек NEAR
 	Подпишитесь на stNEAR на странице депозита


Внесение stNEAR:

 	Введите сумму stNEAR
 	Используйте её в качестве залога, если вы хотите занять
 	Отправьте и подпишите транзакцию


Как взять взаймы?


 	Выберите актив для кредита
 	Введите сумму займа, учитывая полученный коэффициент.
 	Отправьте и подпишите транзакцию


Как погасить?


 	Перейти в Портфолио
 	Чтобы погасить заемные средства, нажмите кнопку «Погасить».


Как вывести?


 	Перейти в портфолио
 	Чтобы вывести предоставленные активы, нажмите «Вывести».





	

	
	
		
			
				Займ наличными доступен в любой стране мира.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Заимствование с помощью stNEAR — Aurigami
Arugami позволяет вам запросить заимствование токенов в сети Aurora. Для этого вы можете использовать токены stNEAR.

Вы можете перейти прямо на панель управления Aurigami и нажать на предложение токена stNEAR. Если у вас уже есть залог, вы можете нажать «Занять».

Опция поставки даст вам модальное окно, в котором может быть размещен stNEAR. После выбора нажмите «Утвердить stNEAR».

Разрешить использование stNEAR в качестве залога. Подтвердите транзакцию на своем кошельке.

Выберите токен, который хотите одолжить, и нажмите кнопку «Занять».

Выберите количество токенов, которое вы хотите взять взаймы. ВНИМАНИЕ: если вы запрашиваете 100%, вы подвергаетесь высокому риску ликвидации.

Всякий раз, когда вы хотите вернуть свой stNEAR, погасите и верните все токены, которые вы получили взаймы.

Фермерство с использованием заемных средств — PembRock
Первое приложение для выращивания урожая с использованием заемных средств в протоколе NEAR. Внутри этого приложения вы можете найти механизмы кредитования, фермерства и ставок. stNEAR разрешено использовать в качестве токена в PembRock.

Ферма STNEAR-wNEAR
Внесите stNEAR и одолжите wNEAR в пуле фермы. Выберите сумму активов для использования в качестве залога и уровень кредитного плеча. Проверьте сводку транзакции.

Одолжить stNEAR
Выберите количество токенов stNEAR, которое вы хотите одолжить. Эти активы используются фермерами, выращивающими урожай, для усиления своих криптоактивов.

Узнайте больше о том, как работает Pembrock, по следующей ссылке: https://docs.pembrock.finance/education/how-to-guides.




	

	
	
		
			
				Leveraged Yield Farming может подразумевать риск ликвидации ваших токенов.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Стэйкинг NEAR на Aurora Network
Мы упростили пользователям Aurora стейкинг wNEAR непосредственно из Aurora с помощью MetaMask. Используя возможности Rainbow Bridge для выполнения контрактных вызовов между Aurora и NEAR, мы создали простое решение, которое поддерживает тот же пользовательский интерфейс и возможности, что и собственное решение NEAR.

Легко определить, в какой сети вы находитесь, поскольку она имеет логотип Aurora, и каждая сеть автоматически предложит вам подключить свой кошелек Metamask.

Мы используем Rainbow Bridge для автоматизации всех шагов, которые пользователям пришлось бы выполнять вручную: мы отправляем wNEAR из Aurora в NEAR Mainnet, распаковываем его, помещаем NEAR в метапул, получаем stNEAR и отправляем stNEAR обратно через Rainbow Bridge к пользовательскому кошельку Aurora.

Наш код был проверен Blocksec. Поэтому мы сделали все возможное, чтобы сохранить активы в безопасности.

Комиссия за депозит на Aurora составляет 0,1%, потому что Meta Pool должен платить комиссию за транзакции по мосту туда и обратно, которая покрывает эти комиссии за транзакции.

### Update – May 23, 2023

Brief Summary:

 	
NameSky, a project from ⚗️LNC Barrel passed security audit and launched on NEAR mainnet!
Don't miss cool prizes at Mintbase!



 

Results:

 	📚 (L)Earn "Why WordPress Can Open The Gates To Web3"

 	🏆May Redeem window was super intense! Almost 400 (L)Earners completed the requirements and claimed 2 NEAR
 	Celebrate Bitcoin 🍕Day with 🗳️qVote of the week! "Do you like Pizza?" - Have your quadratic say, (L)Earner 🕺

 	📚(L)Earn about State of DeFi on NEAR in 2023

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Everyone is invited to NEAR Certified Developer Demo day on May 26, 11 am EDT.

### Por que o WordPress pode abrir as portas para Web3

A transição para web3 parece ser inevitável. Várias empresas já começaram a experimentar as várias facetas da web3, como os NFTs, metaverso e tokenização. No entanto, como podemos minimizar o impacto dessa transição? No Learn Near Club, o futuro da web3 pode ser alcançado incorporando ferramentas web3 em plataformas web2 comprovadas e abertas. Um dos melhores exemplos de uma plataforma web “comprovada e aberta” é o WordPress. Neste blog, vejamos como o WordPress promove o crescimento descentralizado dentro de sua estrutura centralizada.
O que é WordPress?
O WordPress é um sistema, muito popular, de gerenciamento de conteúdo (CMS) de código aberto que permite aos usuários criar e gerenciar sites e blogs. Desde o seu lançamento em 2003, cresceu e se tornou uma das plataformas de sites mais usadas, alimentando cerca de 43% de todos os sites da Internet.

Uma das principais razões para sua popularidade é sua interface amigável que não exige que os usuários tenham nenhum conhecimento de codificação. Isso o tornou uma escolha popular para quem deseja criar e publicar conteúdo facilmente. Além disso, uma grande comunidade de desenvolvedores criou vários plugins e temas, que podem ser facilmente integrados à plataforma, fornecendo funcionalidade adicional e também uma estética atrativa.

O WordPress é altamente personalizável, o que significa que pode atender a uma ampla variedade de sites, desde pequenos blogs pessoais até grandes sites corporativos. Também é escalável, o que permite crescer em conjunto com o crescimento de um negócio ou site. A plataforma tem a capacidade de adicionar novos recursos e funcionalidades conforme necessário, tornando-a altamente adaptável.

Outra vantagem do WordPress é sua estrutura amigável para SEO (Otimização para Motores de Busca). Os sites criados com o WordPress possuem uma ferramenta de SEO integrada que permite aos usuários otimizar seu conteúdo e garantir que seja compatível com os mecanismos de pesquisa. Esse recurso tornou o WordPress a escolha preferida de muitas empresas e indivíduos que desejam que seus sites sejam facilmente encontrados pelos mecanismos de pesquisa.
A filosofia do WordPress
A filosofia do WordPress está erigida sobre vários princípios básicos que orientam seu desenvolvimento e comunidade. Esses princípios são:

 	Fornecer uma plataforma amigável e acessível para que qualquer pessoa possa criar e publicar conteúdo online. Isso significa que o software deve ser fácil de usar, fácil de entender e de acesso gratuito.
 	Sendo de código aberto, o software está disponível gratuitamente para uso, modificação e distribuição sem quaisquer restrições. Isso ajudou a criar uma grande comunidade de desenvolvedores que estão constantemente aprimorando e desenvolvendo a plataforma, adicionando novos recursos e funcionalidades.
 	Incentivo para que os usuários trabalhem juntos e compartilhem conhecimento, o que levou à criação de uma comunidade vibrante de usuários, desenvolvedores e colaboradores que trabalham em aliança para melhorar a plataforma.
 	Fornecimento de uma ferramenta que possa ser usada por qualquer pessoa, independentemente de seus conhecimentos técnicos ou habilidades físicas. Isso significa que o software deve ser projetado tendo em mente a acessibilidade, tornando-o fácil de usar e navegar para todos os usuários.

O WordPress está focado na criação de uma plataforma aberta, acessível e fácil de usar, com forte ênfase na comunidade e na colaboração. Esses princípios básicos ajudaram o WordPress a tornar-se um dos sistemas de gerenciamento de conteúdo mais populares do mundo.




	

	
	
		
			
				Qual é uma das principais razões para o WordPress ser tão popular como sistema de gerenciamento de conteúdo?
			
		

		
					

		
			
			
			
			Seu custo

		
			
			Sua interface amigável que não requer que os usuários tenham nenhum conhecimento de esforço 
		
			
			Sua compatibilidade com outras plataformas 
		
			
			Sua natureza acolhedora
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress e Web3
Vejamos a relação existente entre WordPress e web3. Embora o WordPress não seja inerentemente uma plataforma Web3, existem maneiras de integrar as tecnologias Web3 ao WordPress para criar sites mais descentralizados e seguros. Uma dessas formas é por meio do uso de sistemas de nome de domínio (DNS) descentralizados, como o Unstoppable Domains. Você também pode usar sistemas de armazenamento descentralizados, como IPFS. O IPFS é um sistema de armazenamento ponto a ponto que permite aos usuários armazenar e compartilhar arquivos de maneira descentralizada e resistente à censura. Ao integrar o IPFS em um site WordPress, os usuários podem criar uma plataforma mais segura e descentralizada para compartilhar conteúdo. Por fim, os criadores de sites sempre podem integrar APIs de pagamento criptográfico para acessar pagamentos descentralizados.
WordPress é o standard perfeito
Como você pode ver, o WordPress é uma plataforma web2 flexível que permite integrar tecnologias web3 perfeitamente. Aí está a razão pela qual o CMS é usado por 38% de todos os sites da Internet para criar e gerenciar diferentes tipos de sites, como blogs pessoais, lojas online e muito mais. Essa natureza aberta também permitiu que o WordPress criasse uma comunidade livre e vibrante de colaboradores. Esses colaboradores trabalham duro para melhorar a plataforma desenvolvendo novos recursos, corrigindo bugs e mantendo o código principal. Qualquer pessoa pode contribuir com o WordPress e existem muitas maneiras de fazê-lo.




	

	
	
		
			
				Como o WordPress se alinha com os princípios da web3?
			
		

		
					

		
			
			
			
			Por ser uma plataforma centralizada com um conjunto fixo de funcionalidades
		
			
			Contando com um único desenvolvedor para todas as atualizações
		
			
			Por ser uma plataforma de código fechado
		
			
			Apoiando e incentivando as contribuições da comunidade
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como os contribuidores ajudam o WordPress?

 	Ao relatar bugs, sugerir novos recursos e fornecer feedback sobre recursos existentes, os usuários ajudam os desenvolvedores a identificar problemas e fazer as melhorias necessárias. Este feedback é crucial para o crescimento contínuo e sucesso da plataforma.
 	O WordPress está disponível em vários idiomas, mas sempre existe a necessidade de mais tradutores para ajudar a tornar a plataforma acessível a mais pessoas ainda. Não é preciso ser fluente em vários idiomas para ajudar nas traduções, mesmo pequenas contribuições podem fazer uma grande diferença.
 	Se você possui habilidades de codificação, pode contribuir com o WordPress escrevendo códigos, corrigindo bugs ou desenvolvendo novos recursos. O WordPress é uma plataforma de código aberto e qualquer pessoa pode acessar seu código e contribuir para seu desenvolvimento. Dependendo de suas habilidades e interesses, você pode contribuir com o núcleo, plugins ou temas do WordPress.
 	Você também pode contribuir com o WordPress ajudando na documentação, design ou no gerenciamento da comunidade. Essas áreas são tão importantes quanto a codificação e há muitas oportunidades de se envolver.
 	Você pode apoiar a comunidade WordPress ajudando outros usuários em fóruns, participando de encontros e organizando eventos WordPress. Ao apoiar a comunidade, você cria um ambiente acolhedor e inclusivo que beneficia  a todos os envolvidos.

Patrimônio do WordPress
De acordo com um estudo da WPEngine, o patrimônio mundial do WordPress, que inclui todas as empresas, desenvolvedores e usuários associados ao WordPress, foi avaliado em aproximadamente US $596,7 bilhões em 2020.

Automattic, empresa global distribuída por trás do WordPress.com, com 1.983 Automatticians (apelido que eles usam para designar os funcionários). em 96 países, falando 123 idiomas diferentes, tem ZERO escritórios.

Ganhar dinheiro no WordPress é possível através de vários métodos. Aqui estão algumas das melhores maneiras de monetizar seu site WordPress:

 	Ecommerce (comércio eletrônico): Use um plugin como o WooCommerce para transformar seu site WordPress em uma loja online onde você pode vender produtos físicos ou digitais, serviços e compromissos.
 	Publicidade: Exiba anúncios em seu site e ganhe dinheiro por meio de pagamento por clique (PPC) ou outros modelos de publicidade. O Google AdSense é uma opção popular para exibir anúncios relevantes em seu site.
 	Marketing de afiliados: Promova produtos ou serviços de outras empresas em seu blog ou site usando links exclusivos de afiliados. Você ganha uma comissão por cada venda ou ação realizada por meio de sua referência.
 	Conteúdo Exclusivo: Ofereça conteúdo premium ou exclusivo para seus visitantes por uma taxa. Isso pode incluir artigos, vídeos, cursos ou outros recursos de valor.
 	Cursos online: Se você possui conhecimentos ou habilidades especializadas, crie e venda cursos online por meio do seu site WordPress. Isso permite que você compartilhe sua experiência e monetize seu conhecimento.
 	Desenvolvendo Plugins: Se você possui habilidades de codificação, você pode desenvolver e vender plugins para WordPress. Muitos proprietários de sites estão dispostos a pagar por plugins que aprimoram a funcionalidade de seus sites.
 	Construindo sites WordPress para clientes: Se você possui habilidades de desenvolvimento web, pode oferecer serviços de design e desenvolvimento de sites WordPress para clientes. Isso pode ser um negócio lucrativo se você puder fornecer sites de alta qualidade.

Não é este o espírito da Web3?
Ao criar um modelo que depende fortemente de sua comunidade para melhorias, o WordPress criou um negócio que fica no precipício da web3. Lembre-se, em um ambiente web3, todas as operações são executadas por uma comunidade em vez de um conselho administrativo centralizado. o wordpress está desbravando esse modelo, tanto quanto pode, no cenário web2.

Além disso, o WordPress cria infinitas oportunidades para todos que desejam criar valor real para usuários reais, independentemente da localização geográfica, condições políticas e econômicas.
Veja como o Learn Near Club contribui para levar o WordPress para web3
Criamos dois plugins para WordPress, que permitem aos usuários se conectar com o ecossistema Near.

 	Login com NEAR
 	Comentários LNC Near

Login com NEAR
Configure e personalize facilmente o login com a funcionalidade NEAR em seu site WordPress usando um código de acesso simples. Aqui estão alguns recursos para ter em conta:

 	Suporta carteiras Near populares tais como – “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, “Sender”.
 	Cadastro e login facilitados: Se um usuário possui uma Near Wallet, ele já pode utilizar todas as funcionalidades do seu site e é identificado como Usuário WP.
 	Se o seu aplicativo WordPress usa o contrato inteligente NEAR, o plugin permite que os usuários criem uma chave funcional de acesso limitada para ele. Além disso, os usuários podem fazer chamadas para alterar/visualizar métodos para outros contratos inteligentes.
 	Com o plugin, também fica fácil personalizar a interface de login do usuário.

Se você deseja criar um plug-in com contrato inteligente e chamá-lo desde usuários logados, basta fazê-lo desta maneira:
view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})
Veja o plugin demo.

Baixe o plugin.
Comentarios LNC Near
Integre e personalize o plug-in LNC Near Comments para o seu site WordPress usando o código de acesso fácil [lnc_near_comments]. Aqui estão alguns recursos para ter em conta:

 	Suporta carteiras Near populares tais como – “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, “Sender”.
 	Fornece um captcha exclusivo para a seção de comentários e publica os comentários do usuário após uma pequena transação de gorjeta no contrato inteligente v1.ncaptcha.near.
 	O sistema de pagamento exclusivo permite que você receba uma parte do pagamento para cada captcha resolvido por seus usuários. Você pode configurar a receita do seu lado.
 	Testado e projetado para funcionar com a versão mais recente do WordPress. Certifique-se de que sua instalação do WordPress esteja atualizada antes de usar o plug-in.
 	O plugin LNC Near Comments requer o plugin Near Login para funcionar corretamente. Por favor, consulte a documentação do plugin para quaisquer dependências necessárias e instruções de instalação.

Para utilizar o plug-in com um contrato inteligente e permitir que usuários conectados interajam, use os seguintes métodos:
View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})
Veja o plugin demo.

Baixe o plugin.
Para encerrar
A interseção das tecnologias web2 e web3 apresenta uma fronteira única e empolgante para o mundo digital. Plataformas tradicionais como WordPress demonstraram sua adaptabilidade e relevância neste cenário em evolução. Ao integrar recursos web3, como sistemas de nomes de domínio descentralizados, sistemas de armazenamento descentralizados e APIs de pagamento criptográfico, o WordPress incorpora um modelo híbrido, posicionando-se na vanguarda da revolução web3.

A comunidade que administra o Ethos, (um projeto open source de wordpress), está muito alinhada com os princípios da web3. Sua ampla adoção, facilidade de uso e adaptabilidade o tornam um trampolim ideal para a transição para uma internet mais descentralizada. Ao apoiar e incentivar as contribuições da comunidade, o WordPress promove um ambiente semelhante ao web3 em um contexto web2.

Se você está pronto para participar da conexão do NEAR ao WordPress, junte-se a este Grupo no Telegram




	

	
	
		
			
				Qual das opções a seguir não é uma maneira dos usuários contribuírem com o WordPress?
			
		

		
					

		
			
			
			
			Relatando bugs e sugerindo novos recursos
		
			
			Ajudando com traduções
		
			
			Escrever código ou corrigir bugs
		
			
			Pagar por recursos premium
		
	
		

		
		
			
				Correct!
				Wrong!

### Do you like pizza🍕?

Do you like pizza🍕?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I never tried it, send me some
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Why WordPress Can Open The Gates To Web3

The transition to web3 seems inevitable. Several companies have already started experimenting with the various facets of web3, such as NFTs, metaverse, and tokenization. However, how do we smoothen this transition? At Learn Near Club, the future of web3 can be reached by incorporating web3 tooling into proven and open web2 platforms. One of the best examples of a “proven and open” web platform is WordPress. In this blog, let’s see how WordPress fosters decentralized growth within its centralized framework.
What is WordPress?
WordPress is a popular open-source content management system (CMS) that enables users to create and manage websites and blogs. Since its release in 2003, it has grown to be one of the most widely used website platforms, powering about 43% of all websites on the Internet.

One of the key reasons for its popularity is its user-friendly interface that does not require users to have any coding knowledge. This has made it a popular choice for those who want to create and publish content easily. Additionally, a large community of developers has created numerous plugins and themes, which can be easily integrated into the platform, providing additional functionality and aesthetic appeal.

https://www.youtube.com/watch?v=HCyn97xeKig

WordPress is highly customizable, which means it can cater to a wide range of websites, from small personal blogs to large corporate sites. It is also scalable, which allows it to grow in tandem with a business or website's growth. The platform has the ability to add new features and functionality as required, making it highly adaptable.

Another advantage of WordPress is its SEO-friendly structure. Websites built with WordPress have a built-in SEO tool that enables users to optimize their content and make sure it is search engine friendly. This feature has made WordPress a preferred choice for many businesses and individuals who want their websites to be easily found by search engines.


The Philosophy of WordPress
The philosophy of WordPress is built on several core principles that guide its development and community. These principles are:

 	Provide a user-friendly and accessible platform for anyone to create and publish content online. This means that the software should be easy to use, easy to understand, and free to access.
 	Being open source, the software is freely available to use, modify, and distribute without any restrictions. This has helped to create a large community of developers who are constantly improving and building on the platform, adding new features and functionality.
 	Encourage users to work together and share knowledge, which has led to the creation of a vibrant community of users, developers, and contributors who work together to make the platform better.
 	Provide a tool that can be used by anyone, regardless of their technical expertise or physical abilities. This means that the software should be designed with accessibility in mind, making it easy to use and navigate for all users.

WordPress is focused on creating a platform that is open, accessible, and user-friendly, with a strong emphasis on community and collaboration. These core principles have helped to make WordPress one of the most popular content management systems in the world.




	

	
	
		
			
				What is one of the key reasons for the popularity of WordPress as a content management system?
			
		

		
					

		
			
			
			
			Its cost
		
			
			Its user-friendly interface does not require users to have any coding knowledge
		
			
			Its compatibility with other platforms
		
			
			Its proprietary nature
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





WordPress and Web3
Let's look at the existing relationship between WordPress and web3. While WordPress is not inherently a Web3 platform, there are ways to integrate Web3 technologies into Wordpress to create more decentralized and secure websites. One such way is through the use of decentralized domain name systems (DNS), such as Unstoppable Domains. You can also use decentralized storage systems, such as IPFS. IPFS is a peer-to-peer storage system that allows users to store and share files in a decentralized and censorship-resistant manner. By integrating IPFS into a WordPress website, users can create a more secure and decentralized platform for sharing content. Finally, website creators can always integrate crypto payment APIs to access decentralized payments.
Wordpress is The Gold Standard
As you can see, WordPress is a flexible web2 platform that allows you to seamlessly integrate web3 technologies. There is a reason why the CMS is used by 38% of all internet websites for creating and managing different types of sites such as personal blogs, online stores, and more. This open nature has also allowed WordPress to create an open and vibrant community of contributors. These contributors work hard to improve the platform by developing new features, fixing bugs, and maintaining the core code. Anyone can contribute to WordPress, and there are many ways to do so.




	

	
	
		
			
				How does WordPress align with the principles of web3?
			
		

		
					

		
			
			
			
			By being a centralized platform with a fixed set of features
		
			
			By relying on a single developer for all updates
		
			
			By being a closed-source platform
		
			
			By supporting and encouraging community contributions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Contributors Help WordPress

 	By reporting bugs, suggesting new features, and giving feedback on existing features, users help developers identify issues and make necessary improvements. This feedback is crucial for the continued growth and success of the platform.
 	WordPress is available in many languages, but there is always a need for more translators to help make the platform accessible to even more people. One does not need to be fluent in multiple languages to help with translations - even small contributions can make a big difference.
 	If you have coding skills, you can contribute to WordPress by writing code, fixing bugs, or developing new features. WordPress is an open-source platform, and anyone can access its code and contribute to its development. Depending on your skills and interests, you can contribute to WordPress core, plugins, or themes.
 	You can also contribute to WordPress by helping with documentation, design, or community management. These areas are just as important as coding, and there are many opportunities to get involved.
 	You can support the WordPress community by helping other users on forums, attending meetups, and organizing WordPress events. By supporting the community, you create a welcoming and inclusive environment that benefits everyone involved.

WordPress economy
According to a study by WPEngine, the worldwide WordPress Economy, which includes all the businesses, developers, and users associated with WordPress, was valued at around $596.7 billion in 2020.

Automattic, global distributed company behind WordPress.com with 1,983 Automatticians in 96 countries speaking 123 different languages,  has ZERO offices.

Making money on WordPress is possible through various methods. Here are some of the best ways to monetize your WordPress website:

 	Ecommerce: Use a plugin like WooCommerce to turn your WordPress website into an online store where you can sell physical or digital products, services, or appointments.
 	Advertising: Display ads on your website and earn money through pay-per-click (PPC) or other advertising models. Google AdSense is a popular option for displaying relevant ads on your site.
 	Affiliate Marketing: Promote products or services from other companies on your blog or website using unique affiliate links. You earn a commission for each sale or action made through your referral.
 	Exclusive Content: Offer premium or exclusive content to your visitors for a fee. This can include articles, videos, courses, or other valuable resources.
 	Online Courses: If you have specialized knowledge or skills, create and sell online courses through your WordPress website. This allows you to share your expertise and monetize your knowledge.
 	Building Plugins: If you have coding skills, you can develop and sell plugins for WordPress. Many website owners are willing to pay for plugins that enhance the functionality of their websites.
 	Building WordPress Sites for Clients: If you have web development skills, you can offer WordPress website design and development services to clients. This can be a profitable business if you can deliver high-quality websites.

Isn’t This The Very Ethos Of Web3?
By creating a model that’s heavily dependent on its community for improvement, WordPress has created a business that sits at the very precipice of web3. Remember, in a web3 environment, all operations are run and executed by a community instead of a centralized board of directors. WordPress pioneers that model as much as possible in a web2 scenario.

Moreover, WordPress creates endless opportunities for everyone who is willing to create real value for real users regardless of geographical location, political and economical conditions.
Here’s How Learn Near Club Contributes To WordPress journey to web3
We have created two plugins for WordPress, which allow users to connect with the Near ecosystem.

 	Login with NEAR
 	LNC Near Comments

Login with NEAR


Easily setup and customize login with NEAR functionality at your WordPress site by using simple shortcode. Here are some features to keep in mind:

 	Supports popular Near wallets like – “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, “Sender”
 	Easy registration and login: If a user has a Near Wallet, he already can use all functionality from your site and is identified as WP User
 	If your WordPress app uses NEAR smart contract the plugin allows users to create a functional limited access key for it. Also, users can make calls to change/view methods to other smart contracts
 	The plugin also is easy to customize login UI.

If you want to create plugin with smart contract and call it from logged users you can simply do it in this way:

view method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Watch plugin demo.

Download plugin.
LNC Near Comments


Integrate and customize the LNC Near Comments plugin for your WordPress site by using the easy shortcode [lnc_near_comments]. Here are some features to keep in mind:

 	Supports popular Near wallets like –  “Near Wallet”, “My Near Wallet”, “Here Wallet”, “Meteor Wallet”, and “Sender”
 	Provides a unique captcha for the comment section and posts user comments after a small tip transaction to the v1.ncaptcha.near smart contract
 	Unique payment system allows you to receive a portion of the payment for each captcha solved by your users. You can configure the revenue on your side
 	Tested and designed to work with the latest version of WordPress. Ensure your WordPress installation is updated before using the plugin
 	The LNC Near Comments plugin requires the Near Login plugin to function properly. Please refer to the plugin documentation for any necessary dependencies and installation instructions.

To utilize the plugin with a smart contract and allow logged-in users to interact, use the following methods:

View method: await window.mainWallet.viewMethod({contractId: string, method: string, args: {} }

Change method: await window.mainWallet.callMethod({contractId: string, method: string, args: {}, gas: number, deposit: number})

Watch plugin demo.

Download plugin.
In Closing
The intersection of web2 and web3 technologies presents a unique and exciting frontier for the digital world. Traditional platforms like WordPress have demonstrated their adaptability and relevance in this evolving landscape. By integrating web3 features such as decentralized domain name systems, decentralized storage systems, and crypto payment APIs, WordPress embodies a hybrid model, positioning itself at the forefront of the web3 revolution.

WordPress's open-source, community-driven ethos aligns closely with the principles of web3. Its wide adoption, ease of use, and adaptability make it an ideal springboard for the transition into a more decentralized internet. By supporting and encouraging community contributions, WordPress fosters a web3-like environment in a web2 context.

If you are ready to participate in connecting NEAR to WordPress join this Telegram Group



	

	
	
		
			
				Which of the following is not a way that users can contribute to WordPress?
			
		

		
					

		
			
			
			
			Reporting bugs and suggesting new features
		
			
			Helping with translations
		
			
			Writing code or fixing bugs
		
			
			Paying for premium features
		
	
		

		
		
			
				Correct!
				Wrong!

### DeFi on NEAR 2023

In 2023, the NEAR ecosystem developed a set of mature platforms for the Decentralized Finances (DeFi) ecosystem. It has a wide range of decentralized apps (dApps) focused on the management of finances. NEAR is a showcase of a scalable, low fees, layer 1 blockchain. This advantage makes it easy for anyone interested to start their road on the DeFi’s.

DeFi allows users to have the management over their digital tokens. Some key features of this technology include:

 	Non-custodial; meaning that users maintain control of their assets throughout the trading process.
 	Transparent: All transactions are recorded on the blockchain and can be viewed by anyone.
 	Secure: Using advanced cryptography and other security measures to ensure that trades are safe and secure.
 	Accessible: to anyone with an internet connection and a compatible digital wallet.
 	No central authority: in a decentralized manner, meaning that there is no central authority controlling the exchange.

Proximity Labs, a research and development firm, including a venture capital fund, looks for the next generation of DeFi platforms that wants to develop on NEAR Protocol. If you are a developer and looking for support to enhance your DeFi dApp developed on NEAR look for them.

Lastly, we need to add context. The events occurred during 2022 (as Terra-Luna, FTX-Alameda, and others), and the crypto ecosystem made radical changes to the DeFi future, requiring more dynamic and innovative platforms that can support both: Bear and bull markets. Considering all the technological advantages, this writer believes that the DeFi future should be builded on NEAR.
Decentralized exchanges (DEX)
Ref Finance

Ref Finance, the pioneer of decentralized finance on NEAR Protocol, offers a comprehensive swap service for tokens with liquidity pools and farms. The platform has evolved over time to include an Automatic Market Maker (AMM) for seamless trading experiences.

Ref Finance is governed by a DAO that maintains a whitelist of tokens for trading on the platform, ensuring the security and stability of assets. As of 2023, Ref Finance remains the top DEX on NEAR with a promising roadmap to expand its features.

In Q1-2023, Ref Finance plans to launch Ref V2 Farms, core metrics on Ref Analytics, and Orderly's liquidity integration for a pure Central Limit Order Book (CLOB) experience. In Q2-2023, the platform aims to introduce embedded lending and borrowing primitives, an enhanced swap proposal, Ref widgets, and Zap Swap.

In the second half of 2023, Ref Finance plans to roll out recurring swaps, Sentinel on pools and farms, liquidity as collateral, and innovative solutions for better security and user protection. With its ambitious roadmap, Ref Finance is poised to cement its position as a leading DEX in the NEAR ecosystem.
Spin Finance

Spin Finance is a decentralized trading platform that offers advanced trading tools to NEAR users, including perpetual futures on NEAR, ETH, and BTC. In addition to traditional spot trading, Spin provides DOVs and vaults for yield farming. By utilizing these vaults, traders can easily and safely participate in yield farming without having to trade individually.

Moreover, Spin Finance's roadmap includes the introduction of new features such as options trading, AIPs, and a decentralized Market Maker. These advanced tools can be useful for both traders and degens, making any token on the NEAR Ecosystem worth considering for utilization.

Spin Finance's unique hybrid model combines the advantages of centralized and put those on a decentralized exchanges, making it stand out among its peers. Since its launch in 2021 as an order book for NEAR, Spin has continued to grow, with an expanding team that promises a brilliant future ahead. If you're looking for an advanced trading platform that combines the best of both worlds, Spin Finance may be the perfect choice for you.
Jump DeFi

Jump DeFi is an all-encompassing dapp that provides a range of solutions for launching, raising capital, and swapping NEP-141 tokens. It is regarded as an ecosystem that empowers individuals and organizations to take their first steps into the world of DeFi.

One of the most noteworthy tools provided by Jump Defi is the NFT staking service, which allows NFT communities to support their holders by providing them with tokens. This service is designed to incentivize the holding of NFTs and create a more engaged community.

Jump Token Laboratory is another innovative tool provided by Jump DeFi, which enables users to create tokens and subsequently move them to the Jump Pad, a launchpad that facilitates fundraising on the NEAR Ecosystem.

Jump DeFi has also played host to a boosted yield farming campaign for NEKO, a meme coin living on NEAR Protocol. The platform has also launched crowdfunding campaigns on other launchpads, including Meta Yield, where it raised a total of $68,416 USD in stNEAR tokens that will provide all the staking rewards.

Is an amazing and comprehensive platform that offers a diverse range of DeFi services on NEAR Protocol, including staking, fundraising, and token creation. It is a platform that has the potential to open up new opportunities and possibilities for anyone looking to participate in the decentralized finance ecosystem.
Liquid Staking
Meta Pool
Liquid staking has become a popular solution for those who want to stake their tokens and earn rewards, but also want to retain the ability to use those tokens in other ways. Meta Pool is the first and biggest liquid staking solution on NEAR Protocol, providing a way for users to earn staking rewards while still being able to use their staked tokens in the DeFi ecosystem.

Meta Pool launched with their digital staking token, $stNEAR, which allows users to keep staking while also using the $stNEAR derivative on the DeFi ecosystem. The protocol is managed by a DAO that rewards users with $META, a governance token that can be used to participate in the community driving Meta Pool's DAO.

One of the unique features of Meta Pool is the implementation of the Meta Staking Vote, which allows $META holders to select which validators are the best to be supported. These validators receive 15% of the Meta Pool's Total Value Locked (TVL) distributed based on their voting. This approach ensures that the Meta Pool community has a say in which validators are supported, promoting decentralization and community involvement in the network.

Today, the family of products launched by Meta Pool has enhanced and is compounded by:

 	$stNEAR, Liquid Staking on NEAR.
 	Liquidity pool for liquid unstake on NEAR Protocol.
 	$stAUR token, liquid staking on Aurora
 	Meta Yield, the first lossless crowdfunding platform on NEAR.
 	Meta Bond, sell your locked positions on Meta Yield.
 	Meta Vote, get voting power for the Meta Pool’s governance.

Meta Pool is a permissionless protocol that provides a way for users to stake their tokens and earn rewards, while also retaining the ability to use those tokens in other ways. With the implementation of the Meta Staking Vote and the distribution of $META governance tokens, Meta Pool promotes community involvement and participation in the governance of its network.




	

	
	
		
			
				Which of the following are decentralized exchanges built on NEAR Protocol? (multiple answers)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Uniswap
		
			
			Ref Finance
		
			
			Spin Finance
		
			
			Jump DeFi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





LiNEAR Protocol

$LiNEAR is a liquid staking solution provided by Linear Protocol, one of the leading projects in the NEAR ecosystem. It is part of Cornerstone, a meta-governance protocol built to support the growing NEAR ecosystem, offering $CORN tokens to users of their platforms.

With a relatively high APY of around 9%, LiNEAR has gained popularity among users looking for a lucrative liquid staking option on NEAR. The protocol has also recently supported Stake Wars III, a competition on NEAR that enables more validators to participate in the network as a block producer, further strengthening the ecosystem.

Linear Protocol has also announced its latest product, Phoenix Bonds, a yield generator farm available on Ref Finance for NEAR<>pNEAR liquidity providers. This will provide another opportunity for users to earn rewards while supporting the liquidity of NEAR and pNEAR. With its focus on building innovative and useful DeFi products, Linear Protocol is a project to watch in the NEAR ecosystem.
Stader Labs on NEAR

Stader Labs has brought its innovative liquid staking solution to NEAR Protocol, allowing users to earn staking rewards while also having access to their staked tokens through its token $NearX.

The platform has integrated with multiple wallets to make it easy for users to participate in liquid staking. Additionally, Stader Labs has taken security seriously and has undergone rigorous security audits from Halborn, BlockSec, and OSec, all of which have given the platform their stamp of approval.

Beyond NEAR Protocol, Stader Labs has a presence on several other chains, including Polying, Fantom, BNB Chain, and Hedera, providing liquid staking solutions to users across multiple ecosystems.

In the NEAR ecosystem specifically, the liquid staking token $NearX is available on both: NEAR protocol and Aurora Network, an EVM running over NEAR, giving users even more flexibility and options when it comes to staking their tokens.
Lending platforms
Burrow Cash

Decentralized finance has opened up a world of possibilities when it comes to lending and borrowing. Burrow Cash is a lending platform running on the NEAR Protocol that offers a decentralized way to lend and borrow tokens without the need for a centralized intermediary.

With Burrow Cash, users can lock their tokens and use them as collateral to request another token, allowing them to get access to new tokens without having to sell their existing positions. This is particularly useful for users who don't want to sell their tokens but still want to access other tokens or need liquidity.

Burrow Cash uses oracles to monitor token prices, ensuring that the user's collateral remains stable and that they receive a fair amount of tokens in exchange for their collateral. However, it's important to remember that if the value of the collateral drops, it could be at risk of being liquidated to pay back the debt.

In addition to lending and borrowing, Burrow Cash also offers liquidity pools, where users can supply their tokens for burrowing and earn rewards in exchange. These liquidity pools provide another way for users to earn a return on their tokens, and also provide liquidity to the platform, which helps ensure that there is always enough liquidity available for those who want to borrow or lend.

Overall, Burrow Cash is a decentralized lending platform that offers a simple, secure, and efficient way to lend and borrow tokens on the NEAR Protocol. By using oracles to monitor token prices and providing liquidity pools, Burrow Cash offers a reliable and convenient way for users to access new tokens, while also earning rewards on their existing tokens.




	

	
	
		
			
				Which of the following are liquid staking services on NEAR? (multiple answers)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Meta Pool
		
			
			LiNEAR Protocol
		
			
			Stader Labs
		
			
			Rocket Pool
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Launchpads
Meta Yield

Meta Yield is a crowdfunding platform that leverages liquid staking to provide financial support and exposure to web 3.0 projects built on the NEAR protocol. Backers commit and lock stNEAR to support projects and earn tokens from new projects launching on NEAR or receive an NFT drop. Projects only earn staking rewards of what backers commit, not their underlying crypto assets. Backers can recover 100% of their NEAR tokens at the end of the locking period, making Meta Yield a lossless staking rewards-based crowdfunding platform.

As a backer on the Meta Yield Launchpad, you get early access to the project you backed, project tokens valued higher than the market price, and the ability to recover your initial investment of NEAR tokens. To claim your project tokens and recover your tokens, the process is straightforward and involves a few simple steps.

Overall, Meta Yield offers a unique fundraising mechanism for web 3.0 projects on NEAR. It allows backers to support projects without losing their staked tokens and earn rewards from new projects launching on NEAR. If you become a backer, you can enjoy several benefits, such as early access to projects, higher valued project tokens, and the ability to recover your initial investment of NEAR tokens.

Meta Bonds, a secondary market for Meta Yield locked positions
Meta Bonds is a secondary market that allows backers of crowdfunding campaigns on Meta Yield to trade their locked positions in the form of bonds.

Meta Yield is a crowdfunding protocol that uses stNEAR, a staked token that generates yield by providing liquidity to the Meta Yield protocol. When backers support a project on Meta Yield, they receive two IOUs in the form of bonds: one for their original investment and the other for the project tokens they will receive in exchange for their rewards.

The first bond becomes available when the locking period ends, and the second bond can be claimed after the gradual release period. During this time, backers can invest their tokens by putting them into the market, which can be accessed by visiting the Meta Bonds website at metabondsmarket.app.

Meta Bonds enables backers to monetize their investments before the gradual release period ends. This creates an opportunity for backers to trade their bonds for other assets, such as other tokens or cryptocurrencies, while also providing liquidity to the market.

By creating a secondary market for locked positions, Meta Bonds provides liquidity and trading opportunities, while also creating a new avenue for monetization of investments.

NEAR Starter

NEAR Starter is a game-changing initiative that is empowering new projects to build and launch on NEAR Protocol. Conceived as a decentralized autonomous organization (DAO), NEAR Starter provides a comprehensive ecosystem of support for early-stage projects. The NEAR Starter Launchpad is an integral part of this ecosystem, allowing projects to make an Initial Decentralized Offering (IDO) and raise funds from the community.

In addition to its Launchpad, NEAR Starter has also made a name for itself by providing NFT collections that allow users to farm $NEARIA, the index token that is being used to exchange for projects. This innovative approach has helped to create a vibrant and engaged community around NEAR Starter, with users eagerly participating in the farming process.

The NEAR Starter site is built over the Aurora Network, which allows for low fees and seamless connectivity through Meta Mask. This ensures that users can easily and securely participate in the Launchpad and farming processes, without having to worry about excessive fees or complex technical requirements.

To showcase the power of its Launchpad, NEAR Starter recently launched the $NEARIA token through an IDO, with a target of 24 ETH to be collected. This successful launch is just the beginning for NEAR Starter, as it continues to support and incubate new projects on NEAR Protocol.

Yield aggregators
Pembrock Finance
​​

With NEAR Protocol providing a robust platform for DeFi applications, Pembrock stands out as a leveraged yield farming protocol that utilizes multiple strategies to farm tokens from NEAR Protocol.

What makes Pembrock unique is that it caters to two types of users: Lenders and Leveraged Yield farmers. Lenders can earn passive income by depositing their crypto into vaults, which fund liquidity pools. On the other hand, Leveraged Yield farmers can maximize their profits by opening a leveraged position. This means users can borrow additional funds from the platform, paying a small amount of interest on their profits.

Pembrock has a diverse range of pools available, including wNEAR, ETH, PEM, SWEAT, USDC.e, and more coins available on the NEAR ecosystem. Whether you're a beginner or an experienced investor, starting a position with Pembrock is simple. All you need to do is visit their site and look for farming or lending in their pools. With Pembrock's user-friendly interface, you can easily navigate through the pools and choose the one that best suits your investment strategy.

Overall, Pembrock is an excellent example of how DeFi is revolutionizing the traditional financial sector. By utilizing decentralized protocols, Pembrock provides users with an opportunity to earn passive income and maximize their profits through leveraged yield farming.

The end, for now…
DeFi on NEAR Protocol is a rapidly evolving ecosystem that offers various innovative solutions for users. With a strong focus on scalability, interoperability, and user experience, NEAR Protocol is attracting many developers and investors to build and invest in DeFi projects on the platform. As the ecosystem continues to grow and mature, it is expected to become a significant player in the broader DeFi landscape, offering unique features and advantages to its users.

This post presented several DeFi projects on the NEAR Protocol. Each of these projects has unique features and contributes to the growing DeFi ecosystem on NEAR. We know that sooner or later this article will have to be rewritten to include the new and amazing apps that will come.

See you soon!




	

	
	
		
			
				Which of the following are launchpads in the NEAR Ecosystem? (multiple answers)
			
		

		
					

		
			Please select 2 correct answers
			
			
			DuckStarter
		
			
			NEAR Starter
		
			
			Meta Yield
		
			
			Ethereum Launchpad
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







                
                        
                            qVote DeFi on NEAR 2023
                            
                         
 
                        Does this Guide help you to understand the state of DeFi on NEAR in 2023?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					Not sure what that even means
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					16 nLEARNs (FOUR votes)

### Visão geral da Meteor Wallet

A Meteor wallet (Carteira Meteoro) visa atingir vários objetivos principais, como facilitar a adoção em massa da web3 e tornar-se a principal carteira da NEAR. Ela busca promover uma concorrência saudável com outros projetos notáveis como MyNear, Sender, HERE e a carteira nativa da NEAR.

Introdução
A tecnologia Blockchain apresenta um mundo de oportunidades ilimitadas, incluindo autonomia financeira. No entanto, é inegavelmente desafiador para os recém-chegados navegar neste mundo complexo.

Por que é tão difícil? Principalmente porque a liberdade, que é a principal motivação para muitos de nós, vem acompanhada da responsabilidade. Essa responsabilidade abrange o gerenciamento de suas ações, perdas, investimentos, possíveis golpes, ativos e carteiras. Na web descentralizada, proteger sua criptomoeda depende exclusivamente de você, sem depender de mais ninguém.

No entanto, assumir essa responsabilidade não é a única barreira para entrar no mundo das criptomoedas. A complexidade de entender muitas Dapps (aplicações descentralizadas), tanto em termos de interfaces quanto de funcionalidades, é outro fator crucial a ser considerado.

A carteira Meteor visa atingir vários objetivos principais, como facilitar a adoção em massa da web3 e tornar-se a principal carteira da NEAR. Ela busca promover uma competição saudável com outros projetos notáveis como MyNear, Sender, HERE e a carteira nativa da NEAR.

Temos a sorte de fazer parte de um ecossistema excepcional, onde cada um dos projetos mencionados tem seus pontos fortes únicos. Então, o que diferencia a Meteor? Que pode ser melhor descrita como uma carteira all-in-one (multifuncional).

O termo “all-in-one” refere-se à extensa gama de recursos e funcionalidades que a Meteor reúne em uma carteira única e fácil de usar. Essas ferramentas ajudam os recém-chegados, que podem ter conhecimento limitado, a navegar na Web3 e no cenário blockchain. Nos parágrafos subsequentes, exploraremos alguns desses recursos e nos aprofundaremos nos objetivos da Meteor Wallet como um projeto Web3.
O que é a METEOR WALLET?

A Meteor Wallet é uma carteira abrangente e fácil de usar projetada para gerenciamento seguro e direto de sua criptomoeda, além de permitir o acesso a aplicativos descentralizados (dApps) dentro do ecossistema NEAR. Atualmente, a Meteor está disponível como uma carteira da web e uma extensão do navegador. Seu objetivo principal é se tornar a carteira preferida que simplifica a experiência da blockchain de NEAR para os usuários, tudo dentro de um poderoso aplicativo de carteira.
CARACTERÍSTICAS
Apresentar diariamente a web3 aos usuários comuns pode ser uma tarefa desafiadora. É por isso que, na Meteor, implementamos e planejamos lançar vários recursos para agilizar o processo de integração de todos os envolvidos.
CRIAÇÃO DE CARTEIRA de nomeação livre (Free named wallet)
A Meteor nos traz uma carteira de nomeação livre, um recurso intuitivo que pode ser configurado em menos de um minuto. Esta opção amigável é muito mais conveniente do que usar endereços alfanuméricos tradicionais que são difíceis de lembrar. Se você estiver interessado em criar sua própria carteira Meteor com um nome particular, siga este guia passo a passo cuidadosamente.

Clique aqui para começar.

Para começar, você precisará criar uma senha. Depois de configurar sua carteira, você terá a opção de personalizar seu perfil e, inclusive, conectá-la ao Near Social. Se você não estiver importando uma carteira existente, certifique-se de proteger sua nova frase inicial.

(Clique aqui para ver o guia sobre como importar uma carteira existente).

Adicionalmente, se você preferir usar um endereço tradicional em vez de uma carteira gratuita com nome por qualquer motivo, a Meteor também oferece a opção de criar uma conta implícita, conforme está ilustrado na imagem acima.




	

	
	
		
			
				O que uma Free Named Wallet permite que você faça?
			
		

		
					

		
			
			
			
			Criar um endereço personalizado e fácil de lembrar
		
			
			Alterar os caracteres alfanuméricos de um endereço a qualquer momento
		
			
			Envie ativos para endereços diferentes da NEAR nas blockchains
		
			
			Uma carteira de nomeação livre permite que você envie e receba mensagens de texto entre carteiras
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





funcionalidade de câmbio
A funcionalidade de câmbio permite que os usuários cambiem sem esforço uma criptomoeda por outra dentro da blockchain e, neste caso, sem sair da carteira. A Meteor é a primeira e única carteira, na Blockchain da Near, a incorporar um Swap Aggregator (agregador cambiário), permitindo que os usuários comparem e economizem facilmente com as taxas e slippages (deslizamento) mais baixas disponíveis.

Os recursos de câmbio na Meteor reforçam o conceito de uma carteira completa. Os usuários podem cambiar até 60 tokens (incluindo stablecoins) com provedores de câmbio respeitáveis, como Ref, Jumbo, Spin e muitos mais.

Para começar a explorar a funcionalidade de câmbio na Meteor, clique aqui para acessar o guia do usuário e saber como começar.



	

	
	
		
			
				A que se refere "Swapping"?
			
		

		
					

		
			
			
			
			Cambiar uma criptomoeda por outra
		
			
			Ganhar recompensas por negociar
		
			
			Transferir ativos de uma carteira para outra
		
			
			Swapping refere-se ao processo de saque de fundos de uma carteira
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







STAKING
A carteira Meteor oferece duas opções de Stake: Staking Líquido e Staking Padrão. Vamos explorar as diferenças entre esses dois mecanismos e como gerenciá-los:

O Staking Líquido é um recurso exclusivo que permite receber um token de recebimento como prova de propriedade de seu ativo no stake. Este token de recebimento é transferível, armazenável, negociável e pode ser usado em DeFi ou dapps compatíveis. Por outro lado, o Staking Padrão não oferece tokens de recebimento.

Com o Staking Padrão na Meteor, você pode ganhar recompensas de até ~10% APY (rendimento anual percentual composto) . Você pode comparar e selecionar entre mais de 90 validadores e pools e ver seus ganhos estimados. Você também pode optar por bloquear seu Stake por 7, 30 ou 90 dias.

Para usar o Staking Padrão na Meteor, basta seguir alguns passos simples na versão web ou na extensão. Você pode escolher entre vários validadores com APY estimado e recompensas em potencial.

Clique aqui para checar o Staking Padrão na Meteor.

Com o Staking Líquido na Meteor, nossa parceria com a Meta Pool permite que você receba tokens de recebimento stNEAR ao fazer staking. Esses tokens podem ser usados para participar de várias atividades DeFi na NEAR e na AURORA.

Clicque aqui para ler nosso guia sobre Staking Líquido e como fazê-lo.




	

	
	
		
			
				Qual é a principal vantagem de usar o Staking Líquido sobre o Staking Padrão na carteira Meteor?
			
		

		
					

		
			
			
			
			Não há desvantagens potenciais em usar o Staking Líquido em comparação com o Staking Padrão na carteira Meteor
		
			
			Você poderá participar de vários eventos dentro do ecossistema NEAR graças       ao token stNEAR de recebimento
		
			
			A principal vantagem de usar o Staking Líquido sobre o Staking Padrão na carteira Meteor é que você não recebe nenhuma recompensa ou APYs no Padrão
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFTs
Um NFT (Token Não Fungível) é um identificador digital distinto que não pode ser duplicado, substituído ou dividido. Ele é registrado em uma blockchain ( neste caso, NEAR) e usado para verificar a propriedade e autenticidade.

Enquanto a maioria das carteiras blockchain permite que você envie colecionáveis de uma carteira para outra, a Meteor se destaca quando se trata de NFTs. É a única carteira na NEAR que fornece atualizações em tempo real sobre o preço mínimo e o preço mínimo total de cada coleção que você possui. Além disso, a Meteor permite que você analise as características de seus NFTs e até mesmo definir um item colecionável como sua foto de perfil.

Ao clicar em uma coleção, você poderá visualizar todos os itens colecionáveis que ela contém, bem como o endereço do contrato de cada NFT, o preço mínimo individual e o preço mínimo total de toda a sua coleção NFT. Por favor, clique aqui para obter um guia extenso sobre como usar os recursos NFT na carteira Meteor.




	

	
	
		
			
				Você não pode enviar NFTs da Meteor para uma carteira NEAR nativa
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





EXPLORE
O novo recurso “Explore” na Carteira Meteor mantém você informado sobre os últimos desenvolvimentos na Meteor e no ecossistema NEAR, incluindo notícias relacionadas a dApps, projetos NFT e DeFi. Isso torna a Carteira Meteor não apenas uma ferramenta para gerenciar seus ativos, mas também um centro para aprender e se manter atualizado sobre o ecossistema.

Adicionalmente, na seção “Explore”, você pode participar dos Concursos da Meteor, onde pode ganhar recompensas por meio de uma abordagem de aprender a ganhar! Detalhes sobre como participar desses eventos, muitas vezes decorrentes de parcerias com outros projetos, estão disponíveis na mesma carteira.

A Carteira Meteor em breve apresentará uma seção de Recompensas! Fique atento a esta emocionante atualização.




	

	
	
		
			
				A seção Desafios (Challenges) permite que você ganhe recompensas por meio de:
			
		

		
					

		
			
			
			
			Staking seus NEAR tokens
		
			
			Participar de atividades/brindes DeFi organizados pela Meteor e seus parceiros
		
			
			Cambiar tokens
		
			
			Colecionar NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





CONFIGURAÇÕES E SEGURANÇA
Na Meteor, a segurança é de extrema importância. Recomendamos fortemente que você armazene sua frase inicial e a senha da carteira em um local seguro conhecido apenas por você.

Ao abrir a guia de configurações, você encontrará as seguintes opções:

Connected Apps (aplicativos conectados): Este recurso permite que você conecte sua carteira a Near Social. No futuro, planejamos adicionar opções para conectar sua carteira a redes sociais como Facebook, Twitter e Apple, para citar algumas.

Security and Recovery (segurança e recuperação): Aqui, você pode visualizar e extrair sua frase-semente, bem como gerenciar suas chaves privadas.

Change Password (alterar a senha): Se você acredita que a senha da sua carteira não é segura, você pode alterá-la a qualquer momento, mas sempre com cautela.

Remove Account (remover conta): Se, por qualquer motivo, você quiser remover sua conta, primeiro precisará digitar sua senha e depois confirmar a remoção. Embora alguns possam considerar essa opção desnecessária, acreditamos que ela é crucial para garantir a segurança e a liberdade do usuário. Lembre-se de que a remoção da conta é irreversível.:




	

	
	
		
			
				Atualmente, você pode conectar sua carteira Meteor a
			
		

		
					

		
			
			
			
			Facebook, Twitter, and Apple
		
			
			Você não pode vincular sua carteira Meteor a nenhuma rede social
		
			
			Near Social
		
			
			Com as plataformas reddit e cross-chain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planos futuros
A Meteor Wallet tem várias atualizações empolgantes em andamento, incluindo:

Meteor Support 2.0: Uma revisão do nosso sistema de suporte, que contará com a integração do Gleap e um sistema de suporte de ticket único para e-mail e dentro da carteira.

Meteor Explore 2.0: Com ainda mais dApps e jogos disponíveis!

Ledger Support: Planejado para o terceiro trimestre de 2023.

Social Loggins: além da Near Social, planejamos adicionar suporte para logins sociais via Gmail, Facebook, Twitter, Apple e muito mais.

iOS & Android Apps (aplicativos para iOS e Android): planejado para o final do segundo trimestre de 2023.

Suporte para Rich Media em NFTs: Colaboração com Harmonic Guild, com uma data de lançamento prevista ainda este ano.

### Desenvolvimento de contrato inteligente no Near usando Rust, 1ª Parte

No dia 16 de fevereiro de 2023 eu fiz um  workshop na Universidade de Waterloo sobre o desenvolvimento de contratos inteligentes em Near usando Rust. Gostei de montá-lo e achei que seria divertido também apresentar o conteúdo aqui como uma série de postagens no blog. Neste primeiro post, farei uma analogia para conectar o desenvolvimento da blockchain a um padrão usado em aplicativos Web normais, apresentarei o exemplo do contrato inteligente que usaremos ao longo desta série e discutirei alguns princípios gerais do desenvolvimento do contrato inteligente que são exclusivos para blockchain em relação a outros domínios de programação.
Um modelo mental para criar um aplicativo distribuído (dapp).
O objetivo desta seção é fazer uma analogia entre o desenvolvimento em cima de uma blockchain (aplicativos apoiados pela tecnologia blockchain são frequentemente chamados de “dapps” no meio) e uma tecnologia mais comum para aplicativos da web que você pode ter encontrado antes. Essa analogia pode ser útil ao pensar em como os usuários interagem com contratos inteligentes.

A ideia é que os dapps são muito semelhantes aos aplicativos da web baseados em uma “arquitetura sem servidor“. O termo “sem servidor” é um pouco enganador porque é claro que os servidores ainda estão envolvidos, mas a razão para o nome é que o hardware subjacente (ou seja, servidor) que executa o código é abstraído do desenvolvedor. Isso tem vantagens sobre outras infraestruturas de computação na nuvem em termos de custo e escalabilidade, porque você só paga pelos recursos que usa exatamente, em vez de pagar para executar uma VM (Máquina virtual) que pode ficar ociosa se o tráfego for baixo ou pode não responder se houver muito tráfego. Cada vez que um usuário interage com o aplicativo da web, uma nova instância da “função sem servidor” é invocada no back-end para atender à solicitação do usuário sem que o desenvolvedor precise pensar exatamente em qual hardware essa função está sendo executada.

Os Dapps abstraem o hardware de maneira semelhante. Um contrato inteligente é implantado na blockchain e executado nos nós (servidores) que formam a rede peer-to-peer dessa blockchain. Quando um usuário interage com o dapp, ele faz uma chamada para a blockchain (uma transação) para executar o contrato inteligente. Cada transação cria uma nova instância do contrato inteligente (no sentido de que não há um estado na memória que persista entre as transações), assim como nas funções sem servidor.

Abaixo está uma imagem tirada diretamente do site da Amazon Web Services (AWS) para Lambda (sua versão de uma oferta de computação sem servidor).

É fácil modificar esta imagem para ver como o fluxo de trabalho em um dapp é semelhante.

Outra semelhança entre computação sem servidor e contratos inteligentes é o fato de que cada transação tem um custo. No caso da AWS, a conta AWS do desenvolvedor é cobrada pelos recursos consumidos, enquanto que no caso da blockchain, quem assinou a transação é cobrado pela sua execução.

Com essa analogia como ponto de referência, vamos discutir o exemplo de desenvolvimento dapp que usaremos ao longo desta série.
Nosso exemplo: aplicativo de bate-papo baseado em blockchain.
O exemplo que usaremos ao longo desta série é um aplicativo de bate-papo baseado na blockchain. Este não é um exemplo do mundo real no sentido de que, (na minha opinião), não existe um bom argumento para se usar uma blockchain pública de bate-papo para fazer negócios. O simples fato de que todas as mensagens sejam completamente públicas e incluídas de forma irreversível em um registro permanente é uma clara desvantagem, em vez de um recurso. No entanto, a razão para escolher este exemplo é que ele ilustra vários conceitos importantes no desenvolvimento da dapp enquanto é logicamente fácil de seguir para qualquer um que tenha usado algo como Facebook Messenger, Telegram ou Signal.

O código para este exemplo está disponível no meu GitHub. O README desse repositório fornece algumas instruções para configurar um ambiente de desenvolvimento para interagir com o código e algumas ideias básicas de como usar o contrato. Esta série de postagens será um mergulho muito mais profundo no código e em como ele funciona.

Para fundamentar a discussão dos princípios do desenvolvimento de contratos inteligentes, aqui está uma visão geral de como funciona o contrato de bate-papo.

 	Cada indivíduo que deseja participar da rede de bate-papo implanta sua própria versão do contrato inteligente.
 	Cada instância do contrato mantém uma lista de contas com as que ele está relacionado (contatos, solicitações de contato pendentes, etc.). Além de armazenar as mensagens recebidas (e alguns metadados sobre essas mensagens).
 	Para enviar uma mensagem para outra pessoa, primeiro você deve tê-la como “contato”. Isso funciona como seria de esperar: Alice envia a Bob uma solicitação de contato, se Bob aceitar, Alice e Bob tornam-se contatos um do outro, caso contrário, eles não são contatos.
 	Cada instância do contrato possui um “proprietário” que pode enviar mensagens e enviar/aceitar solicitações de contato.

Princípios do desenvolvimento de contratos inteligentes.
Há três conceitos relacionados que quero enfatizar que são importantes para o desenvolvimento de contratos inteligentes, mas podem não aparecer no  típico desenvolvimento de software. Eles são:

 	Uma mentalidade adversária,
 	Economía,
 	Confirmar invariantes antes de fazer uma chamada entre contratos.

Uma mentalidade adversária
A primeira coisa importante a lembrar ao implantar em uma blockchain pública é que qualquer pessoa no mundo inteiro pode interagir com seu código. Se houver alguma ação sensível que seu contrato inteligente possa realizar (por exemplo, ao enviar mensagens no contrato de bate-papo, você certamente não gostaria que alguém se passasse por você), você deveria poder verificar, sem problemas, a autorização para que apenas contas autorizadas possam executar com êxito a ação (e é por isso que nosso contrato de bate-papo tem a característica "dono"). Se você tiver algum método que receba entradas (entrada de dados), deverá validá-lo antes de prosseguir para qualquer lógica de negócios, porque qualquer usuário aleatório pode enviar qualquer entrada que desejar. De fato, a ideia de uma mentalidade adversária vai ainda mais longe; um usuário pode não apenas enviar uma “entrada lixo”, mas também criar cuidadosamente uma entrada para acionar uma vulnerabilidade em seu código. A única maneira de evitar que isso aconteça é não ter tais vulnerabilidades em primeiro lugar.

Da mesma forma, a lógica do contrato inteligente geralmente depende de algum protocolo para coordenar diferentes componentes juntos (por exemplo, o protocolo para adicionar contatos em nosso contrato de bate-papo). Um usuário pode intervir neste protocolo? O que acontece se eles não atuarem corretamente? Estas são perguntas que você deve responder ao desenvolver um contrato inteligente porque os hackers irão tentar explorar seu contrato.

Encurtando o assunto, você deve sempre assumir que qualquer entrada externa é altamente “byzantine” e verificar explicitamente o contrário antes de prosseguir. Você deve praticar a observação de quais suposições está fazendo e sempre pensar “como eu poderia quebrar essa suposição?” sempre que você perceber que está fazendo uma.
Economía
A economia de um aplicativo da Web típico é bastante simples. Você precisa gerar rentabilidade suficiente para cobrir o custo de hospedagem de qualquer servidor que contenha o código e os dados que seu aplicativo usa. A renda que você precisa gerar pode vir de várias fontes, mas as mais comuns são os rendimentos de anúncios e assinaturas pagas de usuários.

Para a blockchain a situação é um pouco mais complicada porque cada transação precisa ser paga de forma independente. Os produtos blockchain mais recentes procuram simplificar essa história, por exemplo Aurora+ fornece algo como uma “assinatura blockchain” que permite uma série de transações gratuitamente. Mas até que isso se torne padrão no espaço blockchain, ainda é importante responder à pergunta “quem está pagando por isso?

Muitas vezes é o usuário quem paga cada transação porque o pagamento está vinculado à conta de assinatura (ou seja, o pagamento está vinculado à identidade/autorização). Um modelo alternativo é usar “meta-transações” (transações dentro de transações) para que o pagamento seja feito pelo “assinante externo” enquanto a autorização é baseada no “assinante interno”. Por exemplo, é assim que Aurora+ funciona. Infelizmente, dado que esta não é a forma padrão como as transações blockchain operam, requer um trabalho extra por parte do desenvolvedor para que isso aconteça.

Para o nosso exemplo de aplicativo de bate-papo, seguiremos o caminho de menor resistência e cada usuário terá que pagar pelos custos incorridos com seu uso. Depois de tomar essa decisão, precisamos revisar quais possíveis custos podem haver e garantir que eles sejam cobertos adequadamente. Por exemplo, no Near, o pagamento do armazenamento é feito por “storage staking“. Essencialmente, isso significa que cada conta tem parte de seu saldo bloqueado, dependendo de quanto armazenamento está usando. Isso é relevante em nosso contrato de bate-papo porque armazena mensagens recebidas de outros usuários, portanto, precisamos garantir que esses outros usuários estejam cobrindo o custo de armazenamento, anexando um depósito suficiente à sua mensagem. Da mesma forma, as solicitações de contato criam uma entrada no armazenamento, portanto, também devem vir com um depósito. Se não aplicássemos esses requisitos de depósito, os usuários poderiam efetivamente roubar dinheiro uns dos outros enviando muitas mensagens e bloqueando todo o saldo da vítima (observe como isso está relacionado à mentalidade adversária acima).

Em resumo, ao projetar um dapp é sempre importante pensar em quais custos estarão envolvidos e como eles serão pagos, seja adicionando verificadores para depósitos ou usando meta-transações.
Assegure as invariantes antes de fazer chamadas entre contratos
Este último ponto é sutil. Em um aplicativo típico, todo o código está vinculado ao mesmo binário. Quando você chama uma função em uma biblioteca, isso geralmente não aciona nenhuma comunicação, mas apenas adiciona um novo quadro no stack e executa algum código de outra parte do binário. Em uma configuração de blockchain, as coisas são um pouco diferentes.

Fazer uma chamada para outro contrato é mais como fazer uma chamada para um processo totalmente diferente do que chamar uma biblioteca. Mais uma vez, devemos aplicar uma mentalidade de adversário e perceber que não temos ideia do que esse outro processo pode estar fazendo; na verdade, pode estar tentando fazer algo propositalmente malicioso. Um vetor de ataque comum é fazer o outro processo chamar de volta nosso contrato e explorá-lo porque nosso contrato não esperava uma nova chamada enquanto esperava por uma resposta à chamada iniciada. Isto é conhecido como “ataque de reentrância” e foi a fonte de um dos hacks mais famosos do Ethereum, que deu como resultado a criação do “Ethereum Classic” . (o Ethereum Classic rejeitou o “hard fork” sendo a Resposta da Fundação Ethereum ao hack).

Em Near este problema é ainda mais pronunciado porque existe a questão adicional da atomicidade. Na Ethereum Virtual Machine (EVM), cada transação é “atômica” no sentido de que todas as ações resultantes da transação são confirmadas no estado da blockchain ou nenhuma delas é (toda a transação é “revertida”). Isso significa que um ataque de reentrância pode ser frustrado usando uma reversão; tudo o que aconteceu será desfeito, mantendo o contrato seguro. Esse padrão está incluído no exemplo Mutex na documentaçao oficial da Solidity. No entanto, no tempo de execução do Near, a execução dos contratos é independente uma da outra; eles não são atômicos. Portanto, se uma transação fizer com que o contrato A chame o contrato B e B encontrar um erro, as alterações de estado que ocorreram no contrato A permanecerão.

Isso tem sido um monte de história e teoria, mas qual é a lição prática? O ponto é que você deve garantir que seu contrato esteja em “bom estado” quando fizer uma chamada para outro contrato. Ou seja, se houver invariantes nas quais a lógica do seu contrato se baseia, elas devem estar corretas no momento em que a chamada é feita. Como um simples exemplo, suponha que temos um contrato com uma função de transferência. A invariante a ser mantida é que os tokens não são criados ou destruídos em uma transferência. Se por algum motivo fosse necessário fazer uma chamada para outro contrato durante a transferência, seria incorreto debitar uma conta e depois fazer a chamada sem creditar a outra primeiro. Isso ocorre porque a invariante sobre os tokens não serem destruídos seria quebrada quando a chamada externa fosse feita e isso poderia ser explorável. Um exemplo nesse sentido também está incluído na  Documentação do Near.
Resumo
Para finalizar, nesta postagem do blog, estamos apresentando uma nova série de postagens que apresentam uma introdução ao desenvolvimento de contratos inteligentes no Near usando Rust. Aqui, discutimos o exemplo de contrato de bate-papo que usaremos ao longo da série, bem como alguns princípios gerais a serem lembrados ao desenvolver aplicativos baseados em blockchain. No próximo post vamos nos aprofundar mais no código para discutir os detalhes técnicos de como o contrato é implementado. Isso servirá como um exemplo do Rust SDK de Near, ilustrando conceitos que se aplicarão a todos os tipos de contratos do mundo real que você queira escrever.

Se você está gostando desta série de postagens no blog, por favor entre en contato conosco na consultoria Type-Driven Type-Driven consulting. Temos o prazer de fornecer serviços de desenvolvimento de software para dapps, bem como materiais de treinamento para seus próprios engenheiros.

—--------------

2211 words

### NameSky Closed Beta

We are excited to share with you that NameSky, project from LNC Barrel  is going to hold private Beta launch soon.

So we are inviting LNC Beta testers superstars!

If selected you will be provided with 2 $NEAR to spend during private beta.

Please fill the form bellow.

### Smart Contract Development on Near using Rust Part 3

Smart Contract Development on Near using Rust Part 3



This is the third part in a series of posts about building a chat app with Rust on the Near blockchain. You can find the previous posts in the series here and here.

In this post we will focus on the off-chain parts of the code. We’ll discuss the need for “indexers” and walk through some parts of the implementation of the indexer in this example. You can find the complete repository with all the code we’ll discuss today on my GitHub.
Indexers, what they are and why we need them
In the blockchain space an indexer is a service which consumes raw data from a source (typically a co-located full-node instance for that blockchain) and parses it into a format which is more useful for a specific application. For example, in the case of our chat app, the indexer consumes a stream of Near blocks and produces a stream of events (e.g. received messages and contact requests).

Indexers are important because the databases used in operating the blockchain itself are generally not optimized to perform the kinds of queries applications care about. For example, getting a user’s balance for an ERC-20 token on Ethereum is usually done by running the query through the EVM because that is the only way the information is available from a typical Ethereum node. This is an extermely expensive operation compared with looking up an entry in a traditional relational database. Therefore a simple optimization to any application that needs fast access to ERC-20 balances would be to run an indexer on the raw Ethereum data which populates a traditional database with the balances it cares about. Then the application would use this database as its source for the balances instead of an Ethereum node directly. This is how the Etherscan block explorer works under the hood; Etherscan runs an indexer to populate a database which is then used to populate the fields in the web pages Etherscan serves.

Indexers are not just important for Ethereum, any high performance dapp on any blockchain will need to include an indexer somewhere in its architecture. The example chat app we have been discussing on Near is no exception, so let’s dive into how the indexer is implemented.
Getting the raw data
Indexers only process raw blockchain data into a format the associated application can use; they do not generate the data in the first place. Therefore, the first question we need to answer when creating an indexer is: where does the blockchain data come from?

Near provides a few different data sources, as described below.
Running a nearcore node
The best source of data (in terms of decentralization and security) for any blockchain is the peer-to-peer network of the blockchain itself. To access this source of data you must run a node that understands the blockchain’s protocol. In the case of Near, the node implementation is called nearcore. Its source code is open on GitHub. There is documentation available on how to run your own nearcore node. The main barrier to entry here is the amount of disk space required for this; it is recommended you have 1 TB of dedicated storage for your node and it takes a while for it to synchronize with the chain as a result of needing to download all that data.

Once you have a nearcore node setup, Near provides a convenient indexer framework in Rust that can be used to build indexers with nearcore as a data source. For a real project this would be the best way to create an indexer. However, our example is just a demo, so we don’t want to spend hours of time downloading chain data to a dedicated 1TB server. Fortunately there are other options.
Near data lake
To make it easier for developers to get their projects started, Near created the data lake framework as an alternative source of data for indexers to use. The data lake framework is built on top of the indexer framework mentioned above, using a nearcore node as the source of data. The indexer feeding the data lake is trivial in the sense that it is not processing the data for a specific application, it is just passing the data long to be stored in AWS S3 storage. However, this enables developers to get access to this data using their own AWS account and then build their own (non-trivial) indexers using this S3 storage as the data source.

The advantage of this for developers is that this method is much faster to get working. The disadvantage, though, is that the data is coming from a centralized source and is therefore theoretically easier to corrupt than using the peer-to-peer network directly.

Accessing the data lake requires you to pay for the AWS resources you use in delivering that data to you. Once again, for the purposes of the chat app example, I didn’t want to make people sign up for AWS and spend money to run the indexer. Therefore, I chose the final data source option.
Public RPC nodes
The final way to access blockchain data if you are not running your own node or accessing someone else’s pre-built data store is to use someone else’s nodes. RPC nodes are nodes in the blockchain network that are meant to serve the requests of users. Every blockchain has RPC node providers (some free, some paid). A list of the RPC providers for Near can be found here.

This is the least efficient way to access blockchain data because it takes multiple RPC requests to get the data typical indexers use. Each RPC request incurs network latency, thus making the indexer sluggish to respond to events happening on-chain. The only advantage of this approach is that it is free to setup a demo as long as there is a free RPC provider for the chain (which is the case with Near). Therefore, this is the source of data the indexer in our example uses.

All that said, the indexer itself does not care where its data comes from. Therefore even though our example is using the worst data source, it’s worth exploring its implementation because the concepts this indexer uses are the same as those in an indexer that is built using Near’s data lake or node-based indexer frameworks.
Indexer implementation
Our indexer is built as a tokio app in Rust. Tokio is a Rust framework for writing high-performance applications where I/O operations are the main bottleneck. Our indexer is such an application because the actual computation it performs is extremely fast compared to the time it takes to request data from the RPC nodes. The main features of tokio are that it uses non-blocking asynchronous pimitives and has multithreading built-in to enable parallel execution. This is in addition to it being in Rust, so it naturally has the concurrency safe and memory safe guarantees Rust provides.

If tokio is the stage on which our application is set, then what follows are the actors in the play (pun intended; this application follows the actor model, but I choose to do it in tokio directly instead of using a library like actix because I think tokio’s channels provide stronger typing than the generic messages used in most actor frameworks).

The indexer has four main roles: the manager, the block downloader, the chunk downloader, and the receipt handler.
The manager
The manager process supervises the whole indexer. It is responsible for delegating work to the other processes, and telling them to shutdown when the program is being closed (e.g. in the case of an error being encountered). For example, the manager handles the load-balancing of the chunk downloaders by cycling through them when assigning a chunk to download.
The block downloader
As the name implies, the purpose of the block downloader process is to download blocks. It periodically polls the Near RPC to check if there are any new blocks and if there are then downloads them and sends them to the manager. If we were not using the RPC as our data source then this process would be replaced with a connection to a Near node or data lake instead.
The chunk downloader(s)
On Near, blocks do not contain the data about transactions; chunks do. Blocks only give information about what new chunks are available. The reason for this is because of Near’s sharding (you can read more about that here). Therefore, we need separate processes to download the chunk data for each block. The chunk downloaders fulfil this role. Our indexer has multiple chunk downloader instances to enable downloading the chunks in parallel.

If we were not using the RPC as our data source then depending on how the data is factored in the data source we were using these processes might not need to exist, (for example near-indexer-framework includes all block and chunk data into a single message). But for our case, since we are using the RPC, these processes are necessary.
The receipt handler
Chunks contain “receipts” which are created when a transaction is processed. When the manager receives a new chunk from a chunk downloader, it sends all the receipts to the receipt handler process (we could have multiple receipt handler instances to process receipts in parallel just like how we have multiple chunk downloaders, but the receipt processing is fast enough that I didn’t think this added much of a performance improvement). This process filters down the receipts to only the ones we care about, then downloads the execution outcome for the receipts, and finally processes the events from those outcomes. In the case of this example, we simply write the events to a file (for a live demo you can watch the file with something like the tail -f Unix command to see the events come in), but you can imagine a production implementation could forward these events as push notifications to a mobile version of the app.
Remarks
You may notice throughout the indexer code that there is some complexity around sending chunks/receipts with the block hash after the block which included those chunks. This is a quirk of the Near RPC where it wants to know you are aware of later blocks to serve the execution outcome. Again this would be handled much smoother if using a better data source.

It is intentional that there are no panics in any of the actor functions. When they encounter an error they log it and send a shutdown message to the manager (and the manager sends it out to all other actors). This is important because panicking in a multithreaded application can cause unexpected behaviour (in general tokio is pretty good about bringing down the whole app gracefully, but it’s still better to code defensively against it).
Conclusion
In this post we discussed why indexers are important for real-world dapps and looked at some of the details of the example indexer implemented for the chat dapp. As with the previous post, there are exercises in the indexer code included in comments tagged as EXERCISE. I encourage you to try out these exercises if you want some hands-on experience with the code-base.



About the Series
This is the final post in this series. In Part 1 we took at look at general principles of smart contract development and how they apply to an example contract for a chat dapp. In Part 2 we did a deep dive into how to use near-sdk to write smart contracts for Near in Rust. Finally, this post discussed how indexers are needed to integrate the blockchain data with off-chain components of our app.

One final piece of the code I did not cover is the integration testing. The integration testing uses the near-workspaces library to simulate the blockchain locally and uses the same async Rust style as the indexer. Even though integration tests are not especially flashy or interesting, they are important to ensure your contract works correctly. I encourage you to take a look at the integration tests for the messenger contract and try the exercise there to get some hands-on experience in that area too.

If you have enjoyed this series of blog posts, please get in touch with us at Type-Driven consulting. We are happy to provide software development services for dapps, as well as training materials for your own engineers.

### Meta Pool, Module 4 - Participating in Meta Pool’s governance

Meta Pool governance
The governance is the process in which Meta Pool looks to give back the project to the community. In this way the $META token holders are the ones who will have the option to manage the protocol on-chain through a DAO.

Mounting a real on-chain, decentralized, governance is a work under progress on the whole Web 3 ecosystem. As well, this module covers how Meta Pool is handling this situation.
Meta Pool DAO
Meta Pool will introduce $META tokens for DAO governance. The intent is for the $META token to be distributed to protocol builders and project contributors in a fully transparent way. 

One thing to note is that before the on-chain governance voting platform is ready for $META token holders, core protocol contributors will make critical decisions based on the project vision and informal input from the community on Discord. 

This is intentional, as we think it’s important to keep governance nimble in the early days of the protocol.

The main purposes of introducing the governance token: Incentivize liquidity. To bootstrap initial liquidity and accelerate the growth of Meta Pool platform.

Form DAO. $META token represents the ownership of Meta Pool DAO. The DAO is going to be responsible for updating program parameters, product roadmap and other strategic decisions. Capitalize the treasury to allow for strategic partnership funding or creating reserve funds.
$META tokenomics
Max supply: 1,000,000,000 $META

 	Founders: 30%

For the work of creating, launching, promoting and maintaining the protocol. Founders’ tokens have a 1 year lockup followed by a 2-year linear release. (3 years total).

 	Team & Advisors: 2.6%

In order to create a world class product, we need the best of the NEAR Ecosystem working and collaborating in the protocol. They will be committing long term to the protocol. Advisors’ tokens have a 2 year lockup followed by 1 year linear release. (3 years total).

 	Investors: 10%

Partnering with leading investors and institutions will be key to our global reach and also better understanding of the macro conditions of the crypto markets. We know what we don’t know, that is why senior advisors and access to their network will be critical for our growth. Investors’ tokens have a 1 and 2 year lockup followed by 1 year linear release. (2 and 3 years total).

 	Allocation for venture rounds:

● 4% Seed round

● 6% A round

 	Community & Treasury: 57.40%




	

	
	
		
			
				The $META token receive monthly airdrops
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Earn voting power on Meta Pool - Meta Vote
Vote is a community-based Voting Platform for:

 	Projects Fundraising on Launchpad, and
 	Supporting Validators
 	Supporting ambassador community campaigns and general governance proposals.

It is a platform designed to acquire Voting Power to support projects in Launchpad governance proposals and to delegate NEAR Tokens to validators in Validators section.
How to use Meta Vote?
You can access Vote directly from its link https://www.metapool.app/vote or:

 	From Launchpad by clicking on projects you want to vote: https://www.metapool.app/yield
 	From Validators section by clicking on the Validator you want to vote https://www.metapool.app/stakevote

Connect your wallet on Vote

In the Vote site: metapool.app/vote,  click on My Power section and link your NEAR wallet so that you can have full access to your assets. +Connect Wallet button.

 


Vote works with 3 simple steps:

 	Lock your $META tokens
 	Get voting power
 	Vote on projects in Launchpad, Governance proposals or Vote supporting Validators.

Lock your $Meta Tokens
In order to be able to vote for projects or Validators, you must obtain Voting Power and it is very simple. The way to get it is by locking your $META tokens.

If you don’t already have $META – you’ll need some! See below "How do I get $META Tokens?"

 	Click on the button title + Add Voting Power



 	Enter the amount of $META tokens you want to lock.
 	Select the period you wish to “unlock” your tokens with the slider. This is the Unlock time for your $META tokens.

The minimum amount of time your $META can be locked for is 30 days, and up to 300 days. The longer your $META is locked, the more voting power you have for each $META token locked.

After selecting your lock period, click on the lock button and approve the transaction through NEAR wallet – and then you are ready to vote!

 	Use voting power to vote for desired projects or support Validators.


 	Go back to metapool.app/vote/dashboard, refresh the page, and see the voting power!


 	Launchpad: You can then use the vote now button on any project and back them with your tokens. Additionally, you don’t have to spend all your tokens on one project, you can back multiple!

 	Validators: You can now vote directly the validator of your choice. Just click on the “vote” button

of the validator of your choice, or select the validator you want to support, read all information regarding to this validator and vote for it. You can support multiple validators, not just one.



Voting Power acquisition formula for your $META tokens
MULTIPLIER = 1 + (4 * (days - MIN_LOCK_DAYS) / (MAX_LOCK_DAYS - MIN_LOCK_DAYS))

 	MIN_LOCK_DAYS=30
 	MAX_LOCK_DAYS=300

Example

How do I get $META tokens?
In Vote select My Power section, click “Get More $META”

You can choose between MEXC Global tools and Ref Finance to swap NEAR tokens or other NEAR native assets for $META tokens.



 	https://app.ref.finance/#meta-pool.near|meta-token.near

Lock stages
Lock Period
The Lock stage is the one that allows you to vote on projects. $META tokens are locked and users can vote, unvote for projects or validators at any time. There is no time limit for this stage. Voting power will be available as long as $META tokens are locked.

Unlock Period
Once the project voting campaign is over or the user wants to end the support to a validator, can start the Unlock period. By pressing the "Start Unlock" button in the desired lock position, the unlock time begins to run, which corresponds to the time set by adding voting powers.

It should be noted that an unlock stage can only be started if there is enough voting power available. If there is voting power in use and it is not enough to unlock a full position, it will not be able to start the unlock period.

Important: the Unlock period does not start automatically, it must be manually started by the user.
Withdraw of $META tokens
Once the Unlock time is over, $META tokens can be withdraw.

Important: the withdrawal of $META tokens must be done manually by the user.




	

	
	
		
			
				Locking your tokens in Meta Vote have a fee of 3.5%
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Validators - Use your voting power to support best validators
Validators is a community-based platform for the selection of Validators to assign by vote 15% of the NEAR tokens staked in Meta Pool.

Meta Pool gives governance power to $META holders as they are the ones voting in the Validators.
Meta Staking Vote - Use your voting power to support best validators
Meta Staking Vote is a community-based platform for the selection of Validators to assign by vote 15% of the NEAR tokens staked in Meta Pool.

Meta Pool gives governance power to $META holders as they are the ones voting in the Meta Staking Vote.
How to use Validators?
Access Validators section directly from its link https://www.metapool.app/vote
Connect the NEAR wallet on Validators
In the Validators section: https://www.metapool.app/vote, link the NEAR wallet. Click Connect Wallet button, choose a wallet and connect.


Validators works with 4 simple steps:

 	Lock $META tokens in Vote.
 	Get voting power.
 	Vote for the validators to support in Validators section.
 	See a dashboard of votes and NEAR stake assignments.

How it works

 	Meta Pool users, stake their NEAR tokens, receiving stNEAR in return.
 	Those staked Nears are distributed to the Validator nodes. This helps decentralize and secure NEAR Protocol. The more users stake in the Meta Pool, the more is distributed among the validator nodes.
 	The validators produce blocks and get rewards for it, this increases the value of stNEAR in NEAR tokens.
 	Of the total NEAR tokens staked, Validators delegates 15% to the Validators by vote of the $META holders (supporters).

This will be an permanent voting and according to the results, Validators allocates 1% of the total amount staked in the Meta Pool every ̴4 epochs.

$META token Holders
The voting consists of 2 steps:

 	Validator Choice: Go to: https://www.metapool.app/stakevote The complete list of validators tracked by Validators section.


For more information, click on the name of the validators and will be redirected to the validator page, with detailed information.

Once the Validator to support and vote for has been analyzed and chosen, vote. Select it to be voted on the list (vote button), or on the page of the validator (vote this validator button).

 	Validator vote: Connect the NEAR wallet. Select the validator to be vote on the list (vote button), or on the page of the validator (vote this validator button) and assign the voting power to it.

In this link is explained how to obtain voting power.

Validator voting is an ongoing campaign, so votes counts for each campaign as long as it runs.

Vote for any number of validators with no Voting Power allocation limit. The votes can be changed at any time.

This is how vote for Validators in Validators section works, simply, safely and getting 100% of $META tokens back.
Delegation
15% of the Meta Pool TVL provided by users staking will be delegated by vote of $Meta holders.

If the TVL increases, the distributed amount increases. It is very important to promote the Meta Pool Liquid Staking Pool for investors, for which we require the support of validators and the community.

The delegation campaign is continuous, and 1% of the total staked in Meta Pool is assigned every 4 epochs.




	

	
	
		
			
				Once voted for a validator you have to wait 60 epochs to assign your voting to another validator.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Platform - General data


 	

 	Validators

This is the number of validators approved by the Meta Pool to be voted on according to the validator selection criteria.

 	Epoch progress

Indicates the remaining time of the block validation / production epoch.

An epoch lasts approximately 13 hours. (An epoch last 43.200 blocks and a block last approx. 1.1 seconds).

 	NEAR staked @ Meta Pool

TVL (Total Value Locked) to be delegated to validators. 85% by performance and 15% by votes in Validators section.

This amount corresponds to the NEAR tokens staked in Meta Pool.

The amount is available in: www.metapool.app/stake?token=near - Total stNEAR Tokens multiplied by stNEAR Price.

 	Near to be assigned by votes

15% of the TVL to be assigned by votes. How much corresponds to each validator individually can be seen in Assigned by votes.

 	Available Voting Power

Voting power available to be used to vote for validators. If Voting Power is not available, it can be purchased at: https://www.metapool.app/vote (by clicking on My Power section and Add Voting Power).

Important: $META tokens are required in order to get voting power. Get $META at MEXC Global and Ref Finance

 	In Use / Total

Voting power in use and the total that the user has.

In Use can be for having already voted for validators or for voting projects in Launchpad.

Validators voting details

 	Name
Validator name.To know more about a particular validator, just click on the name and it will be redirected to the individual page of the selected validator.

 	APY

Annual Percentage Yield granted by each validator. It depends on validators performance and fees.

 	Votes

Number of votes given to each validator and the corresponding percentage of the total. Voting is continuous and indicates the percentage of allocation tendency to be delegated.

 	Assigned by votes

Amount of NEAR tokens corresponding to be assigned to each validator according to the 15% to be assigned by votes. Important: only 1% will be assigned for every approximately 4 epochs.

This amount is the tendency to be reached for the assigned to each validator according to the votes.

The total TVL to be assigned by votes is distributed approximately every 15 groups of 4 epochs.

 	Assigned Total

This amount corresponds to the amount to be assigned by performance (85%) and by votes (15%). It is the total tendency to be reached by the validator.

 	Meta Pool Staked

NEAR tokens currently delegated by Meta Pool to each validator.




	

	
	
		
			
				The voting power can be used in Validators or in Launchpad voting campaigns.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!

### Système d'exploitation de la chaîne de blocs du protocole NEAR

En mars 2023, NEAR Protocol a lancé le système d'exploitation de la chaîne de blocs (BOS) dans le but de créer la passerelle idéale du Web ouvert(Open Web). L’idée est de combler de manière transparente le fossé entre web2 et web3. Cet article vous en dira plus sur BOS et vous expliquera son fonctionnement.

Qu'est-ce que le Open Web?
"Open Web" est un terme utilisé pour décrire Internet lorsqu'il s'agissait d'une ressource publique mondiale non contrôlée par des superviseurs. Alors, pourquoi ce Open Web est-il nécessaire ?

 	Cela est nécessaire pour la liberté dans la communication et l'expression
 	L'Open Web est l'internet des personnes pour les personnes. Il permet aux individus de se mobiliser et de contribuer positivement à la société.

Dès le départ, la vision de NEAR était d'aider à faciliter la création du Open Web. Fondamentalement, l'Open Web doit être décentralisé, NEAR doit également créer une blockchain de couche 1 évolutive qui fait abstraction de la complexité. NEAR est-il capable de faire cela? Nous allons voir.

 	NEAR a un modèle de compte flexible et lisible par l'homme.
 	Le mécanisme de partitionnement de Nightshade rend NEAR hautement évolutif.
 	NEAR fournit également des outils puissants pour aider les développeurs à développer des protocoles.

Après avoir compris les bases, NEAR devait maintenant créer une pile web3 qui aiderait à rationaliser l'intégration d'Open Web pour les utilisateurs et les développeurs (devs).
Comment BOS peut-il atteindre le Web ouvert ?
Pensez à ce que fait un système d'exploitation ou "OS". Le système d'exploitation permet aux utilisateurs d'interagir avec des machines sophistiquées sans entrer dans une complexité inutile. Garder l'abstraction et la complexité en arrière-plan est essentiel pour l'adoption massive de la technologie.

Nous allons maintenant étendre cette logique au monde du web3. Selon le co-fondateur de Protocole NEAR Illia Polushkin, BOS est une couche générique pour explorer et découvrir les produits Web 3. De plus, BOS prendra en charge Near Protocol et les machines virtuelles Ethereum lors du lancement. Imaginez que vous créez une nouvelle application DeFi sur Ethereum et que vous obteniez des utilisateurs de NEAR via BOS.
Créer une interface composable
Avant d'aller plus loin, il convient de comprendre ce qu'est un frontend. Un frontend est la façon dont un utilisateur interagit avec l'application. Lorsqu'il s'agit de dApps, il est nécessaire de créer une application composable et décentralisée. L'éthique même de web3 est la décentralisation. Dans ce cas, pourquoi continuons-nous à utiliser des services centralisés pour accéder à ces services ? Faire confiance à ces intermédiaires pose plusieurs problèmes de sécurité.

BOS permet d'ajouter des interfaces composables à la pile technologique et d'intégrer facilement les utilisateurs à web3. En ce qui concerne le potentiel de BOS en tant qu’interface, Illia Polusukhin a déclaré : "L’interface décentralisé composable est un outil qui permet d'améliorer la sécurité des utilisateurs :

"Les interfaces décentralisés composables peuvent fonctionner avec n'importe quel back-end Web2 ou Web3 et n'importe quel portefeuille. À l'avenir, nous proposerons [l'utilisation] de portefeuilles d'une chaîne pour interagir avec une autre par le biais d'une interface transparente."
3 piliers de BOS
BOS repose sur trois piliers :

 	Passerelles
 	Composants
 	Chaînes de blocs

Passerelles
Les passerelles sont conçues pour mettre à la disposition de tous des interfaces décentralisées exécutés localement. Une passerelle comprend une machine virtuelle spécialement conçue pour charger et exécuter des interfaces pour des protocoles construits sur Ethereum, des L2 et d'autres couches 1 comme NEAR. Le code de ces frontends est stocké sur la blockchain NEAR.




	

	
	
		
			
				Quel est le but du système d'exploitation NEAR Protocol Blockchain ? Choisissez 2 bonnes réponses
			
		

		
					

		
			Please select 2 correct answers
			
			
			Créer un Internet décentralisé contrôlé par personne
		
			
			Combler le fossé entre Web2 et Web3
		
			
			Pour construire une blockchain de couche 2 évolutive
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Composant
Les composants sont des interfaces pour les protocoles de couche applicative en chaîne tels que Lido, Uniswap et Aave. Les développeurs peuvent visualiser le code de ces applications dans une passerelle similaire à la visualisation d'un contrat intelligent dans Etherscan. En outre, ils peuvent forker ces applications et déployer leurs propres versions ou même composer des composants.
Chaîne de blocs
Les composants peuvent appeler des fonctions sur n'importe quelle blockchain. Actuellement, toutes les chaînes EVM ou L2 et NEAR sont prises en charge. Par ailleurs,code source pour le frontend (application), il est conservé à NEAR en raison de sa capacité à stocker HTML/CSS/JS à moindre coût.
Avis sur Frontend NEAR BOS
Voyons comment le front-end fonctionne en action. Veuillez accéder à la pagealpha.near.org

L'interface connecte les utilisateurs à toutes les différentes possibilités Web3 de l'écosystème. N'importe qui dans l'écosystème Open Web peut créer sa propre interface, compatible avec la blockchain de son choix. Jouons avec l'interface et voyons comment cela fonctionne.

Lorsque nous défilons vers le haut, survolez "Discover" et cliquez sur "Components".

Les composants sont de petites applications qui peuvent résoudre un problème spécifique. Actuellement, nous avons plusieurs composants intégrés que nous pouvons utiliser pour créer le frontend. Voici quelques-uns des composants intégrés disponibles.




	

	
	
		
			
				Quelle est la fonction de la passerelle sur BOS ?
			
		

		
					

		
			
			
			
			Faire en sorte que l'interface centralisée fonctionne localement pour tous
		
			
			Fournir des outils de pointe pour aider les créateurs à créer des protocoles
		
			
			Pour enregistrer le code source de l'interface dans NEAR
		
			
			Pour exécuter le frontend sur des protocoles construits sur Ethereum, la couche 2 et d'autres couches 1
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
Les widgets sont l'unité minimale du frontend. Il vous permet d'inclure un composant existant dans votre code, ce qui vous permet de créer des applications complexes en composant des composants.

Code:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Sortie:

Téléchargeur d'images
Le téléchargeur d'images permet aux utilisateurs de télécharger des images directement sur le système de fichiers interplanétaire (IPFS).

Code:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Sortie:

Nous pouvons utiliser le bouton pour télécharger l'image

Des dossiers
Téléchargez des images avec la prise en charge du glisser-déposer

Code:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Sortie:

Réduction
Composant intégré qui permet le rendu Markdown.

Code:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);


OverlayTrigger
Le widget OverlayTrigger permet aux développeurs d'afficher du texte ou une icône de superposition lorsque la souris survole un élément spécifique.

Code:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Sortie:

DEFILEMENT infini
Ce composant nous permet de créer des pages ou des éléments simples et légers à défilement infini en prenant en charge à la fois les éléments de fenêtre et de défilement.

Code:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Sortie:

Liste de chargement illimité :

Taper à l'avance
Ce composant fournit un champ de saisie anticipée pour sélectionner une option dans une liste d'options. En termes simples, ce composant est utilisé pour créer une fonction d'auto-complétion de texte.

Code:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Sortie:

Cette typographie nous permet de sélectionner le fruit.

Composants stylés
L'outil Styled Components est utilisé pour styliser les composants React à l'aide de CSS-in-JS.

Code:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Sortie:

Info-bulle
Ce composant permet aux développeurs d'ajouter des info-bulles à certains éléments. Créez simplement un bouton et ajoutez une superposition de texte comme info-bulle.

Code:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Sortie:

Résumé
BOS aide à relever les principaux défis de la création d'un front-end Web3, tels que l'accès, la sécurité, la composabilité et l'agilité. Avec BOS, les utilisateurs peuvent exécuter des applications blockchain localement, ce qui contribue à garantir la robustesse et la robustesse du capteur tout en maintenant une expérience conviviale.

Si vous souhaitez en savoir plus sur l'interface BOS, veuillez lire la documentation ici.




	

	
	
		
			
				Qu'est-ce qu'un widget sur BOS ?
			
		

		
					

		
			
			
			
			Code pour le frontend stocké sur la blockchain NEAR
		
			
			Concevoir une machine virtuelle spéciale qui exécute le frontend pour le protocole
		
			
			Une petite application qui résout un problème précis et permet de créer des applications complexes en assemblant des composants
		
			
			Un framework qui peut fonctionner sur n'importe quel backend Web2 ou Web3 et n'importe quel portefeuille
		
	
		

		
		
			
				Correct!
				Wrong!

### Four or Three

Four or Three(Required)
			
					
					Four
			
			
					
					Three
			Quadratic vote with nLEARNs(Required)
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### El Sistema operativo Blockchain del protocolo NEAR

En marzo de 2023, el Protocolo Near lanzó el Sistema Operativo Blockchain (BOS por sus siglas en inglés) para crear el punto de entrada ideal de la Web Abierta. La idea es tender un puente sin fisuras entre la Web2 y la Web3. Este artículo examinará de cerca el BOS y explicará cómo funciona.
¿Qué es la Web Abierta?
"La Web Abierta" es un término utilizado para describir el Internet cuando este se convierte en un recurso público global no supervisado por guardianes o supervisores. ¿Por qué es necesaria una web abierta?

 	Es necesaria para una libre expresión y una comunicación abierta.
 	Una web abierta es una internet del pueblo y para el pueblo. Permite a los individuos intervenir y contribuir positivamente en la sociedad.

Desde el principio, la visión de NEAR fue ayudar a facilitar la creación de la Web Abierta. Dado que la Web Abierta debe ser descentralizada, NEAR necesitaba crear una cadena de bloques escalable, de capa 1, que eliminara las complejidades. ¿Lo han conseguido? Vamos a verlo.

 	NEAR tiene un modelo de cuentas flexible y cuentas legibles por humanos.
 	El mecanismo de fragmentación Nightshade hace que NEAR sea extremadamente escalable.
 	NEAR también proporciona herramientas sofisticadas para ayudar a los creadores a desarrollar el protocolo.

Una vez sentadas las bases, NEAR necesita crear una estructura Web3 que ayude a agilizar la incorporación a la  Web Abierta tanto de los usuarios como de los desarrolladores.
¿Cómo logra el BOS una web abierta?
Piense en lo que hace un sistema operativo o "OS” (por sus siglas en inglés). Un OS permite a los usuarios interactuar con maquinaria sofisticada sin entrar en las complejidades. Abstraerse de las complejidades en segundo plano es crucial para la adopción masiva de la tecnología.

Ahora, extiende esa lógica a la Web3. Según Illia Polushkin, cofundador del Protocolo NEAR, BOS es una capa común para navegar y descubrir productos de la Web3. Además, el BOS será compatible con las cadenas del Protocolo Near y de la Máquina Virtual de Ethereum durante su lanzamiento. Imagínate una aplicación DeFi nueva y genial en Ethereum y conseguir usuarios de NEAR a través de BOS.
Creación de interfaces compuestas
Antes de seguir adelante, vamos a entender lo que es un frontend. Un frontend es la manera en que un usuario interactúa con la aplicación. Cuando se trata de dApps, la creación de una interfaz compuesta y descentralizada es necesaria. El propio ethos de la Web3 es la descentralización. Entonces, ¿por qué seguimos utilizando servicios centralizados para acceder a estos servicios? Confiar en estos intermediarios plantea varios problemas de seguridad.

BOS ayuda a añadir frontends compuestos a la estructura tecnológica y a integrar fácilmente a los usuarios en la Web3. En cuanto al potencial de BOS como frontend, Polushkin ha declarado:

"Los frontends compuestos descentralizados, como un marco, pueden funcionar con cualquier backend Web2 o Web3 y con cualquier billetera. En el futuro ofreceremos [el uso de] billeteras de una cadena para interactuar con otra a través de puentes sin fisuras."
Los 3 pilares del BOS
El BOS está basado en tres pilares:

 	Pasarelas
 	Componentes
 	Blockchains

Pasarelas
Las pasarelas están diseñadas para poner a disposición de todo el mundo interfaces descentralizadas ejecutadas localmente. Una pasarela consta de una máquina virtual especialmente diseñada que carga y ejecuta interfaces para protocolos creados en Ethereum, L2 y otros L1 como NEAR. El código de estas interfaces se almacena en la blockchain de NEAR.




	

	
	
		
			
				¿Cuál es la finalidad del sistema operativo Blockchain (BOS) del Protocolo Near? (elija todas las que correspondan)
			
		

		
					

		
			Please select 2 correct answers
			
			
			Por favor, selecciona 2 respuestas correctas
		
			
			Crear una Internet descentralizada y no supervisada por guardianes.
		
			
			Crear un puente entre la Web2 y la Web3.
		
			
			Desarrollar una blockchain escalable de capa 2
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Componentes
Los componentes son frontends para app-layer, de protocolos en cadena como Lido, Uniswap y Aave. Los desarrolladores pueden ver el código de estas aplicaciones en una pasarela similar a la visualización de un contrato inteligente en Etherscan. Además, pueden bifurcar estas aplicaciones y desplegar sus propias versiones o incluso combinar componentes.
Blockchains
Los componentes pueden llamar a funciones de cualquier blockchain. Actualmente, todas las cadenas EVM/L2 y NEAR son compatibles. Además, el código fuente de los frontends (aplicaciones) se almacena en NEAR debido a su capacidad para almacenar HTML/CSS/JS a bajo coste.
El frontend del BOS de NEAR
Veamos cómo funciona el front-end en tiempo real. Visita alpha.near.org.

El frontend conecta a los usuarios con todas las posibilidades de la Web3 dentro del ecosistema. Cualquiera en el ecosistema de la Web Abierta puede crear sus propios frontends, compatibles con la blockchain que elija. Vamos a jugar con la interfaz y ver cómo funciona.

Cuando te desplaces hacia arriba, sitúa el cursor sobre “Discover” (Descubrir) y haz clic en “Components” (Componentes).

Los componentes son pequeñas aplicaciones que resuelven problemas específicos. Actualmente, tienes algunos componentes incorporados que puedes usar para construir el frontend. Aquí hay algunos componentes incorporados.




	

	
	
		
			
				¿Cuál es la función de las pasarelas en el BOS?
			
		

		
					

		
			
			
			
			Poner a disposición de todo el mundo frontends centralizados ejecutados localmente
		
			
			Proporcionar herramientas sofisticadas para ayudar a los constructores a desarrollar el protocolo
		
			
			Para almacenar el código fuente de los frontends en NEAR
		
			
			Para cargar y ejecutar frontends para protocolos construidos en Ethereum, L2s y otros Layer 1s
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
Un widget es la unidad mínima de un frontend. Permite incluir un componente existente en el código, lo que permite crear aplicaciones complejas mediante la composición de componentes.

Código:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Salida:

Image Uploader (Cargador de imágenes)
El cargador de imágenes permite a los usuarios cargar directamente una imagen en el Sistema Interplanetario de Archivos (IPFS, por sus siglas en inglés).

Código:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Salida:

Puedes usar el botón para subir una imagen:

Archivos
Archivos subidos con soporte para arrastrar y soltar.

Código:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Salida:

Markdown
Un componente integrado que permite renderizar el Markdown.

Código:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);

Salida:

OverlayTrigger
El widget OverlayTrigger permite a los desarrolladores mostrar texto o iconos superpuestos cuando el ratón pasa por encima de un elemento concreto.

Código:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Salida:

InfiniteScroll
Este componente permite crear una página o elemento de desplazamiento infinito sencillo y ligero, ya que admite tanto elementos de ventana como elementos desplazables.

Código:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Salida:

Una lista de carga infinita:

Typeahead
Este componente proporciona un campo de entrada de texto para seleccionar una opción de una lista de opciones. En pocas palabras, este componente se utiliza para crear funciones de autocompletado de texto.

Código:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Salida:

Este Typehead le permite elegir una fruta.

Styled Components
La herramienta Styled Components se utiliza para estilizar componentes React utilizando CSS-in-JS.

Código:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Salida:

ToolTip
Este componente permite a los desarrolladores añadir tool tips en determinados elementos. Solo hay que crear un botón y añadir un texto superpuesto como un tool tip.

Código:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Salida:

Para finalizar
BOS ayuda a resolver los principales retos que plantea la creación de front-ends en la Web3, como el acceso, la seguridad, la composición y la agilidad. Con el BOS, los usuarios pueden ejecutar aplicaciones blockchain localmente, lo que ayuda a garantizar la robustez y la resistencia a la censura, manteniendo al mismo tiempo una experiencia fácil de usar.

Si quieres saber más sobre el frontend de BOS, lee la documentación aquí.




	

	
	
		
			
				¿Qué es un widget en el BOS?
			
		

		
					

		
			
			
			
			El código para frontend almacenado en la blockchain NEAR.
		
			
			Una máquina virtual especialmente diseñada que carga y ejecuta frontends para protocolos.
		
			
			Una pequeña aplicación que resuelve problemas concretos y permite crear aplicaciones complejas mediante la composición de componentes.
		
			
			Un framework que puede funcionar con cualquier backend Web2 o Web3 y cualquier billetera.
		
	
		

		
		
			
				Correct!
				Wrong!

### Операционная система блокчейна NEAR Protocol

В марте 2023 года Near Protocol запустил операционную систему Blockchain (BOS), чтобы создать идеальную точку входа в Open Web. Идея состоит в том, чтобы плавно преодолеть разрыв между web2 и web3. В этой статье мы подробно рассмотрим BOS и поймем, как она работает.
Что такое открытая сеть?
«Открытая сеть» — это термин, используемый для описания Интернета, когда он становится глобальным общедоступным ресурсом и никем не контролируемым. Итак, почему открытая сеть желательна?

 	Это необходимо для свободной и открытой коммуникации и самовыражения.
 	Открытая сеть — это Интернет, созданный людьми и для людей. Это дает людям возможность вмешаться и внести положительный вклад в общество.

С самого начала видение NEAR заключалось в том, чтобы способствовать созданию Открытой сети. Поскольку открытая сеть должна быть децентрализована, NEAR необходимо было создать масштабируемую цепочку блоков первого уровня, которая абстрагируется от сложностей. Удалось ли им это сделать? Давайте взглянем.

 	NEAR имеет гибкую модель учетной записи и удобочитаемые учетные записи.
 	Механизм сегментирования Nightshade делает NEAR чрезвычайно масштабируемым.
 	NEAR также предоставляет сложные инструменты, помогающие разработчикам разрабатывать на протоколе.

Заложив фундамент, NEAR теперь необходимо создать стек web3, который поможет упростить адаптацию Открытой сети для пользователей и разработчиков.
Как BOS добивается открытости Интернета?
Подумайте, что делает операционная система или "ОС". ОС позволяет пользователям взаимодействовать со сложной техникой, не вникая в сложности. Абстрагирование от фоновых сложностей имеет решающее значение для массового внедрения технологии.

Теперь распространите эту логику на web3. По словам соучредителя NEAR Protocol Ильи Полосухина, BOS — это общий уровень для просмотра и обнаружения продуктов Web 3. Кроме того, во время запуска BOS будет поддерживать цепочки Near Protocol и Ethereum Virtual Machine. Представьте себе создание нового крутого приложения DeFi на Ethereum и получение пользователей из NEAR через BOS.
Создание компонуемых внешних интерфейсов
Прежде чем мы пойдем дальше, давайте разберемся, что такое интерфейс. Интерфейс — это то, как пользователь взаимодействует с приложением. Когда дело доходит до dApps, необходимо создавать компонуемые и децентрализованные приложения. Сама суть web3 — децентрализация. Так почему же мы до сих пор используем централизованные службы для доступа к этим службам? Доверие к этим посредникам сопряжено с рядом проблем безопасности.

BOS помогает добавлять компонуемые интерфейсы в технический стек и легко интегрировать пользователей в web3. Что касается потенциала BOS в качестве внешнего интерфейса, Полосухин сказал:

«Компонуемый децентрализованный внешний интерфейс в качестве фреймворка может работать с любым внутренним интерфейсом Web2 или Web3 и любым кошельком. В будущем мы будем предлагать [использование] кошельков из одной цепочки для взаимодействия с другой посредством беспрепятственного моста».
3 столпа BOS
BOS базируется на трех столпах:

 	Шлюзы
 	Компоненты
 	Блокчейны

Шлюзы
Шлюзы предназначены для того, чтобы сделать локальные децентрализованные интерфейсы доступными для всех. Шлюз представляет собой специально разработанную виртуальную машину, которая загружает и запускает внешние интерфейсы для протоколов, построенных на Ethereum, L2 и первых уровнях, таких как NEAR. Код этих интерфейсов хранится в блокчейне NEAR.




	

	
	
		
			
				Какова цель операционной системы Blockchain (BOS) Near Protocol?
			
		

		
					

		
			Please select 2 correct answers
			
			
			создать децентрализованный интернет, никем не контролируемый
		
			
			преодолеть разрыв между web 2 и web 3
		
			
			разработать масштабируемый блокчейн второго уровеня
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Компоненты
Компоненты — это внешние интерфейсы для сетевых протоколов уровня приложений, таких как Lido, Uniswap и Aave. Разработчики могут просматривать код этих приложений в шлюзе, подобно просмотру смарт-контракта в Etherscan. Кроме того, они могут разветвлять эти приложения и развертывать свои собственные версии или даже создавать компоненты.
Блокчейны
Компоненты могут вызывать функции в любой цепочке блоков. В настоящее время поддерживаются все цепочки EVM/L2 и NEAR. Кроме того, исходный код интерфейсов (приложений) хранится на NEAR из-за его способности дешево хранить HTML/CSS/JS.
Посмотрим на интерфейс BOS NEAR
Давайте посмотрим, как интерфейс работает в режиме реального времени. Зайдите на alpha.near.org.

Внешний интерфейс соединяет пользователей со всеми различными возможностями Web3 в рамках экосистемы. Любой участник экосистемы Open Web может создавать собственные интерфейсы, совместимые с выбранной им цепочкой блоков. Давайте поиграем с интерфейсом и посмотрим, как это работает.

Когда вы прокрутите вверх, наведите курсор на «Обнаружение» и нажмите «Компоненты».

Компоненты — это небольшие приложения, которые решают определенные проблемы. В настоящее время у вас есть несколько встроенных компонентов, которые вы можете использовать для создания внешнего интерфейса. Вот некоторые из них.



	

	
	
		
			
				Какова функция шлюзов в BOS?
			
		

		
					

		
			
			
			
			сделать локальные централизованные интерфейсы доступными для всех
		
			
			предоставить сложные инструменты, чтобы помочь разработчикам разработать на протоколе
		
			
			хранить исходный код для интерфейсов на NEAR
		
			
			для загрузки и запуска интерфейсов на Ethereum, L2 или протоколах первого уровня
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Виджет
Виджет — это минимальная единица внешнего интерфейса. Он позволяет вам включать существующий компонент в ваш код, тем самым позволяет  создавать сложные приложения путем компоновки компонентов.

Код:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Результат:

Загрузчик изображений
Средство загрузки изображений позволяет пользователям напрямую загружать изображения в файловую систему (IPFS).

Код:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Результат:

Вы можете использовать кнопку для загрузки изображения:

Файлы
Загружайте файлы с поддержкой перетаскивания.

Код:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Результат:

Markdown
Встроенный компонент, который позволяет отображать Markdown.

Код:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);

Результат:

OverlayTrigger
Виджет OverlayTrigger позволяет разработчикам отображать наложенный текст или значок, когда указатель мыши находится над определенным элементом.

Код:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Результат:

Бесконечная прокрутка
Этот компонент позволяет создавать простую и легкую страницу или элемент с бесконечной прокруткой, поддерживая как оконные, так и прокручиваемые элементы.

Код:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Результат:

Бесконечно загружаемый список:

Упреждающий ввод
Этот компонент предоставляет поле ввода с опережением ввода для выбора параметра из списка вариантов. Проще говоря, этот компонент используется для создания функций автозаполнения текста.

Код:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Результат:

Этот упреждающий ввод позволяет выбрать фрукт.

Стилизованные компоненты
Инструмент Styled Components используется для стилизации компонентов React с использованием CSS-in-JS.

Код:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Результат:

Подсказка
Этот компонент позволяет разработчикам добавлять подсказки к определенным элементам. Просто создайте кнопку и добавьте наложенный текст в качестве всплывающей подсказки.

Код:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Результат:

Заключение
BOS помогает решить основные проблемы, связанные с созданием веб-интерфейсов 3, такие как доступ, безопасность, компонуемость и гибкость. С BOS пользователи могут запускать блокчейн-приложения локально, что помогает обеспечить надежность и устойчивость к цензуре, сохраняя при этом удобство для пользователя.

Если вы хотите узнать больше о внешнем интерфейсе BOS, прочитайте документацию здесь.




	

	
	
		
			
				Что такое виджет в BOS?
			
		

		
					

		
			
			
			
			код для интерфейсов, хранящийся на NEAR
		
			
			специально разработанная виртуальная машина которая загружает и запускает интерфейсы для протокола
		
			
			небольшое приложение, которое решает определенные проблемы и позволяет создавать сложные приложения путем составления компонентов
		
			
			фреймворк, который может работать с любым бэкэндом web2 или web3 и любым кошельком
		
	
		

		
		
			
				Correct!
				Wrong!

### Sistem Operasi Blockchain NEAR Protocol

Pada bulan Maret 2023, NEAR Protocol meluncurkan Sistem Operasi Blockchain/ Blockchain Operating System (BOS) dengan tujuan untuk menciptakan gerbang masuk yang ideal dari Open Web. Disini, idenya adalah untuk menjembatani kesenjangan antara web2 dan web3 dengan lancar. Artikel ini akan menjelaskan lebih lanjut mengenai BOS dan memahami cara kerjanya.

Apa itu Open Web?
“Open Web” merupakan suatu istilah yang digunakan untuk mendeskripsikan internet ketika menjadi sumber daya publik global yang tidak diawasi baik oleh penjaga maupun pengawas manapun. Jadi, mengapa Open Web ini dibutuhkan?

 	Hal ini diperlukan untuk kebebasan dan keterbukaan dalam komunikasi dan berekspresi
 	Open Web merupakan internet dari masyarakat dan untuk masyarakat. Ini memberdayakan individu untuk melangkah dan berkontribusi secara positif kepada masyarakat.

Sejak awal, visi NEAR adalah membantu memfasilitasi pembuatan Open Web. Pada dasarnya, Open Web perlu didesentralisasi, NEAR juga perlu membuat blockchain layer-1 yang dapat diskalakan yang mengabstraksi kompleksitas. Apakah NEAR mampu melakukan har tersebut? Mari kita simak.

 	NEAR memiliki model akun yang fleksibel dan akun yang dapat dibaca manusia (human-readable).
 	Mekanisme sharding Nightshade membuat NEAR sangat skalabel.
 	NEAR juga menyediakan alat canggih untuk membantu pembangun mengembangkan protokol.

Setelah mengetahui dasarnya, NEAR sekarang perlu membuat tumpukan web3 yang akan membantu merampingkan Open Web onboarding untuk pengguna dan para pengembang (dev).
Bagaimana BOS Dapat Mencapai Open Web?
Bayangkan seperti apa yang dilakukan sistem operasi atau "OS". OS memungkinkan para pengguna untuk berinteraksi dengan mesin canggih tanpa masuk ke kerumitan yang tidak perlu. Menjauhkan absraksi dan kompleksitas pada latar belakang sangat penting untuk adopsi teknologi secara massal.

Sekarang kita akan perluas logika itu ke dunia web3. Menurut Co-Founder NEAR Protocol Illia Polushkin, BOS merupakan lapisan umum untuk menjelajahi dan menemukan produk Web 3. Selain itu, BOS akan mendukung chain Near Protocol dan Ethereum Virtual Machine selama peluncuran. Bayangkan bagaimana kita dapat membuat aplikasi DeFi baru yang keren di Ethereum dan mendapatkan pengguna dari NEAR melalui BOS.
Menciptakan Frontend yang Dapat Disusun
Sebelum kita melangkah ke pembahasan yang lebih jauh, mari kita pahami terlebih dahulu apa itu frontend. Frontend merupakan bagaimana pengguna dapat berinteraksi dengan aplikasi. Ketika ini mengenai dApps, membuat aplikasi yang composable dan terdesentralisasi sangatlah diperlukan.  Jiwa utama dari web3 adalah desentralisasi. Lantas, mengapa kita masih menggunakan layanan terpusat untuk mengakses layanan tersebut? Mempercayai perantara seperti ini tentunya memiliki beberapa tantangan terkait keamanan.

BOS membantu menambahkan frontend yang dapat disusun ke tech stack dan dengan mudah memasukkan pengguna ke web3. Mengenai potensi BOS sebagai frontend, Polusukhin mengatakan seperti berikut:

“Front end yang terdesentralisasi dapat disusun sebagai kerangka kerja dapat berjalan dengan backend Web2 atau Web3 apa pun dan dari dompet apa pun. Di masa mendatang kami akan menawarkan [penggunaan] dompet dari satu rantai untuk berinteraksi dengan yang lain melalui penghubung yang lancar.”
3 Pilar dari BOS
BOS memiliki basis berdasarkan 3 pilar, diantaranya adalah:

 	Gateway
 	Komponen
 	Blockchain

Gateway
Gateway dirancang untuk membuat frontend yang dijalankan secara lokal dan terdesentralisasi tersedia untuk semua orang. Gateway terdiri dari mesin virtual yang dirancang khusus yang memuat dan menjalankan frontend untuk protokol yang dibangun di atas Ethereum, L2, dan Lapisan 1 lainnya seperti NEAR. Kode untuk frontend ini disimpan di blockchain NEAR.




	

	
	
		
			
				Apa tujuan dari Sistem Operasi Blockchain NEAR Protocol? Pilih 2 jawaban yang tepat
			
		

		
					

		
			Please select 2 correct answers
			
			
			Menciptakan internet yang terdesentralisasi yang tidak diawasi oleh siapapun
		
			
			Menghubungkan gap antara Web2 dan Web3

		
			
			Untuk membangun blockchain layer-2 yang skalabel
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Komponen
Komponen adalah frontend untuk protokol on-chain maupun layer aplikasi seperti Lido, Uniswap, dan Aave. Pengembang dapat melihat kode untuk aplikasi ini di gateway yang mirip dengan melihat smart contract di Etherscan. Selain itu, mereka dapat melakukan fork pada aplikasi ini dan menerapkan versi mereka sendiri atau bahkan membuat komponen.
Blockchain
Komponen dapat memanggil fungsi pada blockchain apa pun. Saat ini, semua rantai EVM atau L2 dan NEAR telah didukung. Selain itu, source code untuk frontend (aplikasi) disimpan di NEAR karena kemampuannya untuk menyimpan HTML/CSS/JS dengan harga murah.
Meninjau di Frontend NEAR BOS
Ayo kita melihat bagaimana front-end bekerja secara langsung. Silakan mengakses laman alpha.near.org

Frontend menghubungkan pengguna ke semua kemungkinan Web3 yang berbeda dalam ekosistem. Siapa pun di ekosistem Open Web dapat membuat frontend mereka masing-masing, kompatibel dengan blockchain pilihan mereka. Ayo kita bermain-main dengan antarmuka dan melihat bagaimana cara kerjanya.

Saat kita menggulir ke atas, arahkan kursor ke "Discover" dan klik "Komponen".

Komponen adalah aplikasi kecil yang dapat memecahkan masalah tertentu. Saat ini, kita memiliki beberapa komponen bawaan yang dapat kita gunakan untuk membuat frontend. Berikut adalah beberapa komponen bawaan yang tersedia.




	

	
	
		
			
				Apa fungsi dari Gateway pada BOS?


			
		

		
					

		
			
			
			
			Untuk membuat frontend tersentralisasi dapat berjalan secara lokal untuk semua

		
			
			Untuk menyediakan tools mutakhir untuk membantu kreator membangun protokol
		
			
			Untuk menyimpan source code untuk frontend di NEAR
		
			
			Untuk menjalankan frontend pada protokol yang dibangun pada Ethereum, Layer 2 dan Layer 1 lainnya
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
Widget adalah unit minimum frontend. Ini memungkinkan kita untuk memasukkan komponen yang ada dalam kode kita, sehingga memungkinkan kita untuk membuat aplikasi yang kompleks dengan menyusun komponen.

Code:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Output:

Image Uploader
Image Uploader membuat pengguna dapat mengupload gambar secara langsung ke InterPlanetary File System (IPFS).

Code:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Output:

Kita dapat menggunakan tombol untuk mengupload gambar

Files
Upload gambar dengan dukungan drag and drop

Code:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Output:

Markdown
Komponen bawaan yang memungkinkan untuk merender Markdown.

Code:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);


OverlayTrigger
Widget OverlayTrigger memungkinkan pengembang menampilkan teks atau ikon overlay saat mouse diarahkan di atas item tertentu.

Code:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Output:

InfiniteScroll
Komponen ini memungkinkan kita membuat halaman atau elemen pengguliran tak terbatas yang sederhana dan ringan dengan mendukung elemen window dan elemen yang dapat digulir.

Code:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Output:

Daftar pemuatan tanpa batas:

Typeahead
Komponen ini menyediakan kolom input type-ahead untuk memilih opsi dari daftar pilihan. Sederhananya, komponen ini digunakan untuk membuat fitur pelengkapan otomatis teks.

Code:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Output:

Typehead ini memungkinkan kita untuk memilih buah.

Styled Components
Tools Styled Components digunakan untuk menata komponen React menggunakan CSS-in-JS.

Code:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Output:

ToolTip
Komponen ini memungkinkan pengembang menambahkan tool tip pada elemen tertentu. Cukup buat tombol dan tambahkan teks overlay sebagai tool tip.

Code:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Output:

Penutup
BOS membantu mengatasi tantangan utama dalam membangun front-end web3, seperti akses, keamanan, kemampuan menyusun, dan ketangkasan. Dengan BOS, pengguna dapat menjalankan aplikasi blockchain secara lokal, yang membantu memastikan ketangguhan dan ketahanan dari sensor sembari mempertahankan pengalaman yang ramah pengguna.

Jika kamu ingin mempelajari lebih jauh terkait frontend BOS, silakan baca dokumentasinya di sini.




	

	
	
		
			
				Apa itu widget pada BOS?

			
		

		
					

		
			
			
			
			Kode untuk frontend yang disimpan di blockchain NEAR
		
			
			Desain mesin virtual spesial yang menjalankan frontend untuk protokol
		
			
			Sebuah aplikasi kecil yang menyelesaikan permasalahan tertentu dan memperkenankan kita untuk membuat aplikasi yang kompleks dengan menyusun komponen
		
			
			Sebuah framework yang dapat bekerja di backend Web2 atau Web3 manapun dan wallet apapun
		
	
		

		
		
			
				Correct!
				Wrong!

### Sistema Operacional Blockchain do Protocolo NEAR

Em março de 2023, a Near Protocol lançou o Blockchain Operating System ou BOS (Sistema Operacional Blockchain) para criar o ponto de entrada ideal da Open Web (web aberta). A ideia aqui é preencher a lacuna entre a web2 e a web3 sem que haja problemas. Este artigo examinará de perto o BOS e entenderá como ele funciona.
O que é a Open Web?
“Open Web” é um termo usado para descrever a internet quando ela se torna um recurso público global não supervisionado por porteiros ou supervisores. Então, por que a open web é desejável?

 	É necessária para comunicação e expressão livre e aberta.
 	Uma open web é uma internet feita pelo povo e para o povo. Ela capacita os indivíduos a intervir e contribuir positivamente para a sociedade.

Desde o início, a visão da NEAR era ajudar a facilitar a criação da Open Web. Como a open web necessita ser descentralizada, a NEAR precisava criar uma blockchain escalável de camada 1 que abstraísse as complexidades. Eles foram capazes de fazer isso? Vamos dar uma olhada.

 	NEAR tem um modelo de conta flexível e contas legíveis por humanos.
 	O mecanismo de fragmentação Nightshade torna a NEAR extremamente escalável.
 	A NEAR também fornece ferramentas sofisticadas para ajudar os programadores a desenvolver o protocolo.

Tendo estabelecido a base, a NEAR agora precisa criar uma web3 stack  que ajudará a simplificar a integração da Open Web para usuários e desenvolvedores. (Uma WEB STACK é a coleção de softwares usados para o desenvolvimento web que incorpora, no mínimo, um sistema operacional (SO), uma linguagem de programação, software de banco de dados e um servidor web.)
Como o BOS alcança a Open Web?
Pense no que um sistema operacional ou “OS” faz. Um sistema operacional permite que os usuários interajam com máquinas sofisticadas sem entrar nas complexidades. Abstrair as complexidades em segundo plano é crucial para a adoção em massa da tecnologia.

Agora, estenda essa lógica para web3. De acordo com o Cofundador da  NEAR Protocol, Illia Polushkin, o BOS é uma camada comum para navegar e descobrir produtos Web3. Além disso, o BOS suportará Near Protocol e máquinas virtuais blockchains de Ethereum durante o lançamento. Imagine criar um novo e legal aplicativo DeFi no Ethereum e obter usuários da NEAR via BOS.
Criando interfaces compostas.
Antes de prosseguir, vamos entender o que é um front-end. Um front-end é a interface com que um usuário interage com o aplicativo. Quando se trata de dApps, é necessária uma interface composta e descentralizada. A essência do web3 é a descentralização. Então, por que ainda usamos serviços centralizados para acessar esses serviços? Confiar nesses intermediários apresenta vários desafios de segurança.

O BOS ajuda a adicionar interfaces compostas à tecnologia do Stack e a integrar facilmente os usuários a web3. Em relação ao potencial do BOS como front-end, Polushkin disse:

“Os front-ends compostos descentralizados, como uma estrutura, podem funcionar com qualquer back-end Web2 ou Web3 e qualquer carteira. No futuro, ofereceremos [uso de] carteiras de uma cadeia para interagir com outra por meio de uma ponte direta.”
Os três pilares do BOS
O BOS é baseado em três pilares:

 	Gateways (porta de acesso)
 	Componentes
 	Blockchains (Cadeia de Blocos)

Gateways
Os gateways são projetados para disponibilizar front-ends descentralizados e executados localmente para todos. Um gateway compreende uma máquina virtual especialmente projetada que carrega e executa front-ends para protocolos construídos em Ethereum, Layer 2 (camada 2) e outros Layer 1 como NEAR. O código para esses front-ends é armazenado na blockchain NEAR.




	

	
	
		
			
				Qual é o propósito do Sistema Operacional Blockchain (BOS) do Protocolo Near? (escolha todos os aplicáveis)
			
		

		
					

		
			Please select 2 correct answers
			
			
			Para criar uma internet descentralizada não supervisionada por porteiros.

		
			
			Para preencher a lacuna entre web2 e web3. 
		
			
			Para desenvolver um blockchain escalável de camada 2.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Componentes
Os componentes são front-ends para protocolos on-chain (na cadeia) da camada de aplicativos, como Lido, Uniswap e Aave. Os desenvolvedores podem visualizar o código desses aplicativos em um gateway semelhante à visualização de um contrato inteligente no Etherscan. Além disso, eles podem bifurcar esses aplicativos e implantar suas próprias versões ou até mesmo compor componentes.
Blockchains
Os componentes podem chamar funções em qualquer blockchain. Atualmente, todas as cadeias/L2s EVM e NEAR são suportadas. Além disso, o código-fonte dos aplicativos (front-ends) é guardado na NEAR devido à sua capacidade de armazenar HTML/CSS/JS de forma econômica.
Olhando para o BOS Front-end da NEAR.
Vamos ver como o front-end funciona em tempo real. Vá para alpha.near.org.

O front-end conecta os usuários a todas as diferentes possibilidades do Web3 dentro do ecossistema. Qualquer pessoa no ecossistema Open Web pode criar seus próprios frontends, compatíveis com a blockchain escolhida. Vamos brincar com a interface e ver como ela funciona.

Ao rolar para cima, passe o mouse sobre “Discover” e clique em “Components” (Componentes).

Os componentes são pequenos aplicativos que resolvem problemas específicos. Atualmente, você tem alguns componentes integrados que podem ser usados para criar o front-end. Aqui estão alguns componentes incorporados.




	

	
	
		
			
				Qual é a função dos Gateways no BOS?
			
		

		
					

		
			
			
			
			Disponibilizar front-ends centralizados e executados localmente para todos.
		
			
			Fornecer ferramentas sofisticadas para ajudar os programadores a desenvolver  o protocolo.
		
			
			Armazenar o código-fonte para frontends em NEAR.
		
			
			Armazenar o código-fonte para frontends em NEAR.
Carregar e executar front-ends para protocolos construídos em Ethereum, L2s e outros L1s.

		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
Um widget (ferramenta) é a unidade mínima de um front-end. Ela permite que você inclua um componente existente em seu código, permitindo que você crie aplicativos complexos compondo componentes.

Código:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Saída:

Image Uploader
Saída:

O Image Uploader (carregador de imagens) permite que os usuários carreguem diretamente uma imagem para o sistema interplanetário de arquivos  (IPFS de acordo com sua abreviatura em inglês).

Código:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Saída:

Você pode usar o botão para fazer upload de uma imagem:

Arquivos
Faça Upload dos arquivos com suporte “arraste e solte”.

Código:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Saída:

Markdown
Um componente integrado que permite renderizar o Markdown.

Código:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);

Saída:

OverlayTrigger
O widget OverlayTrigger (gatilho de sobreposição) permite que os desenvolvedores exibam texto ou ícone de sobreposição quando o mouse estiver passando sobre um item específico.

Código:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Saída:

InfiniteScroll
Este componente permite criar uma página ou elemento de rolagem infinita simples e leve, suportando janelas e elementos roláveis.

Código:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Saída:

Uma lista de carregamento infinito:

Typeahead
Este componente fornece um campo de entrada de digitação antecipada para selecionar uma opção em uma lista de opções. Simplificando, este componente é usado para criar recursos de preenchimento automático de texto.

Código:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Saída:

Este Typehead permite que você escolha uma fruta.

Styled Components
A ferramenta Styled Components é usada para estilizar componentes React usando CSS-in-JS..

Código:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Saída:

ToolTip
Este componente permite aos desenvolvedores adicionar dicas de ferramentas sobre determinados elementos. Basta criar um botão e adicionar um texto de sobreposição como uma dica de ferramenta.

Código:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Saída:

Para finalizar
O BOS ajuda a resolver os principais desafios relacionados à construção de front-ends web3, como acesso, segurança, capacidade de composição e agilidade. Com o BOS, os usuários podem executar aplicativos blockchain localmente, o que ajuda a garantir robustez e resistência à censura, mantendo uma experiência amigável.

Se você quiser saber mais sobre BOS front-end, leia a documentação aqui.




	

	
	
		
			
				O que é um Widget no BOS?
			
		

		
					

		
			
			
			
			O código para front-ends armazenados na blockchain da NEAR.
		
			
			Uma máquina virtual especialmente projetada que carrega e executa front-ends para protocolos.

		
			
			Um pequeno aplicativo que resolve problemas específicos e permite criar aplicativos complexos compondo componentes.
		
			
			Uma estrutura que pode funcionar com qualquer back-end Web2 ou Web3 e qualquer carteira.
		
	
		

		
		
			
				Correct!
				Wrong!

### Разработка смарт-контрактов на Near с использованием Rust, часть 1

16 февраля 2023 года я провел семинар в Университете Ватерлоо о разработке умных контрактов на платформе Near с использованием Rust. Мне понравилось собирать информацию и мне кажется, что было бы забавно представить содержание здесь в виде серии блог-постов. В этом первом посте я дам аналогию, связывающую разработку блокчейнов с шаблоном для обычных веб-приложений, представлю пример умного контракта, который мы будем использовать в течение этой серии, и обсудим некоторые общие принципы разработки умных контрактов, уникальные для блокчейнов по сравнению с другими областями программирования.
Ментальная модель для создания распределенного приложения (dapp)
Цель этого раздела заключается в том, чтобы провести аналогию между разработкой на основе блокчейна (приложения, разработанные на базе технологии блокчейн, часто называются «dapps» в этой сфере) и более распространенной технологией для веб-приложений, с которой вы могли сталкиваться раньше. Эта аналогия может помочь вам понять, как пользователи взаимодействуют со смарт-контрактами.

Идея заключается в том, что dapps очень похожи на веб-приложения, основанные на "без серверной архитектуре". Термин "без серверный" немного вводит в заблуждение, потому что, конечно, серверы все еще участвуют в процессе, но причина этого названия заключается в том, что аппаратное обеспечение (т. е. сервер), выполняющее код, скрыто от разработчика. Это имеет преимущества по сравнению с другой инфраструктурой облачных вычислений с точки зрения стоимости и масштабируемости, потому что вы платите только за те ресурсы, которые фактически используете, в отличие от того, чтобы платить за запуск виртуальной машины, которая может простаивать в бездействии, если трафик низкий, или может стать нерабочей, если трафик слишком большой. Каждый раз, когда пользователь взаимодействует с веб-приложением, на бэкэнде вызывается новый экземпляр "без серверной функции", чтобы обслужить запрос пользователя, без того, чтобы разработчику приходилось думать о том, на каком аппаратном обеспечении эта функция работает.

Dapps также скрывают аппаратное обеспечение. Смарт-контракт развертывается на блокчейне и выполняется на узлах (серверах), которые составляют пара-пару сеть этого блокчейна. Когда пользователь взаимодействует с dapp, он делает вызов к блокчейну (транзакцию), чтобы выполнить смарт-контракт. Каждая транзакция создает новый экземпляр смарт-контракта (в том смысле, что между транзакциями нет состояния в памяти, сохраняемого между транзакциями), как и с без серверными функциями.

Ниже приведена изображение, взятое непосредственно с веб-сайта Amazon Web Services (AWS) для Lambda (их версии без серверного вычислительного предложения).

Это изображение легко изменить, чтобы увидеть, как похож рабочий процесс в децентрализованном приложении.

Еще одним сходством между вычислением без сервера и смарт-контрактами является то, что каждая транзакция имеет свою стоимость. В случае AWS за использованные ресурсы оплачивает аккаунт разработчика, а в случае блокчейна за выполнение транзакции уплачивает тот, кто ее подписал.

Используя эту аналогию в качестве опорной точки, давайте обсудим пример разработки децентрализованных приложений (dapp), который мы будем использовать в этой серии.
Наш пример: чат-приложение на основе блокчейна
Пример, который мы будем использовать в этой серии - это чат-приложение на основе блокчейна. Это не реальный пример в том смысле, что нет хорошего делового кейса для использования публичного блокчейна для чата (по моему мнению). То, что все сообщения будут полностью общедоступны и необратимо включены в постоянную запись, является недостатком, а не функцией. Однако причиной выбора этого примера является то, что он иллюстрирует различные важные концепции в разработке децентрализованных приложений, при этом логически легкий для того, кто использовал что-то вроде Facebook Messenger, Telegram или Signal.

Код для этого примера доступен на моем GitHub. README в этом репозитории дает инструкции по настройке среды разработки для взаимодействия с кодом и базовые представления о том, как использовать контракт. Эта серия постов будет намного глубже углубленной в код и как он работает.

Чтобы связать обсуждение принципов разработки смарт-контрактов, рассмотрим общую картину работы чат-контракта.

 	Каждый желающий принять участие в сети чата развертывает свою собственную версию смарт-контракта.
 	Каждый экземпляр контракта поддерживает список известных ему учетных записей (контакты, ожидающие запросы на добавление в контакты и т. д.). Кроме того, он сохраняет сообщения, которые получил (а также некоторые метаданные об этих сообщениях).
 	Чтобы отправить сообщение кому-то другому, сначала нужно иметь его в качестве "контакта". Это работает так, как вы и ожидаете: Алиса отправляет запрос на добавление в контакты Бобу, если Боб принимает запрос, то Алиса и Боб становятся контактами друг друга, в противном случае они не являются контактами.
 	Каждый экземпляр контракта имеет "владельца", который может отправлять сообщения и отправлять/принимать запросы на добавление в контакты.

Принципы разработки смарт-контрактов
Я хочу подчеркнуть три взаимосвязанные концепции, которые важны для разработки смарт-контрактов, но могут не встречаться в типичной разработке программного обеспечения.

1. враждебное мышление

2. экономика

3. обеспечить инварианты, прежде чем делать вызовы между контрактами.
Враждебное мышление
Первое важное, что нужно помнить при развертывании в общедоступный блокчейн, это то, что любой житель мира может взаимодействовать с вашим кодом. Если в вашем смарт-контракте есть какое-то чувствительное действие (например, при отправке сообщений в чат-контракте вы бы не хотели, чтобы кто-то мог выдать себя за вас), то вы должны явно проверять авторизацию, чтобы только уполномоченные аккаунты могли успешно выполнять действия (поэтому наш чат-контракт имеет свойство "владельца"). Если у вас есть метод, который принимает входные данные, то вы должны проверять их достоверность перед тем как передавать их на выполнение бизнес-логики, потому что любой случайный пользователь может отправить любые данные, которые ему нравятся. Действительно, идея враждебного мировоззрения идет еще дальше; не только пользователь может отправить неправильный ввод, но он может внимательно составить входные данные, чтобы вызвать уязвимость в вашем коде. Единственный способ предотвратить это - не иметь таких уязвимостей в первую очередь.

Аналогично, логика смарт-контракта часто зависит от некоторого протокола, чтобы координировать разные компоненты вместе (например, протокол для добавления контактов в наш чат-контракт). Имеет ли пользователь агентство в этом протоколе? Что происходит, если он не следует ему правильно? Это вопросы, на которые вы должны ответить при разработке смарт-контракта, потому что хакеры будут пытаться эксплуатировать ваш контракт.

Короче говоря, вы всегда должны предполагать, что любой внешний ввод является византийским, и явно проверять его, прежде чем продолжить. Вам следует научиться замечать, какие предположения вы делаете, и всегда думать: «Как я могу нарушить это предположение?» всякий раз, когда вы понимаете, что вы делаете его.
Экономика
Экономика типичного веб-приложения довольно проста. Необходимо генерировать достаточный доход, чтобы покрыть затраты на хостинг сервера, содержащего код и данные, используемые вашим приложением. Доход можно получить из нескольких источников, но наиболее распространенными являются доходы от рекламы и платные подписки пользователей.

Для блокчейна ситуация немного сложнее, потому что каждая транзакция должна быть оплачена независимо. Новые продукты на блокчейне стремятся упростить эту ситуацию, например, Aurora+ предоставляет что-то вроде «блокчейн-подписки», которая позволяет проводить определенное количество бесплатных транзакций. Но пока это не станет стандартом в блокчейн-пространстве, все еще важно ответить на вопрос "кто за это платит?".

Часто пользователь оплачивает каждую транзакцию, потому что оплата связана с подписывающим аккаунтом (т.е. оплата связана с идентификацией / авторизацией). Альтернативная модель - использовать "мета-транзакции" (транзакции внутри транзакций), чтобы оплата происходила "внешним подписывающим", а авторизация основывалась на "внутреннем подписывающем". Так, например, работает Aurora+. К сожалению, поскольку это не является стандартным способом функционирования блокчейн-транзакций, разработчикам требуется дополнительная работа, чтобы сделать это возможным.

Для примера чат-приложения мы будем следовать пути наименьшего сопротивления, и каждый пользователь должен будет платить за затраты, которые он создает при использовании приложения. Приняв это решение, необходимо рассмотреть возможные затраты и убедиться, что они соответствующим образом покрываются. Например, на Near оплата за хранение обрабатывается через "стейкинг хранилища". По сути, каждый аккаунт блокирует часть своего баланса в зависимости от объема занимаемого хранилища. Это важно в нашем чат-контракте, потому что он хранит сообщения, полученные от других пользователей, поэтому мы должны убедиться, что другие пользователи покрывают затраты на застейкинг хранилища, прикрепляя достаточный депозит к своему сообщению. Аналогично, запросы на контакт создают запись в хранилище, поэтому и тут необходим депозит. Если бы мы не требовали таких депозитных требований, то пользователи могли бы эффективно красть деньги друг у друга, отправляя множество сообщений и блокируя всю сумму на счете жертвы (обратите внимание, как это связано с адверсивным мышлением выше).

В заключение, при проектировании dapp всегда важно обдумать, какие затраты будут связаны с приложением и как они будут оплачены, будь то добавление проверок на депозиты или использование мета-транзакций.
Обеспечить инварианты, прежде чем делать вызовы между контрактами
Этот последний момент непрост. В типичном приложении весь код связывается в один двоичный файл. При вызове функции в библиотеке это обычно не вызывает никакой связи, а просто добавляет новый фрейм в стек и выполняет какой-то код из другой части двоичного файла. В блокчейн-среде дела обстоят немного иначе.

Вызов другого контракта больше напоминает вызов целого другого процесса, чем вызов библиотеки. Опять же, мы должны применять враждебный подход и понимать, что мы не знаем, что может делать этот другой процесс; в действительности, он может пытаться сделать что-то сознательно вредоносное. Общий вектор атаки заключается в том, чтобы другой процесс вызывал обратно наш контракт и эксплуатировать его, потому что наш контракт не ожидал новый вызов во время ожидания ответа на вызов, который он инициировал. Это называется "атакой на повторный вход" и она была источником одного из самых известных взломов на Ethereum, который привел к созданию "Ethereum Classic" (Ethereum Classic отверг "хардфорк", который был ответом Ethereum Foundation на взлом).

На Near эту проблему даже более острой делает дополнительный вопрос атомарности. В Ethereum Virtual Machine (EVM) каждая транзакция является "атомарной" в том смысле, что все действия, результатом транзакции, либо записываются в состояние блокчейна, либо нет (весь транзакция "откатывается"). Это означает, что атаку на повторный вход можно предотвратить, используя откат; все, что произошло, будет отменено, сохраняя контракт в безопасности. Этот шаблон включен даже в пример Mutex в официальной документации по Solidity. Однако в работе времени выполнения Near выполнение контрактов независимо друг от друга; они не являются атомарными. Так что если транзакция приводит к тому, что контракт A вызывает контракт B, и B сталкивается с ошибкой, то изменения состояния, которые произошли в A, останутся.

Это было много истории и теории, но что из этого можно извлечь практически? Суть в том, что вы должны убедиться, что ваш контракт находится в "хорошем состоянии", когда он делает вызов другому контракту. Это означает, что если существуют инварианты, на которых основана логика вашего контракта, то они должны быть правильны в момент вызова. Как простой пример, предположим, что у нас есть контракт с функцией передачи. Инвариантом, который необходимо поддерживать, является то, что токены не создаются или не уничтожаются при передаче. Если по какой-то причине во время передачи было нужно позвонить в другой контракт, неверно было бы задействовать один счет и затем делать вызов, не начисляя средства на другой счет. Это потому, что несоблюдение инварианта относительно токенов может быть использовано для эксплуатации. Пример в этом духе также приводится в документации по Near.
Итог
Подводя итог, в этом сообщении блога мы представляем новую серию сообщений, дающих введение в разработку смарт-контрактов на Near с использованием Rust. Здесь мы обсудили пример контракта чата, который мы будем использовать на протяжении всей серии, а также некоторые общие принципы, которые следует учитывать при разработке приложений на основе блокчейна. В следующем посте мы углубимся в код, чтобы обсудить технические детали реализации контракта. Это послужит примером для Rust SDK компании Near, иллюстрирующим концепции, применимые ко всем видам реальных контрактов, которые вы, возможно, захотите написать.

Если вам нравится эта серия постов в блоге, свяжитесь с нами по Type-Driven Consulting. Мы рады предоставить услуги по разработке программного обеспечения для dapps, а также учебные материалы для ваших собственных инженеров.

### Разработка смарт-контрактов на Near с использованием Rust, часть 2

Это вторая часть серии гайдов о создании чат-приложения с помощью Rust на блокчейне Near. Первый гайд из серии вы можете найти здесь.

В этом гайде мы сосредоточимся на самом смарт-контракте. Мы увидим библиотеку Near-SDK, которая заставляет наш код работать на Near. Также увидим шаблоны доступа и принципы разработки смарт-контрактов, просмотрев код этого смарт-контракта. Вы можете найти полный репозиторий со всем кодом, который мы сегодня обсудим, на моем GitHub.
Смарт-контракт Near Rust SDK
По своей сути среда выполнения смарт-контрактов Near использует WebAssembly (Wasm). Wasm — это хорошо зарекомендовавший себя формат байт-кода, который также используется вне блокчейна, например, в веб-приложениях. Это хорошо для Near, поскольку его среда выполнения может извлечь выгоду из работы, проделанной в более широком сообществе Wasm.

Компилятор Rust хорошо справляется с созданием вывода Wasm, но для того, чтобы байт-код Wasm правильно работал с его «хостом» (средой выполнения Near в нашем случае или движком JavaScript веб-браузера в веб-приложения). Этот скаффолдинг можно сгенерировать автоматически с помощью удобных библиотек Rust: wasm-bindgen в случае интеграции с браузером и Near-sdk в случае с Near. Смарт-контракт, с которым мы сегодня работаем, написан с использованием Near-SDK.

Обе библиотеки используют процедурные макросы Rust (макросы proc). Это своего рода метапрограммирование, когда библиотека определяет небольшие аннотации, которые мы можем использовать для запуска автоматической генерации кода Rust. Макросы proc в Rust используются для уменьшения объема шаблонного кода, который разработчик должен написать, чтобы его бизнес-логика заработала. Например, макрос proc является ядром языка Rust. Он может автоматически определять общие функции для новых типов данных, которые вы создаете. Вы можете увидеть, как это используется в следующем простом фрагменте кода из смарт-контракта чата:

Вы можете увидеть множество признаков, перечисленных в аннотации производных. Вызов некоторых конкретных: Debug означает, что тип MessageStatus может быть преобразован в строку, чтобы помочь в отладке кода; Clone означает, что можно создать идентичный экземпляр MessageStatus из текущего экземпляра, а Copy означает, что операция Clone дешева; PartialEq и Eq означают, что вы можете сравнить два экземпляра MessageStatus, чтобы убедиться, что они одинаковы. Трейты Serialize и Deserialize берутся из библиотеки serde, повсеместно распространенной в экосистеме Rust для кодирования/декодирования данных из таких форматов, как JSON или CBOR. К чертам Borsh мы вернемся позже.

До сих пор это был стандартный Rust, который вы найдете в любом проекте. Макрос Near-specific proc называется Near_bindgen, который используется в следующем фрагменте кода:

Макрос proc near_bindgen автоматически генерирует дополнительный код, который нам нужен, чтобы при компиляции в Wasm мы получали вывод, который среда выполнения Near понимает как использовать. Он используется во многих местах, где необходим такой связующий код. Здесь он помечает структуру MessengerContract как имеющую состояние, необходимое для выполнения методов контракта. Экземпляр структуры MessengerContract будет создаваться каждый раз, когда мы вызываем метод нашего смарт-контракта. Позже мы обсудим, для чего используются некоторые из этих полей.

Макрос Near_bindgen также используется в блоке impl для структуры MessengerContract:

Здесь это означает, что функции, определенные в этом блоке, представляют собой методы, которые мы хотим предоставить в нашем смарт-контракте. Это позволяет пользователям блокчейна Near отправлять транзакции, вызывая эти функции по имени. Например, в этом блоке определяется способ отправки сообщения. Ниже мы рассмотрим некоторые другие методы из этого блока более подробно.

Таким образом, библиотека near-sdk предоставляет макрос proc с именем near_bindgen для автоматической генерации связующего кода, благодаря которому выходные данные Wasm работают со средой выполнения Near. Этот макрос можно использовать в структуре для определения состояния вашего контракта и в блоке реализации этой структуры для определения общедоступных методов в вашем контракте. Near-sdk также предоставляет другие полезные функции и структуры, которые мы увидим в следующих разделах.
Состояние смарт-контракта
По сути, все нетривиальные смарт-контракты требуют некоторого состояния для правильной работы. Например, контракт токенов должен поддерживать балансы различных держателей токенов. Наш чат-контракт ничем не отличается. В предыдущем разделе мы видели, что структура MessengerContract содержит множество полей. В этом разделе мы обсудим некоторые общие особенности состояния в среде выполнения Near, а также некоторые особенности его использования в примере смарт-контракта.

Самое важное, что нужно знать о состоянии смарт-контракта в Near, это то, что это простое хранилище ключей и значений. Вы можете увидеть это в низкоуровневых функциях storage_read и storage_write, предоставляемых near-sdk. Однако вы можете создать несколько более сложных структур данных поверх этой простой основы, и Near-sdk предоставляет некоторые из них в своем модуле collections. По этой причине наш пример контракта не использует хранилище ключей-значений напрямую; вместо этого он использует коллекции более высокого уровня, предлагаемые near-sdk.

Например, смарт-контракт отслеживает состояние учетных записей, о которых он знает (какие из них являются контрактами, на которые мы отправили запрос на контакт и т. д.). Поле учетных записей в MessengerContract представляет собой структуру LookupMap из Near-sdk. Это довольно близко к прямому использованию хранилища ключ-значение, поскольку также является просто способом поиска значения по ключу, но LookupMap делает две важные вещи помимо необработанного интерфейса хранилища ключ-значение. Во-первых, у него есть префикс, который он включает во все ключи хранилища, связанные с этой картой. Использование префикса предотвращает смешение ключей из этой карты с ключами из другой (например, карты last_received_message, которая также имеет ключ на AccountId). Во-вторых, LookupMap позволяет нам работать с типами Rust более высокого уровня, тогда как необработанный интерфейс хранилища работает только с байтами. Это достигается за счет использования сериализации Borsh для преобразования типов в/из двоичных строк. Borsh — это формат сериализации, разработанный Near для использования в блокчейн-приложениях. Это использование Borsh является причиной того, что BorshDeserialize и BorshSerialize являются производными от многих типов по всему коду.

Более интересным примером используемой здесь коллекции является UnorderedSet в поле unread_messages. Это используется для контракта, чтобы отслеживать, какие сообщения все еще не прочитаны. UnorderedSet по-прежнему основан на базовом хранилище ключей и значений, но эффективно использует только ключи, поскольку нам важно только, находится ли элемент в наборе или нет. Структура также хранит метаданные о том, какие ключи она использует, чтобы мы могли перебирать все ключи в наборе.
Проверка среды и вызов других контрактов.
В этом разделе мы обсудим общие особенности среды выполнения Near и вызовы между контрактами. Это делается в контексте того, как пользователи добавляют друг друга в качестве контактов в нашем чат-приложении. Давайте взглянем на определение функции add_contact (это определение находится в импл-блоке MessengerContact с упомянутой выше аннотацией near_bindgen, потому что это основная точка входа для нашего контракта).

В этих нескольких строках кода есть что рассмотреть. В качестве дополнительной основы для нашего обсуждения вспомните три принципа разработки смарт-контрактов, изложенные в предыдущем посте:

 	враждебное мышление
 	экономика
 	обеспечить инварианты, прежде чем делать кросс-контрактные вызовы.

Вернитесь и просмотрите первый гайд, если вам нужно освежить в памяти эти принципы. Каждый из этих принципов появляется в этой функции.
Враждебное мышление
Все методы смарт-контракта являются общедоступными, и мы должны обеспечить контроль доступа, когда метод выполняет конфиденциальное действие, иначе кто-то будет злоупотреблять функциональностью. В этом случае мы не хотим, чтобы кто-либо мог добавлять контакты от имени владельца; только владелец должен иметь возможность решить, с кем связаться (если кто-то еще хочет установить контакты в сети чата, он может развернуть этот контракт на свою учетную запись!). Поэтому у нас есть вызов require_owner_only() прямо в верхней части тела функции. Реализация этой функции проста:

Он использует функцию Pregence_account_id из модуля env для Near-SDK. Модули env содержат множество полезных функций для запроса аспектов среды выполнения Near, в которой выполняется наш контракт. Например, здесь мы проверяем, какая учетная запись выполнила вызов нашего контракта. Модуль env содержит другие полезные функции, например, для проверки идентификатора учетной записи самого нашего контракта и того, сколько токенов Near было привязано к этому вызову. Я рекомендую прочитать документацию модуля, чтобы увидеть все доступные функции.

Из соображений эффективности функция require_owner_only также возвращает учетную запись-предшественника (чтобы избежать множественных вызовов env::predecessor_account_id() в случае, если функции только для владельца также требуется учетная запись-предшественник по другой причине).
Экономика
Самая первая строка фрагмента кода add_contact выше включает атрибут payable. Использование этой аннотации разрешено функцией, определяемой как часть блока реализации near_bindgen. Это означает, что этот метод будет принимать токены Near от пользователей, которые его вызывают. Эти токены необходимы, потому что мы приняли решение, что пользователи платят за такие действия, как создание состояния в цепочке. Поскольку добавление другой учетной записи в качестве контакта создает состояние в их контракте, а также в нашем (нам нужно сообщить им, что мы хотим подключиться), мы должны убедиться, что пользователь, инициирующий это подключение, платит за это хранилище. Депозит, связанный с этой оплачиваемой функцией, используется для покрытия расходов на хранение.

Вы можете увидеть несколько строк ниже, где мы проверяем наличие депозита. Это использует функцию attach_deposit из модуля env. Тот факт, что мы делаем эту проверку на ранней стадии, прекрасно переходит в третий принцип.
Обеспечьте инварианты, прежде чем делать кросс-контрактные вызовы
Важно обратить внимание на сигнатуру типа функции add_contact. Во-первых, аргументы функции (&mut self, account: AccountId) означают, что это изменяемый вызов (он изменит состояние контракта), и он принимает один аргумент с именем «account», который должен быть идентификатором Near Account ID. Когда close_bindgen совершит свое волшебство, это будет означать, что пользователи блокчейна Near могут вызывать эту функцию, совершая транзакцию, которая принимает аргумент в формате JSON, например { "account": "my.account.near" }. Во-вторых, тип возвращаемого значения — Promise, что означает, что мы делаем кросс-контрактный вызов в конце этой функции. Кросс-контрактные вызовы на Near являются асинхронными и неатомарными, поэтому мы должны убедиться, что все в хорошем состоянии, прежде чем совершать вызов. Вот почему мы включаем в тело функции чек только для владельца и депозитный чек. Асинхронный характер вызовов между контрактами также означает, что эта функция не возвращает немедленного значения. Асинхронный вызов будет выполнен, а результат придет позже, после того, как этот вызов произойдет.

Подробную информацию о кросс-контрактном вызове можно увидеть в нижней части функции. Он использует высокоуровневый API от near-sdk (хотя низкоуровневый API также доступен в модуле env), где функция ext автоматически создается Near_bindgen и возвращает структуру данных для построения кросс-контрактного вызова. Вы можете видеть, что сначала мы используем ext(account) для вызова учетной записи, которую хотим добавить в качестве контакта. Вызов включает наш депозит через with_attached_deposit и вызывает функцию ext_add_contact (которая в данном случае определена в том же блоке impl, но в целом может быть определена где угодно). Наконец, мы вызываем then, что означает включение обратного вызова. Обратный вызов сам по себе является еще одним обещанием, поэтому мы снова используем ту же функцию ext, но на этот раз вызывая идентификатор нашей учетной записи. Это сделано для того, чтобы наш контракт мог знать, какой был ответ от контракта, который мы пытаемся добавить в качестве контакта. Я не буду вдаваться в детали реализации ext_add_contact или add_contact_callback здесь (они просто манипулируют хранилищем в зависимости от текущего состояния учетной записи), но я рекомендую вам прочитать их в исходном коде на GitHub, если вам интересно.
Итог
В этом гайде мы с головой погрузились в код! Мы увидели, как Near_bindgen используется для автоматической генерации кода, необходимого для запуска нашего контракта в среде выполнения Near, а также другие функции Near-SDK для взаимодействия с хранилищем, средой выполнения и другими контрактами. В следующем посте мы продолжим глубокое погружение в код, но переключимся на офчейн-компонент этого приложения. Смарт-контракт сам по себе не представляет собой децентрализованное приложение, следите за обновлениями, чтобы узнать, почему!

Если вы хотите получить практический опыт работы с этим кодом, попробуйте некоторые из упражнений! В нескольких местах кода смарт-контракта я включил комментарий с пометкой EXERCISE. Например, в определении типов я указываю на тот факт, что доступен статус пользователя «Заблокировано», но нет способа заблокировать кого-то, кто в настоящее время реализован. Добавление этой функции для блокировки другого пользователя — одно из рекомендуемых упражнений, с которого стоит начать. Все упражнения представляют собой предложения по расширению функциональности контракта, что дает вам возможность попробовать написать код смарт-контракта самостоятельно. Возможно, в следующих постах этой серии я расскажу о некоторых решениях упражнений.

Если вам нравится эта серия гайдов в блоге, свяжитесь с нами по Type-Driven Consulting. Мы рады предоставить услуги по разработке программного обеспечения для dapps, а также учебные материалы для ваших собственных инженеров.

### BOS là gì? Tìm hiểu về BOS trên NEAR Protocol và tạo widget của riêng bạn

Tháng 3/2023, NEAR Protocol ra mắt BOS (Blockchain Operating System - Hệ điều hành chuỗi khối), là điểm vào lý tưởng cho web mở (Open Web). Ý tưởng ở đây là thu hẹp khoảng cách giữa web2 và web3.

Trong bài viết này, hãy cùng LearnNEARClub tìm hiểu BOS là gì và cách thức hoạt động của nó! 
Open Web là gì?
Open Web (Web mở) là thuật ngữ được sử dụng để mô tả internet khi nó trở thành tài nguyên công cộng toàn cầu không bị kiểm soát bởi những người gác cổng hoặc người giám sát. Open Web cần thiết vì:

 	Open Web cần thiết để giao tiếp và diễn đạt được tự do và cởi mở.
 	Open Web là một mạng internet của mọi người và vì mọi người. Nó trao quyền cho các cá nhân bước vào và đóng góp tích cực cho xã hội.

Ngay từ đầu, tầm nhìn của NEAR là hướng tới Open Web. Vì Open Web cần hoạt động trên môi trường phi tập trung, NEAR cần tạo ra một blockchain Layer 1 dễ sử dụng và có thể mở rộng.

Vậy NEAR có thể làm điều đó không? Hãy xét đến các yếu tố sau:

 	NEAR có mô hình tài khoản linh hoạt, dễ đọc, dễ nhớ.
 	Nightshade sharding giúp NEAR có khả năng mở rộng cực cao.
 	NEAR cũng cung cấp các công cụ mạnh mẽ và đơn giản để giúp các developer xây dựng và phát triển giao thức.

Sau khi đã đặt nền móng, NEAR cần một bộ công cụ web3 để phát triển quá trình giới thiệu Open Web cho cả người dùng và developer.
BOS đạt được Open Web như thế nào?
Hãy nghĩ về chức năng của một hệ điều hành hoặc “OS”. Một hệ điều hành cho phép người dùng tương tác với máy móc một cách đơn giản. Từ khóa ở đây là “đơn giản", việc đơn giản hóa và ẩn hết các thành phần phức tạp là cực kỳ quan trọng đối với việc áp dụng công nghệ cho hàng loạt người dùng.

Bây giờ, tiếp tục logic đó sang web3. Theo Illia Polushkin, đồng sáng lập NEAR Protocol, BOS là một lớp chung để duyệt, tìm kiếm và khám phá các sản phẩm Web3. Ngoài ra, BOS hỗ trợ toàn bộ các blockchain(Ethereum, NEAR, Solana...) cũng như các dịch vụ web2 truyền thống.

Hãy tưởng tượng việc tạo một ứng dụng DeFi mới thú vị trên Ethereum và thu hút người dùng từ NEAR thông qua BOS hoặc chatGPT trên nền của BOS.
Tạo giao diện người dùng có thể kết hợp
Trước khi chúng ta đi xa hơn, hãy hiểu giao diện người dùng là gì. Giao diện người dùng là cách người dùng tương tác với ứng dụng. Khi nói đến dApps, việc tạo ra một ứng dụng có thể kết hợp với các ứng dụng khác và phi tập trung là cần thiết.

Bản chất của web3 là sự phi tập trung. Vậy tại sao chúng ta vẫn phải sử dụng các dịch vụ tập trung để truy cập các dapp này? Việc tin tưởng các bên trung gian tạo ra hàng loạt các thách thức về bảo mật.

BOS giúp thêm giao diện người dùng có thể kết hợp vào ngăn xếp công nghệ và dễ dàng đưa người dùng vào web3. Về tiềm năng của BOS với tư cách là giao diện người dùng, Polusukhin cho biết:

“Các giao diện người dùng phi tập trung có thể kết hợp dưới dạng một framework để hoạt động với mọi giao diện web2 hoặc Web3, tương thích với mọi blockchain. Trong tương lai, chúng tôi sẽ cung cấp ví [sử dụng] từ một blockchain để tương tác với các blockchain khác một cách liền mạch và tự động.”
3 trụ cột chính của BOS
BOS được xây dựng trên 3 trụ cột chính:

 	Gateways - Cổng
 	Components - Các thành phần
 	Blockchains - Hạ tầng blockchain

Gateway - cổng
Gateway (cổng) được thiết kể để cung cấp giao diện cho người dùng cuối một cách phi tập trung, có thể chạy cục bộ(tự tải về máy) hay trên server web cho mọi người. Một gateway bao gồm các máy ảo được thiết kế và tùy biến để tải và chạy các giao diện người dùng cho các protocol như NEAR, Ethereum, Layer2 hoặc các Layer1 khác như Solana…

Tất cả phần code cho các giao diện này được lưu trữ trên NEAR.




	

	
	
		
			
				Mục đích của Hệ điều hành Chuỗi khối (BOS) của Near Protocol là gì? (chọn tất cả ý đúng)
			
		

		
					

		
			Please select 2 correct answers
			
			
			Giúp tạo ra mạng internet phi tập trung, không bị kiểm soát bởi những tác nhân khác nhau
		
			
			Thu hẹp khoảng cách giữa web2 và web3
		
			
			Phát triển một Layer2 có thể mở rộng 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Component - Các thành phần
Component là giao diện người dùng cho các ứng dụng web2 hoặc các ứng dụng on-chain như Lido, Uniswap hay Aave hoặc Ref Finance. Người dùng và developers có thể tự xem code của các ứng dụng này trong gateway như xem code của smartcontract trên Etherscan vậy.

Ngoài ra, người dùng cũng có thể fork (sao chép) các ứng dụng này và chỉnh sửa để triển khai các phiên bản của riêng mình hoặc tự tạo các component mới.

Dưới đây là một component cho phép người dùng tạo một ảnh đại diện của mình:
Blockchain
Các component có thể gọi các chức năng của bất kỳ hạ tầng web2 hoặc bất kỳ blockchain nào. Hiện tại, tất cả các blockchain đều được hỗ trợ. Ngoài ra, mã nguồn cho lớp code giao diện người dùng đều được lưu trữ công khai và minh bạch trên NEAR vì đây là nền tảng hiệu năng cao và phí thấp.

Ngoài ra, người dùng cũng có thể fork (sao chép) các ứng dụng này và chỉnh sửa để triển khai các phiên bản của riêng mình hoặc tự tạo các component mới.
BOS Frontend của NEAR
Cùng xem giao diện người dùng hoạt động như thế nào ở thực tế, truy cập  alpha.near.org

Đây là một gateway giúp kết nối người dùng tới tất cả các tính năng khác nhau trong hệ sinh thái. Bất kỳ ai cũng có thể tạo giao diện người dùng (hay còn gọi là component) của riêng mình, tương thích với các blockchain đã chọn của họ.

Hãy thử khám phá xung quanh với gateway alpha NEAR này và xem cách nó hoạt động thế nào nhé!

Ở phần thanh menu trên, bạn hãy di chuột vào Discover và ấn vào Components

Các component là các ứng dụng nhỏ để giải quyết một vấn đề cụ thể (tưởng tượng nó như một mảnh lego). Có rất nhiều các component được xây dựng sẵn và đóng góp bởi cộng đồng để bạn có thể sử dụng nó để xây dựng giao diện người dùng của riêng mình. Dưới đây là một số component tích hợp sẵn.




	

	
	
		
			
				Gateway trên BOS có chức năng gì?
			
		

		
					

		
			
			
			
			Cung cấp giao diện người dùng tập trung, chạy cục bộ cho mọi người.
		
			
			Cung cấp các công cụ để giúp các developer phát triển giao thức.
		
			
			Lưu trữ mã nguồn cho giao diện người dùng trên NEAR.
		
			
			Giúp tải và chạy giao diện người dùng cho các giao thức được xây dựng trên Ethereum, Layer 2 và các Layer 1 khác.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
Widget là đơn vị nhỏ nhất của giao diện người dùng (frontend). Giống như một mảnh lego, cho phép bạn tạo ra các ứng dụng phức tạp hơn bằng cách soạn thảo và tùy biến các component. 

Code:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Output:

Image Uploader
Image Uploader là một widget cho phép người dùng trực tiếp tải file và hình ảnh của mình lên hệ thống IPFS giúp lưu trữ file phi tập trung.

Code:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Image Uploader là một widget cho phép người dùng trực tiếp tải file và hình ảnh của mình lên hệ thống IPFS giúp lưu trữ file phi tập trung.

Kết quả

Bạn có thể sử dụng nút upload này để tải ảnh lên:

Files
Tải file lên, hỗ trợ kéo thả.

Code:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Kết quả

Markdown
Một component được tích hợp sẵn giúp cho phép tạo markedown

Code:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);

Kết quả

OverlayTrigger
OverlayTrigger cho phép các developer hiển thị văn bản hoặc nội dung trong lớp phủ khi chuột được di qua một mục cụ thể

Code:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Kết quả

InfiniteScroll
Component này cho phép bạn tạo tính năng cuộn vô hạn dễ dàng, hỗ trợ các window và các element cuộn.

Code:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Kết quả

Đây là một list được tạo bởi cuộn vô hạn 

Typeahead
Component này cho phép cung cấp field được tự được điền từ các danh sách lựa chọn có trước. Nói đơn giản thì component này được dùng để tạo các tính năng tự động hoàn thành văn bản.

Code:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Kết quả

Typehead này cho phép bạn chọn các loại trái cây.

Styled Components
Styled Component là công cụ được sử dụng để giúp tạo kiểu cho các React component sử dụng CSS-in-JS

Code:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Kết quả

ToolTip
Component này cho phép tạo tooltip vào các phần tử nhất định, khi chuột trỏ qua các phần tử đó sẽ hiện hộp tooltip.

Code:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

 

Kết quả

Tổng kết
BOS giúp giải quyết những thách thức chính xung quanh việc xây dựng giao diện người dùng web3, chẳng hạn như quyền truy cập, bảo mật, khả năng kết hợp và tính linh hoạt. Với BOS, người dùng có thể chạy các ứng dụng blockchain cục bộ trên máy của mình, giúp đảm bảo tính mạnh mẽ và khả năng chống kiểm duyệt của blockchain trong khi vẫn duy trì trải nghiệm thân thiện với người dùng.

Nếu bạn muốn biết thêm về giao diện BOS, hãy đọc tài liệu tại đây .

### Update – April 24, 2023

Brief Summary:

 	
📚 (L)Earn about NEAR Protocol’s Blockchain Operating System




Results:

 	 (L)Earn "Master Security for Rust Developers on NEAR Protocol"
 	⚡️nCaptcha, a project from ⚗️LNC Barrel, our boutique accelerator is:
#4 on #NEARProtocol and #183 among ALL the dapps on ALL blockchains, according to DappRadar
 	🕺Finally LNC speaks Korean!
 	🏆April Redeem window was like no other! 450 Learners successfully claimed 2 $NEAR!
Over 150 reckless farmers broke their nCaptcha score. Hopefully they learned the lesson.
 	🗳️qVote of the week! "Do you use Aurora?" - Have your quadratic say, (L)Earner 🕺


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Everyone is invited to NEAR Certified Developer Demo day on April 28, 11 am EDT.

### Tìm hiểu dự án Pikespeak

Pikespeak là giải pháp phân tích dữ liệu được xây dựng trên NEAR Protocol, mang tới cho các tổ chức, cá nhân và doanh nghiệp những lợi ích sau:

 	Trực quan hóa dữ liệu cùng với bảng điều khiển của các ứng dụng Web3 thường gặp như DeFi, DAO, game, NFT, …
 	Trình đánh chỉ mục (indexer) và API mạnh mẽ với hơn 50 API cung cấp dữ liệu
 	RPC và Indexer chuyên dụng
 	Dữ liệu tùy chỉnh và thông tin insight

Giải pháp này đã thu hút hơn 400 người dùng sớm và đang được sử dụng bởi các dự án hàng đầu trong hệ sinh thái NEAR bao gồm Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader và Learn NEAR Club.




	

	
	
		
			
				Đối tượng nào sau đây không sử dụng dịch vụ của Pikespeak?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			Tổng thống Hoa Kỳ
		
			
			Tonic DEX
		
			
			Learn NEAR Club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Lý do ra đời dự án Pikespeak
Blockchain không được thiết kế phù hợp cho các công cụ phân tích truyền thống:

 	Truy cập dữ liệu trên blockchain có thể phức tạp, từ đó làm giảm khả năng khám phá và tìm kiếm những cơ hội từ lượng dữ liệu này
 	Trích xuất dữ liệu nhanh chóng, theo quy mô và với chi phí thấp là một thách thức không hề nhỏ và phải được trích xuất từ các hợp đồng thông minh được triển khai trên blockchain




Nói một cách đơn giản, Pikespeak sinh ra với mục đích:

 	Lập chỉ mục, lưu trữ và chuyển đổi dữ liệu trên chuỗi khối thành các bảng dữ liệu mà con người có thể đọc được
 	Trao quyền cho người dùng với hàng loạt phân tích mạnh mẽ

Tiện ích mà Pikespeak mang lại
Những lợi ích của Pikespeak phụ thuộc vào vấn đề mà bạn đang cần giải quyết. Dưới đây là một số ví dụ tham khảo:

 	Người dùng DeFi

 	Danh mục đầu tư hiện tại của tôi có giá trị và những đặc điểm gì?
 	Lãi/Lỗ của tôi trong một khoảng thời gian cụ thể là bao nhiêu?
 	Cơ quan thuế (ví dụ: IRS) yêu cầu nhật ký giao dịch và các hoạt động trên blockchain của tôi trong năm tài chính vừa qua, làm cách nào tôi có thể cung cấp thông tin đó?
 	Tôi quan tâm đến việc nắm giữ một token, nhưng tôi muốn hiểu một số điều; nguồn cung lưu thông là bao nhiêu? Những ai cũng đang nắm giữ token (danh sách cá mập)? Những người nắm giữ nhiều token đang hành động như thế nào? Gần đây họ có bán không? Họ đã giữ token này trong bao lâu? …
 	Tôi muốn biết những giao dịch mua/bán token lớn nhất trong 24 giờ qua?




 	Các công ty đầu tư mạo hiểm

 	Danh mục đầu tư của tôi có giá trị và những đặc điểm gì?
 	Kế toán của tôi đang yêu cầu nhật ký hoạt động trên blockchain của công ty, làm cách nào tôi có thể cung cấp thông tin đó?
 	Đâu là những dự án hoạt động tích cực nhất trong danh mục đầu tư?
 	Các công ty trong danh mục đầu tư của tôi có bao nhiêu người dùng hoạt động?
 	Một trong những công ty trong danh mục đầu tư đang khẳng định rằng sản phẩm của họ đang có sức hút lớn, làm cách nào tôi có thể xác minh thông tin này?






	

	
	
		
			
				Bạn có thể làm gì với Pikespeak? (Chọn 3 đáp án đúng)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Tải xuống tất cả hoạt động của một ví tiền mã hóa ở định dạng CSV
		
			
			Kiểm tra hoạt động và các thông số quan trọng của một hợp đồng thông minh bất kỳ
		
			
			Phân tích đánh giá lịch sử giao dịch của một tài khoản bất kỳ
		
			
			Dự đoán giá của một token với độ chính xác 100%
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Chủ dự án

 	Tôi đang gây quỹ và muốn biết quy mô thị trường trong phân khúc của mình (ví dụ: dự án game), có bao nhiêu người dùng đang hoạt động trong mảng này? Ai đang dẫn đầu trong phân khúc này? Thị phần của các dự án cạnh tranh như thế nào?
 	Tôi muốn airdrop cho các địa chỉ cụ thể dựa trên danh mục đầu tư và hoạt động của họ, tôi có thể truy cập vào danh sách các địa chỉ đó không?
 	TVL dự án của tôi đang là bao nhiêu?
 	Tại sao dự án của tôi giảm 20% TVL vào một ngày cụ thể này?




 	Lãnh đạo tiếp thị dự án (Project Marketing Leaders)

 	Gần đây tôi đang hỗ trợ/dẫn dắt một chiến dịch tiếp thị, làm thế nào để đưa chiến dịch đó sang giai đoạn thu hút người dùng?
 	Tôi muốn thúc đẩy hợp tác tiếp thị với một dự án khác, cơ sở người dùng của tôi có thể hiện sự quan tâm hay tương tác tích cực với dự án này chưa? Cộng đồng của hai dự án có mối liên kết chặt chẽ đến mức nào?
 	Tôi muốn thưởng/airdrop cho các địa chỉ ví cụ thể dựa trên danh mục đầu tư và hoạt động của họ, làm thế nào để tôi có thể truy cập vào danh sách các địa chỉ đó?




 	Trưởng nhóm sản phẩm của dự án (Project Product Leaders)

 	Tỷ lệ giữ chân người dùng đang là bao nhiêu?
 	Đâu là các tính năng được sử dụng nhiều nhất?
 	Một dự án cạnh tranh đã tung ra một tính năng mới, nó đã được cộng đồng đón nhận như thế nào? Nó có thu hút người dùng không?
 	Có bao nhiêu người dùng sản phẩm của tôi đang sử dụng các ứng dụng cạnh tranh? Họ chi bao nhiêu cho các ứng dụng đó?




 	Chủ sở hữu Validator

 	Tại sao validator của tôi giảm đi 20% số người stake vào ngày hôm qua?
 	Tôi thấy rằng 1 triệu token NEAR đã bị unstake ngày hôm qua, danh sách địa chỉ ví nào đã làm việc?
 	Tôi có bao nhiêu người stake và so với validator đang cạnh tranh với tôi thì tỉ lệ hơn/thua là bao nhiêu?
 	Validator của tôi đã tích lũy được bao nhiêu phần thưởng từ khi bắt đầu?




 	Chủ sở hữu các DAO

 	Trong kho bạc của DAO đang có bao nhiêu tài sản?
 	Có bao nhiêu thành viên DAO đã bỏ phiếu cho đề xuất gần nhất?
 	Có thành viên nào trong DAO của tôi có liên quan đến các DAO khác không? Nếu có thì đó là những địa chỉ ví nào?
 	DAO của tôi đã thanh toán bao nhiêu khoản trong năm qua? Và tổng số tiền là bao nhiêu?




 	Quản lý ngân quỹ của hệ sinh thái

 	Có bao nhiêu khoản tài trợ đã được trao trong năm qua? Và tổng số tiền là bao nhiêu?
 	Những người được cấp liên quan đến dapp của tôi đang hoạt động tốt như thế nào theo các tiêu chí: số lượng giao dịch, số người dùng hoạt động, quản lý ngân quỹ?
 	Gần đây các quỹ hệ sinh thái khác đã phân bổ vốn như thế nào? Các dự án đang được hỗ trợ là gì?




 	Cơ quan quản lý và/hoặc Điều tra viên AML (chống rửa tiền)/KYC(xác minh danh tính)

 	Mối quan hệ giữa địa chỉ này và địa chỉ khác là gì?
 	Địa chỉ này có liên quan đến một vụ hack, có sàn giao dịch nào đã được nó sử dụng để rút tiền?
 	Những sàn giao dịch nào đã được sử dụng cho địa chỉ độc hại này?
 	Một vài vụ hack có cùng phương thức hoạt động nhưng được tạo bởi các địa chỉ khác nhau, chúng có mối liên hệ nào không?
 	Tất cả các tương tác trên blockchain của một địa chỉ cụ thể là gì?




 	Blockchain Engineers

 	Một giao dịch cụ thể không thành công, tôi có thể kiểm tra và phân tích giao dịch để hiểu điều gì đã xảy ra không?
 	Phí gas của giao dịch cụ thể này là bao nhiêu?






	

	
	
		
			
				Pikespeak mang lại lợi ích cho những đối tượng nào sau đây (Chọn 3 đáp án đúng):
			
		

		
					

		
			Please select 3 correct answers
			
			
			Các tổ chức và các quỹ đầu tư trên hệ sinh thái NEAR
		
			
			Thợ làm pizza ở Napoli
		
			
			Các dự án, Dapp được xây dựng trên NEAR
		
			
			Người dùng DeFi và thực hiện giao dịch trên NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Dữ liệu thật tuyệt vời và những câu chuyện còn tuyệt hơn
Chi phí để truy cập dữ liệu trên blockchain là không đáng kể so với các thị trường truyền thống và tư nhân như các sàn giao dịch chứng khoán hay các phân tích chuyên sâu về khách hàng cho một ngành cụ thể. Điều đó tạo ra cơ hội cho nhiều bên như các nhà báo, nhà điều tra viên hoặc bất kỳ loại hình báo chí, phân tích thông tin dân chủ nào.Chất lượng và mức độ phủ sóng của sự cố FTX trên Twitter là một minh họa tuyệt vời cho xu hướng đó.

Ngoài ra, mô hình đóng góp tin tức để kiếm tiền từ NEARWEEK (Bạn có thể nhận 0.5 NEAR cho mỗi tin tức) là một cách làm sáng tạo nhằm khuyến khích báo chí và thúc đẩy mọi người tham gia vào quá trình sản xuất nội dung dạng tin tức trong môi trường phi tập trung.

Dưới đây là danh sách các sự kiện có khả năng dẫn đến những câu chuyện thú vị và sâu sắc. Chúng tôi muốn khuyến khích cộng đồng LNC tận dụng Pikespeak để kể những câu chuyện tuyệt vời:

 	Ngày 23 tháng 6 năm 2022 – 39 triệu token $NEAR đã unstake từ các validator
 	Ngày 4, 5 và 6 tháng 3 năm 2023 – Near Social (social.near) đã có một lượng lớn người dùng mới
 	Ngày 8 tháng 3 năm 2023 – Hợp đồng nhiều người gửi (multisender.app.near) (tạo nhiều lần chuyển khoản trong cùng một giao dịch) đã gửi 1,13 triệu đô la đến nhiều địa chỉ, giao dịch lớn nhất kể từ khi hợp đồng này được tạo ra

Liên hệ với Pikespeak
Didier Pironi

Email: didier@pikespeak.ai

### Cómo la Prueba de Conocimiento Nulo (ZKP por sus siglas en inglés, Zero Knowledge Proof) Puede Garantizar la Privacidad de los Datos

Probablemente, te hayas topado con las expresiones "si es gratis, tú eres el producto" o "los datos son el nuevo petróleo", y te hayas reído como un tonto. La verdad es que los datos son la fuerza que impulsa casi todos los negocios y servicios. Por ejemplo, las experiencias y los servicios personalizados, el marketing y una serie de otros conocimientos y servicios dependen del volumen y la calidad de los datos que se les proporcionan. La mayoría de las empresas están ansiosas por acceder a los datos para ayudar a comprender mejor a sus clientes, predecir los patrones de comportamiento de los clientes y mejorar la calidad de sus servicios.

El espacio tradicional siempre ha estado sujeto a preocupaciones en torno a los datos y la privacidad. Los defensores de la privacidad han señalado durante mucho tiempo sus preocupaciones sobre cómo se almacenan los datos, cómo se accede a ellos y quién tiene acceso a ellos. Con el crecimiento del ecosistema de criptomonedas y blockchain, también han surgido preocupaciones similares en este sector. La naturaleza pública de las cadenas de bloques ha introducido varias preocupaciones de privacidad para los usuarios con respecto a la protección de su información personal. En este artículo analizaremos más de cerca el problema de la privacidad en las cadenas de bloques y cómo las pruebas de Conocimiento Nulo - (Zero Knowledge - ZK) pueden mitigarlos.
¿Qué es la privacidad de datos?
El aumento en el uso de Internet le ha dado gran importancia al tema de la privacidad de datos, ya qué casi todos los sitios web, aplicaciones y plataformas de redes sociales recopilan y almacenan información personal de los usuarios para proporcionar ciertos servicios. Sin embargo, estas plataformas y sitios web a menudo no cuentan con las medidas de seguridad adecuadas para proteger los datos recopilados, lo que da lugar a numerosas filtraciones de datos.

Con el crecimiento de la tecnología blockchain y el ecosistema cripto, ha habido una creciente preocupación por la privacidad de los usuarios minoristas e institucionales. Estas preocupaciones se deben principalmente a la naturaleza pública de las cadenas de bloques, ya que la mayoría de las soluciones de Capa 1 y Capa 2 no abordan estos problemas. La privacidad de los datos se refiere a la capacidad de los usuarios para determinar, por su parte, cuándo y cómo se comparte su información con otros. También abarca la capacidad de los usuarios de dictar hasta qué punto se comparten sus datos. Esta información puede incluir sus nombres, ubicación, información de contacto, comportamiento en línea, gustos, disgustos, detalles de transacciones y más.
Confianza, privacidad y la cadena de bloques
En la actualidad, el ecosistema de las criptomonedas está experimentando una conmoción considerable tras el colapso de grandes proyectos como FTX. Sin embargo, la tecnología subyacente que respalda las criptomonedas tiene el potencial de revolucionar la privacidad, la confianza y cómo se aprovecha la confianza. Esto es fundamental en la era de Internet, cuando millones navegan y comparten grandes cantidades de su información personal para acceder a servicios y productos.

La tecnología Blockchain viene inherentemente con problemas relacionados con la privacidad, gracias a su diseño. La naturaleza descentralizada de las cadenas de bloques significa que los nodos que procesan las transacciones o la información tienen acceso a los datos de la cadena de bloques. Por ejemplo, la cadena de bloques de Bitcoin está disponible públicamente y cualquier persona que desee consultar su historial de transacciones hasta su bloque de génesis puede acceder a ella. Ahora, recuerde, Bitcoin es pseudo-anónimo, lo que significa "puntos de datos que no están directamente asociados con un individuo específico [pero donde] se pueden vincular múltiples apariencias de [una] persona".

Suficientes datos pseudo-anónimos permiten identificar a las personas detrás de las transacciones, lo cual es preocupante para los usuarios de blockchain, y hay varias razones para ello. A diferencia de los datos que utilizan las aplicaciones normales, a los que solo unos pocos pueden acceder, los datos de la cadena de bloques pueden ser examinados por todos, lo que también incluye actores maliciosos y entidades que pueden explotar la información de la cadena de bloques para su beneficio. Además, la naturaleza inmutable de la cadena de bloques significa que las transacciones y los datos estarán permanentemente vinculados a la persona. Esto se puede hacer monitoreando la comunicación entre los nodos. Además, las billeteras cripto también se pueden analizar sin acceso a claves privadas, lo que complica aún más las cosas.

Un ejemplo de alto perfil del uso de datos de blockchain para rastrear a una persona fue la investigación y el arresto de Ross Ulbricht, el individuo detrás del infame sitio web darknet "Silk Road", que se utilizó para diversas actividades ilegales. Las agencias de aplicación de la ley identificaron a Ulbricht como el individuo detrás de Silk Road, gracias a los datos de la cadena de bloques. Además, podrían rastrear las transacciones de Bitcoin y determinar que un agente de la Administración de Control de Drogas (DEA) de EE. UU. estaba lavando BTC conectado a Silk Road. En este caso, los organismos encargados de hacer cumplir la ley pudieron rastrear los datos disponibles en la cadena de bloques para identificar a un individuo notorio. Pero imagine si las entidades malintencionadas pudieran rastrear sus datos con tanta facilidad gracias a la naturaleza pública de la cadena de bloques. Los resultados serían devastadores.
Introducción a las pruebas de conocimiento cero o nulo
Silvio Micali, Shafi Goldwasser, y Charles Rackoff hablaron por primera vez sobre las Pruebas de Conocimiento Cero (o Nulo) en un artículo titulado "La complejidad del conocimiento de los sistemas de prueba interactivos" (“The Knowledge Complexity of Interactive Proof Systems”), y se consideran una innovación fascinante de la criptografía que se puede utilizar en varios escenarios. En el caso de la cadena de bloques, puede ayudar a permitir transacciones seguras y anónimas. El Zero Knowledge Proof (Prueba de Conocimiento Nulo), también conocido como Zero Knowledge Protocol (Protocolo de Conocimiento Cero), permite que una parte (el probador) demuestre a la otra parte (verificador) que conoce un valor o información específica (x) sin revelar ninguna información aparte del hecho de que conoce el valor o información en cuestión (x). El desafío cuando se trata de Prueba de conocimiento cero es justificar la posesión de la información sin revelarla ni revelar ninguna otra información adicional. Una prueba de conocimiento cero debe satisfacer los siguientes criterios.

 	Completitud – supongamos que la declaración es verdadera. Un verificador honesto, siguiendo correcta y fielmente el protocolo, será convencido por la información dada por el probador que está siguiendo correctamente el protocolo.
 	Solvencia – la solvencia significa que no debe haber forma de que el probador falsifique ninguna información o convenza falsamente al verificador. La falsificación debe ser imposible.
 	Conocimiento Cero – si la declaración del probador es verdadera, el verificador no sabe nada más que el hecho de que la información es verdadera.

Los dos primeros se consideran propiedades de sistemas de prueba interactivos más generales, con la adición de conocimiento cero que transforma el proceso de verificación en una prueba de conocimiento cero. Debido a una pequeña posibilidad (error de solvencia) de que un probador malicioso pueda convencer al verificador de una declaración falsa, las pruebas de conocimiento cero se consideran pruebas probabilísticas en lugar de pruebas deterministas. Sin embargo, el error de solidez se puede mitigar a un valor insignificante.




	

	
	
		
			
				¿Qué criterios debe satisfacer una Prueba de Conocimiento Cero?
			
		

		
					

		
			
			
			
			Completitud
		
			
			Solvencia
		
			
			Conocimiento Cero
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo funciona ZKP (PCC/N)?

Créditos de la imagen

Una Prueba de Conocimiento Cero consiste en tres acciones que ocurren secuencialmente entre los participantes. Estas acciones se denominan testigo, desafío y respuesta. Profundicemos un poco más para comprender mejor el papel de cada acción, suponiendo que hay dos participantes, A y B.

Testigo – Supongamos que A conoce un valor o información específica, que también determina un conjunto de preguntas. Estas preguntas siempre pueden ser respondidas correctamente por A. Inicialmente, A puede elegir cualquier pregunta aleatoria del conjunto, calcular la prueba y enviársela a B.

Desafío – Después del paso de testigo viene la fase de desafío, donde B elige una pregunta del conjunto y le pide a A que la responda.

Respuesta – Luego A calcula la respuesta y se la envía de regreso a B. Esto le permite a B determinar si A realmente sabe la respuesta.

El proceso descrito anteriormente se puede repetir tantas veces como sea necesario hasta que se establezca que A sabe la respuesta correcta y la probabilidad de adivinar se vuelve lo suficientemente baja.




	

	
	
		
			
				El documento "La complejidad del conocimiento de los sistemas de prueba interactivos" fue escrito por
			
		

		
					

		
			
			
			
			Silvio Micali, Shafi Goldwasser, Charles Rackoff
		
			
			Silvio Micali, Charles Hoskinson, Charles Rackoff
		
			
			Vitalik Buterin, Shafi Goldwasser, Satoshi Nakamoto
		
			
			Charles Hoskinson, Satoshi Nakamoto, Vitalik Buterin
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de uso de ZKP (PCC/N)
ZKP se puede aplicar en varios escenarios.
Sistemas de autenticación
Los sistemas de autenticación han jugado un papel crucial en el fomento de la investigación en Pruebas de Conocimiento Cero. En estos sistemas, una parte desea demostrar su identidad a una segunda parte a través de alguna información secreta. Sin embargo, no desea que la segunda parte obtenga ningún conocimiento sobre esta información secreta.
Confidencialidad
Uno de los casos de uso más importantes de ZKP se presenta en transacciones que requieren total confidencialidad. Veamos cómo: Considere una cadena de bloques como la cadena de bloques de Bitcoin. Generalmente, cuando ocurre una transacción en esta cadena de bloques, los datos relacionados con la transacción se registran en la cadena de bloques. Esto significa que cualquiera puede reunir cierta cantidad de información sobre la transacción analizando los datos en la cadena de bloques. Por el bien de la privacidad, es fundamental ocultar algunos detalles para transacciones específicas. ZKP permite ocultar detalles al tiempo que garantiza la validez de la transacción al agregarlos a un nuevo bloque.
Información Personal
Digamos que deseas tomar un préstamo de un banco. Para solicitar el préstamo, deberás aportar una gran cantidad de documentación qué consiste en una cantidad considerable de información personal, poniéndola a disposición de terceros. En el caso de obtener un préstamo de un banco, la única información requerida por el banco es saber si un individuo gana una cantidad específica suficiente para pagar el préstamo. ZKP puede ayudar a los bancos a verificar si una persona gana una cantidad mínima predefinida sin revelar ninguna información confidencial al banco o a un tercero.
ZKP (PCC/N) y Blockchain: el camino a seguir
Varios proyectos y criptomonedas utilizan ZKP, como ZCash, SmartCash, Zerocash y ZeroVert. ZKP se ha implementado principalmente a través de zk-SNARKS y zk-STARKS. zk-SNARKS fue desarrollado originalmente por ZCash. La mayoría de las cadenas de bloques son pseudo-anónimas, lo que significa que la identidad de un usuario se puede rastrear hasta sus transacciones mediante el estudio de los datos de la cadena de bloques. Esta información está disponible para todos los que tienen acceso a la cadena de bloques y cualquier entidad malintencionada podría explotarla.

A pesar de la reputación de blockchain como el pináculo de la ciberseguridad, esta deficiencia en particular es bien conocida por los usuarios. Sin embargo, ZKP podría ayudar a reparar esta vulnerabilidad y garantizar una total privacidad cuando se trata de información personal. Si bien ZKP todavía tiene algunos desafíos que superar, brinda a los usuarios el control de sus datos y privacidad, limita el acceso a terceros y desempeñará un papel crucial en la mejora de la privacidad cuando se trata de las cadenas de bloques.




	

	
	
		
			
				Los ZKP son utilizados por
			
		

		
					

		
			
			
			
			ZCash
		
			
			SmartCash
		
			
			Zerocash
		
			
			ZeroVert
		
			
			Todos los anteriores
		
	
		

		
		
			
				Correct!
				Wrong!

### Como fazer stake de NEAR

Fazer stake no ecossistema NEAR é um nicho próspero que oferece uma variedade de abordagens e soluções. Vamos dar uma olhada em diferentes opções de stake e pensar sobre qual é a mais adequada para você.

Para facilitar a comparação, avaliaremos cada opção com base em três parâmetros: interface do usuário (UI), rendimento percentual anual (APY), taxas de retirada e segurança.
Staking NEAR Padrão
Como o NEAR opera em um mecanismo de consenso de prova de participação delegada (DPOS), cada detentor de token NEAR pode delegar seus tokens a um validador específico. Uma lista completa de validadores está disponível em https://explorer.shardnet.near.org/nodes/validators. Basta escolher um validador de sua preferência e delegar seus tokens a ele. O validador receberá uma comissão por isso, que é indicada antes da seleção, e você receberá um retorno em tokens NEAR. Normalmente, não passa de 9,7% ao ano.

Pode parecer fácil, mas imagine que você acabou de comprar seus primeiros tokens NEAR e deseja obter um retorno. Além disso, você deve esperar 3 dias para retirar seu NEAR do stake e, se quiser retirar instantaneamente, terá que pagar uma taxa. Além disso, você precisa confiar em um dos validadores aos quais delega seus tokens.




	

	
	
		
			
				Quanto tempo você tem que esperar para retirar seu NEAR da aposta padrão?
			
		

		
					

		
			
			
			
			3 dias
		
			
			1 dia
		
			
			Uma semana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Stake Centralizado de NEAR
As trocas centralizadas há muito tempo vêm com mecanismos para aumentar ainda mais seus lucros por meio de ferramentas adicionais. Um deles é o staking de tokens em corretoras. Assim como com todos os fundos que você armazena em uma corretora, você não os possui. O mesmo vale para staking. Embora as próprias corretoras usem seus nós de blockchain para isso, em essência, todos os seus fundos estão com eles.

Esta solução é perfeitamente legítima quando estamos falando de usuários que não estão ativamente imersos na Web3 e estão acostumados a simplesmente comprar suas moedas favoritas nas corretoras. Atualmente, mais de 1 milhão de pessoas possuem NEAR na Binance. Existe o risco de invasão ou roubo de seus fundos, como visto no FTX. Além disso, a lucratividade em uma CEX é muito menor do que no DeFi – 3% para staking flexível (com retirada instantânea).




	

	
	
		
			
				Em que tipo de stake você não possui seus fundos?
			
		

		
					

		
			
			
			
			Meta pool de stake
		
			
			HERE staking
		
			
			Stake Centralizado
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Metapool e Linear
As opções de staking Metapool e Linear já são consideradas nativas no ecossistema NEAR. Para fazer stake de NEAR, você precisará ter uma carteira NEAR e alguns tokens NEAR. Esse tipo de staking é melhor do que as outras duas opções porque é gerenciado por projetos dentro do ecossistema e tem um APY decente em torno de 9,4%, o que também é importante. Ambos os projetos passaram por uma auditoria da BlockSec e não tiveram nenhum problema de segurança.

No entanto, alguém novo no ecossistema precisará encontrar um desses projetos e confiar a eles seus fundos, e também precisará visitar regularmente o site do projeto. Também é importante ter em mente que há uma taxa adicional para retirar instantaneamente NEAR do stake.


HERE Wallet Staking
Acho que você já percebeu quem merece mais atenção em termos de stake. Como o HERE é um método de integração simples não apenas para criptografia, mas também para usuários da web2, o staking também deve ser simples e não causar problemas para alguém que não esteja familiarizado com criptografia.

É por isso que criamos um mecanismo de staking sem bloqueio, onde você pode retirar seu NEAR a qualquer momento sem nenhuma taxa e ainda receber renda passiva. Isso é possível graças à reserva de liquidez do contrato, assim como nos bancos comuns, quando 90% é usado, mas sempre há dinheiro no caixa eletrônico. O retorno sobre o investimento varia dependendo de quão ativamente você deposita/retira fundos e, em média, é de cerca de 9,8%. Proprietários de certos NFTs, como os primeiros usuários da HERE Wallet, também podem receber renda adicional.

Além disso, o próprio processo de staking é o mais simples possível. Tudo o que você precisa fazer é pressionar um botão. Depois disso, a quantidade necessária de NEAR será automaticamente retirada antes de qualquer transação ser feita.

Atualmente, o HERE Staking passou por uma auditoria com a equipe da OtterSec.




	

	
	
		
			
				Qual é a taxa para retirada instantânea de stake NEAR do HERE?
			
		

		
					

		
			
			
			
			1.5%
		
			
			0%
		
			
			3.2%
		
	
		

		
		
			
				Correct!
				Wrong!

### Обзор кошелька Meteor

Кошелек Meteor направлен на достижение нескольких ключевых целей, таких как содействие массовому внедрению web3 и превращение в лучший кошелек NEAR. Он стремится создать здоровую конкуренцию с другими известными проектами, такими как MyNear, Sender, HERE и собственный кошелек NEAR.
Введение
Технология блокчейн представляет собой мир бесконечных возможностей, в том числе финансовой автономии. Однако для новичков это непросто понять сложный мир блокчейна.

Почему это сложно? Главным образом, потому что свобода, которая является главной мотивацией для многих из нас, приходит вместе с ответственностью. Эта ответственность включает в себя управление своими действиями, потерями, инвестициями, возможными мошенничествами, активами и кошельками. В децентрализованном Интернете сохранение вашей криптовалюты полностью зависит только от вас, без необходимости полагаться на кого-либо еще.

Однако, принятие ответственности - это не единственный барьер для входа в мир криптовалюты. Сложность понимания многих децентрализованных приложений (Dapps), как с точки зрения их интерфейса, так и функциональности, является еще одним важным фактором, который необходимо учитывать.

Meteor Wallet имеет несколько ключевых целей, таких как облегчение массового принятия web3 и становление лучшим кошельком NEAR. Он стремится создать здоровую конкуренцию с другими заметными проектами, такими как MyNear, Sender, HERE и собственный кошелек NEAR.

Мы имеем удовольствие быть частью исключительной экосистемы, в которой каждый из вышеупомянутых проектов имеет свои уникальные преимущества. Так что же делает Meteor уникальным? Его можно лучше охарактеризовать как мультиван-кошелек.

Термин "мультиван" относится к широкому диапазону функций и возможностей, которые Meteor предлагает в одном пользовательском кошельке. Эти инструменты помогают новым пользователям, которые могут иметь ограниченные знания, в навигации Web3 и мире блокчейна. В последующих абзацах мы рассмотрим некоторые из этих функций и рассмотрим цели Meteor Wallet как проекта Web3.
ЧТО ТАКОЕ КОШЕЛЕК METEOR?

Meteor — это комплексный, удобный кошелек, предназначенный для безопасного и простого управления вашей криптовалютой, а также обеспечивающий доступ к децентрализованным приложениям (dApps) в экосистеме NEAR. В настоящее время Meteor доступен как в виде веб-кошелька, так и в виде расширения для браузера. Его основная цель — стать предпочтительным кошельком, упрощающим работу с блокчейном NEAR для пользователей, и все это в одном мощном приложении кошелька.
ФУНКЦИИ
Знакомство обычных пользователей с web3 может быть сложной задачей. Вот почему в Meteor мы внедрили и планируем внедрить несколько функций, чтобы упростить процесс адаптации для всех участников.
СОЗДАНИЕ ИМЕННОГО КОШЕЛЬКА БЕСПЛАТНО
Meteor предлагает бесплатный именной кошелек — интуитивно понятную функцию, которую можно настроить менее чем за минуту. Этот удобный вариант, он намного удобнее, чем использование традиционных буквенно-цифровых адресов, которые трудно запомнить. Если вы заинтересованы в создании собственного бесплатного именованного кошелька Meteor, внимательно следуйте этому пошаговому руководству. Нажмите здесь чтобы начать.

Для начала вам необходимо создать пароль. После настройки кошелька у вас будет возможность персонализировать свой профиль и даже подключить его к Near Social. Если вы не импортируете существующий кошелек, обязательно запишите свою новую сид-фразу.

(Нажмите здесь, чтобы просмотреть руководство по импорту существующего кошелька).

если вы по какой-либо причине предпочитаете использовать традиционный адрес вместо бесплатного именованного кошелька, Meteor также предоставляет возможность создать неявную учетную запись, как показано на изображении выше.




	

	
	
		
			
				Что позволяет вам делать бесплатный именованный кошелек?
			
		

		
					

		
			
			
			
			создать персонализированный легко запоминающийся адрес
		
			
			изменить буквенно-цифровые символы адреса в любое время
		
			
			отправлять активы на адреса в блокчейнах, отличных от NEAR
		
			
			бесплатный именной кошелек позволяет отправлять и получать текстовые сообщения между кошельками
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





ФУНКЦИОНАЛЬНОСТЬ ОБМЕНА
Функциональность обмена позволяет пользователям без особых усилий обменивать одну криптовалюту на другую в блокчейне не выходя из кошелька. Meteor является первым и единственным кошельком в Near Blockchain, который включает в себя агрегатор свопов, позволяющий пользователям легко сравнивать и экономить с самыми низкими комиссиями и доступными проскальзываниями.

Функции обмена в Meteor усиливают концепцию универсального кошелька. Пользователи могут обменивать до 60 токенов (включая стейблкоины) с авторитетными поставщиками обмена, такими как Ref, Jumbo, Spin и другими.

Чтобы начать изучение функций подкачки в Meteor, нажмите здесь, чтобы получить доступ к руководству пользователя и узнать, как начать работу.



	

	
	
		
			
				Что означает «обмен»?
			
		

		
					

		
			
			
			
			обмен одной криптовалюты на другую
		
			
			получение наград от торговли
		
			
			отправлять средства с одного кошелька на другой
		
			
			процесс вывода средств из кошелька
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







СТЭЙКИНГ
Кошелек Meteor предлагает два варианта стэйкинга: Ликвидный стейкинг и Стандартный стейкинг. Давайте рассмотрим различия между этими двумя механизмами и способы управления ими:

Ликвидный стейкинг — это уникальная функция, которая позволяет вам получить токен квитанции в качестве доказательства права собственности на ваш актив. Этот токен квитанции можно передавать, хранить, продавать и использовать в DeFi или совместимых приложениях. Стандартный стейкинг не предлагает токены квитанций.

Со стандартным стейкингом на Meteor вы можете получать вознаграждение до ~ 10% годовых. Вы можете сравнить и выбрать из более чем 90 валидаторов и пулов и увидеть свой предполагаемый доход. Вы также можете заблокировать свои средства на 7, 30 или 90 дней.

Чтобы использовать стандартный стейкинг в Meteor, просто выполните несколько простых шагов либо в веб-версии, либо в расширении. Вы можете выбрать один из нескольких валидаторов с предполагаемым APY и потенциальными вознаграждениями.

Нажмите здесь, чтобы узнать, как использовать стандартный стэйкинг на Meteor.

Благодаря Ликвидному стейкингу на Meteor и партнерству с Meta Pool мы можем получать квитанционные токены stNEAR при размещении. Эти токены можно использовать для участия в различных мероприятиях DeFi на NEAR и AURORA.

Нажмите здесь, чтобы узнать, как использовать ликвидный стэйкинг на Meteor.




	

	
	
		
			
				В чем основное преимущество использования ликвидного стейкинга по сравнению со стандартным стейкингом на Meteor Wallet?
			
		

		
					

		
			
			
			
			нет никаких потенциальных недостатков при использовании Ликвидного и Стандартного стейкинга
		
			
			вы можете участвовать в нескольких мероприятиях в рамках экосистемы NEAR и получать stNEAR
		
			
			главное преимущество при использовании Ликвидного стейкинга заключается в том, что вы получаете вознаграждения или APY
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFT
Не взаимозаменяемый токен (NFT) — это отдельный цифровой идентификатор, который нельзя дублировать, заменять или разделять. Он записывается в блокчейне (в данном случае NEAR) и используется для подтверждения права собственности и подлинности.

В то время как большинство кошельков с блокчейном позволяют отправлять предметы коллекционирования из одного кошелька в другой, Meteor выделяется, когда дело доходит до NFT. Это единственный кошелек на NEAR, который в реальном времени обновляет минимальную цену и общий уровень каждой коллекции, которой вы владеете. Кроме того, Meteor позволяет вам анализировать черты ваших NFT и даже устанавливать предмет коллекционирования в качестве изображения вашего профиля.

Нажав на коллекцию, вы сможете просмотреть все содержащиеся в ней предметы коллекционирования, а также адрес каждого контракта NFT, индивидуальную минимальную цену и общую минимальную цену всей вашей коллекции NFT. Подробное руководство по использованию функций NFT в Meteor Wallet можно найти здесь.




	

	
	
		
			
				Вы не можете отправлять NFT из Meteor на родной кошелек NEAR
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





ИССЛЕДОВАТЬ
Новая функция «Исследовать» в Meteor Wallet информирует вас о последних событиях в Meteor и экосистеме NEAR, включая новости, связанные с dApps, проектами NFT и DeFi. Это делает Meteor Wallet не только инструментом для управления вашими активами, но и центром для изучения и обновления информации об экосистеме.

Кроме того, в разделе «Изучение» вы можете принять участие в испытаниях «Метеор», где вы сможете заработать награды, используя подход «Учись зарабатывать»! Подробная информация о том, как участвовать в этих мероприятиях, которые часто связаны с партнерскими отношениями с другими проектами, доступна в том же кошельке.

В Meteor скоро появится раздел вознаграждений! Оставайтесь с нами, чтобы не пропустить это захватывающее обновление.




	

	
	
		
			
				В разделе «Испытания» вы можете получать награды за следующие действия:
			
		

		
					

		
			
			
			
			стэйкая свои токены NEAR
		
			
			участвую в мероприятиях проводимых Meteor или их партнерами
		
			
			обменивая токены
		
			
			коллекционируя NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





НАСТРОЙКИ И БЕЗОПАСНОСТЬ
В Meteor безопасность имеет первостепенное значение. Мы настоятельно рекомендуем хранить исходную фразу и пароль кошелька в безопасном месте, известном только вам.

Открыв вкладку настроек, вы увидите следующие параметры:

Подключенные приложения: эта функция позволяет вам подключить свой кошелек к Near Social. В будущем мы планируем добавить возможность подключения вашего кошелька к социальным сетям, таким как Facebook, Twitter и Apple, и это лишь некоторые из них.

Безопасность и восстановление: здесь вы можете просмотреть и извлечь исходную фразу, а также управлять своими закрытыми ключами.

Изменить пароль. Если вы считаете, что пароль вашего кошелька небезопасен, вы можете изменить его в любое время, всегда соблюдая осторожность.

Удалить учетную запись: если по какой-либо причине вы хотите удалить свою учетную запись, вам сначала нужно будет ввести свой пароль, а затем подтвердить удаление. Хотя некоторые могут посчитать эту опцию ненужной, мы считаем, что она имеет решающее значение для обеспечения безопасности и свободы пользователей. Имейте в виду, что удаление учетной записи необратимо.




	

	
	
		
			
				В настоящее время вы можете подключить свой кошелек Meteor к:
			
		

		
					

		
			
			
			
			Facebook, Twitter и Apple
		
			
			вы не можете связать свой Meteor c социальными сетями
		
			
			Near Social
		
			
			к реддит и кроссчейн платформам
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





ПЛАНЫ НА БУДУЩЕЕ
Meteor Wallet готовит несколько интересных обновлений, в том числе:

Meteor Support 2.0: капитальный изменение нашей системы поддержки, который будет включать интеграцию Gleap и систему поддержки с одним тикетом для электронной почты и в кошельке.

Meteor Explore 2.0: доступно еще больше децентрализованных приложений и игр!

Поддержка реестра: запланирована на третий квартал 2023 года.

Социальные входы: в дополнение к Near Social мы планируем добавить поддержку социальных входов через Gmail, Facebook, Twitter, Apple и другие.

Приложения для iOS и Android: запланировано на конец второго квартала 2023 года.

Поддержка Rich Media в NFT: сотрудничество с Harmonic Guild с ориентировочной датой запуска в конце этого года.

### Do you use Aurora?

Do you use Aurora?(Required)
			
					
					Yes
			
			
					
					No
			
			
					
					I do not know what Aurora is
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Tìm hiểu ví Meteor Wallet

Ví Meteor được phát triển với một số mục đích chính như tạo điều kiện để đưa nhiều người dùng mới hơn tới thế giới Web3 và trở thành ứng dụng ví hàng đầu trong hệ sinh thái NEAR. Sự ra đời của ví Meteor cũng tạo động lực cho sự cạnh tranh lành mạnh của các sản phẩm ví khác như MyNearWallet, Sender, HERE Wallet cũng như dự án ví chính thức do NEAR Foundation phát triển.
Giới thiệu
Công nghệ blockchain mang tới rất nhiều cơ hội mới cho người dùng bao gồm khả năng làm chủ tài chính. Tuy nhiên việc điều hướng những người dùng mới tới và khám phá thế giới blockchain là một thách thức không hề dễ dàng.

Lý do khiến cho việc đưa người dùng mới tới không gian Web3 chủ yếu tới từ một nguyên lý: sự tự do - động lực chính trong cuộc sống của nhiều người - luôn đi kèm với tính trách nhiệm cao. Trách nhiệm này bao gồm việc quản lý các quyết định hành động, những rủi ro, tổn thất đối với tài sản của người dùng. Trong thế phi tập trung này, bạn sẽ không còn phụ thuộc vào bất cứ ai và cũng là người duy nhất chịu trách nhiệm bảo vệ tài sản của mình.

Việc nhận hết trách nhiệm về bản thân không phải là rào cản duy nhất đối với người dùng mới tham gia thế giới tiền mã hóa. Một rào cản khác đó là việc bạn phải tìm hiểu cách sử dụng nhiều ứng dụng phi tập trung (Dapps) với hàng loạt cách thức hoạt động phức tạp.

Meteor Wallet ra đời với mục tiêu tạo điều kiện để người dùng mới dễ dàng khám phá thế giới Web3 và trở thành ví hàng đầu trong hệ sinh thái NEAR, đồng thời thúc đẩy sự cạnh tranh lành mạnh với các ứng dụng ví đáng chú ý khác như MyNearWallet, Sender, HERE và cả ví do NEAR Foundation phát triển.

Chúng tôi cảm thấy may mắn khi trở thành một phần của hệ sinh thái đặc biệt này, nơi mỗi dự án nói trên đều có những thế mạnh riêng. Vậy điều gì làm nên sự khác biệt của Meteor Wallet? Chúng tôi tự tin cho rằng đây là ứng dụng ví “tất cả trong một” với những tính năng cần thiết nhất cho người dùng.

Thuật ngữ “tất cả trong một” thể hiện việc Meteor Wallet đã gói gọn một loạt những tính năng trong một ứng dụng ví duy nhất và vẫn đảm bảo độ thân thiện với người dùng. Những công cụ mà chúng tôi mang tới sẽ hỗ trợ những người dùng mới - những người chưa có nhiều trải nghiệm trong thế giới blockchain và Web3. Tiếp theo đây, chúng ta sẽ đi sâu vào những tính năng chính của Meteor Wallet và mục tiêu mà sản phẩm hướng tới.
Ví Meteor Wallet là gì?

Ví Meteor là một ví dễ sử dụng, thân thiện với người dùng và được thiết kế để bạn quản lý tài sản một cách an toàn và đơn giản, đồng thời cũng giúp dễ dàng truy cập và sử dụng các ứng dụng phi tập trung (dApp) trong hệ sinh thái NEAR. Hiện tại bạn có thể sử dụng ví Meteor phiên bản web hoặc phiên bản tiện ích mở rộng của trình duyệt web. Mục tiêu chính mà ví Meteor hướng tới là trở thành ứng dụng ví được yêu thích và giúp đơn giản hóa trải nghiệm người dùng trên blockchain NEAR.
Các tính năng nổi bật
Việc giới thiệu người dùng mới đến trải nghiệm thế giới Web3 là một nhiệm vụ đầy thách thức. Đó cũng là lý do Meteor đã lên kế hoạch và triển khai một số tính năng nhằm đơn giản hóa quá trình trải nghiệm Web3 cho người dùng mới.
Tạo ví NEAR có tên miễn phí!
Meteor cho phép bạn tạo ví NEAR có tên hoàn toàn miễn phí và bạn chỉ mất chưa tới một phút để tạo thành công một ví NEAR mới. Đây cũng là một tính năng vô cùng tiện lợi nếu đem so sánh với việc sử dụng ví có địa chỉ là những dòng chữ và số dài ngoằng và khó ghi nhớ. Nếu bạn muốn tạo ngay một ví NEAR có tên mới mà lại còn miễn phí thì đừng chần chừ và làm ngay theo hướng dẫn này nhé.

Để bắt đầu tạo ví mới, bạn cần tạo một mật khẩu cho ứng dụng Meteor Wallet. Ngay khi bạn thiết lập xong ví của mình, bạn có thể cá nhân hóa hồ sơ của mình trên ví và thậm chí có thể kết nối ngay ví của mình với ứng dụng Near Social. Trong trường hợp bạn tạo một ví NEAR hoàn toàn mới, hãy nhớ lưu lại và bảo mật thật tốt cụm từ bảo mật của mình nhé.

(Bạn hãy làm theo hướng dẫn này để đăng nhập ví NEAR mà bạn có sẵn vào ứng dụng Meteor Wallet)

Ngoài ra, nếu bạn vẫn thích sử dụng loại địa chỉ truyền thống địa chỉ dài thay vì ví dạng .near ngắn gọn, Meteor vẫn hỗ trợ bạn tùy chọn tạo tài khoản dạng này nhé (minh họa trong hình trên - “Use Implicit Account”).




	

	
	
		
			
				Ví có kèm tên miễn phí cho phép bạn làm gì?
			
		

		
					

		
			
			
			
			Tạo một địa chỉ ví dễ nhớ, cá nhân hóa
		
			
			Thay đổi các ký tự chữ và số của địa chỉ ví bất cứ lúc nào
		
			
			Gửi tài sản vào địa chỉ ví không phải trên hệ sinh thái NEAR
		
			
			Cho phép bạn gửi và nhận tin nhắn giữa các ví khác nhau
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tính năng hoán đổi token
Chức năng hoán đổi token (swap token) cho phép người dùng dễ dàng swap giữa hai loại token khác nhau mà không cần phải rời khỏi ứng dụng ví. Ví Meteor là ứng dụng ví đầu tiên và duy nhất trên NEAR kết hợp công cụ hoán đổi tổng hợp, cho phép người dùng dễ dàng so sánh và tiết kiệm hơn với mức phí giao dịch và độ trượt giá thấp nhất hiện nay!

Tính năng hoán đổi token một lần nữa củng cố khái niệm “tất cả trong một” mà chúng tôi đã miêu tả về ví Meteor. Người dùng ví có thể hoán đổi hơn 60 loại token khác nhau (bao gồm cả stablecoin) với những sàn giao dịch phi tập trung uy tín nhất như Ref, Jumbo, Spin, …

Hãy nhấp vào đây để được hướng dẫn và trải nghiệm ngay tính năng hoán đổi token của Meteor Wallet.




	

	
	
		
			
				“Hoán đổi token” nghĩa là gì?
			
		

		
					

		
			
			
			
			Trao đổi một loại token lấy một loại token khác
		
			
			Nhận phần thưởng khi giao dịch mua/bán token
		
			
			Chuyển tài sản từ ví này sang ví khác
		
			
			Quá trình rút tài sản về ví
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Staking
Meteor Wallet mang tới hai tùy chọn Staking là Staking kiểu truyền thống và Liquid Staking. Sau đây, chúng ta sẽ đi vào chi tiết sự khác nhau giữa hai kiểu staking này.

Liquid Staking là một tính năng vô cùng độc đáo, cho phép bạn sử dụng receipt token của mình như một bằng chứng cho việc bạn đang sở hữu token được stake(tương tự như sổ tiết kiệm đại diện cho số tiền bạn gửi ngân hàng). Hóa đơn này có thể được chuyển nhượng, lưu trữ hay giao dịch và thậm chí được sử dụng trong các ứng dụng DeFi hoặc dApp khác. Kiểu Staking truyền thống thì không trả hóa đơn staking như Liquid Staking.

Với kiểu Staking truyền thống trên ví Meteor, bạn có thể nhận được phần thưởng staking lên tới gần 10% APY. Bạn có thể so sánh và lựa chọn trong hơn 90 trình xác thực và pool staking khác nhau, ngoài ra Meteor Wallet cũng sẽ ước tính khoản tiền thưởng bạn sẽ nhận được nếu lựa chọn stake token vào một trình xác thực cụ thể. Bạn cũng có thể lựa chọn sẽ stake token của mình trong khoảng thời gian bao lâu (7, 30 hay 90 ngày).

Để sử dụng tính năng Staking kiểu truyền thống trên ví Meteor, bạn chỉ cần làm theo một số bước đơn giản trên phiên bản Web của ứng dụng hoặc phiên bản mở rộng của trình duyệt. Bạn có thể lựa chọn từ nhiều trình xác thực và xem được ngay APY và lượng token thưởng dự kiến sẽ nhận được.

Bạn có thể làm theo hướng dẫn này để thực hiện Staking tiêu chuẩn trên ví Meteor.

Với tính năng Liquid Staking trên Meteor, nhờ sự hợp tác của chúng tôi với Meta Pool, bạn có thể stake NEAR và nhận về token biên lai là stNEAR. Bạn có thể sử dụng token stNEAR này trên một số ứng dụng DeFi khác nhau trên NEAR cũng như Aurora.

Bạn sẽ tìm thấy hướng dẫn chi tiết để thực hiện Liquid Staking tại đây.




	

	
	
		
			
				Đâu là những ưu điểm khi thực hiện Liquid Staking thay vì Staking kiểu truyền thống trên Meteor Wallet?
			
		

		
					

		
			
			
			
			Liquid Staking không có nhược điểm gì so với Staking kiểu truyền thống trên Meteor Wallet
		
			
			Bạn có thể sử dụng token stNEAR sau khi thực hiện Liquid Staking để tương tác với những ứng dụng khác trong hệ sinh thái NEAR
		
			
			Bạn sẽ không nhận được bất kỳ phần thưởng nào nếu như bạn lựa chọn Staking kiểu truyền thống
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFT
NFT là định danh kỹ thuật số độc nhất và không thể sao chép, không thể thay thế hay chia nhỏ. NFT được lưu trên blockchain(ví dụ NEAR) và được sử dụng để xác minh quyền sở hữu và tính xác thực.

Trong khi hầu hết các ví blockchain cho phép bạn gửi các bộ sưu tập NFT từ ví này sang ví khác thì Meteor có một số điểm nổi trội trong mảng NFT. Đây là ví duy nhất trong hệ sinh thái NEAR cung cấp thông tin cập nhật theo thời gian thực về giá sàn và tổng giá sàn của từng bộ sưu tập NFT mà bạn sở hữu. Không chỉ có vậy, Meteor còn cho phép bạn phân tích các đặc điểm của NFT và thậm chí thiết lập một bộ sưu tập làm ảnh hồ sơ của bạn trên ứng dụng!

Bạn có thể xem toàn bộ các token trong một bộ sưu tập cũng như địa chỉ, giá sàn của từng NFT hay tổng giá sàn của cả bộ sưu tập chỉ bằng một cái click vào ảnh đại diện của bộ sưu tập đó. Bạn có thể tham khảo hướng dẫn này để tìm hiểu chi tiết hơn về tính năng NFT trên ví Meteor.




	

	
	
		
			
				Bạn không thể gửi NFT từ ví Meteor sang ví do NEAR Foudation phát triển, đúng hay sai?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Khám phá hệ sinh thái NEAR
Tính năng Khám phá trong ví Meteor giúp bạn cập nhật những thông tin mới nhất về tình hình phát triển của hệ sinh thái NEAR, bao gồm những tin tức liên quan tới các dApp, các dự án NFT và DeFi. Nhờ đó, ví Meteor không chỉ là một công cụ để quản lý tài sản mà còn là một nơi tập trung kiến thức và cập nhật của cả hệ sinh thái.

Ngoài ra trong phần Explore - Khám phá của ví, tại phần Challenges - bạn có thể tham gia các thử thách Meteor, nơi bạn có thể kiếm về những phần thưởng theo hướng tiếp cận Learn-to-Earn. Trong cùng một ứng dụng Meteor, bạn đã có thể biết thêm được những thông tin chi tiết về các dự án đối tác của chúng tôi.

Meteor Wallet sẽ sớm mang tới cho bạn tính năng Phần thưởng. Hãy chú ý cập nhật những thông tin mới nhất từ chúng tôi nhé!




	

	
	
		
			
				Mục “Challenges” giúp bạn nhận về những phần thưởng thông qua hình thức nào?
			
		

		
					

		
			
			
			
			Stake token NEAR của bạn
		
			
			Tham gia sử dụng các hoạt động DeFi hay trao gửi giá trị được Meteor và các đối tác tổ chức
		
			
			Hoán đổi token
		
			
			Thu thập NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cài đặt & Bảo mật
Đối với Meteor, bảo mật là một trong những tiêu chí quan trọng nhất mà chúng tôi luôn hướng tới. Chúng tôi thật lòng khuyên các bạn hãy lưu trữ cụm từ hạt giống và mật khẩu ví của mình ở một nơi an toàn mà chỉ bạn biết.

Khi bạn mở mục Cài đặt trên ứng dụng, bạn sẽ thấy các tùy chọn sau:

Tùy chọn Connected Apps: là tính năng giúp bạn kết nối ví Meteor với Near Social. Trong tương lai gần, chúng tôi có kế hoạch sẽ thêm một số tùy chọn để bạn kết nối ví với các ứng dụng mạng xã hội nổi tiếng như Facebook, Twitter hay Apple, …

Tùy chọn Security and Recovery: tại đây, bạn có thể xem cụm từ hạt giống cũng như quản lý các khóa riêng tư của mình.

Tùy chọn Change Password: nếu như bạn cảm thấy mật khẩu hiện tại chưa có tính bảo mật cao, bạn có thể đổi nó bất kỳ lúc nào.

Tùy chọn Remove Account: nếu như vì một lý do nào đó bạn muốn xóa tài khoản của mình, hãy nhập mật khẩu và xác nhận việc xóa tài khoản. Có thể một số người cho rằng đây là một chức năng thừa của ứng dụng nhưng chúng tôi tin rằng nó là một phần cần thiết để đảm bảo tính bảo mật cũng như sự tự do lựa chọn của người dùng. Bạn cũng cần chú ý là bạn sẽ không thể khôi phục lại tài khoản sau khi đã xóa!




	

	
	
		
			
				Câu hỏi: Hiện tại, bạn có thể kết nối ví Meteor với những ứng dụng nào?
			
		

		
					

		
			
			
			
			Facebook, Twitter và Apple
		
			
			Bạn chưa thể kết nối ví Meteor với bất cứ mạng xã hội nào
		
			
			Near Social
		
			
			Reddit và các nền tảng chuỗi chéo
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kế hoạch sắp tới
Ví Meteor có một số kế hoạch vô cùng thú vị bao gồm:

 	Meteor Support phiên bản 2.0: một phiên bản có thể coi là đại tu hệ thống của chúng tôi, tích hợp thêm Gleap và hệ thống hỗ trợ vé cho email và ví
 	Meteor Explore 2.0: với thông tin về nhiều dự án và games cũng như dApps hơn nữa
 	Hỗ trợ kết nối ví Ledger: dự kiến ra mắt tính năng này vào quý III năm 2023
 	Đăng nhập vào các ứng dụng mạng xã hội: ngoài Near Social thì chúng tôi cũng dự định hỗ trợ việc sử dụng ví Meteor để đăng nhập vào các mạng xã hội phổ biến như Gmail, Facebook, Twitter, Apple, …
 	Ứng dụng di động trên Android và iOS: dự kiến ra mắt vào cuối quý II năm 2023
 	Hỗ trợ NFT với nhiều kiểu đa phương tiện: hợp tác với Harmonic Guild và dự kiến ra mắt vào cuối năm nay

### Что такое Pikespeak?

Pikespeak - создан на протоколе NEAR, представляет собой решение для данных и аналитики, предлагающее учреждениям, проектам Web3 и частным лицам:

 	визуализацию и информационные панели самых основных вариантов использования Web3, DeFi, DAO, игры, NFT и т.д.
 	мощные индексаторы и API, охватывающие более 50 конечных точек данных
 	выделенные RPC и индексаторы
 	пользовательские точки данных и аналитические данные

Решение уже привлекло более 400 первых пользователей и используется ведущими проектами в рамках экосистемы, включая Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader и Learn NEAR Club.




	

	
	
		
			
				Кто еще не использует Pikespeak?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			президент США
		
			
			Tonic DEX
		
			
			Learn NEAR Club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Зачем?
Блокчейн не предназначен для традиционных инструментов аналитики:

 	доступ к полезным данным может быть сложным, это затрудняет изучение возможностей
 	быстрое извлечение данных в масштабе и по стоимости — нетривиальная задача, требующая интерпретации на основе развернутых смарт-контрактов.




Проще говоря, Pikespeak стремится:

 	индексировать, хранить и преобразовывать данные в цепочке в удобочитаемые таблицы
 	предоставить пользователям мощную аналитику

Для чего?
Это зависит от проблемы/вопроса, который вам нужно решить/на который нужно ответить. Вот несколько реальных примеров (неполный список):
Пользователи DeFi

 	Какова стоимость и структура моего портфеля?
 	Каков мой P/L за определенный период времени?
 	Налоговый инспектор (например, IRS) запрашивает журналы моих сделок и активности блокчейна за последний финансовый год. Как я могу предоставить эту информацию?
 	Я заинтересован в том, чтобы держать токен, но я хотел бы понять несколько вещей; каков оборотный запас? Кто держит токен (список богатых)? Как ведут себя крупные держатели? Когда они продают? Как долго они держат токен? И т. д.
 	Каковы самые крупные переводы токенов за последние 24 часа?

Венчурные компании

 	Какова стоимость и разбивка моего портфеля?
 	Мой бухгалтер запрашивает журналы активности блокчейна компании, как я могу предоставить эту информацию?
 	Какие самые активные проекты?
 	Сколько активных пользователей у компаний моего портфолио?
 	Одна из портфельных компаний утверждает, что их продукт пользуется огромной популярностью, как я могу проверить и оспорить эту информацию?




	

	
	
		
			
				Используя Pikespeak, могу ли я: (выберите все подходящие варианты)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Скачать всю историю моего кошель в csv формате
		
			
			Проверить активность и ключевые показатели любого смарт-контракта
		
			
			Анализировать историю транзакций адреса
		
			
			Предсказать цену любого токена с 100% вероятностью
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Владельцы проектов

 	Я занимаюсь сбором средств и хотел бы узнать размер доступного рынка в моем сегменте (например, игровой), сколько активных пользователей в этой сфере? Кто лидирует в моем сегменте? Каковы доли рынка конкурирующих проектов?
 	Я хотел бы стимулировать определенные адреса на основе их портфолио и активности, могу ли я получить доступ к списку этих адресов?
 	Какова TVL моего проекта?
 	Почему мой проект потерял 20% своей TVL именно в эту дату?

Руководители маркетинга проектов 

 	Я недавно поддерживал/возглавлял маркетинговую кампанию, как это отразилось на привлечении пользователей?
 	Я хотел бы продвигать маркетинговое сотрудничество с другим проектом, проявила ли моя пользовательская база интерес к этому проекту? Насколько близки наши сообщества?
 	Я хотел бы поощрить конкретные адреса на основе их портфолио и активности. Могу ли я получить доступ к списку этих адресов?

Руководители проекта

 	Что удерживает пользователей?
 	Каковы наиболее часто используемые функции (методы вызова)?
 	Конкурирующий проект запустил новую функцию, насколько хорошо она была воспринята сообществом? Привело ли это к привлечению пользователей?
 	Сколько моих пользователей используют конкурирующие приложения? Сколько они тратят на эти другие приложения?

Валидаторы

 	Почему мой публичный валидатор вчера потерял 20% своих делегатов?
 	Я вижу, что 1M NEAR $NEAR вчера не был распределен. Какой адрес был связан с событием отмены ставок?
 	Сколько у меня делегаторов по сравнению с конкурирующими валидаторами?
 	Сколько наград накопил мой узел с момента создания?

DAO

 	Что такое казна DAO?
 	Сколько членов DAO проголосовало за последнее предложение?
 	Связан ли один из моих членов DAO с другими DAO? Если да, то какие?
 	Сколько платежей мой DAO провел за последний год? На какую общую сумму?

Управляющий казначейством Экосистемного фонда

 	Сколько грантов было выдано за последний год? На какую общую сумму?
 	Насколько хорошо мои грантополучатели, связанные с децентрализованными приложениями, работают по следующим критериям; количество транзакций, активных пользователей, управление казначейством?
 	Как другие экосистемные фонды в последнее время распределяли средства? Какие проекты поддерживаются?

Регулирующие органы и/или следователи по соблюдению требований AML/KYC

 	Какая связь между этим адресом и другим?
 	Этот адрес был замешан во взломе. Какие биржи использовались для вывода средств?
 	Какие биржи использовались, чтобы найти этот вредоносный адрес?
 	Несколько взломов имеют один и тот же способ действия, но были сгенерированы с разных адресов. Они как-то связаны?
 	Каковы все взаимодействия/график уровня 1 конкретного адреса?

Блокчейн-инженеры

 	Конкретная транзакция не удалась, могу ли я проверить разбивку квитанций транзакции, чтобы понять, что произошло?
 	Какова стоимость газа этой конкретной транзакции?




	

	
	
		
			
				Может ли Pikespeak быть полезным для: (выберите все подходящие варианты)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Учреждения венчурного капитала на NEAR
		
			
			Производитель пиццы из Неаполя
		
			
			Проекты и приложения на NEAR
		
			
			Простой DeFI или пользователи NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Данные — это хорошо, а факты — еще лучше
Стоимость доступа к данным на основе данных является незначительной по сравнению с традиционными и частными рынками, такими как фондовые биржи и информация о клиентах (например, панели) для конкретной отрасли. Это создает уникальную возможность для появления молодых журналистов, следователей или любой другой гражданской журналистики. Качество и освещение фиаско FTX в Твиттере стало отличной иллюстрацией этой тенденции.

Более того, модель NEARWEEK Report-to-Earn — это инновационный способ стимулировать гражданскую журналистику и побуждать людей участвовать в процессе создания новостного контента.

Ниже приведен список событий, которые могут привести к интересным и познавательным историям. Мы хотели бы призвать сообщество LNC использовать Pikespeak, чтобы рассказывать отличные истории.

 	23 июня 2022 г. — 39 млн токенов $NEAR были сняты с валидаторов.
 	4, 5 и 6 марта 2023 г. — у Near Social (social.near) был значительный приток новых пользователей.
 	8 марта 2023 г. — Контракт Multi Sender (multisender.app.near) (отправка нескольких переводов за одну простую транзакцию) отправил 1,13 млн долларов США на несколько адресов, что стало крупнейшей транзакцией с момента создания.

Контакты
Didier Pironi

Email: didier@pikespeak.ai

Date: 09/03/2023

Pikespeak.ai

### Meta Pool модуль 2 – Краудфандинг в Meta Pool

Meta Yield — краудфандинг без потерь
Meta Yield - это платформа краудфандинга на основе вознаграждений за майнинг без потерь для проектов NEAR, которые ищут финансовую поддержку и взаимодействие с сообществом NEAR.

Цель Meta Yield - предоставить доступ к различным проектам, позволяющим сообществу финансово поддерживать проекты веб-3.0, построенные на протоколе NEAR.

Meta Yield Launchpad - это безубыточная платформа для краудфандинга проектов на NEAR, которые хотят получить финансирование от своего сообщества. Он использует стейкинг, предоставляя спонсорам возможность финансировать их вознаграждениями, а не основными активами.

Уникальный механизм сбора средств, встроенный в Meta Yield, использует ликвидный стейкинг: финансовые спонсоры создают токены проекта с помощью своих вознаграждений за стейкинг, а не своих криптовалютных активов.

Meta Yield работает по 4 простым шагам:

 	Спонсоры обязываются и блокируют stNEAR, чтобы поддерживать крипто-проекты (если у вас нет stNEAR, перейдите на Meta Pool и поставьте на стейк $NEAR)
 	Проекты зарабатывают только вознаграждения за стейкинг (~10%), которые обязуются спонсоры, а не базовые крипто-активы
 	Спонсоры получают токены от новых проектов, запускающихся на NEAR, или получают NFT (скоро)
 	Спонсоры восстанавливают свои крипто-активы: в конце периода блокировки вы берете обратно 100% своих NEAR

Проще говоря, вы можете поддерживать крипто-проекты, получать вознаграждения в виде токенов проекта и способствовать росту экосистемы NEAR, не теряя свои заблокированные токены.

Вы отдаете только свои будущие вознаграждения NEAR за токены проекта и сохраняете свои NEAR, тем самым уменьшая риски всего процесса инвестирования.

Начните поддерживать проекты NEAR прямо сейчас! Посетите https://metayield.app




	

	
	
		
			
				Существует предварительно установленный лимит на количество токенов stNEAR, которые вы можете внести в кампанию Meta Yield.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как проект может быть добавлен в Meta Yield?
В первую очередь, платформа Meta Yield Launchpad предоставляет механизм для краудфандинга и наградную систему проектам. Кроме того, каждый проект, запустивший кампанию по сбору средств, получает бесплатную маркетинговую поддержку от Meta Yield Launchpad:

 	Кампания до запуска: длительностью от 1 до 2 недель, включая возможные AMA, инфографику и публикации в социальных сетях.
 	Продвижение на старте.
 	Еженедельное продвижение во время сбора средств.

Кроме того, мы сотрудничаем с различными организациями экосистемы NEAR, которые заинтересованы в возможности финансовой поддержки новых проектов на NEAR.
Как мы выбираем проекты?
Мы хотим дать всем возможность собирать средства для своих проектов, но также хотим предложить пользователям и потенциальным инвесторам качественные проекты в качестве вариантов. Поэтому каждый проект, который хочет быть рассмотренным в качестве кандидата на Meta Yield Launchpad, должен соответствовать следующим требованиям:

 	Команда, строящая проект

Проект должен быть поддержан надежной и мотивированной командой, способной перевести проект на следующий уровень после его финансирования.

Опыт каждого члена команды должен быть связан с типом предлагаемого проекта. Другими словами, если это игровой проект, участники должны представить доказательства того, что по крайней мере некоторые из них работали в смежных областях.

Многопрофильные команды также являются хорошим знаком. Важно иметь разработчиков, но чтобы действительно повысить уровень своего проекта, вам также нужны маркетинг, операции, дизайн и, возможно, другие области.

 	Сильное сообщество

Нам нужно, чтобы у этих проектов была крепкая поддержка со стороны их сообщества. Обычно мы проверяем их уровень активности и вовлеченности на социальных сетях, таких как Telegram, Discord, Twitter, YouTube, Instagram, TikTok и любых других, которые упомbнаются проектами в их заявке.

Этот аспект крайне важен по двум основным причинам: мы иногда проводим голосование для выбора проектов, и сообщества обычно толкают эти голоса, а также хороший процент собранных средств придет из сообщества, поэтому необходимо иметь готовое сообщество, чтобы они стояли за вами.

 	Токен и его токеномика

Выбранные проекты должны иметь токен, потому что они будут использовать его, чтобы давать вознаграждения тем, кто поддерживает их кампанию. Конкретно, человек, который поддерживает проект, будет давать проекту свои награды за стейкинг и получать токены от проекта взамен в качестве вознаграждения.

И, поскольку ваши инвесторы получат ваш токен в качестве вознаграждения, важно рассказать им, как они могут его использовать (например: играть, покупать, обмениваться или использовать как токен управления) и ваши планы по увеличению его стоимости.

 	План финансирования

Имейте в виду, что иметь кампанию на Meta Yield Launchpad похоже на попытку собрать деньги у инвесторов: они хотят знать, способны ли вы построить проект и как вы собираетесь на нем заработать.

Так что будьте готовы с базовым объяснением того, как вы собираетесь использовать собранные средства: маркетинг, улучшение продукта/услуги, расширение функциональности, изменение/инновации в брендинге, улучшение функциональности платформы и т. д.

 	Связь с экосистемой NEAR

Поскольку мы работаем с проектами и сообществом NEAR, и связь и коммуникация крайне важны в этом протоколе, мы настоятельно рекомендуем вам установить тесные отношения с экосистемой NEAR Protocol.

У команды проекта должны быть доказательства того, что они сотрудничали и умеют работать с актерами, занятыми в NEAR: получение грантов, участие в программе инкубации или участие в гильдиях учитываются для этого требования.

Это гарантирует, что экосистема уже «узнает команду/проект», и когда проект пойдет на основную сеть, экосистема его поддержит.




	

	
	
		
			
				Многоцепочное видение проекта является обязательным в проекте, который будет запущен на Meta Yield.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Где я могу найти больше информации о Meta Yield?
Вы можете найти больше информации на сайте и блоге Meta Yield.
Meta Bond Market - продайте заблокированные активы на Meta Yield
Цель Meta Bond Market - предоставить инструмент для приобретения и предложения различных типов облигаций, которые в настоящее время генерируются поддерживающими проектами в Meta Yield.

Meta Bond Market можно получить доступ напрямую по ссылке metabondmarket.app.
Подключите свой кошелек на Meta Bond Market
На сайте Meta Bond Market: metabondmarket.app, свяжите кошелек NEAR, чтобы иметь полный доступ к криптоактивам. Нажмите кнопку Подключить кошелек, выберите кошелек и подключитесь.

Как работает рынок Meta Bond:

4 простых шага для понимания механизма Meta Bond:

 	Поддерживайте проекты в Meta Yield.
 	Получайте облигации в соответствии с инвестициями в Meta Yield и связанными вознаграждениями.
 	Предлагайте облигации на платформе.
 	И/или покупайте облигации у других продавцов.

Пользователи вкладываются в Meta Yield в проекты на ранних стадиях. Если эти проекты смогут достичь хотя бы первой инвестиционной цели, поддерживающие получают вознаграждения в токенах проекта, которые высвобождаются плавно в обмен на их заблокированные инвестиции.

После окончания периода фонда Meta Bond Market создает для поддерживающего две облигации:

 	Первая облигация: в токенах NEAR. Эта сумма соответствует оценке в NEAR заблокированных stNEAR в конце периода фонда.
 	Вторая облигация: на сумму токенов поддержанного проекта, которые будут выпущены плавно.

Поддерживающий может выбрать в любое время в течение периода блокировки, хочет ли он выставить на продажу одну или обе облигации.

Если облигации не выставляются на продажу, они продолжают свой курс, и по окончании периода блокировки инвестиция возвращается владельцу облигации, а вознаграждения поддержанного проекта делегируются плавно в соответствии с предложением.

Для каждой облигации можно выбрать / выполнить следующие действия:

 	Разделить облигации на более мелкие облигации.
 	Предложить их для прямой продажи.
 	Предложить их на аукцион.

Установите время, в течение которого облигации будут выставлены на продажу.

Если облигация продается, продавец получает сумму в токенах в соответствии с прямой продажей или лучшим предложением на аукционе.

Если облигация не продается, она становится доступной для продажи снова и остается во владении продавца, и продавец может выставить ее на продажу снова при желании.




	

	
	
		
			
				Meta Bond позволяет вам продавать заблокированные токены вашей поддержки кампании Meta Yield.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Платформа Meta Bond Market

Рынок облигаций
В этом разделе отображаются все облигации, предлагаемые на платформе. Для каждой облигации указываются её данные, и возможно приобрести/подать заявку на покупку.
Мои облигации
Раздел "Мои облигации" содержит информацию о всех облигациях, которые принадлежат пользователю. В этом разделе пользователь может:

 	Просмотреть данные по облигациям;
 	Продать их;
 	Объединить их (важно, чтобы все условия облигаций соответствовали друг другу: актив, срок действия и дата начала действия, если это применимо);
 	Разделить их (облигации могут быть разделены только в том случае, если они не были частично погашены).

Мои продажи
В этом разделе пользователь может просмотреть облигации, которые он выставил на продажу - активные продажи и завершенные.

 	Прямая продажа: покупатель делает предложение прямо, после чего продавец увидит, что продажа состоялась, и сможет получить соответствующие токены.
 	Аукцион: побеждает тот, кто сделал наивысшую ставку, по окончании периода торгов продавец сможет получить токены.
 	Окончание периода торгов: если после окончания периода торгов предложений не было, продавец может выставить свою облигацию на продажу снова или завершить процесс.

Важно: если облигация была продана, продавец должен зайти в облигацию и нажать "получить токены", чтобы закрыть процесс продажи. Этот процесс является ручным.
Гарантия облигации
При предложении облигации на продажу система запросит минимальную сумму в виде гарантии (в настоящее время - 1 NEAR).

Это позволяет системе удерживать только те облигации, которые представляют минимальную сумму вопроса по гарантии.

При завершении процесса продажи это количество будет возвращено продавцу.
Мои заявки
В разделе "Мои заявки" пользователь может просмотреть активные заявки на покупку облигаций на аукционе.

Облигации прямой продажи здесь не отображаются, так как они уже автоматически включены в раздел "Мои облигации".

Если вы проигрываете аукцион, система позволяет увеличить свою ставку или отменить заявку, изъять свои токены.
Статусы облигаций на аукционе
Период активной продажи

 	Проигрыш: данное предложение было перебито. Пользователь может увеличить своё предложение или отменить его.
 	Победа: данное предложение является лучшим и победитель должен дождаться завершения торгов, чтобы увидеть, действительно ли он выиграл.

Период продажи завершён

 	Победа: этот статус отображается, если ставка по окончании периода торгов является выигрышной. Пользователь может запросить облигацию.
 	Проигрыш: данный статус отображается, если ставка по окончании периода торгов не является победной. Пользователь может забрать (зафиксировать) предложенное им количество токенов для этой облигаци




	

	
	
		
			
				Существует потенциальный высокий риск ликвидации при продаже ваших облигаций на Meta Bond Market.
			
		

		
					

		
			
			
			
			правда
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Шаг за шагом на рынке Meta Bond.

### Tìm hiểu dự án Roketo

Tìm hiểu dự án Roketo
(https://learnnear.club/what-is-roketo/ - 607 words)

“Roketo là dự án gì? Tại sao nên tiền mã hóa làm giải pháp thanh toán? Roketo thì khác gì với cả tá dự án làm trong mảng thanh toán tiền mã hóa khác?”.

Trong bài viết này, chúng tôi sẽ đưa ra câu trả lời cho những câu hỏi trên.

Dưới đây chúng tôi sẽ trình bày ngắn gọn cách thức hoạt động của Roketo và lý do tại sao nó sẽ thay đổi hoàn toàn quy trình thanh toán của bạn.

Nhiều công ty gặp khó khăn trong việc tìm ra một cách thanh toán nhanh chóng và đáng tin cậy, đặc biệt nếu các nhóm người dùng của họ được phân phối trên một số khu vực pháp lý khác nhau. Trong trường hợp này, tiền mã hóa sẽ giúp bạn giảm thiểu những rắc rối khi chuyển khoản quốc tế liên ngân hàng - công việc vốn tốn thời gian và yêu cầu một số thủ tục giấy tờ.

Roketo là một dịch vụ chuyển tiền mã hóa trực tuyến, cho phép bạn trả tiền cho mọi người và dịch vụ theo thời gian thực. Hoa hồng thấp, tốc độ giao dịch nhanh và sự minh bạch của blockchain khiến Roketo trở thành một giải pháp hoàn hảo cho việc thanh toán. Khách hàng của Roketo sử dụng dịch vụ của chúng tôi để trả lương cho nhân viên, gửi tiền tài trợ một cách minh bạch, airdrop token của riêng dự án và phát hành token cho các nhà đầu tư. Thanh toán trực tuyến theo thời gian thực cũng rất hữu ích khi áp dụng cho các dịch vụ trả tiền theo phút như bãi đậu xe, thuê trang thiết bị hoặc cho thuê văn phòng làm việc chung.
Cơ chế hoạt động của Roketo
Roketo liên kết với ví người dùng và chuyển tài sản cho người nhận trong thời gian thực. Người thanh toán đăng nhập vào ứng dụng Roketo bằng ví NEAR, thiết lập luồng thanh toán, thời lượng của luồng thanh toán và các cài đặt khác, nhập địa chỉ ví của người nhận và sau đó bắt đầu quá trình chuyển tiền. Tài sản được chuyển đến luồng nhận token của người nhận, sau đó người nhận có thể rút tiền về ví của mình.

Roketo có gì khác với các giải pháp thanh toán khác trên thị trường?
Hoa hồng thấp
Roketo được xây dựng trên NEAR và đây chính là lý do cho phép chúng tôi thu một trong những khoản hoa hồng thấp nhất trên thị trường. Trong khi các đối thủ cạnh tranh của chúng tôi mất khoảng 50 USD –100 USD tiền phí dịch vụ cho mỗi luồng thanh toán, thì mỗi lần thiết lập luồng thanh toán của Roketo chỉ tốn chưa đến 1 USD. Ngoài ra, bạn sẽ phải trả phí gas cho các giao dịch của mình, phí này trên NEAR cũng thấp hơn so với các blockchain khác. So với Ethereum, chi phí cho mỗi giao dịch thường trên 10 USD thì trên NEAR, phí này chỉ đáng vài xu.

Với phí hoa hồng thấp như vậy, bạn có thể thiết lập hàng trăm luồng thanh toán với chi phí vô cùng rẻ, đồng thời người nhận cũng sẽ tiết kiệm rất nhiều chi phí khi rút tiền về ví.
Giao dịch nhanh chóng
Chuyển tiền trực tuyến theo thời gian thực có nghĩa là tiền của được chuyển mỗi giây với một tốc độ nhất định và người nhận có thể rút tiền bất cứ lúc nào. Bạn có thể tiết kiệm được hàng giờ đồng hồ chờ đợi so với việc sử dụng các dịch vụ khác, thậm chí thời gian chờ đợi có thể tính theo đơn vị ngày khi sử dụng các công cụ tài chính truyền thống.
Minh bạch
Khách hàng của chúng tôi được trải nghiệm một quy trình hoàn toàn minh bạch trong việc phân bổ vốn và trả tiền. Ngay cả khi thực hiện thanh toán hàng loạt cho các nhà đầu tư hoặc cộng đồng của mình, các công ty vẫn có toàn quyền kiểm soát việc phân bổ token theo thời gian thực. Mỗi luồng có một địa chỉ url duy nhất để bạn có thể theo dõi quá trình phân phối. Từ đó tạo điều kiện lập kế hoạch tài chính, thanh toán thuế và báo cáo một cách dễ dàng.
Giao diện dễ sử dụng
Bạn không cần quá một phút để thiết lập luồng thanh toán đầu tiên của mình trong Roketo. Mọi tùy chọn để kiểm soát luồng thanh toán đều có thể được thiết lập một cách dễ dàng từ cả người nhận và người gửi mà không cần sự tham gia của bên thứ 3. Bạn có thể dễ dàng tạm dừng, tiếp tục, mở rộng luồng thanh toán và xem lại toàn bộ lịch sử hoạt động trong dApp. Giao diện người dùng của Roketo rất dễ hiểu ngay cả đối với những người chưa có kiến thức trong thị trường tiền mã hóa.

Chúng tôi mới đây đã gọi được 900.000 USD trong vòng hạt giống với sự tham gia của Move Capital, MetaWeb Ventures và A&T Capital. Khoản đầu tư này sẽ giúp chúng tôi phát triển sản phẩm của mình nhanh hơn nữa, vì vậy hãy chú ý theo dõi các bản cập nhật mới của chúng tôi nhé!
Thông tin về dự án

 	Theo dõi chúng tôi trên Twitter
 	Chat với chúng tôi trên Telegram
 	Đóng góp vào mã nguồn của chúng tôi trên Github
 	Thử ngay với Roketo Protocol tại đây
 	Khám phá website của chúng tôi

### Quá trình chuyển đổi ví NEAR: lý do đằng sau và những điều bạn nên làm

Hầu hết người dùng trên hệ sinh thái NEAR đều biết về việc chuyển đổi ứng dụng ví NEAR. Tuy nhiên vẫn còn nhiều thắc mắc về lý do dẫn tới việc chuyển đổi này, quá trình chuyển đổi sẽ diễn ra như thế nào và những thông tin chi tiết về ví MyNearWallet.
Tại sao tôi nên chuyển từ một ví “chính thức” do Near Foundation phát triển sang một ví khác?
Người dùng trên NEAR có những nhu cầu và sở thích khác nhau mà một sản phẩm “chính thức” khó có thể đáp ứng hết. Các nhà phát triển trên hệ sinh thái NEAR đã nhận ra điều này và đưa ra quyết định trong tương lai gần, hệ sinh thái NEAR sẽ không cần một ví chính thức và tất cả các DApp sẽ được khuyến khích kết nối với nhiều loại ví khác nhau. Trang web http://wallet.near.org/ sẽ là nơi liệt kê các loại ví đang được sử dụng trong hệ sinh thái NEAR. Thời điểm chính xác của quá trình chuyển đổi này vẫn chưa được công bố.

Những thay đổi này sẽ tăng cường thêm tính phi tập trung, đồng thời tạo động lực cho sự cạnh tranh lành mạnh cho các nhà phát triển trên hệ sinh thái. Từ đó, người dùng thay vì dùng ví “chính thức” của NEAR, có thể được sử dụng những sản phẩm có chất lượng tốt hơn.
Ví MyNearWallet kết nối với ví NEAR cũ như thế nào?
Kikimora Labs và Tinker Union team (đội ngũ đứng sau phát triển MeteorWallet) đang phát triển ứng dụng MyNearWallet dựa trên mã nguồn mở của ví NEAR. Mã nguồn của ví NEAR sẽ vẫn được công khai sau quá trình chuyển đổi này. Đội ngũ phát triển của MyNearWallet sẽ cải thiện những tính năng hiện có của ví NEAR, bên cạnh đó cũng sẽ thêm những tính năng mới và cải thiện bảo mật cho ví. Hiện tại, nhóm phát triển MyNearWallet vẫn sẽ hỗ trợ người dùng trên ví cũ và ví mới, đồng thời vá các lỗi trong mã nguồn của cả 2 ví này. Tuy nhiên, những tính năng mới sẽ chỉ được thêm vào ứng dụng ví MyNearWallet.

Ví MyNearWallet có giao diện gần giống với ví “chính thức” của NEAR. Nhóm phát triển cũng cho biết quá trình thay đổi giao diện của ví sẽ diễn ra một cách suôn sẻ.
Tài khoản của người dùng trên trang https://wallet.near.org/ có bị ảnh hưởng gì không?
Người dùng có thể chuyển tài khoản của mình sang các ứng dụng ví khác mà không chịu bất kỳ rủi ro nào.
Lộ trình và chiến lược chuyển đổi ví NEAR

 	Giai đoạn 0 — Kêu gọi sự tham gia của cộng đồng
 	Giai đoạn 1 — Di chuyển người dùng khỏi ví NEAR cũ, kích hoạt chức năng xuất thông tin tài khoản
 	Giai đoạn 2 — Cổng thông tin mới về danh sách các ví trên hệ sinh thái (Hoàn thành vào đầu năm 2023)
 	Giai đoạn 3 — Kết thúc quá trình dịch chuyển người dùng
 	Giai đoạn 4 — Hoàn tất quá trình ngừng hoạt động của ví NEAR

### NEAR BOS: NEAR Protocol’s Blockchain Operating System

In March 2023, Near Protocol launched the Blockchain Operating System (BOS) to create the ideal entry point of the Open Web. The idea here is to bridge the gap between web2 and web3 seamlessly. This article will look closely at BOS and understand how it works.
What is Open Web?
“Open Web” is a term used to describe the internet when it becomes a global public resource not overseen by gatekeepers or overseers. So, why is open web desirable?

 	It is necessary for free and open communication and expression.
 	An open web is an internet by the people and for the people. It empowers individuals to step in and contribute positively to society.

From the beginning, NEAR’s vision was to help facilitate the creation of the Open Web. Since the Open Web needs to be decentralized, NEAR needed to create a scalable, layer-1 blockchain that abstracts away the complexities. Were they able to do that? Let’s take a look.

 	NEAR has a flexible account model and human-readable accounts.
 	The Nightshade sharding mechanism makes NEAR extremely scalable.
 	NEAR also provides sophisticated tools to help builders develop the protocol.

Having laid down the foundation, NEAR now needs to create a web3 stack that will help streamline Open Web onboarding for users and developers alike.
How Does BOS Achieve Open Web?
Think of what an operating system or “OS” does. An OS allows users to interact with sophisticated machinery without getting into the complexities. Abstracting away the complexities in the background is crucial for the mass adoption of technology.

Now, extend that logic to web3. According to NEAR Protocol Co-Founder Illia Polushkin, BOS is a common layer for browsing and discovering Web 3 products. In addition, BOS will support Near Protocol and Ethereum Virtual Machine chains during the launch. Imagine creating a cool new DeFi app on Ethereum and getting users from NEAR via BOS.
Creating Composable Frontends
Before we go any further, let’s understand what a frontend is. A frontend is how a user interacts with the application. When it comes to dApps, creating a composable and decentralized is necessary. The very ethos of web3 is decentralization. So then, why do we still use centralized services to access these services? Trusting these intermediaries has several security challenges.

BOS helps add composable frontends to the tech stack and easily onboard users to web3. Regarding BOS’s potential as a frontend, Polusukhin said:

“The composable decentralized front ends as a framework can work with any Web2 or Web3 back end and any wallet. In the future we will be offering [use of] wallets from one chain to interact with another via seamless bridging.”
The 3 Pillars Of BOS
BOS is based on three pillars:

 	Gateways
 	Components
 	Blockchains

Gateways
Gateways are designed to make locally run, decentralized frontends available to everyone. A gateway comprises a specially designed virtual machine that loads and runs frontends for protocols built on Ethereum, L2s, and other Layer 1s like NEAR. The code for these frontends is stored on the NEAR blockchain.




	

	
	
		
			
				What is the purpose of Near Protocol's Blockchain Operating System (BOS)? (choose all applicable)
			
		

		
					

		
			Please select 2 correct answers
			
			
			To create a decentralized internet not overseen by gatekeepers.
		
			
			To bridge the gap between web2 and web3.
		
			
			To develop a scalable, layer-2 blockchain.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Components
Components are frontends for app-layer, on-chain protocols such as Lido, Uniswap, and Aave. Developers can view the code for these apps in a gateway similar to viewing a smart contract in Etherscan. In addition, they can fork these apps and deploy their own versions or even compose components.
Blockchains
Components can call functions on any blockchain. Currently, all EVM chains/L2s and NEAR are supported. In addition, the source code for the frontends (apps) is stored on NEAR due to its ability to cheaply store HTML/CSS/JS.
Looking At NEAR's BOS Frontend
Let’s see how the front-end works in real-time. Go to alpha.near.org.

The frontend connects users to all the different Web3 possibilities within the ecosystem. Anyone in the Open Web ecosystem can create their own frontends, compatible with their chosen blockchain. Let’s play around with the interface and see how it works.

When you scroll up, hover on “Discover” and click “Components.”

Components are small apps that solve specific problems. Currently, you have some built-in components that you can use to build out the frontend. Here are some built-in components.




	

	
	
		
			
				What is the function of Gateways in BOS?
			
		

		
					

		
			
			
			
			To make locally run, centralized frontends available to everyone.
		
			
			To provide sophisticated tools to help builders develop the protocol.
		
			
			To store the source code for frontends on NEAR.
		
			
			To load and run frontends for protocols built on Ethereum, L2s, and other Layer 1s.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Widget
A widget is the minimum unit of a frontend. It allows you to include an existing component in your code, thus enabling you to create complex applications by composing components.

Code:
​​const user = "gagdiez.near";
const props = { name: "Learn NEAR" };

return (
  <>
    <div class="container min-vw-100">

       <h3> Widgets </h3>
      <p> Here is a Widget </p>
      <hr />

      <Widget src={`${user}/widget/Greetings`} props={props} />
    </div>
  </>
);

Output:

Image Uploader
The Image Uploader allows users to directly upload an image to the InterPlanetary File System (IPFS).

Code:
State.init({
  img: null,
});

return (
  <div className='container row'>
    <div>
      Image upload: <br />
      <IpfsImageUpload image={state.img} />
    </div>
    <div>
      Raw State:
      <pre>{JSON.stringify(state)}</pre>
    </div>
    <div className='mt-2'>
      {state.img.cid && (
        <img
          src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
          alt='uploaded'
        />
      )}
    </div>
  </div>
);

Output:

You can use the button to upload an image:

Files
Uplad files with drag and drop support.

Code:
State.init({ img: null });

const uploadFileUpdateState = (body) => {
  asyncFetch(
    "https://ipfs.near.social/add",
    {
      method: "POST",
      headers: { Accept: "application/json" },
      body
    }
  ).then(
    (res) => {
      const cid = res.body.cid;
      State.update({ img: { cid } });
    }
  )
};

const filesOnChange = (files) => {
  if (files) {
    State.update({ img: { uploading: true, cid: null } });
    uploadFileUpdateState(files[0]);
  }
};

return (
  <div className="d-inline-block">
    { state.img?
      <img class="rounded w-100 h-100"
        style={{ objectFit: "cover" }}
        src={`https://ipfs.near.social/ipfs/${state.img.cid}`}
        alt="upload preview" />
      : ""
    }
    <Files
      multiple={false}
      accepts={["image/*"]}
      minFileSize={1}
      clickable
      className="btn btn-outline-primary"
      onChange={filesOnChange}
    >
      { state.img?.uploading ? <> Uploading </> : "Upload an Image" }
    </Files>
  </div>
);

Output:

Markdown
A built-in component that enables to render Markdown.

Code:
const text = `
  #### Markdown Section
  Checkout Learn NEAR [here](https://learnnear.club/)
`;

return (
  <>
    <div class="container border border-info pt-3 min-vw-100 text-center">
      <Markdown text={text} />
    </div>
  </>
);

Output:

OverlayTrigger
The OverlayTrigger widget allows developers to display overlay text or icon when the mouse is hovering above a particular item.

Code:
State.init({
  show: false,
});

const handleOnMouseEnter = () => {
  State.update({ show: true });
};
const handleOnMouseLeave = () => {
  State.update({ show: false });
};

const overlay = (
  <div
    className='border m-3 p-3 rounded-4 bg-white shadow'
    style={{ maxWidth: "24em", zIndex: 1070 }}
    onMouseEnter={handleOnMouseEnter}
    onMouseLeave={handleOnMouseLeave}
  >
    This is the overlay Message
  </div>
);

return (
  <OverlayTrigger
    show={state.show}
    trigger={["hover", "focus"]}
    delay={{ show: 250, hide: 300 }}
    placement='auto'
    overlay={overlay}
  >
    <span
      className='d-inline-flex'
      style={{ backgroundColor: "gray", borderRadius: "10px", padding: "10px" }}
      onMouseEnter={handleOnMouseEnter}
      onMouseLeave={handleOnMouseLeave}
    >
      Place Mouse Over Me
    </span>
  </OverlayTrigger>
);

Output:

InfiniteScroll
This component allows you to create a simple, lightweight infinite scrolling page or element by supporting both window and scrollable elements.

Code:
const allNumbers = Array.from(Array(100).keys())

State.init({
  displayNums: [],
  lastNumber: 0,
});

const loadNumbers = (page) => {
  allNumbers
    .slice(state.lastNumber, state.lastNumber + 10)
    .map((n) => numberToElem(n))
    .forEach((i) => state.displayNums.push(i));
  state.lastNumber += 10;
  State.update();
};

const numberToElem = (number) => <div> {number} </div>;

return (
  <div>
    <InfiniteScroll
      loadMore={loadNumbers}
      hasMore={state.displayNums.length < allNumbers.length}
    >
      {state.displayNums}
    </InfiniteScroll>
  </div>
);

Output:

An infinitely loading list:

Typeahead
This component provides a type-ahead input field for selecting an option from a list of choices. Simply put, this compoeent is used for creating text auto-complete features.

Code:
const options = ["Apple", "Banana", "Cherry", "Durian", "Elderberry"];

return (
  <div class="container min-vh-100 min-vw-100">
    <Typeahead
      options={options}
      multiple
      onChange={(value) => {State.update({choose: value})}}
      placeholder='Choose a fruit...'
    />
    <hr />
    <p> Selected: {JSON.stringify(state.choose)} </p>
  </div>
);

Output:

This Typehead allows you to choose a fruit.

Styled Components
The Styled Components tool is used for styling React components using CSS-in-JS.

Code:
const Button = styled.button`
  /* Adapt the colors based on primary prop */
  background: ${(props) => (props.primary ? "palevioletred" : "white")};
  color: ${(props) => (props.primary ? "white" : "palevioletred")};

  font-size: 1em;
  margin: 1em;
  padding: 0.25em 1em;
  border: 2px solid palevioletred;
  border-radius: 10px;
`;

return (
  <div>
    <Button>White</Button>
    <Button primary>Red</Button>
  </div>
);

Output:

ToolTip
This component allows developers to add tool tips on certain elements. Simply create a button and add an overlay text as a tool tip.

Code:
return (
  <>
    {["top", "right", "bottom", "left"].map((placement) => (
      <div style={{ margin: "2.5rem 1rem", float: "left" }}>
        <OverlayTrigger
          key={placement}
          placement={placement}
          overlay={
            <Tooltip id={`tooltip-${placement}`}>
              Tooltip on <strong>{placement}</strong>.
            </Tooltip>
          }
        >
          <button variant="secondary">Tooltip on {placement}</button>
        </OverlayTrigger>
      </div>
    ))}
  </>
);

Output:

In Closing
BOS helps solve the main challenges around building web3 front-ends, such as access, security, composability, and agility. With BOS, users can run blockchain applications locally, which helps assure robustness and censorship resistance while maintaining a user-friendly experience.

If you want to know more about BOS frontend, read the documentation here.




	

	
	
		
			
				What is a widget in BOS?
			
		

		
					

		
			
			
			
			The code for frontends stored on the NEAR blockchain.
		
			
			A specially designed virtual machine that loads and runs frontends for protocols.
		
			
			A small app that solves specific problems and allows you to create complex applications by composing components.
		
			
			A framework that can work with any Web2 or Web3 backend and any wallet.
		
	
		

		
		
			
				Correct!
				Wrong!

### 니어 프로토콜(NEAR Protocol)이란?

목표: 최종 사용자의 관점에서 니어가 동작하는 방식을 이해한다.

NEAR는 니어 프로토콜 블록체인 상에서 동작하는 탈중앙화된 어플리케이션 플랫폼입니다. 전 세계 수백 개의 기기에 걸쳐 작동하는 이 블록체인은, 새로운 웹을 위한 강하고 분산된 데이터 계층을 생성할 수 있도록 허가를 필요로 하지 않고, 성능이 뛰어나며 안전하게 구성되어 있습니다.

NEAR의 주요 임무는 안전하게 공유되는 사용자의 재산, 개인 정보, 데이터에 접근할 수 있는 어플리케이션을 위한 이상적인 플랫폼을 제공하는 것입니다. NEAR는 파티션 내성 네트워킹, 서버리스 컴퓨팅, 분산 스토리지 기능을 결합하여 새로운 종류의 플랫폼을 만들고 있습니다.

더 나아가기 앞서, 블록체인 플랫폼이 시간에 따라 어떻게 발전해왔는지 배경을 살펴보겠습니다.
블록체인 기술의 발전
사토시 나카모토가 2008년 10월 비트코인 백서를 발표한 이후로, 사람들은 혁신적인 블록체인 기술에 대해 알게 되었습니다. 지난 10년간 블록체인은 세 가지 발전 단계를 거쳐왔습니다.
1세대: 비트코인(Bitcoin)
비트코인은 1세대 블록체인의 완벽한 예시입니다. 이 블록체인의 목표는 간단하고 직관적인 결제 시스템이 되는 것입니다. “인터넷 화폐”로 시작하여, 비트코인은 가장 수요가 많은 자산 중 하나가 되었습니다. 그러나 여기에는 중요한 문제가 있습니다. 비트코인으로는 여러 메타데이터와 논리를 포함하는 복잡한 거래를 수행하는 것이 굉장히 어렵습니다.
2세대: 이더리움(Ethereum)과 스마트 컨트랙트(Smart Contract) 플랫폼
이더리움은 스마트 컨트랙트를 통해 2세대 블록체인 플랫폼을 선도했습니다. 개발자들은 스마트 컨트랙트를 통해 복잡한 거래를 프로그래밍하고, 탈중앙화된 애플리케이션(dApps)을 만들 수 있게 되었습니다. 디앱을 통해 블록체인의 사용 사례가 급증하였습니다.

그러나 지금까지의 블록체인들은 심각한 확장성 문제가 있습니다. 예를 들어, 비트코인은 초당 7건의 거래 처리 능력을 가지고 있으며, 이더리움은 25건 밖에 처리하지 못합니다. 이는 PayPal(초당 115건)이나 Visa(초당 1,700건)와 비교한다면 현저히 떨어지는 수준입니다.

이더리움과 비트코인은 최근 이러한 확장성 문제를 해결하기 위해 라이트닝 네트워크, 레이든, 플라즈마 프로토콜 등 여러 레이어2(layer-2) 기술을 도입하고 있습니다. 이는 기존 블록체인 위에 추가적인 레이어를 생성하여 반복되고 번거로운 작업을 위임하는 방식입니다.

그러나 이러한 방식에는 두 가지 문제점이 있습니다. 첫째, 레이어2 방식은 아직 대중적으로 인정받지 못했습니다. 둘째, 이러한 레이어2 방식은 프로토콜 본래의 구조를 파괴하여 장기적인 영향을 미칠 수 있습니다.

여기서 3세대가 등장합니다!
3세대: NEAR
니어는 확장성 문제를 해결하고 사용자와 개발자가 스마트 컨트랙트와 블록체인의 모든 가능성을 사용할 수 있도록 만들어진 3세대 블록체인의 예시입니다. 레이어2 기술에 의존하는 대신에, 니어는 네트워크에 참여하는 모든 노드가 모든 코드를 실행해야 한다는, 심각한 병목 현상을 만들어 다른 모든 방식을 느리게 만드는 고정관념에서 벗어났습니다.

이를 해결하기 위해 니어는 데이터베이스 분야에 흔하게 사용되는 샤딩이라는 기술을 도입합니다. 적절하게 사용된다면, 네트워크 용량은 네트워크 내 노드의 수에 따라 증가하고 결국 네트워크 용량에 이론적인 한계가 없어집니다. 가장 좋은 점은, 샤딩은 레이어1 확장성 기술입니다.
샤딩(sharding)이란?
데이터베이스에서는 종종 너무 방대한 데이터를 다룹니다. 이는 성능과 처리 능력을 현저하게 저해하고 전체 프로세스를 극도로 비효율적으로 만듭니다. 이때 샤딩이 필요합니다.

샤딩은 데이터베이스를 수평적으로 분할하여 더 작고 관리하기 쉬운 테이블로 만듭니다.

왜 수직 분할이 아니라 수평 분할일까요?

다음과 같은 테이블을 생각해보세요:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



이 테이블을 수직으로 분할하면,



A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



보이시나요?

분할의 결과로, 테이블이 두 개의 완전히 다른 테이블로 바뀌었습니다.

반면에 수평으로 분할을 한다면 어떻게 될까요:



A
B
A*B
A/B


1
1
1
1


2
2
4
1






A
B
A*B
A/B


3
3
9
1


4
4
16
1



수평 분할은 데이터베이스를 동일한 데이터베이스의 작은 테이블로 쪼갭니다. 이 작은 테이블을 샤드(shards)라고 합니다.
샤딩이 블록체인에 어떻게 적용될까?
지금까지 봤듯이, 이더리움과 비트코인 네트워크에 더 많은 노드가 들어올수록 전체 합의 및 검증 과정에 걸리는 시간이 증가합니다. 샤딩은 이를 어떻게 해결할까요?

샤딩은 블록체인의 전역 상태를 더 작고 관리하기 쉬운 조각(샤드)로 분할합니다.

샤딩이 활성화되면:

 	상태는 샤드로 나누어집니다.
 	모든 고유 계정은 하나의 샤드에 포함되고, 샤드 내의 계정은 같은 샤드에 있는 계정과만 거래할 수 있습니다.

간단히 말해, 다음과 같은 상황을 생각해보세요. 가상 네트워크 상에 A,B,C 세 개의 노드가 있고 데이터 T를 검증해야 합니다. 데이터 T는 세 개의 샤드 T1,T2,T3로 쪼개집니다. 모든 노드가 T를 처리하는 대신, 노드 각각이 동시에 샤드를 하나씩 처리할 수 있습니다. 이런 방식으로 소모되는 시간을 기하급수적으로 줄일 수 있습니다.

다른 많은 샤딩 방식과는 다르게 노드가 복잡한 하드웨어에서 실행될 필요가 없기 때문에, NEAR에서는 노드가 단순한 클라우드 호스팅 인스턴스에서 실행될 수 있을 정도로 작습니다.
NEAR처럼 확장가능한 블록체인이 왜 필요할까?
힌트: 속도뿐만이 아닙니다!

2세대와 3세대 블록체인의 핵심 가치는 그 위에서 번창하는 디앱 생태계입니다. 따라서 많은 블록체인 플랫폼이 최대한 많은 개발자들을 유치하려 경쟁하고 있습니다.

그러나 현 플랫폼은 양질의 앱을 위한 정교함이 부족합니다. 이 문제는 윈도우 98 상에서 PS4 게임을 만들려는 것과 같습니다. 결국 개발자들은 디앱의 전체적인 기능성을 상당히 포기해야 합니다.

어플리케이션 사용성에서는 속도 또한 중요한 요소입니다. 사용자는 쓰기 힘든 어플리케이션을 사용할 이유가 없습니다. 개발자는 “임계점”에 도달할 때까지 일정 수의 사용자를 지속적으로 유치해야 합니다.

이것이 블록체인과 스마트 컨트랙트의 대중적 보급을 위해 NEAR처럼 확장 가능한 블록체인 플랫폼이 중요한 이유입니다.

NEAR는 개발자가 인프라 운영 및 확장을 걱정하지 않고 앱을 배포할 수 있도록 해줍니다. 이는 오늘날 대부분의 웹 어플리케이션을 구동하는 Amazon AWS, GCP, Azure와 유사합니다.
NEAR의 간단한 역사
NEAR는 2018년 여름 Alex Skidanove와 Illia Polosukhin이 이전 창업 시도에서 독립하면서 시작되었습니다. 궁금하시면 여기를 읽어보세요. Mishar가 MemSQL을 그만두며, 팀은 3일 만에 7명의 엔지니어, 비즈니스 운영을 맡은 Erik, 마케팅 담당인 Sasha까지 총 9명이 되었습니다.

현재 NEAR Collective는 수많은 개인 조직과 기여자로 이루어진 팀들로 구성된 전세계적인 그룹입니다. 이는 비즈니스나 형식적인 단체가 아니라 대규모 오픈 소스 소프트웨어 프로젝트를 운영하는 사람들의 모임과 비슷합니다.

Collective의 프로젝트 중 하나는 오픈 소스 NEAR 네트워크의 초기 코드 및 참조를 작성하는 것입니다. 이는 우주선의 로켓 추진기를 만드는 것과 같습니다. 그들의 역할은 블록체인이 궤도에 오를 수 있도록 필요한 연구 개발 작업을 수행하는 것입니다. 이 체인의 코드는 오픈 소스이므로 누구나 기여하거나 실행할 수 있습니다.

NEAR 네트워크는 완전히 분산화되도록 설계되어 있기 때문에 자체적으로 운영이 가능하고 제 3자로부터 검열이나 중단 등의 방해를 받지 않습니다. 심지어 초기 구축팀마저도요! 따라서 collective의 구성원들은 참조 구현을 시작하기 위한 업무를 수행하지만, 네트워크가 운영되기 시작하면 더 이상 필수적이지 않습니다. 사실, 출시 준비가 끝나고 나면 누구나 NEAR 프로토콜 코드를 수정하고 실행하여 자신만의 블록체인을 시작할 수 있습니다. 이는 모두 오픈 소스이며 변경 사항은 독립적인 검증원들이 민주적으로 결정하게 됩니다.

NEAR는 Microsoft, MemSQL, Meta, Google과 같은 회사의 개발자 및 연구자로 이루어진 다양한 배경을 가진 팀을 보유하고 있습니다. 이 프로젝트는 Andreessen Horowitz의 a16z, Metastable, Pantera, Ripple의 개발자 생태계 프로젝트 Xspring, Coinbase와 같은 실리콘 밸리에서 가장 영향력있는 벤처 투자자를 포함해 40개 이상의 투자 회사로부터 지원을 받고 있습니다.

메인넷 출시 이후, NEAR는 선택 단계를 위한 초석을 준비하고 있습니다.
레인보우 브릿지(Rainbow Bridge) 개발
레인보우 브릿지는 NEAR 생태계에서 가장 중요한 브릿지입니다. NEAR 프로토콜은 이를 신뢰와 허가 없이 이더리움, NEAR, Aurora 간 자산 이전을 가능하게끔 기획했습니다. 레인보우 브릿지는 개발자가 이더리움 자산을 NEAR에서, NEAR 자산을 이더리움에서 원활하게 사용할 수 있도록 도와줍니다. 출시 이후로, 개발자들은 이 브릿지를 통해 DAI, ETH 등 100만 달러 가치 이상의 자산을 이전하였습니다. 레인보우 브릿지는 NEAR와 Binance Smart Chain, Polygon, Avalanche, Optimism, Arbitrum 등 모든 이더리움 호환 체인을 연결할 수도 있습니다.
오로라(Aurora) 개발
오로라 EVM의 개발도 NEAR의 채택을 위한 주요 사건입니다. 오로라는 NEAR에서 제공하는 고유한 기능을 활용할 수 있는, 현존하는 가장 강력한 EVM입니다. 오로라는 오로라 엔진과 레인보우 브릿지라는 두 가지 핵심 요소로 이루어져 있습니다. 오로라 엔진은 Solidity와 Viper 스마트 컨트랙트의 원활한 배포를 가능하게 하고, 레인보우 브릿지는 이더리움과 오로라 간 자산 거래가 허가 없이 이루어질 수 있게 합니다. 오로라는 이더리움에 비해 수수료는 1000배 낮고, 처리 능력은 50배 이상 증가하여 초당 수천 건의 거래를 처리할 수 있습니다.
Private Shards 출시
2021년 9월, NEAR는 Private Shards를 출시하면서 또 한 번 중요한 성과를 이루었습니다. Private shards는 NEAR 상에서 샤드로써 동작하고, 퍼블릭 체인 컨트랙트가 private shard 컨트랙트를 호출하거나 그 반대도 가능하게 합니다.

Calimero 웹사이트에서 NEAR의 Private Shards에 대해 더 자세히 알아보세요.
디파이(DeFi) 펀드 창설
2021년 10월, Proximity Labs는 NEAR의 디파이 어플리케이션 구축을 위한 3억 5천만 달러의 개발 펀드를 발표했습니다. NEAR Foundation 또한 8억 달러의 디파이 펀드를 창설하였습니다. Blockworks는 NEAR에 초점을 맞춘 펀드를 발표하며, 4천만 달러를 모금할 것이라 밝혔습니다.
기타 중요한 개발 사항
앞서 언급한 개발 사항 외에도:

 	2021년, 글로벌 여행사 Travala.com은 NEAR와 파트너십을 맺고 Travala에 네트워크 토큰을 사용합니다.
 	NEAR는 개발자들이 NEAR 앱을 개발하는 것을 지원하기 위해 스타트업 플랫폼 Pagoda를 발표합니다. 또한 실물 화폐와 암호화폐를 연결하는, NEAR의 첫번째 체크카드이자 결제 위젯인 NEARPay를 발표합니다.
 	NEAR는 Y Combinator Alumni에서 만든 암호화폐 단체인 OrangeDAO에게 주요 레이어1 블록체인으로 채택되었습니다.
 	NEAR-native 스테이블코인 $USN이 Decentral Bank를 통해 발행되었습니다.

NEAR 블록체인의 동작 원리
블록 체인은 거래 기록을 한 곳에 저장하는 대신 P2P 네트워크에 안전하게 보관하는, 암호화폐의 기반이 되는 기술입니다. 블록체인을 운영하는 네트워크는 노드라는, 전 세계의 독립적인 서버로 이루어져 있습니다.

블록체인의 가장 큰 특징 중 하나는 탈중앙화(decentralization)입니다. 탈중앙화가 유용한 이유가 무엇일까요? 개발자와 최종 사용자의 관점에서 살펴봅시다.

 	개발자: 중앙화된 세계에서는 개발자가 앱이 계속 실행되도록 하기 위해 클라우드 플랫폼이나 정부에 의존해야 합니다. 탈중앙화 세계에서는 지배적인 중개인이 존재하지 않습니다.
 	최종 사용자: 탈중앙화 어플리케이션의 투명성 덕분에 사용자는 백엔드 코드를 보고 앱이 자신의 개인 정보를 어떻게 사용하는지 정확하게 알 수 있습니다.

NEAR 합의 알고리즘이란?
합의 프로토콜은 시스템 내 참여자 간에 단일 값을 합의하는 데 사용됩니다. 모든 네트워크 참여자가 합의 프로토콜에 따라 협력하면 새로운 값이 장부(ledger)에 기록되고 노드에 의해 검증될 수 있습니다. 그러나 분쟁이 생기는 경우 네트워크는 안전성이나 활성도 중 한 쪽에 더 초점을 맞추게 됩니다.

NEAR에서 구현된 합의 메커니즘은 나이트셰이드(Nightshade)입니다. 나이트셰이드는 시스템을 단일 블록체인으로 모델링합니다. 각 블록의 모든 거래 목록은 샤드당 하나씩 물리적 청크로 나눠집니다. 모든 청크는 하나의 블록에 누적됩니다. 청크는 해당 샤드의 상태를 유지하는 노드로만 검증할 수 있습니다.

검증에 관해서 NEAR의 핵심 구성 요소는 검증인입니다. 검증인은 포로토콜 내에서 합의를 유지하는 역할을 담당합니다. 검증인은 시스템을 지속적으로 업데이트하면서 서버를 100% 온라인 상태로 유지해야 하는 특수 노드입니다.

다음은 네트워크 검증자에 대해 명심해야 할 몇 가지 사항입니다.

 	NEAR는 새로운 에포크마다 지분에 따라 네트워크 검증인을 선출합니다.
 	이미 선출되었던 검증인도 자동으로 토큰과 누적된 보상을 다시 스테이킹하여 재등록됩니다.
 	잠재적 검증인은 동적으로 결정된 수준 이상의 지분을 보유해야 합니다.
 	검증인이 지분 강화를 위해 사용할 수 있는 두 가지 방법이 있습니다.
- 토큰을 직접 구매하거나, 지분 위임을 통해 빌리거나
 	받는 보상은 지분에 정비례합니다. 지분이 많을수록 보상도 많아집니다.

합의는 가장 무거운 체인 합의를 기반으로 합니다. 블록 생산자가 블록을 게시하면 검증인 노드의 서명을 수집합니다. 블록의 가중치는 해당 블록에 서명한 모든 노드의 누적 지분입니다. 체인의 가중치는 블록 가중치의 합입니다. 덧붙여, 합의는 체인 보안을 위해 슬래싱 조건을 강화하는 불변성 가젯을 활용합니다.



	

	
	
		
			
				블록의 가중치는?
			
		

		
					

		
			
			
			
			블록에 사인한 노드 중 지분의 최댓값
		
			
			블록에 사인한 노드의 지분 총 합
		
			
			전체 네트워크의 평균 지분을 블록에 사인한 노드의 숫자로 나눈 값
		
			
			전부 아니다
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR 런타임
런타임 레이어는 사용자가 만든 스마트 컨트랙트와 기타 작업을 실행하고 실행 간에 상태를 보존하는 데 사용됩니다. 런타임 레이어를 세 가지 각도에서 설명할 수 있습니다: 다양한 시나리오를 단계별로 살펴보기, 런타임 구성 요소를 설명하기, 런타임 시 수행하는 기능을 설명하기.
NEAR 토큰이란?
NEAR 토큰은 NEAR 생태계의 기본 자산이며 모든 계정에서 토큰의 기능을 사용할 수 있습니다. 각 토큰은 이더와 유사한 고유 디지털 자산으로 다음과 같이 사용할 수 있습니다:

 	거래 처리 및 데이터 저장을 위해 시스템에 지불합니다.
 	스테이킹 과정에 참여하여 네트워크의 일부로 노드 유효성 검사를 실행합니다.
 	거버넌스(governance) 과정에 참여하여 네트워크 리소스가 할당되는 방식과 향후 기술 방향을 결정하는 데 도움을 줍니다.

NEAR  토큰은 네트워크를 운영하는 모든 참여자의 경제적 조정과, 네트워크 상에 구축된 어플리케이션의 새로운 행동을 가능케 합니다.
NEAR 시작하기
계정/지갑

NEAR를 시작하기 전에 우선 NEAR 계정을 만들어야 합니다.
NEAR 계정에 대한 다음 영상을 보세요:
https://youtu.be/2_Ekz7w6Eo4

지갑을 통해 블록체인에 컨트랙트를 올리고, 로컬 노드를 설정하고, 다른 사용자와 자금을 주고 받을 수 있습니다. 지갑에 계정 ID를 등록할 때 고유한 이름을 입력해야 합니다. 지갑은 고유한 이름을 가져야 하지만, 모든 사용자는 여러 개의 지갑을 설정할 수 있습니다.

페이스북이나 구글 계정과 비슷하다고 생각하시면 됩니다. 이 서비스에 등록하면 동일한 계정을 사용하여 타사 서비스에 로그인할 수 있습니다. NEAR 계정 ID와 구글 계정의 차이는 바로 계정 ID에 저장된 데이터에는 지갑 소유자만 접근하고 관리할 수 있다는 점입니다. 또한 모든 정보는 단일 서버가 아니라 노드의 분산 네트워크에 저장됩니다.

지금 NEAR 계정을 만드세요: https://wallet.near.org/create

더 자세한 정보는 다음을 참조하세요: https://learnnear.club/doc/videos/accounts-keys/
NEAR Explorer
NEAR Explorer는 블록 생성을 실시간으로 보여줍니다! 이를 활용하여 거래와 계정을 검색하고 사용자와 스마트 컨트랙트 간의 모든 상호작용을 확인할 수 있습니다.

NEAR 토큰을 획득하는 방법
다음은 $NEAR를 획득하는 4가지 방법입니다.

 	이더리움 유저는 지갑을 설정하여 무료 NEAR를 얻을 수 있습니다: https://faucet.paras.id


 	개발에 참여하거나, NEAR의 사람들을 돕거나, NEAR 해커톤에서 우승하거나, 기타 커뮤니티에 적극적으로 참여하여 $NEAR를 얻을 수 있습니다. 스테이킹을 위한 토큰을 가지고 있다면, 검증인으로 참여하여 $NEAR를 벌 수도 있습니다.
 	$NEAR는 여러 주요 거래소(아래를 참조하세요)에서 구매할 수 있습니다.
coinmarketcap이나 coingecko에서 가격 및 페어에 대한 개요를 확인할 수 있습니다.
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR
 	NEAR 계정이 없어도 NEAR 토큰을 받을 수 있습니다! “NEAR Drop”을 사용하면 당신의 친구가 새로운 계정에 미리 자금을 넣어두고 토큰을 받을 수 있는 링크를 당신에게 보낼 수 있습니다.

NEAR 토큰으로 할 수 있는 일
NEAR 전송

$NEAR를 주고 받으며 거래를 Explorer에서 확인하세요. 거래 수수료가 매우 낮아서 아주 적은 양의 $NEAR를 빠르고 쉽게 이동할 수 있습니다.

선물을 보낼 수도 있습니다: http://redpacket.near.org/

NEAR Drop(친구를 초대해보세요)

계정이 없는 친구에게 NEAR Drop을 보낼 수 있습니다.

NEAR 앱 사용하기

NEAR 기반 앱 목록을 보려면 여기를 클릭하세요.

NFT 쉽게 시작하기: https://paras.id/

공동 예술 창작에 참여하기: https://berryclub.io/
NEAR의 가스(Gas) 가격
데이터를 갱신하거나 변경하기 위해 NEAR 블록체인을 호출할 때, 블록체인 인프라를 운영하는 사람들에게 약간의 비용이 발생합니다. 하루가 끝날 때 어딘가에 있는 컴퓨터가 그 요청을 처리하고, 이 컴퓨터를 운영하는 검증인은 상당한 자본을 지출합니다.

다른 프로그래밍 가능한 블록체인과 마찬가지로 NEAR는 가스비라고 하는 거래 수수료를 청구하여 이들에게 보상을 제공합니다.

웹2 클라우드 서비스 제공자(Amazon Web Services, Google Cloud 등)에 익숙하다면, 블록체인의 차이점은 개발자가 모든 인프라 사용 비용을 부담하는 것이 아니라 사용자가 앱을 호출할 때 즉시 비용이 청구된다는 점입니다.  이는 개발자나 회사의 자금 고갈로 인해 앱이 사라질 위험을 방지하는 역할을 하지만 사용성 측면에서는 방해가 되기도 합니다. 이러한 문제를 해결하기 위해 NEAR는 개발자가 사용자의 가스 비용을 대신 부담할 수 있는 기능을 추가했습니다. 이를 통해 웹2 사용자에게 더 친숙한 경험을 제공할 수 있습니다.
가스에 관해서 두 가지를 명심하세요:

 	가스 단위: 내부적으로 거래 수수료는 NEAR 토큰으로 직접 계산되지 않고 중간 단계인 “가스 단위”를 거칩니다. 가스 단위의 장점은 동일한 거래에 항상 동일한 가스 단위의 비용이 소모된다는 것입니다.
 	가스 가격: 가스 단위에 가스 가격을 곱하여 사용자에게 청구할 금액을 결정합니다. 가격은 네트워크 수요에 따라 매 블록마다 자동으로 재계산됩니다. 이전 블록이 반 이상 차 있다면 가격이 올라가고, 아니라면 내려갑니다. 매 블록마다 1% 이상 변경되지 않습니다. 네트워크에서 구성한 가격(현재 1억 yoctoNEAR)이 하한선입니다.

NEAR의 메인넷과 테스트넷에서 가스 가격이 다를 수 있습니다. 아래 숫자에 의존하기 전에 가스 가격을 확인하세요.
가스로 생각하기
NEAR는 블록 당 가스 양을 제한하여 대략 1초의 블록 시간을 가집니다. 가스 단위는 생각하기 쉬운 수치가 되도록 설정되었습니다.

1012 가스, 혹은 1 TGas (TeraGas) ≈ 1밀리초의 “계산” 시간

이는 1억 yoctoNEAR의 최소 가스 가격 기준으로 0.1milliNEAR에 해당하는 금액입니다.

이 1ms는 대략적이지만 유용한 근사치이며, 현재 NEAR 내에서 가스가 설정되는 방식에 대한 목표입니다. 가스 단위는 컴퓨팅/CPU 시간, 대역폭/네트워크 시간, 저장소/IO 시간을 요약합니다. 거버넌스 방식을 통해 시스템 변수를 조정하여 향후 TGas와 밀리초 사이의 관계를 변경할 수 있지만, 위의 내용은 여전히 가스 단위의 의미와 그 출처에 대해 생각해볼 수 있는 좋은 출발점입니다.



	

	
	
		
			
				1테라가스(TGas)와 같은 것은?
			
		

		
					

		
			
			
			
			1마이크로초의 계산 시간
		
			
			10초의 계산 시간
		
			
			1밀리초의 계산 시간
		
			
			1나노초의 계산 시간
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






일반적인 작업의 비용
NEAR에서 작업 시 필요한 비용을 예상할 수 있도록, 아래 표에 일반적인 작업과 그에 필요한 TGas의 양, 최소 가스 가격인 1억 yN을 기준으로 한 수수료(밀리NEAR 단위)를 적어 두었습니다.



작업
TGas
수수료(mN)
수수료(Ⓝ)


계정 생성
0.42
0.042
4.2⨉10-5


송금하기
0.45
0.045
4.5⨉10-5


스테이킹
0.50
0.050
5.0⨉10-5


전체 액세스 키 생성
0.42
0.042
4.2⨉10-5


키 삭제
0.41
0.041
4.1⨉10-5



NEAR를 얻는 방법
스테이킹

지분 증명 모델의 핵심은 스테이킹을 통해 검증인이 커뮤니티의 지원을 받는 것입니다. 검증인은 매년 5%의 고정 물가상승률의 형태로 매 에포크(~12시간)마다 검증인에게 보상으로 줄 새로운 토큰을 생성하는 네트워크 노드를 운영하고 보상으로 NEAR 토큰을 얻습니다.

검증인은 자격을 유지하기 위해 최소한의 스테이킹을 유지해야 합니다. 토큰 보유자는 좋은 성과를 내고 있는 검증인에게 스테이킹을 하고 생성되는 토큰 보상의 일부를 받을 수도 있습니다. 이는 토큰 보유자들이 커뮤니티에 계속해서 참여하도록 인센티브를 제공합니다.

NEAR 지갑은 스테이킹 사용자를 위한 인터페이스가 내장되어 있습니다.

스테이킹 하기:

 	탐색 바(모바일의 경우 드롭다운)에서 “Staking”을 선택합니다.
 	“Select Validator” 버튼을 클릭합니다.
 	검증인을 선택합니다.
 	내용을 확정하고 “Stake with Validator”를 선택합니다.
 	스테이킹할 NEAR 금액을 입력하고 “Submit Stake”를 클릭합니다.

검증인을 선택하는 것과 선택한 검증인에게 스테이킹하는 것, 총 두 가지의 거래를 승인해야 합니다.

스테이킹 취소하기:

 	스테이킹 대시보드(/staking)에서 현재 검증인을 선택합니다.
 	“Unstake”를 클릭하고 거래를 승인합니다.

36~48시간(4 에포크) 후에, 지분을 빼낼 수 있습니다. 검증인 페이지로 돌아가서 “Withdraw”를 클릭하세요.



	

	
	
		
			
				에포크 이후 보상으로 토큰이 생성되는 주기는?
			
		

		
					

		
			
			
			
			12분
		
			
			12초
		
			
			12일
		
			
			12시간
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






NEAR에서 DeFi 구축하기
DeFi(탈중앙화 금융) 생태계가 뜨겁습니다. 이더리움은 1,000억 달러 이상의 가치를 지닌 DeFi 네트워크를 보유하고 있습니다. NEAR의 DeFi 생태계는 아직 어리고 성장하고 있습니다.

DeFiLlama에 따르면, NEAR 생태계의 총 고정 가치는 1억 달러 미만이며 Ref Finance가 선도하고 있습니다. 이더리움의 DeFi 생태계가 NEAR의 1000배에 달한다는 사실은 NEAR DeFi가 아주 초기 단계에 있음을 보여줍니다. 실제로 2021년에 NEAR 프로토콜은 8억 달러 규모의 펀딩 계획을 발표했습니다. 펀드의 대부분은 DeFi 부문을 성장시키기 위해 사용될 예정입니다.

NEAR의 DeFi 생태계에 대해 더 알고 싶다면, 이 글을 읽어보세요.
성장하는 NEAR의 NFT 생태계
대체 불가능한 자산은 다른 자산과 차별화되는 고유한 속성을 가지고 있습니다. NFT(대체 불가능 토큰)은 대체 불가능한 자산을 기반으로 하며 블록체인 기술을 사용하는 고유한 디지털 자산입니다. 이 분야는 최근 폭발적인 인기를 끌고 있습니다.

NEAR 프로토콜은 이더리움에 비해 두 가지 주요 장점을 가지고 있는 NFT를 위한 완벽한 플랫폼입니다:

 	NEAR는 훨씬 빠릅니다.
 	이더리움은 가스 수수료가 상당히 높습니다.

이러한 요인으로 인해 NEAR는 NFT를 사고 팔기에 이상적입니다. 이 기사를 통해 NEAR의 상위 7개 NFT 프로젝트에 대해 더 알아보세요.
그럼 이제, NEAR와 어떻게 상호작용할까요?
다음은 무엇일까요? 여기까지 읽으셨다면, NEAR 프로토콜에 대해 더 자세히 알아보고 싶을 것입니다. 다음으로 해야 할 일은 NEAR 백서를 확인하는 것입니다. 블록체인을 처음 접하고 기술 자체에 대해 더 알고 싶다면 블록체인 생태계에 관한 이 영상을 확인해보세요.

NEAR 디스코드 서버에 가입하고 NEAR 포럼을 확인하세요.

### What is your favorite NEAR DeFi platform?

What is your favorite NEAR DeFi platform? 
            
                312 votes by,
                720 nLEARNs spent
            
            
            
                                    
                        
                            Ref                            
                                (39 votes,
                                57 nLEARNs)
                            
                        
                        
                             
                            13%
                        
                    
                                    
                        
                            Meta Pool                            
                                (42 votes,
                                104 nLEARNs)
                            
                        
                        
                             
                            13%
                        
                    
                                    
                        
                            Spin                            
                                (227 votes,
                                553 nLEARNs)
                            
                        
                        
                             
                            73%
                        
                    
                                    
                        
                            Burrow                            
                                (1 votes,
                                1 nLEARNs)
                            
                        
                        
                             
                            0%
                        
                    
                                    
                        
                            Orderly                            
                                (3 votes,
                                5 nLEARNs)
                            
                        
                        
                             
                            1%
                        
                    
                                    
                        
                            PembRock                            
                                (0 votes,
                                0 nLEARNs)
                            
                        
                        
                             
                            0%
                        
                    
                                    
                        
                            Tonic                            
                                (0 votes,
                                0 nLEARNs)
                            
                        
                        
                             
                            0%

### Стейкинг с Meta Pool

Meta Pool, Модуль 1 – Первые шаги по ликвидному стейкингу
Стейкинг и консенсус в протоколе NEAR
Сначала рекомендуется пройти курс NEAR Power User в Learn NEAR Club (LNC), чтобы получить базовые знания о протоколе NEAR.

Каждой сети блокчейнов требуется метод подтверждения создаваемых новых блоков.

В сети Proof-Of-Stake этот процесс выполняется узлами валидаторов. Чтобы выбрать эти узлы валидатора, необходимо заблокировать токены, назначив их валидатору, это называется стейкингом. На основе количества застейканных токенов NEAR создается набор валидаторов, которые будут участвовать в создании блоков.

Чтобы стимулировать делегаторов и валидаторов токенов, они получают вознаграждение от комиссий, покрываемых протоколом. Таким образом, стейкинг — это способ заработать больше токенов и помочь защитить сеть.

Некоторые из недостатков этого стандартного стейкинга заключаются в том, что ваши токены заблокированы, и вы не можете вывести их до окончания периода анстейкинга. Также вы не можете использовать свои токены каким-либо образом, потому что они делегированы узлу валидатора. Эти два ограничения решаются, когда вы делаете ликвидную ставку.
Proof of Stake
Investopedia.com определяет Proof-of-Stake (PoS) как:

Proof-of-stake — это механизм консенсуса криптовалюты для обработки транзакций и создания новых блоков в блокчейне.

Механизм консенсуса — это метод проверки записей в распределенной базе данных и обеспечения безопасности базы данных. В случае с криптовалютой база данных называется блокчейном, поэтому механизм консенсуса защищает блокчейн.

Протокол NEAR использует PoS в качестве системы для обработки всех транзакций, выполняемых в сети, путем размещения токенов NEAR, собственных токенов из этой цепочки блоков. При стандартном стейкинге вы можете выбрать 1 единственный узел валидатора и делегировать (заблокировать) ему свои токены. Это поможет валидатору обрабатывать блоки или фрагменты и выдавать вознаграждения, если он выше коэффициента Накамото.

Однако делегирование в стандартном стекинге PoS-систем имеет отсроченный механизм или даже невозможность анстейкинга ваших токенов, как в эфириуме. В этом случае решение для ликвидного стейкинга может поддерживать как сетевую безопасность в PoS, так и возможность использовать ваши токены.

 	Ноды валидаторов

Валидаторы — это компьютеры, получившие достаточное количество токенов (долей), чтобы начать подтверждать транзакции в сети NEAR.

В сети NEAR Proof-of-Stake децентрализованный пул валидаторов обрабатывает транзакции для обеспечения безопасности сети. Взамен эти валидаторы получают за это вознаграждение. Эта система также позволяет делегаторам — организациям, которые хотели бы обеспечить безопасность, но могут не иметь для этого оборудования — делегировать свои токены валидаторам.

Эти валидаторы предоставляют компьютерную мощность сети для вычисления новых блоков и взамен получают вознаграждение в зависимости от количества произведенных блоков или фрагментов.

Подробнее о валидаторах протокола NEAR читайте здесь: https://near.org/about/network/validators/




	

	
	
		
			
				Proof of Stake работает так же, как и Proof of Work ?
			
		

		
					

		
			
			
			
			Правда
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Награды и токеномика NEAR

NEAR — это токен, используемый для покрытия всех комиссий по протоколу NEAR.

На графике указан 5-летний и постепенный выпуск токенов.

Как упоминалось в документации, 5% токенов выпускаются каждый год для поддержки сети в качестве наград за эпоху, из которых 90% идут валидаторам (всего 4,5%) и 10% в казну протокола (всего 0,5%).

Дополнительные ресурсы

 	Официальный пост NEAR Foundation: https://near.org/blog/near-token-supply-and-distribution/


 	Тема NEARWEEK о ликвидных ставках: https://twitter.com/NEARWEEK/status/1618257119958175747




	

	
	
		
			
				Какое количество токенов $NEAR распределяемых в год среди валидаторов и делегаторов?
			
		

		
					

		
			
			
			
			45 миллионов
		
			
			12,5 миллионов
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Что такое ликвидный стейкинг? Понимание Meta Pool и актива stNEAR

Протоколы ликвидного стейкинга находятся в авангарде экономики стейкинга криптовалюты, революционизируя доступ к ликвидности в индустрии децентрализованных финансов (DeFi).

Ликвидный стейкинг — это альтернатива традиционному стейкингу: он позволяет пользователям ставить любое количество NEAR и эффективно снимать свои $NEAR без необходимости ждать ~ 48-72 часов (4-6 эпох), прежде чем держатели токенов NEAR получат свои комбинированные вознаграждения.

Одним из преимуществ ликвидных ставок является возможность взаимодействовать и использовать средства, одновременно получая вознаграждение. В результате протоколы ликвидного стейкинга обеспечивают основу для таких видов деятельности, как протоколы кредитования.

Пользователи могут взаимодействовать с многочисленными платформами DeFi, получая несколько вознаграждений из одного пула средств.

 	Критерии выбора валидаторов

Meta Pool следует стратегии Фонда NEAR по распределению доли среди высокопроизводительных, неконцентрированных валидаторов с низкой комиссией, чтобы повысить децентрализацию и устойчивость NEAR.

Оцениваются все валидаторы, в основном продукте нет белых списков. Публикуется формула, код, которую используют для вычисления , а также результаты, которые будут в цепочке. Идея заключается в том, чтобы быть полностью прозрачным и открытым для всех валидаторов.

Есть 5 критериев для выбора валидаторов в сети NEAR, которые соответствуют идеалу прозрачности и справедливости:

 	Время безотказной работы > 95 %
 	Сборы < 10%
 	Валидатор не снижает коэффициент Накамото.
 	Имеет достаточно токенов
 	Производит награды в течение как минимум 4 последовательных эпох

Вы можете просмотреть список валидаторов Meta Pool здесь, вам просто нужно ввести meta-pool.near в фильтр аккаунта.




	

	
	
		
			
				Поддерживает ли ликвидный стейкинг в Meta Pool децентрализацию сети?
			
		

		
					

		
			
			
			
			Правда
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Шаг за шагом: моя первая ликвидная ставка на Meta Pool

Meta Pool позволяет держателям токенов NEAR делать ставки и получать вознаграждения, предоставляя простой способ отмены ставок без периода блокировки.

Он не помещает все ваши ставки NEAR только в один валидатор, скорее, Meta Pool распределяет их среди множества высокопроизводительных валидаторов с низкой комиссией, чтобы вы могли получать наилучшие вознаграждения, в то же время обеспечивая децентрализованность сети и устойчивость к

цензуре.

 	Войдите в Meta Pool, нажав «Начать стейкинг».



 	Нажмите «Стейкать сейчас» в поле «Стейкинг NEAR».



 	Выберите предпочитаемый кошелек, для этого примера мы будем использовать родной кошелек NEAR.



 	Выберите кошелек NEAR, который вы хотите использовать, из раскрывающегося меню и разрешите приложению доступ к вашему кошельку NEAR: нажмите «Авторизация».



 	После того, как вы вошли в систему, перейдите на домашнюю страницу и введите сумму, которую вы хотите застейкать, затем нажмите «стейкинг».

Примечание: вы всегда должны оставлять немного NEAR в своем кошельке для покрытия транзакционных издержек.


 	Обратите внимание, что минимум, который вы можете поставить, составляет 1 $ NEAR.


Вы получите подтверждение после того, как транзакция будет обработана блокчейном и депозит вашей ставки будет успешным. Обычно это занимает всего несколько секунд.

 	Теперь вы можете увидеть средства на своих счетах на страницах «Главная» и «Заработано».


Примечание. На этой панели отображаются только ваши активы ($NEAR и stNEAR) из вашего кошелька. Если вы переведете или продадите свои токены stNEAR, они больше не будут отображаться на этой панели.

На панели вы можете увидеть текущую статистику Meta Pool:

Пошаговая инструкция: отмена стейкинга ваших токенов NEAR.
В Meta Pool есть 2 варианта отмены ставок: вы можете ликвидировать ставки (немедленно отменить ставки) или выполнить традиционную отмену ставок (с задержкой 48–72 часа).

Ликвидный анстейк

Вы можете немедленно отменить ставку своего токена stNEAR, заплатив небольшую комиссию и воспользовавшись функцией Liquid Unstake. Делая это, вы фактически обмениваете свой токен stNEAR на NEAR. Это стало возможным благодаря пулу ликвидности Meta Pool.

Чтобы ликвидировать ставки нужно:

 	Перейдите на вкладку Unstake в меню навигации.
 	Просмотрите текущую комиссию за отмену ставок и решите, хотите ли вы продолжить.
 	Введите количество stNEAR, которое вы хотите отменить.
 	Нажмите «Liquid Unstake» и подтвердите транзакцию.
 	Через несколько секунд, после того как ваша транзакция будет подтверждена блокчейном, вы получите незаложенный NEAR в своем кошельке NEAR.


Примечание. Комиссия за ликвидность Meta Pool находится в диапазоне от 0,3% до 3%. Он изменяется линейно в зависимости от количества ликвидности, доступной в пуле.




	

	
	
		
			
				Цена stNEAR привязана 1:1 к токену NEAR?
			
		

		
					

		
			
			
			
			Правда
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Традиционная отмена ставок (с задержкой)

Традиционный анстейк — это стандартная форма анстейкинга от любого валидатора по протоколу NEAR: из-за дизайна сети валидаторы ждут 4–6 эпох (48–72 часа), прежде чем вернуть поставленные средства обратно пользователю. Отложенный анстейкинг бесплатен для всех пользователей.

Чтобы вывести свои средства из Meta Pool с помощью Delayed Unstake:

 	Перейдите на вкладку «Delayed Unstake» в меню навигации вверху.
 	Введите сумму NEAR, которую вы хотите отменить, и нажмите кнопку «Начать отложенную отмену ставок».



 	Вы увидите уведомление, информирующее вас о приблизительном времени ожидания. Просмотрите и подтвердите.



 	Вам будет предложено авторизовать транзакцию в кошельке NEAR. Щелкните Авторизовать.
 	После отсроченного периода разблокировки средства будут доступны для вывода, нажмите «снять» и подтвердите транзакцию, ваши неразмещенные NEAR появятся в вашем кошельке NEAR.




	

	
	
		
			
				Отложенная отмена ставок влияет на производительность сети из-за дополнительного времени, необходимого для удаления делегированных токенов $NEAR?
			
		

		
					

		
			
			
			
			Правда
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Шаг за шагом: быть поставщиком ликвидности

Liquid Unstaking возможен только благодаря поставщикам ликвидности (LP) необходимым для мгновенных свопов (снятий средств) с помощью stNEAR. Поставщики ликвидности получают комиссию за ликвидный анстейкинг.

Чтобы добавить или снять $NEAR в качестве поставщика ликвидности:

 	Перейдите на вкладку «Ликвидность» на странице Meta Pool.
 	Выберите, хотите ли вы «Добавить» или «Удалить» ликвидность
 	Введите сумму $NEAR, чтобы добавить или удалить


Примечание: минимум, необходимый для обеспечения ликвидности, составляет 2 $NEAR.


 	Подтвердить и подписать транзакцию

Теперь каждый раз, когда кто-то делает ликвидный анстейк, вы будете получать часть комиссии в соответствии с вашим капиталом в пуле ликвидности.




	

	
	
		
			
				~10,8% APY является стандартом в любое время для поставщика ликвидности?
			
		

		
					

		
			
			
			
			Правда
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!

### Como funciona a NEAR Rainbow Bridge

Artigo de Matt Henderson de Aurora 

A NEAR Rainbow Bridge é única em criptografia, é a única ponte sem permissão e Trustless (que não precisa confiança) para Ethereum. Neste artigo, vamos demonstrar como funciona!

O protocolo NEAR criou a Rainbow Bridge, algo que é único e valioso no espaço criptográfico, uma ponte totalmente "Trustless" para transferir tokens entre Ethereum e NEAR - e, finalmente, Aurora. Embora existam descrições técnicas da ponte por aí, este artigo explicará como ela funciona de uma maneira que esperamos que seja compreensível por qualquer pessoa com familiaridade básica com criptografia.
O conceito
Vamos começar imaginando que eu quero transferir 20 DAI desde Ethereum até NEAR. Como a transferência física de tokens não é possível entre redes, isso significa que precisamos tirar 20 DAI de circulação no Ethereum e colocar 20 DAI em circulação na NEAR, para que a oferta global de DAI não mude.

Veja como eu poderia fazer isso sem necessidade de confiança e sem permissão:

 	Digo à rede Ethereum que quero transferir 20 DAI para outro lugar.
 	A rede Ethereum bloqueia meus 20 DAI em um cofre (um contrato inteligente), para que sejam retirados de circulação.
 	Quando tenho a certeza de que esses 20 DAI foram bloqueados no Ethereum, digo ao NEAR para criar 20 novos DAI para mim lá.
 	Logicamente o NEAR não confia em mim, portanto me pede provas que bloqueei 20 DAI no Ethereum.
 	Forneço ao NEAR a prova de que bloqueei esses DAI no Ethereum.
 	NEAR verifica minha prova de maneira independente e, em seguida, cria 20 novos DAI para eu usar no NEAR.

Mais tarde, se e quando eu desejar mover meu DAI de NEAR de volta para Ethereum, simplesmente inverto o procedimento acima. Legal, hein?
Os atores
Então agora vamos ver como tudo isso acontece na prática, usando o Rainbow Bridge. A história vai envolver uma série de componentes técnicos que compõem a ponte:

A Rainbow Bridge UI — Este é  o site  onde você, como usuário, interage com a ponte para transferir seus ativos entre as redes.

O LiteNode — Isso é como um nó na blockchain, exceto que ele armazena apenas cabeçalhos de bloco, reduzindo drasticamente o espaço de armazenamento necessário. O LiteNode é implementado como um contrato inteligente e temos dois deles - um implantado na rede Ethereum, que armazena cabeçalhos de bloco NEAR, e outro implantado em NEAR, que armazena cabeçalhos de bloco Ethereum.

(Para a sua informação, o LiteNode é realmente referido, em outros artigos, como o “cliente leve”, por razões históricas. Se você me perguntar: “O que é que armazena dados de blockchain?”, meu primeiro pensamento é “um nó” e, portanto, neste artigo, para ajudar com modelos mentais, eu o chamo de LiteNode).

Relayers (Retransmissores) — Como os LiteNodes são contratos inteligentes, eles não podem ser executados e atualizados sozinhos. Relayers são scripts rodando em servidores tradicionais, que periodicamente leem blocos de uma blockchain, e os comunicam ao LiteNode rodando em outra. Assim, os retransmissores mantêm os LiteNodes atualizados.

Como há um custo de transação - ou seja, taxas de gás - cada vez que um retransmissor atualiza um LiteNode, o que está em NEAR (contendo os blocos Ethereum) é atualizado em cada bloco Ethereum (já que as taxas de gás NEAR são baratas), enquanto a frequência de atualização no Ethereum (contendo os blocos NEAR) é configurável e determinada por um orçamento econômico (atualmente cerca de 12 a 16 horas).

Connectors (conectores)— Connectors são contratos inteligentes responsáveis por toda a lógica associada ao gerenciamento de cadeia cruzada (cross-chain) de um determinado tipo de ativo. Como os LiteNodes, eles existem em pares - um funcionando na Ethereum e outro funcionando na NEAR. Por exemplo, existe um par de “ETH Connectors” responsáveis pela transferência de ETH entre as duas redes. E há um par “ERC-20 Connector” responsável por transferir tokens ERC-20. Alguém poderia escrever um Conector “NFT”, um Conector “Resultados do Mercado de Previsão” ou um Conector “Resultados da Votação DAO” se assim o desejasse. Qualquer ativo ou dados podem ser transferidos através do Rainbow Bridge, se existirem os conectores pertinentes!
Juntando as peças
Para entender como todos esses elementos funcionam juntos para suportar que eu transfira tokens sem permissão e sem confiança entre Ethereum e NEAR, vamos repassar nosso exemplo original mais uma vez:

 	Usando a IU da Rainbow Bridge, dou início a uma transferência de 20 DAI do Ethereum para o NEAR.
 	Quando confirmo a primeira das duas transações em MetaMask, a Rainbow Bridge se comunica com o conector ERC-20 no Ethereum (já que DAI é um token ERC-20), que transfere e bloqueia 20 DAI em seu cofre. Esses DAI já não irão estar mais em circulação na rede Ethereum.
 	Com base nos dados do cabeçalho no meu bloco de transação, a IU de Rainbow Bridge calcula uma “prova” criptográfica de que eu realmente tenha bloqueado 20 DAI.
 	Como vamos pedir à rede NEAR para criar algum DAI com base no que acabou de acontecer no Ethereum, primeiro esperamos que o Relayer envie cerca de 20 cabeçalhos de bloco Ethereum para o LiteNode em execução no NEAR. Isso é para mais segurança, da mesma forma que sua troca de criptografia faz você esperar por algumas confirmações antes de usar seus fundos depositados.
 	Após essa espera, a interface do usuário do Rainbow Bridge nos permite dar o passo número dois no processo - solicitar ao conector ERC-20 no NEAR para criar 20 novos DAI para nós na rede NEAR.
 	Quando fazemos essa solicitação do conector ERC-20, fornecemos nossa prova criptográfica que recebemos anteriormente, “provando” que bloqueamos 20 DAI no Ethereum.
 	O conector ERC-20 no NEAR procurará nosso cabeçalho de bloco Ethereum no LiteNode em execução no NEAR e fará seu próprio cálculo independente da prova criptográfica.
 	Se a prova que fornecemos coincide com a prova que o conector ERC-20 calculou, então estará comprovado que esses 20 DAI estão trancados com segurança no Ethereum - e que fui eu quem bloqueou! então serão criados (mint) 20 novos DAI em NEAR e entregues na minha carteira.

Quando queremos transferir DAI de NEAR de volta para Ethereum, o processo ocorre ao contrário, ou seja, em vez de bloquear 20 DAI em NEAR, nós os destruímos – operación conhecida como “burning” – e então fornecemos a “prova” dessa destruição para o Conector operando no Ethereum. Tendo acesso aos blocos NEAR no LiteNode que funciona no Ethereum, ele valida nossa prova, libera 20 DAI de seu cofre e envia para nossa carteira!

E é assim, em poucas palavras, que funciona a Rainbow Bridge! É a única ponte Ethereum em criptografia que funciona dessa maneira, atualmente - deixando que você transfira ativos sem permissão entre Ethereum, NEAR e em breve, Aurora sem ter que confiar em terceiros. Muito legal!
Miscelâneos:
Aqui estão algumas notas interessantes para acompanhar essa visão geral:

 	Como o NEAR-to-Ethereum Relayer envia apenas cabeçalhos de bloco NEAR para o Ethereum LiteNode a cada 16 horas, há um atraso de 16 horas entre as etapas um e dois ao mover os tokens nessa direção. (Lembre-se, isso ocorre porque as taxas de gás Ethereum tornam proibitivamente caro para o Relayer atualizar o LiteNode em cada bloco.) Existem várias formas de abordagens que nos permitiriam reduzir esse atraso, e a equipe está trabalhando ativamente nisso.
 	No NEAR, o LiteNode armazena todos os cabeçalhos de bloco Ethereum anteriores. Para que o espaço de armazenamento não fique fora de controle, o LiteNode “remove” (exclui) blocos com mais de duas semanas. Isso significa que se você iniciar uma transferência de Ethereum para NEAR e sair de férias por três semanas entre as etapas um e dois, não poderá concluir sua transferência, porque os dados Ethereum armazenados NEAR necessários para verificar sua “prova” já estariam excluídos!
 	Uma propriedade interessante do design do cabeçalho do bloco NEAR é que, com um único cabeçalho de bloco, podemos calcular o histórico de blocos anteriores por um período bastante longo. Então, em teoria, o LiteNode no Ethereum só precisa de um único bloco NEAR; no entanto, nós os mantemos porque os custos de gás necessários para realizar a remoção seria basicamente um desperdício de recursos.
 	A equipe que criou a Rainbow Bridge é a mesma que criou a Aurora - o NEAR EVM. Como essa equipe se transformou em sua própria entidade, a Rainbow Bridge ficará sob sua própria administração para operações, manutenção e evolução futura.
 	A equipe do Aurora está trabalhando na “finalização automática” para a Rainbow Bridge, para que você não precise mais iniciar manualmente a etapa número dois dessas transferências. Isso será muito conveniente para os usuários (o que significa que você pode iniciar sua transferência Ethereum para NEAR e depois sair de férias!).
 	As transferências entre Ethereum e Aurora são realizadas pela Aurora Bridge, que usa a mesma tecnologia central da Rainbow Bridge, mas aprimorada para lidar com a etapa oculta NEAR/Aurora nas transferências.
 	A interface do usuário e a experiência do Aurora Bridge são diferentes da Rainbow Bridge e, em algum momento no futuro, eles serão compatibilizados.

Embora alguns detalhes técnicos tenham sido simplificados, agora você tem uma compreensão fundamental de como funciona a Rainbow Bridge!

Para uma descrição mais aprofundada da Rainbow Bridge, você pode ler este artigo, e também para ficar por dentro de tudo relacionado a Aurora, não deixe de seguir Aurora no Twitter

### Staking com Meta Pool

Meta Pool, Módulo 1 – Primeiros passos no staking líquido
Protocolo de staking e consenso no Protocolo NEAR
Antes de começar, é recomendável que você siga o Curso de usuário avançado da Near do Learn NEAR Club (LNC) para ter conhecimentos básicos sobre o protocolo NEAR.
Toda rede blockchain requer um método para confirmar os novos blocos que estão sendo produzidos.Em uma rede Proof-Of-Stake (prova de participação) este processo é feito pelos nós validadores. Para escolher esses nós validadores é necessário bloquear os tokens atribuindo-os a um validador, isso é conhecido como staking. Baseado na quantidade de tokens NEAR em Stake, é feito o conjunto de nós validadores que participam na criação dos blocos.
A fim de incentivar os delegadores e validadores de tokens, eles recebem recompensas das taxas cobertas pelo protocolo. Desta forma, fazer staking é uma maneira de ganhar mais tokens e ajudar a proteger a rede.
Alguns dos contras de fazer este tipo de padrão de stake é que seus tokens estarão bloqueados e você não poderá retirá-los antes do término do período de retirada. Além disso, você não pode usar seus tokens de forma alguma porque eles são delegados a um nó validador. Essas duas limitantes são solucionadas quando você faz staking líquido.
Prova de Stake
Investopedia.com define Prova de stake (PoS) como:
A prova de stake é um mecanismo de consenso de criptomoedas para processar transações e criar novos blocos em uma blockchain.

Um mecanismo de consenso é um método para validar entradas em um banco de dados distribuído e manter o banco de dados seguro. No caso da criptomoeda, o banco de dados é chamado de blockchain, portanto o mecanismo de consenso protege a blockchain.

Com isso em mente, o NEAR Protocol usa o PoS como o sistema para processar todas as transações em execução na rede fazendo stake de tokens NEAR, o token nativo dessa blockchain. No stake padrão, você pode escolher um único nó validador e delegar (bloquear) seus tokens a ele. Isso ajudará o validador a processar blocos ou fragmentos e produzir recompensas se estiver acima do coeficiente de nakamoto.

No entanto, a delegação no staking padrão de sistemas PoS tem um mecanismo de retraso, por exemplo o Protocolo NEAR, ou mesmo a incapacidade de retirar seus tokens, como no ethereum. Nesse caso, uma solução de staking líquida pode oferecer suporte a ambos: Segurança de rede em PoS e a capacidade de usar seus tokens.
1. Nós validadores
Os validadores são computadores que receberam tokens (stake) suficientes para começar a confirmar transações na rede NEAR.
Na rede “NEAR Proof-of-Stake”, um pool descentralizado de validadores processa transações para manter a rede segura. Em troca, esses validadores recebem uma recompensa por isso. Este sistema também permite que os delegatários (entidades que gostariam de fornecer segurança, mas talvez não tenham o hardware necessário) possam delegar seus tokens aos validadores.
Esses validadores fornecem poder computacional à rede para computar novos blocos e em troca  recebem recompensas com base na quantidade de blocos ou fragmentos produzidos.
Leia mais sobre os validadores do protocolo NEAR aqui: https://near.org/about/network/validators/



	

	
	
		
			
				A Prova de Stake funciona igual à Prova de Trabalho
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





2. Recompensas e NEAR Tokenomics
NEAR é o token usado para cobrir todas as taxas do protocolo NEAR.
Nos seus tokenomics está indicado um lançamento gradual de tokens  num período de 5 anos.

Conforme mencionado no documento, 5% do suprimento adicional é emitido a cada ano para apoiar a rede como recompensas do período, dos quais 90% vão para os validadores (4,5% no total) e 10% para o tesouro do protocolo (0,5% no total).
Recursos extrasz
- Post oficial da NEAR Foundation: https://near.org/blog/near-token-supply-and-distribution/
- Tópico feito por NEARWEEK sobre staking líquido: https://twitter.com/NEARWEEK/status/1618257119958175747



	

	
	
		
			
				Qual é a quantidade de tokens $NEAR distribuídos por ano para os validadores e delegadores?
			
		

		
					

		
			
			
			
			~45 milhões de tokens $ NEAR
		
			
			~12.5 milhões de tokens $ NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






O que é staking líquido? Entendendo o Meta Pool e o recurso stNEAR
Os protocolos de staking líquido estão na vanguarda da economia de staking em criptomoedas, revolucionando o acesso à liquidez na indústria de finanças descentralizadas (DeFi).

Staking líquido é uma alternativa ao staking tradicional: permite que os usuários façam o stake de qualquer quantidade de NEARs e retire efetivamente seus $NEAR sem a necessidade de esperar 48-72 hrs (4-6 períodos) antes que os detentores de tokens NEAR recebam suas recompensas compostas.

Um dos benefícios do staking líquido é a capacidade de interagir e usar fundos ao mesmo tempo em que ganha recompensas. Como resultado, os protocolos de staking líquidos fornecem as bases para atividades como protocolos de empréstimos e atividades de Yield Farming.

Portanto, os usuários podem interagir com várias plataformas DeFi ganhando várias recompensas de um pool de fundos.

 	
Critérios de seleção de validadores
A Meta Pool segue a estratégia da NEAR Foundation para propagar a participação entre a longa fila de validadores não concentrados de alto desempenho, baixa comissão, a fim de aumentar a descentralização e a resistência à censura para a NEAR.

Avaliamos todos os validadores, em nosso produto principal não temos whitelists, e publicamos a fórmula, o código que usamos para computar a fórmula e também os resultados que estarão on-chain. O propósito ético é ser totalmente transparente e aberto a todos os validadores.

Temos 5 critérios para selecionar validadores na rede NEAR, que estão alinhados com a nossa ética de transparência e equidade:

 	Tempo de atividade > 95%
 	Honorários < 10%
 	Assegurar que o validador não reduz o Coeficiente Nakamoto.
 	Ter tokens suficientes para cumprir o preço de admissão do protocolo NEAR.
 	Produção de recompensas durante pelo menos 4 períodos consecutivos .Você pode revisar a lista de validadores do Meta Pool aqui, você só precisa inserir meta-pool.near no filtro da conta.




	

	
	
		
			
				O staking líquido na Meta Pool suporta a descentralização da rede?
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	
Passo a Passo: Fazendo meu primeiro stake líquido na Meta Pool.


O Meta Pool permite que os detentores de tokens NEAR façam stake e ganhem recompensas, fornecendo uma maneira fácil de se retirar do stake sem período de bloqueio.

Ele não coloca todo o seu staked NEAR em apenas um validador, em vez disso, o Meta Pool o distribui entre muitos validadores de alto desempenho e baixa taxa para que você obtenha as melhores recompensas, e ao mesmo tempo, garanta que a rede seja descentralizada e resistente à censura.

 	Faça Login na Meta Pool, clicando no “Start staking” (Começar staking).



2. Clique em “stake now” (Stake agora) na casa “Stake NEAR”.

3. Escolha sua carteira preferida, para este exemplo, usaremos a carteira nativa do NEAR.

4. Selecione a carteira NEAR que deseja usar no menu suspenso e permita que o aplicativo tenha acesso à sua carteira NEAR: clique em “Authorizing” (Autorizar)

.

5. Depois de fazer login, vá para a página inicial e insira o valor do stake que deseja fazer e clique em “Stake”.

Nota: você sempre deve deixar alguma quantidade de NEAR em sua carteira para cobrir os custos de transação.

Observe que a mínima quantidade de nears que você pode começar a fazer staking é 1 $ NEAR.

Você receberá a confirmação depois que a transação tenha sido processada pela blockchain e o depósito do seu stake também tenha sido bem-sucedido. Isso geralmente tarda apenas alguns segundos.

6. Agora você pode encontrar seus acervos de contas nas páginas Home e Harvest.

Nota: Este painel exibe apenas os ativos ($NEAR e stNEAR) de sua carteira, se você transferir ou vender seus tokens stNEAR, eles não serão mais exibidos neste painel.

No painel, você pode ver as estatísticas atuais do Meta Pool:


 	Passo-a-Passo: Sacando seus tokens NEAR do stake.

Existem 2 opções para desfazer o stake na Meta Pool: você pode fazer  uma Liquid Unstake (unstake imediato) ou fazer uma Traditional Unstake (tempo de espera de 48-72 horas).
Liquid Unstake.
Você pode fazer um unstake imediato do seu token stNEAR pagando uma pequena taxa e usando o recurso Liquid Unstake. Fazendo isso, você está realmente trocando seu token stNEAR por NEAR. Isso é possível graças ao pool de liquidez da Meta Pool.

 	Para fazer um Liquid Unstake simplesmente:1.  Vá para a opção Unstake no menu de navegação.
 	Revise a taxa atual do Liquid Unstake e decida se deseja prosseguir.
 	Digite a quantidade de stNEAR que você deseja retirar.
 	Clique em 'Liquid Unstake' e aprove a transação.
 	Depois de alguns segundos, após sua transação ter sido confirmada pela blockchain, você terá o NEAR que estava em stake disponível em sua carteira NEAR.


Nota: A taxa de liquidez do Meta Pool varia de 0,3% a 3%. Varia linearmente de acordo com a quantidade de liquidez disponível no Meta Pool Liquidity Pool.




	

	
	
		
			
				O preço da stNEAR é de 1:1 com o token NEAR.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Unstake Tradicional (Demorado)

O unstake tradicional é a forma padrão de fazer unstake de qualquer validador no protocolo NEAR: devido ao design da rede, os validadores esperam de 4 a 6 períodos (48 a 72 horas) antes de liberar os fundos em stake de volta ao usuário. A desativação demorada é gratuita para todos os usuários.

Para sacar seus fundos da Meta Pool usando Delayed Unstake:

1. Vá para a opção 'Delayed-Unstake' no menu de navegação na parte superior.
2. Insira a quantidade de NEAR que deseja retirar e clique no botão 'Start Delayed Unstake'.

3. Você verá um aviso informando os tempos aproximados de espera. Revise e confirme.

4. Será requerida a sua autorização para a transação na carteira NEAR. Clique em Autorizar.

5. Após o período atrasado de retirada, os fundos estarão disponíveis para saque, clique em “withdraw” e confirme sua transação, seu NEAR “unstaked” aparecerá em sua carteira NEAR.




	

	
	
		
			
				O Delayed Unstake afeta o desempenho da rede devido ao tempo extra necessário para remover os tokens $NEAR delegados
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






6. Passo a passo: Ser provedor de liquidez

Liquid Unstaking só é possível graças aos Provedores de Liquidez (LP) que abastecem o protocolo com o NEAR necessário para swaps instantâneos (saques) com stNEAR. Os Provedores de Liquidez recebem taxas de Unstaking Líquido.

Para depositar ou sacar $ NEAR como provedor de liquidez:

1. Vá para a guia Liquidez na Meta Pool page.
2. Selecione se deseja “Adicionar” ou “Retirar” liquidez.
3. Insira a quantidade de $NEAR para adicionar ou retirar.

Nota: O mínimo requerido para fornecer liquidez é de 2 $NEAR.

4. Confirme e aprove a transação.

Agora, toda vez que alguém fizer um unstake líquido, você receberá uma fração das taxas de acordo com seu patrimônio no pool de liquidez.




	

	
	
		
			
				~10.8% APY é o padrão em qualquer momento quando se é um provedor de liquidez
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!

### O que é Pikespeak

Construído sobre o protocolo NEAR, Pikespeak é uma solução de data e análise de dados que se oferece a instituições, projetos Web3 e particulares:

 	visualizações e painéis dos casos de uso Web3 mais fundamentais; DeFi, DAOs, jogos, NFTs, etc.
 	um poderoso indexador e API que cobre mais de 50 pontos de saída de dados.
 	RPC (chamada de procedimento remoto) dedicado e indexador.
 	Pontos de dados personalizados e entendimento.

A solução já atraiu mais de 400 usuários iniciais e é usada por projetos de primeira linha dentro do ecossistema – incluindo Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader e Learn NEAR Club.




	

	
	
		
			
				Quem ainda não está usando o Pikespeak?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			O presidente dos Estados Unidos
		
			
			Tonic DEX
		
			
			Learn NEAR Club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Por que?
Porque a blockchain (cadeia de blocos) não está projetada para ferramentas analíticas tradicionais:

 	O acesso a dados utilizáveis pode ser complexo, dificultando a exploração de oportunidades.
 	Extrair dados rapidamente, em escala e ao custo é um desafio fora do comum e requer interpretação com base nos contratos inteligentes implantados.




Em termos simples, o Pikespeak visa:

 	Indexação, armazenamento e transformação de dados on-chain (em cadeia) em tabelas legíveis para seres humanos.
 	Capacitar os usuários com um poder de análises eficaz

Para que?
Depende do problema/pergunta que você precisa resolver/responder. Aqui estão alguns exemplos tangíveis (minucioso):

 	Usuários DeFi

 	Qual é o valor e composição da minha carteira?
 	Qual é o meu P/L (lucro/perda) em um período de tempo específico?
 	O fiscal (ex: imposto de renda) está pedindo registros de minhas negociações e atividade na blockchain do último ano fiscal, como posso fornecer essa informação?
 	Estou interessado em fazer um holding de um token, mas gostaria de entender algumas coisas: qual é o suprimento circulante? Quem está fazendo Holding de token (Lista dos mais ricos)? Como os grandes Holders (proprietários) se comportam? Os tokens foram vendidos recentemente? Há quanto tempo eles estão fazendo Holding do token? etc.
 	Quais foram as maiores transferências de token nas últimas 24h?




 	Empresas de capital de risco

 	Qual é o valor e composição do meu portfólio ?
 	Meu contador está pedindo registros da atividade blockchain da empresa, como posso fornecer essa informação?
 	Quais são os projetos mais ativos?
 	Quantos usuários ativos as empresas do meu portfólio têm?
 	Uma das empresas do portfólio está afirmando que seu produto está tendo uma tração massiva, como posso verificar e contestar essa informação?






	

	
	
		
			
				Usando o Pikespeak, posso: (selecione todas as opções aplicáveis)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Baixar todo o histórico da minha carteira em formato csv?
		
			
			Conferir a atividade e as principais métricas de qualquer contrato inteligente?
		
			
			Analisar as transações históricas dos endereços de Gênesis?
		
			
			rever qualquer preço de token com 100% de precisão?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Proprietários do projeto

 	Estou arrecadando fundos e gostaria de entender o tamanho do mercado endereçável no meu segmento (ex: jogos). Quantos usuários ativos de jogos existem? Quem está liderando no meu segmento? Quais são as quotas de mercado dos projetos concorrentes?
 	Gostaria de enviar incentivo/lançamento a endereços específicos com base em seus portfólios e atividades, posso obter acesso à lista desses endereços?
 	Qual é o TVL (valor total bloqueado) do meu projeto?
 	Por que meu projeto perdeu 20% de seu TVL numa data específica?




 	Líderes de Marketing de Projetos

 	Recentemente, apoiei/liderei uma campanha de marketing. Como isso se traduziu na aquisição de usuários?
 	Gostaria de promover uma colaboração de marketing com outro projeto. Minha base de usuários demonstrou interesse e ou já está interagindo com este projeto? Que tão afins são nossas comunidades?
 	Gostaria de enviar incentivo/lançamento a endereços específicos com base em seus portfólios e atividades, posso obter acesso à lista desses endereços?




 	Líderes de produto do projeto

 	O que é a retenção de usuários?
 	Quais são os recursos mais usados (métodos de chamada)?
 	Um projeto concorrente lançou um novo recurso. Qual foi a recepção da comunidade? Isso se traduziu em aquisição de usuários?
 	Quantos dos meus usuários estão usando aplicativos da concorrência? Quanto eles estão gastando nesses outros aplicativos?




 	Proprietários do Validador

 	Por que meu validador público perdeu 20% de seus delegadores ontem?
 	Vejo que 1M $ NEAR foi sacado do stake ontem, qual era o endereço por trás do evento de Unstaking (retiro de tokens do stake)?
 	Quantos delegadores eu tenho em comparação com os validadores concorrentes?
 	Quantas recompensas meu nó acumulou desde o início?




 	Proprietários de uma DAO

 	Qual é o capital da DAO?
 	Quantos membros da DAO votaram na última proposta?
 	Um dos membros da minha DAO está envolvido com outras DAOs? Sendo assim, quais são?
 	Quantos pagamentos a minha DAO liquidou no último ano? Qual foi o valor total?




 	Gestor do Fundo de Tesouraria do Ecossistema

 	Quantas subvenções foram concedidas no último ano? Por qual valor total?
 	Quão bem está o desempenho de meus beneficiários relacionados a minha Dapp nos seguintes critérios: número de transações, usuários ativos, gestão de tesouraria?
 	Como outros fundos do ecossistema têm alocado fundos recentemente? Quais são os projetos apoiados?




 	Reguladores e/ou Investigadores de conformidade AML/KYC

 	Qual é a relação entre este endereço e outro?
 	Este endereço esteve envolvido em um hack (corte), qual foi a(s) exchange(s) usada(s) para sacar?
 	Qual foi/foram a(s) exchange(s) usadas para financiar este endereço malicioso?
 	Alguns hacks têm o mesmo modus operandi (modo de operação), mas foram gerados por endereços diferentes, eles estão conectados de alguma forma?
 	Quais são todas as interações/gráficas da camada 1 de um endereço específico?




 	Engenheiros Blockchain

 	Uma transação específica falhou, posso verificar a falha nos recibos da transação para entender o que aconteceu?
 	Qual foi o custo do gás dessa transação específica?






	

	
	
		
			
				O Pikespeak pode ser útil para: (selecione todos os que se aplicam)
			
		

		
					

		
			Please select 3 correct answers
			
			
			VCs e Instituições expostas ao Protocolo NEAR?
		
			
			Fábrica de Pizzas com sede em Nápoles?
		
			
			Construção de Projetos e DApps na NEAR
		
			
			Simples usuário DeFi ou NEAR?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Os Dados são ótimos, as histórias são melhores
O custo para acessar dados on-data é marginal em comparação com mercados tradicionais e privados, como bolsas de valores e insights (predições) de clientes (ex: painéis) para um setor específico. Isso cria uma oportunidade única para o surgimento de jornalistas, investigadores ou qualquer tipo de jornalismo cidadão em ascensão.A qualidade e a cobertura do desastre do FTX no Twitter foram uma ótima ilustração dessa tendência.

Além do mais, o modelo  NEARWEEK Report-to-Earn (reporte para ganhar) é uma forma inovadora de incentivar o jornalismo cidadão e levar as pessoas a participar do processo de criação de conteúdo de notícias.

Abaixo está uma lista de eventos que podem potencialmente levar à histórias interessantes e perspicazes. Gostaríamos de encorajar a comunidade LNC a aproveitar o Pikespeak para contar grandes histórias.

 	23 de junho de 2022 - 39 milhões de tokens $ NEAR foram retirados dos validadores.
 	4, 5 e 6 de março de 2023 – Near Social (social.near) teve um fluxo significativo de novos usuários.
 	8 de março de 2023 – O contrato Multi Sender (multisender.app.near) (envio de múltiplas transferências em uma transação simples) enviou US$ 1,13 milhões para múltiplos endereços, sua maior transação desde a criação.

Contato

Para mais informações entre em contato com:

Didier Pironi

Email: didier@pikespeak.ai

Data: 09/03/2023

Pikespeak.ai

### NEAR Protocol e Solana

Hoje vamos ver duas das plataformas de contratos inteligentes mais promissoras do mundo – NEAR Protocol e Solana. Embora o Ethereum ainda domine esse mercado, o fato é que sua falta de escalabilidade e altas taxas forçaram a maioria dos desenvolvedores a procurar alternativas viáveis. Near e Solana emergiram como os dois primeiros colocados.
O que é Solana?
A solana foi fundada em 2017 por Anatoly Yakovenko, que já havia trabalhado na DropBox. Yakovenko, junto com Eric Williams e CTO Greg Fritzgerald, criou Solana para resolver os problemas existentes em Bitcoin e Ethereum. O projeto atraiu investimentos da Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures e muito mais.

Características da blockchain Solana

 	50.000 transações por segundo e tempo de criação de bloco de 0,4 segundos
 	O sistema pode fornecer 28,4 milhões de transações por segundo em uma rede de 40 gigabits.
 	Solana usa o algoritmo de consenso Proof-of-History.

Como funciona a Prova de Histórico (PoH)?
Em uma rede descentralizada que se espalha por uma grande área, o consenso é essencial. O Bitcoin usa o consenso de prova de trabalho (PoW - Proof of Work) para cuidar do consenso. Embora o método seja altamente seguro, é difícil não ignorar seu problema mais significativo – a falta de escalabilidade. Não se esqueça que o Bitcoin só pode fazer 7 transações por segundo.

Solana usa prova de história (PoH - Proof of History), em que cria registros históricos para provar que um evento ocorre durante um momento específico no tempo. Aqui estão alguns pontos que você precisa ter em mente:

 	O algoritmo usa uma função de atraso verificável de alta frequência que requer um certo número de etapas sequenciais para terminar.
 	As transações ou eventos cronometrados na rede serão designados como uma contagem única de hash a, que pode ser verificada publicamente.
 	A contagem permite que a rede saiba exatamente quando a transação ou o evento aconteceu.
 	Cada nó possui um relógio criptográfico que ajuda a rastrear o tempo da rede e a ordem dos eventos.

Devido ao PoH, a rede Solana suporta 50.000 transações por segundo durante a execução com GPUs.
O que é um Cluster Solana?
Um cluster é um conjunto de computadores de propriedade independente trabalhando juntos e pode ser visto como um sistema singular. As principais características do Cluster são as seguintes:

 	Eles ajudam a verificar a saída de programas não confiáveis ​​enviados pelo usuário.
 	Mantém um registro de qualquer transação ou evento que um usuário faz.
 	Ele rastreia quais computadores fizeram um trabalho significativo para manter a rede funcionando.
 	Ele rastreia a posse de ativos do mundo real.




	

	
	
		
			
				Qual dos seguintes utiliza sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			Ambos
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Programação em Solana
Os contratos inteligentes em Solana são escritos em Rust ou C e compilados para bytecode Berkeley Packet Filter (BPF). Como existem mais ferramentas disponíveis, é recomendável que você codifique em Rust. Iniciantes devem codificar seus programas usando o framework Anchor, que simplifica a execução.

Solana tem um modelo de conta exclusivo que é semelhante aos arquivos do sistema operacional Linux. Eles podem conter quaisquer dados arbitrários e também conter metadados sobre como podem ser acessados. Tenha em mente, porém, que as contas têm um tamanho fixo e não podem ser redimensionadas.

O modelo de programação atual da Solana pode forçá-lo a mover a lógica do aplicativo para fora da cadeia ou modificar a funcionalidade para ser ineficiente e limitada pelo tamanho fixo da conta.




	

	
	
		
			
				Qual das opções a seguir é parte integrante de Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Coletivo
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Exemplo de contrato
#![feature(proc_macro_hygiene)]
use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};
#[program]
pub mod plutocratic_hosting {
    use super::*;
    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {
        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;
        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())
    }
    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
            // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;
        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;
        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;
        Ok(())
    }
}
#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}
#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}
impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}
#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}
fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }
    Ok(())
}
#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,

}
O que está acontecendo no contrato?

 	Todas as contas a serem acessadas são anotadas na estrutura para cada chamada com #[derive(Accounts)].
 	As funções ajudam a inicializar os dados da conta do proprietário inicial e da Compra. Isso permite que qualquer pessoa compre por mais tokens.
 	Os dados temporários são passados ​​para os parâmetros da função. Esses parâmetros estão dentro das funções de inicialização e compra. Isso também inclui o Contexto que mantém as contas necessárias para a transação.
 	O estado do contrato está localizado na estrutura ContentRecord. Isso é anotado com #[account] para indicar que representa o layout de dados de uma conta.

O que é NEAR Protocol?
Entrando em vigor no verão de 2018, o protocolo foi projetado para criar o ambiente perfeito para aplicativos descentralizados, fornecendo velocidades mais altas, maior rendimento e melhor compatibilidade com outras blockchains. A NEAR possui uma técnica única de Sharding e apresenta um mecanismo de geração de blocos chamado “Doomslug” proposto em 2019. Doomslug permite finalidade prática ou “Doomslug”, garantindo que os blocos sejam finalizados em segundos.

O protocolo NEAR é desenvolvido pelo NEAR Collective, uma comunidade de desenvolvedores e pesquisadores que colaboram na construção do projeto. Alguns recursos importantes da NEAR são:

 	NEAR é um sistema fragmentado que permite escalabilidade infinita.
 	Um protocolo fácil de usar, a NEAR permite que os desenvolvedores criem aplicativos com facilidade e rapidez.
 	NEAR não é uma rede secundária (side chain), mas um protocolo de camada 1.
 	Os dApps criados usando a NEAR são executados no topo da camada NEAR subjacente.

O que é o coletivo NEAR (NEAR Collective)?
O Coletivo NEAR inclui organizações individuais e outros colaboradores que trabalham continuamente para melhorar o Protocolo NEAR. O Coletivo trabalha em projetos como escrever o código inicial e implementação para a Rede NEAR. A NEAR é totalmente descentralizada, operando de forma independente e não pode ser desligada ou manipulada, mesmo por quem a construiu.

É uma organização sem fins lucrativos focada na criação de um ecossistema vibrante em torno da blockchain NEAR. Auxilia na coordenação das atividades de governança e desenvolvimento. O NEAR Collective tem vários projetos, sendo a NEAR blockchain apenas um dos vários projetos sob o teto do Coletivo.
Mecanismo de Consenso NEAR
O mecanismo de consenso implementado no NEAR é chamado de Nightshade. Nightshade modela o sistema como uma única blockchain. A lista de todas as transações em cada bloco é dividida em blocos físicos, um bloco por fragmento. Todos os pedaços (chunks) se acumulam em um bloco. Observe que os chunks só podem ser validados por nós que mantêm o estado desse shard.

Falando em validação, um componente chave de NEAR são os validadores. Esses validadores são responsáveis ​​por manter o consenso dentro do protocolo. Os validadores são nós especializados que precisam manter seus servidores online 100% do tempo, mantendo seus sistemas continuamente atualizados.

Aqui estão alguns pontos que você deve ter em mente sobre os validadores de rede.

 	A NEAR determina seus validadores de rede a cada nova época, elegendo-os com base em sua participação.
 	Os validadores já eleitos são reinscritos por meio de uma nova aposta automática de seus tokens mais as recompensas acumuladas.
 	Os validadores potenciais devem ter sua participação acima de um nível determinado dinamicamente.
 	Existem dois métodos que um validador pode usar para fortalecer seu staking – comprar os tokens por conta própria ou pedir emprestado por delegação de participação.
 	A recompensa que você recebe é diretamente proporcional à sua aposta - quanto maior a quantidade de tokens em staking, mais recompensas.

O consenso é baseado no consenso da cadeia mais pesada. Ou seja, uma vez que um produtor de bloco publica um bloco, ele coleta as assinaturas dos nós validadores. O peso de um bloco é então a aposta cumulativa de todos os signatários cujas assinaturas estão incluídas no bloco. O peso de uma cadeia é a soma dos pesos dos blocos. Além disso, o consenso utiliza um dispositivo de finalidade que introduz condições de corte adicionais para maior segurança da cadeia.




	

	
	
		
			
				Doomslug” é um mecanismo de geração de blocos de qual protocolo?
			
		

		
					

		
			
			
			
			NEAR Protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora e NEAR Protocol
A Aurora também foi lançada no NEAR Protocol, fornecendo uma Experiência da camada 2 Ethereum. Algumas das maneiras pelas quais a Aurora melhora a NEAR são:

 	Ele ajuda a aumentar a taxa de transferência para milhares de transações por segundo.
 	Um tempo de finalização de bloco de 2 segundos.
 	Crescimento do ecossistema à prova de futuro
 	Baixas taxas de transação, que são 1000 vezes mais baixas que o Ethereum.
 	Compatibilidade intransigente com Ethereum.

Exemplo de Contrato
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};
#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}
impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}
#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }
    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );
            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }
        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }
    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);
        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}
O que está acontecendo no contrato?
Então, o que está acontecendo aqui no contrato? Vamos olhar mais de perto.

 	O contrato é definido por #[near_bindgen] no ContentTracker, é semelhante a um construtor no Solidity e é chamado quando o contrato é implantado.
 	A função de compra é anotada com #[payable].
 	O contrato inclui chamadas assíncronas na forma de Promise::new(…).transfer(…); lines.
 	A estrutura de dados LookupMap<String, ContentRecord> lida com a pesquisa de valor-chave, que acessa o armazenamento. Isso é igual ao  “mapping” do Solidity.

Conclusão
Tanto Solana quanto NEAR Protocol são contratos inteligente brilhantes,  plataformas que construíram comunidades altamente ativas. Ambos trazem recursos especiais que ajudam a combater o maior problema que assola o mundo descentralizado – a velocidade. Ambas as plataformas ainda estão crescendo e são muito promissoras.

### NEAR 🤝 Ethereum (PT)

Hoje, a plataforma do Ethereum é a número um de contratos inteligentes no espaço criptográfico, com a maioria dos contratos inteligentes e aplicativos descentralizados (dApps) baseados nessa blockchain. Como o Ethereum, também existem no mercado, várias outras plataformas de contratos inteligentes.

Porém, só porque a plataforma do Ethereum é a número um quando se trata de contratos inteligentes e DeFi, não significa que não tenha problemas. Ela  tem um problema flagrante, que se referem a questões significativas de escalabilidade. Ela simplesmente não consegue escalar sua rede.

E é aqui que o Protocolo NEAR entra em cena. A USP (proposta única de venda) da NEAR  usa um mecanismo de consenso Proof-of-Stake ( Prova de participação) que utiliza sharding (fragmentação). Antes de profundizar, vamos conhecer o Ethereum e o NEAR.
O que é o Ethereum?
Se você olhar para a definição do Ethereum em seu site, é como segue:

"Ethereum" é uma tecnologia que abriga dinheiro digital, pagamentos globais e aplicativos. A comunidade construiu uma economia digital em expansão, novas formas ousadas para que os criadores ganhassem online e muito mais. É aberto a todos, onde quer que você esteja no mundo”.

Fundada em 2015 por Vitalik Buterin, o Ethereum se estabeleceu firmemente como a segunda maior criptomoeda por capitalização de mercado, perdendo apenas com a Bitcoin. O Ethereum se baseia na blockchain do Bitcoin, tornando-a mais do que apenas outra criptomoeda que permite aos usuários enviar ou receber valor sem nenhuma intervenção de terceiros.

O Ethereum garante a descentralização substituindo os servidores centrais por milhares de nós, garantindo que a plataforma esteja sempre online e livre de qualquer influência de terceiros. Os contratos inteligentes também são parte integrante do ecossistema do Ethereum, e como a plataforma suporta aplicativos descentralizados e esses contratos inteligentes, é excepcionalmente atraente para desenvolvedores e usuários.

O Ethereum agora está se movendo para o Ethereum 2.0 ou Serenity. A atualização melhorará significativamente a escalabilidade, eficiência e velocidade da blockchain do Ethereum. Além disso, a atualização permitirá que o Ethereum reduza os custos de gás e processe mais transações, melhorando a escalabilidade da blockchain sem comprometer a segurança.

A atualização também fará com que o Ethereum  mude para Proof-of-Stake (prova de participação) como mecanismo de consenso. O PoS verá validadores que foram escolhidos algoritmicamente para fornecer segurança à plataforma. Os validadores protegerão a plataforma bloqueando seu ETH. Qualquer validador que atue contra o interesse da plataforma terá sua participação cortada, garantindo a segurança da plataforma.
O que é o Protocolo NEAR ?
O Protocolo NEAR  surgiu no verão de 2018. Uma plataforma de desenvolvimento descentralizada. O protocolo foi projetado para criar o ambiente perfeito para aplicativos descentralizados com foco nas deficiências de outras plataformas, no contrato inteligente e no espaço dApp. Essas deficiências são principalmente problemas de baixas velocidades, baixo rendimento e baixa compatibilidade com outras blockchains.

A NEAR opera no topo do Protocolo NEAR, uma blockchain Proof-of-Stake (PoS), incorporando vários recursos e inovações para reduzir custos e melhorar a escalabilidade para usuários e desenvolvedores. Além disso, o NEAR adota uma abordagem única para o sharding (fragmentação).

Ele também apresenta um mecanismo de geração de blocos chamado “Doomslug” que foi proposto em 2019. Doomslug permite finalidade prática ou finalidade “Doomslug”, garantindo que os blocos recebam finalização em segundos.

O protocolo é baseado na mesma tecnologia do Bitcoin, combinando-o com recursos como sharding de banco de dados. O protocolo NEAR foi criado do zero e é a rede mais acessível para usuários finais e desenvolvedores, além de garantir escalabilidade e segurança.

A maioria das blockchains escaláveis ​​centraliza o processamento, limitando-a aos hardware de ponta, o que fornece um aumento temporário em sua taxa de transferência. O NEAR permite que a plataforma seja dimensionada liNEARmente, até milhares de transações de maneira totalmente descentralizada.

O NEAR é desenvolvido pelo coletivo NEAR, uma comunidade de desenvolvedores e pesquisadores que colaboram na construção do projeto. Algumas características importantes da NEAR são:

 	A NEAR é um sistema fragmentado que permite escalabilidade infinita.
 	Um protocolo fácil de usar, o NEAR permite que os desenvolvedores criem aplicativos com facilidade e rapidez.
 	A NEAR não é uma cadeia lateral, mas um protocolo de layer-1  (camada 1).
 	As dApps criadas usando o NEAR são executadas no topo da camada NEAR subjacente.

O que é o Coletivo NEAR?
O Coletivo NEAR compreende organizações individuais e outros colaboradores que trabalham continuamente para melhorar o protocolo NEAR. O Coletivo trabalha em projetos como escrever o código inicial e a implementação para a rede NEAR. O NEAR é totalmente descentralizado, operando de forma independente e não pode ser desligado ou manipulado, mesmo por quem a construiu.

O Coletivo NEAR  tem membros como a Fundação NEAR. A Fundação NEAR é uma organização sem fins lucrativos focada na criação de um ecossistema vibrante em torno da blockchain NEAR. Auxilia na coordenação das atividades de governança e desenvolvimento. O Coletivo NEAR tem vários projetos, sendo a blockchain NEAR  apenas um dos vários projetos sob o amparo do coletivo.
Por que as blockchains como NEAR são necessárias?
Para entender isso, devemos primeiro entender a evolução da tecnologia blockchain. A blockchain pode ser dividida em três estágios ou gerações. As blockchains de primeira geração foram projetadas para serem um mecanismo de pagamento simples. O Bitcoin é um exemplo de uma blockchain de primeira geração que se estabeleceu firmemente no espaço criptográfico como a plataforma número um. No entanto, as blockchains de primeira geração têm limitações quando se trata de transações complexas.
  As plataformas blockchain de segunda geração vieram à tona com o Ethereum e o conceito de contratos inteligentes, permitindo que os desenvolvedores os usassem e programassem transações mais sofisticadas e criando dApps. Mas as blockchains de segunda geração sofrem de graves problemas de escalabilidade. Por exemplo, o Ethereum pode processar apenas cerca de 25 transações por segundo, compare esse número com as plataformas convencionais como Visa ou PayPal, e você poderá ver o quanto o Ethereum está ficando para trás.
O Ethereum tentou corrigir seus problemas de escalabilidade implementando soluções de camada 2, como o protocolo plasma, criando uma camada adicional que é executada em conjunto com a cadeia principal. No entanto, as soluções da Camada 2 ainda não ganharam força suficiente.
 Isso nos leva ao NEAR, com uma blockchain de terceira geração. O NEAR descarta a ideia de que cada nó da rede precisa executar todo o código, pois a equipe acredita que tudo o que ela faz é criar gargalos. Em vez disso, a blockchain corrige problemas de escalabilidade utilizando uma técnica de sharding, permitindo que a blockchain aumente a capacidade da rede. E, ao contrário das blockchains de segunda geração que usam uma solução de Camada 2, o sharding é uma solução de camada-1.

 O que é Sharding (Fragmentação)?
Antes de prosseguirmos, vamos entender o sharding. Às vezes, os sistemas precisam lidar com muitos dados. Isso afeta o desempenho do sistema, reduzindo o rendimento. O sharding supera isso particionando os dados horizontalmente, tornando-os menores, gerenciáveis ​​e, mais importante, mais rápidos de processar.
O NEAR e o Ethereum: Como funciona o NEAR e o Ethereum?
Ethereum
O Ethereum funciona mais do que apenas uma plataforma financeira que realiza transações; ele também oferece suporte para aplicativos descentralizados e contratos inteligentes, o Ethereum é baseado na tecnologia blockchain e usa um livro público onde todas as transações verificadas são armazenadas. As transações são acessíveis para qualquer pessoa que quiser visualizá-las, garantindo total transparência e assegurando que os dados armazenados na blockchain não possam ser alterados ou manipulados.
A blockchain do Ethereum é semelhante à blockchain do bitcoin e atua como um livro público que mantém um registro de todas as transações e o histórico dos contratos inteligentes. Voluntários em todo o mundo armazenam uma cópia de toda a blockchain do Ethereum, tornando a blockchain completamente descentralizada. Cada vez que uma ação como uma transação ou contrato inteligente ocorre na sua blockchain, todos os nós do mundo a processam, garantindo que as regras da blockchain sejam seguidas.

Todos os nós estão conectados e seguem o mesmo conjunto de regras em relação a contratos e transações inteligentes. Os nós do Ethereum também acompanham o estado de todos os aplicativos, saldos do usuário e o código do contrato inteligente, garantindo que todas as informações estejam sempre atualizadas.

Graças ao Solidity, os desenvolvedores podem escrever contratos inteligentes que podem gerenciar transações na blockchain e seus resultados. Os contratos inteligentes diferem dos contratos tradicionais, pois garantem que os termos do contrato sejam cumpridos. Além disso, eles executam transações automaticamente quando um conjunto de condições predeterminadas é cumprido, eliminando todos os terceiros envolvidos em qualquer transação.
NEAR
O NEAR usa a tecnologia blockchain, assim como outras blockchains como Ethereum e Cardano. O NEAR atua como uma blockchain básica sobre a qual os aplicativos podem ser construídos e implantados. Ele usa um mecanismo de consenso conhecido como Nightshade, que o ajuda a atingir seu alto rendimento. O mecanismo de consenso do NEAR assume que as transações de todos os shards se combinam para formar um bloco, e é por isso que cada shard envia um segmento de cada bloco. Este segmento é chamado de chunk.

Os validadores são escolhidos aleatoriamente e processam transações em várias cadeias de shard, melhorando a capacidade de transação do protocolo NEAR. Os chunks (pedaços) são processados ​​e armazenados na blockchain, finalizando as transações.

O NEAR não é executado com base na ideia de que cada nó precisa processar o código inteiro. Em vez disso, ele aborda problemas de escalabilidade usando o sharding. Por meio do sharding, os dados são particionados horizontalmente, fazendo que o gerenciamento seja mais fácil e o processamento mais rápido.
A NEAR e o Ethereum: Mecanismo de Consenso
Ethereum
Atualmente, o Ethereum usa um mecanismo de consenso Proof-of-Work (prova de trabalho), mas com o Ethereum 2.0 no horizonte, a plataforma mudará para um mecanismo de consenso Proof-of-Stake, que será implementado com o protocolo Casper, criando um ecossistema Trustless (sem confiança). Antes de mudar completamente para o mecanismo de Proof-of-Stake, o Ethereum implementará um mecanismo híbrido de consenso PoW-PoS.

Vamos entender como ambos Proof-of-Work e Proof-of-Stake funcionam. Proof-of-Work , exige que os mineradores compitam entre si utilizando grandes quantidades de poder computacional para resolver problemas matemáticos complexos ao validar as transações. Depois que uma transação é validada, o minerador é recompensado. O Ethereum está mudando para um mecanismo de Proof-of-Stake porque o Proof-of-Work tem vários problemas, como por exemplo o alto consumo de energia. A mudança também está sendo feita para resolver os problemas de escalabilidade do Ethereum.

Em um mecanismo de consenso Proof-of-Stake, os validadores (poseedores) bloqueiam seus ETH, após serem selecionados aleatoriamente para atestar um bloco. O validador selecionado propõe um bloco, enquanto os outros validadores precisam confirmar que o viram. Depois de autenticá-lo, ele é adicionado à  blockchain e os validadores são premiados. Assim, os validadores são gratificados ​​tanto por propor quanto por atestar a existência do bloco.
NEAR
O NEAR Protocol implementou o Nightshade Sharding  como seu mecanismo de consenso Proof-of-Stake. Já discutimos o que é sharding, então podemos pular isso. Contudo, o método de sharding em uso na atualidade tem seus problemas, como a regra de escolha da bifurcação nas cadeias de shard e beacon que precisa ser construída e testada de forma diferente.

No entanto, o Nightshade trata o sistema como uma única blockchain e cada bloco contém transações para todos os shards. De qualquer maneira, os participantes não precisam baixar o estado completo, mantendo apenas o estado que faz parte do shard para o qual estão validando as transações. Uma lista de todas as transações em cada bloco é criada, que é então dividida em chunks, cada shard sendo atribuído a outro shard.

Os validadores são uma parte fundamental do protocolo NEAR, mantendo o consenso sobre o protocolo. Portanto, eles precisam manter seus sistemas sempre atualizados e, ao mesmo tempo, manter seus servidores online.

 	Os validadores são selecionados a cada época com base em seu stake.
 	Os validadores podem ser inscritos novamente fazendo um re-staking de seus tokens e recompensas.
 	Os validadores podem fortalecer seu stake de duas maneiras: comprar um token ou obtê-lo emprestado por meio de uma delegação de stake.

NEAR e Ethereum: os Tokens
O token nativo do Ethereum, o Ether, incentiva os programadores a continuar executando o protocolo da blockchain, já que o hardware que alimenta o Ethereum é caro e consome uma quantidade significativa de energía. Desse modo, mineradores e programadores são recompensados com o Ether por utilizar seus recursos e manter o ecossistema do Ethereum seguro e funcionando.

Os desenvolvedores também usam o Ether para pagar, e assim poder lançar contratos inteligentes ou aplicativos descentralizados na blockchain do Ethereum. Também é usado para acessar contratos inteligentes.

O token nativo do NEAR, o NEAR, é usado para incentivar validadores na rede. O token também impulsiona transações e contratos inteligentes na blockchain. Como o NEAR é uma plataforma governada pela comunidade, os detentores de tokens desempenham um papel significativo na governança da plataforma, votando em possíveis mudanças em sua plataforma.
Projetos no Ethereum e no Protocolo NEAR.
O Ethereum é o líder quando se trata de aplicativos descentralizados e finanças descentralizadas, com mais de 3.000 dApps funcionando em sua blockchain. A maioria dos projetos do Ethereum se concentra em DeFi, expandindo os usos de criptomoedas para atender a usos financeiros mais complexos.

Alguns dos principais projetos na blockchain do Ethereum são:

 	Uniswap.
 	MakerDAO.
 	Chainlink.
 	Aave.

Embora a rede principal do NEAR tenha sido lançada há pouco mais de um ano, várias plataformas estão sendo construídas sobre ela. Alguns dos projetos no protocolo NEAR são:

 	Mintbase –Uma plataforma dedicada a simplificar a emissão e venda de NFTs, além diminuir o custo do processo todo.
 	Flux – Flux é um protocolo de mercado aberto, descentralizado. Foi lançado no protocolo NEAR em 2020.
 	Paras –Paras é um mercado NFT com foco em obras criadas por artistas selecionados.

O NEAR Grants Program (Programas de subvenções), atualmente operado pela Fundação NEAR, apoia projetos que permitem o crescimento do ecossistema NEAR.
Aurora no Protocolo NEAR
A rede Aurora também foi lançada no protocolo NEAR, fornecendo uma experiência “Ethereum Layer-2” Uma solução que permite aos desenvolvedores alcançar mercados adicionais, A Aurora aproveita os recursos do protocolo NEAR, como remuneração de taxa de gás e sharding. Ela é executada em dois componentes críticos, A Bridge (ponte) Aurora e o Engine (motor) Aurora.

Algumas das melhorias que a Aurora traz são:

 	A capacidade de processar milhares de transações por segundo, um aumento de 50 vezes em relação ao Ethereum.
 	Um tempo de finalização de bloco de 2 segundos, em comparação com o tempo de confirmação de bloco único de 13 segundos no Ethereum. A finalização rápida também reduz os ataques de tipo frontrunning.
 	Crescimento do ecossistema à prova de futuro, a abordagem de sharding do protocolo NEAR permite dimensionamento EVM horizontal e comunicação assíncrona entre vários shards.
 	As taxas na Aurora são 1000 vezes menores do que as do Ethereum. Para dar um exemplo, transferir um token ERC-20 na Aurora custa menos de US$ 0,01, enquanto no Ethereum custa cerca de US$ 5,40.
 	Aurora oferece total compatibilidade com o Ethereum ao longo do Protocolo NEAR.

A Aurora fornece uma solução para os desafios enfrentados pelo ecossistema Ethereum, preservando os contratos inteligentes e o código front-end.
Vantagens do Protocolo NEAR.
A solução sharded do NEAR oferece uma enorme vantagem sobre plataformas como o Ethereum e o Bitcoin, resolvendo o problema de baixa escalabilidade e gargalos frequentes na rede Ethereum. Ao fazer seu protocolo fragmentado, os fundadores do NEAR dividem o código da blockchain em “chucks” executados em nós paralelos. Isso resulta em todo o código processado rapidamente e liberando o NEAR de problemas de escalabilidade, graças a essa capacidade de fragmentar o código.

O protocolo NEAR possui vários recursos exclusivos que o tornam uma proposta atraente para usuários e validadores.

 	Um UX flexível e acesso a serviços executados na plataforma NEAR também apresentam um processo de integração fácil.
 	Devido ao protocolo fragmentado da NEAR, os validadores podem ingressar na plataforma sem fazer download de software complexo. Eles podem ganhar tokens validando transações na rede.
 	O NEAR permite que as empresas personalizem as permissões para seus usuários. Com o crescimento constante do mercado, os desenvolvedores também obtêm acesso a uma base crescente de clientes.

O caminho à frente para o Protocolo NEAR

Com o lançamento da ponte Ethereum-NEAR, também chamada de Rainbow Bridge, os usuários podem conectar o seus tokens Ethereum ERC-20 ao NEAR e começar a usá-los no ecossistema de aplicativos descentralizados do NEAR. Este desenvolvimento é um grande passo em direção à visão da equipe fundadora de tornar a plataforma o mais acessível possível.

O NEAR também está trabalhando na implementação do suporte Ethereum Virtual Machine (EVM). Depois que esse processo for concluído, os desenvolvedores poderão reimplantar seus dApps no NEAR com alterações mínimas e habilitar lançamentos entre cadeias.

O Protocolo NEAR anunciou uma parceria com a Chainlink, juntamente com o lançamento da Rainbow Bridge permitindo a interação do NEAR e do Ethereum.
Conclusão:
O protocolo NEAR mostrou-se muito promissor, utilizando sharding para resolver problemas de escalabilidade de blockchains de segunda geração, além disso, o NEAR aumenta significativamente o rendimento sem comprometer a segurança da plataforma.

Graças ao coletivo NEAR, centenas de engenheiros e desenvolvedores de blockchain estão trabalhando sem descanso para melhorar o protocolo. O NEAR também lançou sua rede principal, e ela está pronta para suportar dApps e outros serviços. Com foco em garantir que a plataforma NEAR seja fácil de usar para validadores, usuários finais e desenvolvedores, o NEAR emergiu como uma força no espaço da plataforma de contratos inteligentes.

O Ethereum, por outro lado, manteve sua posição no trono graças à sua invejável comunidade de desenvolvedores e aos prósperos ecossistemas DeFi e NFT. Os dois protocolos fornecem uma brilhante plataforma para os desenvolvedores construírem o ecossistema descentralizado do futuro.

### O que é o NDC: NEAR Digital Collective

O Coletivo Digital Near ou NEAR Digital Collective (NDC) é um projeto ambicioso que reúne usuários, projetos, partes interessadas e parceiros do ecossistema NEAR para criar uma maneira radicalmente nova de se governar.

Ao criar uma estrutura que permite que qualquer membro da rede opine sobre como o protocolo NEAR é executado, o objetivo do NDC é combinar transparência, tomada de decisão coletiva, modelos de governança em evolução e autodeterminação de uma maneira completamente nova.

O NDC planeja fazer isso ajudando a criar a Constituição do NEAR Protocol, um documento unificador que consagra as ideias de autogoverno e descentralização no cerne de como o ecossistema NEAR funciona.

Por que isso é importante?
O ecossistema NEAR é composto por mais de 1.000 projetos, centros regionais, nós de financiamento, provedores de infraestrutura e mais de 20 milhões de carteiras. Isso é muita gente. O NDC foi criado para ajudar todos os envolvidos a desempenhar um papel ativo na evolução da NEAR.

Seja como o financiamento é alocado, como as eleições acontecem ou quem representa o mosaico de interesses que compõem esse ecossistema diversificado e próspero. O NDC quer ajudar todos a terem voz e que essas vozes sejam gravadas na cadeia.
Como ele faz isso?
O NDC está ajudando a desenvolver um sistema de governança. Uma vez em vigor, permitirá que as pessoas votem em uma ampla variedade de questões, elejam membros para diferentes conselhos administrativos e até mesmo façam emendas à própria constituição.

A essência do NDC dá vida a essa estrutura radical e permite que a comunidade se envolva e participe ativamente da formação do futuro da NEAR.

Em seu estágio atual, o NDC está trabalhando em uma estrutura de governança que inclui as seguintes seções:

 	Corpo de votação – Esta é toda conta próxima ativa, conforme qualificado pela estrutura de governança


 	Casa de Mérito – Um grupo de membros experientes da comunidade indicados por membros do ecossistema para representá-los durante votações e decisões importantes.
 	Conselho de Conselheiros – Conselheiros nomeados para ajudar a moldar a direção da Casa de Mérito.
 	Comissão de Transparência – membros da comunidade designados para garantir freios e contrapesos, estão em vigor e são mantidos.
 	Tesouro Comunitário – Membros da Câmara de Mérito com o apoio do Conselho de Assessores ajudam a facilitar a votação sobre como os fundos comunitários são alocados.

Você pode encontrar mais informações sobre isso acima aqui.

Este é um trabalho em andamento e atualmente é supervisionado pelo Grupo de Trabalho de Governança, ou GWG. Esta é uma coleção de membros da comunidade trabalhando para refinar os modelos de governança que ajudarão todos a se expressarem.

O Coletivo e o GWG convidam todos a compartilhar e discutir ideias. Todos os detalhes sobre como fazer isso pode ser encontrado aqui.
Qual é o escopo do NDC?
Embora a constituição e os modelos de governança sejam fundamentais, o NDC também ajudará a moldar, definir e entregar o seguinte:

 	Constituição da NEAR.
 	Criar e implementar tomadas de decisão on-chain locais e globais.
 	Criar e implantar um repositório de diários, logs e minutos on-chain locais e globais.
 	Estabelecer órgãos governamentais, suas operações, poderes e quais verificações e contrapesos cada um precisa.
 	Criar e manter um tesouro comunitário com um conjunto completo de procedimentos operacionais e salvaguardas.
 	Criar e manter Diretrizes Comunitárias, Código de Conduta e protocolos de Resolução de Disputas.
 	Criar e implementar uma estratégia de comunicação para garantir que o trabalho realizado pelo NDC e GWG seja de fácil acesso.
 	Uma estratégia para ajudar a comunidade a encontrar, acessar e usar o NDC.
 	Ajudar a desenvolver e implantar um modelo de governança DAO
 	Facilitar o crescimento do ecossistema NEAR de forma mais ampla.

Qual é o papel da NEAR Foundation no NDC?
A Fundação é parceira e colaboradora do NDC. Ela apóia o trabalho que está sendo realizado pelo Coletivo e, em última instância, buscará entregar seu papel de financiador à comunidade quando estiver pronto para fazê-lo.
Quem está trabalhando no NEAR Digital Collective?
O Coletivo é formado por membros do ecossistema NEAR. Alguns são ex-membros da Fundação, outros são fundadores de projetos e outros ainda são usuários e apoiadores de longo prazo da blockchain e dos projetos que são construídos sobre ela.

Sinta-se à vontade para entrar em contato com qualquer um dos líderes da equipe.
Por que a descentralização é importante?
Descentralização é um termo que se tornou sinônimo de blockchain, mas tem suas origens desde a Revolução Francesa no século XVIII.

A descentralização então é o processo pelo qual as atividades de uma organização, particularmente aquelas relacionadas ao planejamento e tomada de decisão, são distribuídas ou delegadas de um local ou grupo central e autoritário.

Isso é importante porque, como qualquer estudante de história lhe dirá, quando o poder se torna excessivamente centralizado, a oportunidade de abuso aumenta. Em 2022, membros da comunidade blockchain experimentaram em primeira mão o que acontece quando autoridades centralizadas abusam de seu poder.

Os membros da Comunidade NEAR acreditam que o objetivo da descentralização é melhorar o que veio antes. Acredita que o aumento da transparência e da democracia cria uma comunidade justa e mais igualitária para todos.

Mas chegar lá requer um compromisso com um processo. Um processo que deverá evoluir e adaptar-se às necessidades da comunidade, e que esta participe na sua conformação.

A descentralização é vital para a saúde e a sustentabilidade a longo prazo de qualquer conjunto de pessoas e ideias. O NDC é como a comunidade NEAR está tentando conseguir isso.
Como faço para me envolver?
Qualquer membro da comunidade NEAR é livre para ingressar em qualquer um dos seguintes grupos de trabalho:.

 	Constituição
 	Governança e Governança de Tecnologia
 	Jurídico
 	Envolvimento da comunidade
 	Comunicações

Comece pelo processo de integração ao Grupo de Trabalho de Governança (GWG).

Ou se você está procurando se aprofundar como tudo isso funciona, você pode ver a Página de visão geral.
Siga o NDC

 	Twitter
 	Discord

### Por que os DAOs devem migrar para executar um Private Shard?

Introdução às DAOs e contratos multi-sig
A maioria dos usuários do Web3 está muito familiarizada com os termos DAOs e contratos Multi-sig (assinatura múltipla), mas para pessoas não familiarizadas com o espaço Web3, acredito que vale a pena entender melhor ambos os termos.
O que é uma DAO
Uma Organização Autônoma Descentralizada” (DAO) é uma entidade liderada pela comunidade sem autoridade central. É totalmente autônoma e transparente. Os contratos inteligentes são usados para governar a tomada de decisões e a propriedade distribuída de ativos. O processo de votação para DAOs é publicado em uma blockchain e os usuários geralmente devem selecionar entre opções mutuais e exclusivas. O poder de voto geralmente é distribuído entre os usuários com base no peso do voto que eles têm dentro da DAO (valor da quantidade de Tokens que possuem, um membro – um voto e outros).. Todos os votos e atividades por meio da DAO são postados em uma blockchain, tornando todas as ações dos usuários, publicamente visíveis.
Para tomar decisões para as DAOs, eles tiram proveito de uma carteira multi-sig (contrato).
O que é a carteira multi-sig?
A carteira multi-sig é um tipo especial de contrato criptográfico para armazenar criptomoedas com segurança. Ela requer duas ou mais chaves privadas (membro da DAO) para assinar e enviar uma transação e é frequentemente usada para adicionar uma camada extra de segurança às transações de carteira (wallet), garantindo que vários detentores de chaves estejam envolvidos na aprovação da transação.
Os contratos multi-sig também podem ser configurados para permitir que cada um, no conjunto de chaves privadas, gere uma assinatura, tornando-os uma ótima opção para quem deseja armazenar sua criptomoeda de maneira segura e Trustless. (sem necessidade de confiar)
Como as DAOs estão, atualmente, aproveitando os contratos multi-sig?
As DAOs estão usando multi-sig para armazenar seus fundos com segurança e gerenciá-los com eficiência. Os contratos multi-sig fornecem, a vários Stakeholders (poseedores de tokens), a capacidade de assinar uma transação, permitindo uma gestão segura e diversificada de fundos e decisões. As multi-sigs também fornecem uma camada adicional de segurança, exigindo várias chaves privadas para acessar os fundos.

Além disso, as DAOs podem usar contratos multi-sig para implementar um sistema de votação e governança que é mais complexo do que o contrato multi-sig habitual. Isso permite que a tomada de decisões seja descentralizada e segura.
As  estruturas de votaçao DAO mais comuns, são: votação de quórum ponderado por token, a votação quadrática, a democracia líquida ou delegação de voto ou bloqueio de voto e a votação de quórum baseada em token.

 	Votação de quórum ponderado por tokenRequer uma certa porcentagem de eleitores para que uma proposta seja aprovada. Por exemplo: quórum de 60%, significaria, que no mínimo, 60% dos detentores de tokens devem votar a favor de uma proposta para que ela seja aprovada.


 	1 token = 1 voto de governança

O poder de voto de um indivíduo é diretamente proporcional ao número de fichas que ele possui.

 	Voto Quadrático

É um sistema que equilibra os interesses dos grupos minoritários enquanto ainda mantém um processo de decisão majoritário. Democracia líquida ou delegação de votos. Ele permite que as pessoas deleguem seu voto a um representante.

Bloqueio de votos

É um mecanismo que permite que os participantes saiam de uma votação sem penalidade.

 	Votação de quórum baseada em tokenum sistema que exige que um determinado limite de tokens seja mantido pelos eleitores para que uma proposta seja aprovada.

Principais desafios que as DAOs enfrentam
Os principais problemas que as DAOs enfrentam, incluem a falta de status legal reconhecido e potencial responsabilidade ilimitada dos membros, falta de regulamentação e medidas de segurança inadequadas. Além disso, as DAOs podem ser vulneráveis a ataques de governança, má configuração e spam. Esses problemas podem criar uma série de riscos, incluindo proteções inadequadas para dados pessoais, contratos inteligentes vulneráveis e acesso não autorizado a fundos.
A maioria dos problemas técnicos mencionados acima podem ser resolvidos e o restante mitigado usando um Shard privado, mas primeiro devemos desvendar o que é um Shard privado.




	

	
	
		
			
				Quais são algumas das implementações de votos que podem ser usadas com uma Shard privada nas DAOs?
			
		

		
					

		
			
			
			
			1 token = 1 vote governance
		
			
			Quadratic voting
		
			
			Token-weighted quorum voting
		
			
			Todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Shards Privados para DAOs: uma carteira multi-sig com esteróides

Um Private Shard ou Shard privado, é uma sidechain personalizável (uma rede blockchain operando ao lado da blockchain pública com capacidade de transferir ativos e executar chamadas de contratos cruzados) que permite que você proteja seus dados enquanto aproveita todos os benefícios comerciais de blockchains de código aberto. Ele permite que proprietários de Shard Privado obtenham controle total sobre sua blockchain, mantendo privada suas informações entre eles e permitindo que apenas certas partes públicas acessem essas informações.

Os membros dessa DAO obtêm uma rede administrada por eles mesmos com base em suas necessidades. Pode ser personalizada para as estruturas de votação propostas acima mencionadas, onde os validadores (nós validando os blocos da blockchain) são propriedade dos membros da DAO semelhante a como dentro de uma multi-sig, eles teriam uma chave privada com um certo poder de voto. Pense nisso como uma “multi-sig com esteróides”, já que todas as propriedades básicas multi-sig são as mesmas, obtendo os benefícios de todas as informações sendo armazenadas únicamente dentro do shard privado sem ser vazadas para o público.
Além do mais, os membros da DAO podem implantar contratos inteligentes personalizados dentro do Shard com “escalabilidade infinita” proporcionando-lhes a capacidade de ter:

 	Votação privada.
 	Folha de pagamento de contabilidade e contratante.
 	Implemento de mecânicas para alto volume de transações, como leilões (que podem ser muito caros na Mainnet).
 	Departamentos de gestão de tesouraria dentro da DAO e muito mais.




	

	
	
		
			
				Um Shard privado é:
			
		

		
					

		
			
			
			
			Uma base de código Web2 privada armazenada em um ecossistema Sharded fechado.
		
			
			Uma sidechain personalizável privada (uma rede blockchain operando ao lado da blockchain pública com capacidade de transferir ativos e executar chamadas de contrato cruzado).
		
			
			Uma DAO aberta armazenada diretamente na blockchain de NEAR, uma  Sharded que usa validadores NEAR.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






O Bride ( a ponte) para Shard privados tem um contrato de permissão que suporta definir regras sobre quais contratos/contas, públicos e privados, podem interagir e até que ponto. Isso proporciona a capacidade de limitar o acesso a determinadas partes ou contratos para mover ativos de e para os shards privados, além de fornecer acesso a determinados contratos inteligentes para executar chamadas de contrato do shard ou da rede principal.
Por exemplo: Uma DAO pode ter um contrato de votação privado dentro do shard que inicia uma chamada quando a votação termina e que apenas o resultado da votação seja publicado na Mainnet sem revelar os votos específicos dos membros. Esta chamada só pode ser executada desde dentro desse shard e nenhuma outra parte pode publicá-la, exceto este contrato específico. Isso permite que os membros da DAO possam garantir a segurança do voto como fariam usando um multi-sig, enquanto os votos são ocultados do público.




	

	
	
		
			
				Os Shard privados permitem que as DAOs tenham:
			
		

		
					

		
			
			
			
			Votação privada
		
			
			Folha de pagamento de contabilidade e contratante
		
			
			Implementação de mecanismos para alto volume de transações, como leilões
		
			
			Todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Além disso, o Calimero Gateway fornece gerenciamento de permissões adicionais para os membros da DAO para especificar políticas nas quais usuários/carteiras públicas podem interagir com o Shard Privado.Enquanto os membros da DAO executam os validadores e têm acesso de administrador ao shard, eles podem convidar membros/carteiras externas para poder ler determinados dados ou interagir com determinados contratos.

Por exemplo: Uma DAO pode ter um contrato privado dentro do shard para que partes externas enviem propostas nas quais a DAO possa votar. Isso pode permitir que somente os remetentes e membros da DAO possam ver as informações sobre o status de suas propostas. O envio da proposta pode ser limitado a uma lista de permissões de carteiras adicionadas pela DAO ou ao público em geral.

Acreditamos que os Shards Privados são a próxima evolução natural das DAOs e estão procurando trabalhar com mais DAOs nesta próxima transformação a ocorrer na Web3. Sinta-se a vontade para nos contatar se tiver alguma dúvida ou se quiser agendar uma demonstração.

### ¿Qué es Pikespeak?

¿Qué es Pikespeak?
Tweet +4nLEARNs

Basado en NEAR Protocol, Pikespeak es una solución de datos y análisis que ofrece a instituciones, proyectos Web3 e individuos:

 	visualizaciones y tableros de los casos de uso más fundamentales de Web3; DeFi, DAO, Juegos, NFT, etc.
 	un poderoso indexador y API que cubre más de 50 puntos finales de datos
 	RPC dedicado e indexador
 	Información y puntos de datos personalizados

La solución ya ha atraído a más de 400 usuarios iniciales y la utilizan proyectos de primer nivel dentro del ecosistema - incluidos Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader y Learn NEAR Club.


¿Por qué?
Porque la cadena de bloques no está diseñada para herramientas de análisis tradicionales:

 	Acceder a datos utilizables puede ser complejo, lo que dificulta la exploración de oportunidades
 	La extracción de datos rápidamente, a escala y con costo no es un desafío complejo y requiere una interpretación basada en los contratos inteligentes implementados.




En términos simples, Pikespeak tiene como objetivo:

 	Indexación, almacenamiento y transformación de datos en cadena en tablas legibles por humanos
 	Otorgar a los usuarios potentes análisis

¿Para qué?
Eso depende del problema/pregunta que necesites resolver/responder. Aquí hay algunos ejemplos tangibles (no son todos los ejemplos, y podrían existir más):

 	Usuarios de DeFi

 	¿Cuál es el valor y el desglose de mi cartera?
 	¿Cuál es mi P/L durante un período de tiempo específico?
 	El recaudador de impuestos (p. ej., IRS) solicita registros de mis operaciones y actividad de blockchain durante el último año fiscal, ¿cómo puedo proporcionar esa información?
 	Estoy interesado en tener unos tokens, pero me gustaría entender algunas cosas; ¿Cuál es el suministro circulante? ¿Quién tiene el token (lista detallada)? ¿Cómo se comportan los grandes poseedores? ¿Han estado vendiendo recientemente? ¿Cuánto tiempo han estado poseyendo el token? Etc.
 	¿Cuáles fueron las transferencias de tokens más grandes en las últimas 24 horas?




 	Sociedades de Capital de Riesgo

 	¿Cuál es el valor y el desglose de mi cartera?
 	Mi contador solicita registros de la actividad de blockchain de la empresa, ¿cómo puedo proporcionar esa información?
 	¿Cuáles son los proyectos más activos?
 	¿Cuántos usuarios activos tienen las empresas de mi cartera?
 	Una de las empresas de cartera afirma que su producto está teniendo una tracción masiva, ¿cómo puedo verificar y cuestionar esta información?






	

	
	
		
			
				Usando Pikespeak yo puedo (selecciona todas las qué apliquen):
			
		

		
					

		
			Please select 3 correct answers
			
			
			¿Descargar todo el historial de mi billetera en formato csv?
		
			
			¿Consultar la actividad y las métricas importantes de cualquier contrato inteligente?
		
			
			¿Analizar las transacciones históricas de las direcciones de Génesis?
		
			
			¿Predecir cualquier precio de token con un 100 % de precisión?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Propietarios de proyectos

 	Estoy recaudando fondos y me gustaría comprender el tamaño del mercado en mi segmento (por ejemplo, juegos), ¿cuántos usuarios activos de juegos hay? ¿Quién lidera en mi segmento? ¿Cuáles son las cuotas de mercado de los proyectos competidores?
 	Me gustaría incentivar/hacer airdrops a direcciones específicas en función de su cartera y actividad, ¿puedo obtener acceso a la lista de esas direcciones?
 	¿Cuál es el TVL de mi proyecto?
 	¿Por qué mi proyecto perdió el 20 % de su TVL en esta fecha específica?




 	Líderes de marketing de proyectos

 	Recientemente apoyé/lideré una campaña de marketing, ¿cómo se tradujo en la adquisición de usuarios?
 	Me gustaría impulsar una colaboración de marketing con otro proyecto, ¿mi base de usuarios ha demostrado interés/ya está interactuando con este proyecto? ¿Qué tan cerca están nuestras comunidades?
 	Me gustaría incentivar/hacer airdrops a direcciones específicas en función de su cartera y actividad, ¿puedo obtener acceso a la lista de esas direcciones?




 	Líderes de producto del proyecto

 	¿Cuál es la retención de usuarios?
 	¿Cuáles son las funciones más utilizadas (métodos de llamada)?
 	Un proyecto de la competencia ha lanzado una nueva función, ¿qué tan bien ha sido recibida por la comunidad? ¿Se tradujo en adquisición de usuarios?
 	¿Cuántos de mis usuarios utilizan aplicaciones de la competencia? ¿Cuánto están gastando en esas otras aplicaciones?




 	Propietarios de Validadores

 	¿Por qué mi validador público perdió el 20 % de sus delegadores ayer?
 	Veo que 1M $NEAR no se stakearon ayer, ¿cuál fue la dirección detrás del evento de no participación?
 	¿Cuántos delegadores tengo en comparación con los validadores de la competencia?
 	¿Cuántas recompensas ha acumulado mi nodo desde el inicio?




 	Propietarios de DAOs

 	¿Qué es la tesorería de la DAO?
 	¿Cuántos miembros de la DAO han votado por la última propuesta?
 	¿Alguno de los miembros de mi DAO está involucrado con otras DAO? Si es así, ¿cuáles son?
 	¿Cuántos pagos ha liquidado mi DAO en el último año? ¿Cuál es la cantidad total?




 	Administrador de la Tesorería del Fondo del Ecosistema

 	¿Cuántos grants se han concedido en el último año? ¿Por qué cantidad total?
 	¿Qué tan bien se están desempeñando mis beneficiarios relacionados con dapp en los siguientes criterios? número de transacciones, usuarios activos, gestión de tesorería?
 	¿Cómo otros fondos de ecosistemas han estado asignando fondos recientemente? ¿Cuáles son los proyectos que se han apoyado?




 	Reguladores y/o investigadores de cumplimiento AML/KYC

 	¿Cuál es la relación entre esta dirección y otra?
 	Esta dirección ha estado involucrada en un hackeo, ¿cuáles fueron los exchanges utilizados para cobrar?
 	¿Cuáles fueron los exchanges utilizados para financiar esta dirección maliciosa?
 	Algunos hacks tienen el mismo modus operandi pero fueron generados por diferentes direcciones, ¿están conectados de alguna manera?
 	¿Cuáles son todas las interacciones/gráfico de capa 1 de una dirección específica?




 	Ingenieros blockchain

 	Una transacción específica falló, ¿puedo verificar el desglose de los recibos de la transacción para comprender qué sucedió?
 	¿Cuál fue el costo del gas de esta transacción específica?






	

	
	
		
			
				¿Puede Pikespeak ser útil para: (seleccione todas las que correspondan)
			
		

		
					

		
			Please select 3 correct answers
			
			
			¿VC e Instituciones expuestas al Protocolo NEAR?
		
			
			¿Pizzero con sede en Naples?
		
			
			¿Proyectos y Dapps basados en NEAR?
		
			
			¿Usuario simple de DeFi o de la blockchain NEAR?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Los datos son geniales, las historias son mejores
El costo de acceder a los datos en la cadena de bloques es marginal en comparación con los mercados tradicionales y privados, como las bolsas de valores y los conocimientos de los clientes (por ejemplo, paneles) para una industria específica. Eso crea una oportunidad única para que surjan periodistas, investigadores o cualquier tipo de periodismo ciudadano. La calidad y cobertura del desastre de FTX en Twitter fue un gran ejemplo de esa tendencia.

Además, el modelo NEARWEEK Reportes-para-ganar es un modelo innovador de incentivar el periodismo ciudadano y alentar a las personas a participar en el proceso de creación de contenido de noticias.

A continuación se muestra una lista de eventos que podrían generar historias interesantes y perspicaces. Nos gustaría alentar a la comunidad de LNC a aprovechar Pikespeak para contar grandes historias.

 	23 de junio de 2022: 39 millones de tokens $NEAR se retiraron de los validadores
 	4, 5 y 6 de marzo de 2023: Near Social (social.near) ha tenido una afluencia significativa de nuevos usuarios
 	8 de marzo de 2023: el contrato Multi Sender (multisender.app.near) (sirve para envíar múltiples transferencias en una sola transacción) envió $1.13 millones a múltiples direcciones, su transacción más grande desde su creación

Contacto 

Para más información, contacta a:

Didier Pironi

Correo Electrónico: didier@pikespeak.ai

Fecha: 09/03/2023

Pikespeak.ai

### ¿Por qué las DAO deberían migrar a la ejecución de Fragmento Privado

Introducción a las DAOs y a los contratos multi-sig
La mayoría de los usuarios de la Web3 están familiarizados con los términos DAO (Organizaciones Autónomas Descentralizadas, en español) y contratos Multi-Sig (Multi-firmas), pero para las personas que no están acostumbradas con el espacio Web3, creo que vale la pena desglosar ambos términos.
¿Qué es una DAO?
Una “Organización Autónoma Descentralizada“  (DAO) en sus siglas en inglés, es una entidad dirigida por la comunidad sin autoridad central. Es completamente autónoma y transparente: los contratos inteligentes son usados para regular la toma de decisiones y para la distribución de la propiedad de activos. El proceso de votación para las DAOs se publica en una blockchain, y a menudo, los usuarios deben seleccionar entre opciones mutuamente excluyentes. El poder de votación se distribuye en la mayoría de los casos entre los usuarios en función del peso de voto que tienen dentro de la DAO (el peso del número de tokens que tienen, un miembro- un voto y otros). Todos los votos y actividades a través de la DAO son publicadas en la blockchain, haciendo que todas las acciones de los usuarios sean visibles públicamente.
Para tomar decisiones por la DAO, se están aprovechando las billeteras (contratos) multisig.

¿Qué es una billetera multisig?
Las billeteras Multisig (Multifirma) es un tipo de contrato criptográfico para almacenar de manera segura las criptomonedas. Requiere de dos o más llaves privadas (miembros de la DAO) para firmar y enviar una transacción, a menudo es usada para añadir una capa extra de seguridad a las transacciones de la billetera, asegurando que múltiples titulares de las llaves, estén involucrados en la aprobación de la transacción.

Los contratos Multisig también pueden ser configurados para permitir que cada uno genere una firma en el conjunto de llaves privadas, lo que lo hace una excelente opción para aquellos que están buscando almacenar sus criptomonedas de una manera segura.
¿Cómo están aprovechando actualmente las DAOs a los contratos multi-sig?
Las DAOs están usando los contratos multisig para almacenar sus fondos de forma segura y para manejarlos de manera eficiente. Estos brindan a las partes interesadas la capacidad de firmar una transacción, permitiendo un manejo seguro y diversificado de los fondos y de las tomas de decisiones. Los contratos Multisigs también proporcionan una capa adicional de seguridad al requerir múltiples llaves privadas para acceder a los fondos.

Adicionalmente, las DAOs pueden usar los contratos multi-sig para implementar la votación y los sistemas de gobernanza que son más complejos que los contratos multisig promedio.

Esto permite que la toma de decisiones sea descentralizada y segura.

Las estructuras de votación más comunes en la DAO son: la votación de quórum ponderado por tokens, la votación cuadrática, la democracia líquida o la delegación de votos o el bloqueo de votos y la votación de quórum basado en los tokens.

 	Votación de quórum ponderado por tokens

Requiere un cierto umbral de votantes para que se apruebe una propuesta. Por ejemplo: 60% del quórum, lo que significa que el 60% de los poseedores de token deben votar a favor de una propuesta para que se apruebe.

 	1 token = 1 voto de gobernanza

El poder de voto de un individuo es directamente proporcional a la cantidad de tokens que posee.

 	Votación cuadrática

Es un sistema que equilibra los intereses de los grupos minoritarios mientras mantiene un proceso de toma de decisiones mayoritario. Democracia líquida o delegación de voto. Permite que las personas deleguen su voto en un representante.

 	
Bloqueo de votos


Es un mecanismo que permite a los participantes salir de una votación sin penalización.

 	
Votación de quórum basado en tokens


Es un sistema que requiere que los votantes tengan un cierto umbral de tokens para que se apruebe una propuesta.
Principales retos a los que se enfrentan las DAOs.
Los problemas principales que enfrentan las DAOs incluyen la falta de un estatus legal reconocido y la responsabilidad ilimitada de sus miembros, falta de regulación y medidas de seguridad inadecuadas. Además, las DAOs pueden ser vulnerables a ataques de gobernanza, mala configuración y spam. Estos problemas pueden crear una serie de riesgos, incluida una protección inadecuada para los datos personales, contratos inteligentes vulnerables y acceso no autorizado a los fondos.

La mayoría de los problemas técnicos mencionados anteriormente se pueden resolver y el resto se puede mitigar usando una fragmento Privado, pero antes, vamos a conocer ¿qué es un fragmento Privado?




	

	
	
		
			
				¿Cuáles son algunas implementaciones de votos que se pueden usar con la fragmentación privada en las DAOs?
			
		

		
					

		
			
			
			
			1 token = 1 voto de gobernanza
		
			
			Votación cuadrática
		
			
			Votación de quórum ponderado por tokens
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Fragmentos Privados para DAOs: una billetera multisig con esteroides. 

Un Fragmento Privado es una cadena lateral personalizable (una red de la blockchain que se ejecuta junto a una blockchain pública con la capacidad de transferir activos y ejecutar llamadas de contratos cruzados) lo que permite proteger tus datos mientras aprovechas todos los beneficios comerciales de las blockchains de código abierto. Esta faculta a los propietarios de los Fragmentos Privados a tener control total sobre su blockchain mientras mantienen información privada entre ellos y solo permite que ciertas partes públicas accedan a esta información.

Los miembros de las DAOs obtienen una red administrada por ellos, basado en sus necesidades. Se puede personalizar con la estructura de votación antes mencionada, donde los validadores (nodos que validan los bloques de la blockchain) le pertenecen a los miembros de la DAO, de manera similar a como dentro de una multisig tendrían una llave privada con cierto poder de voto. Piensa en ello como una “Multisig con esteroides”, ya que todas las propiedades básicas de una multi-sig son las mismas, mientras obtienes el beneficio de que toda la información solo se almacena dentro del fragmento privado y este no se filtra al público.

Encima de eso, los miembros de la DAO tienen la capacidad de desplegar contratos inteligente personalizados dentro del Fragmento con “escalabilidad infinita” lo que les brinda la capacidad de tener:

 	votación privada
 	contabilidad y nómina de contratistas
 	implementar transacciones de mecanismos pesados como las subastas (que pueden ser demasiado costosas en Mainnet)
 	departamentos de gestión de tesorería dentro de la DAO y mucho más.




	

	
	
		
			
				Un fragmento privado es:
			
		

		
					

		
			
			
			
			Una base de código privada de la Web2 almacenada en un ecosistema fragmentado cerrado
		
			
			Una cadena lateral personalizable privada (una red de la blockchain que se ejecuta junto a una blockchain pública con la capacidad de transferir activos y ejecutar llamadas de contratos cruzados)
		
			
			Una DAO abierta almacenada directamente en la blockchain fragmentada de NEAR que utiliza validadores NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






El puente del Fragmento Privado tiene un contrato de permisos que les autoriza establecer las reglas sobre qué contratos/cuentas públicas y privadas pueden interactuar y en qué medida. Esto brinda la capacidad de limitar el acceso a ciertas partes o ciertos contratos para mover activos desde y hacia los fragmentos privados, además de eso, permite el acceso a ciertos contratos inteligentes para ejecutar llamadas de contrato desde el fragmento o la mainnet.

Por ejemplo: Una DAO puede tener un contrato de votación privada dentro del fragmento, el cual inicia una llamada cuando el voto ha finalizado y el resultado de la votación solo se publica en la Mainnet sin revelar los votos específicos de los miembros. Esta llamada puede ser ejecutada solamente desde dentro del fragmento y ninguna otra parte puede publicarla excepto el contrato específico. Esto le da a los miembros de la DAO la capacidad de garantizar la seguridad de los votos como lo harían usando un multisig, mientras que los votos reales están ocultos al público.




	

	
	
		
			
				Los fragmentos privados permiten que las DAOs tengan la capacidad de:
			
		

		
					

		
			
			
			
			Votación Privada
		
			
			Contabilidad y nómina de contratistas
		
			
			Implementar transacciones de mecanismos pesados como las subastas
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Además de lo anterior, Calimero Gateway, brinda permisos de gestión adicionales para que los miembros de la DAO especifiquen políticas en las que los usuarios/billeteras públicas puedan interactuar con el Fragmento Privado. Mientras los miembros de la DAO ejecutan los validadores y tienen accesos administrativos del fragmento, ellos pueden invitar a miembros/billeteras externas a que lean ciertos datos o interactúen con ciertos contratos.

Por ejemplo: Una DAO puede tener un contrato privado dentro del fragmento para que partes externas presenten propuestas sobre las que la DAO puede votar. Esto permite que solo los miembros de la DAO y los remitentes de la propuesta vean la información sobre el estatus de las propuestas. El envío de la propuesta puede limitarse a una lista blanca de billeteras agregadas por la DAO o al público general.

Creemos que el Fragmento Privado es la evolución natural para las DAOs y buscamos trabajar con más DAOs en esta próxima transformación de la  Web3. No dudes en contactarnos si tienes alguna pregunta o deseas agendar una demostración.

### How often do you use NEAR?

How often do you use NEAR?
                         
 
                        How often do you use NEAR?(Required)
			
					
					Every month
			
			
					
					Every week
			
			
					
					Every day
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Cómo stakear NEAR

Stakear en el Ecosistema NEAR, es un nicho próspero que ofrece una variedad de enfoques y soluciones. Echemos un vistazo a las diferentes opciones de staking y pensemos cuál es la mejor opción para ti.

Para facilitar la comparación, calificaremos cada opción en función de tres parámetros: la interfaz de usuario (UI), el rendimiento porcentual anual (APY), tasas de retiro y seguridad.
El Staking Estándar de NEAR
Dado que NEAR opera en un mecanismo de consenso de prueba de participación delegada (DPOS por sus siglas en inglés), cada titular de token NEAR puede delegar sus tokens a un validador específico. Una lista completa de validadores está disponible en https://explorer.shardnet.near.org/nodes/validators. Simplemente, elige un validador que te guste y delega tus tokens en él. El validador recibirá una comisión por esto, que se indica antes de la selección, y tú recibirás una devolución en tokens NEAR. Por lo general, no es más del 9,7% por año.

Puede sonar fácil, pero imagina que acabas de comprar tus primeros tokens NEAR y quieres obtener un rendimiento. Entonces, debes esperar 3 días para retirar tus NEAR del staking y, si deseas retirarlo al instante, deberás pagar una tasa. Aun así, debes confiar en uno de los validadores a los que delegas tus tokens.




	

	
	
		
			
				¿Cuánto tiempo tienes que esperar para retirar tus NEAR del staking estándar?
			
		

		
					

		
			
			
			
			3 días
		
			
			1 día
		
			
			Una semana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El Staking Centralizado de NEAR
Las plataformas de intercambio centralizadas han ideado durante mucho tiempo mecanismos para aumentar aún más sus ganancias a través de herramientas adicionales. Uno de ellos es el staking de tokens dentro del exchange. Al igual que con todos los fondos que almacenas en ellas, en realidad tu no los posees. Lo mismo ocurre con el staking. Aunque las propias exchanges usan sus nodos de blockchain para esto, en esencia, todos tus fondos están con ellos.

Esta solución es perfectamente legítima cuando hablamos de usuarios que no están inmersos activamente en la Web3 y están acostumbrados simplemente a comprar sus monedas favoritas en los diferentes exchanges. Actualmente, más de 1 millón de personas poseen NEAR en Binance. Existe el riesgo de hackeo o robo de sus fondos, como se ha visto con FTX. Además, la rentabilidad en un CEX es mucho menor que en una DeFi – 3% para staking flexible (con retiro instantáneo).




	

	
	
		
			
				¿En qué tipo de staking no posees tus fondos?
			
		

		
					

		
			
			
			
			Meta pool staking
		
			
			HERE staking
		
			
			Staking Centralizado
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Metapool y Linear
Las opciones de staking de Metapool y Linear ya se consideran nativas en el ecosistema NEAR. Para stakear NEAR, deberás tener una billetera NEAR y algunos tokens NEAR. Este tipo de staking es mejor que las otras dos opciones porque está gestionado por proyectos dentro del ecosistema y tiene un APY decente de alrededor del 9,4%, que también es importante. Ambos proyectos han sido auditados por BlockSec y no han tenido ningún problema de seguridad.

Sin embargo, alguien nuevo en el ecosistema deberá encontrar uno de estos proyectos y confiarles sus fondos, y también deberá visitar regularmente el sitio web del proyecto. Igualmente, es importante tener en cuenta que hay una tarifa adicional por retirar NEAR instantáneamente del staking.


Staking en la Billetera HERE
Creo que ya te habrás dado cuenta de quién merece más atención en términos de staking. Dado que HERE es un método de incorporación simple no solo para las criptomonedas sino también para usuarios de Web2, el staking también debería ser sencillo y no causar problemas para alguien que no esté familiarizado con las criptos.

Es por eso que creamos un mecanismo de staking sin bloqueo, donde puedes retirar tus NEAR en cualquier momento sin ningún cargo y aun así recibir ingresos pasivos. Esto es posible gracias a la reserva de liquidez del contrato, al igual que en los bancos regulares cuando se utiliza el 90%, pero siempre hay dinero en el cajero automático. El retorno de la inversión varía según la frecuencia con la que deposites o retires fondos y, en promedio, ronda el 9,8%. Los propietarios de ciertos NFT, como los primeros usuarios de HERE Wallet, también pueden recibir ingresos adicionales.

Además, el proceso de staking en sí es tan simple como puede ser. Todo lo que necesitas hacer es presionar un botón. Después de eso, la cantidad necesaria de NEAR se desbloqueará automáticamente antes de realizar cualquier transacción.

Actualmente, HERE Staking se ha sometido a una auditoría con el equipo de OtterSec.




	

	
	
		
			
				¿Cuál es la tasa por el retiro instantáneo de NEAR desde HERE?
			
		

		
					

		
			
			
			
			1.5%
		
			
			0%
		
			
			3.2%
		
	
		

		
		
			
				Correct!
				Wrong!

### ¿Qué es el colectivo NEAR Digital

El Colectivo Digital NEAR o NDC por sus siglas en inglés, es un proyecto ambicioso que reúne a usuarios, proyectos, partes interesadas y socios del ecosistema NEAR para crear una forma radicalmente nueva de gobernarse a sí mismo.

El NDC, originalmente imaginado por Illia Polosukhin, cofundador de NEAR Protocol, ahora es un movimiento de pleno derecho liderado por la comunidad NEAR. Su objetivo es establecer un modelo de gobernanza y tesorería de la comunidad que permita que el ecosistema tome decisiones colectivamente sobre todo sus aspectos, desde la financiación hasta los representantes electos y más. Es un paso significativo hacia la creación de una red verdaderamente descentralizada.

Al crear un marco que permite que cualquier miembro de la red tenga voz sobre cómo se ejecuta NEAR, el objetivo del NDC es combinar transparencia, toma de decisiones colectiva, modelos de gobernanza en evolución y autodeterminación de una manera completamente nueva.

El NDC planea hacer esto ayudando a crear la Constitución NEAR, un documento unificador que consagra las ideas de autogobierno y descentralización en el núcleo de cómo funciona el ecosistema NEAR.

¿Por qué esto es importante?
El ecosistema NEAR se compone de más de 1000 proyectos, centros regionales, nodos de financiación, proveedores de infraestructura y más de 20 millones de billeteras. Eso es mucha gente. El NDC se estableció para ayudar a todos los involucrados a tomar un papel activo en la evolución de NEAR.

Ya sea en la asignación de fondos, en la forma como se llevan a cabo las elecciones o quién representa el mosaico de intereses que conforman este ecosistema próspero y diverso. El NDC quiere ayudar a que todos tengan una voz y que esas voces queden registradas en la cadena.
¿Cómo lo hace?
El NDC está ayudando a desarrollar un sistema de gobernanza. Una vez en vigor, permitirá a la gente votar sobre una amplia variedad de temas, elegir miembros para diferentes consejos de gobierno e incluso hacer enmiendas a la propia constitución.

La esencia del NDC da vida a este marco radical y permite que la comunidad se involucre y participe activamente en la configuración del futuro de NEAR.

En su etapa actual, el NDC está trabajando en una estructura de gobernanza que incluye las siguientes secciones:

 	Órgano de votación - esto es, cada cuenta Near activa, según lo calificado por el marco de gobierno.
 	Casa de Mérito - un grupo de miembros experimentados de la comunidad designados por miembros del ecosistema para representarlos durante las votaciones y decisiones claves.
 	Consejo de Asesores - asesores designados para ayudar a dar forma a la dirección de la Casa del Mérito.
 	Comisión de Transparencia - miembros de la comunidad designados para garantizar que los controles y equilibrios estén en su lugar y se mantengan.
 	Tesoro Comunitario - Los miembros de la Casa del Mérito con el apoyo del Consejo de Asesores ayudan a facilitar la votación sobre cómo se asignan los fondos comunitarios.

Puede encontrar más información sobre lo anterior aquí.

Este es un trabajo en progreso, y actualmente es supervisado por el Grupo de Trabajo de Gobernanza, o GWG por sus siglas en inglés. Esta es una colección de miembros de la comunidad que trabajan para perfeccionar los modelos de gobierno que ayudarán a todos a expresar su opinión.

El Colectivo y el GWG invitan a cualquiera a compartir y discutir ideas. Todos los detalles sobre cómo hacerlo se pueden encontrar aquí.
¿Cuál es el alcance del NDC?
Si bien los modelos de constitución y gobernanza son clave, el NDC también ayudará a dar forma, definir y entregar lo siguiente:

 	Constitución de NEAR.
 	Crear e implementar la toma de decisiones en cadena local y global.
 	Crear e implementar un repositorio de diarios, registros y actas locales y globales en cadena.
 	Establecer los órganos de gobierno, su funcionamiento, atribuciones, y qué frenos y contrapesos necesita cada uno.
 	Crear y mantener una tesorería comunitaria con un conjunto completo de procedimientos operativos y salvaguardas.
 	Crear y mantener las Directrices de la Comunidad, el Código de Conducta y los Protocolos de Resolución de Disputas.
 	Crear e implementar una estrategia de comunicación para garantizar que el trabajo realizado por el NDC y el GWG sea de fácil acceso.
 	Una estrategia para ayudar a la comunidad a encontrar, acceder y utilizar el NDC.
 	Ayudar a desarrollar e implementar un Modelo de Gobernanza, DAO.
 	Facilitar el crecimiento del ecosistema NEAR de manera más amplia.

¿Qué papel juega la Fundación NEAR en el NDC?
La Fundación es socia y colaboradora del NDC. Apoya el trabajo que lleva a cabo el Colectivo y, en última instancia, buscará transferir su función de financiación a la comunidad una vez que esté lista para hacerlo.
¿Quién está trabajando en el Colectivo Digital de NEAR?
El Colectivo está formado por miembros del ecosistema NEAR. Algunos son exmiembros de la Fundación, otros son fundadores de proyectos y otros todavía son usuarios y partidarios a largo plazo de la blockchain y los proyectos que se basan en ella.

No dude en comunicarse con cualquiera de los líderes del equipo.
¿Por qué es importante la descentralización?
La descentralización es un término que se ha convertido en sinónimo de la blockchain, pero sus orígenes se remontan a la Revolución Francesa en el siglo XVIII.

La descentralización, entonces y ahora, es el proceso mediante el cual las actividades de una organización, en particular las relacionadas con la planificación y la toma de decisiones, se distribuyen o delegan fuera de un lugar o grupo central autorizado.

Esto es importante porque, como lo dirá cualquier estudiante de historia, cuando el poder se vuelve demasiado centralizado, aumenta la oportunidad de abuso. En 2022, los miembros de la comunidad blockchain experimentaron de primera mano lo que sucede cuando las autoridades centralizadas abusan de su poder.

Los miembros de la comunidad NEAR creen que el objetivo de la descentralización es mejorar lo que había antes. Cree que el aumento de la transparencia y la democracia crea una comunidad justa y más igualitaria para todos.

Pero llegar allí requiere un compromiso con un proceso. Un proceso que deberá evolucionar y adaptarse a las necesidades de la comunidad, y que esa comunidad participe en su configuración.

La descentralización es vital para la salud y la sostenibilidad a largo plazo de cualquier conjunto de personas e ideas. El NDC es cómo la comunidad NEAR está tratando de lograr eso.
¿Cómo me involucro?
Cualquier miembro de la comunidad NEAR es libre de unirse a cualquiera de los siguientes grupos de trabajo.

 	Constitución
 	Gobernanza y Gobernanza Tecnológica
 	Legal
 	Participación de la comunidad
 	Comunicaciones

Comience completando el proceso de incorporación del Grupo de Trabajo de Gobernanza (GWG).

O si está buscando una inmersión más profunda en cómo funciona todo esto, puede ver la página de Descripción general.
Seguir el NDC

 	Twitter
 	Discord

### Các dự án trên NEAR được kiểm toán như thế nào?

Hôm nay chúng ta sẽ cùng tìm hiểu một số cách thức mà một đội ngũ chuyên nghiệp áp dụng trong việc kiểm toán(audit) các hợp đồng thông minh triển khai trên blockchain NEAR. Trong bài viết này, chúng ta sẽ chỉ tập trung vào những điểm chính cần lưu ý khi kiểm toán các dự án trên NEAR. Mọi thứ bạn đọc dưới đây đều dựa trên kinh nghiệm cá nhân của đội ngũ Pessimistic!

Trước hết, chúng tôi muốn bày tỏ lòng biết ơn chân thành tới những người đã và đang xây dựng nên NEAR Protocol và các dự án trên hệ sinh thái NEAR, cùng với đó là tất cả những người đã hỗ trợ, soạn thảo các tài liệu nguồn và tất nhiên là các kiểm toán viên xuất sắc, những người đã giúp phát hiện và chia sẻ những thông tin hữu ích về cách kiểm toán một dự án trên NEAR. Và hôm nay, độc giả thân mến, những thông tin này sẽ được cung cấp tới bạn.

Những mẹo mà chúng tôi sắp chia sẻ dưới đây cũng được công khai ở một số nguồn khác, ví dụ như blog của chúng tôi. Đây là những mẹo và thủ thuật được tích lũy dựa trên sự quan sát và kinh nghiệm từ các kiểm toán viên giỏi nhất của chúng tôi, chúng ta hãy cùng bắt đầu thôi nào!

1 phút quảng cáo, nếu như dự án của các bạn cần được kiểm toán, vui lòng gửi yêu cầu tới chúng tôi, bạn có thể theo dõi báo cáo kiểm toán của các dự án mà chúng tôi đã thực hiện tại đây.

 	
Tìm hiểu về blockchain NEAR



 	NEAR là một blockchain layer 1, sử dụng cơ chế đồng thuận Proof of Stake và lưu trữ theo kiến trúc phân đoạn (sharding). Bằng việc áp dụng công nghệ sharding, NEAR cung cấp các giải pháp cho các vấn đề như tốc độ xử lý chậm, tắc nghẽn mạng và phí gas cao, cho phép khả năng mở rộng đáng kể mà không ảnh hưởng đến độ bảo mật của giao thức.
 	Điều quan trọng cần lưu ý là NEAR là một sharded blockchain có thể mở rộng, có nghĩa là các hợp đồng thông minh đã triển khai được biên dịch thành định dạng WebAssembly (WASM) và có thể được viết bằng các ngôn ngữ:

 	Rust
 	AssemblyScript (ngôn ngữ giống với TypeScript có thể biên dịch ra WebAssembly)
 	Solidity (hoạt động trên Aurora EVM)
 	Javascript (hoạt động trên máy ảo Javascript JS-VM)




 	Việc sử dụng WASM giúp tối ưu phí gas, tạo khối nhanh và phí giao dịch thấp hơn. Hợp đồng thông minh trong NEAR có thể được coi là micro-service chứa dữ liệu và mã thực thi. Tương tác giữa các hợp đồng được thực hiện bất đồng bộ.
 	Với tất cả các yếu tố trên, theo quan điểm của chúng tôi, hệ sinh thái NEAR phần lớn được xây dựng dựa trên ngôn ngữ lập trình Rust.
 	NEAR cũng là nền tảng tập hợp hàng ngàn thành viên cộng đồng, mang lại trải nghiệm người dùng thoải mái nhất, cũng như một hệ sinh thái rộng lớn.



 	Một số điểm nổi bật khác của blockchain NEAR:

 	Về vấn đề sản xuất khối một cách bảo mật, NEAR sử dụng cơ chế được gọi là Doomslug. Doomslug thật ra khá đơn giản, cơ chế này dựa trên giả định rằng các trình xác thực khác nhau thay phiên nhau tạo ra các khối dựa trên số lượng token NEAR mà họ đã stake.
 	Chúng tôi sẽ không đi vào chi tiết trong bài viết này vì chúng tôi cho rằng bạn, độc giả thân mến, đã có đủ hiểu biết về hệ sinh thái NEAR, vì vậy chúng tôi thực sự khuyên bạn nên truy cập cơ sở kiến thức của họ và nghiên cứu tài liệu dự án để hiểu rõ hơn: https://near.org/learn/




 	
Quy trình đánh giá một dự án trên NEAR của Pessimistic.io



 	Những trở ngại chính mà kiểm toán viên có thể gặp phải khi thực hiện kiểm toán các dự án trên NEAR là tính logic của mã nguồn, nên lời khuyên đầu tiên của chúng tôi cho bất kỳ nhóm kiểm toán nào là hãy phát triển năng lực chuyên môn, từ đó nắm chắc các tài liệu kỹ thuật và tạo ra các bản thử nghiệm có độ tin cậy cao. Điều này có vẻ khá hiển nhiên, nhưng hãy chắc chắn rằng các bạn có quy trình tốt và đã hoạt động ổn định trong một thời gian nhất định.
 	Sau đây, nhóm kiểm toán xuất sắc của chúng tôi muốn giới thiệu cho bạn bộ quy tắc riêng của mình, được tích lũy qua nhiều năm làm việc, trong đó chúng tôi sẽ cố gắng truyền đạt mọi thứ thật ngắn gọn và súc tích. Cụ thể, chúng tôi thực hiện việc kiểm toán theo các thủ tục sau:


 	
Phân tích tự động:

 	Biên dịch các hợp đồng thông minh
 	Chạy các bộ unit test mà dự án đã dựng sẵn và kiểm tra xem bộ test này có bao quát đầy đủ các trường hợp có thể xảy ra không
 	Chạy các công cụ phân tích và xác minh một cách thủ công (từ chối hoặc xác nhận) từng vấn đề được báo cáo (chi tiết bên dưới)




 	
Kiểm toán thủ công

 	Xem xét cẩn thận mã nguồn và đánh giá chất lượng
 	Kiểm tra xem trong mã nguồn có các lỗ hổng thường gặp không
 	Kiểm tra mã nguồn sau khi được biên dịch có chạy đúng theo logic đã được nêu trong tài liệu của dự án không
 	Đề xuất các giải pháp tối ưu phí gas và phí lưu trữ on-chain




 	
Các vấn đề mà dự án thường gặp

 	Các sự cố liên quan tới việc kiểm soát truy cập tới hợp đồng thông minh (xác định/ủy quyền quản trị viên hoặc người dùng không chính xác);
 	Các vấn đề về tài sản bị mất/bị đánh cắp (tài sản bị mắc kẹt trong hợp đồng hoặc bị gửi tới sai tài khoản);
 	DoS do các vấn đề logic (deadlock, lỗi máy trạng thái, v.v.);
 	DoS do sự cố kỹ thuật (Lỗi hết phí gas, các hạn chế khác);
 	Các vấn đề về tương tác hợp đồng (lỗ hổng reentrancy, gọi hàm không an toàn, giả định của người gọi);
 	Các vấn đề số học (tràn số, làm tròn số);
 	Sử dụng NEAR SDK không hợp lý
 	Các vấn đề khác.




 	
Phí Gas


Chúng tôi kiểm tra xem các hoạt động tương tác với hợp đồng thông minh sử dụng nhiều gas có được thực hiện hiệu quả hay không

 	Các cấu trúc dữ liệu — các cấu trúc dữ liệu từ thư viện std::collections khi được đọc cùng nhau, làm tăng mức tiêu thụ gas. Bạn nên sử dụng near_sdk::collections hoặc near_sdk::store;
 	Các cấu trúc dữ liệu có mối quan hệ trực tiếp với bộ nhớ được lưu trữ trên blockchain và bạn có thể vô tình quên đồng bộ hóa chúng;
 	Các cấu trúc dữ liệu dạng key-value: LookupMap / UnorderedMap / TreeMap — Bạn cần chọn theo chức năng cần thiết (LookupMap có phí gas rẻ nhất, trong khi TreeMap hỗ trợ nhiều tính năng nhất);
 	LazyOption — dành cho “dữ liệu lớn” và hiếm khi được sử dụng (chỉ có thể được sử dụng trong hàm khởi tạo constructor);
 	Borsh/JSON để tuần tự hóa các gói tin được truyền đi hay trả về trên blockchain (tham số/giá trị trả về) — ảnh hưởng đến mức tiêu thụ gas;
 	Hãy tham khảo kỹ Cuộc tấn công “hàng triệu lượt bổ sung dữ liệu giá rẻ” để tránh gặp phải vấn đề tương tự.


 	
Các công cụ


Sau đây là các công cụ phân tích tự động mà bạn có thể sử dụng trong công việc của mình:

 	Valgrind — có thể được sử dụng nếu mã nguồn bao gồm các block không an toàn gây nguy hiểm trong cấp phát bộ nhớ. Tuy nhiên, việc sử dụng các đoạn mã nguồn không an toàn này vốn dĩ đã là dấu hiệu cho thấy dự án có nhiều lỗ hổng. Nói chung, Valgrind không có quá nhiều công dụng
 	Cargo Geiger là một công cụ hiển thị số liệu thống kê về việc sử dụng mã Rust không an toàn trong một thư viện Rust và các đoạn mã phụ thuộc của nó. Công cụ này giúp phát hiện các vấn đề có thể xảy ra do các đoạn mã nguồn nguy hiểm của dự án và từ đó giúp chúng ta tập trung giải quyết các lỗ hổng lớn
 	Cargo Audit — kiểm tra các tệp để tìm thư viện Rust chứa lỗ hổng bảo mật. Công cụ này giúp hiển thị các thư viện đã lâu chưa được cập nhật mà mọi người vẫn sử dụng. Bạn nên sử dụng nó cho mục đích kiểm toán.
 	Trình phân tích tĩnh Clippy là một công cụ tuyệt vời để phát hiện các lỗi cú pháp phổ biến và cải thiện mã nguồn Rust của bạn.
 	Cargo Tarpaulin — dành cho việc kiểm tra độ phủ của test case — một công cụ rất tiện dụng cho biết số lượng code chưa được kiểm thử.


 	
Các bản báo cáo kiểm toán công khai của Pessimistic

 	Các báo cáo kiểm toán công khai của các dự án trên hệ sinh thái NEAR của chúng tôi được cấu trúc theo sơ đồ luồng kiểm toán được trình bày ở trên, vì vậy chúng tôi khuyên bạn hãy xem qua các báo cáo này, đặc biệt là kết quả của chúng, với quy trình được trình bày ở phần trước:

 	Phân tích bảo mật dự án Sweat Economy - Audit bởi Pessimistic
 	Phân tích bảo mật dự án Neartar - Audit bởi Pessimistic

 	Chúng tôi hy vọng rằng bài viết đã cung cấp nhiều thông tin hữu ích cho bạn! Cảm ơn bạn đã đọc! Và đừng quên cho chúng tôi biết chúng tôi nên tham khảo thêm những công cụ nào, bạn quan tâm đến điều gì khi đọc blog của chúng tôi?
 	Nếu bạn vẫn còn thắc mắc, hãy liên hệ! Chúng tôi luôn sẵn lòng trả lời mọi câu hỏi của bạn! Các câu trả lời và câu hỏi hay nhất có thể được đưa vào bài đăng blog tiếp theo!
 	5 phút nữa cho quảng cáo :)), nếu dự án của bạn cần được kiểm toán, hãy liên hệ ngay với chúng tôi! Bạn có thể xem danh sách các dự án được Pessimistic kiểm toán tại đây.

### NEAR Blockchain Explorer

Sau thảm họa FTX khiến hàng tỉ đô la tiền của người dùng bị đánh cắp, việc kiểm soát tài sản của bạn trở nên quan trọng hơn bao giờ hết. Một trong những cách quan trọng nhất để làm điều này là học cách đọc thông tin on-chain được thống kê trên explorer của blockchain.

Với blockchain NEAR, các explorer phổ biến nhất là:

 	NEAR Explorer
 	NearBlocks
 	NearScan

Blockchain Explorer là gì?
Explorer của một blockchain là một phần mềm được sử dụng để trực quan hóa các số liệu khác nhau của blockchain đó như:

 	Hashrate (tỷ lệ băm của các blockchain sử dụng cơ chế đồng thuận PoW)
 	Block size - Kích thước block
 	Block difficulty - Độ khó để tạo block
 	Phí giao dịch trung bình

Sau đây là những tính năng chính mà bạn có thể tương tác với blockchain explorer:

 	Theo dõi trạng thái của một giao dịch đang chờ xử lý trong khi nó đang ở trong mempool.
 	Theo dõi số dư của ví mà không cần phải sử dụng ví. Điều này có thể hữu ích nếu bạn muốn kiểm tra số dư trong ví phần cứng của mình.
 	Theo dõi mọi giao dịch vào và ra khỏi một địa chỉ cụ thể.
 	Xem được các khối “mồ côi” - các khối không được gắn vào chuỗi chính.
 	Khám phá các giao dịch “cá voi” có thể có tác động lớn đến thị trường.
 	Theo dõi địa chỉ của những người có ảnh hưởng trên thị trường tiền mã hóa
 	Theo dõi các đồng tiền mã hóa sau những sự cố như hack, tấn công, …

Blockchain Explorer hoạt động như thế nào?
Blockchain explorer hoạt động dựa trên dữ liệu lấy từ các node của blockchain và sử dụng giao diện lập trình ứng dụng (API) và cơ sở dữ liệu SQL để truy xuất thông tin liên quan từ mạng blockchain bên dưới. Dưới đây là một số điều cần chú ý:

 	Explorer lưu trữ, sắp xếp tất cả thông tin này vào cơ sở dữ liệu và hiển thị dữ liệu ở định dạng có thể tìm kiếm được.
 	Người dùng có thể thực hiện tìm kiếm thông tin được lưu trong các bảng dữ liệu quan hệ đã được tổ chức một cách hợp lý.
 	Tất cả các yêu cầu tìm kiếm được gửi đến máy chủ phụ trợ, nơi sẽ cung cấp các phản hồi ứng với yêu cầu tìm kiếm tương ứng.

Làm cách nào để tôi sử dụng blockchain explorer?
Nhằm giải thích một cách dễ hiểu và trực quan, hãy cùng xem một ví dụ thực tế trên NEAR Explorer dưới đây. Chúng tôi lấy ra một ví dụ hoàn toàn ngẫu nhiên, và dữ liệu hiển thị trên giao diện của explorer như sau:

Chúng ta có thể thấy được một số thông tin sau:

 	Transaction - Giao dịch: Số lượng giao dịch được gửi và nhận. Tài khoản này đã gửi 1.816 giao dịch và không nhận được giao dịch nào.
 	Storage used - Dung lượng đã sử dụng: Tổng dung lượng lưu trữ blockchain được sử dụng bởi tài khoản. Tài khoản này sử dụng 390kB.
 	Native account balance - Số dư tài khoản gốc: Số lượng token NEAR hiện đang được tài khoản nắm giữ. Tài khoản này giữ 81.1916 NEAR.
 	Validator Stake - Phần stake của trình xác thực: Tài khoản này có đang được stake một số lượng NEAR để hỗ trợ xác thực và bảo mật mạng. Tài khoản này đã được stake 23 triệu NEAR.
 	Created At - Thời điểm tạo tài khoản: Tài khoản được tạo vào ngày 15 tháng 2 năm 2022, lúc 4:49:20 sáng.
 	Created by transaction - Giao dịch tạo ra tài khoản này: Giá trị băm của giao dịch chịu trách nhiệm tạo tài khoản này là 4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Khi kéo xuống dưới, bạn sẽ thấy lịch sử giao dịch của tài khoản này.

Kiểm tra trạng thái của giao dịch
Hãy cùng tìm kiếm một hash (mã băm) ngẫu nhiên trên explorer và xem nó trông như thế nào. Ở trong ví dụ này, ta sẽ dùng giá trị băm 2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3.

Đây là một giao dịch điển hình, trong đó một tài khoản gửi một số tiền cho tài khoản khác. Hãy cùng đi qua các chi tiết mà explorer cung cấp cho chúng ta:

 	Signed by - Người gửi: Đây là tài khoản đã ký và gửi giao dịch. Trong trường hợp này, đó là “Sweat_welcome.near.”
 	Receiver - Người nhận: Đây là tài khoản nhận giao dịch – 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Status - Trạng thái: Trạng thái hiện tại của các giao dịch. Giá trị này có thể là Đang chờ xử lý, Đã thành công, Không thành công/Đã hoàn thành hoặc chưa hoàn thành. Trong trường hợp này, giao dịch đã thành công.
 	Transaction fee - Phí giao dịch: Đây là khoản phí cần thiết để thực hiện giao dịch này. Trong trường hợp này, nó là 0,00008 NEAR.
 	Deposit value - Mệnh giá tiền gửi: Là tổng giá trị được chuyển từ tài khoản ký gửi sang tài khoản nhận tiền. Trong trường hợp này, giá trị tiền gửi là 0,5 NEAR.
 	Gas used - Gas đã sử dụng: Đơn vị gas cần thiết để thực hiện giao dịch. Trong trường hợp này, đó là 1 Tgas ( 1 TeraGas = 10¹² đơn vị gas).
 	Created - Thời điểm tạo giao dịch: Giao dịch này được tạo vào ngày 17 tháng 11 năm 2022, lúc 1:18:33 chiều.
 	Hash - Băm khối: Mã định danh duy nhất (giá trị băm) của khối mà giao dịch này được đưa vào. Trong trường hợp này, hàm băm khối là F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN

Biên lai của giao dịch


 	Explorer cũng hiển thị một biên lai cho giao dịch. Biên lai này có hai phần.
 	Phần đầu tiên là biên lai cho việc nhận giao dịch. Có ID biên lai và tổng số gas và số NEAR đã bị đốt.
 	Phần thứ hai là biên lai hệ thống. “Hệ thống” là một tài khoản đặc biệt được sử dụng để xác định biên lai hoàn tiền.




	

	
	
		
			
				Trường hợp nào dưới đây tôi có thể sử dụng blockchain explorer?
			
		

		
					

		
			
			
			
			Xem lịch sử giao dịch của một tài khoản cụ thể
		
			
			Kiểm tra xem giao dịch gần nhất của tôi đã tốn bao nhiêu phí gas
		
			
			Cả 2 trường hợp trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sử dụng các phần mềm NEAR Explorer khác
Ở ví dụ dưới đây, thử tìm kiếm cùng một giao dịch với ví dụ ở phần trước trên NearScan và NearBlocks để xem cách hiển thị dữ liệu khác nhau giữa các explorer.
NearBlocks

NearBlocks explorer hiển thị dữ liệu giống như NEAR Explorer phía trên với các thông tin như tổng lượng gas, lượng NEAR được đốt trong quá trình giao dịch, …




	

	
	
		
			
				“System account” đóng vai trò gì?
			
		

		
					

		
			
			
			
			Xác thực các giao dịch
		
			
			Xác định biên lai hoàn tiền
		
			
			Thêm giao dịch vào mạng blockchain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NearScan

Giao diện của NearScan cũng hiển thị khá giống với hai explorer bên trên, có một điểm khác biệt là số chữ số thập phân trên NearScan được hiển thị nhiều hơn so với Near Explorer.




	

	
	
		
			
				Đâu là explorer được sử dụng cho NEAR Protocol?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			NearScan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kết luận
Có nhiều giao dịch phức tạp hơn so với các ví dụ ở trên được thực hiện trên NEAR. Tuy nhiên, bài viết này chỉ dừng lại ở việc cung cấp cho bạn ý tưởng về cách đọc thông tin của các giao dịch này. Blockchain explorer cho phép bạn khai thác một trong những đặc điểm thiết yếu nhất của công nghệ blockchain – tính minh bạch. Nó trao quyền cho bạn với tư cách là người dùng để theo dõi một cách chi tiết và tinh vi tiền của bạn.

### Meta Pool, Module 3 - Decentralized Finances x Meta Pool

DeFi Ecosystem with Meta Pool
Decentralized Finances (DeFi) are a new way to operate finances based on blockchain technology. These finances use smart contracts to store, lock, share, vest and farm tokens. DeFi aims to subtract the control that central banks have over funds or assets and distribute them through smart contracts.

Meta Pool is a permissionless, non-custodial, asset issuer smart contract that makes it possible to join NEAR tokens and staking rewards in a single token called staked NEAR (stNEAR).

stNEAR allows its holders to move value of staked tokens and rewards on the DeFi ecosystem of multiple chains, including NEAR and Aurora.




	

	
	
		
			
				Decentralized Finances can have part of its operation managed by centralized entities. Not all DeFi is 100% decentralized.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bridge stNEAR tokens between NEAR <> Aurora - Rainbow Bridge
Meta Pool uses Rainbow Bridge to transfer $META and stNEAR tokens between NEAR and Aurora Network, this allows you to use your Meta Pool tokens in Aurora dApps, such as Trisolaris, WannaSwap and etc.

Moving stNEAR and $META to Aurora Using Rainbow Bridge

Using https://rainbowbridge.app/ you can connect your NEAR Wallet and your MetaMask wallet in order to transfer your tokens:



How to Add $META stNEAR Contracts to MetaMask Wallet

To add a token from your past Rainbow Bridge transfer to MetaMask on Aurora Mainnet, click 'Scan transfer history' in the Bridge and select 'Add token to MetaMask'.

To add a token manually, find the token address in the list of supported tokens. Note that they have a different address on Aurora Mainnet than on Ethereum.

 	$META on Aurora 0xc21ff01229e982d7c8b8691163b0a3cb8f357453
 	stNEAR on Aurora 0x07f9f7f963c5cd2bbffd30ccfb964be114332e30

(VIDEO) How to transfer stNEAR to Aurora. Liquidity Minings Opportunities (NEAR Protocol, Aurora): https://www.youtube.com/watch?v=_o--5GY5G0w




	

	
	
		
			
				Once bridging a token from NEAR Protocol to Aurora is impossible to have it back on the original chain.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Swap tokens on Aurora - Trisolaris
Swap is the process where you exchange a token for another one according to the value given by market or pool conditions. In this way you can get tokens that you pretend to hold or look for a token that you are interested in using in a specific app.

Trisolaris is #1 Dex on the Aurora engine, an EVM compatible blockchain running in the near ecosystem.

How to swap on Trisolaris?

 	Go to Trisolaris Swap section and connect your MetaMask wallet with Aurora Network



 	Enter the amount to swap
 	Approve and confirm transaction




	

	
	
		
			
				You can use routing to swap to a token where there is no direct liquidity pool.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Add liquidity to swap pools of stNEAR - Trisolaris
As token emissions are not managed by a decentralized exchange, the swap pools need users that add liquidity to be able to make a swap.

In this way, you can become a liquidity provider by putting the pair of tokens required for a pool. In exchange, you receive a fraction of the fees generated by the pool.

 	Go to the Pool section and click on the add liquidity button.



 	Select the pair you are looking to add liquidity. In Trisolaris you can find stNEAR <> wNEAR pool.



 	Confirm the balance and click add button


Swap tokens on NEAR Protocol - Ref Finance
1. Go to Ref Finance and connect your NEAR wallet
2. Go to Trade section and select Swap


3. Select tokens to swap and check 'Price impact', 'Swap rate' and 'Minimum received' in the Details menu. Decide if this swap is right for you

4. Enter the amount for swap

5. Click Swap button, confirm and sign transaction

Thus, on Ref Finance you can get $META and stNEAR tokens.
Add liquidity to swap pools of stNEAR - Ref Finance
Ref Finance is the major Decentralized Exchange on NEAR Protocol. It makes available a set of DeFi tools using the NEP-141 standard of NEAR.

 	Go to pools, search for stNEAR pools and choose the pool you want to add liquidity.



 	Click Add Liquidity button



 	Select the amount of tokens you want to add in liquidity to the pool.


Once done, you are now able to receive a partition of the fees generated by the pool.




	

	
	
		
			
				Being a liquidity provider puts your tokens at risk of being liquidated.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Borrow using stNEAR - Burrow Cash
Borrowing means that you ask for tokens giving a collateral token. You receive a fraction of the value of your collateral (over collateralization) to receive the requested token in burrow.
If you want your tokens back you have the option to pay your debt.
In case your collateral drops in value this will be liquidated automatically by the borrow platform and you will stay with only your borrowed tokens without the option of recovering your tokens.


 	Go to BurrowCash
 	Connect your NEAR wallet
 	Follow stNEAR on the Deposit page


Depositing stNEAR:

 	Enter the amount stNEAR
 	Use as Collateral if you want to borrow
 	Submit and sign the transaction


How to Borrowing?


 	Select the asset to borrow
 	Enter the amount to borrow, keeping in mind the resulting Health Factor
 	Submit and sign the transaction


How to Repay?


 	Go to Portfolio
 	To repay borrowed assets, click the "Repay" button


How to Withdraw?


 	Go to Portfolio
 	To withdraw supplied assets, click "Withdraw"





	

	
	
		
			
				Borrow cash is available in any country in the world.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Borrow using stNEAR - Aurigami
Arugami allows you to request a borrow of tokens on Aurora Network. For this you can use stNEAR tokens.
At the time this is written, you can go directly to the dashboard of Aurigami and click on supply for stNEAR token. If you already have a collateral you can click on borrow.


The supply option will give you a modal where stNEAR can be deposited. Once chosen click on Approve stNEAR.

Allow the use of stNEAR as collateral to request a burrow. Confirm the transaction on your wallet.

Select the token you want to borrow and click on the Borrow button.

Select the amount of tokens you want to have on borrow. WARNING: if you request 100% you are at high risk of being liquidated.

Whenever you want to have your stNEAR back, go to repay and return all the tokens you get by borrowing.

Leveraged Yield Farming -  Pembrock
The first leveraged yield farming application on NEAR Protocol. Inside of this application you can find lending, farming and staking mechanisms. stNEAR is allowed as a token to use in PembRock.

Farm STNEAR-wNEAR

Deposit stNEAR and borrow wNEAR on the farm pool. Choose the amount of assets to use as collateral and the leveraged level. Verify the summary of the transaction.

Lend stNEAR

Choose the amount of stNEAR tokens you want to lend. These assets are used by yield farmers to leverage their crypto assets.

Learn more about how Pembrock works on the following link: https://docs.pembrock.finance/education/how-to-guides




	

	
	
		
			
				Leveraged Yield Farming can imply risk of liquidation of your tokens.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR staking on Aurora Network
We’ve made it easy for Aurora users to stake wNEAR directly from Aurora using MetaMask. Leveraging the Rainbow Bridge’s ability to do contract calls between Aurora and NEAR, we’ve built a simple solution that maintains the same user interface and experience as the NEAR native solution.

It’s easy to distinguish which network you are on as it has the Aurora logo, and each network will automatically, it will prompt you to connect your Metamask wallet.
We are leveraging the Rainbow Bridge to automate all the steps the users would’ve had to perform manually: behind the scenes we are sending wNEAR from Aurora to NEAR Mainnet, unwrapping it, depositing NEAR on Meta Pool, receiving stNEAR and sending stNEAR back over Rainbow Bridge to the user’s Aurora Wallet.
Our code has been audited by Blocksec. Here is the Audits, so we did our best to keep assets secure.
Fee for deposit on Aurora is 0,1%, because Meta Pool needs to pay transaction fees on the bridge back and forth, that covers those transaction fees.

### Smart Contract Development on Near using Rust Part 2

This is the second part is a series of posts about building a chat app with Rust on the Near blockchain. You can find the first post in the series here.

In this post we will focus on the smart contract itself. We’ll see the near-sdk library that makes our code work on Near. We’ll also see Near state access patterns and the smart contract development principles in action by reviewing the code of this smart contract. You can find the complete repository with all the code we’ll discuss today on my GitHub.
Near’s smart contract Rust SDK
At its core Near’s smart contract runtime uses WebAssembly (Wasm). Wasm is a well-established bytecode format that is used outside of blockchain as well, such as in web apps. This is good for Near because its runtime can benefit from the work that is done in broader Wasm community.

The Rust compiler does a good job at generating Wasm output, but there needs to be some scaffolding around it for the Wasm bytecode to work properly with its “host” (the Near runtime in our case, or a web browser’s JavaScript engine in the case of a web app). This scaffolding can be automatically generated using convenient Rust libraries: wasm-bindgen in the case of browser integration, and near-sdk in the case of Near. The smart contract we are working with today is written using near-sdk.

Both libraries make use of Rust procedural macros (proc macros). This is a kind of metaprogramming where the library defines small annotations we can use to trigger Rust code to be automatically generated for us. Rust’s proc macros are used to reduce the amount of boilerplate code the developer needs to write to get their business logic working. For example, the derive proc macro is core to the Rust language. It can automatically define common functionality on new data types you create. You can see this used in the following simple code snippet from the chat smart contract:




#[derive(


 Debug, BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, Copy, PartialEq, Eq,


)]


#[serde(crate = "near_sdk::serde")]


pub enum MessageStatus {


 Read,


 Unread,


}




You can see many traits listed in the derive annotation. To call out some specific ones: Debug means the MessageStatus type can be converted to a string to help in debugging code; Clone means it is possible to create an identical MessageStatus instance from the current one, and Copy means that Clone operation is cheap; PartialEq and Eq mean that you can compare two MessageStatus instances to see if they are the same. The Serialize and Deserialize traits come from the serde library, which is ubiquitous in the Rust ecosystem for encoding/decoding data from formats like JSON or CBOR. We’ll come back to the Borsh traits later.

Thus far, this has all been standard Rust that you will find in any project. The Near-specific proc macro is near_bindgen which you can see used in the following code snippet:




#[near_bindgen]


#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]


pub struct MessengerContract {


 accounts: LookupMap<AccountId, AccountStatus>,


 messages: LookupMap<MessageId, Message>,


 unread_messages: UnorderedSet<MessageId>,


 read_messages: UnorderedSet<MessageId>,


 last_received_message: LookupMap<AccountId, MessageId>,


 pending_contacts: UnorderedSet<AccountId>,


 owner: AccountId,


}




The near_bindgen proc macro automatically generates the extra code we need so that when we compile to Wasm we get an output that the Near runtime understands how to use. It is used in multiple places where such glue code is needed. Here it marks the MessengerContract struct as having the state needed to execute the methods of the contract. An instance of the MessengerContract struct will be created each time we call a method on our smart contract. We’ll discuss what some of these fields are used for later.

The near_bindgen macro is also used over the impl block for the MessengerContract struct:




#[near_bindgen]


impl MessengerContract {


// ...


}




Here it means that the functions defined in this block are the methods we want exposed on our smart contract. It allows users of the Near blockchain to submit transactions calling these functions by name. For example, the method for sending a message is defined in this block. We’ll look at some other methods from this block in more detail below.

In summary, the near-sdk rust library provides a proc macro called near_bindgen to automatically generate glue code that makes the Wasm output work with the Near runtime. This macro can be used on a struct to define the state of your contract and on that struct’s impl block to define the public methods on your contract. Near-sdk provides other useful functions and structures as well, which we’ll see in the subsequent sections.
Smart contract state
Essentially all non-trivial smart contracts require some state to operate correctly. For example, a token contract needs to maintain the balances of the various token holders. Our chat contract is no different. We saw in the previous section that the MessengerContract struct contained many fields. In this section we discuss some general features of state in Near’s runtime as well as some specifics as to how it is used in the example smart contract.

The most important thing to know about smart contract state in Near is that it is a simple key-value storage. You can see this in the low-level storage_read and storage_write functions exposed by near-sdk. However, you can build some more sophisticated data structures on top of this simple foundation, and near-sdk provides some of these in its collections module. For this reason, our example contract does not use the key-value storage directly; instead it makes use of the higher-level collections offered by near-sdk.

For example, the smart contract keeps track of the status of the accounts it knows about (which ones are contracts, which we have sent a contact request to, etc.). The accounts field of MessengerContract is a LookupMap structure from near-sdk. This is pretty close to directly using the key-value storage since the map is also simply a way of looking up a value from a key, but the LookupMap does two important things above the raw key-value storage interface. First it has a prefix it includes on all storage keys related to this map. Using a prefix prevents mixing up keys from this map with keys from another (for example the last_received_message map, which is also keyed on AccountId). Second, the LookupMap lets us work with higher level Rust types whereas the raw storage interface works with bytes only. This is achieved by using Borsh serialization to convert the types to/from binary strings. Borsh is a serialization format designed by Near to be useful in blockchain applications specifically. This usage of Borsh is why you see BorshDeserialize and BorshSerialize derived on many types throughout the code.

A more interesting example of a collection used here is the UnorderedSet used in the unread_messages field. This is used for the contract to keep track of which messages are still unread. The UnorderedSet is still built on the underlying key-value storage, but it effectively only uses the keys as we only care if an element is in the set or not. The structure also keeps metadata about what keys it is using to allow us to iterate over all the keys in the set.
Checking the environment and calling other contracts
In this section we discuss general features of Near’s runtime environment and making cross-contract calls. To keep us grounded, this is done in the context of how users add each other as contacts in our chat application. Let’s take a look at the add_contact function definition (this definition is in the MessengerContact impl block, with the near_bindgen annotation mentioned above, because it is a main entry point for our contract).




#[payable]


pub fn add_contact(&mut self, account: AccountId) -> Promise {


self.require_owner_only();





let deposit = env::attached_deposit();


require!(deposit >= ADD_CONTACT_DEPOSIT, "Insufficient deposit");





let this = env::current_account_id();


Self::ext(account.clone())


 .with_attached_deposit(deposit)


 .ext_add_contact()


 .then(Self::ext(this).add_contact_callback(account))


}




There is a lot to unpack in these few lines of code. As additional framing to guide our discussion, recall the three principles of smart contract development outlined in the previous post:

 	an adversarial mindset,
 	economics,
 	ensure invariants before making cross-contract calls.

Go back and review the first post if you need a refresher on what these principles were about. Each of these principles makes an appearance in this function.
An adversarial mindset
All smart contract methods are public and we must enforce access control when the method makes a sensitive action, otherwise someone will misuse the functionality. In this case we do not want anyone to be able to add contacts on the owner’s behalf; only the owner should be able to decide who to connect with (if someone else wants to make contacts in the chat network they can deploy this contract to their own account!). Therefore, we have the require_owner_only() call right at the top of the function body. The implementation of this function is simple:




fn require_owner_only(&self) -> AccountId {


let predecessor_account = env::predecessor_account_id();


require!(


self.owner == predecessor_account,


"Only the owner can use this method!"


);


 predecessor_account


}




It makes use of the predecessor_account_id function rom the env module of near-sdk. The env modules contains many useful functions for querying aspects of the Near runtime environment our contract is executing in. For example here we are checking which account made the call to our contract. The env module contains other useful functions such as for checking the account ID of our contract itself, and how many Near tokens were attached to this call. I recommend reading the module’s documentation to see all the functions that are available.

For efficiency reasons the require_owner_only function also returns the predecessor account (to avoid multiple calls to env::predecessor_account_id() in case an owner-only function also needs the predecessor account for another reason).
Economics
The very first line of the add_contact code snippet above includes the payable attribute. Using this annotation is enabled by the function being defined as part of a near_bindgen impl block. It means that this method will accept Near tokens from the users that call it. These tokens are needed because we made the decision that users are paying for actions like creating state on-chain. Since adding another account as a contact creates state in their contract as well as ours (we need to let them know we want to connect), we must ensure the user initiating this connection is paying for that storage. The deposit attached to this payable function is used to cover that storage cost.

You can see a few lines down where we check that the deposit is indeed present. This makes use of the attached_deposit function from the env module. The fact we are making this check early segues perfectly into the third principle.
Ensure invariants before making cross-contract calls
The type signature of the add_contact function is important to notice. First, the arguments to the function (&mut self, account: AccountId) mean that this is a mutable call (it will change the state of the contract) and it takes one argument called “account” which must be a Near Account ID. When near_bindgen does its magic, it will mean users of the Near blockchain can call this function by making a transaction which takes a JSON encoded argument like { "account": "my.account.near" }. Second, the return type is Promise, which means that we are making a cross-contract call at the end of this function. Cross-contract calls on Near are asynchronous and non-atomic, therefore we must ensure everything is in a good state before we make the call. This is why we include the owner-only and deposit check first in the function body. The asynchronous nature of the cross-contract calls also means there is no return value from this function immediately. The asynchronous call will be performed and the result will only come later, after this call happens.

You can see the details of the cross-contract call at the bottom of the function. It uses the high-level API from near-sdk (though the low-level API is also available in the env module) where the ext function is automatically generated by near_bindgen and it returns a data structure to construct the cross-contract call. You can see first we use ext(account) to call the account we want to add as a contact. The call includes our deposit via with_attached_deposit and is calling the ext_add_contact function (which is defined in the same impl block in this case, but in general it could be defined anywhere). Finally, we call then which means to include a callback. The callback is itself another Promise, so we use the same ext function again, but this time calling on our own account ID. This is done so that our contract can know what the response was from the contract we are trying to add as a contact. I won’t go into the details of the ext_add_contact or add_contact_callback implementations here (they just manipulate the storage depending on the current status of the account), but I encourage you to read through them in the source code on GitHub if you are interested.
Summary
In this post we dove head first into some code! We saw how near_bindgen is used to automatically generate code needed to run our contract in the Near runtime, as well as other features of near-sdk to interact with storage, the runtime environment and other contracts. In the next post we’ll continue the deep dive into code, but change gears to look at the off-chain component of this application. A smart contract alone does not constitute a dapp, stay tuned to see why!

If you want some hands-on experience with this code then try out some of the exercises! In a few places in the smart contract code I included a comment tagged as EXERCISE. For example, in the types definition I call out the fact that a Blocked user status is available, but there is no way to block someone currently implemented. Adding this functionality to block another user is one suggested exercise, and a good one to get started with. All the exercises are suggestions of ways to extend the functionality of the contract, giving you an opportunity to try writing some smart contract code for yourself. Perhaps in a future post in this series I’ll discuss some solutions to the exercises.

If you are enjoying this series of blog posts please get in touch with us at Type-Driven consulting. We are happy to provide software development services for dapps, as well as training materials for your own engineers.

### Hướng dẫn sử dụng NEAR trên điện thoại của bạn

Có một cách để sử dụng NEAR trên điện thoại của bạn là dùng ví HERE. Đây là ví non-custodial (Không lưu ký) - các khóa bí mật của ví sẽ được lưu trên điện thoại của bạn, tức là không ai ngoài bạn biết được khóa riêng tư của ví.

Ví HERE tập trung vào cách để người dùng sử dụng NEAR dễ dàng nhất. Bạn có thể sử dụng nhiều ứng dụng trực tiếp từ đây. Ngoài ra còn có tính năng stake thanh khoản được tích hợp trong ứng dụng với khả năng rút tiền ngay lập tức với 0% phí.

Khi bạn thực hiện bất kỳ giao dịch chuyển tiền, tiền sẽ ngay lập tức được unstake mà không mất phí.

Trong bài viết này, chúng tôi sẽ hướng dẫn bạn cách sử dụng các tính năng cơ bản của ứng dụng HERE Wallet, nếu có bất kỳ câu hỏi nào, bạn luôn có thể chat để hỏi nhóm phát triển.
Đăng nhập với seed phrase
Nếu bạn đã có sẵn tài khoản NEAR, bạn có thể đăng nhập ví bằng cách sử dụng seed phrase của tài khoản NEAR:

 	Nhấp vào nút “import existing account”
 	Nhấp vào “use seed phrase”
 	Điền seed phrase của bạn vào form và nhấp vào nút “find my account”


Nếu bạn đã có tài khoản NEAR trên trang wallet.near.org:

 	Nhấp vào nút “import existing account”
 	Nhấp vào “use seed phrase”
 	Điền seed phrase của bạn vào form và nhấp vào nút “find my account”
 	Nhấp vào “import existing account”
 	Chọn “share the link”
 	Nhập đường link ở bước 5 vào trình duyệt trên máy tính của bạn
 	Truy cập đường link, lựa chọn tài khoản mà bạn muốn đăng nhập và nhấp vào “Next”
 	Chọn “Connect”
 	Nhập account ID của bạn và chọn “Confirm”
 	Bạn sẽ được ủy quyền trên ứng dụng HERE


Cài đặt tên tài khoản (miễn phí)
Tài khoản NEAR có định dạng username.near thay vì một chuỗi địa chỉ dài. Thường thì bạn phải có sẵn một ít token NEAR để tạo tên tài khoản, nhưng trên ứng dụng HERE, chúng tôi đang cung cấp tên tài khoản miễn phí. Bạn chỉ cần nhập tên tài khoản mà mình muốn, rồi chọn “Continue”.

* Chú ý quan trọng: bạn sẽ không thể thay đổi tên khác một khi bạn đã chọn tên tài khoản. Cách duy nhất để bạn dùng một tài khoản có tên khác là tạo mới tài khoản và chuyển token sang tài khoản mới này. Chúng tôi khuyên bạn không nên sử dụng họ tên của mình làm tên tài khoản NEAR vì nó có thể khiến bạn bị lộ danh tính.

Kiếm tiền trên ứng dụng
Ví HERE có sẵn tính năng stake thanh khoản, và bạn có thể rút thanh khoản bất kỳ lúc nào mà không hề mất phí.

 	Nhấp vào nút màu hồng có chữ “Stake”
 	Chọn “start staking”
 	Điền số NEAR mà bạn muốn stake
 	Chọn “stake”
 	Như vậy là bạn đã stake thành công, từ nay bạn sẽ nhận được một khoản thu nhập với lãi suất 8-10% một năm tính trên lượng NEAR mà bạn đã stake.


Nhận lãi

 	Nhấp vào nút “Claim”
 	Đợi một chút để ứng dụng gửi giao dịch lên mạng NEAR
 	Hoàn thành! Tiền lãi đã được chuyển về tài khoản của bạn


Mua NEAR bằng crypto

 	Nhấp vào nút “Add money”
 	Chọn “Buy NEAR with other crypto”
 	Lựa chọn loại tài sản mà bạn muốn dùng để mua NEAR (ví dụ BTC)
 	Nạp loại tài sản mà bạn chọn ở bước 3 vào địa chỉ hiển thị trên ứng dụng
 	Nhấp vào nút Done sau khi bạn nạp tài sản
 	Bạn có thể kiểm tra tình trạng nạp tiền ở màn hình theo dõi các giao dịch


Cách sử dụng dApps trên ví HERE

 	Lựa chọn HERE Wallet trên danh sách các ứng dụng hiển thị trên website của dapp đó
 	Scan QR code bằng camera trên điện thoại của bạn
 	Bạn sẽ được điều hướng sang ứng dụng, sau đó nhấp vào nút “Confirm” để xác nhận kết nối

### (L)Earner NFT là gì?

(L)Earner NFT là gì?
Gần đây bộ sưu tập NFT thú vị mang tên (L)Earner NFT từ LearnNear.Club đã ra mắt trên Hệ sinh thái của NEAR và đã đạt được nhiều sự ủng hộ từ cộng đồng. Hôm nay chúng ta cùng tìm hiểu về bộ sưu tập NFT đầy thú vị này nhé!
NFT là gì?
NFT là viết tắt của Non-Fungible Token (Mã thông báo không thể thay thế). NFT là tài sản kỹ thuật số duy nhất, có thông tin nhận dạng được ghi lại trên hợp đồng thông minh và lưu trên blockchain. Thông tin trên hợp đồng thông minh là thứ làm cho NFT trở nên độc nhất. NFT là một tài sản không thể thay thế và không thể chia nhỏ được. Ví dụ: bạn không thể gửi cho ai đó một góc của bức tranh hoặc của tấm vé.

NFT là chứng chỉ số về quyền sở hữu đối với tài sản kỹ thuật số, là một hợp đồng thông minh được sử dụng để bảo mật tài sản kỹ thuật số. Sau khi được viết ra, nó sẽ được xuất bản thành token (theo chuẩn ERC-721 với Ethereum hoặc NEP-171 với NEAR) trên blockchain. Mọi thứ đều có thể được chuyển thành NFT, trong đó phổ biến nhất là các video, GIF hoặc JPEG.
Bộ sưu tập (L)Earner NFT là gì?
Bộ sưu tập (L)Earner NFT là sự hợp tác giữa cộng đồng Learn Near Club (LNC) và Denis Bashev, một trong những nhà thiết kế đồ họa từng đoạt giải thưởng xuất sắc nhất ở Châu Âu.
Ý tưởng thiết kế
Ý tưởng thiết kế của (L)Earner NFT dựa trên trí thông minh vận động của con người, được hỗ trợ thêm bởi sự độc đáo của mỗi học viên. Mỗi con người là một cá thể duy nhất có mô hình học tập, điểm mạnh và điểm yếu khác nhau muôn màu muôn vẻ.

Bộ sưu tập (L)Earner NFT có mục đích làm nổi bật cá tính của mỗi học viên và cách họ vận động, suy nghĩ, ước mơ, sợ hãi, trải nghiệm và cá tính riêng.

Nếu bạn không quen với cách giải thích kiểu khoa học như trên, có thể hình dung theo cách dễ hiểu như sau:

Khi bạn tích cực học một thứ gì đó, các tế bào thần kinh (tế bào não) sẽ bắt đầu hình thành những liên kết với nhau. Lúc đầu, các liên kết này rất yếu và phần kiến ​​thức chưa được lưu toàn bộ vào vùng nhớ dài hạn. Chỉ khi bạn dành nhiều thời gian hơn để tìm hiểu về một khái niệm nào đó, những liên kết này sẽ trở nên mạnh mẽ hơn và được lưu lại lâu hơn. Kiến thức của bạn sẽ thực sự được lưu trữ trong hàng tỷ kết nối thần kinh giữa các nơ-ron trong bộ não. Quá trình này được gọi là học Hebbian.

Ý tưởng về các nhân vật hình que dựa trên hệ thống thần kinh của con người. Các đoạn cấu tạo thành nhân vật được lấy cảm hứng từ vỏ Myelin, là nơi giúp các xung điện được truyền qua các tế bào thần kinh.


Các tư thế của nhân vật thể hiện vô số sự kết hợp của các kết nối thần kinh hợp nhất trong thế giới vi mô của chúng, tạo thành những ký ức dài hạn riêng biệt về một khái niệm hoặc hoạt động. Các đoạn thẳng được vẽ trên mặt phẳng cartesian để tạo ra các tư thế vui nhộn.


Bảng màu được Denis lựa chọn cẩn thận để mang lại sự sống động và vui tươi hơn cho nhân vật người que. Nó tượng trưng cho niềm vui học tập. Niềm vui của việc học không phải là thứ có thể cảm nhận được bằng sự hài lòng tức thì. Đó là đỉnh điểm của tất cả những cách mà sự khao khát về kỹ năng và kiến thức mới đã cải thiện cuộc sống của bạn và cuộc sống của những người xung quanh bạn.

Việc đúc NFT
Tất cả những ai yêu thích việc đúc(mint) NFT đều được mời tham gia vào dự án thú vị này. Phí mint bắt đầu từ 2 $NEAR và tăng dần khi bộ sưu tập tăng lên đến giới hạn 10.000 NFT. Người tạo NFT có thể:

 	Khởi tạo- phần mềm sẽ khởi tạo ra một tư thế ngẫu nhiên và trộn các màu bao nhiêu lần tùy thích để bạn có được (L)Earner NFT mà bạn muốn. Hầu hết các NFT trên thị trường đều được “tạo ra” từ các mô hình dựng sẵn, trong khi (L)Earner NFT có lượng tổ hợp hầu như không giới hạn để tạo ra một NFT thực sự độc nhất cho bạn.


 	Đặt tên- đặt tên cho (L)Earner NFT của bạn, làm cho nó độc đáo như chính nhân vật đó


 	Mint- đúc NFT của bạn và bảo mật nó trên blockchain NEAR.


 	Quản lý- thu thập bao nhiêu tùy thích và quản lý bộ sưu tập cá nhân, nguyên bản của bạn
 	Giao dịch- mua và bán các (L)Earner NFT trên Paras NEAR NFT Marketplace

Lợi ích của (L)Earner NFT LNC
Bạn không chỉ nhận được một NFT cool ngầu khi mint (L)Earner NFT, mà bạn còn nhận được các đặc quyền hữu ích với tư cách là thành viên chính thức của cộng đồng LNC:

 	Ưu tiên quyền truy cập sớm hơn 2 giờ vào cửa sổ Redeem sang NEAR
 	Đúc Proof of (L)Earn NFT
 	Được hỗ trợ ưu tiên tại LNC Telegram
 	Và các quyền lợi khác trong tương lai…

Hãy coi NFT của LNC như một thẻ thành viên vậy - đẹp, uy tín, giá cả phải chăng, hữu ích, độc đáo, được thiết kế bởi các nhà thiết kế vĩ đại và chính bạn, do bạn đặt tên, số lượng giới hạn với 10 ngàn NFT.

Tham gia nhóm telegram LNC để chia sẻ (L)Earner NFT của bạn với các thành viên khác trong cộng đồng.
Tổng kết
Bộ sưu tập (L)Earner NFT là sự hợp tác tiên phong giữa LNC và Denish Bashev (nhà thiết kế đồ họa đoạt giải thưởng lớn). Mục đích của dự án là gói gọn trải nghiệm học tập cá nhân của mỗi học viên vào một NFT. Bộ sưu tập được giới hạn ở 10,000 NFT, vì vậy hãy nhận ngay nhân vật của bạn khi còn có thể tại https://learnnear.club/learner-nft/

### Tại sao các DAO nên chuyển sang vận hành trên các Shard riêng tư

Giới thiệu về DAO và hợp đồng đa chữ ký
Hầu hết người dùng Web3 đều đã quen thuộc với hai khái niệm là DAO và Multisign smart contract - Hợp đồng đa chữ ký, nhưng đối với những người mới tới với thế giới Web3, tôi cho rằng cần giải thích qua về hai thuật ngữ này.
DAO là gì?
“Tổ chức tự trị phi tập trung” (DAO) là một thực thể được quản lý bởi cả cộng đồng và không có thực thể tập trung nào kiểm soát. Hoàn toàn tự động và minh bạch: các hợp đồng thông minh được sử dụng để kiểm soát việc ra quyết định và phân bổ quyền sở hữu tài sản. Quá trình bỏ phiếu cho DAO được công khai trên blockchain và người dùng thường phải chọn giữa các tùy chọn loại trừ lẫn nhau. Quyền biểu quyết thường được phân phối giữa những người dùng dựa trên trọng số biểu quyết mà họ có trong DAO (trọng số thường được tính tỉ lệ với lượng token quản trị của dự án mà họ nắm giữ). Tất cả các phiếu bầu và hoạt động thông qua DAO được lưu trữ trên blockchain, làm cho tất cả các hành động của người dùng có thể được theo dõi một cách công khai.

Các DAO đưa ra quyết định bằng việc áp dụng ví đa chữ ký (là một smart contract).
Ví đa chữ ký là gì?
Ví đa chữ ký (Multisig) là một loại hợp đồng tiền mã hóa đặc biệt để lưu trữ token một cách an toàn. Nó yêu cầu hai hoặc nhiều khóa riêng tư (tương ứng các thành viên trong một DAO) để ký và tạo giao dịch và thường được sử dụng như một lớp bảo mật bổ sung cho các giao dịch ví bằng cách đảm bảo rằng nhiều người nắm giữ khóa tham gia phê duyệt giao dịch.

Hợp đồng đa chữ ký cũng có thể được cấu hình để cho phép từng thành viên tạo chữ ký riêng, đây cũng là một lựa chọn tuyệt vời cho những người muốn lưu trữ tiền điện tử của họ một cách an toàn và không phụ thuộc vào bên thứ ba.
Các DAO đang áp dụng hợp đồng đa chữ ký như thế nào?
DAO đang sử dụng ví đa chữ ký để lưu trữ tiền của họ một cách an toàn và quản lý tài sản một cách hiệu quả. Hợp đồng đa chữ ký cung cấp cho nhiều bên liên quan khả năng ký kết giao dịch, cho phép quản lý tiền và quyết định an toàn và đa dạng. Đa chữ ký cũng tăng thêm một lớp bảo mật bổ sung bằng cách yêu cầu nhiều khóa riêng tư để truy cập tài sản.

Ngoài ra, các DAO có thể sử dụng hợp đồng đa chữ ký để triển khai hệ thống bỏ phiếu và quản trị phức tạp hơn so với hợp đồng nhiều chữ ký thông thường. Điều này cho phép việc ra quyết định được phi tập trung và an toàn.

Các cấu trúc bỏ phiếu DAO phổ biến nhất là bỏ phiếu đại biểu theo trọng số token, bỏ phiếu bậc hai, ủy quyền bỏ phiếu (Liquid Democracy) hoặc khóa phiếu bầu và bỏ phiếu đại biểu dựa trên token.

 	Bỏ phiếu đại biểu theo trọng số token: Yêu cầu một ngưỡng nhất định để một đề xuất được thông qua. Ví dụ: 60% đại biểu, có nghĩa là 60% số lượng chủ sở hữu của token phải bỏ phiếu ủng hộ đề xuất để nó được thông qua.
 	1 token = 1 phiếu bầu quản trị: Quyền biểu quyết của một cá nhân tỷ lệ thuận với số lượng token họ nắm giữ.
 	Biểu quyết bậc hai: Đó là một hệ thống cân bằng lợi ích của các nhóm thiểu số trong khi vẫn ra quyết định dựa trên ý kiến của đa số. Hệ thống này cho phép mọi người ủy thác lá phiếu của họ cho một người đại diện.
 	Khóa phiếu bầu: một cơ chế cho phép người tham gia xóa phiếu bầu của mình mà không bị phạt.
 	Bỏ phiếu đại biểu dựa trên việc nắm giữ token: Một hệ thống yêu cầu cử tri nắm giữ một lượng token nhất định để đề xuất được thông qua.

Những thách thức hiện tại của các DAO
Các vấn đề chính mà DAO đang phải đối mặt bao gồm: thiếu tư cách pháp nhân được công nhận và khả năng chịu trách nhiệm vô hạn của các thành viên, thiếu quy định và các biện pháp bảo mật không đầy đủ. Ngoài ra, DAO dễ bị tấn công quản trị, cấu hình không tốt hoặc có thể bị spam. Những vấn đề này có thể tạo ra một số rủi ro như dễ lộ dữ liệu cá nhân, hợp đồng thông minh dễ bị tấn công và truy cập trái phép vào quỹ.

Phần lớn các vấn đề này có thể được giải quyết hoặc giảm thiểu bằng cách sử dụng Private Shard (Phân đoạn riêng tư), nhưng trước hết chúng ta cùng khám phá Private Shard là gì.




	

	
	
		
			
				Cách bỏ phiếu nào sau đây có thể được sử dụng khi DAO triển khai private shard?
			
		

		
					

		
			
			
			
			Cơ chế 1 token = 1 phiếu bầu
		
			
			Biểu quyết bậc hai
		
			
			Bỏ phiếu theo trọng số token
		
			
			Tất cả các cách trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Private Shard dành cho DAO: sự nâng cấp của ví đa chữ ký

Private Shard là một sidechain có thể tùy chỉnh (sidechain là mạng blockchain chạy song song với blockchain công khai có khả năng chuyển tài sản và thực hiện các lệnh gọi hợp đồng chéo) cho phép bạn bảo vệ dữ liệu của mình trong khi vẫn tận dụng được tất cả các lợi ích của blockchain chính. Nó cho phép các chủ sở hữu Private Shard có toàn quyền kiểm soát blockchain của họ trong khi vẫn giữ thông tin riêng tư giữa họ và chỉ cho phép một số bên công khai truy cập thông tin này.

Các thành viên DAO điều hành blockchain riêng dựa trên nhu cầu của họ. Private Shard có thể được tùy chỉnh theo các cấu trúc biểu quyết được giới thiệu ở trên, nơi các trình xác thực (các nút xác thực các khối của blockchain) thuộc sở hữu của các thành viên DAO, tương tự như cách hoạt động của một ví đa chữ ký, họ sẽ sở hữu một khóa riêng với quyền biểu quyết nhất định. Hãy nghĩ về nó như một phiên bản nâng cấp của ví đa chữ ký, vì tất cả các thuộc tính của ví multisign cơ bản là giống nhau, trong khi vẫn đảm bảo tính riêng tư cho tất cả thông tin lưu trữ bên trong private shard. 

Trên hết, các thành viên DAO có thể triển khai các hợp đồng thông minh tùy chỉnh bên trong Shard với “khả năng mở rộng vô hạn” cung cấp những khả năng:

 	Bỏ phiếu kín
 	Kế toán và tính lương
 	Triển khai các cơ chế thiên về giao dịch như đấu giá (có thể quá đắt nếu thực hiện trên public blockchain)
 	Tạo ra các bộ phận quản lý ngân quỹ bên trong DAO
 	Và còn nhiều khả năng khác nữa




	

	
	
		
			
				Private shard là gì?
			
		

		
					

		
			
			
			
			Một hệ thống Web2 bí mật được lưu trữ trên một hệ sinh thái đóng
		
			
			Một sidechain có thể tùy chỉnh (blockchain chạy song song với blockchain công khai có khả năng chuyển tài sản và thực hiện các lệnh gọi hợp đồng chéo)
		
			
			Một DAO công khai được triển khai trên một shard của blockchain NEAR và được vận hành bởi các trình xác thực của NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Cầu nối Private Shards có smart contract cho phép thiết lập các quy tắc về hợp đồng/tài khoản công khai có thể tương tác và cấu hình phù hợp. Điều này cung cấp khả năng giới hạn quyền truy cập cho một số bên hoặc hợp đồng nhất định để di chuyển tài sản đến các private shard, ngoài ra nó còn cung cấp quyền truy cập vào một số hợp đồng thông minh nhất định để thực hiện các lệnh gọi hợp đồng từ shard hoặc từ mạng chính.

Ví dụ: Một DAO có thể có hợp đồng bỏ phiếu riêng tư bên trong private shard, hợp đồng này sẽ bắt đầu lệnh gọi khi cuộc bỏ phiếu kết thúc và chỉ kết quả bỏ phiếu mới được công bố trên mạng chính mà không tiết lộ phiếu bầu cụ thể của từng thành viên. Cuộc gọi này chỉ có thể được thực hiện từ bên trong shard đó và không bên nào khác có thể thực hiện nó ngoại trừ hợp đồng cụ thể này. Điều này giúp các thành viên DAO đảm bảo tính bí mật của phiếu bầu giống như cách họ sử dụng multisign, trong khi phiếu bầu thực tế được giữ bí mật.




	

	
	
		
			
				Private shard cung cấp khả năng nào mới cho DAO?
			
		

		
					

		
			
			
			
			Bỏ phiếu bí mật
		
			
			Kế toán và tính lương nhà thầu
		
			
			Triển khai các cơ chế thiên về giao dịch như đấu giá
		
			
			Tất cả các khả năng trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Trên hết, Calimero Gateway cung cấp khả năng quản lý quyền bổ sung cho các thành viên DAO để chỉ định các chính sách mà người dùng/ví công khai có thể tương tác với private shard. Trong khi các thành viên DAO chạy trình xác thực và có quyền truy cập quản trị vào shard, họ có thể mời các thành viên/ví bên ngoài đọc một số dữ liệu nhất định hoặc tương tác với các hợp đồng được chỉ định.

Ví dụ: Một DAO có thể có một hợp đồng riêng bên private shard của mình để các bên bên ngoài gửi đề xuất mà DAO có thể bỏ phiếu. Chỉ những người gửi và thành viên DAO có thể xem thông tin về trạng thái của đề xuất đó.

Khả năng gửi đề xuất có thể được giới hạn trong danh sách các ví được whitelist do DAO thêm, hoặc cũng có thể cấu hình cho phép bất cứ ai cũng có thể thực hiện tạo đề xuất.

Chúng tôi tin rằng Private Shard là sự phát triển tự nhiên tiếp theo của DAO và đang tìm cách làm việc với nhiều DAO hơn cho quá trình chuyển đổi của Web3 này.

Vui lòng liên hệ với chúng tôi nếu bạn có bất kỳ câu hỏi nào hoặc đang muốn dùng thử dịch vụ.

### Toolblox - Công cụ xây dựng hợp đồng thông minh không cần code

Toolblox là trình tạo hợp đồng thông minh và DApp không cần kỹ năng lập trình. Trong bài viết này, chúng tôi muốn cung cấp cho bạn mọi thông tin hữu ích nhất về dự án - chúng tôi đang làm gì và tại sao điều đó lại quan trọng.

(Toolblox Workflow Builder và giao diện người dùng được tạo tự động)
Sơ lược lịch sử phát triển
Dự án bắt đầu vào đầu năm 2022 khi tham gia hackathon Near Metabuild II. Chúng tôi đã giành được giải thưởng lớn và dùng giải thưởng này làm vốn phát triển. Toolblox đã giành được các giải thưởng khác trong năm 2022, chẳng hạn như giải thưởng Công cụ & Cơ sở hạ tầng tốt nhất tại cuộc thi hackathon Polygon BUIDL IT.

Kể từ phiên bản đầu tiên, giao diện người dùng đã được đơn giản hóa gấp 10 lần và chúng tôi cũng đã hoàn thiện trình tạo DApp. Ban đầu nó chỉ hỗ trợ một blockchain, hiện tại Toolblox đã hỗ trợ tổng cộng 6 blockchain khác nhau.

Toolblox sắp tròn 1 năm tuổi và chúng tôi đang dần hoàn thiện và muốn chia sẻ nó với mọi người.
Hợp đồng thông minh tự thực thi
Hợp đồng thông minh là các thỏa thuận tự thực hiện được mã hóa dưới dạng chương trình máy tính. Khi đoạn mã lập trình trong hợp đồng được kích hoạt, các hợp đồng có thể ngay lập tức thực hiện hành động như giải quyết các khoản thanh toán hoặc chuyển quyền sở hữu. Điều này là khả thi vì trên blockchain không cần một thực thể tập trung nào ra quyết định, chữ ký số được sử dụng và dữ liệu lưu trữ trên blockchain chỉ có thể thay đổi khi thực hiện giao dịch.

Hợp đồng thông minh được sử dụng để:

 	Truyền niềm tin, sự công bằng và minh bạch vào bất kỳ hệ thống hoặc quy trình hiện có nào.
 	Loại bỏ thành phần trung gian và các thực thể kiểm soát theo hướng tập trung.
 	Xử lý tập hợp quy trình công việc đa dạng — từ các cửa hàng truyền thống đến chuỗi cung ứng cho đến các Tổ chức tự trị phi tập trung (DAO).

Hợp đồng thông minh đang trở nên phổ biến, là sức mạnh của các mạng lưới kinh doanh của tương lai. Chúng có thể thay thế bất kỳ sản phẩm quản lý quy trình kinh doanh SaaS tập trung nào.
Hướng tiếp cận của Toolblox
Toolblox đã phát triển trình tạo hợp đồng thông minh dựa trên quy trình làm việc siêu đơn giản để giúp các công ty nhanh chóng mang mang doanh nghiệp của họ lên blockchain: xây dựng quy trình làm việc và triển khai nó như một ứng dụng có thể sử dụng được.

 	Không cần lập trình: Người ta luôn có thể đầu tư vào một nhóm phát triển hoặc thuê các chuyên gia lập trình nên những quy trình công việc tùy chỉnh. Nhưng đối với 90% doanh nghiệp nhỏ và siêu nhỏ, tổ chức phi lợi nhuận, DAO, v.v. - họ chỉ muốn tập trung vào cách tiếp cận trực quan và không cần quá nhiều kiến thức lập trình. Khoản đầu tư ban đầu sẽ ít hơn, linh hoạt hơn, tạo mẫu sản phẩm và đưa ra thị trường nhanh hơn.
 	Quy trình làm việc dựa trên máy trạng thái: Blockchain không phải là về dữ liệu (data), mà là về trạng thái (state), đặc biệt là về chuyển đổi trạng thái (state transitions) — các điểm nối nơi giá trị được chuyển giao — cho dù là tiền thật, quyền sở hữu hay cả hai. Đây là cốt lõi của bất kỳ quy trình kinh doanh hoặc hợp đồng nào. Quy trình làm việc theo máy trạng thái(state machine workflow) cũng được đề xuất bởi Hyperledger Foundation, rất phù hợp để trực quan hóa hợp đồng thông minh. Bạn có thể tìm hiểu thêm về trình tạo quy trình công việc của chúng tôi tại một cách trực quan tại đây.
 	Giao diện người dùng đột phá: Thật tuyệt vời khi có thể tạo ra các hợp đồng thông minh tùy chỉnh một cách dễ dàng nhưng người dùng hay các đối tác kinh doanh cũng cần phải dễ dàng tương tác với những hợp đồng này. Toolblox có tính năng giúp tự động tạo một ứng dụng đơn giản. Đối với các giao diện người dùng và tùy chỉnh phức tạp hơn, chúng tôi có trình tạo DApp cho phép thiết kế một ứng dụng phi tập trung mà không cần lập trình. Chi tiết hơn về trình tạo DApp tại đây.
 	Tích hợp vào hệ sinh thái: Có nhiều tùy chọn để tích hợp với các dịch vụ bên ngoài (chẳng hạn như bảo hiểm token, tài sản thế chấp, chợ NFT, phân đoạn hóa NFT, v.v.):

 	Mọi quy trình công việc (workflow) đều có thể tương thích với ERC721
 	ERC20 tokens (ví dụ USDT, USDC, EURC, …) có thể được sử dụng làm phí thanh toán
 	Các event trên blockchain có thể được sử dụng để tích hợp và tùy chỉnh
 	Có thể tích hợp vào các ứng dụng mạng xã hội phi tập trung



Toolblox phù hợp cho những đối tượng nào?

 	Các tổ chức tự trị phi tập trung đang tìm cách quản lý các dự án và quy trình công việc tùy chỉnh.
 	Chuỗi cung ứng và các ngành liên quan đến hàng hóa để xử lý các nhiệm vụ từ sản xuất đến bán lẻ và kinh doanh.
 	Các doanh nghiệp nhỏ và siêu nhỏ thiếu bí quyết chuyên môn sẽ được hưởng lợi từ giải pháp toàn diện mà Toolblox mang tới (quản lý trạng thái hợp đồng thông minh, logic nghiệp vụ và thanh toán).

Những lý do mà bạn nên sử dụng Toolblox

 	Công cụ số hóa — giúp xây dựng quy trình kinh doanh trên blockchain và chia sẻ ứng dụng với người dùng và đối tác.
 	Công cụ tạo mẫu nhanh — giúp tiết kiệm thời gian tạo ra các DApp có thể sử dụng và chia sẻ để giải quyết một vấn đề cụ thể.
 	Công cụ khởi động phát triển — giúp tạo một bản dự thảo hợp đồng thông minh và sau đó phát triển nó hơn nữa bằng các công cụ tùy chỉnh.
 	Xương sống của một sản phẩm hiện có — giúp kết nối một sản phẩm hiện có để sử dụng blockchain như một nguồn dữ liệu an toàn và bất biến.

Một số ví dụ
Dưới đây là một số ví dụ về các quy trình, DApp đã được xây dựng sử dụng Toolblox. Mỗi quy trình sẽ bao gồm những thành phần sau:

 	Item - Các đầu mục (dự án, tài liệu, ưu đãi, đề xuất, v.v.)
 	Item attributes - Thuộc tính của mỗi đầu mục (tên, thời hạn, tác giả, chủ sở hữu, khách hàng, v.v.)
 	Workflow states - Trạng thái quy trình làm việc (đang hoạt động, đã hủy, đang chờ phản hồi, v.v.)
 	State transitions  - Chuyển đổi trạng thái (sửa đổi, thanh toán, khởi tạo, đồng ý, cập nhật, v.v.)

Tất cả các dự án sau đều có thể sử dụng dưới dạng DApp và có thể được sử dụng làm mẫu để tạo hợp đồng thông minh mới.
DAO gây quỹ cho các dự án

Chi tiết hơn về quy trình tạo DAO gây quỹ tại đây.
Đăng ký đám cưới phi tập trung

Chi tiết hơn về quy trình Đăng ký đám cưới phi tập trung tại đây.
Hỏi đáp nhận thưởng (AMA)

Chi tiết hơn về quy trình ứng dụng Hỏi đáp nhận thưởng tại đây.
Quy trình thẩm định bất động sản

Chi tiết hơn về Quy trình thẩm định bất động sản tại đây.
Đăng ký nhận ưu đãi in 3D

Chi tiết hơn về quy trình Đăng ký nhận ưu đãi in 3D tại đây.

Bạn hãy ghé qua trang web và Twitter của chúng tôi tại www.toolblox.net và Twitterđể biết thêm nhiều ví dụ khác!

Ngoài ra, hãy tham gia academy.toolblox.net để xem thêm các hướng dẫn và tài liệu về cách xây dựng bằng Toolblox!

### O que é votação Quadrática e financiamento Quadrático?

Se você é um indivíduo interessado em governança descentralizada, pode ter se deparado com palavras como “votação quadrática” e “financiamento quadrático”. Embora alguns possam considerá-los como clichês, esses conceitos ganharam uma considerável força nos últimos anos. Houve vários casos em que ambos foram implementados, obtendo um alto grau de sucesso. A votação quadrática foi usada para votar em projetos vencedores durante o Hackathon Presidencial de Taiwan. Vimos o sistema ser usado novamente quando o Partido Democrata do Colorado o usou para determinar sua plataforma partidária. Por outro lado, o financiamento Quadrático foi usado pelo Gitcoin Grants (subvenção) para financiar bens públicos no ecossistema Ethereum.

Ambos os conceitos, segundo seus proponentes, têm o potencial de revolucionar a forma como as decisões são tomadas. A implementação final desses conceitos poderia ser, nas palavras de Vitalik Buterin, “profundamente transformadora como o advento da era industrial de mercados predominantemente livres e democracia constitucional”. O hype não é sem motivo, como este artigo explicará, analisando os dois conceitos e suas aplicações e benefícios.

Comecemos com a votação quadrática
O problema com os modelos de governança.
Os modelos de governança utilizados pelas plataformas blockchain estão se tornando cada vez mais cruciais, com sua capacidade de impactar a participação do usuário, eficiência da plataforma e atratividade. Uma das maiores preocupações que as blockchains tinham quando se tratava de governança era o potencial para o surgimento de posições dominantes. Tais “posições dominantes” seriam constituídas por usuários que teriam, sob seu controle, um grande número de votos ou até mesmo a maioria dos votos. Isso daria a esse grupo de usuários um controle sem precedentes sobre os assuntos relacionados à evolução das plataformas.

Tal concentração de poder de voto pode desestimular usuários com menor número de votos a participar de mecanismos de governança ou até mesmo forçá-los a abandonar totalmente a plataforma. A promessa e o potencial da tecnologia e plataformas blockchain só podem ser cumpridos se for dada atenção cuidadosa aos mecanismos de governança dessas plataformas. Tal concentração de votos e poder de votação, sem dúvida, suscitaria preocupação a outros na plataforma. No entanto, um novo método de votação, que nos últimos tempos encontrou utilidade em decisões sociais, está surgindo como uma possível solução para o dilema que assola as plataformas blockchain.
Votação Quadrática: o caminho matemático para uma votação mais justa.
A votação quadrática é um mecanismo de decisão coletiva que permite um melhor caminho para a tomada de decisões, evitando assim a chamada “tirania da maioria”. Foi proposto pela primeira vez pelo economista político Glen Weyl e permite que os participantes expressem a direção de suas preferências, o grau de suas preferências e que tão firmes se sentem com respeito a tais decisões. Com isso, se espera abordar a questão do governo da maioria e proteger os interesses de grupos menores de eleitores que se preocupam profundamente com questões específicas. A votação quadrática permite que os usuários “paguem” por votos adicionais sobre um determinado assunto, permitindo assim que eles expressem seu apoio de maneira mais decisiva em questões específicas.

Enquanto uma pesquisa regular pode perguntar se você concorda ou discorda de um determinado conjunto de questões, a votação quadrática dá aos eleitores um orçamento de “créditos de voto” que eles podem gastar para concordar ou discordar de questões. Os eleitores podem votar múltiplas vezes, mas cada voto subsequente custaria mais créditos do que o anterior. Esse tipo de mecanismo de votação pode ser utilizado em diferentes áreas, como instituições democráticas, governança corporativa e tomada de decisão coletiva habilitada pela blockchain.




	

	
	
		
			
				A votação quadrática foi proposta pela primeira vez por:
			
		

		
					

		
			
			
			
			Vitalik Buterin
		
			
			Glen Weyl
		
			
			Zoe Hitzig
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como funciona a votação quadrática?
Agora vamos dar uma olhada em como funciona a votação quadrática. A votação quadrática é baseada em princípios de mercado, com cada eleitor recebendo um orçamento de créditos de voto que eles podem gastar para influenciar o resultado das principais deliberações. Se um eleitor apoiar ou se opor fortemente a uma decisão específica, ele pode alocar votos adicionais para demonstrar o nível de seu apoio ou oposição a uma decisão específica. O custo dos votos adicionais é determinado por uma regra de precificação de votos, com cada voto se tornando mais caro que o anterior. O aumento do custo do crédito do eleitor demonstra o grau de apoio ou oposição a uma determinada decisão.

A votação quadrática usa uma fórmula simples, custo para o eleitor = (número de votos)2

Vamos entender isso melhor com a ajuda de um exemplo. Suponhamos  que um eleitor tenha um orçamento de 16 créditos de voto e tenha a liberdade de usar um crédito para 16 questões diferentes nas quais ele pode votar. No entanto, se o eleitor tiver uma opinião mais forte sobre uma questão específica, poderá alocar quatro votos para essa questão ao custo de todo o orçamento. Os quatro votos custam todos os 16 créditos de voto porque o custo de cada voto adicional torna-se mais caro quadraticamente. Assim, 1 voto custaria 1 crédito, 2 votos custariam 4, 3 votos custariam 9 e o 4º voto custaria 16.

Esse mecanismo foi visto como uma potencial solução para resolver problemas de governança que as plataformas e comunidades de blockchain  enfrentam, impedindo assim que um único grupo assuma o controle e também protegendo os interesses de grupos minoritários. Os tokens lançados como votos são distribuídos igualmente entre os eleitores ao final de cada ciclo de governança. Um grupo levaria vários ciclos de votação e custos significativos para assumir o controle de uma plataforma.

Mas como a votação quadrática se compara a outros mecanismos de votação estabelecidos? Existem outros três mecanismos democráticos principais de votação:

- Sistemas de Pluralidade
- Sistemas de representação proporcional
- Sistemas semi-proporcionais
Sistemas de Pluralidade
Nos sistemas de votação pluralista, vence a eleição o partido ou cargo que receber mais votos, valendo-se do mecanismo “um voto, um eleitor”. No entanto, os sistemas de votação plural não podem garantir que os eleitores possam expressar seu nível de apoio a uma causa ou questão específica, nem alocar seus votos para expressar o grau de apoio.
Sistemas de representação proporcional
Esse método de votação é visto principalmente nas legislaturas nacionais, onde garante que a divisão de um corpo eleito reflita a divisão de votos no eleitorado. Embora esse método de votação reflita melhor o ponto de vista dos eleitores, ele falha em representar o quão decididos se sentem os eleitores sobre sua posição sobre as questões.
Sistemas semi-proporcionais
Existem vários tipos de sistemas de votação semi-proporcionais. No entanto, nenhum deles esclarece o grau de preferência ou oposição dos eleitores às questões.

Financiamento Quadrático: Uma Nova Forma de Financiar Bens Públicos.
Vamos passar para o financiamento quadrático. O financiamento quadrático é um dos experimentos socioeconômicos mais inovadores do ecossistema criptográfico. Tem sido apresentado como uma maneira matematicamente ótima de financiar bens públicos em comunidades democráticas, ampliando as doações feitas por uma grande comunidade sobre as contribuições feitas por grupos pequenos porém com grandes capitais monetários. Mas fica a pergunta: Como definir o que são bens públicos?

Bens públicos são definidos como mercadorias ou serviços que estão disponíveis para todos os membros da sociedade. Esses produtos devem ter as seguintes qualidades:

- Sem rivalidade – Isso significa que o uso desses bens por um membro não diminui sua disponibilidade para outros membros.
- Não excludente – Esses bens devem ser acessíveis a todos.

O financiamento quadrático foi descrito por Vitalik Buterin, Zoe Hitzig e Glen Weyl em um trabalho de pesquisa publicado em 2018. No entanto, para fins de uma melhor compreensão, devemos simplificar o conceito. A força motriz por trás do financiamento Quadrático é seu pool de correspondência, um pool de fundos fornecido por indivíduos, empresas e protocolos conhecidos coletivamente como parceiros de correspondência. Os fundos arrecadados no pool correspondente são usados ​​para ampliar as contribuições de projetos individuais. Vejamos um exemplo rápido para entender melhor o conceito.

Vamos supor que temos US$ 10.000 em um pool correspondente e três projetos participando de uma rodada de financiamento. O Projeto A recebe $ 1.000 em financiamento de 5 contribuidores que contribuem com $ 200 cada. O Projeto B recebe $ 1.000 de 2 contribuidores, cada um contribuindo com $ 500. O Projeto C também recebe $ 1.000, mas de 20 contribuidores, cada um contribuindo com $ 50. Agora, os valores correspondentes são calculados usando a fórmula de financiamento quadrática. Seguindo a fórmula, o primeiro projeto recebe um adicional de $ 1.851,85, 185% a mais do que o valor contribuído. O segundo projeto recebe US$ 740,74, um adicional de 74% das contribuições totais, enquanto o terceiro recebe US$ 7.407,41 do financiamento correspondente, impressionantes 740% da contribuição original.

Vejamos então como a fórmula chega a esses valores.

- Indivíduos, empresas e protocolos contribuem para os projetos (A, B, C).
- Vamos começar com o projeto A. Depois que a rodada de financiamento foi concluída, a raiz quadrada de cada contribuição foi adicionada e a soma resultante foi elevada ao quadrado. Vamos supor que esta seja a variável de Financiamento Quadrático.
- O mesmo processo é repetido nos Projetos B e C.
- A participação do projeto A no pool é calculada como a média ponderada de sua variável de financiamento quadrático.
- Os projetos B e C também receberam sua parte do pool seguindo o mesmo modelo matemático.
Benefícios do Financiamento Quadrático.
O Financiamento Quadrático ajuda a resolver um problema chamado “Tragédia dos Bens Comuns.” Este é um problema econômico em que cada indivíduo tem o incentivo de consumir recursos às custas de outros, sem nenhuma forma de excluir ninguém de consumir o recurso, levando ao consumo excessivo e ao esgotamento dos recursos. O financiamento quadrático enfatiza o número de doações e não o tamanho da doação. Projetos que trazem mais doações são representativos de bens públicos que atendem a um grupo maior de usuários, tornando a tragédia dos comuns ainda mais grave.

Como resultado, supõe-se que os projetos que atendem a um grupo mais extenso sejam apoiados por mais doadores, resultando em maiores doações do pool correspondente. É por isso que o projeto C recebeu o maior financiamento em nosso exemplo anterior.




	

	
	
		
			
				O Financiamento Quadrático faz énfasis em qual das seguintes opções?
			
		

		
					

		
			
			
			
			O número de doadores
		
			
			O tamanho das doações
		
			
			Ambas respostas anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de uso de Votação Quadrática e Financiamento Quadrático.
A Câmara Legislativa do estado do Colorado usou a votação quadrática para decidir quais projetos de lei de apropriação devem ser financiados pela Câmara em primeiro lugar. Com legislaturas mais propensas a patrocinar seus próprios projetos de lei e votar neles, os democratas usaram a votação quadrática para determinar quais projetos de lei tinham apoio geral. Cada legislatura recebeu um orçamento de 100 créditos, onde um voto lhes custaria um token. No entanto, as legislaturas podem lançar mais votos em uma questão, com o custo de cada voto aumentando quadraticamente, conforme mostrado abaixo.

O Hackathon presidencial de Taiwanês também foi julgado por votação quadrática.

Quando se trata de Financiamento Quadrático, o exemplo mais proeminente é o de Gitcoin, que utiliza o método para arrecadar fundos. O Gitcoin permite que a comunidade crie e financie projetos e tem apoiado vários projetos, incluindo Uniswap, Finematics, Kickback, e outros. Vitalik Buterin usa o Gitcoin Grants para descobrir novos projetos, enquanto Andre Cronje usou-o para financiar a Yearn Finance.




	

	
	
		
			
				Onde o conceito de Votação Quadrática foi colocado em prática?
			
		

		
					

		
			
			
			
			Câmara Legislativa do Estado de Colorado
		
			
			Hackathon presidencial Taiwanês
		
			
			No partido alemão Volt durante seu segundo congresso
		
			
			Todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Para finalizar

Tradicionalmente, as democracias modernas têm usado o método de uma pessoa para um voto, enquanto as corporações adotaram mecanismos de votação um pouco mais sofisticados. No entanto, sistemas de votação mais democráticos, como votação por escolha classificada e votação proporcional, não conseguiram ganhar força devido à complexidade envolvida. A Votaçao Quadrática, Ao permitir que os eleitores expressem suas preferências e a intensidade dessas preferências, ajuda a proteger os interesses de grupos minoritários dentro das comunidades.

Financiamento Quadrático, embora seja um conceito relativamente novo, teve um impacto considerável, com mais de US$ 2 milhões distribuídos para bens públicos. Um número crescente de projetos está explorando o financiamento Quadrático, sendo os principais Gitcoin Grants, clr.fund e Downtown Stimulus. No entanto, ambos os conceitos têm o potencial de mudar radicalmente como os protocolos blockchain são governados e financiados.




	

	
	
		
			
				Quais são os projetos mais proeminentes que exploram o financiamento Quadrático?
			
		

		
					

		
			
			
			
			Gitcoin Grants
		
			
			Clr.fund
		
			
			Downtown Stimulus
		
			
			Todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Agora vamos provar IRL – Faça o seu Quadrático dizer, (L)Earner!

### Toolblox, a ferramenta para elaborar contratos inteligentes sem código

Toolblox é um elaborador de contratos inteligentes sem código e criador de DApp. Nesta postagem, pretendemos desvendar tudo o que estamos fazendo e por que é tão importante.

Imagen de fluxo de trabalho e a interface de usuário gerada automaticamente
Breve história
O projeto começou no início de 2022 como um competidor no hackathon da Near Metabuild II. E conseguiu ganhar o grande prêmio que serviu de capital semente. Toolblox ganhou outros prêmios ao longo do ano, como o de melhor “Tooling & Infrastructure” (ferramental e infraestrutura)  no hackathon de Polygon BUIDL IT.

Desde a primeira versão, a interface do usuário foi simplificada 1000% e um criador DApp também foi adicionado. Embora originalmente suportasse apenas uma blockchain, cinco mais foram adicionados.

O Toolblox está prestes a completar 1 ano e aqui estamos para desvendar e compartilhar com o mundo.
Contratos inteligentes autoexecutáveis
Contratos Inteligentes são acordos autoexecutáveis codificados como programas de computador. Quando uma determinada ação é desencadeada, eles podem agir de forma imediata, como por exemplo liquidar pagamentos ou transferir a propriedade. Isso é possível porque na blockchain não há necessidade de uma autoridade central, as assinaturas digitais são empregadas e ademais o estado do programa é imutável.

Os contratos inteligentes autoexecutáveis estão, portanto, posicionados de maneira única para:

 	Infundir confiança, justiça e transparência em qualquer sistema ou processo existente.
 	Eliminar os intermediários e a agência centralizada.
 	Lidar com diversos conjuntos de fluxos de trabalho - desde lojas físicas a cadeias de suprimentos e organizações nativas digitais chamadas Organizações Autônomas Descentralizadas ou DAOs.

O contrato inteligente será onipresente, alimentando as redes de negócios do futuro. Eles podem e devem substituir a coluna vertebral de todo e qualquer produto de gerenciamento de processos de negócios SaaS centralizado.
Nossa perspectiva
O Toolblox fornece um criador de contratos inteligentes super simples baseado em fluxo de trabalho para ajudar as empresas a criar rapidamente sua presença na blockchain: crie um fluxo de trabalho e implante-o como um aplicativo utilizável.

 	Sem código.
Pode-se sempre investir em uma equipe de desenvolvimento ou contratar profissionais para codificar um fluxo de trabalho personalizado. Mas, para o resto (90% das pequenas empresas e microempresas, assim como organizações sem fins lucrativos, DAOs etc), que desejam apenas manter o foco, uma abordagem visual sem código é o caminho a seguir. Menos investimento inicial, mais flexibilidade, prototipagem rápida e lançamento mais rápido no mercado.
 	Fluxo de trabalho baseado em máquina de estado.
Blockchain não é sobre dados, é sobre estado, especialmente sobre transições de estado – as junções onde o valor é transferido – seja dinheiro real, propriedade ou ambos. A base fundamental de qualquer processo comercial ou contrato. Proposto também pela Fundação HyperLedger, um fluxo de trabalho de máquina de estado é uma ótima opção para a visualização de contratos inteligentes. Saiba mais sobre o nosso criador de fluxo de trabalho.
 	Interface de usuário pronta para uso.
Embora seja ótimo poder criar contratos inteligentes personalizados com facilidade, eles também precisam ser utilizáveis - seja para compartilhar com usuários finais ou para envolver parceiros de negócios. É por isso que o Toolblox gera um aplicativo simples automaticamente. Para interfaces de usuário e personalização mais complexas, temos o construtor DApp, que permite projetar um aplicativo descentralizado sem nenhum código.
Saiba mais sobre o nosso criador DApp.
 	É integrado com o ecossistema.
Tem muitas opções para integração com serviços externos (como seguro de token, colateralização, portais NFT, fracionamento etc):
 	– Cada fluxo de trabalho pode ser compatível com ERC721.
–Tokens ERC20 (como USDT, USDC, EURC etc) podem ser usados ​​como pagamentos.
– eventos blockchain podem ser usados ​​para maior integração.
– integração de mídia social descentralizada.

E para quem o Toolbox está dirigido?

 	Organizações Autônomas Descentralizadas que procuram gerenciar fluxos de trabalho e projetos personalizados.
 	Cadeia de suprimentos e mercadorias, relacionadas a indústrias, para lidar com tarefas que vão desde a produção até o comércio e varejo.
 	Micro e pequenas empresas que carecem de know-how (experiência e conhecimento) especializado e seriam beneficiados com uma solução full stack (estado, lógica e pagamentos).

Por que alguém usaria o Toolblox?
Aqui estão algumas características para ter o Toolblox em mente para qualquer organização:

 	Ferramenta de digitalização — para construir um processo de negócios na cadeia e compartilhar o aplicativo com sócios e usuários.
 	Ferramenta de prototipagem rápida — para criar DApps utilizáveis e compartilháveis para resolver um problema específico.
 	Botão de arranque do desenvolvimento — para criar um rascunho de contrato inteligente e depois desenvolvê-lo ainda mais com recursos personalizados.
 	Suporte principal para um produto existente — para conectar um produto existente para usar a blockchain como uma fonte única de dados com um estado imutável e seguro.

Exemplos de fluxo de trabalho
Aqui estão alguns fluxos de trabalho/DApps criados com o Toolblox. Cada fluxo de trabalho consiste nos seguintes elementos:

 	Item (projeto, documento, oferta, proposta etc.)
 	Atributos do item (nome, prazo, autor, proprietário, cliente etc.)
 	Estados do fluxo de trabalho (ativo, cancelado, aguardando comentários, etc.)
 	Transições de estado (alterar, pagar, criar, concordar, atualizar, etc.)

Todos os projetos a seguir podem ser usados como uma DApp e podem ser usados como modelo para criar novos contratos inteligentes.
DAO arrecadação de fundos para projetos

Resumo da arrecadação de fundos DAO (toolblox.net)
Registro de casamento distribuído

Resumo do registro de casamento distribuído (toolblox.net)
Pergunte-me qualquer coisa (AMA) com recompensa

Resumo da plataforma AMA com exemplo de recompensa (toolblox.net)

Fluxo de trabalho de avaliação imobiliária


Resumo do fluxo de trabalho de avaliação de preços de imóveis (toolblox.net)
Ofertas de preço de impressão 3D e gerenciamento de impressões

Resumo do registro de oferta de impressão 3D (toolblox.net)

Confira nossa web www.toolblox.net e o nosso Twitter para mais exemplos! Una-se também a academy.toolblox.net para tutoriais e documentação sobre como construir com Toolblox.

### Update - March 28, 2023

Brief Summary:

 	
👉March Redeem to NEAR window was a blast! 334 (L)Earners successfully claimed!
(L)Earning is fun and rewarding!🕺


Results:

 	🏗️Another project from LNC Barrel is being audited by @pessimistic_io
 	🕺Holders of (L)Earner NFT get early access to learning materials
 	🧪 We improved award distribution for Beta test for Pikespeak. $NEAR 180 were claimed by 29 testers! 
 	 (L)Earn "What is Pikespeak?"
 	🚀WordPress plugin "Login with NEAR" downloaded over 300 times already and counting!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Everyone is invited to NEAR Certified Developer Demo day on March 31, 11 am EDT.

### Liberdade no mundo digital: é alcançável

Hoje, quando nossa vida cotidiana está se tornando cada vez mais digital, as pessoas começaram a entender que alguns de seus bens neste novo mundo são valiosos.

Diversas informações de contas, personagens de jogos, assinaturas, ingressos para acesso a eventos físicos e digitais e associação a algum clube: temos cada vez mais coisas importantes e de grande valor. E às vezes até as coisas ligadas ao sucesso ou segurança na vida. É uma sensação nova para muitos de nós entender que você depende significativamente de “uma informação” armazenada em algum lugar e estamos ficando desconfortáveis na tentativa de gerenciar tudo bem. A maioria de nós acaba armazenando essas coisas em um arquivo na nuvem ou em uma carteira proprietária como a Apple.

É raro perceber que aqueles  lugares considerados seguros não são tão seguros quanto pensamos. Primeiro, eles não nos pertencem e não são geridos por nós. Em segundo lugar, eles são menos acessíveis do que pensávamos. Basta mudar dos EUA para a China e você perceberá que a maioria dos seus pertences armazenados no Google não estão mais acessíveis. Para quem pensa um pouco mais, parece claro que no mundo digital, nada realmente pertence a você quando é armazenado em algum tipo de nuvem ou simplesmente desconhecido por seus servidores: o servidor pode desaparecer, serviço que você está usando para acessar as informações também pode desaparecer, também as informações podem ser alteradas pelos administradores do servidor ou como resultado da intervenção maliciosa.

OK. Parece não haver muitas possibilidades de realmente possuir algo no mundo digital. Mas precisamos disso? Provavelmente não. Ao mesmo tempo, acredito pessoalmente nas palavras de George Washington:

A liberdade e os direitos de propriedade são inseparáveis. Você não pode ter um sem o outro.

O que é um motivador perfeito para eu procurar melhores possibilidades de direitos de propriedade digital do que tínhamos antes.

Surpreendentemente, a resposta é bastante simples e bastante interessante: a tecnologia que costumamos pensar como “a tokenização de todos os tipos de arte” é perfeitamente capaz de facilitar o armazenamento auto-soberano de direitos de propriedade digital.

Sim, estou falando de NFT. Ao atribuir um NFT a qualquer informação, podemos definir o preço inicial e a propriedade dessa peça. E ficará guardado na carteira do proprietário para ser utilizado caso seja necessário para qualquer tipo de demonstração, ou apresentações no ponto de checagem. E as evidências de nossa propriedade são armazenadas de maneira descentralizada, o que evita qualquer tipo de alteração não autorizada de informações e facilita a resiliência necessária: podemos ter certeza de que pelo menos parte da rede descentralizada permanecerá acessível, o que significa ainda fornecer ao solicitante as informações sobre o fato de o proprietário do imóvel ainda ser o proprietário.

Vamos olhar mais amplamente: ao “NFTizar” qualquer tipo de informação estamos permitindo a interoperabilidade entre vários sistemas de informação, soluções de TI, metaverso e jogos: para acessar os dados, basta solicitar a carteira do proprietário sobre o provisionamento de certos NFTs e seus parâmetros de utilidade. Além disso, podemos usar esses parâmetros para qualquer tipo de verificação, cálculo ou visualização simples.

Então, vamos resumir: o NFT é perfeito para representar a propriedade no mundo digital: tem o preço, o proprietário e a propriedade real dos dados que o proprietário está reivindicando e, além de tudo isso, pode ter representação visual ou de áudio, tornando a posse reconhecível.

Para muitos de nós, também permitirá o desenvolvimento da conexão emocional que é frequentemente desenvolvida por meio da representação visual. Portanto, NFT é algo bom e negociável, permitindo-nos reivindicar nossos direitos no novo mundo digital.

### Como a Prova de Conhecimento Zero (Zero Knowledge) pode garantir a privacidade dos dados

Você provavelmente já se deparou com as expressões “se é grátis, você é o produto” ou “dados são o novo petróleo” e riu como se isso fosse um ditado bobo. A verdade é que os dados são a força motriz por trás de quase todos os negócios e serviços. Por exemplo, experiências e serviços personalizados, marketing e uma série de outros insights e serviços dependem do volume e da qualidade dos dados fornecidos a eles. A maioria das empresas está ansiosa para acessar dados para ajudar a entender melhor seus clientes, prever padrões de comportamento do cliente e melhorar a qualidade de seus serviços.

O ambiente da internet tradicional sempre esteve sujeito a preocupações em torno de dados e privacidade. Os defensores da privacidade há muito sinalizam preocupações sobre como os dados são armazenados, como são acessados ​​e quem tem acesso a eles. Com o crescimento do ecossistema de criptomoedas e blockchain, preocupações semelhantes também surgiram neste setor. A natureza pública das blockchains introduziu várias preocupações de privacidade para os usuários em relação à proteção de suas informações pessoais. Este artigo examinará mais de perto o problema de privacidade em blockchains e como as provas de Zero Knowledge (ZK) podem mitigá-los.
O que é privacidade de dados?
O aumento do uso da Internet trouxe a questão da privacidade de dados para o mainstream, com quase todos os sites, aplicativos e plataformas de mídia social coletando e armazenando informações pessoais dos usuários para fornecer determinados serviços. No entanto, essas plataformas e sites geralmente não possuem proteções adequadas para proteger os dados coletados, resultando em inúmeras violações de dados.

Com o crescimento da tecnologia blockchain e do ecossistema criptográfico, as preocupações são crescentes sobre a privacidade de usuários institucionais e de varejo. Essas preocupações se devem principalmente à natureza pública das blockchains, com a maioria das opções de Camada 1 e Camada 2 não abordam essas questões. Privacidade de dados refere-se à capacidade dos usuários de determinar, por sua vez, quando e como suas informações são compartilhadas com outras pessoas. Também abrange a capacidade dos usuários de ditar até que ponto seus dados são compartilhados. Essas informações podem incluir seus nomes, localização, informações de contato, comportamento online, o que você gosta, o que não gosta, detalhes de transações e muito mais.
Confiança, Privacidade e Blockchain
Atualmente, o ecossistema de criptomoedas está passando por uma reviravolta considerável após o colapso de grandes projetos como FTX. No entanto, a tecnologia subjacente que suporta criptomoedas tem o potencial de revolucionar a privacidade, a confiança e como ela é alavancada. Isso é crítico na era da Internet, quando milhões navegam e compartilham grandes quantidades de suas informações pessoais para acessar serviços e produtos.

A tecnologia Blockchain vem inerentemente com problemas em torno da privacidade, graças ao seu design. A natureza descentralizada das blockchains significa que os nós que processam as transações ou informações têm acesso aos dados da blockchain. Por exemplo, a blockchain do Bitcoin está disponível publicamente e pode ser acessada por qualquer pessoa que deseje verificar seu histórico de transações até seu bloco de gênese. Agora, lembre-se, Bitcoin é pseudo-anônimo, o que significa “[dados] que não estão diretamente associados a um indivíduo específico [mas onde] várias aparências de [uma] pessoa podem ser ligadas”.

Dados pseudo-anônimos suficientes tornam possível identificar os indivíduos por trás das transações, o que é preocupante para os usuários do blockchain, e há vários motivos para isso. Ao contrário dos dados usados ​​por aplicativos comuns, acessíveis apenas a alguns, os dados do blockchain podem ser examinados por todos, o que também inclui atores e entidades mal-intencionadas que podem explorar as informações da blockchain para seu benefício próprio. Além disso, a natureza imutável da blockchain significa que as transações e os dados estarão permanentemente vinculados ao indivíduo. Isso pode ser feito monitorando a comunicação entre os nós. Além disso, carteiras criptográficas também podem ser analisadas sem acesso a chaves privadas, complicando ainda mais as coisas.

Um exemplo de destaque do uso de dados blockchain para rastrear um indivíduo foi a investigação e prisão de Ross Ulbricht, o indivíduo por trás do infame site darknet “Silk Road”, que foi usado para várias atividades ilegais. As agências de aplicação da lei identificaram Ulbricht como o indivíduo por trás do Silk Road, graças aos dados da blockchain. Além disso, eles poderiam rastrear transações de Bitcoin e determinar que um agente da US Drug Enforcement Administration (DEA) estava lavando BTC conectado ao Silk Road. Nesse caso, as agências de aplicação da lei conseguiram rastrear os dados disponíveis na blockchain para identificar um indivíduo. Mas imagine se entidades maliciosas pudessem rastrear seus dados com tanta facilidade graças à natureza pública do blockchain. Os resultados seriam devastadores.
Apresentando as Provas de Conhecimento Zero (Zero Knowledge ou ZK)
As Provas de Conhecimento Zero foram discutidas pela primeira vez por Silvio Micali,Shafi Goldwasser, e Charles Rackoff em um artigo intitulado “A Complexidade de Conhecimento de Sistemas de Provas Interativas”, e são considerados uma fascinante inovação da criptografia que pode ser utilizada em diversos cenários. No caso da blockchain, pode ajudar a permitir transações seguras e anônimas. O Zero Knowledge Proof (Prova de Conhecimento Zero), também conhecido como Zero Knowledge Protocol, permite que uma parte (o provador) prove à outra parte (verificador) que conhece um determinado valor ou informação (x) sem divulgar nenhuma informação além do fato de conhecer o valor ou informação em questão (x). O desafio quando se trata da Prova de Conhecimento Zero é justificar a posse da informação sem revelá-la ou qualquer outra informação adicional. Uma Prova de Conhecimento Zero deve satisfazer os seguintes critérios.

 	Integridade - Vamos supor que a afirmação seja verdadeira. Um verificador honesto, seguindo correta e fielmente o protocolo, será convencido pelas informações fornecidas pelo provador que está seguindo corretamente o protocolo.
 	Solidez – Solidez significa que não deve haver maneira de o provador falsificar qualquer informação ou convencer falsamente o verificador. A falsificação deve ser impossível.
 	Conhecimento Zero – Se a afirmação do provador for verdadeira, o verificador não aprenderá nada além do fato de que a informação é verdadeira.

As duas primeiras são consideradas propriedades mais gerais de sistemas de prova interativos, com a adição de conhecimento zero transformando o processo de verificação em uma prova de conhecimento zero. Devido a uma pequena possibilidade (erro de solidez) de que um provador malicioso possa convencer o verificador de uma declaração falsa, as provas de conhecimento zero são consideradas provas probabilísticas em vez de provas determinísticas. No entanto, o erro de solidez pode ser mitigado para um valor insignificante.




	

	
	
		
			
				Uma Prova de Conhecimento Zero deve atender a quais critérios?
			
		

		
					

		
			
			
			
			Integridade
		
			
			Solidez
		
			
			Conhecimento zero
		
			
			Todas as opções acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como funciona o ZKP?

Crédito da imagem

Uma Prova de Conhecimento Zero consiste em três ações que ocorrem sequencialmente entre os participantes. Essas ações são chamadas de testemunho, desafio e resposta. Vamos nos aprofundar um pouco mais para entender melhor o papel de cada ação, assumindo que há dois participantes, A e B.

Testemunho - Vamos supor que A conheça um valor ou informação específica, o que também determina um conjunto de perguntas. Essas perguntas sempre podem ser respondidas corretamente por A. Inicialmente, A pode escolher qualquer pergunta aleatória do conjunto, calcular a prova e enviá-la para B.

Desafio - Após a etapa de testemunho, vem a fase de desafio, onde B escolhe uma pergunta do conjunto e pede a A para respondê-la.

Resposta - A então calcula a resposta e a envia de volta para B. Isso permite que B determine se A realmente sabe a resposta.

O processo descrito acima pode ser repetido quantas vezes for necessário até que se estabeleça que A sabe a resposta correta e a probabilidade de palpites tornar-se baixa o suficiente.




	

	
	
		
			
				O artigo “The Knowledge Complexity of Interactive Proof Systems” foi escrito por
			
		

		
					

		
			
			
			
			Silvio Micali, Shafi Goldwasser, Charles Rackoff
		
			
			Silvio Micali, Charles Hoskinson, Charles Rackoff
		
			
			Vitalik Buterin, Shafi Goldwasser, Satoshi Nakamoto
		
			
			Charles Hoskinson, Satoshi Nakamoto, Vitalik Buterin
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de Uso de ZKP
O ZKP pode ser aplicado em vários cenários.
Sistemas de Autenticação
Os sistemas de autenticação têm desempenhado um papel crucial na promoção da pesquisa em Provas de Conhecimento Zero. Nesses sistemas, uma parte deseja provar sua identidade para uma segunda parte por meio de alguma informação secreta. No entanto, não deseja que a segunda parte obtenha qualquer conhecimento sobre essas informações secretas.
Confidencialidade
Um dos casos de uso mais significativos do ZKP ocorre em transações que exigem total confidencialidade. Vamos entender como. Considere uma blockchain como a do bitcoin. Geralmente, quando ocorre uma transação nesta blockchain, os dados relacionados à transação são registrados na blockchain. Isso significa que qualquer pessoa pode reunir algumas informações sobre a transação analisando os dados na blockchain. Por uma questão de privacidade, é fundamental ocultar alguns detalhes de transações específicas. O ZKP permite ocultar detalhes e, ao mesmo tempo, garantir a validade da transação, adicionando-os a um novo bloco.
Informações pessoais
Digamos que você queira fazer um empréstimo em um banco. Para solicitar o empréstimo, você deve fornecer uma série de documentos compostos por uma quantidade considerável de informações pessoais, disponibilizando-os a terceiros. No caso de obter um empréstimo de um banco, a única informação exigida pelo banco é saber se um indivíduo ganha uma quantia específica suficiente para pagar o empréstimo. O ZKP pode ajudar os bancos a verificar se um indivíduo ganha um valor mínimo predefinido sem revelar nenhuma informação confidencial ao banco ou a terceiros.
ZKP e Blockchain: o caminho a seguir
Vários projetos e criptomoedas utilizam ZKP, como ZCash, SmartCash, Zerocash e ZeroVert. O ZKP foi implementado principalmente por meio de zk-SNARKS e zk-STARKS.. zk-SNARKS foi originalmente desenvolvido pela ZCash. A maioria das blockchains é pseudo-anônima, o que significa que a identidade de um usuário pode ser rastreada até suas transações por meio do estudo dos dados da blockchain. Esta informação está disponível para todos com acesso ao blockchain e pode ser explorada por qualquer entidade maliciosa.

Apesar da reputação da blockchain como o auge da segurança cibernética, essa falha específica é bem conhecida dos usuários. No entanto, o ZKP pode ajudar a corrigir essa vulnerabilidade e garantir total privacidade quando se trata de informações pessoais. Embora o ZKP ainda tenha alguns desafios a serem superados, ele dá aos usuários o controle de seus dados e privacidade, limitando o acesso a terceiros, e desempenhará um papel crucial na melhoria da privacidade quando se trata de blockchains.




	

	
	
		
			
				Os ZKPs são utilizados por
			
		

		
					

		
			
			
			
			ZCash
		
			
			SmartCash
		
			
			Zerocash
		
			
			ZeroVert
		
			
			Todas as opções acima
		
	
		

		
		
			
				Correct!
				Wrong!

### Smart Contract Development on Near using Rust Part 1

On February 16, 2023 I gave a workshop at the University of Waterloo about smart contract development on Near using Rust. I enjoyed putting it together and I thought it would be fun to also present the content here as a series of blog posts. In this first post I’ll give an analogy to connect blockchain development to a pattern used in normal web applications, introduce the smart contract example we’ll be using throughout this series, and discuss some general principles of smart contract development that are unique to blockchain relative to other domains of programming.
A mental model for creating a distributed application (dapp)
The purpose of this section is to draw an analogy between developing on top of a blockchain (apps backed by blockchain technology are often called “dapps” in the space) and a more common technology for web apps that you may have encountered before. This analogy may be helpful when thinking about how users interact with smart contracts.

The idea is that dapps are very similar to web apps based on a “serverless architecture“. The term “serverless” is a little misleading because of course servers are still involved, but the reason for the name is that the underlying hardware (i.e. server) executing the code is abstracted away from the developer. This has benefits over other cloud computing infrastructure in terms of cost and scalability because you only pay for exactly what resources you use as opposed to paying to run a VM that may sit idle if traffic is low, or may become unresponsive if there is too much traffic. Each time a user interacts with the web app, a new instance of the “serverless function” is invoked on the backend to serve the user’s request without the developer having to think about exactly what hardware this function is running on.

Dapps abstract away hardware in a similar way. A smart contract is deployed to the blockchain and executed on the nodes (servers) that form the peer-to-peer network of that blockchain. When a user interacts with the dapp it makes a call to the blockchain (a transaction) to execute the smart contract. Each transaction creates a new instance of the smart contract (in the sense that there is no in-memory state that is persisted between transactions), just like with serverless functions.

Below is an image taken directly from the Amazon Web Services (AWS) website for Lambda (their version of a serverless compute offering).

It is easy to modify this image to see how the workflow in a dapp is similar.

Another similarity between serverless compute and smart contracts is the fact that each transaction has a cost to it. In the case of AWS the developer’s AWS account is charged for the resources consumed, whereas in the case of blockchain whoever signed the transaction is charged for its execution.

With this analogy as a reference point, let’s discuss the dapp development example we’ll be using throughout this series.
Our example: blockchain-based chat app
The example we will use throughout this series is a blockchain-based chat app. This is not a real-world example in the sense that there is not a good business case to use a public blockchain for chat (in my opinion). The fact that all the messages will be completely public and irreversibly included into a permanent record is a drawback, not a feature. However, the reason to choose this example is that it illustrates various important concepts in dapp development while being logically easy to follow for anyone that has used something like Facebook Messenger, Telegram, or Signal.

The code for this example is available on my GitHub. The README on that repository gives some instructions for setting up a development environment for interacting with the code and some basic idea of how to use the contract. This series of posts will be a much deeper dive into the code and how it works.

To ground the discussion of principles of smart contract development, here is an overview of how the chat contract works.

 	Each individual who wants to participate in the chat network deploys their own version of the smart contract.
 	Each instance of the contract maintains a list of accounts it knows about (contacts, pending contact requests, etc.). It also stores the messages it has received (and some metadata about those messages).
 	To send a message to someone else, you must first have them as a “contact”. This works as you would expect: Alice sends Bob a contact request, if Bob accepts then Alice and Bob become contacts of one another, otherwise they are not contacts.
 	Each instance of the contract has an “owner” who is able to send messages and send/accept contact requests.

Principles of smart contract development
There are three related concepts I want to emphasize that are important to smart contract development, but may not appear in typical software development. They are:

 	an adversarial mindset,
 	economics,
 	ensure invariants before making cross-contract calls.

An adversarial mindset
The first important thing to remember when deploying to a public blockchain is that anyone in the whole world can interact with your code. If there is some sensitive action your smart contract can take (for example when sending messages in the chat contract you wouldn’t want someone to be able to impersonate you) then you must explicitly check for authorization so that only authorized accounts can successfully perform the action (this is why our chat contract has the “owner” property). If you have any method that takes input then you must validate it before proceeding to any business logic because any random user could submit any input they like. Indeed, the idea of an adversarial mindset goes even further; not only might a user submit garbage input, but they might carefully craft input to trigger a vulnerability in your code. The only way to prevent this from happening is to not have such vulnerabilities in the first place.

Similarly, smart contract logic often depends on some protocol to coordinate different components together (for example the protocol to add contacts in our chat contract). Does a user have agency over in this protocol? What happens if they do not follow it correctly? These are questions that you must answer when developing a smart contract because hackers will be trying to exploit your contract.

Long story short, you should always assume that any external input is byzantine and explicitly verify otherwise before proceeding. You should practice noticing what assumptions you are making and always think “how could I break this assumption?” whenever you realize you are making one.
Economics
The economics of a typical web app are pretty simple. You need to generate enough revenue to cover the cost of hosting whatever server contains the code and data your app uses. The revenue you need to generate could come from a number of sources, but the most common are ad revenue and paid user subscriptions.

For blockchain the situation is a little more complicated because every single transaction needs to be paid for independently. Newer blockchain products are looking to simplify this story, for example Aurora+ provides something like a “blockchain subscription” which allows a number of transactions for free. But until this becomes standard in the blockchain space it’s still important to answer the question “who is paying for this?”.

Often it is the user who pays for each transaction because payment is tied to the signing account (i.e. payment is tied up with identity / authorization). An alternative model is to use “meta-transactions” (transactions within transactions) so that the payment is done by the “outer signer” while the authorization is based on the “inner signer”. This is how Aurora+ works for example. Unfortunately, since this is not the default way blockchain transactions operate it does require extra work on the developer’s part to make it happen.

For the sake of our chat app example, we will follow the path of least resistance and each user will have to pay for the costs they incur through their usage. After having made this decision, we need to review what possible costs there could be and make sure they are being covered appropriately. For example, on Near, storage payment is handled by “storage staking“. Essentially this means that each account has some of its balance locked depending on how much storage it is using. This is relevant in our chat contract because it stores messages received from other users, therefore we need to make sure those other users are covering the storage staking cost by attaching a sufficient deposit with their message. Similarly, contact requests create an entry in storage so those too must come with a deposit. If we did not enforce these deposit requirements then users could effectively steal money from one another by sending many messages and locking up the victim’s entire balance (notice how this ties in with the adversarial mindset above).

In summary, when designing a dapp it is always important to think about what costs will be involved and how they are being paid for, whether this means adding checks for deposits or using meta-transactions.
Ensure invariants before making cross-contract calls
This last point is subtle. In a typical application all code is linked into the same binary. When you call a function in a library, this is not usually triggering any communication, but rather just adding a new frame on the stack and executing some code from another part of the binary. In a blockchain setting things are a little different.

Making a call to another contract is more like performing a call to a whole other process than it is like calling a library. Again we must apply an adversarial mindset and realize that we have no idea what that other process might be doing; indeed, it might be trying to do something purposely malicious. A common attack vector is to have the other process call back into our contract and exploit it because our contract was not expecting a new call to come in while it was waiting for a response to the call it initiated. This is called a “reentrency attack” and it was the source of one of the most famous hacks on Ethereum, the one that resulted in “Ethereum Classic” being created (Ethereum classic rejected the “hard fork” that was the Ethereum Foundation’s response to the hack).

On Near this problem is even more pronounced because there is the additional issue of atomicity. In the Ethereum Virtual Machine (EVM) each transaction is “atomic” in the sense that all actions as a result of the transaction are committed to the blockchain state or none of them are (the whole transaction is “reverted”). This means a reentrancy attack can be thwarted by using a revert; everything that has happened will be undone, keeping the contract safe. This pattern is even included in the Mutex example in the official Solidity documentation. However, in Near’s runtime the execution of contracts is independent of one another; they are not atomic. So if a transaction causes contract A to call contract B, and B encounters an error then the state changes that happened in A will remain.

This has been a lot of history and theory, but what is the practical take-away? The point is that you must ensure your contract is in a “good state” when it makes a call to another contract. That is to say, if there are invariants your contract’s logic relies on then they must be correct at the time the call is made. As a simple example, suppose we have a contract with a transfer function. The invariant to maintain is that tokens are not created or destroyed in a transfer. If for some reason there needed to be a call to another contract during the transfer, it would be incorrect to debit one account and then make the call without crediting the other first. This is because the invariant about tokens not being destroyed would be broken when the external call was made and this might be exploitable. An example along these lines is also included in Near’s documentation.
Summary
Wrapping up, in this blog post we are introducing a new series of posts giving an introduction to smart contract development on Near using Rust. Here we discussed the chat contract example we will use throughout the series as well as some general principles to keep in mind when developing on blockchain-based applications. In the next post we’ll dive more into the code to discuss the technical details of how the contract is implemented. This will serve as an example of Near’s Rust SDK, illustrating concepts that will apply to all kinds of real-world contracts you may want to write.

If you are enjoying this series of blog posts please get in touch with us at Type-Driven consulting. We are happy to provide software development services for dapps, as well as training materials for your own engineers.

### Apa itu Quadratic Voting dan Quadratic Funding

Jika anda adalah seseorang yang tertarik dengan tata kelola terdesentralisasi, anda mungkin pernah menemukan kata-kata seperti “Quadratic Voting” dan “Quadratic Funding”. Sementara sebagian orang mungkin menganggap ini sebagai buzzwords, konsep-konsep ini telah mendapatkan daya tarik yang cukup besar selama beberapa tahun terakhir. Ada beberapa contoh di mana kedua hal ini telah diterapkan, dan bertemu dengan tingkat keberhasilan yang tinggi. Quadratic voting digunakan untuk memilih project yang menjadi pemenang selama Taiwanese Presidential Hackathon. Kami melihat bahwa system ini digunakan lagi oleh Partai Demokrat Colorado yang menggunakannya untuk menentukan platform partai mereka. Di sisi lain, Quadratic Funding digunakan juga oleh Gitcoin Grants untuk mendanai barang publik di ekosistem Ethereum.

Kedua konsep tersebut, menurut para pendukungnya, memiliki potensi untuk merevolusi cara pengambilan keputusan. Implementasi akhir dari kedua konsep ini dapat menjadi; dalam kata-kata Vitalik Buterin, “sangat transformatif seiring munculnya era industri dari pasar yang sebagian besar bebas dan demokrasi konstitusional.” Publisitas ini terjadi bukan tanpa alasan, seperti yang akan dijelaskan di dalam artikel ini, dengan melihat konsep dan penerapan serta manfaatnya.

Mari kita mulai dengan Quadratic Voting.
Masalah dalam Model Tata Kelola
Model tata kelola yang digunakan oleh platform blockchain menjadi semakin penting, dengan kemampuannya untuk memengaruhi partisipasi pengguna, efisiensi platform, dan daya tarik. Salah satu kekhawatiran terbesar yang dimiliki blockchain dalam hal tata kelola adalah potensi munculnya posisi dominan. "Posisi dominan" ini akan terdiri dari pengguna yang akan memiliki (di bawah kendali mereka) sejumlah besar suara atau bahkan suara mayoritas. Ini akan memberi kelompok pengguna ini, kontrol yang belum pernah terjadi sebelumnya atas hal-hal yang berkaitan dengan evolusi platform.

Pemusatan kekuatan voting seperti itu dapat membuat pengguna dengan jumlah suara yang lebih kecil enggan berpartisipasi dalam mekanisme tata kelola atau bahkan membuat mereka benar-benar meninggalkan platform. Janji dan potensi teknologi dan platform blockchain hanya dapat dipenuhi jika perhatian yang cermat dan bijaksana diberikan pada mekanisme tata kelola platform ini. Pemusatan suara dan kekuatan pemungutan suara seperti itu, tidak diragukan lagi, akan membuat orang-orang di platform menjadi benar-benar khawatir. Namun, metode pemungutan suara baru, yang baru-baru ini telah menemukan kegunaan dalam pengambilan keputusan sosial, muncul sebagai solusi yang memungkinkan untuk dilema yang mengganggu platform blockchain.
Quadratic Voting: Cara Matematika Menuju Pemungutan Suara yang Lebih Adil
Quadratic voting adalah mekanisme pengambilan keputusan kolektif yang memungkinkan jalan yang lebih baik untuk membuat keputusan, menghindari apa yang disebut “tirani mayoritas.” Ini pertama kali diusulkan oleh ekonom politik Glen Weyl dan memungkinkan peserta untuk mengekspresikan arah preferensi mereka, tingkat preferensi mereka, dan seberapa kuat perasaan mereka terhadapnya. Melalui ini, diharapkan dapat mengatasi masalah kekuasaan mayoritas dan melindungi kepentingan kelompok pemilih yang lebih kecil yang sangat peduli dengan isu-isu tertentu. Quadratic voting memungkinkan pengguna untuk "membayar" suara tambahan pada masalah tertentu, memungkinkan mereka untuk mengekspresikan dukungan mereka lebih kuat untuk masalah tertentu.

Sementara pada pemungutan suara yang umum, mungkin biasanya menanyakan apakah Anda setuju atau tidak setuju dengan serangkaian masalah tertentu, Quadratic Voting memberi pemilih anggaran "kredit suara" yang mereka bisa keluarkan untuk setuju atau tidak setuju dalam sebuah permasalahan. Pemilih dapat memberikan banyak suara. Akan tetapi, pada setiap suara yang keberikutnya akan membutuhkan lebih banyak kredit daripada yang terakhir. Jenis mekanisme pemungutan suara ini dapat digunakan di berbagai bidang, seperti lembaga demokrasi, tata kelola perusahaan, dan pengambilan keputusan kolektif yang dimungkinkan oleh blockchain.




	

	
	
		
			
				Quadratic voting pertama kali diusulkan oleh:
			
		

		
					

		
			
			
			
			Vitalik Buterin
		
			
			Glen Weyl
		
			
			Zoe Hitzig
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Quadratic Voting bekerja?
Sekarang, mari kita lihat bagaimana Quadratic Voting ini bekerja. Quadratic Voting didasarkan pada prinsip-prinsip pasar, dengan masing-masing pemilih dialokasikan anggaran kredit suara yang dapat mereka keluarkan untuk mempengaruhi hasil musyawarah kunci. Jika seorang pemilih sangat mendukung atau menentang keputusan tertentu, mereka dapat mengalokasikan suara tambahan untuk menunjukkan tingkat dukungan atau penentangan mereka terhadap keputusan tertentu. Biaya suara tambahan ditentukan melalui aturan penetapan harga suara, dengan setiap suara menjadi lebih mahal daripada yang terakhir. Meningkatnya biaya kredit pemilih menunjukkan tingkat dukungan atau penolakan terhadap keputusan tertentu.

Quadratic Voting menggunakan rumus sederhana, yaitu sebagai berikut: biaya pemilih = (jumlah suara)2

Mari kita pahami dengan lebih baik dengan bantuan sebuah contoh. Anggaplah seorang pemilih memiliki anggaran 16 kredit suara dan bebas menggunakan satu kredit untuk 16 masalah berbeda yang dapat mereka pilih. Namun, jika pemilih merasa lebih kuat tentang satu isu tertentu, mereka dapat mengalokasikan empat suara untuk isu tersebut dengan mengorbankan seluruh anggaran mereka. Empat suara menghabiskan semua 16 kredit suara karena biaya setiap suara tambahan menjadi lebih mahal secara kuadrat. Jadi 1 suara akan dikenakan biaya 1 kredit, 2 suara akan dikenakan biaya 4, 3 suara akan dikenakan biaya 9, dan suara ke-4 akan dikenakan biaya 16.

Mekanisme ini telah dilihat sebagai salah satu solusi potensial untuk mengatasi masalah tata kelola yang dihadapi oleh platform dan komunitas blockchain, mencegah satu kelompok mengambil alih sementara juga melindungi kepentingan kelompok minoritas. Token yang diberikan sebagai suara didistribusikan kembali secara merata di antara pemilih pada akhir setiap siklus tata kelola. Grup membutuhkan beberapa siklus pemungutan suara dan biaya yang signifikan untuk mengendalikan platform.

Akan tetapi, bagaimana jika Quadratic Voting apabila dibandingkan dengan mekanisme pemungutan suara lain yang sudah mapan? Ada tiga mekanisme pemungutan suara demokratis utama lainnya,

 	Sistem Pluralitas
 	Sistem Representasi Proporsional
 	Sistem Semi Proporsional

Sistem Pluralitas
Pada system pemilihan pluralitas, pihak atau posisi yang memperoleh suara terbanyak memenangkan pemilihan, dengan mengandalkan mekanisme “satu suara, satu pemilih”. Namun, sistem pemungutan suara pluralitas tidak dapat memastikan bahwa para pemilih dapat menyatakan tingkat dukungan mereka untuk suatu alasan atau masalah tertentu atau mengalokasikan suara mereka untuk menyatakan tingkat dukungan.
Sistem Representasi Proporsional
Metode pemungutan suara ini pada pokoknya sangat terlihat di badan legislatif nasional, yang memastikan bahwa pembagian badan terpilih mencerminkan pembagian suara di daerah pemilihan. Meskipun metode pemungutan suara ini mencerminkan sudut pandang pemilih dengan lebih baik, metode ini gagal untuk menggambarkan seberapa kuat perasaan pemilih tentang posisi mereka atas suatu masalah.
Sistem Semi Proporsional
Ada beberapa jenis sistem pemungutan suara semi-proporsional. Namun, tidak satu pun dari ini menjelaskan tingkat preferensi pemilih atau oposisi terhadap masalah.
Quadratic Funding: Cara Baru Untuk Mendanai Barang Publik
Mari beralih ke Quadratic Funding. Quadratic Funding adalah salah satu eksperimen sosio-ekonomi paling inovatif yang muncul dari ekosistem kripto. Ini telah disebut-sebut sebagai cara yang optimal secara matematis untuk mendanai barang publik dalam komunitas demokratis dengan memperkuat sumbangan yang diberikan oleh komunitas besar di atas kontribusi yang diberikan oleh kelompok kecil dengan kantong yang dalam. Tapi apa itu barang publik?

Barang publik didefinisikan sebagai komoditas atau layanan yang tersedia untuk semua anggota masyarakat. Barang-barang tersebut harus memiliki kualitas sebagai berikut:

 	Tidak bersaing – Ini berarti bahwa penggunaan barang oleh satu anggota tidak mengurangi ketersediaannya untuk anggota lain.
 	Tidak dapat dikecualikan – Barang-barang ini harus dapat diakses oleh semua orang.

Quadratic Funding diuraikan oleh Vitalik Buterin, Zoe Hitzig, dan Glen Weyl dalam makalah penelitian yang diterbitkan pada tahun 2018. Namun, agar lebih mudah dipahami, kita harus menyederhanakan konsep tersebut. Kekuatan pendorong di belakang Quadratic Funding adalah penggabungan yang serupa, penggabungan dana yang disediakan oleh individu, perusahaan, dan protokol yang secara kolektif dikenal sebagai mitra yang sesuai. Dana yang terkumpul di dalam penggabungan yang sesuai tadi akan digunakan untuk memperbesar kontribusi proyek individu. Mari kita lihat contoh singkat untuk memahami konsep dengan lebih baik.

Mari kita asumsikan kita memiliki $10.000 dalam suatu penggabungan yang sesuai dan tiga proyek berpartisipasi dalam putaran pendanaan. Proyek A mendapat pendanaan $1000 dari 5 kontributor yang masing-masing memberikan $200. Proyek B menerima $1000 dari 2 kontributor, masing-masing memberikan $500. Proyek C juga menerima $1000, tetapi dari 20 kontributor, masing-masing memberikan $50. Sekarang, jumlah yang cocok dihitung menggunakan rumus Quadratic Funding. Sesuai rumus, proyek pertama mendapat tambahan $1851,85, 185% lebih banyak dari jumlah kontribusi. Proyek kedua menerima $740,74, tambahan 74% dari total kontribusi, sementara yang ketiga mendapatkan $7407,41 dari dana yang cocok, 740% yang mengejutkan dari kontribusi awal.

Mari kita lihat bagaimana rumus sampai pada nilai-nilai ini.

 	Individu, perusahaan, dan protokol berkontribusi pada proyek (A, B, C).
 	Mari kita mulai dengan proyek A. Setelah putaran pendanaan selesai, akar kuadrat dari setiap kontribusi ditambahkan, dan hasilnya dikuadratkan. Mari kita asumsikan ini adalah variabel Quadratic Funding.
 	Proses yang tepat diulangi untuk Proyek B dan C.
 	Porsi kumpulan Proyek A dihitung sebagai rata-rata tertimbang dari variabel Quadratic Funding.
 	Proyek B dan C juga menerima bagian mereka dengan mengikuti model matematika yang sama.

Manfaat dari Quadratic Funding
Quadratic Funding membantu mengatasi masalah yang disebut "tragedi milik bersama". Ini adalah masalah ekonomi dimana setiap individu memiliki insentif untuk mengkonsumsi sumber daya dari pengeluaran orang lain, dengan tanpa mengecualikan siapa pun dari konsumsi sumber daya, menyebabkan konsumsi berlebihan dan penipisan sumber daya. Quadratic Funding menekankan pada jumlah donasi daripada besarnya donasi. Proyek yang menghasilkan lebih banyak donasi mewakili barang publik yang melayani kelompok pengguna yang lebih besar, membuat tragedi bersama menjadi lebih parah.

Akibatnya, proyek yang melayani kelompok yang lebih luas diasumsikan didukung oleh lebih banyak donor, sehingga menghasilkan sumbangan yang lebih tinggi dari kelompok yang cocok. Inilah mengapa proyek C menerima pendanaan tertinggi dan yang paling cocok dalam contoh kami sebelumnya.




	

	
	
		
			
				Mana yang di bawah ini yang paling ditekankan oleh Quadratic Funding?
			
		

		
					

		
			
			
			
			Jumlah Donasi
		
			
			Besarnya Donasi
		
			
			Semua Benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kasus yang Menggunakan Quadratic Voting dan Quadratic Funding
Badan Legislatif Negara Bagian Colorado telah menggunakan Quadratic Voting untuk memutuskan tagihan alokasi mana yang harus didanai oleh mereka terlebih dahulu. Dengan badan legislative yang lebih cenderung untuk mensponsori tagihan mereka sendiri dan memilihnya, Demokrat menggunakan Quadratic Voting untuk menentukan tagihan mana yang mendapat dukungan secara keseluruhan. Setiap badan legislatif diberi anggaran 100 kredit, di mana satu suara akan dikenakan biaya satu token. Namun, badan legislatif dapat memberikan lebih banyak suara untuk suatu masalah, dengan biaya setiap suara meningkat secara kuadratik, seperti yang ditunjukkan di bawah ini.

Taiwanese Presidential Hackathon juga dinilai melalui Quadratic Voting.

Ketika berbicara tentang Quadratic Voting, contoh yang paling menonjol adalah Gitcoin, yang menggunakan metode untuk mengumpulkan dana. Gitcoin memungkinkan komunitas untuk membuat dan mendanai proyek dan telah mendukung berbagai proyek, termasuk Uniswap, Finematics, Kickback, dan lainnya. Vitalik Buterin menggunakan Hibah Gitcoin untuk menemukan proyek baru, sedangkan Andre Cronje menggunakannya untuk mendanai Yearn Finance.




	

	
	
		
			
				Dimanakah konsep Quadratic Voting dipraktikkan?
			
		

		
					

		
			
			
			
			Legislatif Negara Bagian Colorado
		
			
			Taiwanese Presidential Hackathon
		
			
			Pihak German Volt pada kongres keduanya
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kesimpulan
Secara tradisional, demokrasi modern telah menggunakan metode satu orang satu suara, sementara perusahaan mengadopsi mekanisme pemungutan suara yang sedikit lebih canggih. Namun, sistem pemungutan suara yang lebih demokratis, seperti; Ranked Choice Voting (Pemungutan Suara Pilihan Berperingkat) dan Proportional Voting (Pemungutan Suara Proporsional), telah gagal mendapatkan daya tarik karena kerumitannya. Quadratic Voting, dengan memungkinkan pemilih untuk mengekspresikan preferensi mereka dan intensitas preferensi ini, membantu melindungi kepentingan kelompok yang lebih kecil dalam komunitas.

Quadratic Funding, meski merupakan konsep yang relatif baru, telah memberikan dampak yang cukup besar, dengan lebih dari $2 juta disalurkan untuk barang publik. Semakin banyak proyek yang mengeksplorasi Quadratic Funding, di antaranya adalah Gitcoin Grants, clr.fund, dan Downtown Stimulus. Namun, kedua konsep tersebut memiliki potensi dengan secara radikal mengubah cara protokol blockchain diatur dan didanai.




	

	
	
		
			
				Manakah proyek paling unggul yang mengeksplorasi Quadratic Funding?
			
		

		
					

		
			
			
			
			Gitcoin Grants
		
			
			Clr.funds
		
			
			Downtown Stimulus
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Now let’s try it IRL – have your Quadratic say, (L)Earner!

### Bagaimana Cara Melakukan Stake di NEAR

Staking di ekosistem NEAR merupakan kegiatan spesifik yang tengah berkembang yang menawarkan berbagai pendekatan dan solusi. Mari kita lihat opsi staking yang berbeda dan bayangkan opsi mana yang paling cocok untuk teman-teman sekalian pilih.

Untuk memudahkan perbandingan, kami akan menilai setiap opsi berdasarkan tiga parameter yakni: Antarmuka Pengguna (UI), Hasil Persentase Tahunan (APY), biaya penarikan, dan standar keamanan.
NEAR Staking Standar
Karena NEAR beroperasi dengan mekanisme konsensus Delegated Proof-of-stake (DPOS), setiap pemegang token NEAR dapat mendelegasikan token mereka ke validator tertentu. Daftar lengkap dari pilihan validator yang tersedia bisa dicek di https://explorer.shardnet.near.org/nodes/validators. Kamu dapat memilih validator yang disukai dan mendelegasikan token milikmu kepada mereka. Validator akan menerima komisi sebagai imbal hasil untuk aktivitas ini, yang nilainya akan ditampilkan sebelum kita memilih, dan selanjutnya kita akan menerima keuntungan dalam bentuk token NEAR. Biasanya, nilainya tidak lebih dari 9,7% per tahun.

Mungkin ini kedengarannya cukup mudah, tetapi bayangkan ketika kamu baru saja membeli token NEAR untuk pertama kalinya dan kamu ingin mendapatkan keuntungan secara langsung. Selain itu, kamu harus menunggu selama 3 hari untuk menarik NEAR yang ada dari staking, dan jika kita ingin menarik secara instan, kita harus membayar sejumlah biaya tambahan. Tidak hanya itu, kita juga perlu memercayai salah satu validator tempat kita mendelegasikan token kita sebelumnya.




	

	
	
		
			
				Berapa lama kita harus menunggu untuk menarik NEAR dari staking standar?
			
		

		
					

		
			
			
			
			1 hari
		
			
			3 hari
		
			
			1 minggu
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Staking NEAR Terpusat (Centralized)
Centralized Exchange (CEX) telah lama hadir dengan mekanisme untuk meningkatkan keuntungan dengan tools tambahan agar keuntungan yang didapat bisa lebih banyak lagi. Salah satunya adalah melakukan staking token di dalam exchange tersebut. Sama halnya seperti dana yang anda yang disimpan di bursa, realita sebenarnya kita tidak memilikinya. Hal yang sama juga berlaku untuk staking. Meskipun exchange itu sendiri menggunakan node blockchain milik mereka untuk ini, pada dasarnya semua dana milik kita ada di pihak mereka.

Solusi ini jadi benar-benar sah ketika kita berbicara tentang pengguna yang tidak aktif namun terjun ke Web3 serta terbiasa membeli koin favorit mereka di bursa. Saat ini, lebih dari 1 juta orang memiliki token NEAR di Binance. Tentunya akan ada risiko peretasan atau pencurian dari dana kita, seperti halnya yang terjadi pada FTX. Selain itu, profitabilitas di CEX jauh lebih rendah daripada di DeFi, yakni sekitae 3% untuk staking yang fleksibel (dengan penarikan secara instan).




	

	
	
		
			
				Dalam Staking jenis apa yang kita tidak punya kuasa atas dana kita sendiri?
			
		

		
					

		
			
			
			
			Metapool Staking
		
			
			HERE staking
		
			
			Centralized Staking
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Metapool dan Linear
Opsi staking lainnya adalah Metapool dan Linear, dimana proyek ini sudah dianggap asli (native) di ekosistem NEAR. Untuk melakukan Staking NEAR, kita harus memiliki wallet NEAR dan beberapa token NEAR. Jenis staking seperti ini lebih baik daripada dua opsi lainnya karena dikelola oleh proyek yang ada didalam ekosistem dan memiliki APY yang wajar yakni sekitar 9,4% dimana hal ini juga tak kalah penting. Kedua proyek tersebut telah menjalani audit dari BlockSec serta tidak memiliki masalah dalam keamanan.

Namun, seseorang yang baru mengenal ekosistem perlu menemukan sendiri proyek ini dan mempercayainya dengan dana milik mereka, dan tentunya mereka juga perlu mengunjungi situs website proyek tersebut secara rutin. Penting juga untuk diingat bahwa ada biaya tambahan untuk menarik NEAR secara instan dari staking.


Staking NEAR di HERE Wallet
Kami anggap kalian sudah mengetahui yang mana yang pantas untuk mendapat perhatian lebih lanjut dalam hal staking. Karena HERE sendiri merupakan metode onboarding yang sederhana dan tidak hanya untuk crypto tetapi juga untuk pengguna web2 lain, staking juga harus dibuat sederhana dan tidak menimbulkan masalah bagi seseorang yang tidak terbiasa dengan crypto.

Itulah sebabnya kami membuat mekanisme staking non-blocking, di mana kita dapat menarik NEAR kapan saja tanpa biaya apa pun dan tetap menerima pendapatan secara pasif. Ini menjadi memungkinkan berkat cadangan likuiditas pada kontrak, seperti layaknya di bank konvensional ketika 90% dana memang digunakan tetapi selalu ada uang yang tersedia di ATM. Pengembalian investasi bervariasi tergantung seberapa aktif kita menyetor/menarik dana dan rata-rata sekitar 9,8%. Pemilik dari NFT tertentu, seperti pengguna awal dari HERE Wallet, juga akan bisa menerima penghasilan tambahan.

Selain itu, proses staking itu sendiri dibuat sesederhana mungkin. Yang perlu kita lakukan hanyalah menekan satu tombol. Setelah itu, jumlah NEAR yang diperlukan akan dilepas secara otomatis sebelum transaksi lainnya dilakukan.

Saat ini, HERE Staking telah menjalani audit dengan tim OtterSec.




	

	
	
		
			
				Berapa biaya untuk penarikan secara instan di HERE untuk staking NEAR?
			
		

		
					

		
			
			
			
			1.5%
		
			
			0%
		
			
			3.2%
		
	
		

		
		
			
				Correct!
				Wrong!

### Bagaimana Zero Knowledge Proof Dapat Memastikan Privasi Data

Kalian mungkin pernah mendengar istilah seperti berikut "jika itu gratis, maka kitalah yang menjadi produknya" atau "data sama seperti minyak di era sekarang ", lalu kita menertawakannya begitu saja sebagai istilah konyol belaka. Faktanya, data merupakan kekuatan pendorong di balik hampir semua bisnis dan layanan. Misalnya personalisasi pengalaman dan layanan, pemasaran, dan sejumlah wawasan dan layanan lainnya yang bergantung pada volume dan kualitas data yang diberikan kepada mereka. Sebagian besar perusahaan sangat ingin mengakses data untuk membantu memahami pelanggan mereka dengan lebih baik lagi, lalu memprediksi pola perilaku pelanggan, dan meningkatkan kualitas layanan mereka.

Secara umum, dimana-mana tentunya akan selalu peduli pada kekhawatiran seputar data dan privasi. Pendukung privasi telah lama menandai kekhawatiran tentang bagaimana data disimpan, bagaimana diakses, dan siapa yang memiliki akses ke sana. Dengan pertumbuhan ekosistem cryptocurrency dan blockchain, kekhawatiran serupa juga muncul di sektor ini. Sifat publik dari blockchain telah memperkenalkan beberapa masalah privasi bagi pengguna terkait pengamanan informasi pribadi mereka. Artikel ini akan melihat lebih dekat mengenai masalah privasi pada blockchain dan bagaimana bukti Zero Knowledge (ZK) dapat memitigasi hal tersebut.
Apa Itu Privasi Data?
Meningkatnya penggunaan internet telah membawa masalah privasi data menjadi pokok permasalahan yang utama, dengan hampir semua situs web, aplikasi, dan platform yang ada di media sosial saat ini telah mengumpulkan dan menyimpan informasi pribadi pengguna agar dapat menyediakan layanan tertentu. Namun, platform dan situs web ini seringkali tidak memiliki perlindungan yang memadai untuk mengamankan data yang telah dikumpulkan, yang mengakibatkan banyak sekali terjadi pelanggaran data.

Dengan pertumbuhan teknologi blockchain dan ekosistem crypto, ada kekhawatiran yang berkembang tentang privasi pengguna baik di skala ritel dan institusional. Kekhawatiran ini terutama disebabkan oleh sifat publik dari blockchain, dengan sebagian besar solusi Lapisan 1 dan Lapisan 2 gagal mengatasi masalah ini. Privasi data mengacu pada kemampuan pengguna untuk menentukan yang pada akhirnya, kapan dan bagaimana informasi mereka dibagikan dengan orang lain. Ini juga mencakup kemampuan pengguna untuk menentukan sejauh mana data mereka dibagikan. Informasi ini dapat mencakup nama, lokasi, informasi kontak, perilaku online, kesukaan, ketidak sukaan, detail transaksi, dan lainnya.
Kepercayaan, Privasi dan Blockchain
Saat sekarang ini, ekosistem cryptocurrency tengah mengalami berbagai gejolak yang cukup besar setelah kejadian runtuhnya proyek-proyek besar seperti FTX. Namun, basis dari teknologi dasar yang mendukung cryptocurrency tentunya berpotensi merevolusi privasi, kepercayaan, dan bagaimana kepercayaan akan dimanfaatkan. Ini sangat penting di era internet ketika jutaan orang menelusuri dan membagikan banyak informasi pribadi mereka untuk mengakses layanan dan produk.

Teknologi Blockchain secara inheren hadir dengan masalah terkait privasi, semua ini dikarenakan desain sistemnya. Sifat terdesentralisasi dari blockchain ini berarti node yang akan memproses transaksi ataupun informasi dan memiliki akses ke data blockchain. Misalnya, blockchain Bitcoin tersedia untuk umum dan dapat diakses oleh siapa saja yang ingin memeriksa riwayat transaksinya hingga ke blok asalnya. Sekarang perlu diperhatikan bahwa Bitcoin bersifat pseudo-anonim, yang berarti “[d]ata poin yang tidak secara langsung terkait dengan individu tertentu [tetapi di mana] banyak tampilan dari orang-orang akan dapat dihubungkan semuanya.”

Data pseudo-anonim yang cukup memungkinkan untuk mengidentifikasi individu di balik transaksi, yang ini mengkhawatirkan pengguna blockchain, dan tentunya ada beberapa alasan untuk ini semua. Tidak seperti data yang digunakan oleh aplikasi biasa yang hanya dapat diakses oleh beberapa orang, data blockchain dapat diperiksa oleh semua orang, termasuk aktor dan entitas jahat yang dapat mengeksploitasi informasi di blockchain untuk keuntungan mereka. Selain itu, sifat blockchain yang tidak dapat diubah berarti bahwa transaksi dan data akan ditautkan secara permanen ke individu tersebut. Ini dapat dilakukan dengan memantau komunikasi antar node. Selain itu, dompet kripto juga dapat dianalisis tanpa akses ke kunci pribadi, yang semakin memperumit masalah.

Salah satu contoh yang terkenal dimana menggunakan data blockchain untuk melacak seseorang adalah penyelidikan dan penangkapan Ross Ulbricht, yakni individu di balik situs web darknet “Silk Road” yang terkenal dimana mereka gunakan ini untuk berbagai aktivitas ilegal. Lembaga penegak hukum mengidentifikasi Ulbricht sebagai individu di balik Silk Road, berkat data blockchain. Selain itu, mereka dapat melacak transaksi Bitcoin dan menentukan bahwa agen Drug Enforcement Administration (DEA) AS mencuci BTC yang terhubung ke Silk Road. Dalam hal ini, lembaga penegak hukum dapat melacak data yang tersedia di blockchain untuk mengidentifikasi individu terkenal. Tapi bayangkan jika entitas jahat dapat melacak data Anda dengan mudah berkat sifat publik dari blockchain. Hasilnya akan menjadi sangat destruktif.
Memperkenalkan Zero Knowledge Proof
Zero Knowledge Proofs pertama kali dibahas oleh Silvio Micali, Shafi Goldwasser, dan Charles Rackoff dalam makalah berjudul “The Knowledge Complexity of Interactive Proof Systems,” dan dianggap sebagai inovasi kriptografi yang menarik yang dapat digunakan dalam beberapa skenario. Dalam kasus blockchain, ini dapat membantu mengaktifkan transaksi yang aman dan anonim. Zero Knowledge Proof, juga dikenal sebagai Zero Knowledge Protocol, memungkinkan satu pihak (prover) untuk membuktikan kepada pihak lawan (verifier) bahwa mereka mengetahui nilai atau informasi tertentu (x) tanpa mengungkapkan informasi apa pun selain dari fakta bahwa mereka mengetahui nilai atau informasi yang bersangkutan (x). Tantangan terkait Zero Knowledge Proof adalah membenarkan kepemilikan informasi tanpa mengungkapkannya atau informasi tambahan lainnya. Zero Knowledge Proof harus memenuhi kriteria sebagai berikut.

 	Kelengkapan – Mari kita asumsikan pernyataan itu benar. Verifikator yang jujur, benar dan setia mengikuti protokol, akan yakin dengan informasi yang diberikan oleh verifikator yang benar mengikuti protokol.
 	Penguatan – Penguatan berarti tidak boleh ada cara bagi pembukti untuk memalsukan informasi atau meyakinkan pemverifikasi secara salah. Pemalsuan akan mustahil terjadi.
 	Zero Knowledge – Jika pernyataan oleh prover benar, pemverifikasi tidak mempelajari apa pun selain fakta bahwa informasi tersebut benar.

Dua yang pertama dianggap sebagai properti dari sistem bukti interaktif yang lebih umum, dengan penambahan nol pengetahuan yang mengubah proses verifikasi menjadi bukti tanpa pengetahuan. Karena kemungkinan kecil (kesalahan kesehatan) bahwa pembukti jahat dapat meyakinkan pemverifikasi pernyataan palsu, bukti tanpa pengetahuan dianggap sebagai bukti probabilistik daripada bukti deterministik. Namun, kesalahan kesehatan dapat dikurangi menjadi nilai yang dapat diabaikan.




	

	
	
		
			
				Kriteria apa yang harus dipenuhi Zero Knowledge Proof ?
			
		

		
					

		
			
			
			
			Kelengkapan
		
			
			Penguatan
		
			
			Zero Knowledge
		
			
			Semua Benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Zero Knowledge Proof Bekerja?

Sumber Gambar

Zero Knowledge Proof terdiri dari tiga tindakan yang terjadi secara berurutan di antara para peserta. Tindakan ini disebut saksi, tantangan, dan respon. Ayo kiya pelajari lebih lanjut untuk memahami peran setiap tindakan dengan lebih baik dengan mengasumsikan ada dua peserta yakni A, dan B.

Saksi – Mari kita asumsikan A mengetahui nilai atau informasi tertentu, yang juga menentukan serangkaian pertanyaan. Pertanyaan-pertanyaan ini selalu dapat dijawab dengan benar oleh A. Awalnya, A dapat memilih sembarang pertanyaan acak dari kumpulan pertanyaan yang ada, menghitung buktinya, dan mengirimkannya ke B.

Tantangan – Setelah bagian saksi, lalu ada fase tantangan, di mana B memilih pertanyaan dari set dan meminta A untuk menjawabnya.

Respon – A kemudian menghitung tanggapan dan mengirimkannya kembali ke B. Hal ini memungkinkan B untuk menentukan apakah A benar-benar mengetahui jawabannya.

Proses yang dijelaskan di atas dapat diulangi sebanyak yang diperlukan hingga diketahui bahwa A mengetahui jawaban yang benar dan probabilitas tebakan menjadi cukup rendah.




	

	
	
		
			
				Paper mengenai “The Knowledge Complexity of Interactive Proof Systems” dibuat oleh:
			
		

		
					

		
			
			
			
			Silvio Micali, Shafi Goldwasser, Charles Rackoff
		
			
			Silvio Micali, Charles Hoskinson, Charles Rackoff
		
			
			Vitalik Buterin, Shafi Goldwasser, Satoshi Nakamoto
		
			
			Charles Hoskinson, Satoshi Nakamoto, Vitalik Buterin
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kasus Penggunaan dari ZKP
ZKP dapat digunakan di beberapa jenis skenario
Sistem Otentikasi
Sistem autentikasi telah memainkan peran penting dalam mendorong penelitian di Zero Knowledge Proofs. Dalam sistem ini, satu pihak ingin membuktikan identitasnya kepada pihak kedua melalui beberapa informasi rahasia. Namun, pihak kedua tidak ingin mengetahui informasi rahasia ini.
Kerahasiaan
Salah satu kasus penggunaan ZKP yang paling signifikan datang dalam transaksi yang membutuhkan kerahasiaan penuh. Mari kita pahami caranya. Pertimbangkan blockchain seperti blockchain Bitcoin. Umumnya, ketika transaksi terjadi di blockchain ini, data yang terkait dengan transaksi tersebut dicatat di blockchain. Ini berarti siapa pun dapat mengumpulkan sejumlah informasi tentang transaksi dengan menganalisis data di blockchain. Demi privasi, sangat penting untuk menyembunyikan beberapa detail untuk transaksi tertentu. ZKP memungkinkan untuk menyembunyikan detail sekaligus memastikan validitas transaksi dengan menambahkannya ke blok baru.
Informasi pribadi
Katakanlah Anda ingin mengambil pinjaman dari bank. Untuk mengajukan pinjaman, Anda harus memberikan sejumlah dokumentasi yang terdiri dari sejumlah besar informasi pribadi, sehingga tersedia untuk pihak ketiga. Dalam hal memperoleh pinjaman dari bank, satu-satunya informasi yang diperlukan oleh bank adalah untuk mengetahui apakah seseorang memperoleh jumlah tertentu yang cukup untuk melunasi pinjaman tersebut. ZKP dapat membantu bank memverifikasi apakah seseorang memperoleh jumlah minimum yang telah ditentukan sebelumnya tanpa mengungkapkan informasi sensitif apa pun kepada bank atau pihak ketiga mana pun.
ZKP Dan Blockchain: Peta Jalan Kedepan
Beberapa proyek dan cryptocurrency menggunakan ZKP, seperti ZCash, SmartCash, Zerocash, dan ZeroVert. ZKP sebagian besar telah diimplementasikan melalui zk-SNARKS dan zk-STARKS. zk-SNARKS awalnya dikembangkan oleh ZCash. Sebagian besar blockchain adalah pseudo-anonim, artinya identitas pengguna dapat ditelusuri kembali ke transaksi mereka dengan mempelajari data blockchain. Informasi ini tersedia untuk semua orang yang memiliki akses ke blockchain dan dapat dieksploitasi oleh entitas jahat mana pun.

Terlepas dari reputasi blockchain sebagai puncak keamanan dunia maya, kelemahan khusus ini sudah diketahui oleh pengguna. Namun, ZKP dapat membantu menambal kerentanan ini dan memastikan privasi lengkap terkait informasi pribadi. Meskipun ZKP masih memiliki beberapa tantangan untuk diatasi, ZKP memberi pengguna kendali atas data dan privasi mereka, membatasi akses ke pihak ketiga, dan akan memainkan peran penting dalam meningkatkan privasi dalam hal blockchain.




	

	
	
		
			
				ZKP telah digunakan di:
			
		

		
					

		
			
			
			
			Zcash
		
			
			SmartCash
		
			
			Zerocash
		
			
			ZeroVert
		
			
			Semuanya benar
		
	
		

		
		
			
				Correct!
				Wrong!

### How to get started on NEAR protocol?

How to get started on NEAR protocol?

### Meteor Wallet Overview

INTRODUCTION
Blockchain technology presents a realm of boundless opportunities, including financial autonomy. However, it's undeniably challenging for newcomers to navigate this complex world.

Why is it difficult? Primarily because freedom, which is the main motivation for many of us, comes with responsibility. This responsibility encompasses managing your actions, losses, investments, potential scams, assets, and wallets. In the decentralized web, safeguarding your cryptocurrency relies solely on you, with no one else to depend on.

Yet, assuming responsibility isn't the only barrier to entry in the world of cryptocurrency. The complexity of understanding many decentralized applications (Dapps), both in terms of their interfaces and functionalities, is another crucial factor to consider.

Meteor wallet aims to achieve several key objectives, such as facilitating mass adoption of web3 and becoming NEAR's top wallet. It seeks to foster healthy competition with other notable projects like MyNear, Sender, HERE, and NEAR's native wallet.

We are fortunate to be part of an exceptional ecosystem where each of the aforementioned projects has its unique strengths. So, what sets Meteor apart? It can be best described as an all-in-one wallet.

The term "all-in-one" refers to the extensive range of features and functionalities that Meteor packs into a single, user-friendly wallet. These tools assist newcomers, who may have limited knowledge, in navigating Web3 and the blockchain landscape. In the subsequent paragraphs, we will explore some of these features and delve into Meteor Wallet's objectives as a Web3 project.
WHAT IS METEOR WALLET?

Meteor Wallet is a comprehensive, user-friendly wallet designed for secure and straightforward management of your cryptocurrency while also enabling access to decentralized applications (dApps) within the NEAR ecosystem. Meteor is currently available as both a web wallet and a browser extension. Its primary objective is to become the preferred wallet that simplifies the NEAR blockchain experience for users, all within one powerful wallet application.
FEATURES
Introducing everyday users to web3 can be a challenging task. That's why, at Meteor, we have implemented and plan to roll out several features to streamline the onboarding process for everyone involved.
FREE NAMED WALLET CREATION
Meteor offers a free named wallet, an intuitive feature that can be set up in under a minute. This user-friendly option is far more convenient than using traditional alphanumeric addresses that are difficult to remember. If you're interested in creating your own Meteor free named wallet, follow this step-by-step guide carefully. Click here to get started.

To get started, you'll need to create a password. Once your wallet is set up, you'll have the option to personalize your profile and even connect it to Near Social. If you're not importing an existing wallet, make sure to secure your new seed phrase.

(Click here to view the guide on how to import an existing wallet).

Additionally, if you prefer using a traditional address instead of a free named wallet for any reason, Meteor also provides the option to create an implicit account, as illustrated in the image above.




	

	
	
		
			
				What does a free-named-wallet allow you to do?
			
		

		
					

		
			
			
			
			Create a personalized, easy-to-remember address
		
			
			Change the alphanumeric characters of an address at any time
		
			
			Send assets to addresses on blockchains other than NEAR
		
			
			A free-named-wallet allows you to send and receive text messages between wallets.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





SWAP FUNCTIONALITY
Swap functionality enables users to effortlessly exchange one cryptocurrency for another within the blockchain, and in this instance, without leaving the wallet. Meteor is the first and only wallet on the Near Blockchain to incorporate a Swap Aggregator, allowing users to easily compare and save with the lowest fees and slippage available.

The swap features in Meteor reinforce the concept of an all-in-one wallet. Users can swap up to 60 tokens (including stablecoins) with reputable swap providers such as Ref, Jumbo, Spin, and more.

To begin exploring the swap functionality in Meteor, click here to access the user guide and learn how to get started.




	

	
	
		
			
				What does "swapping" refer to?
			
		

		
					

		
			
			
			
			Exchanging one cryptocurrency for another
		
			
			Earning rewards for trading
		
			
			Transferring assets from one wallet to another
		
			
			Swapping refers to the process of withdrawing funds from a wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






STAKING
The Meteor wallet offers two staking options: Liquid Staking and Standard Staking. Let's explore the differences between these two mechanisms and how to manage them:

Liquid staking is a unique feature that allows you to receive a receipt token as proof of ownership of your staked asset. This receipt token is transferable, storable, tradeable, and can be used in DeFi or compatible dapps. On the other hand, Standard Staking doesn't offer receipt tokens.

With Standard Staking on Meteor, you can earn staking rewards of up to ~10% APY. You can compare and select from 90+ validators and pools and see your estimated earnings. You can also choose to lock your stake for 7, 30, or 90 days.

To use Standard Staking in Meteor, simply follow a few simple steps in either the web version or the extension. You can choose from multiple validators with estimated APY and potential rewards.

Click here to check how to do Standard Staking on Meteor.

With Liquid Staking on Meteor, our partnership with Meta Pool allows you to receive stNEAR receipt tokens upon staking. These tokens can be used to engage in various DeFi activities on NEAR and AURORA.

Click here to check our guide about Liquid Staking and how to do it.




	

	
	
		
			
				Which is the main advantage of using Liquid Staking over Standard Staking on Meteor Wallet?
			
		

		
					

		
			
			
			
			There are no potential downsides to using Liquid Staking compared to Standard Staking in the Meteor wallet
		
			
			You will be able to participate in multiple events within the NEAR ecosystem thanks to the receipt stNEAR token
		
			
			The main advantage of using Liquid Staking over Standard Staking in the Meteor wallet is that you do not receive any rewards or APYs on Standard
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFTs
A non-fungible token (NFT) is a distinct digital identifier that cannot be duplicated, replaced, or divided. It is recorded on a blockchain (NEAR in this case) and used to verify ownership and authenticity.

While most blockchain wallets allow you to send collectibles from one wallet to another, Meteor stands out when it comes to NFTs. It is the only wallet on NEAR that provides real-time updates on the floor price and total floor of each collection you own. Additionally, Meteor enables you to analyze your NFTs' traits and even set a collectible as your profile picture.

By clicking on a collection, you'll be able to view all the collectibles it contains, as well as each NFT's contract address, individual floor price, and the total floor price of your entire NFT collection. For a comprehensive guide on how to use NFT features within Meteor Wallet, please click here.




	

	
	
		
			
				You cannot send NFTs from Meteor to a NEAR native wallet
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





EXPLORE
The new Explore feature in Meteor Wallet keeps you informed about the latest developments in Meteor and the NEAR ecosystem, including news related to dApps, NFT projects, and DeFi. This makes Meteor Wallet not only a tool for managing your assets but also a hub for learning and staying updated about the ecosystem.

Additionally, within the Explore section, you can take part in Meteor Challenges, where you can earn rewards through a Learn-to-Earn approach! Details on how to participate in these events, which often stem from partnerships with other projects, are available within the same wallet.

Meteor Wallet will soon be introducing a Rewards section! Stay tuned for this exciting update.




	

	
	
		
			
				The Challenges section enables you to earn rewards through:
			
		

		
					

		
			
			
			
			Staking your NEAR tokens
		
			
			Participating in DeFi activities/giveaways organized by Meteor and its partners
		
			
			Swapping tokens
		
			
			Collect NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





SETTINGS & SECURITY
At Meteor, security is of utmost importance. We strongly recommend storing your seed phrase and wallet password in a secure location known only to you.

Upon opening the settings tab, you will encounter the following options:

Connected Apps: This feature allows you to connect your wallet to Near Social. In the future, we plan to add options for connecting your wallet to social networks such as Facebook, Twitter, and Apple, to name a few.

Security and Recovery: Here, you can view and extract your seed phrase, as well as manage your private keys.

Change Password: If you believe your wallet's password is not secure, you can change it at any time, always exercising caution.

Remove Account: If, for any reason, you want to remove your account, you'll first need to enter your password and then confirm the removal. While some may consider this option unnecessary, we believe it is crucial for ensuring security and user freedom. Keep in mind that account removal is irreversible.




	

	
	
		
			
				Currently, you can connect your Meteor wallet to:
			
		

		
					

		
			
			
			
			Facebook, Twitter, and Apple
		
			
			You cannot link your Meteor wallet to any social network
		
			
			Near Social
		
			
			To reddit and cross-chain platforms
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





FUTURE PLANS
Meteor Wallet has several exciting updates in the pipeline, including:

Meteor Support 2.0: An overhaul of our support system, which will feature the integration of Gleap and a single-ticket support system for email and in-wallet.

Meteor Explore 2.0: With even more dApps and games available!

Ledger Support: Planned for Q3 2023.

Social Logins: In addition to Near Social, we plan to add support for social logins via Gmail, Facebook, Twitter, Apple, and more.

iOS & Android Apps: Planned for the end of Q2 2023.

Support for Rich Media in NFTs: Collaboration with Harmonic Guild, with a tentative launch date later this year.

### Meta Pool, Module 2 - Crowdfunding on Meta Pool

Launchpad - Crowdfunding in a lossless way
Launchpad is a lossless staking rewards-based crowdfunding platform for NEAR projects seeking financial support and exposure to the NEAR community. The objective is to provide exposure and access to different projects, enabling the community to financially support web 3.0 projects built on NEAR protocol.
Launchpad is a lossless crowdfunding platform for projects on NEAR that want to get funded by their community. It leverages staking by providing backers with the possibility of funding with their rewards, not their main assets.


The unique fundraising mechanism built in Launchpad leverages Liquid Staking: financial backers mint the project's tokens with their staking rewards, not their crypto assets.

Launchpad works with 4 simple steps:

 	Backers commit & lock stNEAR to support crypto-based projects (if you don't have stNEAR go to Meta Pool & stake $NEAR)
 	Projects only earn staking rewards (~10%) of what backers commit, not the underlying crypto assets
 	Backers earn tokens from new projects launching on NEAR or receive an NFT drop (coming soon)
 	Backers recover their crypto assets: at the end of the locking period, you recover 100% of your NEAR.

Simply said, you can support crypto projects, get rewarded the project's native token and contribute to the growth of the NEAR ecosystem without losing your staked tokens.

You only give away their future NEAR rewards for the project’s tokens and get to keep their NEAR, thus de-risking the whole investment process.

Start supporting NEAR Projects now! 

Visit https://www.metapool.app/yield




	

	
	
		
			
				There is a pre established limit in the amount of stNEAR tokens you can deposit in a Launchpad campaign.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How can a project get listed on Launchpad?
First of all, Launchpad provides the crowdfunding platform and the rewards-based mechanism. On top of that, every project that get a fundraising campaign gets a marketing push at no cost from Launchpad: 

 	Pre-launch campaign: 1 or 2 weeks of buzz about the project, including possible AMAs, infographics and social media posts. 
 	Launch promotion
 	Weekly on going promotion during the fundraising time window.

Additionally, we are working with different entities of the NEAR ecosystem that are interested in the opportunity of financially supporting these new projects on NEAR.
How do we select projects?
We want to give everyone the opportunity to fundraise their projects, but we also want to give the users and potential investors quality projects as options. Because of that, every project that wants to be considered as a candidate to be on Launchpad must fulfill the following requirements:

 	A solid team building the project

The project must be backed by a solid and motivated team, capable of taking the project to the next stage once it is funded.

The experience of each member must be related to the type of project proposed. In other words, if it is a game project, the members must present evidence that at least some of their members have worked in related areas.

Multidisciplinary teams are also a good sign, having developers is important, but to really take your project to the next level you also need marketing, operations, design and maybe other areas.

 	Strong community

We want these projects to have a strong support from their community, we usually check their level of activity and engagement on social networks such as Telegram, Discord, Twitter, YouTube, Instagram, TikTok, and any others the projects mentioned in their application. 

This aspect is of vital importance because of 2 main reasons: we sometimes have a voting phase to select projects and the communities are usually the ones that push those votes, and also a good percentage of the amount fundraised will come from the community so it is essential to have one ready to get your back.

 	A Token and its Tokenomics

It’s indispensable for selected projects to have a token because they will use it to give rewards to those who support their campaign. To be more specific, the person who supports the project will give the project their staking rewards and will receive tokens from the project in exchange as a reward.

And, since your investors will get your token as a reward, it is important to tell them how they can use it (for example: play, buy, exchange or as a governance token) and your plans to increase its value. 

 	A plan for the funding

Keep in mind that having a campaign on Launchpad is similar to trying to raise money from investors: they want to know if you’re capable of building the project and how are you going to make money from it. 

So, be ready with a basic explanation on how you are going to use the raised funds: marketing, improvement of the product/service, expanding functionalities, changing/innovating branding, improving the functionalities of the platform, etc. 

 	Connect with the NEAR Ecosystem

Since we work with NEAR projects and community and communication is very important in this protocol, we encourage you to establish a close relationship with the NEAR Protocol Ecosystem.

The project team must have evidence that they have collaborated and know how to work with the actors involved in NEAR: Getting grants, participating in incubation programs or being part of guilds count for this requirement. 

This guarantees that the ecosystem already "recognizes the team/project" and that when the project goes to mainnet, the ecosystem will support it.




	

	
	
		
			
				Question. The multichain vision on a project is a must in a project that will be launched on Launchpad.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Where can I find more information about Launchpad?
You can find more information at Meta Pool site and blog.
Meta Bond Market - Sell your locked assets on Launchpad
The objective of Meta Bond Market is to provide a tool to acquire and offer different types of bonds that are currently generated by supporting projects in Launchpad.

Meta Bond Market can be accessed directly from its link metapool.app/bonds
Connect your wallet on Meta Bond Market
In the Meta Bond Market site:  metapool.app/bonds, scroll down and link the NEAR wallet to have full access to the crypto assets. Click the Connect Wallet button, choose the wallet and connect.

How Meta Bond Market works:
4 Easy steps to understand the Meta Bond mechanism:

 	Support Projects in Launchpad.
 	Get bonds according to the investment in Launchpad and related rewards.
 	Offer the bonds on the platform.
 	And/or buy bonds from other sellers.

Users invest in Launchpad to early-stage projects. If these projects manage to reach at least the first investment goal, supporters get rewards in project tokens, in gradual release in exchange for their locked investment.

Once the Fund Period is over, Meta Bond Market generates two bonds for the supporter:

 	First Bond: In NEAR tokens. This amount corresponds to the valuation in NEAR of the stNEAR locked at the end of the Fund period.
 	Second bond: For the amount of Tokens of the supported project to receive in gradual release.

The supporter can choose at any time during the Lock Period if they want to put either one or both bonds up for sale.

If the bonds are not put up for sale, the bonds continue their course, and at the end of the lock period the investment is returned to the bond holder, and the rewards of the supported project are delegated in gradual release according to the proposal.

For each bond you can choose/perform the following actions:

 	Split the bonds into smaller bonds.
 	Offer them for direct sale.
 	Offer them at auction.

Set the time that the bonds will be offered for sale.

If the bond is sold, the seller gets the amount in tokens according to the direct sale or the best auction offer.

If the bond is not sold, it becomes available for sale again and remains in the seller's possession and the seller can put it up for sale again if desired.




	

	
	
		
			
				Meta Bond allows you to sell the locked tokens from your support to a Launchpad campaign.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Bond Market Platform
Platform Menu

Bond Market
This section displays all the bonds offered on the platform. The data of each bond is shown and it will be possible to acquire/bid for them.


My Bonds
My Bonds section details all the bonds that the user owns. From this section the user can:


 	See all the data of the bonds
 	Sell them
 	Merge them (important, in order to merge 2 bonds, all the bond criteria must match: asset, due date and Cliff date if applicable).
 	Split them (bonds can only be split if that have not been partially claimed).

My Sales
In this section you can view the bonds that the user put up for sale. The active sales and the completed ones.

 	Direct sale: the buyer bids directly and the seller will see in this section, that the sale was made and will be able to obtain the corresponding tokens.
 	Auction Sale: the highest bid is the winner and at the end of the bidding period the seller will be able to get the tokens.
 	End of bid period: If at the end of the bid period, there were no offers, the seller may put his bond up for sale again or end the process.

Important: if the bond was sold, the seller must enter the bond and press “get tokens” to close the sale process. This process is manual.
Bond Guarantee
When offering a bond up for sale, the system will request a minimum amount (currently 1 NEAR) as a guarantee.

This allows the system to hold only bonds that represent a minimum of the amount of the guarantee in question.

When closing the sale process, this amount will be returned to the seller.
My Bids
In "My bids" the user can view the active bids he has made for bonds at Auction.

Direct Sell bonds are not displayed here, since they are already automatically incorporated into the "My Bonds" section.

If you are losing the auction, the system allows you to increase your bid or cancel your bid by withdrawing your tokens.
States of the bonds in auction
Active sale period

 	Losing: this offer was outbid. The user can increase the offer or withdraw the current offer.
 	Winning: This bid is the best, it is the one that is winning. The user must wait for the completion (sale ends) to see if he actually won.

Sale period ended

 	Win: This status is displayed if the bid at the end of the bidding period is the winning one. The user can claim the bond.
 	Lose:This status is displayed if the bid at the end of the bidding period is the loser one. The user can claim (withdraw) his offer of tokens for this bond.




	

	
	
		
			
				There is a potential high risk of liquidation when selling your bonds on Meta Bond Market.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Step-by-step on Meta Bond market.
In the Meta Pool Bond Market page : https://www.metapool.app/bonds/market, displays all the bonds offered on the platform.
Choose a bond and clicking on Action and Buy button


Connect your wallet to make an offer. You can choose between Aurora and Near network. Select your preferal wallet and connect.



Clicking on buy button, allow permission on wallet and you can have a bond.

### How Zero Knowledge Proof Can Ensure Data Privacy

You’ve probably come across the expressions “if it’s free, you’re the product” or “data is the new oil,” and laughed it off as a silly little saying. The truth is data is the driving force behind nearly all businesses and services. For example, personalized experiences and services, marketing, and a host of other insights and services depend on the volume and quality of data provided to them. Most companies are eager to access data to help understand their customers better, predict customer behavior patterns, and improve the quality of their services.

The traditional space has always been subject to concerns surrounding data and privacy. Privacy advocates have long flagged concerns about how data is stored, how it is accessed, and who has access to it. With the growth of the cryptocurrency and blockchain ecosystem, similar concerns have also arisen in this sector. The public nature of blockchains has introduced several privacy concerns for users regarding safeguarding their personal information. This article will take a closer look at the privacy problem on blockchains and how Zero Knowledge (ZK) proofs can mitigate them.
What Is Data Privacy?
The increase in internet usage has brought the issue of data privacy into the mainstream, with nearly all websites, applications, and social media platforms collecting and storing users’ personal information to provide certain services. However, these platforms and websites often do not have adequate safeguards in place to secure the data collected, resulting in numerous data breaches.

With the growth of blockchain technology and the crypto ecosystem, there have been growing concerns about the privacy of retail and institutional users. These concerns are primarily due to the public nature of blockchains, with most Layer 1 and Layer 2 solutions failing to address these issues. Data privacy refers to the ability of users to determine, at their end, when and how their information is shared with others. It also encompasses the ability of users to dictate to what extent their data is shared. This information can include their names, location, contact information, online behavior, likes, dislikes, transaction details, and more.
Trust, Privacy, And The Blockchain 
At present, the cryptocurrency ecosystem is undergoing considerable upheaval following the collapse of major projects such as FTX. However, the underlying technology supporting cryptocurrencies has the potential to revolutionize privacy, trust, and how trust is leveraged. This is critical in the internet age when millions browse and share copious amounts of their personal information to access services and products.

Blockchain technology inherently comes with problems around privacy, thanks to its design. The decentralized nature of blockchains means that nodes processing the transactions or information have access to the blockchain data. For example, the Bitcoin blockchain is publicly available and can be accessed by anyone who wishes to check its transaction history right up to its genesis block. Now, remember, Bitcoin is pseudo-anonymous, which means “[d]ata points which are not directly associated with a specific individual [but where] multiple appearances of [a] person can be linked together.” 

Enough pseudo-anonymous data makes it possible to identify individuals behind transactions, which is concerning for blockchain users, and there are several reasons for this. Unlike data that is used by regular applications, which is accessible only to a few, blockchain data can be scrutinized by everyone, which also includes malicious actors and entities that can exploit the information on the blockchain for their gain. Additionally, the immutable nature of the blockchain means that transactions and data will be permanently linked to the individual. This can be done by monitoring communication between nodes. Additionally, crypto wallets can also be analyzed without access to private keys, further complicating matters.

One high-profile example of using blockchain data to track an individual was the investigation and arrest of Ross Ulbricht, the individual behind the infamous “Silk Road” darknet website, which was used for various illegal activities. Law enforcement agencies identified Ulbricht as the individual behind Silk Road, thanks to blockchain data. Furthermore, they could track Bitcoin transactions and determine that a US Drug Enforcement Administration (DEA) agent was laundering BTC connected to Silk Road. In this case, law enforcement agencies were able to track the data available on the blockchain to identify a notorious individual. But imagine if malicious entities could track your data with such ease thanks to the public nature of the blockchain. The results would be devastating.
Introducing Zero Knowledge Proofs 
Zero Knowledge Proofs were first talked about by Silvio Micali, Shafi Goldwasser, and Charles Rackoff in a paper titled “The Knowledge Complexity of Interactive Proof Systems,” and are considered a fascinating innovation of cryptography that can be utilized in several scenarios. In the case of the blockchain, it can help enable secure and anonymous transactions. Zero Knowledge Proof, also known as Zero Knowledge Protocol, allows one party (the prover) to prove to the opposite party (verifier) that they know a specific value or information (x) without disclosing any information apart from the fact that they know the value or information in question (x). The challenge when it comes to Zero Knowledge Proof is to justify the possession of the information without revealing it or any other additional information. A Zero Knowledge Proof must satisfy the following criteria.

 	Completeness - Let’s assume the statement is true. An honest verifier, correctly and faithfully following the protocol, will be convinced by the information given by the prover who is correctly following protocol.
 	Soundness - Soundness means there should be no way for the prover to falsify any information or falsely convince the verifier. Falsification must be impossible.
 	Zero Knowledge - If the statement by the prover is true, the verifier learns nothing other than the fact that the information is true.

The first two are considered properties of more general interactive proof systems, with the addition of zero knowledge transforming the verification process into a zero-knowledge proof. Due to a small possibility (soundness error) that a malicious prover may convince the verifier of a false statement, zero-knowledge proofs are considered probabilistic proofs rather than deterministic proofs. However, the soundness error can be mitigated to a negligible value.




	

	
	
		
			
				A Zero Knowledge Proof must satisfy what criteria?
			
		

		
					

		
			
			
			
			Completeness
		
			
			Soundness
		
			
			Zero Knowledge
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Does ZKP Work? 

Image Credit

A Zero Knowledge Proof consists of three actions occurring sequentially between participants. These actions are called a witness, a challenge, and a response. Let’s delve a little deeper to understand the role of each action better by assuming there are two participants, A, and B.

Witness - Let’s assume A knows a specific value or information, which also determines a set of questions. These questions can always be answered correctly by A. Initially, A can choose any random question from the set, calculate the proof, and send it to B.

Challenge - After the witness step comes the challenge phase, where B chooses a question from the set and asks A to answer it.

Response - A then calculates the response and sends it back to B. This allows B to determine whether A actually knows the answer.

The process described above can be repeated as many times as required until it is established that A knows the correct answer and the probability of guesses becomes low enough.




	

	
	
		
			
				The paper “The Knowledge Complexity of Interactive Proof Systems” was written by
			
		

		
					

		
			
			
			
			Silvio Micali, Shafi Goldwasser, Charles Rackoff
		
			
			Silvio Micali, Charles Hoskinson, Charles Rackoff
		
			
			Vitalik Buterin, Shafi Goldwasser, Satoshi Nakamoto
		
			
			Charles Hoskinson, Satoshi Nakamoto, Vitalik Buterin
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Use Cases Of ZKP 
ZKP can be applied in several scenarios.
Authentication Systems 
Authentication systems have played a crucial role in fostering research in Zero Knowledge Proofs. In these systems, one party wishes to prove its identity to a second party through some secret information. However, it does not wish for the second party to gain any knowledge about this secret information.
Confidentiality 
One of the most significant use cases of ZKP comes in transactions that require complete confidentiality. Let’s understand how. Consider a blockchain such as the Bitcoin blockchain. Generally, when a transaction occurs on this blockchain, data related to the transaction is recorded on the blockchain. This means anyone can piece together some amount of information about the transaction by analyzing the data on the blockchain. For the sake of privacy, it is critical to hide some details for specific transactions. ZKP makes it possible to hide details while also ensuring the transaction’s validity by adding them to a new block.
Personal Information 
Say you wish to take a loan from a bank. To apply for the loan, you must furnish a host of documentation consisting of a considerable amount of personal information, making it available to third parties. In the case of obtaining a loan from a bank, the only information required by the bank is to know if an individual earns a specific amount enough to repay the loan. ZKP can help banks verify whether an individual earns a predefined minimum amount without revealing any sensitive information to the bank or any third party.
ZKP And Blockchain: The Way Forward 
Several projects and cryptocurrencies utilize ZKP, such as ZCash, SmartCash, Zerocash, and ZeroVert. ZKP has mostly been implement via zk-SNARKS and zk-STARKS.. zk-SNARKS was originally developed by ZCash. Most blockchains are pseudo-anonymous, meaning a user’s identity could be traced back to their transactions by studying blockchain data. This information is available to everyone with access to the blockchain and could be exploited by any malicious entity.

Despite the blockchain’s reputation as the pinnacle of cybersecurity, this particular shortcoming is well-known to users. However, ZKP could help patch this vulnerability and ensure complete privacy when it comes to personal information. While ZKP still has quite a few challenges to overcome, it gives users control of their data and privacy, limiting access to third parties, and will play a crucial role in improving privacy when it comes to blockchains.




	

	
	
		
			
				ZKPs are utilized by
			
		

		
					

		
			
			
			
			ZCash
		
			
			SmartCash
		
			
			Zerocash
		
			
			ZeroVert
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!

### Como usar NEAR no seu celular

Uma forma de usar NEAR no seu celular é a HERE Wallet. Esta é uma carteira sem custódia, o que significa que as chaves privadas são armazenadas apenas no seu telefone.

A HERE Wallet se concentra na maneira mais fácil de usar NEAR. Você pode usar muitos aplicativos diretamente da carteira. O Staking líquido também está incorporado ao aplicativo com uma taxa de saque instantâneo de 0%. Quando você fizer qualquer transferência, o dinheiro será liberado instantaneamente no momento em que a transação seja realizada.

Neste artigo, abordamos como usar os recursos básicos do aplicativo HERE, se você tiver alguma dúvida, pode sempre perguntar à equipe HERE na sala de bate-papo
Faça login com a frase de início (seed phrase)
Se tiver uma Conta Near,  você poderá fazer login em sua conta usando a sua frase de início.

 	Clique em “import existing account” (importar conta existente)
 	Clique em “seed Phrase” (usar frase inicial)
 	Digite a frase inicial e clique em “find my account" (encontrar minha conta)


Caso você tenha uma conta em wallet.near.org

 	Clique em “import existing account” (importar conta existente).
 	Clique em “seed phrase” (usar frase inicial).
 	Digite a “seed phrase” (frase inicial) e clique em “find my account”  (encontrar minha conta).
 	Clique em “import existing account” (importar conta existente).
 	Clique em “share the link” (compartilhar o link)
 	Envie o link para a área de trabalho do seu computador.
 	Abra o link, selecione a conta e clique em “next” (continuar).
 	Clique em “connect” (conectar).
 	Digite o ID da conta e clique em “confirm” (confirmar).
 	Você estará autorizado no dispositivo móvel.


Configurar o nome de usuário (gratuito)
NEAR está disponível com nomes de usuários em vez de endereços. Normalmente, é necessário ter NEAR para criar um nome de usuário, mas os alocamos gratuitamente no aplicativo HERE. Basta digitar o nome de usuário e clicar em “Continuar”
OBSERVAÇÕES IMPORTANTES

Depois de selecionar um nome de usuário, você não poderá alterá-lo. A única alternativa disponível é criar uma nova conta e transferir dinheiro

Não recomendamos o uso do seu sobrenome no nome de usuário, isso pode anular o seu anonimato.


Comece a obter dividendos
A carteira HERE possui staking líquido integrado, o que significa que você pode sacar dinheiro a qualquer momento sem taxas.

 	Clique no botão grande côr de rosa redondo “Earn” (ganhe).
 	Clique em “start staking” (iniciar staking).
 	Digite o montante (amount).
 	Clique “Stake”.
 	Tudo pronto! Agora você receberá uma renda diária à taxa de 8-10% a.a. no seu saldo.


Retirar Dividendos

 	Clique em “claim” (sacar).
 	Espere até que seja carregado.
 	Pronto! Seus dividendos foram transferidos para o seu saldo.


Deposite NEAR com outros ativos

 	Clique em “Add money”  (depositar dinheiro).
 	Clique “buy NEAR with other crypto” (comprar NEAR com outra crypto).
 	Selecionar asset (ativo).
 	Deposite BTC no endereço exibido.
 	Clique em “done” (concluído) após o depósito.
 	Você pode acompanhar o status do depósito no Histórico de transações.


Como usar dApps

 	Selecione HERE Wallet na lista de aplicativos no site.
 	Digitalize o código QR com a câmera (QR scanner) do seu celular.
 	Você será redirecionado para o aplicativo. Clique em “Confirm” (confirmar).



 

### Apa itu NEAR Digital Collective?

NEAR Digital Collective (NDC) merupakan proyek ambisius yang menyatukan antara pengguna, proyek, pihak terkait, dan mitra ekosistem NEAR untuk menciptakan gebrakan yang baru dalam mengatur ekosistemnya sendiri.

NDC yang awalnya disampaikan oleh Illia Polosukhin selaku salah satu pendiri dari NEAR Protocol, akan menjadi gerakan yang sepenuhnya matang yang dipimpin oleh Komunitas NEAR. Tujuannya adalah untuk membangun perbendaharaan komunitas dan model tata kelola yang memungkinkan ekosistem untuk secara kolektif membuat keputusan tentang segala hal mulai dari pendanaan hingga perwakilan yang terpilih dan masih banyak lagi. Ini adalah langkah signifikan untuk menciptakan jaringan yang benar-benar terdesentralisasi.

Dengan menciptakan kerangka kerja yang memungkinkan setiap anggota jaringan untuk menentukan bagaimana NEAR akan berjalan, tujuan NDC adalah menggabungkan transparansi, pengambilan keputusan kolektif, mengembangkan model tata kelola, dan penentuan arah kedepan dengan cara yang benar-benar baru.

NDC berencana untuk melakukan ini dengan membantu menciptakan Konstitusi NEAR, sebuah dokumen pemersatu yang mengabadikan gagasan tata kelola mandiri dan desentralisasi ke dalam inti cara kerja di ekosistem NEAR.




Mengapa ini Penting?
Ekosistem NEAR sendiri sudah memiliki dari lebih dari 1.000 proyek, regional hubs, funding nodes, penyedia infrastruktur, dan lebih dari 20 juta wallet. Jumlah ini sangatlah banyak. NDC didirikan untuk membantu semua pihak yang terlibat berperan aktif dalam perkembangan dari NEAR.

Entah itu terkait bagaimana dana dialokasikan, bagaimana pemilihan berlangsung, atau siapa yang mewakili mosaik kepentingan yang membentuk ekosistem yang berkembang dan beragam ini. NDC ingin membantu setiap orang memiliki suara, dan agar suara itu dicatat secara on-chain.
Bagaimana Cara Kerjanya?
NDC membantu mengembangkan sistem pemerintahan. Setelah diberlakukan, ini akan memungkinkan orang untuk memberikan suara pada berbagai jenis permasalahan, memilih anggota dewan pemerintahan yang berbeda, dan bahkan membuat amandemen konstitusi itu sendiri.

Inti dari NDC menghidupkan kerangka baru tersebut, dan memungkinkan komunitas untuk kemudian terlibat dan mengambil bagian dalam membentuk masa depan NEAR secara aktif.

Pada tahap saat ini, NDC sedang mengerjakan struktur tata kelola yang mencakup bagian-bagian sebagai berikut:

 	Badan Pemungutan Suara (Voting Body) — Ini merupakan setiap akun NEAR yang aktif, sebagaimana yang telah dikualifikasi oleh kerangka tata kelola
 	House of Merit — Sekelompok anggota komunitas berpengalaman yang ditunjuk oleh anggota ekosistem untuk mewakili mereka selama pemungutan suara dan keputusan penting.
 	Dewan Penasehat (Council of Advisors) — Penasihat yang ditunjuk untuk membantu membentuk arah House of Merit.
 	Komisi Transparansi (Transparency Commision) — anggota komunitas yang ditunjuk untuk memastikan checks and balances, penyesuaian dilapangan dan penegakan.
 	Perbendaharaan Komunitas (Community Treasury) — Anggota House of Merit dengan dukungan dari Council of Advisors membantu memfasilitasi pemungutan suara tentang bagaimana dana komunitas dialokasikan.

Kamu dapat menemukan informasi lebih lanjut tentang hal di atas di sini.

Ini adalah pekerjaan yang sedang berjalan, dan saat ini diawasi oleh Kelompok Kerja Tata Kelola, atau Governance Working Group (GWG). Ini merupakan kumpulan anggota komunitas yang berupaya menyempurnakan model tata kelola yang akan membantu setiap orang menyampaikan pendapatnya.The Collective dan GWG mengajak siapa saja untuk berbagi dan berdiskusi. Semua detail tentang prosesnya dapat ditemukan di sini.
Apa Lingkup Pekerjaan dari NDC?
Meskipun model konstitusi dan tata kelola merupakan kunci terpenting, NDC juga akan membantu dalam membentuk, mendefinisikan, dan mewujudkan hal-hal berikut:

 	Konstitusi NEAR.
 	Membuat dan menetapkan pengambilan keputusan on-chain lokal dan global.
 	Membuat dan menerapkan repositori jurnal, log, dan catatan on-chain lokal dan global.
 	Menetapkan badan pengatur, operasional, kekuasaan, dan melakukan check and balances apa yang dibutuhkan masing-masing.
 	Membuat dan memelihara perbendaharaan komunitas dengan seperangkat prosedur operasi dan pengamanan yang lengkap.
 	Membuat dan memelihara Pedoman Komunitas, Kode Etik, dan protokol Penyelesaian Sengketa.
 	Membuat dan menerapkan strategi komunikasi untuk memastikan pekerjaan yang dilakukan oleh NDC dan GWG mudah diakses.
 	Strategi untuk membantu komunitas agar bisa menemukan, mengakses, dan menggunakan NDC.
 	Membantu mengembangkan dan menerapkan Model Tata Kelola DAO
 	Memfasilitasi pertumbuhan ekosistem NEAR secara lebih luas.

Apa Peran Dari NEAR Foundation di NDC?
Foundation adalah mitra dan kontributor NDC. Foundation mendukung pekerjaan yang dilakukan oleh Collective, dan pada akhirnya akan menyerahkan peran pendanaannya kepada komunitas setelah siap melakukannya.

Siapa yang terlibat di NEAR Digital Collective?
Collective dibuat untuk anggota ekosistem NEAR. Beberapa adalah mantan anggota Foundation, lalu terdiri pendiri project dan yang lainnya yang masih menjadi pengguna jangka panjang yang pendukung blockchain serta proyek yang dibangun di atasnya.

Jangan ragu untuk menghubungi salah satu team lead yang ada.
Mengapa Desentralisasi itu Penting?
Desentralisasi merupakan istilah yang identik dengan blockchain, tetapi berasal dari Revolusi Prancis pada abad ke-18.

Desentralisasi dulu, dan sekarang adalah proses di mana kegiatan organisasi, terutama yang berkaitan dengan perencanaan dan pengambilan keputusan, didistribusikan atau didelegasikan jauh dari lokasi atau kelompok pusat yang berwenang.

Ini penting karena, seperti yang akan dikatakan oleh setiap mahasiswa sejarah kepada kita, ketika kekuasaan menjadi terlalu tersentralisasi, peluang penyalahgunaan meningkat. Pada tahun 2022, anggota komunitas blockchain mengalami langsung apa yang terjadi ketika otoritas terpusat menyalahgunakan kekuasaan mereka.

Anggota Komunitas NEAR percaya bahwa tujuan desentralisasi adalah untuk meningkatkan apa yang datang sebelumnya. Kita percaya bahwa peningkatan transparansi dan demokrasi dapat menciptakan komunitas yang adil dan lebih setara untuk semua orang.

Namun untuk mencapainya dibutuhkan komitmen pada sebuah proses. Sebuah proses yang perlu berkembang dan beradaptasi dengan kebutuhan komunitas, dan agar komunitas tersebut dapat mengambil bagian dalam membentuknya.

Desentralisasi tentu sangat penting untuk kebaikan jangka panjang dan keberlanjutan dari sekumpulan orang maupun ide-ide yang ada. NDC adalah bagaimana komunitas NEAR mencoba untuk mencapai itu semua.
Bagaimana Saya Bisa Ikut Terlibat?
Setiap anggota komunitas NEAR bebas untuk bergabung dengan salah satu dari kelompok kerja berikut ini:

 	Constitution
 	Governance & Tech Governance
 	Legal
 	Community Engagement
 	Communications

Kamu bisa memulai dengan menyelesaikan proses onboarding Governance Working Group (GWG).Atau jika kamu ingin mempelajari lebih lanjut mengenai cara kerjanya, kamu dapat melihat di halaman pengenalan awal.
Follow NDC

 	Twitter
 	Discord

### Mengapa DAO harus bermigrasi untuk menjalankan Private Shard?

Mengenalkan DAO dan Multi-sig contracts
Sebagian besar pengguna Web3 akan familiar dengan istilah DAO dan Multi-sig contracts, tetapi bagi orang yang belum mengenal ruang Web3, saya yakin perlu mengetahui kedua istilah tersebut.
Apa itu DAO?
“Decentralized Autonomous Organization” (DAO) adalah entitas yang dipimpin komunitas tanpa otoritas pusat. Ini sepenuhnya otonom dan transparan: kontrak pintar digunakan untuk mengatur pengambilan keputusan dan mendistribusikan kepemilikan aset. Proses pemungutan suara untuk DAO diposting di blockchain, dan pengguna harus seringkali memilih di antara opsi yang sama eksklusifnya. Kekuatan voting sering didistribusikan ke seluruh pengguna berdasarkan bobot voting yang mereka miliki di dalam DAO (jumlah bobot token yang mereka pegang, satu anggota – satu suara, dan lain-lain). Semua suara dan aktivitas melalui DAO diposting di blockchain, membuat semua yang dilakukan pengguna dapat dilihat secara publik.

Untuk membuat keputusan bagi DAO, mereka memanfaatkan multisig wallet (contract).
Apa itu multisig wallet?
Multisig wallet adalah jenis kontrak crypto khusus untuk menyimpan cryptocurrency dengan aman. Ini membutuhkan dua atau lebih kunci pribadi (para pihak DAO) untuk menandatangani dan mengirim transaksi, dan sering digunakan untuk menambahkan lapisan keamanan ekstra ke transaksi dompet dengan memastikan bahwa ada banyak pemegang kunci yang terlibat dalam menyetujui transaksi.

Multisig contract juga dapat dikonfigurasi untuk memungkinkan setiap set kunci pribadi menghasilkan tanda tangan, menjadikannya pilihan yang bagus bagi mereka yang ingin menyimpan mata uang kripto mereka dengan cara yang aman dan bersifat trustless.
Bagaimana DAO saat ini memanfaatkan multi-sig contracts?
DAO menggunakan multisig untuk menyimpan dana mereka dengan aman dan mengelolanya secara efisien. Multi-sig contracts memberi kemampuan kepada banyak pemangku kepentingan untuk menandatangani transaksi, memungkinkan pengelolaan dana dan keputusan yang aman dan beragam. Multisigs juga menyediakan lapisan keamanan tambahan dengan meminta beberapa kunci privat untuk mengakses dana.

Selain itu, DAO dapat menggunakan multi-sig contracts untuk menerapkan sistem pemungutan suara dan tata kelola yang lebih kompleks daripada rata-rata multi-sig contracts. Hal ini memungkinkan pengambilan keputusan menjadi terdesentralisasi dan aman.

Struktur pemungutan suara DAO yang paling umum adalah pemungutan suara kuorum berbobot token, pemungutan suara kuadrat, demokrasi likuid atau delegasi suara atau penguncian suara, dan pemungutan suara kuorum berbasis token.

 	Pemungutan suara kuorum pembobotan Token

Ini membutuhkan ambang pemilih tertentu agar proposal bisa lolos. Misalnya: kuorum 60%, yang berarti bahwa 60% pemegang token harus memberikan suara untuk menyetujui proposal agar dapat disahkan.

 	1 token = 1 suara pemerintahan

Kekuatan suara individu berbanding lurus dengan jumlah token yang mereka pegang.

 	Pemungutan Suara Quadrat

Ini adalah sistem yang menyeimbangkan kepentingan kelompok minoritas dengan tetap mempertahankan proses pengambilan keputusan mayoritas. Liquid democracy atau delegasi suara. Ini memungkinkan orang untuk mendelegasikan suara mereka kepada perwakilan.

 	Penguncian suara

Ini adalah mekanisme yang memungkinkan peserta untuk keluar dari pemungutan suara tanpa penalti.

 	Pemungutan suara kuorum berbasis token

Ini adalah sistem yang membutuhkan ambang batas token tertentu yang harus dipegang oleh pemilih agar proposal dapat lolos.
Tantangan utama yang dihadapi DAO
Masalah utama yang dihadapi DAO termasuk kurangnya status hukum yang diakui dan potensi tanggung jawab anggota yang tidak terbatas, kurangnya regulasi, dan langkah-langkah keamanan yang tidak memadai. Selain itu, DAO rentan terhadap serangan tata kelola, konfigurasi buruk, dan spam. Masalah ini dapat menimbulkan sejumlah risiko, termasuk perlindungan yang tidak memadai untuk data pribadi, kontrak cerdas yang rentan, dan akses dana yang tidak sah.

Sebagian besar masalah teknis yang disebutkan di atas dapat diselesaikan dan sisanya dimitigasi menggunakan Private Shard, tetapi pertama-tama mari kita buka apa itu Private Shard.




	

	
	
		
			
				Apa saja penerapan suara yang dapat digunakan dengan Private Shard di DAO?
			
		

		
					

		
			
			
			
			1 token = 1 suara pemerintahan
		
			
			Pemungutan Suara Quadrat
		
			
			Pemungutan suara kuorum berbasis token
		
			
			Semua Benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Private Shards untuk DAO: Wallet multisig di Steroid

Private Shard adalah sidechain yang dapat disesuaikan (jaringan blockchain yang berjalan bersama blockchain publik dengan kemampuan untuk mentransfer aset dan melakukan panggilan lintas kontrak) yang memungkinkan Anda melindungi data sambil memanfaatkan semua manfaat bisnis dari blockchain open-source. Ini memungkinkan pemilik Private Shard untuk mendapatkan kontrol penuh atas blockchain mereka sambil menyimpan informasi pribadi di antara mereka dan hanya mengizinkan pihak publik tertentu untuk mengakses informasi ini.

Anggota DAO mendapatkan jaringan yang dijalankan oleh mereka berdasarkan kebutuhan mereka. Itu dapat disesuaikan dengan struktur pemungutan suara yang diusulkan di atas di mana validator (node yang memvalidasi blok blockchain) dimiliki oleh anggota DAO serupa dengan bagaimana di dalam multisig mereka akan memiliki kunci pribadi dengan kekuatan pemungutan suara tertentu. Anggap saja sebagai "Multisig pada steroid", karena semua properti multi-sig dasar adalah sama, sambil mendapatkan manfaat dari semua informasi yang hanya disimpan di dalam Private Shard dan tidak dibocorkan ke publik.

Selain itu, anggota DAO dapat menerapkan kontrak pintar khusus di dalam Shard dengan "skalabilitas tak terbatas" yang memberi mereka kemampuan untuk memiliki:

 	pemungutan suara pribadi
 	akuntansi dan penggajian kontraktor
 	menerapkan mekanisme transaksi-berat seperti lelang (yang mungkin terlalu mahal di Mainnet)
 	departemen manajemen keuangan di dalam DAO dan banyak lagi.




	

	
	
		
			
				Private Shard adalah:
			
		

		
					

		
			
			
			
			Basis kode web2 pribadi yang disimpan dalam ekosistem shard tertutup
		
			
			Sebuah sidechain pribadi yang dapat disesuaikan (jaringan blockchain berjalan bersama blockchain publik dengan kemampuan untuk mentransfer aset dan mengeksekusi panggilan kontrak corss)
		
			
			DAO terbuka yang disimpan langsung di blockchain NEAR yang dipecah yang menggunakan validator NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Private Shards bridge memiliki kontrak izin yang memungkinkan mereka untuk menetapkan aturan dimana kontrak/akun publik dan swasta dapat berinteraksi dan sejauh mana. Ini memberikan kemampuan untuk membatasi akses ke pihak atau kontrak tertentu untuk memindahkan aset dari dan ke Private Shard, selain itu juga menyediakan akses ke kontrak pintar tertentu untuk mengeksekusi panggilan kontrak dari Shard atau Mainnet.

Misalnya: DAO dapat memiliki kontrak pemungutan suara pribadi di dalam shard yang memulai panggilan saat pemungutan suara berakhir dan hanya hasil pemungutan suara yang dipublikasikan di Mainnet tanpa mengungkapkan suara anggota tertentu. Perintah ini hanya dapat dijalankan dari dalam shard itu dan tidak ada pihak lain yang dapat mempublikasikannya kecuali kontrak khusus ini. Ini memberikan kemampuan bagi anggota DAO untuk memastikan keamanan pemungutan suara seperti mereka menggunakan multisig, sementara suara sebenarnya disembunyikan dari publik.




	

	
	
		
			
				Private shards memungkinkan DAO untuk memiliki:
			
		

		
					

		
			
			
			
			pemungutan suara pribadi
		
			
			akuntansi dan penggajian kontraktor
		
			
			menerapkan mekanisme transaksi-berat seperti lelang
		
			
			semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Selain itu, Calimero Gateway menyediakan manajemen izin tambahan bagi anggota DAO untuk menentukan kebijakan di mana public users/wallets dapat berinteraksi dengan Private Shard. Sementara anggota DAO menjalankan validator dan memiliki akses admin ke shard, mereka dapat mengundang anggota/wallet eksternal untuk dapat membaca data tertentu atau berinteraksi dengan kontrak tertentu.

Misalnya: DAO dapat memiliki kontrak pribadi di dalam shard agar pihak eksternal dapat mengajukan proposal yang dapat dipilih oleh DAO. Ini hanya dapat mengizinkan pengirim dan anggota DAO proposal untuk melihat informasi mereka tentang status proposal. Mengirimkan proposal dapat dibatasi pada daftar putih dompet yang ditambahkan oleh DAO atau untuk masyarakat umum.

Kami percaya bahwa Private Shard adalah pertumbuhan alami yang selanjutnya untuk DAO dan ingin bekerja dengan lebih banyak DAO dalam transformasi berikutnya di Web3. Jangan ragu untuk menghubungi kami jika Anda memiliki pertanyaan atau ingin memesan demo.

### O que é Burrow?

Este guia de usuário foi criado em colaboração com NEAR Mates e NEAR Insights. Siga-os no Twitter para obter mais conteúdo NEAR de qualidade, como abaixo. Artigo de origem no Medium
O que é Burrow?
Burrow em inglês significa cavar, o que explica o fato do mascote ser um castor. A plataforma Burrow é um mercado monetário autônomo descentralizado (AMM), não custodial e de natureza semelhante ao Aave e ao Compound. 

Burrow visa desbloquear liquidez para ativos com juros, particularmente derivativos de staking de camada 1, como stNEAR e stETH. Os usuários do Burrow poderão depositar stNEAR como garantia, depois emprestar mais NEAR para criar uma posição de staking alavancada ou emprestar uma stablecoin para fazer uma posição de auto-reembolso.


Começando

New to NEAR?
Se você não tiver uma conta NEAR, basta seguir este guia para configurar sua carteira NEAR primeiro!

Conecte sua carteira NEAR
Inicie o aplicativo Burrow e conecte sua carteira NEAR no canto superior direito.








Como alocar seus ativos
Os usuários podem fornecer ativos ao protocolo e começar a ganhar juros. As taxas de juros são variáveis ​​e flutuarão com base na taxa de utilização de determinado ativo. (Mais informações sobre o modelo de taxa de juros aqui.)

Ativos suportados no lançamento:

 	NEAR
 	stNEAR (staked NEAR)
 	ETH
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (Burrow’s native token)

1. Vá em “Deposit” e escolha o ativo desejado
Navegue até a seção “Depósito” e clique no ativo que deseja depositar.





2. Selecione o valor que deseja depositar e envie sua transação.
3. Depois de depositar seus ativos, agora você tem duas opções:




(1) Ative "Use as collateral". (Usar como garantia)

Isso significa que agora você poderá emprestar ativos contra o valor que depositou no pool de suprimentos.

Isso também significa que seus fundos podem ser liquidados. Consulte as seções “Health Factor” (Fator de Saúde) e “Liquidation” (Liquidação) abaixo para obter mais informações.

(2) Basta fornecer ativos, não "Use as collateral". (Usar como garantia). 

Isso significa que você simplesmente ganhará juros sobre o valor que forneceu ao pool, sem emprestar mais nenhum ativo. Nesse caso, seus ativos não estão sujeitos a liquidação.

Você sempre pode ativar "usar como garantia" posteriormente na página "Portfólio".
4. Aprove a transação no prompt NEAR wallet.




Seu depósito foi registrado com sucesso e você pode começar a ganhar juros. O número “APY” (rendimento percentual anual) informa quanto você pode esperar em recompensas de $BRRR pelo fornecimento de ativos.


Como pedir emprestado

Agora que você forneceu seus ativos para o pool de liquidez da Burrow, também pode emprestar fundos contra ele.

1. Designe seus ativos como garantia
Para emprestar ativos, você deve primeiro habilitar"Use as collateral". (Usar como garantia). Se você não ativou o botão “Usar como garantia” durante o depósito, você pode ajustar sua posição na seção “Carteira” → “Adjust Collaterl” (Ajustar garantia).

No Burrow, você pode escolher quais ativos depositados deseja usar como garantia, além de personalizar a taxa de colateralização.




2. Na página "Borrow", selecione o ativo que deseja emprestar




3. Insira o valor que deseja emprestar, tendo em mente o fator de saúde resultante




O que é o “Health Factor” (Fator Saúde)?
O risco de uma posição pode ser entendido através do Health Factor, que representa os índices de garantias combinados dos ativos emprestados.

 	Se o fator de saúde for superior a 100%, significa que a conta está em bom estado e não pode ser liquidada.
 	Se o fator de saúde for inferior a 100%, significa que a conta pode ser parcialmente liquidada e não pode emprestar mais sem reembolsar algum valor dos ativos existentes ou fornecer mais ativos de garantia.

Para saber mais sobre como o fator de saúde é calculado, veja aqui.

O que é “Liquidação?
Liquidação é quando sua posição é fechada à força pelo protocolo (ou seja, sua garantia é vendida) porque, devido a mudanças nas condições de mercado, o valor de sua garantia não é mais suficiente para garantir sua dívida com base no fator de saúde, o que significa que você correm o risco de não conseguir pagar sua dívida. Esse tipo de insolvência ameaça o protocolo e, portanto, um evento de liquidação é acionado por meio de bots para evitá-lo antecipadamente.

Isso pode acontecer quando:

 	A garantia diminui de valor (por exemplo, o preço wNEAR diminui de 20$ para 10$)
 	A dívida emprestada aumenta de valor

Você pode ler mais sobre liquidação aqui.

TL;DR
Quando seu fator de saúde é…

 	Verde: Seus fundos estão (geralmente) protegidos
 	Amarelo: o risco é moderado
 	Vermelho: Seus fundos correm alto risco de serem liquidados

Aviso

 	Recomendamos que os usuários NÃO definam a taxa de utilização de garantias em 100%. Você está pedindo para ser liquidado!
 	O fator de saúde pode mudar se o preço dos ativos subjacentes mudar muito. Recomendamos que os usuários monitorem seu fator de saúde de tempos em tempos, especialmente se houver mudanças rápidas nas condições do mercado.

4. Envie e aprove a transação







Como gerenciar seus ativos
Acesse “Portfolio” (Carteira) no menu para visualizar e gerenciar seus ativos depositados e emprestados.

APY líquido
Seu “Net APY” é o seu APY total (rendimento percentual anual) que calcula quanto você está ganhando com o depósito de ativos (depósito APY) menos o quanto você deve ao protocolo de empréstimo (empréstimo APY).

Retirar
Escolha o ativo que deseja retirar e clique em “Withdraw”.





Se você quiser retirar todos os seus ativos, certifique-se de pagar sua dívida primeiro. Se retirar a 100% não funcionar, diminua para 99% ou mais e tente novamente.

Se você estiver retirando apenas uma parte de seus ativos e mantendo sua posição de dívida, tome cuidado com a forma como isso alterará o fator de saúde e gerenciará seu risco de liquidação.




Ajustar garantia
No Burrow, você pode personalizar a taxa na qual seus ativos são garantidos e defini-la de maneira diferente para cada ativo fornecido. Isso é diferente dos protocolos de empréstimo anteriores, cujas taxas de garantias eram definidas a uma taxa de inadimplência.

Você pode definir a taxa de garantia desejada quando depositar seus ativos pela primeira vez ou ir para “Portfolio” e clicar em “Adjust Collateral”.




Reembolsar
Para quitar sua dívida pendente, vá para a seção “Portfolio” e clique no botão “Repay” (Reembolsar).





Depositar NEAR, reembolsar com wNEAR?
Devido à diferença nos padrões de token, Burrow (e a maioria dos outros dapps DeFi em NEAR) usam wNEAR (Wrapped NEAR ou “ NEAR envelopado), não NEAR.

Quando você depositar, seu NEAR será automaticamente empacotado, então não há nada que você precise fazer. No entanto, se você emprestou $wNEAR e deseja reembolsar, deve trabsformá-lo em wNEAR. Use a página Ref Finance Wrapping para agrupar seu NEAR em wNEAR primeiro.

No futuro, o Burrow oferecerá suporte ao wrap/unwrap direto no próprio aplicativo. Além disso, a função wrap/unwrap será integrada à carteira NEAR para que esse problema seja resolvido mais facilmente.




Para ler sobre a diferença entre wNEAR e NEAR, consulte nosso FAQ.





Burrow está ao vivo na Mainnet! Leia este FAQ para começar
A espera acabou! O primeiro mercado monetário no NEAR nativo está finalmente disponível na rede principal. Isso significa mais liquidez e DeFi…

burrowcash.medium.com










Em breve: xBRRR Staking!
Em breve, o staking será ativado em Burrow. Os usuários podem apostar seu BRRR e receber xBRRR, com o qual podem acessar recompensas aprimoradas e participar da governança do protocolo. Fique atento!



Torne-se um investidor Burrow
Dapp • Twitter • Discord • Docs

### Toolblox, pembuat smart contract tanpa kode

Toolblox, pembuat smart-contract tanpa kode
Toolblox adalah pembuat smart-contract tanpa kode dan pembuat DApp. Dalam postingan ini kami bertujuan untuk menunjukkan semuanya; apa yang kami lakukan dan mengapa itu diimpor.

Toolblox Workflow Builder dan user interface yang dibuat secara otomatis 
Sejarah singkat
Project ini dimulai pada awal tahun 2022 sebagai entri hackathon Near Metabuild II, berhasil memenangkan hadiah utama yang kemudian dijadikan sebagai modal awal. Toolblox juga telah memenangkan hadiah lain selama tahun ini seperti terpilihnya sebagai best of Tooling & Infrastructure pada Polygon BUIDL IT hackathon.

Sejak versi pertama, user interface telah disederhanakan 10x dan pembuat DApp juga telah ditambahkan. Meskipun awalnya hanya mensupport satu blockchain dan lima lainnya ditambahkan.

Toolblox sebentar lagi akan genap berusia 1 tahun dan kami siap memperlihatkan dan membaginya dengan seluruh dunia.
Smart contract yang dieksekusi sendiri
Smart contract adalah perjanjian yang dijalankan sendiri yang dikodekan sebagai program komputer. Ketika pemicu tertentu dipanggil, smart contract dapat segera mengambil tindakan seperti menyelesaikan pembayaran atau mentransfer kepemilikan. Hal ini dimungkinkan karena pada blockchain tidak diperlukan otoritas pusat. Tanda tangan digital digunakan dan status program tidak dapat diubah.

Smart contract yang dieksekusi sendiri dengan demikian diposisikan secara unik ke:

 	Menanamkan kepercayaan, keadilan, dan transparansi ke dalam sistem atau proses yang ada.
 	Memutus perantara dan agensi terpusat.
 	Menangani beragam alur kerja — dari bentuk bisnis konvensional yang mempertahankan lokasi fisik, menjadi rantai pasokan, kemudian menjadi digital native business (operasi bisnis menggunakan teknologi digital) yang disebut sebagai Decentralized Autonomous Organizations atau DAOs.

Smart contract  akan berada dimanapun, memperkuat jaringan bisnis di masa depan. Smart contract bisa dan harus menggantikan tulang punggung dari setiap dan semua produk manajemen proses bisnis SaaS terpusat.
Pendekatan Kami
Toolblox menyediakan pembuat smart contract berbasis alur kerja yang sangat sederhana untuk membantu perusahaan dengan cepat membuat kehadiran mereka di blockchain: membangun alur kerja dan menyebarkannya sebagai aplikasi yang dapat digunakan.

 	Tanpa Code

Seseorang akan selalu bisa berinvestasi dalam tim pengembangan atau mempekerjakan tenaga profesional untuk membuat kode alur kerja khusus. Tetapi untuk sisanya — 90% bisnis kecil dan bisnis mikro, nirlaba, DAO, dsb — yang hanya ingin tetap fokus, pendekatan tanpa kode visual adalah cara yang tepat. Dengan lebih sedikit investasi di awal, akan lebih banyak fleksibilitas, prototyping yang cepat, dan lebih cepat ke market.

 	Alur kerja berbasis state-machine

Blockchain bukan hanya sebatas tentang data, melainkan tentang keadaan, terutama tentang transisi keadaan — persimpangan di mana sebuah nilai ditransfer — antara uang riil, kepemilikan atau keduanya. Jantung dari seluruh proses bisnis atau sebuah kontrak. Diusulkan pula oleh Hyperledger Foundation bahwa, sebuah alur kerja berbasis state-machine sangat cocok untuk visualisasi smart-contract.

Pelajari tentang pembuat alur kerja kami.

 	User Interface out of the box

Walaupun sebenarnya hebat unutuk bisa menjalankan smart-contract yang khusus dengan mudah, mereka juga harus bisa digunakan — baik untuk berbagi dengan pengguna akhir atau melibatkan mitra bisnis. Inilah mengapa Toolblox membuat aplikasi sederhana secara otomatis. Untuk penyesuaian dan user interface yang lebih kompleks, kami memiliki DApp builder yang memungkinkan untuk merancang aplikasi terdesentralisasi tanpa kode apapun.

Pelajari tentang DApp builder kami.

 	Terintegrasi dengan ekosistem.

Banyak opsi untuk berintegrasi dengan layanan eksternal (seperti asuransi token, kolateralisasi, portal NFT, fraksionalisasi, dll):

 	setiap alur kerja dapat dibuat kompatibel dengan ERC721
 	Token ERC20 (seperti USDT, USDC, EURC dll) dapat digunakan sebagai pembayaran
 	Blockchain event dapat digunakan untuk integrasi lebih lanjut
 	integrasi media sosial yang terdesentralisasi.

Untuk siapa ini ditujukan?

 	Decentralized Autonomous Organizations (Organisasi Otonomi Terdesentralisasi) ingin mengelola alur kerja dan proyek khusus.
 	Rantai pasokan dan komoditas industri terkait untuk menangani tugas mulai dari produksi hingga ritel dan perdagangan.
 	Usaha kecil dan usaha mikro yang tidak memiliki pengetahuan khusus dan akan mendapat manfaat dari segudang solusi (statusm logika dan pembayaran).

Kenapa harus menggunakan Toolblox?
Berikut adalah beberapa cara yang dapat dipikirkan tentang Toolblox di organisasi mana pun:

 	Alat digitalisasi — untuk membangun proses bisnis pada rantai dan berbagi aplikasi dengan pengguna dan mitra.
 	Alat pembuatan prototipe cepat — untuk membuat DApps yang dapat digunakan dan dibagikan untuk mengatasi masalah tertentu.
 	Yang memulai pengembangan — untuk membuat draf smart contract dan kemudian mengembangkannya lebih lanjut dengan sumber daya tertentu.
 	Tulang punggung dari produk yang telah ada — untuk menghubungkan produk yang sudah ada untuk menggunakan blockchain sebagai satu sumber data keadaan yang tidak berubah dan aman.

Contoh Alur Kerja
Berikut adalah beberapa alur kerja/DApps yang dibangun dengan Toolblox. Setiap alur kerja terdiri dari elemen-elemen berikut:

 	Item (project, document, offer, proposal, dll)
 	Item attributes (name, deadline, author, owner, client, dll)
 	Workflow states (active, cancelled, waiting for feedback, dll)
 	State transitions (amend, pay, create, agree, update, dll)

Semua project berikut dapat digunakan sebagai DApp dan dapat digunakan sebagai template untuk membuat smart contract baru.
DAO fundraising untuk project

Ringkasan DAO Fundraising (toolblox.net)
Distributed Wedding Registry (Distribusi Status Nikah yang Terdaftar)

Ringkasan Distributed Wedding Registry (toolblox.net)
Ask me anything (AMA) with bounty

Ringkasan Ask me anything (AMA) with bounty (toolbox.net)
Real-estate appraisal workflow (Alur kerja penilaian real-estate)

Ringkasan Real-estate appraisal workflow (toolbox.net)
3d print price offers dan prints management

Ringkasan 3D printing offer registry (toolblox.net)

Lihat web www.toolblox.net dan Twitter kami untuk lebih banyak contoh! Dan bergabunglah dengan academy.toolblox.net untuk tutorial dan dokumentasi tentang cara membangun dengan Toolblox.

### O Guia para Finanzas de PembRock

Aproveite as vantagens do LYF (Leveraged Yield Farming) com PembRock

Introdução

Neste guia, examinamos as formas mais difundidas de ganhar com DeFi

—yield farming (farming de rendimento), lending and staking (prestamos e participação)— através das lentes de PembRock, a primeira e única plataforma LYF no protocolo NEAR que é alimentada por Ref.finance DEX.
Vamos começar com o básico.
O que é Yield Farming?
Para que qualquer projeto de Finanças Descentralizadas funcione, é necessário que haja liquidez. A liquidez é o que torna as transações possíveis, e os participantes que tornam as plataformas líquidas são chamados de Provedores de Liquidez, ou LPs. Agora, por fazer isso, eles são recompensados ​​com os tokens LP de um pool específico (também chamados de 'ações') por meio de um processo conhecido como mineração de liquidez. Esses tokens representam a participação do usuário na liquidez total, que por sua vez determina seus lucros potenciais.

Yield farming é um incentivo extra que recompensa os usuários pelo simples fato de bloquear seus fundos para que outros participantes possam usá-los para ganhar a si mesmos. Depois de receber os tokens LP, um provedor de liquidez pode colocá-los em um yield farming pool  para se tornar um “farmer” (agricultor). Para isso, eles receberão pagamentos extras na criptomoeda nativa da plataforma (no caso da Ref.finance, seria $REF; no caso da PembRock, seria $PEM; e assim por diante) ou uma criptomoeda diferente (por exemplo, USDT), dependendo das regras de um determinado programa de farming.

O que é Yield Farming alavancado?

Com o regular Yield  Farming (farming de rendimento regular), você só pode fornecer a quantidade que possui, o que parece lógico. Mas e se você quiser maximizar retornos (e riscos, não se esqueça disso)? Nesse caso, você precisaria emprestar fundos de outras pessoas, e é isso o que Yield farming alavancado ajuda a fazer.

Enquanto muitas plataformas DeFi exigem que os usuários coloquem fundos de valor maior do que os emprestados (o que também é conhecido como sobrecolateralização), o PembRock não exige, dando aos agricultores a oportunidade de sacar o valor até três vezes maior.

Portanto, se você, por exemplo, decide fornecer 100 USN como garantia e toma emprestado 200 USN, terá 300 USN no total, o que significa que o nível de alavancagem seria 3 a um índice de endividamento de 67%. Se o preço do USN caísse mais de 31%, isso significaria que sua perda não poderia mais ser coberta. É quando a liquidação aconteceria.

O que é Empréstimo?
O empréstimo é uma estratégia que permite que você ganhe juros por permitir que outra pessoa use seu dinheiro. Ao mesmo tempo, ao contrário dos farmers, os credores não estão sujeitos ao risco de liquidação (por exemplo, pense em uma situação em que um dos ativos em um pool cai para $ 0), enquanto seus retornos são compostos automaticamente e pagos regularmente. Parece justo, certo?
Antes de começar
Vá para app.pembrock.finance e pressione o botão Connect wallet que você verá no canto superior direito. A janela do seletor de carteira aparecerá; escolha o que você prefira. Depois disso, você será levado à sua carteira, onde terá que habilitar certos direitos de acesso e permitir que o PembRock App gaste parte do seu NEAR para cobrir as taxas de transação.

Para obter farming de rendimento com alavancagem , você precisará primeiro carregar sua carteira com o ativo com o qual deseja fazer isso.

Passo 1. Vá para a seção Farm: app.pembrock.finance/farm.

Passo 2. Selecione o par e clique em Farm

Passo 3. Escolha o ativo que deseja depositar, aquele que deseja tomar emprestado, seus valores e a alavancagem (entre 1x e 3x com incremento de 0,5).

Passo 4. Clique Farm e confirme a transação. Observe que você pode ter várias posições de farming abertas ao mesmo tempo; portanto, se tiver outro pool em mente, volte e repita o processo.
Fechando uma posição agrícola e reivindicando recompensas
Passo 1. Vá para Portfolio e mude para  Farm Positions.

Passo 2. Pressione Close (Fechar) ao lado da posição da qual deseja sair.

Passo 3. Na próxima tela, você pode fechar a posição por completo.

Minimize Trading (Minimizar negociação): significa que converteremos a quantidade mínima necessária de tokens no token emprestado para pagar a dívida e lhe devolver os ativos restantes.

Convert all (Converter tudo): significa que toda a sua posição será convertida para o token emprestado e devolvida a você após o pagamento da dívida.

Passo 4. Se você deseja fechar sua posição totalmente, role para baixo e pressione Close Position (Fechar posição) e, em seguida, faça uma aprovação em sua carteira.




	

	
	
		
			
				No que diz respeito à agricultura de rendimento alavancado, PembRock…
			
		

		
					

		
			
			
			
			 Sobrecolateraliza
		
			
			Subcolateraliza
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Para fazer uso do empréstimo, você precisará primeiro recarregar sua carteira com o ativo que vai fornecer.

Passo 1. Vá para  app.pembrock.finance/lend, selecione o ativo e clique em Deposit (Depositar).

Passo 2. Especifique o valor que deseja emprestar e confirme a transação. Observe que você pode emprestar mais de um pool por vez, portanto, se tiver outro ativo em mente, volte e repita o processo.

Claiming Rewards (Reclamando recompensas)
A PembRock Finance incentiva credores e tomadores de empréstimos (agricultores/Farmers).

Passo 1. Vá para app.pembrock.finance. Lá, você verá um guia Portfólio com uma subseção Recompensas desbloqueadas (Unlocked Rewards)

Passo 2. Pressione Claim e aprove a transação dentro de sua carteira.
Fazendo Retiradas/Ajustes
Passo 1. Vá para  app.pembrock.finance/lend-pools. Lá, você verá uma lista de ativos que você forneceu.

Passo 2. Escolha o ativo que você não deseja mais emprestar e clique no botão de seta para baixo à direita da caixa.

Passo 3. Insira o valor que deseja cancelar o empréstimo e pressione Withdraw (Retirar)

Como alternativa, você pode ajustar a posição adicionando mais tokens ao empréstimo.

Sobre a PembRock

A PembRock foi criada pela  INC4 - uma empresa profissional de desenvolvimento de blockchain de origem ucraniana que existe desde 2013.

A principal ideia por trás da PembRock era trazer negociação com alavancagem - uma ferramenta amplamente disponível para jogadores nos mercados financeiros tradicionais - para um setor de DeFi nascente, mas em tendência.

Em março de 2022, a PembRock Finance recebeu uma subvenção de US$75.000 da NEAR Foundation com o objetivo de auxiliar no desenvolvimento, aprimoramento e adoção do protocolo.
Utilidade $PEM
PEM é o token digital nativo de protocolo da PembRock. Ele tem quatro casos de uso principais:

 	Os detentores de PEM que fazem staking (participação) em seus tokens compartilham toda a receita gerada pelo protocolo.
 	Eles também orientam o processo de tomada de decisão do projeto por meio da participação na DAO.
 	O token é central para o mecanismo que distribui recompensas pela interação com o protocolo.
 	$PEM também é usado para fornecer um bônus adicional para aqueles que fornecem liquidez aos nossos pools.

Para lugares onde comprá-lo, procure aqui

 	Nome: PembRock Finance Token
 	Senha: PEM
 	Oferta Total: 160M unidades
 	Rede: NEAR Protocol
 	Endereço do contrato: token.pembrock.near





	

	
	
		
			
				Qual utilitário o token $PEM NÃO possui?
			
		

		
					

		
			
			
			
			Partilha de Lucros
		
			
			Votação
		
			
			Incentivo
		
			
			Distribuição NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O que é Staking?
Dentro do protocolo PembRock, Staking significa bloquear o PEM em troca do direito de obter uma parte das receitas obtidas pelo protocolo e de participar da Organização Autônoma Descentralizada (DAO), influenciando decisões - inclusive sobre quanto os farmers e lenders (credores) mencionados acima devem ganhar. Quanto maior é a quantidade em staking e maior o período, maior o poder de voto e as recompensas.

Digamos que você faz staking de 1.000 PEM por 4 anos em troca de 1.000 unidades de poder de voto (que é concedido na forma de tokens vePEM), enquanto outra pessoa faz staking de 1.000 PEM por 2 anos em troca de 500 unidades de poder de voto (porque mesmo que o staking deles é do mesmo volume, o segundo foi por um período duas vezes menor). Juntos, seu poder de voto seria de 1.500. Portanto, se um protocolo gerasse 100 PEM em recompensas semanais, você obteria 66,66 PEM (porque sua participação no valor total do staking seria de 66,66%) e outro participante apenas 33,33 PEM (a deles seria 33,33%).
Como fazer Staking
Para fazer staking e ingressar na DAO, você precisará do token digital nativo da PembRock chamado PEM. Se você ainda não possui nenhum PEM, aqui poderá corrigir isso.

Passo 1. Vá para  app.pembrock.finance/staking;

Passo 2. Digite o valor do staking e a duração (o poder de votação estimado pode ser visto abaixo da Data Final).

Passo 3. Pressione Confirm (confirmar)
Como fazer ajustes
O poder de votação está diminuindo gradualmente, mas você pode ajustar sua posição (stake mais e/ou por mais tempo) para manter sua influência no mesmo nível ou até mesmo torná-la mais substancial.

Passo 1. Role para baixo até a parte inferior app.pembrock.finance/staking;

Passo 2. Digite o valor de staking que deseja, além do que já fez e pressione Confirm (Confirmar).

Passo 3..Depois disso, você pode prolongar o período de bloqueio

Reclamos & Retiros
Para retirar o PEM assim que o período de bloqueio terminar ou solicitar o pagamento de suas recompensas no PEM, visite app.pembrock.finance/staking Uma vez disponíveis, os botões ficarão laranja.




	

	
	
		
			
				Qual das seguintes afirmações é verdadeira?
			
		

		
					

		
			
			
			
			O valor apostado (stakeado) é o único fator que determina o poder de voto
		
			
			O período de aposta é o único fator que determina o poder de voto
		
			
			Tanto o valor quanto o período determinam o poder de voto
		
			
			Nenhuma das acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como participar na DAO
Na DAO, você pode definir a quantidade de recompensas que vão para lenders e farmers todos os meses.

Passo 1. Vá para  app.pembrock.finance/voting. Lá, você verá duas guias - Recompensas dos lenders e borrowers (mutuários).

As recompensas dos Lenders são ganhas pelos participantes que depositam em pools de empréstimos. As recompensas dos borrowers são obtidas pelos participantes que emprestam ativos de pools de empréstimos.

As etapas abaixo são as mesmas para ambos.

Passo 2. Distribua seu poder de votação para pools usando o campo Vote (Votar). Quanto maior % você der, maior será o retorno que irá gerar.

Lembre-se de que todas as % devem somar 100.

Passo 3. Aperte Vote e confirme a transação na sua Carteira NEAR.

Se mudar de ideia, você pode votar novamente enquanto a janela ainda está aberta. Ao fazer isso, certifique-se de especificar % para todos os ativos novamente.
Conclusão
A PembRock está apenas ganhando impulso, já que o mercado DeFi em geral e o espaço de farming de rendimento alavancado (leveraged yield farming) em particular ainda estão em sua infância. Assim como Ref Finance foi um pioneiro no espaço DeFi da NEAR, o PembRock se tornou o primeiro e único protocolo de farming de rendimento alavancado da rede. Então, se você quer estar entre a multidão que define tendências, por que não experimentá-lo (embora, cuidado com o risco)?

Se você quiser se manter atualizado sobre tudo o relacionado com o PembRock, abaixo estão alguns links para você:

PembRock Website | Twitter | Telegram | Discord

### Auditoria de projetos na blockchain NEAR: recruta a marechal

Olá queridos leitores!

Hoje vamos olhar algumas dicas profissionais na auditoria de contratos inteligentes na blockchain NEAR. Nesta série, vamos nos concentrar apenas nos aspectos que podem ser realmente úteis para a auditoria de projetos baseados na NEAR. Tudo o que você verá abaixo é baseado na nossa experiência pessoal!

Em primeiro lugar, gostaríamos de expressar nossa sincera gratidão aos criadores da NEAR e seus projetos do ecossistema, a todos que a apóiam, aos autores de todos os materiais de recursos e, claro está, aos nossos brilhantes auditores que nos ajudaram revelando informações muito necessárias e levantando o véu do segredo. E hoje, queridos leitores, isso estará disponível para vocês.

Podemos dizer com confiança que dicas como essas podem ser lidas publicamente em poucos lugares e nosso blog é um desses lugares! O seguinte será nossas observações – apenas fatos diretos para auditores, truques e os melhores macetes compartilhados pelos nossos melhores auditores. Vamos começar!

A propósito, há alguns espaços vacantes neste momento, portanto, se o seu projeto precisar de uma auditoria - sinta-se à vontade para nos escrever (write), visite nossa página de relatórios públicos here (aqui).
I — O que é NEAR?
NEAR é uma plataforma de desenvolvimento construída sobre uma blockchain  de primeira camada, fragmentada, e com prova de participação. Usando a tecnologia sharding (fragmentação), a NEAR oferece soluções para problemas como, baixa velocidade de processamento, congestionamento de rede e altas cargas de gás, permitindo uma escalabilidade significativa da plataforma sem sacrificar a segurança do protocolo.

É importante ter em mente que NEAR é uma blockchain fragmentada escalável o que significa que os contratos inteligentes implantados são compilados para WebAssembly (WASM) e podem ser escritos nas seguintes linguagens :

 	Rust
 	AssemblyScript (uma linguagem de programação TypeScript para WebAssembly)
 	Solidity (via Aurora EVM)
 	Javascript (via JS-VM)

O uso de WASM resulta em um alto limite de gás e eficiência, geração rápida de blocos e taxas de transação mais baixas. Os contratos inteligentes na NEAR podem ser considerados microsserviços contendo dados e códigos executáveis. As interações entre contratos são realizadas de forma assíncrona.

Com tudo o dito, desde nossa perspectiva, o ecossistema NEAR é principalmente baseado em Rust.

https://github.com/rust-in-blockchain/awesome-blockchain-rust

A plataforma reúne milhares de membros da comunidade para entregar a experiência mais confortável, além de um ecossistema multifuncional de ampla gama.

A plataforma está baseada em vários recursos principais:

Em termos de segurança de produção de blocos, eles empregam um mecanismo conhecido como Doomslug. Doomslug, apesar de seu nome sinistro, é bastante simples e assume que diferentes validadores se revezam produzindo blocos com base em quantos tokens NEAR foram postos em stake.

Não entraremos em detalhes neste artigo porque assumimos que você, caro leitor, já possui um conhecimento suficiente do ecossistema NEAR, por isso recomendamos fortemente que você visite sua base de conhecimento e estude a documentação do projeto para um melhor entendimento:

https://docs.near.org/
II — Procedimento de Revisão de Projeto NEAR do Time Pessimistic.io:
Como os principais obstáculos que o auditor pode encontrar ao auditar projetos no NEAR são lógicos, a primeira sugestão para qualquer empresa estará em um desenvolvimento competente, o que resulta em documentação sólida e testes confiáveis. Parece simples demais para ser verdade, mas tenha certeza de que funciona e só se prova com o tempo!

Então, nossa brilhante equipe de auditoria gostaria de apresentar-lhe o nosso próprio regulamento, acumulado ao longo de muitos meses e anos de trabalho, no qual tentaremos evitar redundâncias e tentar transmitir tudo de forma muito concisa e profissional. Com tudo dito, realizamos nossa auditoria de acordo com os seguintes procedimentos:
Análise automatizada:

 	Compilamos contratos;
 	Executamos testes fornecidos e verificamos a cobertura do código;
 	Executamos ferramentas de análise e verificamos manualmente (rejeitamos ou confirmamos) todos os problemas relatados (veja abaixo);

Análise manual:

 	Revisamos manualmente o código e avaliamos sua qualidade;
 	Verificamos o código à procura de vulnerabilidades conhecidas;
 	Verificamos se a lógica do código está de acordo com a documentação fornecida;
 	Sugerimos possíveis otimizações de gás e armazenamento;

Problemas:
Estamos ativamente à procura de:

 	Problemas de controle de acesso (identificação/autorização incorreta do administrador ou dos usuários);
 	Problemas de ativos perdidos/roubados (ativos presos no contrato ou enviados para lugar nenhum ou para uma conta errada);
 	DoS devido a problemas lógicos (deadlock, erro de máquina de estado, etc);
 	DoS devido a problemas técnicos (erros por falta de Gas, outras limitações);
 	Problemas de interação do contrato, (reentrância, chamadas inseguras, suposições do chamador) ;
 	A Problemas aritméticos (overflow, underflow, problemas de arredondamento);
 	Uso incorreto da Near SDK;
 	Outros problemas.

Gas:
Verificamos se as operações com uso intensivo de gás são realizadas de forma eficiente:

 	Coleções: As coleções de std::collections são lidas todas juntas, o que aumenta o consumo de gás. Você deve usar near_sdk::collections ou near_sdk::store; As coleções estão vinculadas a um armazenamento e você pode acidentalmente esquecer de sincronizá-las;
 	Mapas: LookupMap / UnorderedMap / TreeMap — Você precisa escolher de acordo com a funcionalidade necessária (a primeira é a mais barata e a última a mais poderosa);
 	LazyOption — para “big data” raramente usado (só pode ser usado no construtor); Borsh/JSON para serialização de mensagens (parâmetros/valores de retorno) — afeta o consumo de gás;
 	Dê uma olhada mais de perto em The “million cheap data additions” attack para evitar problemas semelhantes.

Ferramentas:
Vamos dar uma olhada mais de perto nas ferramentas de análise automática que você pode usar em seu trabalho e suas características:

 	Valgrind — pode ser usado se o código incluir blocos inseguros com alocação de memória perigosa. No entanto, tal prática levanta uma bandeira vermelha para a auditoria. Em geral, executar valgrind não faz muito sentido!
 	Cargo Geiger é uma ferramenta que exibe estatísticas sobre o uso de código Rust não seguro em uma caixa Rust e todas as suas dependências. Sua capacidade de se concentrar em possíveis problemas é uma característica benéfica. A existência de códigos perigosos já é um problema em tais projetos, e qualquer uma dessas entradas deve ser verificada duas vezes.
 	Cargo Audit — verifica os arquivos em busca de caixas que contenham vulnerabilidades de segurança. Ou seja, exibe bibliotecas desatualizadas que todos ainda usam. No entanto, você deve usá-lo para fins de auditoria.
 	Clippy O analisador estático é um código linter, incrível para detectar erros comuns e melhorar seu código Rust.
 	Cargo Tarpaulin — para cobertura de teste — uma ferramenta muito útil que revela o número de linhas de código que não são cobertas por testes.

III — Relatórios Públicos de Auditoria
Nossos Relatórios Públicos de Auditoria dos projetos do ecossistema NEAR são estruturados de acordo com um esquema de fluxo de auditoria apresentado acima, por isso recomendamos que você compare esses relatórios, principalmente seus resultados, com os seguintes:

 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

Esperamos que este artigo tenha sido informativo e útil para você! Obrigado por ler! Que instrumentos devemos rever? Sobre o que você estaria interessado em ler em nosso blog?

Se você ainda tiver dúvidas, sinta-se à vontade para perguntar! Teremos o maior prazer em responder a todas as perguntas que você tiver! As melhores perguntas e respostas poderão ser incluídas na próxima postagem do blog!

A propósito, há alguns espaços vacantes no momento, portanto, se o seu projeto precisar de uma auditoria - sinta-se à vontade para nos escrever, visite nossa página de reportes públicos aqui.

### Toolblox, la herramienta para crear contratos inteligentes sin escribir código.

Toolblox, la herramienta para crear contratos inteligentes sin escribir código.
Toolblox, la herramienta para crear contratos inteligentes sin escribir código.
Toolblox es un generador de contratos inteligentes sin código y un constructor de DApp. En esta publicación, nuestro objetivo es mostrarte todo: qué estamos haciendo y por qué es importante lo que hacemos.

Imagen del Flujo de Trabajo de Toolblox y la interfaz de usuario generada automáticamente
Breve historia
El proyecto comenzó a principios de 2022 como un concursante en el hackatón Near Metabuild II. Logró ganar el gran premio que sirvió como capital semilla. Toolblox ha ganado otros premios a lo largo del año, como el mejor de Herramientas e Infraestructura en el hackatón Polygon BUIDL IT.

Desde la primera versión, la interfaz de usuario se simplificó en un 1000% y también se agregó un generador de DApp. Si bien originalmente admitía solo una cadena de bloques, se agregaron cinco más.

Toolblox pronto cumplirá 1 año y aquí estamos para revelarlo y compartirlo con el mundo.
Contratos inteligentes autoejecutables
Los contratos inteligentes son acuerdos qué se ejecutan de manera automática codificados como programas de computadora. Cuando se invoca un desencadenante determinado, pueden tomar medidas de inmediato, como liquidar pagos o transferir la propiedad. Esto es posible porque en la blockchain no hay necesidad de una autoridad central, se emplean firmas digitales y además, el estado del programa es inmutable.

Por lo tanto, los contratos inteligentes autoejecutables están en una posición única para:

 	Infundir confianza, rectitud y transparencia en cualquier sistema o proceso existente.
 	 Elimina a los intermediarios y la agencia centralizada.
 	 Manejar un conjunto diverso de flujos de trabajo, desde tiendas físicas hasta cadenas de suministro y organizaciones nativas digitales llamadas Organizaciones Autónomas Descentralizadas o DAO (Por sus siglas en Inglés).

Los contratos inteligentes serán omnipresentes y potenciarán las redes comerciales del futuro.  Pueden y deben reemplazar las bases internas de todos y cada uno de los productos de gestión de procesos comerciales SaaS centralizados.
Nuestro enfoque
Toolblox proporciona un creador de contratos inteligentes super simple basado en flujos de trabajo para ayudar a las empresas a crear rápidamente su presencia en la blockchain (cadena de bloques): crea un flujo de trabajo e impleméntalo como una aplicación utilizable.

 	Sin código.
Siempre se puede invertir en un equipo de desarrollo o contratar profesionales para codificar con un flujo de trabajo personalizado.  Pero para el resto (el 90% de las pequeñas y microempresas, organizaciones sin fines de lucro, DAO, etc.) que solo quieren mantenerse enfocados, un enfoque visual y sin código es el camino a seguir.  Menos inversión inicial, más flexibilidad, creación rápida de prototipos y comercialización más rápida.
 	Flujo de trabajo basado en máquinas de estado.
La blockchain no se trata de datos, se trata de estado, especialmente de transiciones de estado, los cruces donde se transfiere el valor, ya sea dinero real, propiedad o ambos.  El corazón palpitante de cualquier proceso comercial o contrato. Propuesto también por la Fundación Hyperledger, un flujo de trabajo de máquina de estado es ideal para la visualización de contratos inteligentes. Obtenga más información sobre nuestro creador de flujo de trabajo.
 	Interfaz de usuario lista para usar.
Si bien es genial poder desplegar contratos inteligentes personalizados fácilmente, también deben ser utilizables, ya sea para compartir con usuarios finales o involucrar a socios comerciales. Es por eso que Toolblox genera una aplicación simple automáticamente. Para interfaces de usuario y personalización más complejas, tenemos el generador DApp que permite diseñar una aplicación descentralizada sin ningún código.
Aprende más acerca de nuestro creador de DApp
 	Se integra con el ecosistema.
Muchas opciones para la integración con servicios externos (como seguro de token, colateralización, portales NFT, fracciones, etc.):
– todos los flujos de trabajo se pueden hacer compatibles con ERC721
– Los tokens ERC20 (como USDT, USDC, EURC, etc.) se pueden usar para realizar pagos
– Los eventos de la cadena de bloques se pueden utilizar para una mayor integración
– integración descentralizada de redes sociales

¿Para quién es Toolblox?

 	Organizaciones Autónomas Descentralizadas que buscan gestionar flujos de trabajo y proyectos personalizados.
 	Industrias relacionadas con la cadena de suministro y los productos básicos para manejar tareas que van desde la producción hasta la venta minorista y el comercio.
 	Pequeñas y microempresas que carecen de conocimientos especializados y se beneficiarían de una solución completa (estado, lógica y pagos).

¿Por qué uno usaría Toolblox?
Aquí hay algunas formas en que uno puede pensar en Toolblox en cualquier organización: Aquí hay algunas formas en que uno puede pensar en Toolblox en cualquier organización:

 	Herramienta de digitalización - para construir un proceso comercial en cadena y compartir la aplicación con usuarios y socios.
 	Herramienta de creación rápida de prototipos - para crear DApps utilizables y compartibles para abordar un problema específico.
 	Empujón para arrancar el desarrollo - para crear un borrador de contrato inteligente y luego desarrollarlo aún más con recursos personalizados.
 	Ser el soporte principal de un producto existente - para conectar un producto existente para usar blockchain como una fuente única de datos de estado inmutables y seguros.

Ejemplos de flujo de trabajo
Aquí hay un par de flujos de trabajo/DApps creados con Toolblox. Cada flujo de trabajo consta de los siguientes elementos:

 	Artículo (proyecto, documento, oferta, propuesta, etc.)
 	Atributos del artículo (nombre, fecha límite, autor, propietario, cliente, etc.)
 	Estados del flujo de trabajo (activo, cancelado, esperando comentarios, etc.)
 	Transiciones de estado (modificar, pagar, crear, aceptar, actualizar, etc.)

Todos los siguientes proyectos se pueden usar como DApp y se pueden usar como plantilla para crear nuevos contratos inteligentes.
Recaudación de fondos DAO para proyectos

Resumen de la recaudación de fondos de DAO (toolblox.net)
Registro de bodas distribuido

Resumen de la recaudación de fondos de DAO de Registro de Bodas Distribuído (toolblox.net)
Pregúntame cualquier cosa (AMA) con recompensa

Resumen de la plataforma AMA con ejemplo de recompensa (toolblox.net)
Flujo de trabajo de tasación de bienes inmuebles

Resumen del flujo de trabajo de tasación de precios de bienes raíces (toolblox.net)
Ofertas de precios de impresión 3D y gestión de impresiones.

Resumen del registro de ofertas de impresión 3D (toolblox.net)

¡Consulta nuestra web www.toolblox.net y nuestro Twitter para más ejemplos! De igual manera, únete a academy.toolblox.net por tutoriales y documentación sobre cómo construir con Toolblox.

### Por que Ref v2 é melhor que Uni v3

Introdução e antecedentes
Ref Finance v2 está trazendo o futuro da negociação para NEAR: um AMM de Liquidez Discretizada (DLAMM) com ordens limitadas. Com lançamento nas próximas semanas, em breve você poderá desfrutar de uma experiência de negociação semelhante à CEX com todos os benefícios da DEX.
TL;DR
1. O colapso do FTX aponta para a necessidade de DEXs com uma experiência de negociação comparável aos CEXs.

2. A Ref Finance está lançando sua v2, cujos principais componentes são sua liquidez discreta AMM (DLAMM) e ordens limitadas.

3. O DLAMM é uma versão aprimorada da liquidez concentrada do Uniswap v3, com provisão de liquidez mais precisa, maior eficiência de capital e derrapagem quase zero.

4. A Ref v2 também possui ordens de limite integradas. Os traders podem colocar ordens de mercado e limite com derrapagem quase zero, obtendo assim uma experiência de negociação no estilo CEX em um DEX.

5. Ref v2 pode ser aproveitado mais rápido e mais barato do que quase qualquer outra rede, graças à finalização rápida do NEAR (1–2s) e taxas insignificantes (<$ 0,01).

6. Liquidez discreta AMM é um jogo de soma positiva em que LPs e traders ganham.

Com o recente colapso de uma das maiores bolsas centralizadas do mundo (CEX), FTX, a comunidade cripto rapidamente ficou alerta com a importância da descentralização. Adoption to decentralized finance (DeFi) protocolos, especialmente trocas descentralizadas (DEXs), cresceram à medida que as pessoas reconheceram a necessidade de transparência e auto custódia sobre seus ativos.

E agora, com as DEXs, mais importantes do que nunca, vamos dar uma olhada para onde elas estão indo. Neste artigo, analisaremos a evolução das DEXs por meio de seu principal exemplo, o Uniswap, e iremos apresentar a próxima fase de seu desenvolvimento: a liquidez concentrada discreta.
Recapitulação do v1, v2, and v3
Em novembro de 2018, o Uniswap v1 foi lançado principalmente como uma prova de conceito. Ele introduziu a ideia de um AMM, aproveitando a matemática por trás da equação do produto constante, x * y = k. Na época, o Uniswap v1 suportava apenas pares de negociação ETH-ERC20 e pools de liquidez (LPs).

Em maio de 2020, o Uniswap v2 foi lançado como uma melhoria da v1. Algumas das principais melhorias foram a introdução de pools de liquidez, pools ERC20-ERC20, um  oráculo de preços TWAP descentralizado e flash swaps.

Em maio de 2021, o Uniswap v3 foi lançado. v3 introduziu inovações importantes, como liquidez concentrada, bem como segurança aprimorada, novos níveis de taxas, desenvolvimento de feed oracle e liquidez não fungível. Em suma, a principal tese do Uniswap v3 era alcançar uma melhor eficiência de capital para os traders da plataforma e os provedores de liquidez por meio do conceito de liquidez concentrada.




	

	
	
		
			
				Que tipo de negociação foi suportada no Uniswap v1?
			
		

		
					

		
			
			
			
			Pares de negociação e pools ETH-ERC20
		
			
			pools ERC20-ERC20
		
			
			Pares de negociação e pools  ETH-NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






O que é liquidez concentrada? que benefícios isso traz?


Ao contrário dos AMMs, onde a liquidez é simplesmente fornecida sem especificar um intervalo, a liquidez concentrada significa que os LPs podem alocar capital para seus intervalos de preço preferidos, o que permite uma eficiência de capital significativamente maior.

A liquidez concentrada beneficia todas as partes: traders e LPs.

Os LPs se beneficiam da eficiência de capital de fornecer uma faixa estreita de liquidez, geralmente mais utilizada pelos traders, que consequentemente pode gerar até 4000x mais fees em comparação com o Uniswap v2.

Os traders, por sua vez, se beneficiam da liquidez mais a fundo.

O Uniswap V3 foi fortemente adotado pela comunidade de criptomoedas graças ao seu novo modelo de liquidez concentrada. Os volumes do Uniswap v3 aumentaram sem parar desde o seu lançamento, alcançando rapidamente um domínio de 97,2% sobre o Uniswap v2 em termos de volume diário.

Liquidez Discretizada na Ref v2

Em parceria com iZUMi Finance e Arctic, a Ref Finance tem o orgulho de apresentar o Ref v2: o AMM de liquidez discretizada (DLAMM) com ordens limitadas. Pense na liquidez concentrada do Uniswap V3, porém melhor, e agora com funcionalidade de ordem limitada para trazer a experiência de negociação CEX on-chain.

AMM de Liquidez Discretizada vs AMM de Liquidez Concentrada

A liquidez discretizada é a abreviação de DLAMM, que significa “formador de mercado automatizado de liquidez discreta”. Os AMMs de liquidez concentrada existentes, como Uniswap v3, seguem a fórmula de produto constante (X*Y=K), onde o preço muda continuamente com a quantidade de tokens X e Y no pool. Concebido pela iZUMi Finance, o AMM de liquidez discretizado utiliza uma curva de produto constante contínua sintética com uma fórmula de soma constante discretizada (x+y=k), onde os preços são discretizados no AMM (ver figura abaixo).

Isso resulta em duas grandes melhorias para AMMs de liquidez discreta: slippage (diferença entre o preço esperado e o preço alcançado ao concretizar a negociação) reduzida e provisão de liquidez mais precisa dentro de uma faixa de preço.




	

	
	
		
			
				Qual criador de mercado é usado no Ref Finance?
			
		

		
					

		
			
			
			
			Liquidez Concentrada AMM
		
			
			AMM de Liquidez Discretizada
		
			
			Liquidez objetivo AMM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como o Ref v2 é melhorado em relação ao Uniswap V3
Ref v2 não apenas apresenta as melhores partes do Uniswap v3 (eficiência de capital) com seu AMM de liquidez discretizada, mas vai ainda mais além para permitir uma experiência de negociação semelhante à CEX normalmente impossível em DEXs com uma funcionalidade de ordem de limite integrada. E tudo isso, com todos os benefícios de um DEX: transações end-to-end descentralizadas, seguras e transparentes para traders e provedores de liquidez.

Na Ref v2 você pode...

 	Desfrutar da alta eficiência de capital graças ao Discretized Liquidity (liquidez discretizada) AMM

Assim como no Uni v3, o Ref v2 permite fornecer liquidez concentrada - ou seja, liquidez específica para uma faixa de preço. Isso significa que, como LP, você pode fornecer liquidez a uma faixa de preço que você acha que os traders utilizam mais, por exemplo, e potencialmente cobrar muito mais taxas do que antes. Como trader, você pode desfrutar de uma liquidez mais a fundo nas faixas de preço que frequenta, pois a liquidez não precisa mais se espalhar por toda a faixa.

2. Aproveite o estilo AMM Uni V3 com apenas uma fração da velocidade e custos. 

Ao alavancar o NEAR, a Ref é capaz de oferecer seu AMM de liquidez discretizado com finalização incrivelmente rápida (1–2s) e com custos insignificantes (frações de um centavo).

3. Colocar ordens de limite

Por definição, uma ordem limitada é uma ordem de compra ou venda de um ativo com restrição ao preço máximo a ser pago ou ao preço mínimo pelo qual você vende. Este é um recurso típico dos CEXs que utilizam um livro de pedidos, que permite aos usuários programar pedidos dentro de sua faixa de preço preferida.

Atualmente, não há uma função de ordem de limite adequada no Uniswap v3. A única maneira é fornecer liquidez concentrada fora do preço atual e, assim, imitar uma ordem limitada. A Ref v2, por outro lado, apresenta a funcionalidade de ordem de limite integrada. Agora os usuários podem negociar em um DEX como fariam normalmente em um CEX .

4. Faça ordens limitadas sem limitações de preço

Como o Uni v3 permite apenas ordens de limite de forma indireta, uma vez que a ordem de limite sintética é preenchida, se ou quando o preço retornar ao seu ponto original, os LPs não poderão mais reivindicar seus ganhos de ordem, pois os tokens ganhos teriam sido revertidos.

Na Ref v2, os usuários podem colocar ordens de compra limitada a um preço maior que o preço atual, e o algoritmo fará a correspondência automática com o melhor preço. Isso proporciona, ademais, uma experiência de negociação semelhante à dos CEXs.

5. Coloque ordens limitadas com slippage de Near-zero

Graças ao AMM de liquidez discretizado da Ref, que aproveita o poder de uma fórmula de soma constante, os traders podem não apenas colocar ordens limitadas, mas fazê-lo com  slippage (derrapagem) Near-zero.

Além disso, quando os traders colocam ordens limitadas na Ref v2, eles efetivamente se tornam LPs temporários para esse pool nessa faixa de preço. Além do próprio modelo DLAMM de última geração, a capacidade de ordem limitada do Ref v2 efetivamente agrega liquidez adicional aos pools, reduzindo assim ainda mais as slippage.

6. Beneficie-se da prioridade de ordem limitada “E” da estrutura justa de taxas de LP

A introdução do provedor de liquidez de ordem limitada na Ref v2 introduz naturalmente a concorrência nas taxas com os LPs regulares que fornecem liquidez concentrada. Para melhor incentivar cada parte, as ordens de limite sempre serão priorizadas em termos de ordem de transação, mas as taxas de LP serão distribuídas proporcionalmente aos provedores de liquidez concentrados.



	

	
	
		
			
				Qual exchange permite que os clientes façam pedidos limitados sem limitações de preço?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			1 Inch
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Por que “VOCÊ” deveria se importar?

Tldr; Liquidez Discretizada AMM é um jogo de soma positiva. Todos ganham na Ref V2.

 	Provedores de liquidez: como no Uni v3, os LPs no Ref v2 podem maximizar as taxas de transação que cobram das negociações, fornecendo liquidez concentrada em uma faixa de preço específica que os traders frequentam. Além disso, os LPs também recebem todas as taxas geradas pelas negociações de ordens limitadas. Quando uma ordem de limite é preenchida, não é o trader que recebe a taxa de transação, mas sim o LP subjacente dentro desse intervalo.
 	Traders (negociadores): Os traders, agora, podem desfrutar de uma liquidez mais profunda, bem como fazer ordens de mercado e limitar ordens com slippage Near-zero. Quando os traders colocam ordens limitadas, eles efetivamente se tornam provedores de liquidez, que “criam mercados” colocando ofertas na bolsa.
 	Criadores de mercado ativos: os criadores de mercado podem reduzir o custo do gerenciamento de LP a uma taxa muito acessível (<$ 0,01/txn), com lucros e perdas (PnL) mais previsíveis e experiência de negociação (trading) mais próxima de uma exchange CLOB.

“Tldr; DL-AMM é uma jogada de soma positiva”

### Exploradores da blockchain NEAR

To Share and +4 nLEARNs

Após a implosão do FTX, assumir o controle de suas criptos tornou-se mais crítico do que nunca. Uma das maneiras mais importantes de fazer isso é aprendendo a ler um explorador de blockchain. Para o  Protocolo NEAR, os exploradores de blockchain mais populares são:

 	NEAR Explorer
 	NearBlocks
 	NearScan

O que é um explorador de blockchain?
Um scanner blockchain é um software usado para visualizar diferentes métricas de rede blockchain como:

 	Taxa de hash.
 	Tamanho do Bloco.
 	Complexidade do Bloco.
 	Taxas médias de transação.

Então, o que você pode fazer com o blockchain explorer? Vamos dar uma olhada.

 	Acompanhar o status de uma transação pendente enquanto aguarda no mempool.
 	Fazer acompanhamento do saldo das carteiras sem precisar usar a própria carteira. Isso pode ser útil se você quiser verificar o saldo em sua carteira de hardware.
 	Rastrear todas as transações que entram e saem de um determinado endereço.
 	Visualizar blocos órfãos, também conhecidos como blocos que não estão anexados à cadeia principal.
 	Explorar transações de baleias que podem ter um grande impacto no mercado.
 	Acompanhar os endereços de cripto líderes conhecidos.
 	Acompanhar as moedas pós-hack

Como funcionam os exploradores de blockchain?
Os exploradores de Blockchain trabalham ao lado dos nodes da blockchain e usam interfaces de programação de aplicativos (APIs), bancos de dados relacionais e bancos de dados SQL para recuperar informações relevantes da rede subjacente. Aqui estão algumas coisas para manter em mente:

 	O explorador organiza todas essas informações em um banco de dados e exibe esses dados em um formato pesquisável.
 	Os usuários podem realizar buscas através de uma tabela organizada.
 	Todas as solicitações de pesquisa são enviadas ao servidor back-end, que fornece as respostas necessárias.

Como usar um explorador de blockchain?
Para nossas primeiras demonstrações, vamos verificar o  explorador da NEAR. Colocamos uma conta selecionada aleatoriamente no scanner. Vejamos quais dados obtemos.

A primeira seção que vemos, tem os seguintes dados:

 	Transactions: (transações) O número de transações enviadas e recebidas. Esta conta enviou 1.816 transações e não recebeu nenhuma.
 	Storage used: (armazenamento usado) o armazenamento blockchain total usado pela conta. Esta conta usa 390 kB.
 	Native account balance: (Saldo da conta nativa) a quantidade de Tokens NEAR atualmente mantidos pela conta. Esta conta contém 81.1916 NEAR.
 	Validator stake: (validador de stake) Esta conta está colocando uma quantidade de NEAR em stake para respaldar um validador e proteger a rede? A conta colocou 23.439.675,24565 NEAR atrás de um validador.
 	Created: A conta foi criada em 15 de fevereiro de 2022, às 4h49min20s.
 	Created transaction: (transação criada) O hash da transação responsável por criar esta conta é: 4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Ao rolar para baixo, você verá o histórico de transações desta conta.

Verificando o status da transação.
Vamos colocar um hash de transação aleatória no explorer e ver como fica. Primeiro, vamos colocar este hash de transação:

2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3

Esta é uma transação padrão em que uma conta envia algumas moedas para outra. Então vamos aos detalhes.

 	Signed by: (Assinante) Esta é a conta que o remetente que assinou e enviou a transação. Neste caso, é: “Sweat_welcome.near.”
 	Receiver: (Destinatário) Esta é a conta que recebe a transação – 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Status:  O status atual das transações. Isso pode ser Pendente, Bem-sucedido, Com Falha/Finalizado ou não finalizado. Neste caso, é bem-sucedido.
 	Transaction fee: (taxa de transação) Esta é a taxa necessária para executar esta transação. Neste caso, é 0,00008 NEAR.
 	Deposit value: (valor do depósito) Este é o valor total que está sendo transferido da conta assinante para a conta receptora. Neste caso, o valor do depósito é 0,5 NEAR.
 	Gas used: (gás usado) As unidades de gás necessárias para executar a transação. Neste caso, é 1 Tgas ( 1 TeraGas = 10¹² unidades de gás).
 	Created: Esta transação foi criada em 17 de novembro de 2022, às 13h18min33s.
 	Block hash: O identificador único (hash) do bloco em que esta transação foi incluída. Neste caso, o hash do bloco é:
F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN

Transaction receipt


 	O explorador também compartilha um recibo. O recibo em si tem duas partes.
 	A primeira parte é a recepção da própria transação. Há uma ID de recibo e o total de gás e tokens queimados.
 	A segunda parte é o recibo do sistema. “Sistema” é uma conta especial usada para identificar recibos de reembolso.




	

	
	
		
			
				Para qual das opções a seguir posso usar um scanner?
			
		

		
					

		
			
			
			
			Ver o histórico de transações de uma conta
		
			
			Verificar quanto gastei em taxas de gás na minha última transação
		
			
			Tudo o que precede
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Vamos usar a mesma transação em NearScan e NearBlocks para ver como a apresentação de dados difere entre esses exploradores.
NearBlocks

O Explorador de blocos Near mostra os mesmos dados do total de gás e tokens queimados durante a transação.




	

	
	
		
			
				O que faz a "conta do sistema" ?
			
		

		
					

		
			
			
			
			Validar transações
		
			
			Identificar recibos de reembolso
		
			
			Adicionar transações
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NearScan

A interface do NearScan fornece praticamente os mesmos dados. Os dados de gás mostram mais casas decimais do que o NEAR Explorer.




	

	
	
		
			
				Qual dos seguintes scanners pode ser usado para o protocolo NEAR?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			Nearscan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusão
Existem transações mais complicadas na blockchain NEAR. No entanto, este artigo deve dar uma ideia de como ler essas transações. Os Explorers permitem que você explore uma das características mais essenciais da tecnologia blockchain – a transparência. Ele permite que você, como usuário, rastreie meticulosamente suas moedas e veja para onde estão indo.

### Pourquoi Les DAO Devraient-ils Migrer Pour Exécuter un Fragment Privé

Introduction aux DAO et aux contrats multisignatures
La plupart des utilisateurs de Web3 connaissent très bien les termes DAO et contrats multisignatures, mais pour les personnes qui ne connaissent pas l'espace Web3, je pense qu'il vaut la peine de déballer les deux termes.
Qu'est-ce qu'un DAO ?
Une « Organisation Autonome Décentralisée» (DAO) est une entité dirigée par la communauté sans autorité centrale. Il est totalement autonome et transparent : des contrats intelligents sont utilisés pour régir la prise de décision et la propriété distribuée des actifs. Le processus de vote pour les DAO est publié sur une blockchain, et les utilisateurs doivent souvent choisir entre des options mutuellement exclusives.  Le pouvoir de vote est fréquemment réparti entre les utilisateurs en fonction du poids de vote qu'ils ont au sein du DAO (poids du nombre de jetons qu'ils détiennent, un membre - un vote et autres). Tous les votes et activités via le DAO sont publiés sur une blockchain, ce qui rend toutes les actions des utilisateurs visibles publiquement.

Pour prendre des décisions pour les DAO, ils utilisent un portefeuille multisignatures (contrat)
Qu'est-ce qu'un portefeuille multisignatures ?
Le portefeuille multisig est un type spécial de contrat de cryptographie pour stocker en toute sécurité la crypto-monnaie. Il nécessite deux clés privées ou plus (parties DAO) pour signer et envoyer une transaction, et est souvent utilisé pour ajouter une couche de sécurité supplémentaire aux transactions de portefeuille en garantissant que plusieurs détenteurs de clés sont impliqués dans l'approbation de la transaction.

Les contrats multisignatures peuvent également être configurés pour permettre à chacune des clés privées de générer une signature, ce qui en fait une excellente option pour ceux qui cherchent à stocker leur crypto-monnaie de manière sécurisée et sans confiance.
Comment les DAO tirent-ils actuellement parti des contrats multisignatures ?
Les DAO utilisent multisignatures pour stocker leurs fonds en toute sécurité et les gérer efficacement. Les contrats multisignatures offrent à plusieurs parties prenantes la possibilité de signer une transaction, permettant une gestion sécurisée et diversifiée des fonds et des décisions. Les multisignatures fournissent également une couche de sécurité supplémentaire en exigeant plusieurs clés privées pour accéder aux fonds.

De plus, les DAO peuvent utiliser des contrats multisignatures pour mettre en œuvre un système de vote et de gouvernance plus complexe que le contrat multisignatures moyen. Cela permet une prise de décision décentralisée et sécurisée.

Les structures de votes du DAO les plus courantes sont le vote par quorum pondéré par jetons, le vote quadratique, la démocratie liquide ou la délégation de vote ou le verrouillage des votes et le vote par quorum basé sur des jetons.

 	Vote de quorum pondéré par jeton

Il faut un certain seuil d'électeurs pour qu'une proposition soit acceptée. Par exemple : un quorum de 60 %, ce qui signifierait que 60 % des détenteurs de jetons doivent voter en faveur d'une proposition pour qu'elle soit adoptée.

 	1 jeton = 1 vote gouvernance

Le pouvoir de vote d'un individu est directement proportionnel au nombre de jetons qu'il détient.

 	Vote quadratique

C'est un système qui équilibre les intérêts des groupes minoritaires tout en maintenant un processus décisionnel majoritaire. Démocratie liquide ou délégation de vote. Il permet aux personnes de déléguer leur vote à un représentant.

 	Verrouillage des votes

C'est un mécanisme qui permet aux participants de sortir d'un vote sans pénalité.

 	Vote de quorum basé sur des jetons

C'est un système qui exige qu'un certain seuil de jetons soit détenu par les électeurs pour qu'une proposition soit acceptée.
Principaux défis auxquels les DAO sont confrontés
Les principaux problèmes auxquels les DAO sont confrontés comprennent l'absence de statut juridique reconnu et la responsabilité potentielle illimitée des membres, l'absence de réglementation et des mesures de sécurité inadéquates. De plus, les DAO peuvent être vulnérables aux attaques de gouvernance, à une mauvaise configuration et au spam. Ces problèmes peuvent créer un certain nombre de risques, notamment des protections inadéquates pour les données personnelles, des contrats intelligents vulnérables et un accès non autorisé aux fonds.

La plupart des problèmes techniques mentionnés ci-dessus peuvent être résolus et le reste atténué à l'aide d'un fragment privé, mais déballons d'abord ce qu'est un fragment privé.




	

	
	
		
			
				Quelles sont certaines implémentations de votes qui peuvent être utilisées avec le partage privé dans les DAO ?
			
		

		
					

		
			
			
			
			1 jeton = 1 vote de gouvernance
		
			
			Vote quadratique
		
			
			Vote de quorum pondéré par jeton
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Fragments Privés pour les DAO : un portefeuille multisignature sur les stéroïdes

Un Fragment Privé est une chaîne latérale personnalisable (un réseau de chaînes de blocs fonctionnant parallèlement à la chaîne de blocs publique avec la possibilité de transférer des actifs et d'exécuter des appels de contrats croisés) qui vous permet de protéger vos données tout en tirant parti de tous les avantages commerciaux des chaînes de blocs open source. Il permet aux propriétaires de Fragment Privé d'avoir un contrôle total sur leur blockchain tout en gardant des informations privées entre eux et en n'autorisant que certaines parties publiques à accéder à ces informations.

Les membres de DAO obtiennent un réseau géré par eux en fonction de leurs besoins. Il peut être personnalisé selon les structures de vote proposées mentionnées ci-dessus où les validateurs (nœuds validant les blocs de blockchain) appartiennent aux membres du DAO, de la même manière qu'à l'intérieur d'un multisignature, ils posséderaient une clé privée avec un certain pouvoir de vote. Considérez-le comme un "Multisignature sur stéroïdes", car toutes les propriétés multisignature de base sont les mêmes, tout en bénéficiant des avantages de toutes les informations stockées uniquement dans le fragment privé et non divulguées au public.

En plus de cela, les membres de DAO peuvent déployer des contrats intelligents personnalisés à l'intérieur du Fragment avec une "évolutivité infinie" leur offrant la possibilité d'avoir :

 	vote privé
 	comptabilité et paie des entrepreneurs
 	mettre en œuvre des mécanismes de transactions lourdes comme les enchères (qui peuvent être trop chères sur Mainnet)
 	départements de gestion de trésorerie au sein du DAO et bien plus encore.




	

	
	
		
			
				Un fragment privé est :
			
		

		
					

		
			
			
			
			Une base de code Web2 privée stockée dans un écosystème partagé fermé
		
			
			Une chaîne latérale privée personnalisable (un réseau de chaînes de blocs fonctionnant parallèlement à la chaîne de blocs publique avec la possibilité de transférer des actifs et d'exécuter des appels de contrats croisés)
		
			
			Un DAO ouvert stocké directement sur la blockchain NEAR fragmentée qui utilise des validateurs NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Le pont Private Shards a un contrat d'autorisations qui lui permet de définir des règles sur les contrats/comptes publics et privés pouvant interagir et dans quelle mesure. Cela permet de limiter l'accès à certaines parties ou contrats pour déplacer des actifs depuis et vers les fragments privés, en plus de cela, il donne accès à certains contrats intelligents pour exécuter des appels de contrat depuis le fragment ou le réseau principal.

Par exemple : un DAO peut avoir un contrat de vote privé à l'intérieur du fragment qui lance un appel lorsque le vote est terminé et que seul le résultat du vote est publié sur Mainnet sans révéler les votes spécifiques des membres. Cet appel ne peut être exécuté que depuis l'intérieur de ce fragment et aucune autre partie ne peut le publier à l'exception de ce contrat spécifique. Cela permet aux membres du DAO d'assurer la sécurité du vote comme ils le feraient en utilisant un multisig, tandis que les votes réels sont cachés au public.




	

	
	
		
			
				Les fragments privés permettent aux DAO d'avoir :
			
		

		
					

		
			
			
			
			Vote privé
		
			
			Comptabilité et paie des entrepreneurs
		
			
			Mettre en œuvre des mécanismes de transactions lourdes comme les enchères
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






En plus de cela, la passerelle Calimero fournit une gestion des autorisations supplémentaires pour les membres DAO afin de spécifier des politiques sur lesquelles les utilisateurs/portefeuilles publics peuvent interagir avec le fragment privé. Alors que les membres DAO exécutent les validateurs et ont un accès administrateur au fragment, ils peuvent inviter des membres/portefeuilles externes pour pouvoir lire certaines données ou interagir avec certains contrats.

Par exemple : un DAO peut avoir un contrat privé à l'intérieur du fragment pour que des parties externes soumettent des propositions sur lesquelles le DAO peut voter. Cela peut permettre uniquement aux émetteurs et aux membres DAO de la proposition de voir leurs informations sur l'état de la proposition. La soumission de la proposition peut être limitée à une liste blanche de portefeuilles ajoutée par le DAO ou au grand public.

Nous pensons que les fragments privés sont la prochaine évolution naturelle pour les DAO et nous cherchons à travailler avec plus de DAO dans cette prochaine transformation du Web3.  N'hésitez pas à nous contacter si vous avez des questions ou souhaitez réserver une démo.

### Toolblox, Le Constructeur de Contrats Intelligents Sans code

Toolblox est un constructeur de contrats intelligents sans code et un fabricant de DApp. Dans cet article, nous visons à tout déballer - que faisons-nous et pourquoi est-ce important.



Toolblox Workflow Builder et l'interface utilisateur générée automatiquement
Bref historique
Le projet a débuté au début de 2022 en tant qu'entrée à l'hackathon Near Metabuild II. Il a réussi à remporter le grand prix qui a servi de capital d'amorçage. Toolblox a remporté d'autres prix au cours de l'année, notamment celui du meilleur outil et de l'infrastructure lors de l'hackathon Polygon BUIDL IT.

Depuis la première version, l'interface utilisateur a été simplifiée 10 fois et un constructeur DApp a également été ajouté. Alors qu'il ne supportait à l'origine qu'une seule blockchain, cinq autres ont été ajoutées.

Toolblox a presque 1 an et nous commençons à le révéler et à le partager avec le monde.
Contrats intelligents auto-exécutables
Les contrats intelligents sont des accords auto-exécutoires codés comme des programmes informatiques. Lorsqu'un certain déclencheur est invoqué, ils peuvent immédiatement prendre des mesures telles que régler des paiements ou transférer la propriété. Cela est possible, car sur la blockchain, il n'y a pas besoin d'autorité centrale, les signatures numériques sont utilisées et l'état du programme est immuable.

Les contrats intelligents auto-exécutables sont donc particulièrement bien placés pour :

 	Infuser la confiance, l'équité et la transparence dans tout système ou processus existant.
 	Éliminer les intermédiaires et l'agence centralisée.
 	Gérer divers ensembles de flux de travail — des magasins physiques aux chaînes d'approvisionnement en passant par les organisations natives numériques appelées organisations autonomes décentralisées ou DAO.

Le contrat intelligent sera omniprésent, alimentant les réseaux d'entreprise du futur. Ils peuvent et doivent remplacer l'épine dorsale de tous les produits de gestion des processus métier SaaS centralisés.
Notre approche
Toolblox fournit un générateur de contrats intelligents basé sur un flux de travail extrêmement simple pour aider les entreprises à créer rapidement leur présence sur la blockchain : créez un flux de travail et déployez-le en tant qu'application utilisable.

 	Pas de code.
On peut toujours investir dans une équipe de développement ou embaucher des professionnels pour coder un flux de travail personnalisé. Mais pour le reste - 90% des petites et micro-entreprises, des organisations à but non lucratif, des DAO, etc. - qui veulent juste rester concentrées, une approche visuelle sans code est la voie à suivre. Moins d'investissement initial, plus de flexibilité, un prototypage rapide et une mise sur le marché plus rapide.
 	Flux de travail basé sur la machine d'état.
La blockchain ne concerne pas les données, mais l'état, en particulier les transitions d'état - les jonctions où la valeur est transférée - qu'il s'agisse d'argent réel, de propriété ou des deux. Le cœur battant de tout processus métier ou d'un contrat. Également proposé par Hyperledger Foundation, un flux de travail de machine d'état convient parfaitement à la visualisation de contrats intelligents. Découvrez notre générateur de flux de travail.
 	Interface utilisateur prête à l'emploi.
Bien qu'il soit formidable de pouvoir créer facilement des contrats intelligents personnalisés, ils doivent pareillement être utilisables, que ce soit pour les partager avec les utilisateurs finaux ou pour engager des partenaires commerciaux. C'est pourquoi Toolblox génère automatiquement une application simple. Pour des interfaces utilisateur et une personnalisation plus complexes, nous avons le constructeur DApp qui permet de concevoir une application décentralisée sans aucun code. Découvrez notre constructeur DApp.
 	S'intègre à l'écosystème.
De nombreuses options d'intégration avec des services externes (telles que l'assurance de jetons, la collatéralisation, les portails NFT, le fractionnement, etc.) :– chaque flux de travail peut être rendu compatible ERC721
– Les jetons ERC20 (tels que USDT, USDC, EURC, etc.) peuvent être utilisés comme paiements
– Les événements blockchain peuvent être utilisés pour une intégration plus poussée
– Intégration décentralisée des médias sociaux

C'est pour qui ?

 	Organisations autonomes décentralisées cherchant à gérer des flux de travail et des projets personnalisés.
 	Chaîne d'approvisionnement et industries liées aux matières premières pour gérer des tâches allant de la production à la vente au détail et au commerce.
 	Les petites et micro-entreprises qui manquent de savoir-faire spécialisé et qui bénéficieraient d'une solution complète (état, logique et paiements).

Pourquoi utiliser Toolblox ?
Voici quelques façons de penser à Toolblox dans n'importe quelle organisation :

 	Outil de numérisation - pour créer un processus métier en chaîne et partager l'application avec les utilisateurs et les partenaires.
 	Outil de prototypage rapide - pour créer des DApp utilisables et partageables pour résoudre un problème spécifique.
 	Kickstarter de développement — pour créer un brouillon de contrat intelligent, puis le développer davantage avec des ressources personnalisées.
 	Backbone à un produit existant - pour connecter un produit existant pour utiliser la blockchain comme source unique de données d'état immuables et sécurisées.

Exemples de flux de travail
Voici quelques workflows/DApps construits avec Toolblox. Chaque flux de travail se compose des éléments suivants :

 	Objet (projet, document, offre, proposition, etc.)
 	Attributs de l'objet (nom, date limite, auteur, propriétaire, client, etc.)
 	États du flux de travail (actif, annulé, en attente de commentaires, etc.)
 	Transitions d'état (modifier, payer, créer, accepter, mettre à jour, etc.)

Tous les projets suivants sont utilisables en tant que DApp et peuvent être utilisés comme modèle pour créer de nouveaux contrats intelligents.
DAO collecte de fonds pour des projets


Résumé de la collecte de fonds DAO (toolblox.net)
Registre de Mariage Distribué


Résumé du registre de mariage distribué (toolblox.net)
Demandez-moi n'importe quoi (AMA) Demandez-moi n'importe quoi avec prime


Résumé de la plate-forme AMA avec exemple de prime (toolblox.net)
Flux de travail d'évaluation immobilière


Résumé du flux de travail d'évaluation du prix de l'immobilier (toolblox.net)
Offres de prix d'impression 3d et gestion des impressions


Résumé du registre des offres d'impression 3D (toolblox.net)

Consultez notre site Web www.toolblox.net et notre Twitter pour plus d'exemples ! Rejoignez également academy.toolblox.net pour des tutoriels et de la documentation sur la façon de construire avec Toolblox.

### Comment Preuve à divulgation nulle de connaissance peut garantir la confidentialité des données

Vous avez probablement rencontré les expressions "si c'est gratuit, vous êtes le produit" ou "les données sont le nouveau pétrole", et en avez ri comme un petit dicton idiot. La vérité est que les données sont le moteur de presque toutes les entreprises et de tous les services. Par exemple, les expériences et services personnalisés, le marketing et une foule d'autres informations et services dépendent du volume et de la qualité des données qui leur sont fournies. La plupart des entreprises sont impatientes d'accéder aux données pour mieux comprendre leurs clients, prédire les modèles de comportement des clients et améliorer la qualité de leurs services.

L'espace traditionnel a toujours fait l'objet de préoccupations concernant les données et la confidentialité. Les défenseurs de la vie privée ont depuis longtemps signalé des inquiétudes quant à la manière dont les données sont stockées, comment elles sont accessibles et qui y a accès. Avec la croissance de l'écosystème de la crypto-monnaie et de la blockchain, des préoccupations similaires sont également apparues dans ce secteur. La nature publique des blockchains a introduit plusieurs problèmes de confidentialité pour les utilisateurs concernant la protection de leurs informations personnelles. Cet article examinera de plus près le problème de confidentialité sur les blockchains et comment les preuves Preuve à divulgation nulle de connaissance (ZK) peuvent les atténuer.
Qu'est-ce que la confidentialité des données ?
L'augmentation de l'utilisation d'Internet a amené la question de la confidentialité des données dans le courant dominant, presque tous les sites Web, applications et plateformes de médias sociaux collectant et stockant les informations personnelles des utilisateurs pour fournir certains services. Cependant, ces plateformes et sites Web ne disposent souvent pas de garanties adéquates pour sécuriser les données collectées, ce qui entraîne de nombreuses violations de données.

Avec la croissance de la technologie blockchain et de l'écosystème cryptographique, la confidentialité des utilisateurs commerciaux et institutionnels suscite des inquiétudes croissantes. Ces préoccupations sont principalement dues à la nature publique des blockchains, la plupart des solutions de couche 1 et de couche 2 ne résolvant pas ces problèmes. La confidentialité des données fait référence à la capacité des utilisateurs à déterminer, de leur côté, quand et comment leurs informations sont partagées avec d'autres. Cela englobe également l'habileté des utilisateurs à dicter dans quelle mesure leurs données sont partagées. Ces informations peuvent inclure leurs noms, leur emplacement, leurs coordonnées, leur comportement en ligne, leurs préférences, leurs aversions, les détails de la transaction, etc.
Confiance, confidentialité et blockchain
À l'heure actuelle, l'écosystème des cryptomonnaies subit des bouleversements considérables suite à l'effondrement de grands projets tels que FTX. Cependant, la technologie sous-jacente prenant en charge les crypto-monnaies a le potentiel de révolutionner la confidentialité, la confiance et la manière dont la confiance est exploitée. Ceci est essentiel à l'ère d'Internet où des millions de personnes parcourent et partagent de grandes quantités de leurs informations personnelles pour accéder à des services et des produits.

La technologie Blockchain pose intrinsèquement des problèmes de confidentialité, grâce à sa conception. La nature décentralisée des blockchains signifie que les nœuds traitant les transactions ou les informations ont accès aux données de la blockchain. Par exemple, la blockchain Bitcoin est accessible au public et accessible à toute personne souhaitant consulter l'historique de ses transactions jusqu'à son bloc de genèse. Maintenant, rappelez-vous, Bitcoin est pseudo-anonyme, ce qui signifie "[d] des points de données qui ne sont pas directement associés à un individu spécifique [mais où] plusieurs apparences de [a] personne peuvent être liées ensemble. "

Suffisamment de données pseudo-anonymes permettent d'identifier les individus derrière les transactions, ce qui est préoccupant pour les utilisateurs de la blockchain, et il y a plusieurs raisons à cela. Contrairement aux données utilisées par les applications classiques, qui ne sont opérationnels qu'à quelques-uns, les données de la blockchain peuvent être examinées par tout le monde, ce qui inclut également les acteurs malveillants et les entités qui peuvent exploiter les informations de la blockchain à leur profit. De plus, la nature immuable de la blockchain signifie que les transactions et les données seront liées en permanence à l'individu. Cela peut être fait en surveillant la communication entre les nœuds. De plus, les portefeuilles cryptographiques peuvent également être analysés sans accès aux clés privées, ce qui complique encore les choses.

Un exemple très médiatisé d'utilisation des données de la blockchain pour suivre un individu a été l'enquête et l'arrestation de Ross Ulbricht, l'individu derrière le tristement célèbre site Web darknet "Silk Road", qui a été utilisé pour diverses activités illégales. Les forces de l'ordre ont identifié Ulbricht comme l'individu derrière Silk Road, grâce aux données de la blockchain. De plus, ils pouvaient suivre les transactions Bitcoin et déterminer qu'un agent de la Drug Enforcement Administration (DEA) des États-Unis blanchissait des BTC connectés à Silk Road. Dans ce cas, les forces de l'ordre ont pu suivre les données disponibles sur la blockchain pour identifier un individu notoire. Mais imaginez si des entités malveillantes pouvaient suivre vos données avec une telle facilité grâce à la nature publique de la blockchain. Les résultats seraient dévastateurs.
Présentation des Preuves à divulgation nulle de connaissance
Les preuves à zéro connaissance ont été évoquées pour la première fois par Silvio Micali, Shafi Goldwasser et Charles Rackoff dans un article intitulé "La complexité des connaissances des systèmes de preuve interactifs", et sont considérées comme une innovation fascinante de la cryptographie qui peut être utilisée dans plusieurs scénarios. Dans le cas de la blockchain, cela peut aider à permettre des transactions sécurisées et anonymes. Preuve à divulgation nulle de connaissance, également connu sous le nom de Preuve à divulgation nulle de connaissance Protocol, permet à une partie (le prouveur) de prouver à la partie opposée (vérificateur) qu'elle connaît une valeur ou une information spécifique (x) sans divulguer aucune information en dehors du fait qu'elle connaît la valeur ou information en question (x). Le défi en matière de Preuve à divulgation nulle de connaissance est de justifier la possession de l'information sans la révéler ou toute autre information supplémentaire. Une preuve de connaissance zéro doit satisfaire aux critères suivants.

 	Complétude - Supposons que l'énoncé est vrai. Un vérificateur honnête, suivant correctement et fidèlement le protocole, sera convaincu par les informations fournies par le prouveur qui suit correctement le protocole.
 	Solidité - La solidité signifie qu'il ne devrait y avoir aucun moyen pour le prouveur de falsifier des informations ou de convaincre à tort le vérificateur. La falsification doit être impossible.
 	Preuve à divulgation nulle de connaissance - Si la déclaration du prouveur est vraie, le vérificateur n'apprend rien d'autre que le fait que l'information est vraie.

Les deux premiers sont considérés comme des propriétés de systèmes de preuve interactifs plus généraux, l'ajout d'une connaissance nulle transformant le processus de vérification en une preuve à connaissance nulle. En raison d'une faible possibilité (erreur de solidité) qu'un prouveur malveillant puisse convaincre le vérificateur d'une fausse déclaration, les preuves à nulle sont considérées comme des preuves probabilistes plutôt que des preuves déterministes. Cependant, l'erreur de correction peut être atténuée à une valeur négligeable.




	

	
	
		
			
				Une Preuve à divulgation nulle de connaissance doit répondre à quels critères ?
			
		

		
					

		
			
			
			
			Complétude
		
			
			Solidité
		
			
			Preuve à divulgation nulle de connaissance
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment fonctionne ZKP ?

Une Preuve à divulgation nulle de connaissance consiste en trois actions séquentielles entre les participants. Ces actions sont appelées un témoignage, un défi et une réponse. Approfondissons un peu pour mieux comprendre le rôle de chaque action en supposant qu'il y ait deux participants, A et B.

 	Témoin - Supposons que A connait une valeur ou une information spécifique, qui détermine également un ensemble de questions. Ces questions peuvent toujours être répondues correctement par A. Initialement, A peut choisir n'importe quelle question aléatoire dans l'ensemble, calculer la preuve et l'envoyer à B.


 	Défi - Après l'étape du témoin vient la phase de défi, où B choisit une question dans l'ensemble et demande à A d'y répondre.


 	Réponse – A calcule ensuite la réponse et la renvoie à B. Cela permet à B de déterminer si A connaît réellement la réponse.

Le processus décrit ci-dessus peut être répété autant de fois que nécessaire jusqu'à ce qu'il soit établi que A connaît la bonne réponse et que la probabilité de deviner devient suffisamment faible.




	

	
	
		
			
				L'article "La complexité des connaissances des systèmes de preuve interactifs" a été écrit par
			
		

		
					

		
			
			
			
			Silvio Micali , Shafi Goldwasser , Charles Rackoff
		
			
			Silvio Micali , Charles Hoskinson , Charles Rackoff
		
			
			Vitalik Buterin , Shafi Goldwasser , Satoshi Nakamoto
		
			
			Charles Hoskinson , Satoshi Nakamoto , Vitalik Buterin
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cas d'utilisation de ZKP
ZKP peut être appliqué dans plusieurs scénarios.
Systèmes d'authentification
Les systèmes d'authentification ont joué un rôle crucial dans la promotion de la recherche dans Preuve à divulgation nulle de connaissance . Dans ces systèmes, une partie souhaite prouver son identité à une seconde partie grâce à des informations secrètes. Cependant, il ne souhaite pas que la deuxième partie ait connaissance de ces informations secrètes.
Confidentialité
L'un des cas d'utilisation les plus importants de ZKP concerne les transactions qui nécessitent une confidentialité totale. Comprenons comment. Considérez une blockchain telle que la blockchain Bitcoin. Généralement, lorsqu'une transaction a lieu sur cette blockchain, les données liées à la transaction sont enregistrées sur la blockchain. Cela signifie que n'importe qui peut rassembler une certaine quantité d'informations sur la transaction en analysant les données sur la blockchain. Pour des raisons de confidentialité, il est essentiel de masquer certains détails pour des transactions spécifiques. ZKP permet de masquer les détails tout en garantissant la validité de la transaction en les ajoutant à un nouveau bloc.
Informations personnelles
Supposons que vous souhaitiez contracter un prêt auprès d'une banque. Pour demander le prêt, vous devez fournir une multitude de documents constitués d'une quantité considérable d'informations personnelles, les rendant accessibles à des tiers. Dans le cas de l'obtention d'un prêt auprès d'une banque, la seule information requise par la banque est de savoir si un particulier gagne un montant précis suffisant pour rembourser le prêt. ZKP peut aider les banques à vérifier si un individu gagne un montant minimum prédéfini sans révéler aucune information sensible à la banque ou à un tiers.
ZKP et Blockchain : la voie à suivre
Plusieurs projets et crypto-monnaies utilisent ZKP, tels que ZCash, SmartCash, Zerocash et ZeroVert. ZKP a principalement été implémenté via zk-SNARKS et zk-STARKS. zk-SNARKS a été initialement développé par ZCash. La plupart des blockchains sont pseudo-anonymes, ce qui signifie que l'identité d'un utilisateur peut être retracée jusqu'à ses transactions en étudiant les données de la blockchain. Ces informations sont accessibles à toute personne ayant accès à la blockchain et pourraient être exploitées par toute entité malveillante.

Malgré la réputation de la blockchain comme le summum de la cybersécurité, cette lacune particulière est bien connue des utilisateurs. Cependant, ZKP pourrait aider à corriger cette vulnérabilité et à garantir une confidentialité totale en ce qui concerne les informations personnelles. Bien que ZKP ait encore de nombreux défis à relever, il donne aux utilisateurs le contrôle de leurs données et de leur confidentialité, limite l'accès aux tiers et jouera un rôle crucial dans l'amélioration de la confidentialité en ce qui concerne les blockchains.




	

	
	
		
			
				Les ZKP sont utilisés par ?
			
		

		
					

		
			
			
			
			ZCash
		
			
			SmartCash
		
			
			ZeroCash
		
			
			ZeroVert
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!

### La Liberté Dans Le Monde Numérique : Est-ce Réalisable ?

 Aujourd'hui, alors que notre vie quotidienne devient de plus en plus numérique, les gens ont commencé à comprendre que certains de leurs biens dans ce nouveau monde numérique sont précieux. Diverses informations de compte, personnages de jeu, abonnements, billets pour accéder à des événements physiques et numériques et adhésion à un club : nous avons de plus en plus de choses importantes et de grande valeur pour nous. Et parfois même les choses liées au succès ou à la sécurité dans la vie. C'est un nouveau sentiment pour beaucoup d'entre nous de comprendre que vous dépendez de manière significative d'"une information" stockée quelque part et que nous perdons un peu de confort en essayant de bien la gérer. La plupart d'entre nous finissent par stocker ces éléments dans un fichier cloud ou dans un portefeuille propriétaire comme Apple. Il est rare de se rendre compte que ceux qui sont considérés comme des endroits sûrs ne sont pas aussi sûrs qu'on le pense. Premièrement, ils ne nous appartiennent pas et ne sont pas gérés par nous. Il s'agit de quelqu'un d'autre où la tenue des dossiers est effectuée. Deuxièmement, ils sont moins accessibles qu'on ne le pensait. Déplacez-vous simplement des États-Unis vers la Chine continentale et vous vous rendrez compte que la plupart de vos biens stockés sur Google ne sont plus accessibles. Pour ceux qui pensent plus loin, il apparaît clair que dans le monde numérique que nous utilisions, rien ne vous appartient vraiment lorsqu'il est stocké dans une sorte de cloud ou simplement inconnu de vos serveurs : le serveur peut disparaître, le service que vous utilisez pour accéder aux informations peuvent également disparaître, les informations peuvent également être modifiées par les administrateurs du serveur ou à la suite d'une intervention malveillante.

D'accord. Il semble qu'il n'y ait pas beaucoup de possibilités de vraiment posséder quelque chose dans le monde numérique. Mais en avons-nous besoin ? Probablement pas. En même temps, je crois personnellement aux paroles de George Washington :
La liberté et les droits de propriété sont inséparables. Vous ne pouvez pas avoir l'un sans l'autre.


Ce qui est une motivation parfaite pour moi de rechercher de meilleures possibilités de droits de propriété numériques que nous n'avions auparavant.

Étonnamment, la réponse est assez simple et assez intéressante : la technologie à laquelle nous avons l'habitude de penser comme « la tokenisation de toutes sortes d'art » est parfaitement capable de faciliter le stockage auto-souverain des droits de propriété numériques. Oui, je parle de NFT. En attribuant un NFT à n'importe quel élément d'information, nous pouvons définir le prix initial et la propriété de cet élément. Et il sera stocké dans le portefeuille du propriétaire pour être utilisé si nécessaire pour toute sorte de démonstrations ou de présentations au point de contrôle et d'accès aux portes de contrôle. Et la preuve de notre propriété est stockée de manière décentralisée, ce qui empêche toute modification non autorisée des informations et facilite la résilience nécessaire : nous pouvons être sûrs qu'au moins une partie du réseau décentralisé restera accessible, ce qui signifie toujours fournir au demandeur les informations sur le fait que le propriétaire du bien est toujours propriétaire.

 

Et un pas en arrière pour une vision plus large : en visualisant NFT tout type d'informations, nous permettons l'interopérabilité entre divers systèmes d'information, solutions informatiques, métavers et royaumes de jeu : pour accéder aux données, il nous suffit de demander le portefeuille du propriétaire à propos de l'approvisionnement de certains NFT et ses paramètres d'utilité. De plus, nous pouvons utiliser ces paramètres pour toute sorte de vérification, de calcul ou de simple visualisation.

Alors, résumons : NFT est parfait pour représenter la propriété dans le monde numérique : il a le prix, le propriétaire et la propriété réelle des données dont le propriétaire revendique, et en plus de tout cela, il peut avoir une représentation visuelle ou audio rendant la possession reconnaissable. Pour beaucoup d'entre nous, cela permettra en outre le développement d'une connexion émotionnelle qui est souvent développée par la représentation visuelle. Donc, encore plus court, pour les enfants probablement : NFT est quelque chose de sympa et échangeable, nous permettant de revendiquer nos droits dans le nouveau monde numérique.

### Qu'est-ce que le Collectif Numérique NEAR

Le NEAR Digital Collective (NDC) est un projet ambitieux qui rassemble les utilisateurs, les projets, les parties prenantes et les partenaires de l'écosystème NEAR pour créer une manière radicalement nouvelle de se gouverner.

Le NDC, imaginé à l'origine par Illia Polosukhin, cofondateur du protocole NEAR, est désormais un mouvement à part entière dirigé par la communauté NEAR. Son objectif est d'établir un modèle de trésorerie et de gouvernance communautaire qui permet à l'écosystème de prendre collectivement des décisions sur tout, du financement aux représentants élus et plus encore. C'est une étape importante vers la création d'un réseau véritablement décentralisé.

En créant un cadre qui permet à tout membre du réseau d'avoir son mot à dire sur la gestion de NEAR, l'objectif du NDC est de combiner la transparence, la prise de décision collective, l'évolution des modèles de gouvernance et l'autodétermination d'une manière complètement nouvelle.

Le NDC prévoit de le faire en aidant à créer la Constitution NEAR, un document unificateur qui consacre les idées d'auto-gouvernance et de décentralisation au cœur du fonctionnement de l'écosystème NEAR.

Pourquoi est-ce important?
L'écosystème NEAR est composé de plus de 1 000 projets, hubs régionaux, nœuds de financement, fournisseurs d'infrastructures et plus de 20 millions de portefeuilles. C'est beaucoup de monde. Le NDC a été créé pour aider toutes les personnes impliquées à jouer un rôle actif dans l'évolution de NEAR.

Qu'il s'agisse de la manière dont les fonds sont alloués, de la manière dont les élections se déroulent ou de qui représente la mosaïque d'intérêts qui composent cet écosystème florissant et diversifié. Le NDC veut aider tout le monde à avoir une voix, et que ces voix soient enregistrées sur la chaîne.
Comment fait-il cela ?
Le NDC aide à développer un système de gouvernance. Une fois en place, il permettra aux gens de voter sur une grande variété de questions, d'élire des membres à différents conseils d'administration et même d'apporter des modifications à la constitution elle-même.

L'essence de la NDC donne vie à ce cadre radical et permet à la communauté de s'engager et de participer activement à l'élaboration de l'avenir de NEAR.

Dans sa phase actuelle, le NDC travaille sur une structure de gouvernance qui comprend les sections suivantes :

 	Voting Body - Il s'agit de tous les comptes proches actifs, tels que qualifiés par le cadre de gouvernance
 	House of Merit - Un groupe de membres expérimentés de la communauté nommés par les membres de l'écosystème pour les représenter lors des votes et des décisions clés.
 	Conseil des conseillers — Conseillers nommés pour aider à façonner l'orientation de la Maison du mérite.
 	Commission de la transparence — les membres de la communauté nommés pour s'assurer que les freins et contrepoids sont en place et respectés.
 	Trésorerie communautaire — Les membres de la Chambre du mérite, avec le soutien du Conseil des conseillers, aident à faciliter le vote sur la façon dont les fonds communautaires sont alloués.

Vous pouvez trouver plus informations sur ce qui précède ici.

Il s'agit d'un travail en cours et est actuellement supervisé par le Groupe de travail sur la gouvernance, or GWG. Il s'agit d'un ensemble de membres de la communauté travaillant à affiner les modèles de gouvernance qui aideront chacun à s'exprimer.

Le Collectif et le GWG invitent tout le monde à partager et discuter des idées. Tous les détails sur la façon de le faire peuvent être trouvés ici.
Quelle est la portée de la CDN ?
Bien que la constitution et les modèles de gouvernance soient essentiels, la NDC contribuera également à façonner, définir et fournir les éléments suivants :

 	Constitution NEAR.
 	Créez et déployez une prise de décision en chaîne locale et mondiale.
 	Créez et déployez un référentiel de journaux, journaux et procès-verbaux locaux et mondiaux sur la chaîne.
 	Établissez des organes directeurs, leurs opérations, leurs pouvoirs et les freins et contrepoids dont chacun a besoin.
 	Créer et maintenir une trésorerie communautaire avec un ensemble complet de procédures de fonctionnement et de sauvegardes.
 	Créer et tenir à jour les lignes directrices communautaires, le code de conduite et les protocoles de règlement des différends.
 	Créer et déployer une stratégie de communication pour s'assurer que le travail effectué par le NDC et le GWG est facile d'accès.
 	Une stratégie pour aider la communauté à trouver, accéder et utiliser le NDC.
 	Aider à développer et déployer un modèle de gouvernance DAO
 	Faciliter la croissance de l'écosystème NEAR plus largement.

Quel rôle la Fondation NEAR joue-t-elle dans le NDC ?
La Fondation est partenaire et contributeur du NDC. Il soutient le travail effectué par le Collectif et cherchera finalement à confier son rôle de financement à la communauté une fois qu'il sera prêt à le faire.
Qui travaille sur NEAR Digital Collective ?
Le Collectif est composé de membres de l'écosystème NEAR. Certains sont d'anciens membres de la Fondation, d'autres sont des fondateurs de projets, et d'autres encore sont des utilisateurs et des partisans de longue date de la blockchain et des projets qui s'en inspirent.

N'hésitez pas à contacter l'un des chefs d'équipe.
Pourquoi la décentralisation est-elle importante ?
La décentralisation est un terme devenu synonyme de blockchain, mais dont les origines remontent à la Révolution française au XVIIIe siècle.

La décentralisation à l'époque et aujourd'hui est le processus par lequel les activités d'une organisation, en particulier celles concernant la planification et la prise de décision, sont réparties ou déléguées à partir d'un lieu ou d'un groupe central faisant autorité.

Ceci est important car, comme tout étudiant en histoire vous le dira, lorsque le pouvoir devient trop centralisé, les possibilités d'abus augmentent. En 2022, les membres de la communauté blockchain ont fait l'expérience directe de ce qui se passe lorsque les autorités centralisées abusent de leur pouvoir.

Les membres de la communauté NEAR pensent que l'objectif de la décentralisation est d'améliorer ce qui existait auparavant. Il croit que l'augmentation de la transparence et de la démocratie crée une communauté juste et plus égale pour tous.

Mais pour y arriver, il faut s'engager dans un processus. Un processus qui devra évoluer et s'adapter aux besoins de la communauté, et pour que cette communauté participe à sa formation.

La décentralisation est vitale pour la santé et la durabilité à long terme de tout ensemble de personnes et d'idées. Le NDC est la façon dont la communauté NEAR essaie d'y parvenir.
Comment puis-je m'impliquer?
Tout membre de la communauté NEAR est libre de rejoindre l'un des groupes de travail suivants.

 	Constitution
 	Gouvernance et gouvernance technologique
 	Juridique
 	Engagement communautaire
 	Communication

Commencez par suivre le processus d'intégration du groupe de travail sur la gouvernance (GWG).

Ou si vous cherchez à approfondir le fonctionnement de tout cela, vous pouvez consulter la page Présentation.
Suivez le NDC

 	Twitter
 	Discord

### Shall we bring back tips on Twitter?

Shall we bring back tips on Twitter? 
            
                84 votes by,
                192 nLEARNs spent
            
            
            
                                    
                        
                            Yes                            
                                (73 votes,
                                173 nLEARNs)
                            
                        
                        
                             
                            87%
                        
                    
                                    
                        
                            No                            
                                (5 votes,
                                11 nLEARNs)
                            
                        
                        
                             
                            6%
                        
                    
                                    
                        
                            I do not know                            
                                (6 votes,
                                8 nLEARNs)
                            
                        
                        
                             
                            7%

### Pikespeak Beta test

Follow @LearnNEAR and @pikespeak_ai on Twitter

Beta test sprint starts: March 14, 9 am ET
Beta Test sprint ends: March 19, 9 am ET
Requirements:

 	Login with NEAR at https://pikespeak.ai/
 	Start your FREE trial
 	Explore NEAR world https://pikespeak.ai/near-world/overview
 	Explore your favorite NEAR wallets https://pikespeak.ai/wallet-explorer
 	Explore your favorite NEAR contracts https://pikespeak.ai/contract-analysis/overview/global
 	Unleash your curiosity - explore other dashboards
 	Make a screenshot of the dashboard/graph that impressed you the most!
 	Tweet your screenshot and  "These numbers look beautiful at @pikespeak_ai via @LearnNEAR Beta test!"
 	Submit feedback form

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR.

Happy Testing!

If any question for the test feel free to contact project lead @dpironi at LNC Telegram Beta test topic

### What is Pikespeak?

Built on the NEAR Protocol, Pikespeak is a Data & Analytics solution offering to institutions, Web3 projects, and individuals:

 	visualisations and dashboards of the most fundamental Web3 use cases; DeFi, DAOs, Gaming, NFTs, etc.
 	a powerful Indexer and API covering 50+ data endpoints
 	dedicated RPC and Indexer
 	Custom data points and insights

The solution has already attracted 400+ early users and is used by top-tier projects within the ecosystem - including Immunefi, Proximity Labs, Octopus Network, Ref Finance, Tonic, Stader and Learn NEAR Club.




	

	
	
		
			
				Who is not yet using Pikespeak? 
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			The President of the United States
		
			
			Tonic DEX
		
			
			Learn NEAR Club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Why?
Because blockchain is not designed for traditional analytics tools:

 	Accessing usable data can be complex, making it hard to explore opportunities
 	Extracting data rapidly, at-scale, and at-cost is a nontrivial challenge and requires interpretation based on the smart contracts deployed




In simple terms, Pikespeak aims at:

 	Indexing, storing and transforming on-chain data into human-readable tables
 	Empowering users with powerful analytics

What for?
It depends on the problem/question you need to solve/answer. Here are a few tangible examples (non-exhaustive):

 	DeFi users

 	What’s the value and breakdown of my portfolio?
 	What’s my P/L over a specific period of time?
 	The taxman (ex: IRS) is asking for logs of my trades and blockchain activity for the last fiscal year, how can I provide that information?
 	I am interested in holding a token, but I would like to understand a few things; what’s the circulating supply? Who’s holding the token (rich list)? How do large holders behave? Have they been selling recently? How long have they been holding the token? Etc.
 	What are the largest token transfers over the last 24h?




 	Venture Capital companies

 	What’s the value and breakdown of my portfolio?
 	My accountant is asking for logs of the company’s blockchain activity, how can I provide that information?
 	What are the most active projects?
 	How many active users do my portfolio companies have?
 	One of portfolio companies is asserting that their product is having a massive traction, how can I verify and challenge this information?






	

	
	
		
			
				Using Pikespeak, can I: (select all that apply)
			
		

		
					

		
			Please select 3 correct answers
			
			
			Download the entire history of my wallet in a csv format?
		
			
			Check out the activity and key metrics of any smart contract?
		
			
			Analyse the historical transactions of Genesis addresses?
		
			
			Predict any token price with 100% accuracy?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	Project Owners

 	I am fundraising and would like to understand the addressable market size on my segment (ex: Gaming), how many Gaming active users are there?  Who’s leading on my segment? What are the market shares of competing projects?
 	I would like to incentivise/airdrop specific addresses based on their portfolio and activity, can I get access to the list of those addresses?
 	What’s the TVL of my project?
 	Why did my project lose 20% of its TVL on this specific date?




 	Project Marketing Leaders

 	I have recently supported/led a marketing campaign, how did it translate into user acquisition?
 	I would like to push for a marketing collaboration with another project, has my user base demonstrated an interest / is already interacting with this project? How close are our communities?
 	I would like to incentivise/airdrop specific addresses based on their portfolio and activity, can I get access to the list of those addresses?




 	Project Product Leaders

 	What’s the user retention?
 	What are the most used features (call methods)?
 	A competing project has launched a new feature, how well has it been received by the community? Did it translate into user acquisition?
 	How many of my users are using competing applications? How much are they spending on those other applications?




 	Validator Owners

 	Why did my public validator lose 20% of its delegators yesterday?
 	I see that 1M $NEAR were unstaked yesterday, what was the address behind the unstaking event?
 	How many delegators do I have compared to competing validators?
 	How many rewards has my node accumulated since inception?




 	DAO Owners

 	What’s the DAO treasury?
 	How many DAO members have voted for the last proposal?
 	Is one of my DAO members involved with other DAOs? If yes, what are there?
 	How many payments does my DAO have settled over the last year? For what total amount?




 	Ecosystem Fund Treasury Manager

 	How many grants have been given over the last year? For what total amount?
 	How well are performing my dapp-related grantees on the following criteria; number of transactions, active users, treasury management?
 	How other ecosystem funds have been allocating funds recently? What are the projects being supported?




 	Regulators and/or AML/KYC Compliance Investigators

 	What’s the relationship between this address and another?
 	This address has been involved in a hack, what was the exchange(s) used to cash out?
 	What was/were the exchange(s) used to fund this malicious address?
 	A few hacks have the same modus operandi but were generated by different addresses, are they connected somehow?
 	What are all the layer-1 interactions/graph of a specific address?




 	Blockchain Engineers

 	A specific transaction failed, can I check the breakdown of the receipts of the transaction to understand what happened?
 	What was the gas cost of this specific transaction?






	

	
	
		
			
				Can Pikespeak be useful for: (select all that apply)
			
		

		
					

		
			Please select 3 correct answers
			
			
			VCs and Institutions exposed to the NEAR Protocol?
		
			
			Pizza Maker based in Naples?
		
			
			Projects and Dapps building on NEAR?
		
			
			Simple DeFi or NEAR blockchain user?
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Data is great, stories are better
The cost to access on-data data is marginal compared to traditional and private markets, such as Stock Exchanges and customer insights (ex: panels) for a specific industry. That creates a unique opportunity for burgeoning journalists, investigators or any type of citizen journalism to emerge. The quality and coverage of the FTX debacle on Twitter was a great illustration of that trend.

Moreover, the NEARWEEK Report-to-Earn model is an innovative way to incentivise citizen journalism and push people to participate in the News content creation process.

Below is a list of events that could potentially lead to interesting and insightful stories. We would like to encourage the LNC community to leverage Pikespeak to tell great stories.

 	June 23rd, 2022 - 39M $NEAR tokens were unstaked from validators
 	March 4th, 5th and 6th, 2023 - Near Social (social.near) has had a significant inflow of new users
 	March 8th, 2023 - The Multi Sender (multisender.app.near) contract (send multiple transfers in one simple transaction) sent $1.13M to multiple addresses, its largest transaction since creation




	

	
	
		
			
				Who is not yet using Pikespeak?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			Immunefi
		
			
			The President of the United States
		
			
			Tonic DEX
		
			
			Learn NEAR Club
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Contact 

For more information, contact:

Didier Pironi

Email: didier@pikespeak.ai

Date: 09/03/2023

Pikespeak.ai

### Update - March 9, 2023

Brief Summary:

 	
👉LNC presented in front of NEAR OGs and leading projects at #ETHDenver2023 NEAR offsite!




Results:

 	🏗️Enroll in updated "NEAR Certified Developer" course🧑‍💻
 	🏆 Top 10 #NEAR projects who got the most (L)Earners attention in February 2023! 
 	🧪 Beta test for Positron Bridge and HERE wallet were success -  over $NEAR 130 were awarded for the feedback!
 	 (L)Earn "How Zero Knowledge Proof Can Ensure Data Privacy"
 	 492 (L)Earners successfully redeemed in February Redeem Window - check LNC Telegram for Redeem discussions 

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Don't miss March Redeem to NEAR window!

### LNC presentation at NEAR roundtable at ETHDenver



### Как стейкать NEAR

Стэйкинг в экосистеме NEAR — это процветающая ниша, предлагающая множество подходов и решений. Давайте рассмотрим различные варианты стэйкинга и подумаем, какой из них лучше всего подходит для вас.

Для простоты сравнения мы будем оценивать каждый вариант по трем параметрам: пользовательский интерфейс (UI), годовая процентная доходность (APY), комиссия за снятие средств и безопасность.
Стандартный стэйкинг NEAR
Поскольку NEAR работает на основе механизма консенсуса Delegated Proof-of-Stake (DPOS), каждый держатель токена NEAR может делегировать свои токены определенному валидатору. Полный список валидаторов доступен по адресу https://explorer.shardnet.near.org/nodes/validators. Выберите валидатора, который вам нравится и делегируйте ему свои токены. Валидатор получит за это комиссию, которая указана перед отбором, а вы получите возврат в токенах NEAR. Обычно она составляет не более 9,7% годовых.

Это может показаться простым, но представьте, что вы только что купили свои первые токены NEAR и хотите получить доход. Кроме того, вам нужно подождать 3 дня, чтобы вывести NEAR из стейкинга,  если вы хотите вывести средства мгновенно, вам придется заплатить комиссию. Более того, вам нужно доверять одному из валидаторов, которым вы делегируете свои токены.




	

	
	
		
			
				Как долго вам нужно ждать, чтобы вывести NEAR из стандартного стейкинга?
			
		

		
					

		
			
			
			
			3 дня
		
			
			1 день
		
			
			неделя
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Централизованный стейкинг NEAR
Централизованные биржи уже давно придумали механизмы, позволяющие еще больше увеличить свою прибыль за счет дополнительных инструментов. Одним из них является биржевой стейкинг токенов. Как и со всеми средствами, которые вы храните на бирже, вы на самом деле ими не владеете. То же самое касается стейкинга. Хотя сами биржи используют для этого свои узлы блокчейна, по сути, все ваши средства находятся у них.

Это решение вполне правомерно, когда речь идет о пользователях, которые активно не погружены в Web3 и привыкли просто покупать любимые монеты на биржах. В настоящее время более 1 миллиона человек владеют NEAR на Binance. Существует риск взлома или кражи ваших средств, как это видно на примере FTX. Кроме того, доходность на CEX намного ниже, чем в DeFi — 3% для гибкого стейкинга (с мгновенным выводом).




	

	
	
		
			
				В каком типе стейкинга вы не владеете своими средствами?
			
		

		
					

		
			
			
			
			Meta pool
		
			
			HERE
		
			
			Централизованный
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta pool и Linear
Варианты ставок Metapool и Linear считаются родными в экосистеме NEAR. Чтобы застейкать NEAR, вам понадобится кошелек NEAR и несколько токенов NEAR. Этот тип ставок лучше, чем два других варианта, потому что он управляется проектами в рамках экосистемы и имеет приличный APY около 9,4%, что также важно. Оба проекта прошли аудит BlockSec и не имели проблем с безопасностью.

Новичку в экосистеме нужно будет найти один из этих проектов и доверить ему свои средства, а также регулярно посещать веб-сайт проекта. Также важно помнить, что за мгновенный вывод NEAR из стейкинга взимается дополнительная плата.


HERE Wallet стейкинг
Думаю, вы уже поняли, кто заслуживает большего внимания в плане стейкинга. Поскольку HERE — это простой метод онбординга не только для крипто, но и для пользователей web2, стейкинг тоже должен быть таким же простым и не вызывать проблем у того, кто не знаком с криптовалютой.

Вот почему мы создали неблокирующий механизм ставок, с помощью которого вы можете вывести свои NEAR в любое время без каких-либо комиссий и при этом получать пассивный доход. Это возможно благодаря резерву ликвидности по контракту, как и в обычных банках, когда используется 90%, но в банкомате всегда есть деньги. Возврат инвестиций варьируется в зависимости от того, насколько активно вы вносите/выводите средства и в среднем составляет около 9,8%. Владельцы определенных NFT, например, первые пользователи HERE Wallet, также могут получать дополнительный доход.

Сам процесс стейкинга максимально прост. Все, что вам нужно сделать, это нажать одну кнопку. После этого необходимое количество NEAR будет автоматически разблокировано до совершения любой транзакции.

В настоящее время HERE Staking прошел аудит с командой OtterSec.




	

	
	
		
			
				Какова комиссия за мгновенный вывод NEAR из стейкинга HERE?
			
		

		
					

		
			
			
			
			1,5%
		
			
			0%
		
			
			3,2%
		
	
		

		
		
			
				Correct!
				Wrong!

### Mengapa Ref v2 Lebih Baik dibanding Uni v3

Pendahuluan dan Latar Belakang
Ref Finance v2 telah membawa masa depan transaksi dan aktifitas perdagangan di NEAR: yakni sebagai sebuah platform Discretized Liquidity AMM (DLAMM) dengan limit order. Karena ini telah diluncurkan dalam beberapa minggu mendatang, cepat atau lambat kita akan merasakan pengalaman layaknya bertransaksi di Central Exchange dengan keuntungan maupun manfaat yang ada di DEX.
TL;DR
1. Kejadian dari runtuhnya FTX menunjukkan perlunya kehadiran DEX yang memberikan pengalaman perdagangan yang sebanding layaknya CEX.

2. Ref Finance meluncurkan versi terbarunya (v2), komponen pentingnya adalah Auto Market Maker likuiditas diskrit (DLAMM) dan limit order.

3. DLAMM merupakan versi peningkatan dari likuiditas terkonsentrasi dari Uniswap v3, dengan penyediaan likuiditas yang lebih akurat, peningkatan efisiensi dana, dan slippage hampir nol.

4. Ref v2 juga memiliki limit order asli bawaan. Trader dapat menempatkan pesanan dan limit order dengan slippage hampir nol, menghadirkan pengalaman transaksi ala CEX di DEX.

5. Ref v2 dapat dinikmati lebih cepat dan lebih murah dibandingkan dengan semua jaringan lainnya, berkat finalitas NEAR yang cepat (1–2 detik) dan biaya sangat murah sehingga dapat diabaikan (<$0,01).

6. Likuiditas terdiskritisasi AMM adalah sum game positif  di mana LP dan trader sama-sama diuntungkan.

Dengan runtuhnya salah satu bursa terpusat (CEX) terbesar di dunia baru-baru ini yakni FTX, komunitas crypto dengan cepat menyadari pentingnya arti desentralisasi. Adopsi ke protokol keuangan terdesentralisasi (DeFi), terutama pertukaran terdesentralisasi (DEX), jadi bertumbuh karena orang menyadari perlunya transparansi dan hak kelolaan sendiri atas aset seseorang.

Dengan DEX yang saat ini jadi lebih penting daripada sebelumnya, mari kita lihat ke mana mereka akan bergerak. Pada artikel ini, kami akan menganalisis evolusi DEX melalui contoh utamanya, Uniswap, dan memperkenalkan fase pengembangan selanjutnya: discretized concentrated liquidity.
Rekap dari Uniswap v1, v2, dan v3
Pada bulan November 2018, Uniswap v1 diluncurkan sebagian besar sebagai bukti konsep (proof-of-concept). Ini memperkenalkan ide dari AMM, yakni memanfaatkan matematika di balik persamaan produk konstan, x * y = k. Pada saat itu, Uniswap v1 hanya mendukung pasangan perdagangan ETH-ERC20 dan kumpulan likuiditas (LP).

Pada bulan Mei 2020, Uniswap v2 diluncurkan sebagai bentuk peningkatan dari v1. Beberapa peningkatan utama adalah terkait pengenalan liquidity pool, pool ERC20-ERC20, harga TWAP terdesentralisasi oracle, dan flash swap.

Pada bulan Mei 2021, Uniswap v3 diluncurkan. v3 memperkenalkan inovasi utama seperti likuiditas terkonsentrasi,  peningkatan keamanan, jenis tingkatan biaya terbaru, pengembangan feed oracle, dan likuiditas non-fungible. Secara keseluruhan, menu utama dari Uniswap v3 adalah mencapai efisiensi modal yang lebih baik untuk trader platform dan penyedia likuiditas melalui konsep likuiditas terkonsentrasi.




	

	
	
		
			
				Apa jenis trading yang didukung oleh Uniswap v1?
			
		

		
					

		
			
			
			
			ETH-ERC20 trading pairs and pools
		
			
			ERC20-ERC20 pools
		
			
			ETH-NEAR trading pairs and pools
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apa itu Concentrated Liquidity? Apa manfaatnya?
Berbeda halnya dengan AMM yang di mana likuiditas hanya disediakan tanpa menentukan rentang spesifik, Concentrated Liquidity/ likuiditas terkonsentrasi berarti LP dapat mengalokasikan modal ke interval harga pilihan mereka, yang memungkinkan efisiensi modal yang jauh lebih tinggi.

Likuiditas terkonsentrasi menguntungkan semua pihak baik trader maupun LP.

LP mendapatkan keuntungan dari efisiensi modal dalam menyediakan rentang likuiditas yang sempit, umumnya lebih banyak digunakan oleh trader, yang akibatnya dapat menghasilkan biaya hingga 4000x lebih banyak dibandingkan dengan Uniswap v2.

Untuk para Trader, mereka mendapat manfaat dari likuiditas yang lebih dalam

Uniswap V3 telah melihat adopsi yang kuat dari komunitas crypto berkat model concentrated liquidity yang baru. Volume Uniswap v3 meningkat terus sejak pertama kali diluncurkan, dengan cepat mereka mencapai dominasi 97,2% dibandingkan Uniswap v2 dalam hal volume harian.

Discretized Liquidity pada Ref v2
Dalam kerjasamanya dengan iZUMi Finance dan Arctic, Ref Finance dengan bangga memperkenalkan Ref v2: Discretized Liquidity AMM (DLAMM) dengan limit order. Pikirkan jika likuiditas terkonsentrasi yang ada di Uniswap V3 tetapi lebih baik, dan sekarang dengan fungsi limit order untuk menghadirkan pengalaman layaknya transaksi di CEX secara on-chain.
Discretized Liquidity AMM vs Concentrated Liquidity AMM
Likuiditas Terdiskritisasi (Discretized Liquidity) adalah kependekan dari DLAMM, yang berarti "Discretized liquidity automated market makeri". AMM likuiditas terkonsentrasi yang ada, seperti Uniswap v3, mengikuti rumus produk konstan (X*Y=K), di mana harga berubah terus menerus dengan jumlah token X dan Y di pool. Didesain oleh iZUMi Finance, AMM likuiditas terdiskritisasi menggunakan kurva produk konstan sintetik dengan rumus penjumlahan konstan terdiskritisasi (x+y=k), di mana harga didiskritisasi dalam AMM (lihat gambar di bawah).

Hal ini menghasilkan dua peningkatan besar untuk AMM likuiditas terdiskritisasi: slippage yang berkurang dan penyediaan likuiditas yang lebih akurat dalam kisaran harga.




	

	
	
		
			
				Jenis market maker apa yang digunakan pada Ref Finance?
			
		

		
					

		
			
			
			
			Concentrated Liquidity AMM
		
			
			Discretized Liquidity AMM
		
			
			Focused Liquidity AMM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Ref v2 Berbenah diatas Uniswap v3
Ref v2 tidak hanya memperkenalkan bagian terbaik dari Uniswap v3 (efisiensi dana) dengan AMM likuiditasnya yang terdiskritisasi, tetapi melangkah lebih jauh untuk memungkinkan pengalaman transaksi layaknya di CEX yang biasanya tidak mungkin dilakukan pada DEX dengan fungsi limit order bawaan. Dan semua ini, dengan manfaat penuh dari DEX: transaksi end-to-end yang terdesentralisasi, aman, dan transparan untuk trader dan penyedia likuiditas.

Pada Ref v2 kita bisa ..

 	Menikmati efisiensi modal yang tinggi berkat AMM Likuiditas Diskrit

Sama seperti di Uni v3, Ref v2 memungkinkan kita menyediakan likuiditas terkonsentrasi — yaitu likuiditas yang khusus untuk rentang harga. Ini berarti bahwa sebagai LP anda dapat menyediakan likuiditas ke kisaran harga yang menurut anda lebih banyak digunakan oleh trader, misalnya, dan berpotensi mengumpulkan lebih banyak biaya daripada sebelumnya. Sebagai seorang trader, anda berpotensi menikmati likuiditas yang lebih dalam pada rentang harga yang sering Anda kunjungi, karena likuiditas tidak lagi harus tersebar di seluruh rentang.

 	Menikmati AMM ala Uni V3 dengan sedikit kecepatan dan biaya

Dengan memanfaatkan NEAR, Ref dapat menawarkan AMM likuiditasnya yang terdiskritisasi dengan penyelesaian yang sangat cepat (1–2 detik) dan dengan biaya yang dapat diabaikan (sepersekian sen).

 	Menempatkan limit order

Secara definisi, limit order adalah order untuk membeli atau menjual aset dengan batasan harga maksimum yang harus dibayar atau harga minimum di mana kita akan menjual. Ini adalah fitur khas pada CEX yang menggunakan order book, yang memungkinkan pengguna untuk memprogram pesanan dalam kisaran harga pilihan mereka.

Saat ini, tidak ada fungsi limit order yang sesuai di Uniswap v3. Satu-satunya cara adalah menyediakan likuiditas terkonsentrasi di luar harga saat ini dan dengan demikian meniru limit order. Ref v2, di sisi lain, memperkenalkan fungsionalitas limit order bawaan. Sekarang pengguna dapat bertransaksi di DEX seperti layaknya di CEX 🤯

 	Menempatkan limit order tanpa batasan harga

Karena Uni v3 hanya mengizinkan limit order secara tidak langsung, setelah limit order sintetik diisi, jika atau ketika harga kembali ke titik semula, LP tidak lagi dapat mengklaim penghasilan dari order mereka karena token yang diperoleh akan dikembalikan. .

Pada Ref v2, pengguna dapat menempatkan limit order pembelian dengan harga yang lebih tinggi dari harga saat ini, dan algoritme kemudian akan mencocokkan secara otomatis dengan harga terbaik. Ini lebih lanjut memberikan pengalaman transaksi  yang mirip dengan CEX.

5. Menempatkan limit order dengan slippage mendekati nol

Berkat AMM likuiditas terdiskritisasi dari Ref, yang memanfaatkan kekuatan rumus jumlah konstan, trader tidak hanya dapat menempatkan limit order, tetapi melakukannya dengan selip hampir nol.

Selain itu, saat trader menempatkan limit order pada Ref v2, mereka secara efektif menjadi LP sementara untuk pool tersebut dalam kisaran harga tersebut. Selain dari model DLAMM yang canggih itu sendiri, kapasitas limit order Ref v2 secara efektif menambah likuiditas tambahan ke dalam pool, sehingga mengurangi lebih banyak selip.

6. Manfaat dari prioritas limit order dan struktur biaya LP yang adil

Pengenalan penyedia likuiditas limit order pada Ref v2 secara alami memperkenalkan persaingan biaya dengan LP reguler yang menyediakan likuiditas terkonsentrasi. Untuk memberikan insentif terbaik kepada masing-masing pihak, limit order akan selalu diprioritaskan dalam hal urutan transaksi, namun biaya LP akan didistribusikan secara proporsional kepada penyedia likuiditas yang terkonsentrasi.




	

	
	
		
			
				Exchange mana yang memberikan pengguna kemampuan untuk menerapkan limit order tanpa batasan harga?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			1Inch
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kenapa KAMU harus peduli/ paham?

TLDR; Discretized Liquidity AMM adalah sum-game yang positif. Semua orang diuntungkan di Ref V2.

 	Penyedia Likuiditas (LP): Seperti di Uni v3, LP di Ref v2 dapat memaksimalkan biaya transaksi yang mereka kumpulkan dari perdagangan dengan menyediakan likuiditas terkonsentrasi ke rentang harga tertentu yang sering digunakan trader. Selain itu, LP juga menerima semua biaya yang dihasilkan dari perdagangan limit order. Ketika limit order terisi, bukan trader yang menerima biaya transaksi, melainkan LP yang mendasari dalam rentang tersebut.


 	Trader: Trader sekarang dapat menikmati likuiditas yang lebih dalam, serta menempatkan order market dan limit order dengan selip hampir nol. Ketika trader menempatkan limit order, mereka secara efektif menjadi penyedia likuiditas, yang “membuat pasar” dengan menempatkan penawaran ke bursa.


 	Active Market Maker: Market maker dapat mengurangi biaya manajemen LP ke tingkat yang jauh lebih terjangkau (<$0,01/txn), dengan keuntungan dan kerugian (PnL) yang lebih dapat diprediksi, dan pengalaman perdagangan yang lebih dekat dengan pertukaran CLOB.

“TLDR : DL-AMM adalah sum-game yang positif”

### Что такое NEAR Digital Collective?

NEAR Digital Collective (NDC) — амбициозный проект, который объединяет пользователей, проекты, заинтересованные стороны и партнеров экосистемы NEAR для создания радикально нового способа управления.

NDC, первоначально был задуман Ильей Полосухиным, соучредителем Протокола NEAR. Сейчас он является полноценным движением, возглавляемым сообществом NEAR. Его цель — создать модель казначейства и управления сообщества, которая позволит экосистеме коллективно принимать решения по всем вопросам, от финансирования до избранных представителей и многого другого. Это важный шаг к созданию действительно децентрализованной сети.

С помощью NDC создать структуру, которая позволяет любому члену сети влиять на то, как работает NEAR. Цель NDC состоит в том, чтобы совершенно по-новому сочетать прозрачность, коллективное принятие решений, развивающиеся модели управления и самоопределение.

В планы NDC входит создать Конституцию NEAR, объединяющий документ, который закрепляет идеи самоуправления и децентрализации в основе работы экосистемы.

Почему это важно?
Экосистема NEAR состоит из более чем 1000 проектов, региональных центров, узлов финансирования, поставщиков инфраструктуры и более 20 миллионов кошельков. Это очень большая экосистема. NDC был создан, чтобы помочь всем участникам принять активное участие в развитии NEAR.

Независимо от того, как распределяется финансирование, как проходят выборы или кто представляет интересы. NDC хочет помочь каждому иметь право голоса, и чтобы эти голоса были учтены.
Как это работает?
NDC помогает разработать систему управления. Когда она будет готова, она позволит людям голосовать по широкому кругу вопросов, избирать членов в различные советы управляющих и даже вносить поправки в саму конституцию.

NDC воплощает в жизнь это и позволит сообществу участвовать и принимать активные действия в формировании будущего NEAR.

На текущем этапе NDC работает над структурой управления, которая включает следующие разделы:

 	Голосующий орган — это каждая активная учетная запись NEAR, определяемая структурой управления.
 	Дом управления — группа опытных членов сообщества, назначенных членами экосистемы для их представления во время голосования и принятия ключевых решений.
 	Совет консулов — советники, назначаемые для помощи в формировании направления Дома управления.
 	Комиссия по прозрачности — члены сообщества, назначенные для обеспечения системы сдержек и противовесов.
 	Казначейство — члены Дома управления при поддержке Совета консулов помогают организовать голосование по распределению средств сообщества.

Более подробную информацию о вышеизложенном вы можете найти здесь.

Сейчас всё находится в стадии разработки. Контроль за разработкой осуществляет рабочая группа по управлению или GWG. Это собрание членов сообщества, работающих над совершенствованием моделей управления, которые помогут каждому высказать свое мнение.

NDC и GWG приглашают всех поделиться идеями и обсудить их. Все подробности о том, как это сделать, можно найти здесь.
Какова сфера действия NDC?
В то время как конституция и модели управления являются ключевыми, NDC  поможет сформировать, определить и реализовать следующее:

 	Конституцию NEAR
 	Создание и внедрение локального и глобального принятия решений в сети.
 	Создание и развертывание хранилищ локальных и глобальных сетевых журналов, журналов и протоколов.
 	Установить руководящие органы, их деятельность и полномочия.
 	Создать и поддерживать казначейство сообщества с полным набором операционных процедур и мер безопасности.
 	Создать и поддерживать правила сообщества, кодекс поведения и протоколы разрешения споров.
 	Создать и развернуть коммуникационную стратегию, чтобы обеспечить легкий доступ к работе, выполняемой NDC и GWG.
 	Стратегия помощи сообществу в поиске, доступе и использовании NDC.
 	Помочь разработать и внедрить модель управления DAO.
 	Способствовать расширению экосистемы NEAR.

Какую роль NEAR Foundation играет в NDC?
Фонд является партнером и участником NDC. Он поддерживает работу, проводимую NDC, и в конечном итоге постарается передать свою финансовую роль сообществу, как только оно будет к этому готово.
Кто работает над NEAR Digital Collective?
NDC создан для участников экосистемы NEAR. Некоторые из них являются бывшими членами Фонда, другие являются основателями проектов, а третьи до сих пор являются давними пользователями и сторонниками блокчейна и проектов, которые на нем построены.

Не стесняйтесь обращаться к любому из руководителей команды.
Почему важна децентрализация?
Децентрализация — это термин, который стал синонимом блокчейна, но берет свое начало еще во времена Французской революции 18 века.

Децентрализация тогда и сейчас — это процесс, посредством которого деятельность организации, особенно в отношении планирования и принятия решений, распределяется или делегируется из центрального, авторитетного места или группы.

Это важно, потому что, как скажет вам любой изучающий историю, когда власть становится чрезмерно централизованной, возможности для злоупотреблений возрастают. В 2022 году члены блокчейн-сообщества на собственном опыте узнали, что происходит, когда централизованные органы власти злоупотребляют своей властью.

Члены сообщества NEAR считают, что цель децентрализации — улучшить то, что было раньше. Он считает, что повышение прозрачности и демократии создает справедливое и более равноправное сообщество для всех.

Но чтобы достичь этого, требуется приверженность процессу. Процесс, который необходимо будет развивать и адаптировать к потребностям сообщества, а также для того, чтобы это сообщество принимало участие в его формировании.

Децентрализация жизненно важна для долгосрочного здоровья и устойчивости любого собрания людей и идей. NDC — это то, как сообщество NEAR пытается достичь этого.
Как принять участие?
Любой член сообщества NEAR может присоединиться к любой из следующих рабочих групп.

 	Конституция
 	Управление и технологии
 	Юридический
 	Взаимодействие с сообществом
 	Коммуникации

Начните с прохождения процедуры адаптации Рабочей группы по управлению (GWG).

Если вы ищете более глубокое понимание того, как все это работает, вы можете посетить эту страницу.
Следите за NDC

 	Twitter
 	Discord

### O que é Near Social?

Near Social (antes conhecida como Social08) é um protocolo de dados sociais construído sobre o protocolo NEAR.

Únete ao canal: Telegram group @NearSocial para debates

Assista a apresentação: Near Social at NEARCON22

Explore Near Social: near.social
Links
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

Contrato SocialDB:

 	Fonte: https://github.com/NearSocial/social-db
 	Mainnet: social.near
 	Testnet: v1.social08.testnet

Padrões: https://github.com/NearSocial/standards

Navegador da Near Social:

 	Fonte: https://github.com/NearSocial/viewer
 	Mainnet: https://near.social/
 	Testnet: https://test.near.social/

Se você está procurando uma rede social baseada em Mastodon para usuários .near, veja este artigo sobre mastodon.near.social
SocialDB
SocialDB é um contrato inteligente para armazenar dados sociais no protocolo da NEAR.

 	Código fonte: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	ID Da conta Testnet : v1.social08.testnet
 	ID da conta Mainnet : social.near

Obtenha API
Pega uma lista de chaves e retorna um objeto JSON unido com os dados correspondentes.


 	keys – uma matriz de padrões de chave a serem retornados.

Lendo um perfil da conta self.social.near
Para ler todos os campos recursivamente para um determinado caminho, adicione o sufixo **.



Retorna o objeto JSON agregado.


Lendo nomes de todas as contas com perfis
Observe que esta consulta é iterada em todas as contas e não se ajustará à exibição de gás de chamada disponível no futuro.




Chaves das API
Pega uma lista de chaves e retorna um objeto JSON unido com as chaves correspondentes à consulta.



 	keys – uma matriz de padrões de chave a serem retornados.

Retorna o objeto JSON agregado.
Obtendo uma lista de widgets de contas root.near



Obtendo uma lista de contas que possuem widgets


Observe que esta consulta é iterada em todas as contas e não se ajustará à exibição de gás de chamada disponível no futuro. 


Padrões
Os dados no SocialDB são organizados como uma árvore JSON simples. A única regra imposta é que as chaves na raiz são os IDs de conta que armazenam os dados. Isso é feito intencionalmente, portanto, o contrato do SocialDB não impõe nenhuma estrutura ou esquema. Caso contrário, o contrato deve ser modificado para cada mudança de esquema. O controle dos esquemas contratuais pode levar à centralização e restrições. Em vez disso, o Near Social Standards vive fora do contrato do SocialDB.

Atualmente, Standards on Github é o local especificado para os padrões, mas isso pode mudar no futuro.
Descrição do esquema

 	bold significa que a chave é necessária.
 	italic significa que a chave é opcional.
 	[account_id] significa que a chave dinâmica é um ID de conta. Por exemplo, alex.near como uma chave. Geralmente usado para criar alguma vantagem para essa conta.

Esquema raiz
Cada conta deveria seguir o Root schema
Widgets
Widgets são componentes reutilizáveis que podem ser compostos para o Near Social.

Você pode visualizar e criar widgets em near.social.

Por exemplo, um data explorer widget permite explorar dados brutos de SocialDB.


Código aberto com controle de versão
O código-fonte de cada widget é armazenado abertamente no SocialDB. O proprietário do widget pode atualizá-lo, atualizando o código-fonte. Mas como o SocialDB é armazenado em um blockchain, todas as versões anteriores do widget também estão disponíveis. Isso permite o controle de versão automático para cada widget.
Bifurcação (Forking)
Se você está familiarizado com o GitHub, sabe que pode usar qualquer repositório público para criar sua versão local. Da mesma forma, você pode utilizar qualquer widget diretamente da IU near.social.



Forking cria uma cópia do código-fonte do widget, mas em sua conta. Ele permite que todos modifiquem os widgets existentes. Depois de salvar o novo widget, ele ficará imediatamente disponível. E agora todos podem visualizar e bifurcar sua versão do widget.

É principalmente uma questão de interface do usuário para criar solicitações tipo pull request, para que as pessoas possam mesclar alterações de outras bifurcações (forks). Atualmente, tem que ser feito manualmente.
Linguagem de programação
Os widgets são implementados em uma versão limitada do JSX (um JavaScript com ReactJS). O código é executado na Virtual Machine personalizada para criar um espaço isolado (sandbox) seguro. Isso garante que os widgets não possam acessar o armazenamento local ou as cookies.

### Staking with Meta Pool

Meta Pool, Module 1 - First steps on Liquid Staking
Staking and consensus protocol on NEAR Protocol
Before starting, it is recommended that you follow the NEAR Power User course of Learn NEAR Club (LNC) to have basic knowledge about NEAR Protocol.

Every blockchain network requires a method to confirm the new blocks that are being produced.

On the Proof-Of-Stake network this process is made by the validators nodes. To pick these validator nodes is required to lock the tokens assigning these to a validator, this is known as staking. Based on the amount of NEAR tokens staked the set of validators who would participate in the creation of blocks is made.

In order to incentivize token delegators and validators this receives rewards from the fees covered by the protocol. In this way staking is a way to earn more tokens and help to secure the network.

Some of the cons of making this standard staking is that your tokens are locked and you are not able to withdraw them before the unstake period ends. Also you are not able to use your tokens in any way because these are delegated to a validator node. These two limitants are solved when you are doing liquid stake.
Proof of Stake
Investopedia.com defines Proof-of-Stake (PoS) as:

Proof-of-stake is a cryptocurrency consensus mechanism for processing transactions and creating new blocks in a blockchain. 

A consensus mechanism is a method for validating entries into a distributed database and keeping the database secure. In the case of cryptocurrency, the database is called a blockchain—so the consensus mechanism secures the blockchain.

With this in mind, NEAR Protocol uses PoS as the system to process all the transactions running on the network by staking NEAR tokens, the native token from this blockchain. On the standard staking, you can pick 1 single validator node and delegate (lock) your tokens to it. This will help the validator to process blocks or chunks and to produce rewards if it is above nakamoto coefficient.

However, delegation in standard staking of PoS systems has a delayed mechanism, e.g. NEAR Protocol, or even the inability to unstake your tokens, like in ethereum. In this case a Liquid Staking solution could support both: Network security in PoS and the ability to use your tokens.

 	
Validators nodes


Validators are computers that have received enough tokens (stake) to start confirming transactions on the NEAR network.

In the NEAR Proof-of-Stake network, a decentralized pool of validators process transactions to keep the network secure. In return, these validators receive a reward for doing so. This system also allows delegators – entities that would like to provide security but may not have the hardware to do – to delegate their tokens to validators.

These validators provide computer power to the network in order to compute new blocks and in exchange they receive rewards based on the quantity of blocks or chunks produced.

Read more about NEAR Protocol validators here: https://near.org/about/network/validators/




	

	
	
		
			
				Proof of Stake works equal to Proof of Work
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	
Rewards and NEAR Tokenomics


NEAR is the token used to cover all fees on NEAR Protocol.

On its tokenomics is indicated a 5-years long and gradual release of tokens.

As mentioned on the paper, 5% of additional supply is issued each year to support the network as epoch rewards, of which 90% goes to validators (4.5% total) and 10% to the protocol treasury (0.5% total).

Extra resources

 	Official post by NEAR Foundation: https://near.org/blog/near-token-supply-and-distribution/


 	Thread made by  NEARWEEK about Liquid Staking: https://twitter.com/NEARWEEK/status/1618257119958175747




	

	
	
		
			
				Amount of $NEAR tokens that are distributed per year to the validators and delegators.
			
		

		
					

		
			
			
			
			~45 million $NEAR tokens
		
			
			~12.5 million $NEAR tokens
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What is Liquid Staking? Understanding Meta Pool and stNEAR asset
Liquid Staking protocols are at the forefront of the cryptocurrency staking economy, revolutionizing liquidity access in the decentralized finance (DeFi) industry.

Liquid Staking is an alternative to traditional staking: it allows users to stake any amount of NEAR and to effectively unstake their $NEAR without the requirement of waiting ~48-72hrs (4-6 epochs) before NEAR token holders get their compounded rewards.

 

One of the benefits of Liquid Staking is the ability to interact and use funds while simultaneously earning rewards. As a result, Liquid Staking protocols provide the foundations for activities such as lending protocols and yield farming activities.

Therefore, users can interact with numerous DeFi platforms earning multiple rewards from one pool of funds.

 	
Validators selection criteria


Meta Pool follows the NEAR Foundation strategy to spread the stake among the long tail of high-performance, low-commission, non-concentrated validators, in order to increase decentralization and censorship resistance for NEAR.

We evaluate all validators, in our main product we do not have whitelists, and we publish the formula, the code we use to compute the formula and also the results that will be on-chain. The ethos is to be totally transparent and open to all validators.

We have 5 criteria for selecting validators on the NEAR network, that are in line with our ethos of transparency and fairness:

 	Uptime > 95%
 	Fees < 10%
 	Making sure the validator doesn't reduce the Nakamoto Coefficient
 	Have enough tokens to accomplish the seat price of NEAR Protocol
 	Production of rewards during at least 4 consecutive epochs

You can review the list of Meta Pool validators here, you just need to enter meta-pool.near in the account filter.




	

	
	
		
			
				Does liquid staking on Meta Pool support the network decentralization?
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	
Step-by-Step: Making my first liquid stake on Meta Pool


Meta Pool allows NEAR token holders to stake and earn rewards, providing an easy way to unstake with no lockup period.

It does not put all your staked NEAR into just one validator, rather Meta Pool spreads it among many high performant and low fee validators in order that you get the best rewards while at the same time ensuring the network is decentralized and censorship resistant.

 	Log in to Meta Pool, by clicking on “Stake Now”


Case 1: NEAR
2. Select one of the options in the dropdown for a token to stake: ETH, AURORA, NEAR, and wNEAR. For this example, we will use NEAR.



3. Click to Connect your wallet and choose your preferred wallet, for this example, we will use MyNearWallet.


4. Select the NEAR wallet you want to use from the dropdown menu and allow the app access to your NEAR wallet: click "Next" and “Connect”.

5. After you've logged in, go to the Stake page and Enter the amount that you wish to stake, then click 'Stake now'.

Note: you always want to leave some NEAR on your wallet to cover transaction costs.

5. Note, the minimum you are allowed to stake is 1 $NEAR

5. You'll get confirmation after the transaction has been processed by the blockchain and your stake deposit has been successful. This usually only takes a few seconds.

6. Now, you can find your accounts holdings on the Stake page, by clicking on the top button or clicking on the dashboard page.

 



Note: This panel only displays your assets ($NEAR and stNEAR) from your wallet, if you transfer or sell your stNEAR tokens, they will no longer be displayed in this panel.

On panel you can see the current Meta Pool stats.

Case 2: ETH

 	 Select one of the options in the dropdown for a token to stake: ETH, AURORA, NEAR, and wNEAR. For this example, we will use Ethereum.
 	Click to Connect your wallet to stake and choose your preferred wallet, for this example, we will use MetaMask.

 	
Select the ETH wallet you want to use from the dropdown menu and allow the app access to your ETH wallet: click "Next" and “Connect”.

 	
Repeat step 5 and 6.
Note, the minimum you are allowed to stake is 0.01 ETH 



Step-by-Step: Doing unstake of your NEAR tokens
There are 2 options to unstake in Meta Pool: you can Liquid Unstake (unstake immediately) or do a Traditional Unstake (delayed takes up to 6 days to complete).
Liquid Unstake
You may unstake your stNEAR token immediately by paying a small fee and using the Liquid Unstake feature. Doing this you are actually swapping your stNEAR token for NEAR. This is made possible thanks to Meta Pool liquidity pool.

To Liquid Unstake simply:

 	Go to the Fast unstake tab on the navigation menu
 	Review the current Liquid Unstake Fee and decide whether you want to proceed.
 	Enter the amount of stNEAR you wish to unstake.
 	Click 'Unstake' and approve the transaction.
 	After a few seconds, afte your transaction has been confirmed by the blockchain, you'll have your unstaked NEAR available on your NEAR wallet.


 

Note: Meta Pool liquidity fee is in a range from 0.3% to 3%. It varies linearly according to the quantity of liquidity available in Meta Pool Liquidity Pool.

Note, in ETH case the promotional launch period is a great opportunity to earn up to 13% APY, but keep in mind that your tokens will be locked until September 21st, 16:17. After that, you'll be able to unstake them and withdraw your earnings.




	

	
	
		
			
				Is stNEAR pegged 1:1 in price with NEAR token.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Traditional Unstake (Delayed)
Traditional Unstake is the default form of unstaking from any validator on the NEAR protocol: due to the design of the network, validators wait 4 - 6 epochs (48-72 hours) before releasing the staked funds back to the user. Delayed unstaking is fee-free for all users.

To withdraw your funds from Meta Pool using Delayed Unstake:

 	Go to the 'Delayed-Unstake' tab on the navigation menu at the top
 	Enter the amount of NEAR you want to unstake and click 'Unstake' button.


 

Note, the minimum you are allowed to unstake is 1 $stNEAR

 	 You'll see a notice informing you of the approx. waiting times. Review and confirm by clicking on Unstake.



 	 You'll be prompted to Authorize the transaction on the NEAR wallet. Click Confirm.
 	 After the delayed unstaking period, the funds will be available to withdraw, click "withdraw" and confirm your transaction, your unstaked NEAR will show up in your NEAR wallet.Note, in ETH case the promotional launch period is a great opportunity to earn up to 13% APY, but keep in mind that your tokens will be locked until September 21st, 16:17. After that, you'll be able to unstake them and withdraw your earnings.




	

	
	
		
			
				Delayed unstake affects the network performance due to the extra time required to remove the delegated $NEAR tokens
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






 	
Step-by-step: Being liquidity provider


Liquid Unstaking is only possible thanks to the Liquidity Providers (LP) who supply the protocol with the NEAR required for instant swaps (withdrawals) with stNEAR. Liquidity Providers earn Liquid Unstaking fees.

To add or withdraw $NEAR as a liquidity provider:

 	Go to the Liquidity tab on Meta Pool page
 	Select whether you want to "Add" or "Remove" liquidity
 	Enter the amount $NEAR to add or remove


Note: the minimum required to provide liquidity is 2 $NEAR

4. Confirm and sign the transaction

Now, every time somebody does liquid unstake you will get a fraction of the fees according to your equity on the liquidity pool.

Note, in ETH case this section will be enabled at the end of the promotional APY period.




	

	
	
		
			
				~10.8% APY is the standard at any time being a liquidity provider
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!

### 🧪HERE wallet on Android Beta Test

Follow @LearnNEAR and @HEREwallet on Twitter

Beta test sprint starts: February 16, 9 am ET
Beta Test sprint ends: February 19, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Install HERE wallet app from Google Play store
 	Switch to NEAR testnet

 	Create or import account
 	Send some NEAR to your friend, make a screenshot
 	Try to send other tokens
 	Tweet with your screenshot “I’ve just sent tokens at @here_wallet  on Android during @LearnNEAR Beta test” and tag 3 friends
 	Tell us what do you think about the process

💡HINT: the goal of the test is to check how HERE wallet looks on different Android devices, so please try at least TWO devices
Fill the Feedback form
🤑The top 15 beta testers will get 4 NEAR, top 2 beta test feedback submitters will get 20 NEAR each. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead @neafiol at LNC Telegram Beta test topic

### How to stake NEAR

Staking in the NEAR ecosystem is a thriving niche that offers a variety of approaches and solutions. Let's take a look at different staking options and think about which one is the best fit for you.

For ease of comparison, we'll rate each option based on three parameters: User Interface (UI), Annual Percentage Yield (APY), withdrawal fees, and security.
Standard NEAR Staking
Since NEAR operates on a Delegated Proof-of-stake (DPOS) consensus mechanism, every NEAR token holder can delegate their tokens to a specific validator. A full list of validators is available at https://explorer.shardnet.near.org/nodes/validators. Simply choose a validator that you like and delegate your tokens to them. The validator will receive a commission for this, which is indicated before selection, and you will receive a return in NEAR tokens. Typically, it is no more than 9.7% per year.

It may sound easy, but imagine you just bought your first NEAR tokens and want to earn a return. Additionally, you have to wait 3 days to withdraw your NEAR from staking, and if you want to withdraw instantly, you'll have to pay a fee. Moreover, you need to trust one of the validators you delegate your tokens to.




	

	
	
		
			
				How long do you have to wait to withdraw your NEAR from the standard staking?
			
		

		
					

		
			
			
			
			3 days
		
			
			1 day
		
			
			A week
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The NEAR Centralized Staking
Centralized exchanges have long come up with mechanisms to increase their profits even more through additional tools. One of them is the in-exchange staking of tokens. Just like with all funds that you store on an exchange, you don't actually own them. The same goes for staking. Although the exchanges themselves use their blockchain nodes for this, in essence all of your funds are with them.

This solution is perfectly legitimate when we're talking about users who are not actively immersed in Web3 and are used to simply buying their favorite coins on exchanges. Currently, over 1 million people own NEAR on Binance. There's a risk of hacking or theft of your funds, as seen with FTX. Additionally, the profitability on CEX is much lower than in DeFi - 3% for flexible staking (with instant withdraw).




	

	
	
		
			
				In which type of staking do you not own your funds?
			
		

		
					

		
			
			
			
			Meta pool staking
		
			
			HERE staking
		
			
			Centralized staking
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Metapool and Linear 
The Metapool and Linear staking options are already considered native in the NEAR ecosystem. To stake NEAR, you'll need to have both a NEAR wallet and some NEAR tokens. This type of staking is better than the other two options because it is managed by projects within the ecosystem and has a decent APY of around 9.4%, which is also important. Both projects have undergone an audit by BlockSec and have not had any security issues.

However, someone new to the ecosystem will need to find one of these projects and trust them with their funds, and they will also need to regularly visit the project's website. It's also important to keep in mind that there is an additional fee for instantly withdrawing NEAR from staking.


HERE Wallet Staking
I think you have already realized who deserves more attention in terms of staking. Since HERE is a simple onboarding method not only for crypto but also for web2 users, staking should also be as simple and not cause problems for someone who is not familiar with crypto.

That's why we created a non-blocking staking mechanism, where you can withdraw your NEAR at any time without any fees and still receive passive income. This is possible thanks to the liquidity reserve on the contract, just like in regular banks when 90% is used but there's always money in the ATM. The return on investment varies depending on how actively you deposit/withdraw funds and on average it is around 9.8%. Owners of certain NFTs, such as HERE Wallet early users, can also receive additional income.

In addition, the staking process itself is as simple as it can be. All you need to do is press one button. After that, the necessary amount of NEAR will be automatically unstaked before any transaction is made.

Currently, HERE Staking has undergone an audit with the OtterSec team.




	

	
	
		
			
				What is the fee for instant withdrawal of NEAR from HERE staking?
			
		

		
					

		
			
			
			
			1.5%
		
			
			0%
		
			
			3.2%
		
	
		

		
		
			
				Correct!
				Wrong!

### Как доказательство с нулевым разглашением может обеспечить конфиденциальность данных

Вы, наверное, встречали выражения «если это бесплатно, то вы — продукт» или «данные — это новая нефть» и отмахивались от них как от глупых фраз. Правда в том, что данные являются движущей силой почти всех предприятий и услуг. Например, персонализированный опыт и услуги, маркетинг и множество других идей и услуг зависят от объема и качества предоставляемых им данных. Большинство компаний стремятся получить доступ к данным, чтобы помочь лучше понять своих клиентов, предсказать модели поведения клиентов и улучшить качество своих услуг.

Традиционное пространство всегда было предметом опасений, связанных с данными и конфиденциальностью. Сторонники конфиденциальности уже давно беспокоятся о том, как хранятся данные, как к ним осуществляется доступ и кто имеет к ним доступ. С ростом экосистемы криптовалюты и блокчейна в этом секторе также возникли аналогичные проблемы. Публичный характер блокчейнов вызвал у пользователей ряд проблем с конфиденциальностью в отношении защиты их личной информации. В этой статье мы более подробно рассмотрим проблему конфиденциальности в блокчейнах и то, как доказательства с нулевым разглашением (ZK) могут их смягчить.
Что такое конфиденциальность данных?
Увеличение использования Интернета вывело проблему конфиденциальности данных на первый план: почти все веб-сайты, приложения и платформы социальных сетей собирают и хранят личную информацию пользователей для предоставления определенных услуг. Тем не менее, эти платформы и веб-сайты часто не имеют адекватных средств защиты собранных данных, что приводит к многочисленным утечкам данных.

С развитием технологии блокчейн и крипто-экосистемы растет озабоченность по поводу конфиденциальности розничных и институциональных пользователей. Эти опасения в первую очередь связаны с общедоступным характером блокчейнов, поскольку большинство решений уровня 1 и уровня 2 не могут решить эти проблемы. Конфиденциальность данных относится к способности пользователей определять, когда и как их информация будет передана другим. Это также включает в себя возможность пользователей диктовать, в какой степени их данные будут использоваться совместно. Эта информация может включать их имена, местоположение, контактную информацию, онлайн-поведение, симпатии и антипатии, сведения о транзакциях и многое другое.
Доверие, приватность и блокчейн
В настоящее время криптовалютная экосистема претерпевает значительные изменения после краха таких крупных проектов, как FTX. Тем не менее, базовая технология, поддерживающая криптовалюты, может революционизировать конфиденциальность, доверие и то, как доверие используется. Это очень важно в эпоху Интернета, когда миллионы людей просматривают и обмениваются большими объемами своей личной информации для доступа к услугам и продуктам.

Технология Blockchain по своей природе связана с проблемами конфиденциальности из-за ее конструкции. Децентрализованный характер блокчейна означает, что узлы, обрабатывающие транзакции или информацию, имеют доступ к данным блокчейна. Например, блокчейн Биткойн общедоступен, и к нему может получить доступ любой, кто хочет проверить историю его транзакций вплоть до его генезисного блока. Теперь помните, что Биткойн является псевдо-анонимным, что означает «[данные] точки данных, которые не связаны напрямую с конкретным человеком, [но где] несколько образов [одного] человека могут быть связаны вместе».

Достаточное количество псевдо-анонимных данных позволяет идентифицировать лиц, стоящих за транзакциями, что вызывает беспокойство у пользователей блокчейна, и на это есть несколько причин. В отличие от данных, которые используются обычными приложениями и доступны лишь немногим, данные блокчейна могут быть тщательно изучены всеми, включая злоумышленников и организации, которые могут использовать информацию в блокчейне для своей выгоды. Кроме того, неизменный характер блокчейна означает, что транзакции и данные будут постоянно связаны с человеком. Это можно сделать, отслеживая связь между узлами. Кроме того, крипто-кошельки также можно анализировать без доступа к закрытым ключам, что еще больше усложняет ситуацию.

Одним из ярких примеров использования данных блокчейна для отслеживания человека было расследование и арест Росса Ульбрихта, человека, стоящего за печально известным веб-сайтом даркнета «Шелковый путь», который использовался для различных незаконных действий. Правоохранительные органы идентифицировали Ульбрихта как человека, стоящего за Silk Road, благодаря данным блокчейна. Кроме того, они могли отслеживать транзакции биткойнов и определять, что агент Управления по борьбе с наркотиками США (DEA) отмывал биткойны, связанные с Silk Road. В этом случае правоохранительные органы смогли отследить имеющиеся в блокчейне данные, чтобы идентифицировать одиозного человека. Но представьте, если бы злоумышленники могли так легко отслеживать ваши данные благодаря публичному характеру блокчейна. Результаты были бы печальными.
Введение доказательств с нулевым разглашением
О доказательствах с нулевым разглашением впервые рассказали Сильвио Микали, Шафи Голдвассер и Чарльз Ракофф в статье под названием «Сложность знаний в системах интерактивных доказательств». В случае блокчейна это может помочь обеспечить безопасные и анонимные транзакции. Доказательство с нулевым разглашением, также известное как протокол с нулевым разглашением, позволяет одной стороне (доказывающей стороне) доказать другой стороне (верификатору), что она знает конкретное значение или информацию (x), не раскрывая никакой информации, кроме того факта, что она знает значение или информация, о которой идет речь (x). Проблема, когда дело доходит до доказательства с нулевым разглашением, состоит в том, чтобы оправдать владение информацией, не раскрывая ее или любую другую дополнительную информацию. Доказательство с нулевым разглашением должно удовлетворять следующим критериям.

 	Полнота - предположим, что утверждение верно. Честный проверяющий, правильно и добросовестно следующий протоколу, будет убежден информацией, предоставленной доказывающим, который правильно следует протоколу.
 	Надежность - надежность означает, что у доказывающей стороны не должно быть возможности фальсифицировать какую-либо информацию или ложно убедить проверяющую. Фальсификация должна быть невозможной.
 	Нулевое разглашение — если утверждение доказывающего истинно, проверяющий не узнает ничего, кроме того факта, что информация верна.

Первые два считаются свойствами более общих систем интерактивных доказательств с добавлением нулевого знания, превращающего процесс проверки в доказательство с нулевым разглашением. Из-за небольшой вероятности (ошибка достоверности) того, что злонамеренный доказывающий может убедить проверяющего в ложном утверждении, доказательства с нулевым разглашением считаются вероятностными, а не детерминированными. Тем не менее, ошибка надежности может быть уменьшена до незначительного значения.




	

	
	
		
			
				Каким критериям должно соответствовать доказательство с нулевым разглашением?
			
		

		
					

		
			
			
			
			Полнота
		
			
			Надежность
		
			
			Нулевое разглашение
		
			
			Всё выше перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как работает ZKP?

Доказательство с нулевым разглашением состоит из трех действий, происходящих последовательно между участниками. Эти действия называются свидетелем, вызовом и ответом. Давайте углубимся немного глубже, чтобы лучше понять роль каждого действия, предположив, что есть два участника, A и B.

Свидетель - предположим, что А знает конкретное значение или информацию, которая также определяет набор вопросов. На эти вопросы всегда может ответить правильно А. Первоначально А может выбрать любой случайный вопрос из набора, вычислить доказательство и отправить его В.

Вызов — после этапа свидетеля наступает этап вызова, где Б выбирает вопрос из набора и просит А ответить на него.

Ответ - затем A вычисляет ответ и отправляет его обратно B. Это позволяет B определить, действительно ли A знает ответ.

Описанный выше процесс можно повторять столько раз, сколько требуется, пока не будет установлено, что А знает правильный ответ, и вероятность догадок не станет достаточно низкой.




	

	
	
		
			
				Статья «Сложность знаний интерактивных систем доказательства» была написана
			
		

		
					

		
			
			
			
			Сильвио Микали, Шафи Голдвассер и Чарльз Ракофф
		
			
			Сильвио Микали, Чарли Хоскинсон и Чарльз Ракофф
		
			
			Виталик Бутерин, Шафи Голдвассер и Сатоши Накомото
		
			
			Чарли Хоскинсон, Сатоши Накомото и Виталик Бутерин
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Варианты использования ZKP
ZKP может применяться в нескольких сценариях.
Системы аутентификации
Системы аутентификации сыграли решающую роль в развитии исследований в области доказательств с нулевым разглашением. В этих системах одна сторона хочет подтвердить свою личность другой стороне с помощью некоторой секретной информации. Однако он не хочет, чтобы вторая сторона получала какие-либо сведения об этой секретной информации.
Конфиденциальность
Один из наиболее важных вариантов использования ZKP связан с транзакциями, требующими полной конфиденциальности. Давайте разберёмся. Рассмотрим блок-цепочку, такую как биткойн-блокчейн. Как правило, когда транзакция происходит в этой цепочке блоков, данные, связанные с транзакцией, записываются в цепочку блоков. Это означает, что любой может собрать воедино некоторое количество информации о транзакции, проанализировав данные в блокчейне. В целях конфиденциальности очень важно скрывать некоторые детали конкретных транзакций. ZKP позволяет скрыть детали, а также обеспечить достоверность транзакции, добавив их в новый блок.
Персональная информация
Допустим, вы хотите взять кредит в банке. Чтобы подать заявку на кредит, вы должны предоставить множество документов, состоящих из значительного объема личной информации, чтобы сделать ее доступной для третьих лиц. В случае получения кредита в банке единственная информация, требуемая банком, - это знать, зарабатывает ли физическое лицо определенную сумму, достаточную для погашения кредита. ZKP может помочь банкам проверить, зарабатывает ли физическое лицо заранее определенную минимальную сумму, не раскрывая никакой конфиденциальной информации банку или какой-либо третьей стороне.
ZKP и блокчейн: путь вперед
Несколько проектов и криптовалют используют ZKP, например ZCash, SmartCash, Zerocash и ZeroVert. ZKP в основном был реализован через zk-SNARKS и zk-STARKS. Zk-SNARKS изначально был разработан ZCash. Большинство блокчейнов являются псевдоанонимными, что означает, что личность пользователя можно отследить до его транзакций путем изучения данных блокчейна. Эта информация доступна всем, у кого есть доступ к блокчейну, и может быть использована любым злоумышленником.

Несмотря на репутацию блокчейна как вершины кибербезопасности, этот конкретный недостаток хорошо известен пользователям. Однако ZKP может помочь исправить эту уязвимость и обеспечить полную конфиденциальность личной информации. Хотя ZKP все еще предстоит преодолеть немало проблем, он дает пользователям контроль над своими данными и конфиденциальностью, ограничивая доступ для третьих лиц, и будет играть решающую роль в улучшении конфиденциальности, когда речь идет о блокчейнах.




	

	
	
		
			
				ZKP используются
			
		

		
					

		
			
			
			
			Zcash
		
			
			SmartCash
		
			
			Zerocash
		
			
			ZeroVert
		
			
			Все выше перечисленные
		
	
		

		
		
			
				Correct!
				Wrong!

### Почему DAO должны перейти на использование приватного шарда?

Знакомство с DAO и контрактами с мульти-подписями
Большинство пользователей Web3 хорошо знакомы с терминами DAO и контрактами с мульти-подписями, но для людей, не знакомых с пространством Web3, стоит раскрыть оба термина.
Что такое ДАО?
«Децентрализованная автономная организация» (ДАО) — это организация, управляемая сообществом и не имеющая центральной власти. ДАО полностью автономно и прозрачно: смарт-контракты используются для управления процессом принятия решений и распределенным владением активами. Процесс голосования размещается в блокчейне, и пользователям часто приходится выбирать между взаимоисключающими вариантами. Право голоса часто распределяется между пользователями в зависимости от веса голоса, который они имеют внутри DAO (весовое количество токенов, которыми они владеют, один участник — один голос и другие). Все голоса и действия через DAO публикуются в блокчейне, что делает все действия пользователей общедоступными. Чтобы принимать решения для DAO, они используют мульти-подписной кошелек (контракт).
Что такое мульти-подписной кошелек?
Мульти-подписной кошелек — это особый тип крипто-контракта для безопасного хранения криптовалюты. Для подписания и отправки транзакции требуется два или более закрытых ключа (стороны DAO), он часто используется для добавления дополнительного уровня безопасности к транзакциям кошелька, гарантируя, что несколько держателей ключей участвуют в утверждении транзакции. Контракты с мульти-подписью также можно настроить так, чтобы каждый из набора закрытых ключей мог генерировать подпись, что делает их отличным вариантом для тех, кто хочет хранить свою криптовалюту безопасным и надежным способом.
Как DAO в настоящее время используют контракты с несколькими подписями?
DAO используют мульти-подпись для безопасного хранения своих средств и эффективного управления ими. Контракты с несколькими подписями предоставляют нескольким заинтересованным сторонам возможность подписывать транзакцию, обеспечивая безопасное и диверсифицированное управление средствами и решениями. Мульти-подписи также обеспечивают дополнительный уровень безопасности, требуя несколько закрытых ключей для доступа к средствам.

Кроме того, DAO могут использовать мульти-подписные контракты для реализации более сложной системы голосования и управления, чем обычный мульти-подписной контракт. Это позволяет децентрализовать и безопасно принимать решения. Наиболее распространенными структурами голосования DAO являются взвешенное по токенам голосование кворума, квадратичное голосование, ликвидная демократия или делегирование или блокировка голосов, а также голосование по кворуму на основе токенов.

 	
Кворумное голосование держателей токена
Для принятия предложения требуется определенный порог избирателей. Например: 60% кворума, что будет означать, что 60% держателей токенов должны проголосовать за предложение, чтобы оно было принято.
 	
1 токен = 1 голос управления
Право голоса человека прямо пропорционально количеству токенов, которыми он владеет.
 	
Квадратичное голосование
Это система, которая уравновешивает интересы групп меньшинств, сохраняя при этом процесс принятия решений большинством. Ликвидная демократия или делегирование голосов. Это позволяет людям делегировать свой голос представителю.
 	
Блокировка голоса
Это механизм, который позволяет участникам выйти из голосования без штрафных санкций.
 	
Кворумное голосование на основе токенов
Это система, которая требует наличия у избирателей определенного порога токенов, чтобы предложение было принято.

Основные проблемы, с которыми сталкиваются DAO
Основные проблемы, с которыми сталкиваются DAO, включают отсутствие признанного юридического статуса и потенциальную неограниченную ответственность участников, отсутствие регулирования и неадекватные меры безопасности. Кроме того, DAO могут быть уязвимы для атак управления, плохой конфигурации и спама. Эти проблемы могут создать ряд рисков, включая неадекватную защиту личных данных, уязвимые смарт-контракты и несанкционированный доступ к средствам. Большинство технических проблем, упомянутых выше, могут быть решены, а остальные смягчены с помощью частного сегмента, но давайте сначала разберемся, что такое приватный шард.




	

	
	
		
			
				Какие реализации голосов можно использовать с приватным шардингом в DAO?
			
		

		
					

		
			
			
			
			1 токен = 1 голос управления
		
			
			Квадратичное голосование
		
			
			Кворумное голосование держателей токена
		
			
			Всё выше перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Приватный шард для DAO: мульти-подписной кошелек на стероидах


Приватный шард — это настраиваемая сайдчейн (сеть блокчейнов, работающая вместе с общедоступным блокчейном с возможностью передачи активов и выполнения меж-контрактных вызовов), которая позволяет защитить ваши данные, используя при этом все бизнес-преимущества блокчейнов с открытым исходным кодом. Это позволяет владельцам приватного шарда получить полный контроль над своей цепочкой блоков, сохраняя при этом личную информацию между собой, и разрешать доступ к этой информации только определенным публичным сторонам.

Члены DAO получают сеть, управляемую ими в зависимости от их потребностей. Её можно настроить для предложенных выше структур голосования, где валидаторы (узлы, проверяющие блоки блокчейна) принадлежат членам DAO, подобно тому, как внутри мульти-подписи они будут владеть закрытым ключом с определенной силой голоса. Это как «мульти-подпись на стероидах», так как все основные свойства мульти-подписи одинаковы, при этом вы получаете преимущества, заключающиеся в том, что вся информация хранится только внутри частного шарда и не просачивается в открытый доступ.

Кроме того, члены DAO могут развертывать настраиваемые смарт-контракты внутри шарда с «бесконечной масштабируемостью», предоставляя им возможность:

 	закрытое голосование 
 	учет и начисление заработной платы подрядчикам 
 	внедрить механику транзакций, такую как аукционы (которые могут быть слишком дорогими в основной сети) 
 	отделы управления финансами внутри DAO и многое другое.




	

	
	
		
			
				Приватный шард — это:
			
		

		
					

		
			
			
			
			Частная база web2, хранящаяся в закрытой экосистеме
		
			
			Частный настраиваемый сайндчейн
		
			
			Открытый DAO, хранящийся непосредственно в сегментированном блокчейне, который использует валидаторы NEAR.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Приватный шард имеет контракт разрешений, который позволяет им устанавливать правила, по которым общедоступные и частные контракты / учетные записи могут взаимодействовать и в какой степени. Это дает возможность ограничить доступ к определенным сторонам или контрактам для перемещения активов из и в частные сегменты, кроме того, он предоставляет доступ к определенным смарт-контрактам для выполнения вызовов контрактов из сегмента или основной сети.

Например: DAO может иметь частный контракт на голосование внутри сегмента, который инициирует вызов, когда голосование закончилось, и что только результат голосования публикуется в основной сети без раскрытия голосов конкретных участников. Этот вызов может быть выполнен только внутри этого сегмента, и никакая другая сторона не может опубликовать его, кроме этого конкретного контракта. Это дает членам DAO возможность обеспечить безопасность голосования, как если бы они использовали мультиподпись, в то время как фактические голоса скрыты от общественности.




	

	
	
		
			
				Приватные шарды позволяют DAO иметь:
			
		

		
					

		
			
			
			
			Приватное голосование
		
			
			Учет и начисление заработной платы подрядчикам
		
			
			Внедрить механику транзакций, такую как аукционы (которые могут быть слишком дорогими в основной сети) 
		
			
			Всё выше перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Кроме того, Calimero Gateway обеспечивает дополнительное управление разрешениями для членов DAO, чтобы указать политики, в соответствии с которыми общедоступные пользователи/кошельки могут взаимодействовать с частным шардом. Хотя члены DAO запускают валидаторы и имеют административный доступ к сегменту, они могут приглашать внешних участников/кошельков, чтобы иметь возможность читать определенные данные или взаимодействовать с определенными контрактами.

Например: DAO может иметь частный контракт внутри сегмента, чтобы внешние стороны могли подавать предложения, по которым DAO может голосовать. Это может позволить только отправителям и членам DAO предложения видеть свою информацию о статусе предложения. Подача предложения может быть ограничена белым списком кошельков, добавленным DAO или участниками.

Мы считаем, что приватный шард — это следующая естественная эволюция для DAO. Мы надеемся работать с большим количеством DAO в следующей трансформации в Web3. Не стесняйтесь обращаться к нам, если у вас есть какие-либо вопросы или вы хотите заказать демонстрацию.

### Libertad en El Mundo Digital: ¿es alcanzable?

Hoy, cuando nuestra vida diaria se vuelve cada vez más digital, las personas han empezado a comprender que algunas de sus posesiones en este nuevo mundo digital son valiosas. Varios datos de cuentas, personajes de juegos, suscripciones, boletos para acceder a eventos físicos y digitales y membresía de clubes: cada vez tenemos más cosas importantes y de gran valor para nosotros. Y a veces, incluso las cosas relacionadas con el éxito o la seguridad en la vida. Es una sensación nueva para muchos de nosotros comprender que dependemos significativamente de "una pieza de información" almacenada en algún lugar y estamos perdiendo algo de comodidad en un intento de gestionarla bien. La mayoría de nosotros terminamos almacenando esas cosas en un archivo en la nube o en una billetera patentada como Apple. Es raro darse cuenta de que los que se consideran lugares seguros no son tan seguros como pensamos. En primer lugar, no nos pertenecen y no son gestionados por nosotros. Son los sitios de otras personas donde se lleva a cabo el mantenimiento de registros. En segundo lugar, son menos accesibles de lo que solíamos pensar. Simplemente muévete de los EE. UU. a China continental y te darás cuenta de que la mayoría de tus posesiones almacenadas en Google ya no están accesibles. Para aquellos que piensan más allá, parece claro que en el mundo digital, en el que solíamos operar, nada realmente te pertenece cuando está almacenado en algún tipo de nube o simplemente es desconocido para tus servidores: el servidor puede desaparecer, el servicio que estás usando para el acceso a la información también puede desaparecer, de igual forma la información puede ser modificada por los administradores del servidor o como resultado de una intervención maliciosa.

Está bien. Parece que no hay muchas posibilidades de poseer realmente algo en el mundo digital. Pero, ¿lo necesitamos? Probablemente no. Al mismo tiempo, personalmente creo en las palabras de George Washington:
“La libertad y los derechos de propiedad son inseparables. No puedes tener una sin la otra”.


Lo cual es un motivador perfecto para buscar mejores posibilidades en materia de derechos de propiedad digital que las que teníamos antes.

Sorprendentemente, la respuesta es bastante simple e interesante: la tecnología que solíamos considerar como "la tokenización de todo tipo de arte" es perfectamente capaz de facilitar el almacenamiento autónomo de los derechos de propiedad digital. Sí, estoy hablando de NFT. Al asignar un NFT a cualquier pieza de información, podemos establecer el precio inicial y la propiedad de esta pieza. Y se almacenará en la billetera del propietario para ser utilizada en caso de ser necesario cualquier tipo de demostración o presentación en un punto de verificación y acceso a puertas de control. Además, la evidencia de nuestra propiedad se almacena de manera descentralizada, lo que evita cualquier tipo de cambio de información no autorizado y facilita la resiliencia necesaria: podemos estar seguros de que al menos una parte de la red descentralizada permanecerá accesible, lo que significa seguir proporcionando al solicitante la información sobre el hecho de que el dueño de la propiedad sigue siendo el titular.

Así pues, demos un paso atrás para una mirada más amplia: al visualizar cualquier tipo de información mediante NFT, estamos habilitando la interoperabilidad entre varios sistemas de información, soluciones de TI, metaverso y ámbitos de juego: para acceder a los datos solo necesitamos solicitar la billetera del propietario sobre el aprovisionamiento de determinados NFT y sus parámetros de utilidad. Además, podemos usar esos parámetros para cualquier tipo de verificación, cálculo o visualización simple.

Entonces, resumamos: Un NFT es perfecto para representar la propiedad en el mundo digital: tiene el precio, el dueño y la propiedad real de los datos que el titular reclama, y además de todo esto, puede tener una representación visual o de audio que hace reconocible la posesión. Para muchos de nosotros, también permitirá el desarrollo de una conexión emocional que con frecuencia crece a través de la representación visual. Entonces, en pocas palabras, probablemente para los niños: Un NFT es algo agradable y negociable, lo que nos permite reclamar nuestros derechos en el nuevo mundo digital.

### ¿Qué es la Votación Cuadrática y el Financiamiento Cuadrático

Si eres una persona que está interesada en la gobernanza descentralizada, seguro te has encontrado con palabras como “Votación Cuadrática” y “Financiamiento Cuadrático”. Mientras que algunos pueden considerarlas palabras de moda, estos conceptos han ganado una fuerza considerable en los últimos años. Hay varios casos donde ambos se han implementado con un alto grado de éxito. La votación Cuadrática se utilizó para votar sobre los proyectos ganadores durante el Hackatón presidencial de Taiwán. Observamos también que el sistema fue usado una vez más por el Partido Demócrata de Colorado, para elegir la plataforma del partido. Por otro lado, los Gitcoin Grants utilizan el Financiamiento Cuadrático para financiar bienes públicos en el ecosistema de Ethereum.

Ambos conceptos, de acuerdo a sus proponentes, tienen el potencial de revolucionar como se toman las decisiones. La implementación definitiva de estos conceptos pueden ser, en palabras de Vitalik Buterin. “Una transformación profunda, como la llegada de la era industrial de los mercados mayoritariamente libres y la llegada de las democracias constitucionales”. El revuelo no es sin razón, como se explicará en este artículo, analizaremos ambos conceptos, su aplicación y beneficios.

Vamos a comenzar con la Votación Cuadrática.
El Problema con los Modelos de Gobernanzas
Los modelos de gobernanza utilizada por las plataformas de blockchain se están volviendo cada vez más cruciales, con la habilidad de impactar en la participación de usuarios, la eficiencia de la plataforma y su atractivo. Una de las mayores preocupaciones que tenían las blockchain  cuando se trataba de la gobernanza era el potencial para el surgimiento de posiciones de dominancia.  Estas “posiciones dominantes” estarían compuestas por usuarios que tendrían en su control, un gran número de votos o quizás la mayoría de los votos. Esto le daría a este grupo de usuarios un control sin precedentes sobre asuntos relacionados con la evolución de las plataformas.

Esta concentración de poder de votación puede desalentar a los usuarios con un número menor de votos, a participar en los mecanismos de gobernanza o incluso obligarlos a abandonar por completo la plataforma. La promesa y el potencial de la tecnología y plataformas blockchain solo pueden ser completadas si se presta una atención especial  y cercana a los mecanismos de gobernanzas de estas plataformas. Tal concentración de votos y poder de votación, sin duda, puede preocupar a otros en la plataforma. Sin embargo, un nuevo método de votación, el cual, en tiempos recientes ha encontrado utilidad en las decisiones sociales, está emergiendo como una posible solución al dilema que plaga a las plataformas de blockchains.
Voto Cuadrático: El Camino Matemático Hacia un Voto más Justo 
La votación Cuadrática es un mecanismo colectivo de toma de decisiones que permite una mejor vía hacia la toma de decisiones, evitando la llamada “tiranía de la mayoría”. Fue propuesto por primera vez por el político y economista Glen Weyl y permite que los participantes expresen la dirección de sus preferencias, el grado de sus preferencias y cuán firmes se sienten sobre ellas. A través de esto, se espera que se aborde el problema de la regla de la mayoría y así proteger los intereses de grupos más pequeños de votantes que se preocupan profundamente por asuntos específicos. El voto Cuadrático permite a los usuarios “pagar” por votos adicionales sobre un tema en particular, permitiéndoles expresar su apoyo de forma más decisiva por temas puntuales.

Mientras que una encuesta regular puede preguntar si estás de acuerdo o en desacuerdo con un grupo de temas en particular, la votación Cuadrática brinda a los votantes un presupuesto de “créditos” que pueden gastar si están de acuerdo o en desacuerdo con los temas. Los votantes pueden emitir múltiples votos, pero cada voto subsiguiente le va a costar más créditos que el anterior. Este tipo de mecanismo de votación puede ser utilizado en diferentes áreas, como en instituciones democráticas, gobernanza corporativa y la toma de decisiones colectiva habilitada por la blockchain.




	

	
	
		
			
				La votación Cuadrática fue planteada por primera vez por:
			
		

		
					

		
			
			
			
			Vitalik Buterin
		
			
			Glen Weyl
		
			
			Zoe Hitzig
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo Funciona la Votación Cuadrática? 
Ahora, vamos a observar cómo funciona la votación Cuadrática. La votación Cuadrática está basada en los principios del mercado, en el que a cada votante se le asigna un presupuesto de créditos para votos que pueden gastar para influir en el resultado de deliberaciones claves. Si un votante apoya o se opone firmemente a una decisión particular, puede destinar votos adicionales para demostrar el nivel de su apoyo u oposición sobre una decisión específica. El costo de votos adicionales se determina a través de una regla de fijación de precios de votos, en la que cada voto se hace más caro que el anterior. El aumento del costo del crédito por voto demuestra el grado de apoyo u oposición sobre una decisión particular.

La votación Cuadrática usa una fórmula sencilla, costo para el votante = (números de votos)2

Entendamos esto mejor con la ayuda de un ejemplo. Asumamos que un votante tiene un presupuesto de 16 créditos de voto y que tiene la libertad de usar un crédito para 16 temas diferentes sobre los que puede votar. Sin embargo, si el votante está más convencido sobre un tema particular, puede asignar cuatro votos hacia ese tema, así le cueste todo su presupuesto. Los cuatro votos cuestan 16 créditos de voto porque el precio de cada voto adicional se vuelve más caro cuadráticamente. Entonces, 1 voto costaría 1 crédito, 2 votos costarían 4, 3 votos costarían 9 y 4 votos costaría 16.

Este mecanismo ha sido visto como una potencial solución para abordar los problemas de gobernanzas que enfrentan las plataformas y comunidades de blockchain, previniendo que un solo grupo tome el control y protegiendo de igual forma los intereses de los grupos minoritarios. Los tokens emitidos como votos, son redistribuidos uniformemente entre los votantes al final de cada ciclo de gobernanza. Le tomará a un grupo varios ciclos de votación y costos significativos para tomar el control de una plataforma.

Pero, ¿cómo se compara la votación Cuadrática con otros mecanismos de votación establecidos? Existen otros tres mecanismos democráticos de votación importantes:

 	Sistema Pluralista.
 	Sistema de representación proporcional.
 	Sistema semi proporcional.

Sistema Pluralista
En los sistemas de votación pluralistas, el partido o la propuesta que recibe la mayoría de los votos gana la elección, se basa en el mecanismo "un voto, un votante". No obstante, el sistema de votación plural no puede garantizar que los votantes puedan expresar su nivel de apoyo a una causa o tema particular y no pueden asignar sus votos para expresar su grado de apoyo.
Sistema de Representación Proporcional
Este método de votación se observa principalmente en legislaturas nacionales, donde asegura que la división de un cuerpo electo refleje la división de votos en el electorado. Si bien este método de votación muestra mejor los puntos de vista de los electores, falla en representar como se sienten los votantes acerca de su posición sobre los temas.
Sistema Semi-Proporcional
Hay varios tipos de sistemas de votación semi-proporcional. Pero, ninguno de ellos explica el grado de preferencia u oposición de los votantes sobre los temas.
El Financiamiento Cuadrático: Una Nueva Forma de Financiar Bienes Públicos 
Pasemos al financiamiento Cuadrático. El financiamiento Cuadrático es uno de los experimentos socioeconómicos más innovadores que han salido del ecosistema criptográfico. Se ha promocionado como una manera matemáticamente óptima de financiar bienes públicos en comunidades democráticas, aumentando las donaciones hechas por una gran comunidad sobre las contribuciones hechas por grupos pequeños con mucho dinero. Pero antes vamos a conocer: ¿Qué son los bienes públicos?

Los bienes públicos se definen como la materia prima o servicios que están disponibles para todos los miembros de una sociedad. Estos bienes deben poseer las siguientes cualidades.

 	Sin rivalidad - Esto quiere decir que el uso de estos bienes por parte de un miembro no disminuye su disponibilidad para otros miembros.
 	No excluibles - Estos bienes deben ser accesibles para todos.

El financiamiento Cuadrático fue descrito por Vitalik Buterin, Zoe Hitzig y Glen Weyl en una investigación publicada en 2018. Sin embargo, para comprender mejor de qué trata, vamos a simplificar el concepto. La fuerza impulsora detrás del financiamiento Cuadrático es su fondo de contrapartida, un fondo de financiación proporcionado por individuos, compañías y protocolos, conocidos colectivamente como socios de contrapartida. Los fondos recaudados en el fondo de contrapartida son utilizados para aumentar la contribución de proyectos individuales. Veamos un ejemplo rápido para entender mejor el concepto.

Supongamos que tenemos $10.000 en un fondo de contrapartida y tres proyectos participando en una ronda de financiación. El proyecto A obtiene $1000 en recursos, de 5 contribuyentes que entregan $200 cada uno. El proyecto B recibe $1000 en recursos, de 2 contribuyentes cada uno da $500. El proyecto C también recibe $1000, pero de 20 contribuyentes, cada uno aportando $50. Ahora, las cantidades igualadas se calculan usando la fórmula de financiación Cuadrática. Siguiendo la fórmula, el primer proyecto obtiene $1851,85 adicionales, 185% más que el monto de la contribución. El segundo proyecto recibe $740,74, un 74% más de las contribuciones totales, mientras que el tercer proyecto recibe $7407,41 del fondo de contrapartida, un sorprendente 740% de la contribución original.

Observemos cómo la fórmula llega a esos valores.

 	Individuos, compañías y protocolos contribuyen en los proyectos (A, B, C).
 	Comencemos con el proyecto A. Después de completar las rondas de financiación, se sumó la raíz cuadrada de cada contribución y se elevó al cuadrado la suma resultante. Asumamos que esta es la variable de la financiación Cuadrática.
 	El mismo proceso se repite en los proyectos B y C.
 	La participación del proyecto A en el fondo común es calculada como el promedio ponderado de su variable de financiación cuadrática.
 	Los proyectos B y C también recibieron su parte del fondo común siguiendo el mismo modelo matemático.

Los Beneficios del Financiamiento Cuadrático 
El financiamiento Cuadrático ayuda a abordar el problema denominado la “tragedia de los bienes comunes.” Este es un problema económico donde cada individuo tiene el incentivo de consumir recursos a expensas de otros, sin manera de excluir a nadie del consumo de recursos, llevando al sobre consumo y agotamiento de los bienes comunes. El financiamiento Cuadrático hace énfasis en el número de donaciones en lugar de la cantidad de la donación. Los proyectos que atraen más donaciones son representativos de los bienes públicos que sirven a un grupo mayor de usuarios, haciendo más severa la tragedia de los bienes comunes.

Como resultado, se asume que los proyectos que atienden a un grupo mayor cuentan con el respaldo de más donantes, generando mayores donaciones del fondo de contrapartida. Esta es la razón por la cual el proyecto C, recibió la mayor cantidad de fondos en el ejemplo anterior.




	

	
	
		
			
				¿El financiamiento cuadrático hace énfasis en cuál de las siguientes?
			
		

		
					

		
			
			
			
			El número de las donaciones
		
			
			El tamaño de las donaciones
		
			
			Las dos anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de Uso de la Votación Cuadrática y el Financiamiento Cuadrático
La Legislatura del Estado de Colorado ha usado la votación Cuadrática para decidir qué proyectos de ley de apropiación deben ser financiados primero por la cámara. Ya que es más probable que los legisladores patrocinen y voten por sus propios proyectos, los Demócratas usan la votación Cuadrática para determinar qué proyecto de ley tiene apoyo del consejo. A cada legislador se le entrega un presupuesto de 100 créditos, donde un voto les costará un token. Sin embargo, los legisladores pueden dar más votos a un tema específico, con el costo de cada voto aumentando cuadráticamente, como mostramos a continuación.

El hackathon Presidencial de Taiwán fue juzgado también a través de la votación Cuadrática.

Cuando se trata del financiamiento Cuadrático, el mejor ejemplo es el de Gitcoin, que utiliza este método para recaudar fondos. Gitcoin permite a la comunidad crear y financiar proyectos, además, ha apoyado varios proyectos, incluido Uniswap, Finematics, Kickback y otros. Vitalik Buterin usa Gitcoin Grants para descubrir nuevos proyectos, mientras que Andre Cronje lo usó para financiar los Yearn Finance.




	

	
	
		
			
				¿Dónde se ha puesto en práctica el concepto de votación cuadrática?
			
		

		
					

		
			
			
			
			En la Legislatura del Estado de Colorado
		
			
			En el hackathon Presidencial de Taiwán
		
			
			En el partido Alemán Volt, durante el segundo congreso
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Finalizando 
Tradicionalmente, las democracias modernas han usado el método de una persona, un voto, mientras que las corporaciones han adoptado mecanismos de votación ligeramente más sofisticados. Sin embargo, los sistemas de votación más democráticos, como la Votación por Elección Clasificada y la Votación Proporcional, han fallado en ganar terreno, debido a la complejidad que implica. La votación Cuadrática, permitiendo a los votantes expresar sus preferencias y la intensidad de esas preferencias, ayuda a proteger los intereses de grupos más pequeños dentro de las comunidades.

El financiamiento Cuadrático, si bien es un concepto relativamente nuevo, ha tenido un impacto considerable, con más de $2millones distribuidos en bienes públicos. Un número creciente de proyectos están explorando el financiamiento Cuadrático, entre los que destacan Gitcoin Grants, clr.fund y Downtown Stimulus. No obstante, ambos conceptos tienen el potencial de cambiar radicalmente como los protocolos de blockchain son gobernados y financiados.




	

	
	
		
			
				¿Cuáles son los proyectos más destacados que exploran el financiamiento cuadrático?
			
		

		
					

		
			
			
			
			Gitcoin Grants
		
			
			Clr.fund
		
			
			Downtown Stimulus
		
			
			Todos los anteriores
		
	
		

		
		
			
				Correct!
				Wrong!

### Система аккаунтов NEAR - Экспресс гайд

Введение
 
    NEAR использует человекочитаемые идентификаторы аккаунтов формата name.near. Например, maria.near или jane.near.	 
  Система аккаунтов NEAR подобна системе доменных имен веб-сайтов, в том плане, что аккаунт может создать сколько угодно дочерних аккаунтов. Например, аккаунт с именем maria.near можно создать аккаунт вида sub.maria.near, а он в свою очередь может создать аккаунты first.sub.masha.near, second.sub.maria.near и т.д.	 
  Для создания аккаунта можно использовать NEAR Wallet (https://wallet.near.org/) (кошелек от NEAR Protocol), NEAR Faucet (кран для пользователей Ethereum и Metamask) или near-cli (https://github.com/near/near-cli) (интерфейс командной строки, предоставляющий функционал для взаимодействия с NEAR).	 
  В NEAR можно создать аккаунт и отправить его другу или подписчику в качестве подарка при помощи сервиса https://nearnames.com.
  Посмотреть информацию о аккаунте можно не только в кошельке, но и в NEAR Explorer (https://explorer.near.org/).	 
  Кроме явных аккаунтов (вида name.near), экосистема NEAR также поддерживает создание неявных аккаунтов при помощи near-cli (они выглядят подобно адресам Bitcoin или Ethereum). Подробный гайд на английском можно найти здесь (https://docs.near.org/docs/roles/integrator/implicit-accounts).	 
  Каждый аккаунт в системе может иметь только один смарт-контракт. Для приложений, в которых пользователи должны управлять несколькими смарт-контрактами можно использовать дочерние аккаунты. Например, contract_1.maria.near, contract_2.maria.near и т.д.	 
  В экосистеме NEAR существуют аккаунты для разработчиков (https://docs.near.org/docs/concepts/account#dev-accounts). Их особенность в том, что они предназначены для тестирования и отладки смарт-контрактов.	 
 	 
 НИАР Аккунт - Ключи	 
  
 
    NEAR, как и большинство других блокчейнов, основан на криптографии с открытым ключом. Таким образом он полагается на пары ключей, в каждой из которых одному открытому ключу (public key) соответствует только один закрытый ключ (private key).	 
  NEAR использует открытый ключ для идентификации, а закрытый — для подписей транзакций (подтверждения контроля над аккаунтом при создании транзакций от его имени).	 
  В NEAR существует 3 типа ключей. Ключи доступа — для подписей транзакции от лица аккаунта, ключи валидатора — для обеспечения работы операций, связанных с валидированием сети, и ключи нод (узлов сети) — для обеспечения низкоуровневой коммуникации между узлами сети.	 
  Ключи могут храниться в 3-х разных хранилищах. InMemoryKeyStore — хранение в памяти, используется для временных сценариев. BrowserLocalStorageKeyStore — незашифрованное локальное хранилище браузера, используется для работы с приложениями в браузере. UnencryptedFileSystemKeyStore — незашифрованное хранилище в файловой системе, используется при работе с near-cli.	 
  Аккаунт может иметь несколько ключей доступа или не иметь ни одного.	 
  У ключей могут быть разные уровни доступа — FullAccess (полный доступ) или FunctionCall (только возможность вызывать методы контракта).	 
  Все ключи уникальные в пределах одного аккаунта, однако публичный ключ может быть назначен разным аккаунтам с различными уровнями доступа. От уровня доступа зависит какие действия в аккаунте можно выполнять с данным ключом.	 
  Для уровня доступа FullAccess доступны все 8 типов действий: CreateAccountAction (создание аккаунта), DeployContractAction (развертывание контракта), FunctionCallAction (вызов методов контракта), TransferAction (отправка токенов другому аккаунту), StakeAction (стейкинг токенов), AddKeyAction (добавление ключа аккаунту), DeleteKeyAction (удаление ключа аккаунта), DeleteAccountAction (удаление аккаунта).	 
  Для уровня доступа FunctionCall доступно только действие FunctionCallAction (вызов методов контракта). При этом для такого ключа можно указать какие именно методы контракта он может вызывать.

### 🧪Positron Bridge Beta Test

Follow @LearnNEAR and @labs_electron on Twitter

Beta test sprint starts: February  9, 9 am ET
Beta Test sprint ends: February 12, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Read the Guide 📚How to Test the Positron Bridge: A Step-by-Step Guide
 	Get yourself an Ethereum account via Metamask
 	Go to Positron Bridge
 	Follow the steps in the Guide above
 	Take a screenshot of your transfers History

 	Tweet with your screenshot “I’ve just transferred tokens from Ethereum to NEAR via  @labs_electron Positron Bridge during @LearnNEAR Beta test” and tag 3 friends
 	Tell us what do you think about the process

💡HINT: if nothing works, you may need to try another browser with disabled JS blocking addons
Fill the Feedback form
🤑The top 15 beta testers will get 4 NEAR, top 2 beta test feedback submitters will get 20 NEAR each. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead Shubham Yadav at LNC Telegram Beta test topic

### How I started my way as a NEAR developer

Introduction:
Hi all, my name is Bogdan and 3 months ago I started my way as a NEAR developer in the RUST language. This is my first text where I want to share my experience as a NEAR Certified Developer from scratch. I have no experience in development or learning programming languages, the only thing I was working with before was making SQL queries to unload data from tables when I was a tech support person.
Choice of language and blockchain:
The choice every aspiring developer probably faces is "What language should I even learn?" and I was no exception. I started to watch various YouTube videos about popular programming languages and the tops were Python, Java, JavaScript which I had heard about before and Rust which I knew nothing about.

Since I was a bit interested in cryptocurrencies and blockchain before that, I started looking into what languages this code is written in in general. The first thing I came across was Solidity which can be used to write contracts for Ethereum. After that I found out that all of the front-end is written in JavaScript, but it felt like I didn't want to work with the front-end. The last thing I found was Rust, where I could write contracts for Solana and NEAR.

I decided to learn more about Solidity and Rust and started digging. At first I went to YouTube to find some basic information and listen to the pros and cons of each language. As often happens with videos like that, they mostly talked about the pros and cons, the only thing I can remember is that on one hand Rust will be hard to learn if it's the first programming language, but on the other hand it's good to learn as the first language because it has principles that make it different from other languages. It was also important for me to get the basic information translated into my native language, Russian, because I had no experience with that kind of book, and it was harder to understand all the information in English. So, after reading about what a great language Rust is and that all the developers are very fond of it, I decided to choose it.
Searching for the necessary information:
Looking for the very first information on Rust, I went to YouTube. There I watched several introductory videos for 2-3 hours each, but of course I didn't understand any of them. After that I found several articles about how to start learning Rust and it came down to what to start with The Rust Programming Language, so I did that. After reading the book the first time, I started to understand a little bit about the concepts of Ownership and Borrowing, and realized that there are different types of data, structures and so on. So, that was it, and I had no idea how to write anything more complicated than Hello, World! What I found next was an article on how to "properly" read The Rust Programming Language in order to understand at least something about how Rust worked. It went something like this:

First read chapter 1, 3, 5, 6, then 4, then 8, then 4 again, then 10, then 8 and 4 again

and so on through all the chapters, constantly going back to the previous ones. After this reading I got a little better understanding of how Rust works and why it works this way, and I was able to understand and repeat chapter 2 of Programming a Guessing Game. That was the end of my basic Rust experience and I started to choose a blockchain for my code (I didn't know that it's called smart contracts yet). The choice was not difficult, between Solana and NEAR, and since there was much more information about NEAR, I chose it.
Choosing the NEAR Certified Developer course:
First of all I went to https://near.org/ and started researching what training opportunities there are in general, went to https://docs.near.org/ and started reading everything in order to form an understanding of how everything works here. After I read what I thought were all the basic articles and got a little familiar with blockchain itself, I started looking for something more applied. Something where I could not only read and watch ready-made examples, but also to start working with the first smart-contracts, deploy them and somehow interact with them in testnet. And I found Learn NEAR Club and NEAR Certified Developer course, I liked the tasks of this course and the fact that after finishing it I could get up to $500 in NEAR tokens.

I didn't fit the audience it was meant for, but I was ready to spend more than 6 hours a day and was not limited in time to complete it, so I decided to take it.
First Step:
The first step, as I understood it, describes the general concepts of both cryptocurrencies in general and Bitcoin and NEAR. Since I really wanted to get to the practical part and I already read a lot of articles and watched the MIT course on cryptocurrencies before, I decided that I could skip this step and go straight to the second one.
Second step. Reading:
The first steps of this course are to read three contract reviews and in addition you can watch Live Contract Review videos, Illia's contract repo and all Rainbow Hackathon contract submissions. As it says in the description of these activities

It took me about two days to understand the three contracts that are described in the CORE Activities section. And I spent a few weeks reading and understanding the contracts of BONUS Activities, so that the lines of writing would mean something to me, and not just letters on a screen. After that, I moved on to step three, the title of which reflected what I had wanted for so long.
Step Three. Writing:
Here it is, the long-awaited stage, when the interaction with the contract begins, albeit minimal, but you can already feel like a developer who makes changes in the code and something changes from it, even if it's just the names of variables or changing gas values. So, VS Code is set up and the repository is copied (which also took me a few days). Finally I change the first value in the code, the name of the function new to initialization (it was the first thing that came to my mind)

try to build the contract and get a bunch of errors. After a few hours of figuring out why, I realized that there was no way to build a contract using PowerShell and I had to install the Windows Linux subsystem. I was able to solve this fairly quickly and the contract was built and tested and no problems appeared later on when making small changes. The next step was the workshop on Rust contracts (based on berryclub) from the BONUS Activities section, it took me a few more days, but no special problems I remembered. After that, I moved on to the next step.
Steps 4, 5, 6:
Since the next steps didn't require me to confirm exactly what I was doing going through them I decided to flip through them and see what was next in the course. I saw exactly what was required to sign up for demo day and turn in a project and focused specifically on coming up with a project and doing it, skipping steps 4 and 5.
Choosing the topic of the project:
I went straight to https://docs.near.org/ and started looking at Examples there. Tutorials and Zero to Hero guides. The most interesting thing was to study Zero to Hero guides, I was determined to understand every line of code, so after reading each section I tried to write code that I figured out on my own. This greatly improved my understanding of how FT, NFT and marketplaces work and my understanding of smart contracts in general.

Initially I wanted to implement a marketplace project, but to come up with something new or at least something that I have not seen in other marketplace contracts I could not and so I continued to look further and one evening I found a contract with a lottery I was wondering how it works and what I could do with it.

While I was working on that contract and simultaneously studying Master NFTs on NEAR, I had an idea to combine those two contracts and make a site similar to Patreon, where users could support content makers and get something in return.

I saw it this way, using an example: a drummer who puts out videos on YouTube creates an NFT collection, people who want to support him mint NFTs from that collection and every 5 new NFTs for example are raffled off, the winner gets to interact with the content maker somehow, like offer a topic for the next video or get a lesson with that drummer.
Implementation:
Since I was already familiar with the NFT contract, making the necessary changes to it in the form of collections, series, and lazy minting wasn't difficult, but it still took me a long time and even simple changes like that took me days at a time.

Things were much more complicated with the lottery contract, initially it was a huge contract with several kinds of lottery itself, a participant whitelist, and different kinds of tokens that were accepted to participate.

In my case, most of that functionality wasn't needed, so I started to clean it up, but it was quite a challenge to remove everything that wasn't needed so that nothing would break. At first I removed all kinds of lotteries and left only the one that suited me, it was easy, and when I removed the last error that was highlighted by VS Code, rebuilt the contract, checked that all the tests pass, I redesigned the contract, but nothing changed. And then, with the seemingly simple problem I was stuck for a few days, because I didn't know what it could be and where to look.

I checked the whole code several times from beginning to end, everything was fine and should work correctly. Deploy the contract to different accounts, rebuild contract a few times, deleted the target folder, built the contract again, googled a lot and noticed that the file Cargo.toml my old version rand = "0.7.3" and need to change it to "0.8.5"

which I did, after that contract is no longer built, but I thought that the problem was this and started looking to fix it. I spent half a day in Google and found a random function to replace the one that was in the contract, but still nothing worked and the contract was not created. I tried to solve this problem for three days and was almost in despair, but I found a man who could advise me and he explained that the random function in the blockchain is a very complicated thing and I should revert the contract and the old version rand = "0.7.3" was correct.

After I put everything back, I deleted the target folder again for some reason and this time for some reason decided to delete .wasm file from the res folder, rebuilt the contract and it was a miracle, all the changes applied. I understand that the problem was in .wasm file, but why it was not updated, I have not understood and never had such a problem.

Since I understood the lottery contract very well during those two weeks, making the other changes was no problem and did not take much time.

The next step was to write cross-contract calls between NFT contract and Lottery contract, I had two weeks for that before the Demo Live session in January, when I wanted to hand in the finished project.

I spent two days finding and view as many examples of cross-contract calls as I could, I've looked everywhere - at the NEAR YouTube channel, examples on https://docs.near.org, and many examples of cross-contract calls in different contracts on GitHub. The basic examples were easy to understand, because there were plenty of examples and they were explained in great detail, but writing the cross-contract calls I needed for my project was much harder. After that I tried to write cross-contract calls similar to the basic example described in the tutorial and got nothing, but this time the same thing didn't work either. The next step was to write to the NEAR developer chat room, they suggested me several code examples where I could see the similar solution and use ChatGPT to make the "skeleton" of the function

the bot produced the same solution, as I wrote, when I took the cross-contract call from the NFT contract. But using this skeleton I got a compilation error, which I couldn't fix.

After 12 days of trying to write this cross-contract call I failed and decided to show only the lottery contract at the Demo Live session.
Demo Live session:
This was my first experience with this type of call and I didn't know what to expect. I was very unsure if the lottery contract I had written was enough and if I was ready to show the results of my work. The day before Demo Live session I found a playlist on YouTube with recordings of previous demo sessions and the projects shown there seemed to me much bigger and more complicated than mine, with good presentations and ready front-end, as you understand I didn't have it. And knowing myself, knowing that I usually want to do everything perfectly, which most often leads to the fact that in an attempt to achieve perfection I can stop doing something and decide that my project is not good enough to show it to someone, I decided that by all means conquer my fear and show everything as it is, hear some criticism and keep moving forward. With these thoughts in mind, I sat over the presentation text until four in the morning and was ready to turn it in at eleven in the morning.

I slept very badly all night, was very nervous and tried to recover somehow before the presentation. I woke up at 10:30 and was ready to hand in the project, but then I noticed that the Demo Live session started at 11 a.m. Canadian time and I had it at 8 p.m. At first I was upset because I would have to spend another 9 hours in excitement and anxiety and I decided to go over the presentation again and when I started to do that I was very happy that the presentation wouldn't be until 8pm. I saw a lot of errors in the commands I had to call as I went through the presentation. The constants were written with a "__" which caused an error when calling the functions and the subaccounts I was supposed to call the payable functions from had run out of balance in the previous tests and in the time left until the presentation I was able to fix them.

The presentation went great, I was the first one to give my project, so I didn't feel the pressure that I would have felt if I had seen the projects that were halfway through. After I showed and talked about my project Sasha asked me some questions and gave me his feedback:

"This project doesn't have a bright future in the mainnet, but for three months of study, it's a good result, don't you want to write an article about it?" Which I did.
Conclusion:
In conclusion, I would like to say that during these three months there were many problems that seemed unsolvable. There was a lot of joy when these problems were solved. I have a much better understanding of what code is and how to write it. How NEAR blockchain works and what its benefits are, got development experience and a big boost of motivation to keep it all going. And if you're in doubt about whether to start the NEAR Certified Developer course, even if you have no experience at all, definitely yes, you should. You have to be prepared that it can take a lot of time and effort, but it seems to me at the beginning of the path it is one of the best ways to learn something. And I've got plans to continue studying, to figure out these problems and

### What is your favorite NEAR NFT marketplace?

Sorry. This form is no longer accepting new submissions.

### Update - February 2, 2023

Brief Summary:

 	
👉LNC became a home for 50,000 (L)Earners! Congrats, everyone!




Results:

 	🏆 Top 10 #NEAR projects who got the most (L)Earners attention in January 2023! 

 	🧪 Beta test for Aurora Bridge was tough but rewarding -  $NEAR 90 were awarded for the feedback
 	🔑NEAR Wallet Selector came to LNC!
 	 (L)Earn "Why should DAOs migrate to running a Private Shard?" by chefsale.near, CEO of Calimero
 	 492 (L)Earners successfully redeemed in January Redeem Window - check LNC Telegram for Redeem discussions 

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Don't miss February Redeem to NEAR window!

### Why should DAOs migrate to running a Private Shard?

Introduction to DAOs and multi-sig contracts
Most of the users of Web3 are very familiar with both terms DAOs and Multi-sig contracts, but for people not familiar with the Web3 space I believe it is worth unwrapping both of the terms.
What is a DAO?
A “Decentralized Autonomous Organization” (DAO) is a community-led entity with no central authority. It is fully autonomous and transparent: smart contracts are used to govern decision-making and distributed ownership of assets. The voting process for DAOs is posted on a blockchain, and users must often select between mutually-exclusive options. Voting power is often distributed across users based on the voting weight they have inside the DAO (weight number of tokens they hold, one member - one vote and others). All votes and activity through the DAO are posted on a blockchain, making all actions of users publicly viewable.
To make decisions for the DAOs they are leveraging a multisig wallet (contract).
What is a multisig wallet?
Multisig wallet is a special type of crypto contract for securely storing cryptocurrency. It requires two or more private keys (DAO parties) to sign and send a transaction, and is often used to add an extra layer of security to wallet transactions by ensuring that multiple key holders are involved in approving the transaction.
Multisig contracts can also be configured to allow each in the set of private keys to generate a signature, making them a great option for those looking to store their cryptocurrency in a secure and trustless manner.
How are DAOs currently leveraging multi-sig contracts?
DAOs are using multisig to store their funds securely and manage them efficiently. Multi-sig contracts provide multiple stakeholders the ability to sign off on a transaction, allowing for secure and diversified management of funds and decisions. Multisigs also provide an additional layer of security by requiring multiple private keys to access the funds.

Additionally, DAOs can use multi-sig contracts to implement a voting and governance system that is more complex than the average multisig contract. This allows for decision-making to be decentralized and secure.
The most common DAO voting structures are token-weighted quorum voting, quadratic voting, liquid democracy or vote delegation or vote locking, and token-based quorum voting.

 	
Token-weighted quorum voting
It requires a certain threshold of voters in order for a proposal to pass. For example: 60% quorum, which would mean that 60% of token holders must vote in favor of a proposal for it to pass.
 	
1 token = 1 vote governance
An individual's voting power is directly proportional to the number of tokens they hold.
 	
Quadratic voting
It’s a system that balances the interests of minority groups while still maintaining a majority decision-making process. Liquid democracy or vote delegation. It allows people to delegate their vote to a representative.
 	
Vote locking
It’s a mechanism that allows participants to exit a vote without penalty.
 	
Token-based quorum voting
It’s a system which requires a certain threshold of tokens to be held by voters for a proposal to pass.

Main challenges DAOs are facing
The main issues DAOs are facing include a lack of recognized legal status and potential unlimited liability of members, lack of regulation, and inadequate security measures. In addition, DAOs can be vulnerable to governance attacks, bad configuration, and spam. These issues can create a number of risks, including inadequate safeguards for personal data, vulnerable smart contracts, and unauthorized access to funds.
Most of the technical problems mentioned above can be solved and the rest mitigated using a Private shard, but let’s first unwrap what a Private Shard is.




	

	
	
		
			
				What are some implementations of votes that can be used with private sharding in DAOs
			
		

		
					

		
			
			
			
			1 token = 1 vote governance
		
			
			Quadratic voting
		
			
			Token-weighted quorum voting
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Private Shards for DAOs: a multisig wallet on steroids


A Private Shard is a customizable sidechain (a blockchain network running alongside the public blockchain with ability to transfer assets and execute cross contract calls) which allows you to protect your data while leveraging all the business benefits of open-source blockchains. It allows Private Shard owners to get full control over their blockchain while keeping private information between them and allow only certain public parties to access this information.
DAO members get a network run by them based on their needs. It can be customized to the proposed voting structures above mentioned where validators (nodes validating the blockchain blocks) are owned by DAO members similar to how inside a multisig they would own a private key with a certain voting power. Think of it as a “Multisig on steroids”, as all the basic multi-sig properties are the same, while getting the benefits of all the information being only stored inside the private shard and not leaked to the public.
On top of that DAO members are able to deploy custom smart contracts inside the Shard with “infinite scalability” providing them with the ability to have:

 	private voting
 	accounting and contractor payroll
 	implement transaction-heavy mechanics like auctions (which may be too expensive on Mainnet)
 	treasury management departments inside the DAO and much more.




	

	
	
		
			
				A private shard is:
			
		

		
					

		
			
			
			
			A private Web2 codebase stored in a closed sharded ecosystem
		
			
			A private customizable sidechain (a blockchain network running alongside the public blockchain with ability to transfer assets and execute cross contract calls)
		
			
			An open DAO stored directly on the sharded NEAR blockchain that uses NEAR validators
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






The Private Shards bridge has a permissions contract which allows them to set rules on which public and private contracts/accounts are able to interact and to what extent. This provides the ability to limit access to certain parties or contracts to move assets from and to the Private shards, on top of that it provides access to certain smart contracts to execute contract calls from the shard or mainnet.
For example: A DAO can have a private voting contract inside the shard which initiates a call when the vote has ended and that only the result of the voting gets published on Mainnet without revealing specific member votes. This call can be only executed from inside that shard and no other party can publish it except this specific contract. This provides the ability for DAO members to ensure the security of the vote like they would using a multisig, while the actual votes are hidden from the public.




	

	
	
		
			
				Private shards allow DAOs the ability to have:
			
		

		
					

		
			
			
			
			Private voting
		
			
			Accounting and contractor payroll
		
			
			Implement transaction-heavy mechanics like auctions
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





On top of that the Calimero Gateway provides additional permissions management for the DAO members to specify policies on which public users/wallets are able to interact with the Private Shard. While the DAO members run the validators and have admin access to the shard, they can invite external members/wallets to be able to read certain data or interact with certain contracts.
For example: A DAO can have a private contract inside the shard for external parties to submit proposals on which the DAO can vote. This can allow only the submitters and DAO members of the proposal to see their information about the status of the proposal. Submitting the proposal can be limited to a whitelist of wallets added by the DAO or to the general public.
We believe that Private Shards are the next natural evolution for DAOs and are looking to work with more DAOs in this next transformation in Web3. Feel free to contact us if you have any questions or are looking to book a demo.

### Explorer Blockchain di NEAR

Setelah munculnya peristiwa besar dari FTX, kita jadi lebih kritis dalam mengendalikan aset crypto daripada sebelumnya. Salah satu cara terpenting untuk melakukannya adalah dengan belajar membaca block explorer. Untuk Protokol NEAR, penjelajah blok yang paling populer adalah:

 	NEAR Explorer
 	NearBlocks
 	NearScan

Apa itu Explorer Blockchain?
Blockchain Scanner merupakan perangkat lunak yang digunakan untuk memvisualisasikan berbagai metrik dalam  jaringan blockchain seperti:

 	Hashrate
 	Ukuran blok
 	Kesulitan Blok
 	Biaya transaksi rata-rata.

Jadi, apa yang dapat kita lakukan dengan explorer blockchain? Mari kita uraikan satu persatu.

 	Melacak status transaksi yang tertunda saat sedang menunggu di mempool.
 	Melacak saldo dompet tanpa harus menggunakan dompet itu sendiri. Ini dapat membantu jika Anda ingin memeriksa saldo di dompet hardware anda.
 	Melacak setiap transaksi yang masuk dan keluar dari alamat tertentu.
 	Melihat blok tanpa induk, alias blok yang tidak terpasang ke rantai utama.
 	Menjelajahi transaksi whale yang dapat berdampak besar pada pasar.
 	Melacak alamat leader atau influencer crypto terkenal.
 	Melacak koin pasca diretas.

Bagaimana Explorer Blockchain Bekerja?
Explorer Blockchain bekerja bersama node blockchain dan menggunakan antarmuka pemrograman aplikasi (API), basis data rasional, dan basis data SQL untuk mengambil informasi yang relevan dari jaringan yang mendasarinya. Berikut adalah beberapa hal yang perlu diingat:

 	Explorer mengatur semua informasi ini ke dalam database dan menampilkan data ini dalam format yang dapat dicari.
 	Pengguna dapat melakukan pencarian melalui tabel yang terorganisir.
 	Semua permintaan pencarian dikirim ke server backend, yang menyediakan respons yang diperlukan.

Bagaimana Cara Kita Menggunakan Explorer Blockchain?
Untuk beberapa demonstrasi pertama ini, mari kita cek NEAR explorer. Kami menempatkan akun yang dipilih secara acak di scanner. Mari kita lihat data apa yang kita dapatkan.

Pada bagian pertama yang kita lihat adalah data berikut:

 	Transaksi: Jumlah transaksi yang dikirim dan diterima. Akun ini telah mengirimkan 1.816 transaksi dan tidak menerima apapun sama sekali.
 	Penyimpanan yang digunakan: Total penyimpanan blockchain yang digunakan oleh akun. Akun ini menggunakan 390 kB.
 	Saldo akun Native: Jumlah token NEAR yang saat ini dipegang oleh akun. Akun ini memiliki total  81.1916 NEAR token.
 	Stake validator: Apakah akun ini melakukan staking NEAR untuk mendukung validator dan mengamankan jaringan? Akun telah menstaking sebanyak 23.439.675,24565 NEAR pada validator.
 	Dibuat: Akun dibuat pada 15 Februari 2022, pukul 4:49:20.
 	Transaksi yang dibuat: Hash transaksi yang bertanggung jawab untuk membuat akun ini adalah 4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Saat Anda menggulir ke bawah, Anda akan melihat riwayat transaksi akun ini.

Memeriksa status transaksi
Mari letakkan hash transaksi acak di penjelajah (explorer) dan lihat tampilannya. Pertama, kami akan menempatkan hash transaksi ini:

2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3


 	Pengirim: Ini adalah akun yang menandatangani dan mengirim transaksi. Dalam hal ini, ini adalah “Sweat_welcome.near.”
 	Penerima: Ini adalah akun yang menerima transaksi – 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Status: Status transaksi saat ini. Ini bisa jadi Pending, Succeeded, Failed/Finalized, atau non-finalized. Dalam kasus contoh ini, Berhasil.
 	Biaya transaksi: Ini adalah biaya yang diperlukan untuk melaksanakan transaksi ini. Dalam hal ini, nilainya 0,00008 NEAR.
 	Nilai deposit: Ini adalah nilai total yang ditransfer dari akun penandatanganan ke akun penerima. Dalam hal ini, nilai setoran adalah 0,05 NEAR.
 	Gas yang digunakan: Satuan gas yang dibutuhkan untuk menjalankan transaksi. Dalam hal ini, 1 Tgas ( 1 TeraGas = 10¹² unit gas).
 	Dibuat: Transaksi ini dibuat pada 17 November 2022, pukul 13:18:33.
 	Hash blok: Pengidentifikasi unik (hash) dari blok tempat transaksi ini disertakan. Dalam hal ini, hash blok adalah F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN

Transaction Receipt


 	Explorer juga membagikan tanda terima. Tanda terima itu sendiri memiliki dua bagian.
 	Bagian pertama adalah tanda terima dari transaksi itu sendiri. Ada ID kuitansi dan total gas dan token yang dibakar.
 	Bagian kedua adalah penerimaan sistem. “Sistem” adalah akun khusus yang digunakan untuk mengidentifikasi tanda terima pengembalian dana.




	

	
	
		
			
				Dimana pilihan dibawah ini yang bisa saya gunakan menggunakan scanner?
			
		

		
					

		
			
			
			
			Melihat historikal transaksi dari sebuah akun
		
			
			Mengecek seberapa banyak fee gas yang dikeluarkan di transaksi terakhir
		
			
			Semuanya benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Menggunakan Explorer NEAR Lainnya
Ayo kita gunakan transaksi yang sama pada NearScan dan NearBlocks untuk melihat bagaimana data disajikan antara kedua explorer yang berbeda ini

NearBlocks

Explorer NearBlocks menunjukkan data yang sama baik total gas dan token yang dibakar saat terjadinya transaksi




	

	
	
		
			
				Apa yang “Akun System” dapat kerjakan?
			
		

		
					

		
			
			
			
			Memvalidasi transaksi
		
			
			Mengidentifikasi bukti refund
		
			
			Menambahkan transaksi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NearScan

Antarmuka NearScan memberikan data yang hampir sama. Data gas menunjukkan lebih banyak tempat desimal daripada Penjelajah NEAR.




	

	
	
		
			
				Apa scanner dibawah ini yang bisa digunakan untuk NEAR Protocol?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			NearScan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kesimpulan
Sebenarnya ada transaksi yang lebih rumit di jaringan blockchain NEAR. Namun, artikel ini seharusnya dapat memberi kita gambaran tentang cara membaca transaksi ini. Explorer memungkinkan kita untuk mengeksploitasi salah satu sifat paling penting dari teknologi blockchain yakti transparansi. Ini memberdayakan kita sebagai pengguna untuk melacak koin milik kita dengan cermat dan melihat ke mana mereka pergi.

### Что такое квадратичное голосование и квадратичное финансирование?

Если вы знакомы с децентрализованном управлением, тогда возможно вы встречали такие слова, как «квадратичное голосование» и «квадратичное финансирование». Хотя некоторые могут подумать, что это модные словечки, но за последние несколько лет эти концепции получили большое распространение. Было несколько случаев, когда обе концепции были реализованы с высокой степенью успеха. Квадратное голосование использовалось для голосования за проекты-победители во время тайваньского президентского хакатона. Мы видели, как система использовалась снова, когда Демократическая партия Колорадо использовала ее для определения своей партийной платформы. С другой стороны, финансирование Quadratic использовалось Gitcoin Grants для финансирования разработок в экосистеме Ethereum.

Обе концепции, по мнению их сторонников, могут революционизировать процесс принятия решений. По словам Виталика Бутерина: - окончательная реализация этих концепций могла бы глубоко преобразовать индустрию, поскольку в индустриальную эпоху наступили в основном свободные рынки и конституционная демократия. Ажиотаж не без причины, в этой статье мы рассмотрим обе концепции, их применение и преимущества.

Начнем с квадратичного голосования.
Проблема моделей управления
Модели управления, используемые блокчейн-платформами, становятся все более важными благодаря их способности влиять на участие пользователей, эффективность и привлекательность платформы. Одной из самых больших проблем, с которыми столкнулись блокчейны, когда дело дошло до управления, была возможность появления доминирующих позиций. Эти «доминирующие позиции» будут состоять из пользователей, которые будут иметь под своим контролем большое количество голосов или даже большинство голосов. Это дало бы этой группе пользователей беспрецедентный контроль над вопросами, связанными с развитием платформы.

Такая концентрация права голоса может отпугнуть пользователей с меньшим количеством голосов от участия в механизмах управления или даже вынудить их полностью покинуть платформу. Перспективы и потенциал технологии и платформ блокчейна могут быть реализованы только в том случае, если пристальное и вдумчивое внимание будет уделено механизмам управления этими платформами. Такая концентрация голосов и права голоса, несомненно, обеспокоила бы других на платформе. Тем не менее, новый метод голосования, который в последнее время нашел применение в гонке социальных решений, является возможным решением дилеммы, преследующей блокчейн-платформы.
Квадратичное голосование: математический путь к более справедливому голосованию
Квадратично голосование — это механизм коллективного принятия решений, который обеспечивает лучший путь к принятию решений, избегая так называемой «тирании большинства». Впервые он был предложен политэкономом Гленом Вейлом и позволяет участникам выразить направление своих предпочтений, степень своих предпочтений. Благодаря этому он надеется решить проблему правления большинства и защитить интересы небольших групп избирателей, которым глубоко не безразличны конкретные вопросы. Квадратично голосование позволяет пользователям «платить» за дополнительные голоса по конкретному вопросу, что позволяет им более решительно выразить свою позицию.

В то время как в обычном опросе может быть задан вопрос, согласны вы или не согласны с определенным набором вопросов, квадратичное голосование дает избирателям бюджет «голосовых кредитов», которые они могут потратить, чтобы согласиться или не согласиться с вопросами. Избиратели могут отдать несколько голосов, но каждый последующий голос будет стоить больше кредитов, чем предыдущий. Этот тип механизма голосования может использоваться в различных областях, таких как демократические институты, корпоративное управление и коллективное принятие решений с использованием блокчейна.




	

	
	
		
			
				Квадратичное голосование было впервые предложено:
			
		

		
					

		
			
			
			
			Виталик Бутерин
		
			
			Глен Вейл
		
			
			Зои Гитциг
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как работает квадратичное голосование?
Теперь давайте посмотрим, как работает квадратичное голосование. Квадратное голосование основано на рыночных принципах, при этом каждому избирателю выделяется определенный бюджет голосов, который он может потратить, чтобы повлиять на исход ключевых обсуждений. Если избиратель решительно поддерживает или возражает против определенного решения, он может выделить дополнительные голоса, чтобы продемонстрировать уровень своей поддержки или несогласия с конкретным решением. Стоимость дополнительных голосов определяется с помощью правила ценообразования голосов, при этом каждый голос становится дороже предыдущего. Возрастающая стоимость кредита избирателя демонстрирует степень поддержки или оппозиции конкретному решению.

В квадратичном голосовании используется простая формула: стоимость для избирателя = (количество голосов)2.

Давайте лучше разберемся в этом на примере. Предположим, у избирателя есть бюджет в 16 кредитов для голосования, и он может свободно использовать один кредит для 16 различных вопросов, по которым он может голосовать. Однако, если избиратель настроен более решительно по одному конкретному вопросу, он может выделить четыре голоса по этому вопросу за счет всего своего бюджета. Четыре голоса стоят все 16 голосовых кредитов, потому что стоимость каждого дополнительного голоса становится дороже квадратично. Таким образом, 1 голос будет стоить 1 кредит, 2 голоса — 4, 3 голоса — 9, а 4-й голос — 16.

Этот механизм рассматривался как одно из возможных решений проблем управления, с которыми сталкиваются блокчейн-платформы и сообщества, предотвращая захват власти одной группой, а также защищая интересы групп меньшинств. Токены, отданные в качестве голосов, равномерно перераспределяются между избирателями в конце каждого цикла управления. Группе потребуется несколько циклов голосования и значительные затраты, чтобы получить контроль над платформой.

Но как квадратичное голосование сравнивается с другими установленными механизмами голосования? Есть еще три основных демократических механизма голосования.

 	Системы множественности
 	Пропорциональные системы представления
 	Полупропорциональные системы

Системы множественности
В системах множественного голосования партия или позиция, получившая наибольшее количество голосов, побеждает на выборах, полагаясь на механизм «один голос, один избиратель». Однако системы множественного голосования не могут гарантировать, что избиратели могут выразить свою поддержку определенного дела или вопроса, а также распределить свои голоса для выражения степени поддержки.
Пропорциональные системы представления
Этот метод голосования в основном используется в национальных законодательных органах, где он гарантирует, что разделение выборного органа отражает разделение голосов электората. Хотя этот метод голосования лучше отражает точку зрения избирателей, он не отражает, насколько сильно избиратели относятся к своей позиции по вопросам.
Полупропорциональные системы
Существует несколько типов полу пропорциональных систем голосования. Однако ни один из них не учитывает степень предпочтения избирателей по вопросам.
Квадратичное финансирование: новый способ финансирования 
Перейдем к квадратичному финансированию. Квадратичное финансирование — один из самых инновационных социально-экономических экспериментов, вышедших из крипто-экосистемы. Его позиционируют как математически оптимальный способ финансирования общественных благ в демократических сообществах за счет увеличения пожертвований, сделанных большим сообществом, по сравнению с пожертвованиями, сделанными небольшими группами. Но что такое общественные блага?

Общественные блага определяются как товары или услуги, доступные всем членам общества, они должны обладать следующими качествами:

 	Не конкурентный — это означает, что использование этих товаров одним участником не снижает их доступности для других участников.
 	Не исключаемый – эти товары должны быть доступны для всех.

Квадратичное финансирование было описано Виталиком Бутерином, Зои Хитциг и Гленом Вейлом в исследовательской статье, опубликованной в 2018 году. Однако для понимания мы должны упростить концепцию. Движущей силой квадратичного финансирования является его соответствующий пул, пул средств, предоставляемых отдельными лицами, компаниями и протоколами, которые вместе известны как соответствующие партнеры. Средства, собранные в соответствующем пуле, используются для увеличения индивидуальных вкладов в проекты. Давайте рассмотрим краткий пример, чтобы лучше понять концепцию.

Предположим, у нас есть 10 000 долларов в соответствующем пуле и три проекта, участвующих в раунде финансирования. Проект А получает финансирование в размере 1000 долларов США от 5 участников, которые вносят по 200 долларов США каждый. Проект B получает 1000 долларов США от 2 участников, каждый из которых вносит по 500 долларов США. Проект C также получает 1000 долларов, но от 20 участников, каждый из которых вносит по 50 долларов. Теперь совпадающие суммы рассчитываются по квадратичной формуле финансирования. Следуя формуле, первый проект получает дополнительные $1851,85, что на 185% больше, чем внесенная сумма. Второй проект получает 740,74 доллара США, что составляет дополнительные 74% от общей суммы взносов, а третий получает 7407,41 доллара США в виде софинансирования, что составляет ошеломляющие 740% от первоначального взноса.

Давайте посмотрим откуда появляются эти цифры:

 	Отдельные лица, компании и протоколы вносят свой вклад в проекты (A, B, C).
 	Начнем с проекта А. После завершения раунда финансирования прибавлялся квадратный корень каждого взноса, и полученная сумма возводилась в квадрат. Предположим, что это квадратичная переменная.
 	Такой же процесс повторяется для проектов B и C.
 	Доля проекта А в пуле рассчитывается как средневзвешенное значение его квадратичной переменной финансирования.
 	Проекты B и C также получили свою долю в пуле, следуя той же математической модели.

Преимущества квадратичного финансирования
Квадратичное финансирование помогает решить проблему, называемую «трагедией общего достояния». Это экономическая проблема, когда у каждого человека есть стимул потреблять ресурсы за счет других, при этом нет возможности исключить кого-либо из потребления ресурса, что приводит к чрезмерному потреблению и истощению ресурсов. Квадратичное финансирование делает акцент на количестве пожертвований, а не на размере пожертвования. Проекты, приносящие больше пожертвований, представляют собой общественные блага, обслуживающие большую группу пользователей, что усугубляет положение общин.

В результате предполагается, что проекты, обслуживающие более обширную группу, поддерживаются большим количеством доноров, что приводит к увеличению пожертвований из соответствующего пула. Вот почему в нашем предыдущем примере проект C получил наибольшее финансирование.




	

	
	
		
			
				Квадратичное финансирование делает упор на….?
			
		

		
					

		
			
			
			
			количество пожертвований
		
			
			размер пожертвований
		
			
			оба вышеперечисленных
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Варианты использования квадратичного голосования и квадратичного финансирования
Законодательное собрание штата Колорадо использовало квадратное голосование, чтобы решить, какие законопроекты об ассигнованиях должны быть профинансированы палатой в первую очередь. Поскольку законодательные органы с большей вероятностью будут спонсировать свои собственные законопроекты и голосовать за них, демократы использовали квадратное голосование, чтобы определить, какие законопроекты пользуются всеобщей поддержкой. Каждому законодательному органу был дан бюджет в 100 кредитов, где один голос стоил им один жетон. Тем не менее, законодательные органы могут отдать больше голосов по вопросу, при этом стоимость каждого голоса увеличивается квадратично, как показано ниже.

Тайваньский президентский хакатон также оценивался квадратичным голосованием.

Когда дело доходит до квадратичного финансирования, наиболее ярким примером является Gitcoin. Он использует этот метод для сбора средств. Gitcoin позволяет сообществу создавать и финансировать проекты такие как Uniswap, Finematics, Kickback и другие. Виталик Бутерин использует Gitcoin Grants для открытия новых проектов, а Андре Кронье использовал его для финансирования Yearn Finance.




	

	
	
		
			
				Где была реализована концепция квадратичного голосования?
			
		

		
					

		
			
			
			
			Законодательное собрание штата Колорадо
		
			
			Тайваньский президентский хакатон
		
			
			Партия Германа Вольта
		
			
			Все вышеперечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Заключение
Традиционно современные демократии использовали метод «один человек — один голос», в то время как корпорации приняли несколько более сложные механизмы голосования. Однако более демократичные системы голосования, такие как рейтинговое голосование и пропорциональное голосование, не смогли завоевать популярность из-за связанной с этим сложности. Квадратичное голосование, позволяющее избирателям выражать свои предпочтения и интенсивность этих предпочтений, помогает защитить интересы небольших групп внутри сообществ.

Квадратичное финансирование, хотя и является относительно новой концепцией, оказало значительное влияние: более 2 миллионов долларов было направлено на общественные блага. Растущее число проектов изучают возможность квадратичного финансирования, главными из которых являются Gitcoin Grants, clr.fund и Downtown Stimulus. Обе концепции могут радикально изменить то, как протоколы блокчейна управляются и финансируются.




	

	
	
		
			
				Какие наиболее известные проекты изучают квадратичное финансирование?
			
		

		
					

		
			
			
			
			Gitcoin Grants
		
			
			Сlr.fund
		
			
			Downtown Stimulus
		
			
			Все вышеперечисленное
		
	
		

		
		
			
				Correct!
				Wrong!

### Carteira de transição da NEAR: por que isso vai acontecer e o que seus usuários devem fazer agora

Sem dúvida, a maioria dos usuários NEAR já ouviu falar sobre a transição da carteira NEAR. Mas ainda restam muitas dúvidas sobre suas razões, processos e relação com MyNearWallet. Aqui estão as perguntas mais frequentes sobre essa transição e também os comentários da equipe MyNearWallet.
Por que devo mudar de uma carteira “oficial” desenvolvida pela Near Foundation para outra?
Para começar, os usuários da NEAR têm necessidades e preferências diferentes e é improvável que somente um produto, ainda que seja oficial, cubra todas essas necessidades. Chegou um ponto em que os desenvolvedores do ecossistema NEAR perceberam isso e decidiram que em um futuro próximo o ecossistema NEAR não terá uma carteira oficial e todos os DApps serão incentivados a usar um seletor de carteira. A carteira  oficial da NEAR,  wallet.near.org, se tornará uma página de listagem para todas as carteiras do ecossistema. As datas exatas ainda não foram anunciadas.

As mudanças devem aumentar a descentralização e inspirar uma competição saudável no ecossistema NEAR. E como resultado, ao não existir carteira oficial, os usuários irão obter produtos mais avançados.
Como a MyNearWallet está conectada à carteira NEAR?
Kikimora Labs, está construindo MyNearWallet no topo da base do código-fonte aberto da carteira NEAR. A base de usuários não foi movida para MyNearWallet. A própria carteira permaneceu como código aberto. No novo projeto, MyNearWallet A equipe começou a melhorar os recursos antigos, adicionando novos e também fortalecendo a segurança. No momento, a equipe de suporte do MyNearWallet presta ajuda aos usuários de ambas  carteiras. Além disso, a equipe MyNearWallet resolve problemas de bug para dois projetos. Enquanto isso, os novos recursos estarão disponíveis apenas na MyNearWallet.

A interface MyNearWallet ainda parece quase a mesma da wallet.near.org. Mas, como afirma a equipe do projeto, o design será alterado sem sobressaltos.
O que sucederá com a minha conta https://wallet.near.org/?
Os usuários podem transferir suas contas para qualquer carteira NEAR que desejarem sem perda de fundos. Aqui está o instrutivo que explica como transferir sua conta para a MyNearWallet.
Roteiro e plano de transição de carteira

 	Fase 0 — Envolvimento da Comunidade [agora].
 	Fase 1 — Usuários externos, ativação das funcionalidades da conta de exportação                               [Começa em outubro].
 	Fase 2 — Um novo portal para Array de carteiras [Conclusão prevista para o início de 2.023].
 	Fase 3 —Terminar o encaminhamento das transações.
 	Fase 4 — Desativação completa da carteira NEAR.

### O que são (L)Earner NFTs?

Uma nova e emocionante coleção NFT foi recentemente lançada no ecossistema Near NEAR Ecosystem. Antes de explorarmos o que é a coleção (L)Earner NFT, aqui está um breve resumo do que é um NFT. Sinta-se à vontade para ignorá-lo se já estiver familiarizado com os NFTs.
O que é um NFT?
NFT é a sigla de Token Não Fungível. NFTs são ativos digitais únicos que têm suas informações de identificação registradas em um contrato inteligente. As informações no contrato inteligente são o que torna um NFT único. Um NFT é um ativo não fungível. Os bens não fungíveis não são divisíveis. Por exemplo, você não pode enviar a alguém uma parte de uma pintura ou um bilhete.

NFTs são certificados digitais de propriedade de ativos digitais. Um NFT é um contrato inteligente utilizado para proteger um ativo digital. Depois de escrito, ele é publicado em um token (ERC-721 ou NEP-171) na blockchain. Qualquer coisa pode ser transformada em NFT, sendo os mais populares: vídeos, GIFs ou JPEGs.
O que é a Coleção NFT (L)Earner?
A coleção (L)Earner NFT é uma colaboração entre o Learn Near Club (LNC) community e Denis Bashev, um dos designers gráficos mais prestigiados da Europa.
Conceito de design
O conceito de design é baseado na diversidade dinâmica da inteligência humana alimentada pela singularidade de cada aprendiz. Cada ser humano é um indivíduo único que tem diversos padrões de aprendizagem, destrezas e debilidades. A coleção (L)Earner NFT visa destacar a individualidade de cada aprendiz e como diferentes engrenagens interagem na máquina para criar uma pessoa holística, cada uma com seus próprios sonhos, medos, experiências e personalidade.

Para aqueles que não estão familiarizados com a forma como aprendemos a nível científico, aqui está a essência:

Quando você se compromete ativamente em aprender algo, os neurônios (células cerebrais) começam a formar conexões entre si. No princípio, essas conexões são muito fracas e o conhecimento não está totalmente comprometido com a memória de longo prazo. À medida que o tempo avança e você passa mais tempo aprendendo sobre um conceito, essas conexões se tornam mais fortes e ficam comprometidas com a memória de longo prazo. Seu conhecimento é realmente armazenado em bilhões de conexões neurais entre os neurônios do cérebro humano. Este processo é chamado de aprendizagem Hebbian.

A ideia dos bonequinhos é baseada no sistema nervoso humano. Os segmentos que compõem as pessoas-palito são inspirados nas bainhas de mielina que ajudam os impulsos elétricos a serem transmitidos através dos neurônios.


As poses dos personagens incorporam as inúmeras combinações de conexões neurais que se amalgamam em seus próprios microcosmos para formar memórias distintas de longo prazo de um conceito ou atividade. Os segmentos de linha são plotados em um plano cartesiano para criar poses divertidas.


A paleta de cores foi cuidadosamente escolhida por Denis para dar vida e dar um tom mais lúdico aos bonequinhos (stick people). Simboliza a alegria de aprender. A alegria de aprender não é algo que pode ser sentido apenas com gratificação instantânea. É o culminar de todas as maneiras pelas quais a sede de novas habilidades e conhecimentos melhorou sua vida e a vida das pessoas ao seu redor.

Minting
Todos os minters NFT são convidados a participar deste projeto de ponta. O custo de cunhagem começou em 2 $ NEAR e aumenta gradualmente à medida que a coleção cresce em direção ao limite de 10.000 NFTs. Os Minters podem:

 	Gerar - o software gera uma postura aleatória e mistura de cores quantas vezes quiser, para que você obtenha o (L)Earner NFT que deseja. A maioria dos NFTs no mercado são “gerados” a partir de modelos pré-construídos, enquanto os NFTs (L)Earner têm um número virtualmente ilimitado de combinações, criando um NFT verdadeiramente único para você.


 	Nome- dê um nome ao seu (L)Earner NFT, torne-o tão único quanto seu personagem.


 	Criar- crie seu NFT e proteja-o na blockchain NEAR.


 	Curadoria- colecione quantos quiser e organize sua coleção original e pessoal
 	Comércio- compre e venda (L)Earner NFTs no Paras NEAR NFT Marketplace

Benefícios do (L)Earner NFT LNC 
Você não apenas obtém um NFT legal quando cria um (L)Earner NFT, mas também obtém vantagens úteis como membro oficial da comunidade LNC:

 	Acesso prioritário com 2 horas de antecedência à janela Redeem da NEAR
 	Prova de origem da (L)Earn NFTs
 	Mais novidades no futuro…

Una-se a LNC telegram group para compartilhar seu (L)Earner NFT com os demais membros da comunidade.
Conclusão:
A coleção (L)Earner NFT é uma colaboração de ponta entre LNC e Denish Bashev (prestigiado designer gráfico). O objetivo do projeto é encapsular a experiência de aprendizagem individual de cada aluno em um NFT. A coleção é limitada a 10.000 NFTs, então adquira o seu enquanto pode!

### 🧪Aurora Rainbow bridge Beta Test

Follow @LearnNEAR and @auroraisnear on Twitter

Beta test sprint starts: January 24, 9 am ET
Beta Test sprint ends: January 27, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Read the Guide 📚How the NEAR Rainbow Bridge works
 	Get yourself an Ethereum account via Metamask
 	Get yourself some ETH on testnet  from https://goerlifaucet.com/
 	Go to https://testnet.rainbowbridge.app/ and connect your NEAR and Ethereum wallets

 	Start new transfer

 	Transfer 20 $NEAR t0 Ethereum or Aurora.
 	Try to transfer the funds back
 	Tell us what do you think about the process

💡HINT: if nothing works, you may need to try another browser with disabled JS blocking addons
Fill the Feedback form
🤑The top 10 beta testers will get 5 NEAR, top 2 beta test feedback submitters will get 20 NEAR each. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead @antonpaisov at LNC Telegram Beta test topic

### Shards privados da rede Calimero explicados – A solução Blockchain que permite escalabilidade e privacidade

Shards privados da rede Calimero explicados – A solução Blockchain que permite escalabilidade e privacidade
A beleza da tecnologia blockchain é que todos os participantes das redes blockchain confiam nas informações contidas nela, porque os dados na blockchain são imutáveis, visíveis e acessíveis a todos em tempo real. Mas a web3 atualmente está longe de ser perfeita, pois existem dois grandes desafios: privacidade de dados e potencial para negócios escalarem usando a tecnologia blockchain.

Desafios no uso de blockchain para empresas

Se todos os dados estiverem publicamente disponíveis e transparentes, questões de privacidade aparecem.

 	O que acontece quando as informações são classificadas como informações pessoais?
 	Há necessidade de proteção de dados ou obrigações de conformidade? Sob qual jurisdição?
 	O que acontece quando a informação é um segredo comercial?

Preservar a privacidade dos dados pessoais e empresariais é uma necessidade, não um luxo. Na blockchain, isso pode ser feito combinando dados e interoperabilidade on-chain e off-chain. Tudo isso é possível com os private shards (fragmentos privados) do Calimero.

Não vamos entrar na explicação do Calimero ainda. Há mais uma questão importante que precisa ser abordada: Escalonamento . Escalabilidade é a capacidade de uma rede blockchain de suportar uma quantidade crescente de transações, aumentando o número de nós/validadores.

À medida que o interesse pelo uso de criptomoedas e tecnologia blockchain cresceu, muitos usuários e empresas começaram a emitir tokens, construir Dapps e criar NFTs cada vez mais a cada dia. Como resultado, as redes começaram a ficar congestionadas, o que trouxe custos crescentes de gás para usuários novos e existentes, desencorajando-os a criar novos e melhores produtos . Foi aqui que surgiram as novas soluções de escalonamento . Um bom exemplo é a  NEAR, que usa sharding (fragmentação) para dimensionar e suportar o uso crescente de blockchain. Mas mesmo com fragmentação, para algumas empresas que têm muitas transações de rede diariamente, os custos podem aumentar substancialmente .

É aqui que entra o Calimero - pois você pode criar seu próprio shard (fragmento), no qual as transações são gratuitas e privadas. Você só precisa pagar um valor fixo por mês com base no número de validadores que está executando.
O que é a Calimero Network
Calimero é uma sidechain (cadeia lateral) personalizável construída sobre a NEAR Protocol. Pode ser vista como uma rede de redes. Uma solução para as empresas acessarem recursos de privacidade e possibilitar o escalonamento . O Calimero fornece uma infraestrutura que compartilha todos os e melhores benefícios da NEAR enquanto é aprimorada com vários novos recursos com ênfase na privacidade.

Calimero permite que você:

 	Crie seus próprios shards privados (pense em um shard como uma pequena rede blockchain privada que você possui)
 	Comunique-se entre seus shards e outras redes ou entre vários shards (mesmo que eles sejam de propriedade de empresas diferentes)

Usando shards privados Calimero, entre outras coisas, os usuários podem aprimorar aplicativos permitindo que possam ter integração com protocolos e aplicativos de código aberto, de DeFi a NFTs. Os usuários podem manter e gerenciar ativos públicos e movê-los entre shards privados e outras cadeias públicas sem problemas.

Além disso, os usuários estão se beneficiando de transações cross shard, que fornecem a capacidade de interagir com terceiros na cadeia pública ou outros shards corporativos autorizados. Shards privados podem interagir uns com os outros por meio de canais criptografados.

Com Calimero, as possibilidades são infinitas.
Benefícios do uso de shards privados da Calimero Network
Os shards privados do Calimero têm todos os benefícios da NEAR em termos de alto desempenho, segurança e sustentabilidade. Mas, como uma distinção importante, os shards não estão usando os validadores, a execução e o armazenamento de estado do NEAR, mas você está usando o seu próprio. Os principais benefícios incluem:

 	Escalonar  seus negócios ao ter acesso a transações gratuitas dentro do shard.
 	Fazer que toda ou parte de suas transações sejam privadas e que somente pessoas/entidades com acesso ao shard possam ver os dados contidos.
 	Compatibilidade EVM – Você pode usar DApps já construídos na Ethereum em vez de criá-los do zero.
 	Compatibilidade WASM e suporte a Javascript para facilitar a integração na Web3
 	Interoperabilidade – Os fragmentos podem se comunicar com somentea rede principal NEAR e entre si (cada fragmento pode representar uma empresa diferente ou partes da mesma empresa) e, graças à ponte, vários ativos diferentes, como tokens fungíveis e não fungíveis podem ser transferidos.
 	Personalizável, eficiente e econômico. É possível realizar até 200.000 transações por segundo (a implantação de shard padrão tem uma taxa de transferência de 5.000 transações por segundo). Tempos de bloco, tamanhos de contrato e limites de gás são personalizáveis. Transportar os ativos ou chamadas de dados são rápidos  (5 a 10 segundos) e baratos (custa somente alguns centavos).

Para quê e quem são os fragmentos privados de Calimero?
O Calimero pode ser usado:

 	Como um gateway para empresas tradicionais (web2) entrarem no mundo web3 com um painel fácil de usar para gerenciar seu shard privado.
 	Para empresas que já operam na web3 e precisam de recursos de privacidade e escalonamento de gás zero.

Em quais indústrias o Calimero pode ser usado?
Existem inúmeras formas  de uso, pois apenas a imaginação é o limite. Para fomentar  alguma inspiração, listamos alguns setores diferentes em que os shards privados atingem todo o seu potencial.

 

 	
Governos
Pense em bancos implementando casos de uso de CBDC ou KYC e anti-lavagem de dinheiro. Os dados privados são armazenados em um shard  e podem estar disponíveis quando necessário, mas ficam ocultos ao público.
 	
Fintech
Ativos digitais e tokenização de ativos financeiros, AML, KYC e identidade digital, pontuação de crédito, mercado de capitais, finanças de comércio (trade finance) , soluções de privacidade (para gestão de custódia e tesouraria)…
 	
Infraestrutura
Para empresas de energia, saúde, seguros, imobiliário, telecomunicações, cadeia de suprimentos…
Por exemplo, na cadeia de suprimentos/indústria de transporte, você pode usar o Calimero para verificar dados, acompanhar  remessas em várias empresas (cada uma com seu próprio shard ) e até mesmo comprar/vender as mercadorias enquanto ainda estão em transporte .
 	
Web3
DAOs, DeFi, CeFi – pense em todas as operações dentro deles, incluindo livro de pedidos, darkpools, gerenciamento de tesouraria e folha de pagamento de contribuidores, também em jogos, metaverso, entretenimento, publicação (arte, música, NFTs)…
Exemplo de uso de shards privados em jogos : você inicia um jogo de xadrez na rede principal. Você conecta todo o jogo a um shard privado. Nele, o jogo se desenrola GRATUITAMENTE e os movimentos ficam ocultos (a menos que você queira revelá-los). Você conecta o resultado de volta à rede principal. E voilá!

As possibilidades são infinitas! Converse com a equipe Calimero se quiser saber mais e tente executar seu próprio shard privado para acessar os inúmeros benefícios de sharding. Você pode usar o Calimero gratuitamente enquanto estiver no modo de teste. Você pode ter acesso a um shard privado para o seu projeto. Siga no Twitter para ficar por dentro de todas as novidades sobre os shards privados! Se quiser saber mais, pode ouvir as palestras que os membros da equipe Calimero tiveram na Nearcon em Lisboa (setembro de 2022).

https://www.youtube.com/watch?t=4814&v=VrK46yUEh9s&feature=youtu.be

### Multiverse Fighters - First Patch

Lista de mudanças e atualizações em Multiverse Fighters. Para jogar, você precisará ter a NEAR Wallet na testnet (rede de provas) e não se esqueça de guardar a frase semente.
Ferramentas de Desenvolvimento

 Funcionalidade implementada para designers de jogos, dando a oportunidade de:


Criar habilidades.
Criar e editar bots (inventário, deque, etc.).
Criar coisas para bots.
Ajustar o saldo sem a participação do desenvolvedor.


 A base de teste NFT foi atualizada, novos tipos de NFT foram adicionados.

Jogo / Mecânica do Jogo

 Foi adicionado um nível e nivelamento do personagem (a capacidade do jogador para  distribuir os atributos obtidos com cada nível).
 Raças (NFT) foram adicionadas ao jogo.
 A Classe e a Raça agora têm ainda mais influência no estilo de jogo:


Ao usar Classes, além das cartas, as características do jogador mudam.
Ao usar Raça, algumas características mudam para melhor e outras para pior. Exemplos de raças: Humano, Elfo, Homem-Besta.


 Foram adicionadas 2 novas classes que estão num processo de balanceamento.
 Se adicionaram novas armas e armaduras (armas de duas mãos, armaduras leves e pesadas) que agora dão-lhe características ao personagem.
 Foi implementado o poder do jogador (ou bot), o número de Tokens recebidos e a experiência em batalha, assim como a procura por um oponente, depende do poder.
 Foi implementado um mapa-múndi com mobs de vários níveis (ainda na versão de teste).
 Se adicionam 16 primeiros mobs, com habilidades especiais e diferentes níveis de dificuldade.
 Sistema de busca de batalha atualizado.

Economía / Token / NFT / Blockchain

 Economia básica lançada:


O token MFIGHT foi adicionado ao ref finance na rede de Testnet NEAR, o par NEAR/FIGHT foi criado.
Se Adicionou a capacidade de cunhar e comprar NFT para um token de jogo.


 Cada NFT possui características únicas que variam dependendo da raridade.
 Foi adicionado um contrato inteligente para o token de experiência.
 Atualização NFT implementada devido ao token de experiência e o token de jogo.
 O acúmulo de recompensas nas batalhas (token principal e token de experiência) foi implementado.
 Foi preparada uma ferramenta para geração de características NFT.

Perfil do Personagem / Guias Sociais

 O sistema de clãs está implementado de forma básica. Você pode criar um clã, fazer upload de um logotipo e convidar usuários, no futuro a funcionalidade será expandida e transferida para a blockchain.
 PEDIDOS
 Layout da página de perfil atualizado.
 Se implementaram os títulos dos jogadores (eles podem ser obtidos por atividade no projeto).
 As estatísticas PvP (Jogador contra Jogador)/PvE (jogador contra computador) foram separadas.
 Implementado o NFT favorito, agora você pode escolher o NFT que será exibido no seu perfil.
 Foi implementada a Visualização de conquistas (se recebem NFT para eventos especiais no jogo)
 Se Adicionou a visualização de lutas recentes.
 A possibilidade de reivindicação de tokens foi adicionada.
 Foi adicionado um gráfico-diagrama do jogo nas classes.
 Adicionada uma página de edição de perfil (apelido, lema, descrição e avatar).
 Foi implementado o parâmetro de decência do jogador, muda a partir do bom / mau comportamento do jogador no jogo (não se renda, não saia do jogo até o final).
 Chat de jogo implementado (básico).


Foi implementada a visualização de jogadores locais online.


 Se adicionou uma tabela de classificação (na versão de teste) com a exibição dos melhores jogadores por taxa de vitórias e outros parâmetros.
 Agora o torneio se divide em grupos para facilitar a visualização com um grande número de pessoas.
 Foi implementado um contrato inteligente para reputação (token) no jogo.
 Agora você pode ver o perfil de outros jogadores.

Website

 Funcionalidade implementada para preencher as páginas do Wiki, bem como páginas individuais no site para visualização do wiki (o trabalho no Wiki está em andamento).
 Foi implementado um sistema de notificações no site (pessoais e gerais).

Base / Servidor
Foi preparada a funcionalidade no servidor para criar análises no jogo (número de novos jogadores por datas, uso de classes, proporção de vitórias de classe, número de lutas por datas, número de tokens recebidos (básico e experiência) por datas.

### Porqué Ref v2 es mejor que Uni v3

Porqué Ref v2 es Mejor que Uni v3
Tweet +4nLEARNs
Introducción y Antecedentes
Ref Finance v2 trae el futuro del comercio a NEAR: un AMM de liquidez discretizada (DLAMM) con órdenes limitadas. Con el lanzamiento en las próximas semanas, pronto podrá disfrutar de una experiencia comercial similar a un CEX con todos los beneficios de un DEX.
TL;DR
1. El colapso de FTX subraya la necesidad de tener DEX con experiencia comercial comparable a la de un CEX.

2. Ref Finance lanza su v2, cuyos componentes principales son su AMM de liquidez discreta (DLAMM) y sus órdenes limitadas.

3. DLAMM es una versión mejorada de Uniswap v3 Concentrated Liquidity, con una entrega de liquidez más precisa, una mayor eficiencia de capital y un deslizamiento de near-cero.

4. Ref v2 también tiene órdenes limitadas incorporadas. Los operadores pueden colocar órdenes de mercado y limitadas con un deslizamiento de near-cero, lo que brinda una experiencia comercial de estilo CEX a un DEX.

5. Ref v2 se puede disfrutar más rápido y más barato que casi cualquier otro canal, gracias a la finalización rápida de NEAR (1–2 s) y comisiones insignificantes (<$0.01).

6. Liquidez discretizada AMM es un juego de suma positiva en el que tanto los LP como los traders ganan.

Con el reciente colapso de uno de los intercambios centralizados más grandes del mundo (CEX), FTX, la comunidad criptográfica se dio cuenta rápidamente de la importancia de la descentralización. La adopción de protocolos de finanzas descentralizadas(DeFi) especialmente los intercambios descentralizados (DEX), creció a medida que las personas reconocieron la necesidad de transparencia y autocustodia de sus activos.

Con los DEX más importantes que nunca, echemos un vistazo a dónde se dirigen. En este artículo, analizaremos la evolución de los DEX a través de su ejemplo insignia, Uniswap, y presentaremos la siguiente fase de su desarrollo: liquidez concentrada discretizada.
Resumen de Uniswap v1, v2 y v3
En noviembre de 2018, Uniswap v1 se lanzó principalmente como prueba de concepto. Introdujo la idea de un AMM, aprovechando las matemáticas detrás de la ecuación del producto constante, x*y=k. En ese momento, Uniswap v1 solo admitía pares comerciales ETH-ERC20 y fondos de liquidez (LP).

En mayo de 2020, se lanzó Uniswap v2 como una mejora de v1. Algunas de las principales mejoras fueron la introducción de fondos de liquidez, fondos ERC20-ERC20, un oráculo de precios TWAP descentralizado y swaps rápidos.

En mayo de 2021, se lanzó Uniswap v3. v3 introdujo innovaciones claves como Liquidez concentrada, así como seguridad mejorada, nuevos niveles de comisiones, desarrollo de Oracle Stream y liquidez no fungible. En general, la tesis principal de Uniswap v3 fue lograr una mayor eficiencia de capital para los comerciantes de plataformas y proveedores de liquidez a través del concepto de liquidez concentrada.




	

	
	
		
			
				¿Qué tipo de negociación se admitía en Uniswap v1?
			
		

		
					

		
			
			
			
			Intercambio de pares y pools de negociación  ETH-ERC20
		
			
			Pools ERC20-ERC20
		
			
			Pares comerciales y pools de negociación ETH-NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






¿Qué es la Liquidez Concentrada? ¿Qué ventajas ofrece?

A diferencia de los AMM, donde la liquidez simplemente se proporciona sin especificar un rango, la liquidez concentrada significa que los LP pueden asignar capital a sus intervalos de precios preferidos, lo que permite una eficiencia de capital significativamente mayor.

La liquidez concentrada beneficia a todas las partes: comerciantes y LP.

Los LP se benefician de la eficiencia de capital de proporcionar una gama estrecha de liquidez, que generalmente los comerciantes utilizan más, lo que, en consecuencia, puede generar hasta 4000 veces más de comisiones en comparación con Uniswap v2.

Los comerciantes, a su vez, se benefician de una mayor liquidez.

Uniswap V3 ha sido ampliamente adoptado por la criptocomunidad gracias a su nuevo modelo de liquidez concentrada. Los volúmenes de Uniswap v3 han crecido constantemente desde su lanzamiento, alcanzando rápidamente un dominio del 97,2 % sobre Uniswap v2 en términos de volumen diario.

Liquidez Discretizada en Ref v2

En asociación con iZUMi Finance y Arctic, Ref Finance se enorgullece de presentar Ref v2: el AMM de liquidez discretizada (DLAMM) con órdenes limitadas. Piense en la liquidez concentrada de Uniswap V3 solo que mejor, y ahora con la funcionalidad de orden limitada para llevar la experiencia comercial de CEX a la cadena.

AMM con Liquidez Discretizada vs AMM con Liquidez Concentrada

Discretized Liquidity es la abreviatura de DLAMM, que significa "Discretized Liquidity Automated Market Maker". Los AMM de liquidez concentrada existentes, como Uniswap v3, siguen la fórmula de producto constante (X*Y=K), donde el precio cambia continuamente con la cantidad de tokens X e Y en el grupo. Diseñado por iZUMi Finance, el AMM de liquidez discretizada utiliza una curva de producto constante continua sintética con una fórmula de suma constante discretizada (x+y=k), donde los precios se discretizan en el AMM (consulte la figura a continuación).

Esto da como resultado dos mejoras importantes para las AMM de liquidez discretizadas: deslizamiento reducido y provisión de liquidez más precisa dentro de un rango de precios.




	

	
	
		
			
				¿Qué creador de mercado se utiliza en Ref Finance?
			
		

		
					

		
			
			
			
			Liquidez Concentrada AMM
		
			
			AMM de Liquidez Discretizada
		
			
			Liquidez objetivo AMM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cómo se mejora Ref v2 sobre Uniswap V3
Ref v2 no solo muestra las mejores partes de Uniswap v3 (eficiencia de capital) con su AMM de liquidez discretizada, sino que va un paso más allá para permitir una experiencia comercial similar a un CEX que normalmente no es posible en DEX con la funcionalidad de orden limitada integrada. Y todo esto, con todas las ventajas de un DEX: transacciones end-to-end descentralizadas, seguras y transparentes para traders y proveedores de liquidez.

En Ref v2, puede...

1. Beneficiarse de una alta eficiencia de capital gracias a Liquidity Discretized AMM

Al igual que en Uni v3, Ref v2 le permite proporcionar liquidez concentrada, es decir, liquidez específica para un rango de precios. Esto significa que, como LP, puede proporcionar liquidez a un rango de precios que usted piense que los comerciantes están usando más, por ejemplo, y potencialmente cobrar comisiones significativamente más altas que antes. Como comerciante, puede beneficiarse potencialmente de una mayor liquidez en los rangos de precios que frecuenta, ya que la liquidez ya no necesita distribuirse en todo el rango.

2. Disfrute de un AMM V3 estilo Uni a una fracción de la velocidad y el costo

Al aprovechar NEAR, Ref puede ofrecer su AMM de liquidez discretizada con una finalidad increíblemente rápida (1-2 s) y a costos insignificantes (fracciones de un centavo).

3. Realizar órdenes limitadas.

Por definición, una orden limitada es una orden para comprar o vender un activo con una restricción sobre el precio máximo que paga o el precio mínimo al que vende. Esta es una característica típica de los CEX que utilizan un libro de pedidos, lo que permite a los usuarios programar órdenes dentro de su rango de precios preferido.

Actualmente, no existe una función de orden limitada adecuada en Uniswap v3. La única forma es proporcionar liquidez concentrada fuera del precio actual y, por lo tanto, imitar una orden limitada. Ref v2, por otro lado, presenta la funcionalidad de orden limitada incorporada. Ahora los usuarios pueden operar en un DEX como lo harían normalmente en un CEX.

4. Realizar órdenes limitadas sin limitación de precio

Como Uni v3 solo permite órdenes limitadas de forma indirecta, una vez que se completa la orden limitada sintética, si el precio vuelve a su punto de origen o cuando lo haga, los LP ya no pueden reclamar las ganancias de su orden porque los tokens ganados se habrían anulado. . .

En Ref v2, los usuarios pueden colocar órdenes limitadas de compra a un precio más alto que el precio actual, y el algoritmo igualará automáticamente el mejor precio. Esto ofrece además una experiencia comercial similar a un CEX.

5. Realice órdenes limitadas con deslizamiento de near-cero

Con la liquidez discretizada AMM de Ref, que aprovecha el poder de una fórmula de suma constante, los operadores no solo pueden colocar órdenes limitadas, sino que también pueden hacerlo con un deslizamiento de near-cero.

Además, cuando los comerciantes colocan órdenes limitadas en Ref v2, se convierten efectivamente en LP temporales para ese grupo en ese rango de precios. Aparte del propio modelo DLAMM de última generación, la capacidad de órdenes limitadas de Ref v2 agrega liquidez adicional a los grupos, lo que reduce aún más el deslizamiento.

6. Disfrute de una prioridad de orden limitada Y una estructura de comisiones de LP justa

La introducción del Proveedor de Liquidez de Órdenes Limitadas en Ref v2 naturalmente introduce competencia de comisiones con LP regulares que brindan liquidez concentrada. Para incentivar mejor a cada parte, las órdenes limitadas seguirán teniendo prioridad en términos de orden comercial, pero las comisiones de LP se distribuirán proporcionalmente a los proveedores de liquidez concentrada.




	

	
	
		
			
				¿Qué intercambio permite a los clientes realizar órdenes limitadas sin limitación de precio?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			1Inch
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Por qué sería importarte para TÍ?

Tldr; AMM con liquidez discretizada es un juego de suma positiva. Todos ganan en Ref V2.

 	Proveedores de liquidez: al igual que en Uni v3, los LP en Ref v2 pueden maximizar las comisiones de transacción que cobran en las transacciones al proporcionar liquidez concentrada dentro de un rango de precios específico que frecuentan los operadores. Además, los LP también reciben todas las comisiones generadas por las transacciones de órdenes limitadas. Cuando se completa una orden limitada, no es el comerciante quien recibe la tarifa de transacción, sino el LP subyacente dentro de ese rango.
 	Traders : Los comerciantes o traders ahora pueden aprovechar una mayor liquidez, así como colocar órdenes de mercado y órdenes limitadas con deslizamiento de near-cero. Cuando los comerciantes colocan órdenes limitadas, se convierten efectivamente en proveedores de liquidez, que "hacen mercados" al realizar ofertas en el intercambio.
 	Creadores de mercado activos: los creadores de mercado pueden reducir el costo de administrar LP a una tasa muy asequible (<$0.01/txn), con ganancias y pérdidas (PnL) más predecibles y una experiencia comercial más cercana a un intercambio CLOB.

“Tldr; DL-AMM es un juego de suma positiva”

### Qu'est-ce que le vote quadratique et le financement quadratique

Si vous êtes une personne intéressée par la gouvernance décentralisée, vous avez peut-être rencontré des mots tels que «vote quadratique» et «financement quadratique». Bien que certains puissent les considérer comme des mots à la mode, ces concepts ont gagné en popularité au cours des dernières années. Il y a eu plusieurs cas où les deux ont été mis en œuvre, rencontrant un degré élevé de succès. Le vote quadratique a été utilisé pour voter sur les projets gagnants lors du hackathon présidentiel taïwanais. Nous avons vu le système utilisé à nouveau lorsque le Parti démocrate du Colorado l'a utilisé pour déterminer la plate-forme de son parti. D'autre part, le financement Quadratic a été utilisé par Gitcoin Grants pour financer des biens publics dans l'écosystème Ethereum.

Les deux concepts, selon leurs partisans, ont le potentiel de révolutionner la façon dont les décisions sont prises. La mise en œuvre ultime de ces concepts pourrait être, selon les mots de Vitalik Buterin, "profondément transformatrice comme l'avènement de l'ère industrielle des marchés majoritairement libres et de la démocratie constitutionnelle". Le battage médiatique n'est pas sans raison, comme cet article l'expliquera, en examinant les deux concepts, leur application et leurs avantages.

Commençons par le vote quadratique.
Le problème des modèles de gouvernance
Les modèles de gouvernance utilisés par les plateformes blockchain deviennent de plus en plus cruciaux, avec leur capacité à avoir un impact sur la participation des utilisateurs, l'efficacité de la plateforme et l'attractivité. L'une des plus grandes préoccupations des blockchains en matière de gouvernance était le potentiel d'émergence de positions dominantes. Ces « positions dominantes » seraient constituées d'utilisateurs qui disposeraient, sous leur contrôle, d'un grand nombre de voix, voire de la majorité des voix. Cela donnerait à ce groupe d'utilisateurs un contrôle sans précédent sur les questions liées à l'évolution de la plateforme.

Une telle concentration du pouvoir de vote peut décourager les utilisateurs disposant d'un plus petit nombre de voix de participer aux mécanismes de gouvernance, voire les contraindre à quitter complètement la plateforme. La promesse et le potentiel de la technologie et des plates-formes blockchain ne peuvent être réalisés que si une attention particulière et réfléchie est accordée aux mécanismes de gouvernance de ces plates-formes. Une telle concentration des voix et du pouvoir de vote inquiéterait sans doute les autres sur la plate-forme. Cependant, une nouvelle méthode de vote, qui a récemment trouvé son utilité dans la course aux décisions sociales, apparaît comme une solution possible au dilemme qui afflige les plateformes de blockchain.
Vote quadratique : la méthode mathématique pour un vote plus équitable
Le vote quadratique est un mécanisme de prise de décision collective qui permet une meilleure voie vers la prise de décisions, en évitant la soi-disant «tyrannie de la majorité». Il a été proposé pour la première fois par l'économiste politique Glen Weyl et permet aux participants d'exprimer la direction de leurs préférences, le degré de leurs préférences et à quel point ils les ressentent. Grâce à cela, il espère résoudre le problème de la règle de la majorité et protéger les intérêts de petits groupes d'électeurs qui se soucient profondément de questions spécifiques. Le vote quadratique permet aux utilisateurs de « payer » des votes supplémentaires sur un sujet particulier, ce qui leur permet d'exprimer plus fortement leur soutien pour des questions spécifiques.

Alors qu'un sondage régulier peut demander si vous êtes d'accord ou en désaccord avec un ensemble particulier de questions, le vote quadratique donne aux électeurs un budget de « crédits de voix » qu'ils peuvent dépenser pour être d'accord ou non avec des questions. Les électeurs peuvent voter plusieurs fois, mais chaque vote suivant coûterait plus de crédits que le précédent. Ce type de mécanisme de vote peut être utilisé dans différents domaines, tels que les institutions démocratiques, la gouvernance d'entreprise et la prise de décision collective basée sur la blockchain.




	

	
	
		
			
				Le vote quadratique a été proposé pour la première fois par :
			
		

		
					

		
			
			
			
			Vitalik Buterin
		
			
			Glen Weyl
		
			
			Zoe Hitzig
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment fonctionne le vote quadratique ?
Voyons maintenant comment fonctionne le vote quadratique. Le vote quadratique est basé sur les principes du marché, chaque électeur se voyant attribuer un budget de crédits de vote qu'il peut dépenser pour influencer le résultat des délibérations clés. Si un électeur soutient ou s'oppose fortement à une décision particulière, il peut allouer des votes supplémentaires pour démontrer le niveau de son soutien ou de son opposition à une décision spécifique. Le coût des votes supplémentaires est déterminé par une règle de tarification des votes, chaque vote devenant plus cher que le précédent. L'augmentation du coût du crédit des électeurs démontre le degré de soutien ou d'opposition à une décision particulière.

Le vote quadratique utilise une formule simple, coût pour l'électeur = (nombre de votes)2

Comprenons mieux cela à l'aide d'un exemple. Supposons qu'un électeur dispose d'un budget de 16 crédits de vote et a la liberté d'utiliser un crédit pour 16 questions différentes sur lesquelles il peut voter. Cependant, si l'électeur se sent plus fortement sur une question particulière, il peut allouer quatre votes à cette question au prix de l'ensemble de son budget. Les quatre votes coûtent tous les 16 crédits de vote parce que le coût de chaque vote supplémentaire devient plus cher de manière quadratique. Ainsi, 1 vote coûterait 1 crédit, 2 votes en coûteraient 4, 3 votes en coûteraient 9 et le 4e vote en coûterait 16.

Ce mécanisme a été considéré comme une solution potentielle pour résoudre les problèmes de gouvernance rencontrés par les plateformes et les communautés de blockchain, empêchant un seul groupe de prendre le relais tout en protégeant les intérêts des groupes minoritaires. Les jetons émis en tant que votes sont redistribués équitablement entre les électeurs à la fin de chaque cycle de gouvernance. Il faudrait à un groupe plusieurs cycles de vote et des coûts importants pour prendre le contrôle d'une plateforme.

Mais comment le vote quadratique se compare-t-il aux autres mécanismes de vote établis ? Il existe trois autres grands mécanismes de vote démocratique,

 	Systèmes de pluralité
 	Systèmes de représentation proportionnelle
 	Systèmes semi-proportionnels

Systèmes de pluralité
Dans les systèmes de vote à la pluralité, le parti ou la position qui reçoit le plus de voix remporte l'élection, en s'appuyant sur le mécanisme « une voix, un électeur ». Cependant, les systèmes de vote à la pluralité ne peuvent pas garantir que les électeurs peuvent exprimer leur niveau de soutien à une cause ou à une question particulière ni allouer leurs votes pour exprimer le degré de soutien.
Systèmes de représentation proportionnelle
Cette méthode de vote est principalement observée dans les législatures nationales, où elle garantit que la division d'un organe élu reflète la répartition des voix dans l'électorat. Bien que cette méthode de vote reflète mieux le point de vue des électeurs, elle ne représente pas le degré de conviction des électeurs quant à leur position sur les questions.
Systèmes semi-proportionnels
Il existe plusieurs types de systèmes de vote semi-proportionnels. Cependant, aucun de ces facteurs n'explique le degré de préférence ou d'opposition des électeurs aux questions.
Financement quadratique : une nouvelle façon de financer les biens publics
Passons au financement quadratique. Le financement quadratique est l'une des expériences socio-économiques les plus innovantes issues de l'écosystème crypto. Il a été présenté comme un moyen mathématiquement optimal de financer les biens publics dans les communautés démocratiques en amplifiant les dons faits par une grande communauté par rapport aux contributions faites par des groupes plus petits aux poches profondes. Mais qu'est-ce qu'un bien public ?

Les biens publics sont définis comme des biens ou des services qui sont disponibles pour tous les membres de la société. Ces marchandises doivent avoir les qualités suivantes.

 	Non rival - Cela signifie que l'utilisation de ces biens par un membre ne diminue pas sa disponibilité pour les autres membres.
 	Non exclusif – Ces biens doivent être accessibles à tous.

Le financement quadratique a été décrit par Vitalik Buterin, Zoe Hitzig et Glen Weyl dans un document de recherche publié en 2018. Cependant, pour des raisons de compréhension, nous devrions simplifier le concept. La force motrice derrière le financement Quadratic est son pool de contrepartie, un pool de fonds fournis par des individus, des entreprises et des protocoles collectivement connus sous le nom de partenaires de contrepartie. Les fonds collectés dans le pool de contrepartie sont utilisés pour amplifier les contributions de projets individuels. Passons en revue un exemple rapide pour mieux comprendre le concept.

Supposons que nous ayons 10 000 $ dans un pool de contrepartie et trois projets participant à un cycle de financement. Le projet A reçoit un financement de 1 000 $ de la part de 5 contributeurs qui offrent 200 $ chacun. Le projet B reçoit 1 000 $ de 2 contributeurs, chacun offrant 500 $. Le projet C reçoit également 1 000 $, mais de 20 contributeurs, chacun offrant 50 $. Désormais, les montants correspondants sont calculés à l'aide de la formule de financement quadratique. Selon la formule, le premier projet reçoit 1 851,85 $ supplémentaires, 185 % de plus que le montant contribué. Le deuxième projet reçoit 740,74 $, soit 74 % supplémentaires du total des contributions, tandis que le troisième reçoit 7 407,41 $ du financement de contrepartie, soit 740 % de la contribution initiale.

Regardons comment la formule arrive à ces valeurs.

 	Des particuliers, des entreprises et des protocoles contribuent aux projets (A, B, C).
 	Commençons par le projet A. Une fois le cycle de financement terminé, la racine carrée de chaque contribution a été ajoutée et la somme résultante a été élevée au carré. Supposons qu'il s'agit de la variable de financement quadratique.
 	Le processus exact est répété pour les projets B et C.
 	La part du pool du projet A est calculée comme la moyenne pondérée de sa variable de financement quadratique.
 	Les projets B et C ont également reçu leur part du pool en suivant le même modèle mathématique.

Avantages du financement quadratique
Le financement quadratique aide à résoudre un problème appelé la « tragédie des biens communs ». Il s'agit d'un problème économique où chaque individu est incité à consommer des ressources au détriment des autres, sans aucun moyen d'empêcher quiconque de consommer la ressource, ce qui entraîne une surconsommation et un épuisement des ressources. Le financement quadratique met l'accent sur le nombre de dons plutôt que sur la taille du don. Les projets apportant plus de dons sont représentatifs de biens publics au service d'un plus grand groupe d'utilisateurs, ce qui rend la tragédie des biens communs plus grave.

En conséquence, les projets desservant un groupe plus étendu sont supposés être soutenus par plus de donateurs, ce qui entraîne des dons plus élevés de la part du pool de contrepartie. C'est pourquoi le projet C a reçu le financement de contrepartie le plus élevé dans notre exemple précédent.




	

	
	
		
			
				Le financement quadratique met l'accent sur lequel des éléments suivants ?:
			
		

		
					

		
			
			
			
			Le nombre de dons
		
			
			La taille des dons
		
			
			les deux ci-dessus
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cas d'utilisation du vote quadratique et du financement quadratique
La législature de l'État du Colorado a utilisé le vote quadratique pour décider quels projets de loi de crédits doivent être financés par la maison en premier. Les législatures étant plus susceptibles de parrainer leurs propres projets de loi et de voter pour ceux-ci, les démocrates ont utilisé le vote quadratique pour déterminer quels projets de loi bénéficiaient d'un soutien général. Chaque législature a reçu un budget de 100 crédits, où un vote leur coûterait un jeton. Cependant, les législatures pourraient émettre plus de votes sur une question, le coût de chaque vote augmentant de manière quadratique, comme indiqué ci-dessous.

Le hackathon présidentiel taïwanais a également été jugé par vote quadratique.

En ce qui concerne le financement quadratique, l'exemple le plus frappant est celui de Gitcoin, qui utilise la méthode pour collecter des fonds. Gitcoin permet à la communauté de créer et de financer des projets et a soutenu divers projets, notamment Uniswap, Finematics, Kickback et autres. Vitalik Buterin utilise Gitcoin Grants pour découvrir de nouveaux projets, tandis qu'Andre Cronje l'a utilisé pour financer Yearn Finance.




	

	
	
		
			
				Où le concept de vote quadratique a-t-il été mis en pratique ?
			
		

		
					

		
			
			
			
			Assemblée législative de l'État du Colorado
		
			
			Le hackathon présidentiel taïwanais
		
			
			Parti Volt allemand lors de son deuxième congrès
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Emballer
Traditionnellement, les démocraties modernes ont utilisé la méthode une personne, un vote, tandis que les entreprises ont adopté des mécanismes de vote légèrement plus sophistiqués. Cependant, des systèmes de vote plus démocratiques, tels que le vote préférentiel et le vote proportionnel, n'ont pas réussi à gagner du terrain en raison de la complexité en cause. Le vote quadratique, en permettant aux électeurs d'exprimer leurs préférences et l'intensité de ces préférences, aide à protéger les intérêts de petits groupes au sein des communautés.

Le financement quadratique, bien qu'il s'agisse d'un concept relativement nouveau, a eu un impact considérable, avec plus de 2 millions de dollars distribués aux biens publics. Un nombre croissant de projets explorent le financement quadratique, les principaux étant Gitcoin Grants, clr.fund et Downtown Stimulus. Cependant, les deux concepts ont le potentiel de changer radicalement la façon dont les protocoles de blockchain sont régis et financés.




	

	
	
		
			
				Quels sont les projets les plus importants explorant le financement Quadratic ?
			
		

		
					

		
			
			
			
			Gitcoins grants
		
			
			Clr.fund
		
			
			DownTown Stimulus
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Maintenant, essayons IRL - demandez à votre quadratique de dire, (L)Earner !

Ce guide vous aide-t-il à comprendre le vote quadratique ? (obligatoire)

 	Oui
 	Non
 	Je ne sais même pas ce que cela signifie

Vote quadratique avec nLEARNs (obligatoire)

 	1 nLEARN (UNE voix)
 	 4 nLEARN (DEUX voix)
 	16 nLEARN (QUATRE voix)

### Qu'est-ce que le Near-social ?

Near Social  (anciennement connu sous le nom de  Social08 ) est un protocole de données sociales construit au-dessus du protocole NEAR.

Veuillez rejoindre  le groupe Telegram @NearSocial  pour des discussions.

Regarder la présentation  Near Social à NEARCON22

Explorez Near Social :  near.social
Liens
Github :  https://github.com/NearSocial

Twitter :  @NearSocial_

Télégramme :  @NearSocial

Contrat SocialDB :

 	Source :  https://github.com/NearSocial/social-db
 	Réseau principal : social.near
 	Réseau de test : v1.social08.testnet

Normes :  https://github.com/NearSocial/standards

Navigateur du Near social :

 	Source :  https://github.com/NearSocial/viewer
 	Réseau principal :  https://near.social/
 	Réseau test :  https://test.near.social/

Si vous recherchez un réseau social basé sur mastodon pour les  .near utilisateurs, consultez un article sur  mastodon.near.social
SocialDB
SocialDB est un contrat intelligent pour stocker des données sociales sur le protocole NEAR.

 	Code source :  https://github.com/NearSocial/social-db
 	API :  https://github.com/NearSocial/social-db#api
 	ID de compte Testnet : v1.social08.testnet
 	ID de compte principal : social.near

Get API
Prend une liste de clés et renvoie un objet JSON joint avec les données correspondantes.


 	keys - un tableau de modèles de clé à renvoyer.

Lecture d'un profil de compte self.social.near
Pour lire tous les champs de manière récursive pour un chemin donné, ajoutez un  ** suffixe.



Renvoie l'objet JSON agrégé.


Lecture des noms de tous les comptes avec des profils
Notez que cette requête itère sur tous les comptes et ne rentrera plus dans le gaz d'appel de vue disponible à l'avenir.




API de clés
Prend une liste de clés et renvoie un objet JSON joint avec les clés correspondant à la requête.



 	keys - un tableau de modèles de clé à renvoyer.

Renvoie l'objet JSON agrégé.
Obtenir une liste de widgets de comptes root.near



Obtenir une liste des comptes qui ont des widgets


Notez que cette requête itère sur tous les comptes et ne rentrera plus dans le gaz d'appel de vue disponible à l'avenir.


Normes
Les données de SocialDB sont organisées sous la forme d'un simple arbre JSON. La seule règle appliquée est que les clés de la racine sont les ID de compte qui stockent les données. Ceci est fait exprès, de sorte que le contrat SocialDB n'applique aucune structure ou schéma. Sinon, le contrat doit être modifié à chaque changement de schéma. La maîtrise des schémas contractuels peut conduire à la centralisation et aux restrictions. Au lieu de cela, les normes sociales proches vivent en dehors du contrat SocialDB.

Actuellement,  Standards sur Github  est l'endroit par défaut pour les normes, mais cela pourrait changer à l'avenir.
Description du schéma

 	bold signifie que la clé est requise.
 	italic signifie que la clé est facultative.
 	[account_id] signifie que la clé dynamique est un ID de compte. Par exemple,  alex.near comme clé. Il était généralement utilisé pour créer un avantage vers ce compte.

Schéma racine
Chaque compte doit suivre leschéma racine
Widget
Les widgets sont des composants composables réutilisables pour Near Social.

Vous pouvez afficher et créer des widgets sur  near.social .

Par exemple, un  widget d'explorateur de données  vous permet d'explorer les données brutes de SocialDB.


Open source avec contrôle de version
Le code source de chaque widget est stocké ouvertement dans SocialDB. Le propriétaire du widget a la possibilité de mettre à jour le widget en mettant à jour le code source. Mais parce que SocialDB est stocké sur une blockchain, toutes les versions précédentes du widget sont également disponibles. Cela permet un contrôle de version automatique pour chaque widget.
Bifurcation
Si vous connaissez GitHub, vous savez que vous pouvez dupliquer n'importe quel référentiel public pour créer votre version locale. De même, vous pouvez bifurquer n'importe quel widget directement à partir de l'interface utilisateur near.social.



Forking crée une copie du code source du widget, mais sous votre compte. Il permet à chacun de modifier les widgets existants. Une fois que vous enregistrez le nouveau widget, il devient immédiatement disponible. Et tout le monde peut désormais voir et bifurquer votre version du widget.
Il s'agit principalement d'une interface utilisateur pour créer des demandes d'extraction, afin que les utilisateurs puissent fusionner les modifications d'autres forks. Actuellement, il doit être fait manuellement.
Langage de programmation
Les widgets sont implémentés dans une version limitée de JSX (un JavaScript avec ReactJS). Le code est exécuté dans une machine virtuelle personnalisée pour créer un bac à sable sécurisé. Cela garantit que les widgets ne peuvent pas accéder au stockage local ou aux cookies.

### What is your favorite NEAR wallet

qVote for your favorite NEAR wallet! 
            
                748 votes by,
                1660 nLEARNs spent
            
            
            
                                    
                        
                            Wallet.near.org                            
                                (204 votes,
                                452 nLEARNs)
                            
                        
                        
                             
                            27%
                        
                    
                                    
                        
                            My NEAR Wallet                            
                                (162 votes,
                                316 nLEARNs)
                            
                        
                        
                             
                            22%
                        
                    
                                    
                        
                            Sender wallet                            
                                (19 votes,
                                33 nLEARNs)
                            
                        
                        
                             
                            3%
                        
                    
                                    
                        
                            HERE wallet                            
                                (297 votes,
                                687 nLEARNs)
                            
                        
                        
                             
                            40%
                        
                    
                                    
                        
                            Meteor wallet                            
                                (66 votes,
                                172 nLEARNs)
                            
                        
                        
                             
                            9%

### Toolblox, конструктор смарт-контрактов без кода

Toolblox — это конструктор смарт-контрактов и децентрализованных приложений без кода. В этом гайде мы попытаемся рассказать — что мы делаем и почему это важно.

Toolblox Workflow Builder и автоматически сгенерированный пользовательский интерфейс
Краткая история
Проект стартовал в начале 2022 года как вход на хакатон Near Metabuild II. Ему удалось выиграть главный приз, который послужил стартовым капиталом. В течение года Toolblox выигрывал и другие призы, такие как «Лучший инструментарий и инфраструктура» на хакатоне Polygon BUIDL IT.

Начиная с первой версии пользовательский интерфейс был упрощен в 10 раз, а также был добавлен конструктор DApp. Хотя изначально он поддерживал только один блокчейн, было добавлено еще пять.

Toolblox скоро исполнится 1 год и мы собираемся поделиться им со всем миром.
Самоисполняющиеся смарт-контракты
Смарт-контракты — это самоисполняющиеся соглашения, закодированные в виде компьютерных программ. При срабатывании определенного триггера они могут немедленно предпринять какие-либо действия, например произвести оплату или передать право собственности. Это возможно, потому что в блокчейне нет необходимости в центральном органе, используются цифровые подписи, а состояние программы неизменно.

Таким образом, самоисполняющиеся смарт-контракты обладают уникальными возможностями:

 	Внедрите доверие, справедливость и прозрачность в любую существующую систему или процесс.
 	Исключите посредников и централизованное агентство.
 	Управляйте разнообразным набором рабочих процессов — от обычных магазинов до цепочек поставок и цифровых организаций, называемых децентрализованными автономными организациями или DAO.

Смарт-контракты будут повсеместно распространены, обеспечивая работу бизнес-сетей будущего. Они могут и должны заменить основу любых и всех централизованных продуктов управления бизнес-процессами SaaS.
Наш метод
Toolblox предоставляет сверхпростой конструктор смарт-контрактов на основе рабочего процесса, который помогает компаниям быстро создать свое присутствие в блокчейне: создать рабочий процесс и развернуть его как полезное приложение.

 	
Нет кода


Всегда можно инвестировать в команду разработчиков или нанять профессионалов для кодирования пользовательского рабочего процесса. Но для остальных — 90% малых и микропредприятий, некоммерческих организаций, DAO и т. д. — которые просто хотят сосредоточиться, визуальный подход без кода — это то, что нужно. Меньше предварительных инвестиций, больше гибкости, быстрое прототипирование и более быстрый выход на рынок.

 	
Автоматический рабочий процесс


Блокчейн — это не данные, а состояние, особенно переходы между состояниями — узлы, где передается ценность — будь то реальные деньги, право собственности или и то, и другое. Это сердце любого бизнес-процесса или контракта. Автоматический рабочий процесс, предложенный Hyperledger Foundation, отлично подходит для визуализации смарт-контрактов. Узнать больше о нашем конструкторе рабочих процессов.

 	
Пользовательский интерфейс из коробки


Здорово иметь возможность легко запускать пользовательские смарт-контракты,но они также должны быть пригодными для использования — будь то обмен с конечными пользователями или привлечение деловых партнеров. Вот почему Toolblox автоматически создает простое приложение. Для более сложных пользовательских интерфейсов и настройки у нас есть конструктор DApp, который позволяет создавать децентрализованные приложения без какого-либо кода. Узнать больше о конструкторе DApp.

 	
Интеграция с экосистемой


Множество вариантов интеграции с внешними сервисами (например, страхование токенов, залог, порталы NFT, фракционирование и т. д.):

 	любой рабочий процесс можно сделать совместимым с ERC721
 	Токены ERC20 (например, USDT, USDC, EURC и т. д.) можно использовать в качестве платежей.
 	события блокчейна можно использовать для дальнейшей интеграции
 	децентрализованная интеграция с социальными сетями

Для кого это?

 	Децентрализованные автономные организации, которые хотят управлять пользовательскими рабочими процессами и проектами.
 	Цепочка поставок и отрасли, связанные с сырьевыми товарами, для решения различных задач, от производства до розничной торговли.
 	Малые и микропредприятия, которым не хватает специализированных ноу-хау и которым было бы полезно комплексное решение (состояние, логика и платежи).

Зачем использовать Toolblox?
Вот несколько способов применить Toolblox в любой организации:

 	Инструмент цифровизации — для построения бизнес-процесса по цепочке и совместного использования приложения с пользователями и партнерами.
 	Инструмент быстрого прототипирования — для создания полезных и общедоступных DApp для решения конкретной проблемы.
 	Кикстартер разработки — создание черновика смарт-контракта, а затем его дальнейшее развитие с помощью пользовательских ресурсов.
 	Магистраль к существующему продукту — для подключения существующего продукта к использованию блокчейна в качестве единого источника неизменяемых и безопасных данных о состоянии.

Примеры рабочего процесса
Вот несколько рабочих процессов/DApps, созданных с помощью Toolblox. Каждый рабочий процесс состоит из следующих элементов:

 	Элемент (проект, документ, предложение, предложение и т. д.)
 	Атрибуты элемента (название, крайний срок, автор, владелец, клиент и т. д.)
 	Статусы рабочего процесса (активен, отменен, ожидает отзыва и т. д.)
 	Переходы между состояниями (изменение, оплата, создание, согласие, обновление и т. д.)

Все следующие проекты можно использовать в качестве DApp и шаблонов для создания новых смарт-контрактов.
Сбор средств DAO для проектов

Сводка по сбору средств DAO (toolblox.net)
Распределенный свадебный реестр

Сводка Распределенного реестра свадеб (toolblox.net)
Спроси меня о чем угодно (АМА) с наградой

Сводка по платформе AMA с примером вознаграждения (toolblox.net)
Рабочий процесс оценки недвижимости

Сводка процесса оценки стоимости недвижимости (toolblox.net)
Цены на 3D-печать и управление печатью

Сводка реестра предложений 3D-печати (toolblox.net)

Посетите наш веб-сайт www.toolblox.net и наш Twitter , чтобы найти больше примеров! Также присоединяйтесь к academy.toolblox.net, чтобы получать учебные пособия и документацию о том, как строить с помощью Toolblox.

### Pourquoi Ref v2 est Meilleur que Uni v3

Introduction et Contexte
Ref Finance v2 apporte l'avenir du trading à NEAR : un AMM à liquidité discrétisée (DLAMM) avec des ordres à cours limité. Lancé dans les semaines à venir, vous pourrez bientôt profiter d'une expérience de trading de type CEX avec tous les avantages de DEX.
TL;DR
1. L'effondrement de FTX souligne le besoin de DEX avec une expérience commerciale comparable à celle des CEX.

2. Ref Finance lance sa v2, dont les principaux composants sont son AMM de liquidité discrétisée (DLAMM) et ses ordres à cours limité.

3. DLAMM est une version améliorée de la liquidité concentrée d'Uniswap v3, avec un apport de liquidité plus précis, une efficacité accrue du capital et un glissement near-źero.

4. Ref v2 a également des ordres à cours limité intégrés. Les traders peuvent passer des ordres au marché et à cours limité avec un glissement  de near-zéro, apportant une expérience de trading de style CEX sur un DEX.

5. Ref v2 peut être apprécié plus rapidement et moins cher que presque n'importe quelle autre chaîne, grâce à la finalité rapide de NEAR (1–2s) et aux frais négligeables (<0,01 $).

6. Liquidité discrétisée AMM est un jeu à somme positive où les LP et les traders gagnent tous les deux.

Avec l'effondrement récent de l'un des plus grands échanges centralisés au monde (CEX), FTX, la communauté crypto a rapidement pris conscience de l'importance de la décentralisation. L'adoption des protocoles de finance décentralisée(DeFi) en particulier les échanges décentralisés (DEX), s'est développée à mesure que les gens reconnaissaient le besoin de transparence et d'auto-garde sur leurs actifs.

Les DEX étant plus importants que jamais, examinons où ils se dirigent. Dans cet article, nous analyserons l'évolution des DEX à travers son exemple phare, Uniswap, et présenterons la prochaine phase de son développement : liquidité concentrée discrétisée.
Récapitulatif d'Uniswap v1, v2 et v3
En novembre 2018, Uniswap v1 a été lancé principalement comme preuve de concept. Il a introduit l'idée d'un AMM, tirant parti des mathématiques derrière l'équation du produit constant, x * y = k. À l'époque, Uniswap v1 ne prenait en charge que les paires de négociation ETH-ERC20 et les pools de liquidité (LP).

En mai 2020, Uniswap v2 a été lancé en tant qu'amélioration de la v1. Certaines des principales améliorations ont été l'introduction de pools de liquidités, de pools ERC20-ERC20, d'un oracle de prix TWAP décentralisé et de flash swaps.

En mai 2021, Uniswap v3 a été lancé. La v3 a introduit des innovations clés telles que la liquidité concentrée, ainsi qu'une sécurité améliorée, de nouveaux niveaux de frais, le développement de flux oracle et une liquidité non fongible. Dans l'ensemble, la thèse principale d'Uniswap v3 était d'obtenir une meilleure efficacité du capital pour les commerçants de la plateforme et les fournisseurs de liquidité grâce au concept de liquidité concentrée.




	

	
	
		
			
				Quel type de trading était pris en charge sur Uniswap v1 ?
			
		

		
					

		
			
			
			
			Paires et pools de négociation ETH-ERC20
		
			
			Pools ERC20-ERC20
		
			
			Paires et pools de trading ETH-NEAR
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Qu'est-ce que la liquidité concentrée ? Quels bénéfices apporte-t-il ?

Contrairement aux AMM, où la liquidité est simplement fournie sans spécifier de fourchette, la liquidité concentrée signifie que les LP peuvent allouer le capital à leurs intervalles de prix préférés, ce qui permet une efficacité du capital nettement plus élevée.

La liquidité concentrée profite à toutes les parties : traders et LPs.

Les LP bénéficient de l'efficacité du capital en fournissant une gamme étroite de liquidités, généralement plus utilisées par les traders, qui peuvent par conséquent générer jusqu'à 4000 fois plus de frais par rapport à Uniswap v2.

Les commerçants, à leur tour, bénéficient de la liquidité plus profonde

Uniswap V3 a été fortement adopté par la communauté crypto grâce à son nouveau modèle de liquidité concentrée. Les volumes d'Uniswap v3 ont augmenté sans arrêt depuis son lancement, atteignant rapidement une domination de 97,2 % sur Uniswap v2 en termes de volume quotidien.

Liquidité Discrétisée sur Ref v2

En partenariat avec iZUMi Finance et Arctic, Ref Finance est fier de présenter Ref v2 : le Discretized Liquidity AMM (DLAMM) avec ordres à cours limité. Pensez à la liquidité concentrée d'Uniswap V3 mais en mieux, et maintenant avec la fonctionnalité d'ordre à cours limité pour apporter l'expérience de trading CEX en chaîne.

AMM à Liquidité Discrétisée vs AMM à Liquidité Concentrée

La liquidité discrétisée est l'abréviation de DLAMM, qui signifie « créateur de marché automatisé de liquidité discrétisée ». Les AMM à liquidité concentrée existants, tels que Uniswap v3, suivent la formule du produit constant (X * Y = K), où le prix change continuellement avec la quantité de jetons X et Y dans le pool. Conçu par iZUMi Finance, l'AMM à liquidité discrétisée utilise une courbe de produit constante continue synthétique avec une formule à somme constante discrétisée (x+y=k), où les prix sont discrétisés dans l'AMM (voir figure ci-dessous).

Cela se traduit par deux améliorations majeures pour les AMM de liquidité discrétisés : un glissement réduit et une fourniture de liquidité plus précise dans une fourchette de prix.




	

	
	
		
			
				Quel teneur de marché est utilisé dans Ref Finance ?
			
		

		
					

		
			
			
			
			Liquidité Concentrée AMM
		
			
			AMM de Liquidité Discrétisée
		
			
			Liquidité Ciblée AMM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment Ref v2 S'Améliore Sur Uniswap V3
Ref v2 présente non seulement les meilleures parties d'Uniswap v3 (efficacité du capital) avec son AMM à liquidité discrétisée, mais va encore plus loin pour permettre une expérience de trading de type CEX normalement impossible sur les DEX avec une fonctionnalité d'ordre limite intégrée. Et tout cela, avec tous les avantages d'un DEX : des transactions de bout en bout décentralisées, sécurisées et transparentes pour les traders et les fournisseurs de liquidités.

Sur Ref v2, vous pouvez..

 	Bénéficiez d'une haute efficacité du capital grâce à l'AMM Discrétisé Liquidité

Tout comme sur Uni v3, Ref v2 vous permet de fournir une liquidité concentrée - c'est-à-dire liquidité spécifique à une fourchette de prix. Cela signifie qu'en tant que LP, vous êtes en mesure de fournir des liquidités à une fourchette de prix que vous pensez que les commerçants utilisent davantage, par exemple, et de percevoir potentiellement beaucoup plus de frais qu'auparavant. En tant que trader, vous pouvez potentiellement bénéficier d'une liquidité plus importante dans les fourchettes de prix que vous fréquentez, car la liquidité n'a plus besoin d'être répartie sur toute la fourchette.

2. Profitez d'un AMM de style Uni V3 à une fraction de la vitesse et des coûts

En tirant parti de NEAR, Ref est en mesure d'offrir son AMM de liquidité discrétisé avec une finalité incroyablement rapide (1 à 2 s) et à des coûts négligeables (fractions de centime).

3. Passez des ordres à cours limité

Par définition, un ordre à cours limité est un ordre d'achat ou de vente d'un actif avec une restriction sur le prix maximum à payer ou le prix minimum auquel vous vendez. Il s'agit d'une caractéristique typique des CEX qui utilisent un carnet de commandes, qui permet aux utilisateurs de programmer des commandes dans leur fourchette de prix préférée.

Actuellement, il n'y a pas de fonction d'ordre limite appropriée sur Uniswap v3. Le seul moyen est de fournir une liquidité concentrée en dehors du prix actuel et ainsi d'imiter un ordre à cours limité. Ref v2, d'autre part, introduit une fonctionnalité d'ordre limite intégrée. Désormais, les utilisateurs peuvent échanger sur un DEX comme ils le feraient normalement sur un CEX

4. Passez des ordres à cours limité sans limitation de prix

Comme Uni v3 n'autorise les ordres à cours limité que de manière détournée, une fois l'ordre à cours limité synthétique rempli, si ou lorsque le prix revient à son point d'origine, les LP ne sont plus en mesure de réclamer leurs gains de commande car les jetons gagnés auraient été annulés. .

Sur Ref v2, les utilisateurs peuvent placer des ordres d'achat à cours limité à un prix supérieur au prix actuel, et l'algorithme correspondra alors automatiquement au meilleur prix. Cela offre en outre une expérience de trading similaire aux CEX.

5. Passez des ordres à cours limité avec un glissement NEAR-zero

Grâce à la liquidité discrétisée AMM de Ref, qui exploite la puissance d'une formule à somme constante, les traders peuvent non seulement passer des ordres à cours limité, mais le faire avec un glissement  de near-zéro.

De plus, lorsque les traders passent des ordres à cours limité sur Ref v2, ils deviennent effectivement des LP temporaires pour ce pool dans cette gamme de prix. Outre le modèle DLAMM de pointe lui-même, la capacité d'ordre limite de Ref v2 ajoute efficacement des liquidités supplémentaires dans les pools, réduisant ainsi encore plus le glissement.

6. Bénéficiez d'une priorité d'ordre limité ET d'une structure de frais LP équitable

L'introduction du fournisseur de liquidité par ordre limité sur Ref v2 introduit naturellement une concurrence sur les frais avec les LP réguliers qui fournissent une liquidité concentrée. Afin d'inciter au mieux chaque partie, les ordres limités seront toujours priorisés en termes d'ordre de transaction, mais les frais de LP seront distribués proportionnellement aux fournisseurs de liquidité concentrés.




	

	
	
		
			
				Quelle bourse permet aux clients de passer des ordres à cours limité sans limitation de prix ?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			1Inch
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pourquoi devriez-vous VOUS en soucier ?

Tldr ; L'AMM à liquidité discrétisée est un jeu à somme positive. Tout le monde y gagne sur Ref V2.

 	Fournisseurs de liquidité : Comme sur Uni v3, les LP sur Ref v2 peuvent maximiser les frais de transaction qu'ils perçoivent sur les transactions en fournissant une liquidité concentrée dans une fourchette de prix spécifique que les traders fréquentent. En outre, les LP reçoivent également tous les frais générés par les transactions d'ordres à cours limité. Lorsqu'un ordre à cours limité est rempli, ce n'est pas le trader qui reçoit les frais de transaction, mais plutôt le LP sous-jacent dans cette fourchette.
 	Traders : les traders peuvent désormais profiter d'une liquidité plus importante, ainsi que passer des ordres de marché et des ordres à cours limité avec un glissement de near-zéro. Lorsque les traders passent des ordres à cours limité, ils deviennent effectivement des fournisseurs de liquidités, qui « créent des marchés » en plaçant des offres sur la bourse.
 	Teneurs de marché actifs : les teneurs de marché peuvent réduire le coût de la gestion des LP à un taux très abordable (< 0,01 $/txn), avec des profits et pertes (PnL) plus prévisibles et une expérience de négociation plus proche d'un échange CLOB.

“Tldr; DL-AMM est un jeu à somme positive”

### Le guide du financement PembRock

Le guide du financement PembRockProfitez des avantages de LYF avec PembRock

Introduction
Dans ce guide, nous examinons les moyens les plus répandus de gagner avec DeFi - Yield Farming, le Lending et le Staking - à travers l'objectif de PembRock, la première et la seule plate-forme LYF sur le protocole NEAR qui est alimentée par Ref.finance DEX.

Commençons par les bases.
Qu'est-ce que le Yield Farming ?
Pour que tout projet de financement décentralisé fonctionne, il doit y avoir des liquidités. La liquidité est ce qui rend les transactions possibles, et les participants qui rendent les plateformes liquides sont appelés fournisseurs de liquidité, ou LP. Maintenant, pour cela, ils sont récompensés par les jetons LP d'un pool particulier (également appelés «actions») via un processus connu sous le nom d'extraction de liquidités. Ces jetons représentent la part de l'utilisateur dans la liquidité totale, qui à son tour détermine ses bénéfices potentiels.

Le Yield Farming est une incitation supplémentaire qui récompense les utilisateurs pour le fait même de verrouiller leurs fonds afin que d'autres participants puissent les utiliser pour gagner leur vie. Après avoir reçu les jetons LP, un fournisseur de liquidités peut les placer dans un yield farming pool pour devenir agriculteur. Pour cela, ils recevront des paiements supplémentaires dans la crypto native de la plate-forme (dans le cas de Ref.finance, ce serait $REF ; dans le cas de PembRock, ce serait $PEM ; et ainsi de suite) ou une crypto-monnaie différente (par exemple, USDT), selon les règles d'un programme farming donné.
Qu'est-ce que le Yield Farming à l’effet de levier ?
Avec un Yield farming régulier, vous ne pouvez fournir que le montant dont vous disposez, ce qui semble logique. Et si vous vouliez maximiser les rendements (et les risques, ne l'oubliez pas) ? Dans ce cas, vous auriez besoin d'emprunter des fonds à d'autres, et c'est ce que le Yield Farming à l’effet de levier vous aide à faire.

Alors que de nombreuses plates-formes DeFi exigent que les utilisateurs mettent des fonds d'une valeur supérieure à ceux empruntés (ce qui est également connu sous le nom de surdimensionnement), PembRock ne le fait pas, donnant aux agriculteurs la possibilité de retirer le montant jusqu'à trois fois plus important.

Ainsi, si vous décidiez, par exemple, de fournir 100 USN en garantie et d'emprunter 200 USN, vous auriez 300 USN au total, ce qui signifie que le niveau d'endettement serait de 3 à un ratio d'endettement de 67 %. Si le prix de l'USN baissait de plus de 31 %, cela signifierait que votre perte ne pourrait plus être couverte. C'est alors que la liquidation aurait lieu.

Qu'est-ce que le Lending (prêt) ?
Le Lending est une stratégie qui vous permet de gagner des intérêts en laissant quelqu'un d'autre utiliser votre argent. Dans le même temps, contrairement aux agriculteurs, les prêteurs ne sont pas sujets au risque de liquidation (par exemple, pensez à une situation où l'un des actifs d'un pool tombe à 0 $), tandis que leurs rendements sont auto-composés et payés régulièrement. base. Cela semble juste, non ?
Avant de commencer
Rendez-vous sur app.pembrok.finance  et appuyez sur le bouton Connect wallet  que vous verrez dans le coin supérieur droit. La fenêtre de sélection de portefeuille apparaîtra ; choisissez celui que vous préférez. Après cela, vous serez redirigé vers votre portefeuille, où vous devrez activer certains droits d'accès et autoriser l'application PembRock à dépenser une partie de votre NEAR pour couvrir les frais de transaction. Yield Farming avec l’effet de levier.

Pour cultiver un yield avec l’effet de levier, vous devrez d'abord charger votre portefeuille avec l'asset avec lequel vous souhaitez le faire.

Étape 1.  Accédez à la section Ferme  : app.pembrock.finance/farm .

Étape 2.  Sélectionnez la paire et cliquez sur Ferme .

Étape 3.  Choisissez l'asset que vous souhaitez déposer, celui que vous souhaitez emprunter, leurs montants et l'effet de levier (entre 1x et 3x avec un incrément de 0,5).

Étape 4.  Cliquez sur Ferme  et confirmez la transaction. Veuillez noter que vous pouvez avoir plusieures positions farming ouvertes en même temps, donc si vous avez un autre pool en tête, revenez simplement en arrière et répétez le processus.
Fermeture d'une position farming et réclamation de récompenses
Étape 1.  Accédez à Portfolio et passez à l'  onglet Farm Positions .

Étape 2.  Appuyez sur Fermer  à côté de la position que vous souhaitez quitter.

Étape 3.  Sur l'écran suivant, vous pouvez fermer complètement la position.

Minimize Trading  signifie que nous convertirons le montant minimum requis de jetons en jetons empruntés pour rembourser la dette et vous restituer les actifs restants.

Convert all  signifie que l'intégralité de votre position sera convertie en jeton emprunté et vous sera restituée une fois la dette payée.

Étape 4.  Si vous souhaitez fermer entièrement votre position, faites défiler vers le bas et appuyez sur Fermer la position , puis faites une approbation dans votre portefeuille.




	

	
	
		
			
				En ce qui concerne le Farming à effet de levier, PembRock…
			
		

		
					

		
			
			
			
			surdimensionne
		
			
			Sous-garantie
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Le Lending (Prêt)
Pour utiliser le Lending, vous devrez d'abord recharger votre portefeuille avec l'asset que vous allez fournir.

Étape 1.  Accédez à app.pembrok.finance/lend , sélectionnez l'asset et cliquez sur Dépôt .

Étape 2.  Spécifiez le montant que vous souhaitez prêter et confirmez la transaction. Veuillez noter que vous pouvez prêter dans plus d'un pool à la fois, donc si vous avez un autre asset en tête, revenez en arrière et répétez le processus.

Réclamer des récompenses
PembRock Finance incite à la fois les prêteurs et les  emprunteurs (agriculteurs).

Étape 1.  Accédez à app.pembrok.finance . Là, vous verrez un  onglet Portefeuille avec une sous-section Récompenses  déverrouillées.

Étape 2.  Appuyez sur Réclamer  et approuvez la transaction dans votre portefeuille.
Effectuer des retraits/ajustements
Étape 1.  Accédez à app.pembrok.finance/lend-pools . Là, vous verrez une liste des assets que vous avez fournis.

Étape 2.  Choisissez l'asset que vous ne souhaitez plus prêter et cliquez sur le bouton fléché vers le bas à droite dans la case.

Étape 3.  Entrez le montant que vous souhaitez retirer et appuyez sur Retirer .

Alternativement, vous pouvez ajuster la position en ajoutant plus de jetons dans le Lending.
À propos de PembRock
PembRock a été créé par INC4 , une société professionnelle de développement de blockchain d'origine ukrainienne qui existe depuis 2013.

L'idée principale derrière PembRock était d'apporter le trading avec effet de levier - un outil largement disponible pour les acteurs des marchés financiers traditionnels - à un secteur DeFi naissant mais tendance.

En mars 2022, PembRock Finance a reçu  une subvention de 75 000 USD de la Fondation NEAR visant à aider au développement, à l'amélioration et à l'adoption du protocole.
Utilitaire $PEM
PEM  est le jeton numérique natif du protocole de PembRock. Il a quatre cas d'utilisation principaux :

 	Les détenteurs de PEM qui misent leurs jetons partagent  tous  les revenus générés par le protocole.
 	Ils guident également le processus de prise de décision du projet à travers la participation au DAO.
 	Le jeton est au cœur du mécanisme qui distribue les récompenses pour interagir avec le protocole.
 	Le $PEM est également utilisé pour fournir un bonus supplémentaire à ceux qui fournissent des liquidités à nos pools.

Pour les endroits où l'acheter, regardez ici .

 	Nom :  Jeton financier PembRock
 	Symbole :  PEM
 	Offre totale : 160 millions d'unités
 	Réseau : protocole NEAR
 	Adresse du contrat : token.pembrock.near





	

	
	
		
			
				Quel utilitaire le jeton $PEM n'a-t-il PAS ?
			
		

		
					

		
			
			
			
			Partage des profits
		
			
			Vote
		
			
			Incitation
		
			
			Diffusion NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Qu'est-ce que le Staking ?
Dans le protocole PembRock, le staking signifie verrouiller PEM en échange d'un droit d'obtenir une partie des revenus générés par le protocole et de participer à l'organisation autonome décentralisée, influençant les décisions, y compris sur le montant que les agriculteurs et les prêteurs mentionnés ci-dessus devraient faire. Plus le montant misé est important et  plus la période est longue, plus le pouvoir de vote et  les récompenses sont élevés.

Supposons que vous misez 1 000 PEM pendant 4 ans en échange de 1 000 unités de pouvoir de vote (ce qui est accordé sous la forme de jetons vePEM), tandis que quelqu'un d'autre mise 1 000 PEM pendant 2 ans en échange de 500 unités de pouvoir de vote (car même s'ils jalonné le même volume, ils l'ont fait pendant une période deux fois plus courte). Ensemble, votre pouvoir de vote serait de 1 500. Donc, si un protocole générait 100 PEM en récompenses hebdomadaires, vous obtiendriez 66,66 PEM (car votre part dans le montant total misé serait de 66,66%), et un autre participant seulement 33,33 PEM (le sien serait de 33,33%).
Comment miser
Pour staker et par procuration rejoindre le DAO, vous aurez besoin du jeton numérique natif de PembRock appelé PEM. Si vous ne possédez pas encore de PEM, voici  comment résoudre ce problème.

Étape 1. Allez sur app.pembrok.finance/staking ;

Étape 2. Tapez le montant que vous souhaitez miser et la durée (le pouvoir de vote estimé peut être vu sous la date de fin ).

Étape 3. Appuyez sur  Confirmer.
Comment faire des ajustements
Le pouvoir de vote diminue progressivement, mais vous pouvez ajuster votre position (participer plus et/ou plus longtemps) pour maintenir votre influence au même niveau voire la rendre plus conséquente.

Étape 1. Faites défiler vers le bas de app.pembrok.finance/staking ;

Étape 2.  Tapez le montant que vous souhaitez miser en plus de ce que vous avez déjà misé et appuyez sur Confirmer ;

Étape 3. Après cela, vous pouvez prolonger la période de blocage.

Réclamer et retirer
Pour retirer PEM une fois la période de verrouillage terminée ou demander le paiement de vos récompenses dans PEM, visitez app.pembrock.finance/staking . Une fois disponibles, les boutons deviendront orange.




	

	
	
		
			
				Laquelle des affirmations suivantes est vraie?
			
		

		
					

		
			
			
			
			Le montant misé est le seul facteur qui détermine le pouvoir de vote
		
			
			La période du Staking est le seul facteur qui détermine le pouvoir de vote
		
			
			Le montant et la période déterminent le pouvoir de vote
		
			
			Aucune de ces réponses
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment participer à DAO
Dans DAO, vous pouvez définir le montant des récompenses qui sont versées chaque mois aux prêteurs et aux agriculteurs.

Étape 1. Allez sur app.pembrok.finance/voting . Là, vous verrez deux onglets - Récompenses des prêteurs et des emprunteurs .

Les récompenses des prêteurs  sont gagnées par les participants qui déposent dans des pools du Lending. Les récompenses des emprunteurs  sont gagnées par les participants qui empruntent des actifs auprès de pools du Lending.

Les étapes ci-dessous sont les mêmes pour les deux.

Étape 2. Distribuez votre pouvoir de vote aux pools à l'aide du champ  Vote . Plus le pourcentage que vous donnez est élevé, plus le rendement qu'il générera sera important.

N'oubliez pas que tous les % doivent totaliser 100.

Étape 3. Appuyez sur  Voter et confirmez la transaction dans NEAR Wallet.

Si vous changez d'avis, vous pouvez voter à nouveau pendant que la fenêtre est encore ouverte. Ce faisant, assurez-vous de spécifier à nouveau % pour tous les  éléments.
Conclusion
PembRock ne fait que prendre de l'ampleur alors que le marché DeFi en général et l'espace yield farming à effet de levier en particulier sont encore à leurs balbutiements. Tout comme Ref Finance  a été un pionnier dans l'espace DeFi de NEAR, PembRock est devenu le premier et le seul protocole yield farming à effet de levier du réseau. Donc, si vous voulez faire partie de la foule des créateurs de tendances, pourquoi ne pas l'essayer (attention aux risques , cependant) ?

Si vous souhaitez rester au courant de tout ce qui concerne PembRock, voici quelques liens pour vous :

PembRock site web | Twitter | Telegram | Discord

Article original: https://learnnear.club/the-guide-to-pembrock-finance/?fbclid=IwAR0N9FjgWs7iVV0gkLOyE39nDsgNnDJRjMVt0gAfKyRVGBnJGurEemPyigo#pll_switcher

### Update - January 10, 2023

Brief Summary:

 	
👉Important Redeem requirement update:
to participate in January Redeem window every (L)Earner must refer and invite 2 (TWO) friends to become LNC members via LNC affiliate program!


Results:

 	🏆 Top 22 #NEAR projects who got the most (L)Earners attention in year 2022!
 	 (L)Earn hands-on "What Is Quadratic Voting And Quadratic Funding?"
 	🧪 Beta test for Toolblox is on  🔥🔥🔥🔥 Over $NEAR 120 were awarded for the feedback


 	 (L)Earn "Why Ref v2 is Better than Uni v3"
 	Many thanks for your support - LNC has now 8K followers on Twitter

 	 501 (L)Earners successfully redeemed in December Redeem Window - check LNC Telegram for Redeem discussions 

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	🗳️ Updated NEAR Certified Developer course is coming!

### What is the NEAR Digital Collective?

The NEAR Digital Collective (NDC) is an ambitious project that brings together users, projects, stakeholders and partners of the NEAR ecosystem to create a radically new way of governing itself.
The NDC, originally envisioned by Illia Polosukhin, the co-founder of NEAR Protocol, is now a fully fledged movement led by the NEAR Community. It’s goal is to establish a community treasury and governance model that allows the ecosystem to collectively make decisions on everything from funding to elected representatives and more. It’s a significant step towards creating a truly decentralized network.
By creating a framework that allows any member of the network to have a say in how NEAR is run, the NDC’s goal is to combine transparency, collective decision making, evolving governance models and self-determination in a completely new way.
The NDC plans on doing this by helping to create the NEAR Constitution, a unifying document that enshrines the ideas of self-governance and decentralization into the core of how the NEAR ecosystem works.





Why is this important?
The NEAR ecosystem is made up of over 1,000 projects, regional hubs, funding nodes, infrastructure providers, and more than 20 million wallets. That’s a lot of people. The NDC was established to help all those involved take an active role in how NEAR evolves.
Whether that’s how funding is allocated, how elections take place, or who represents the mosaic of interests that make up this thriving and diverse ecosystem. The NDC wants to help everyone have a voice, and for those voices to be recorded on chain.

How does it do that?
The NDC is helping develop a system of governance. Once in place, it will allow people to vote on a wide variety of issues, elect members to different governing councils, and even make amendments to the constitution itself.
The essence of the NDC brings this radical framework to life, and allows the community to then engage and take part in actively shaping the future of NEAR.
In its current stage, the NDC is working on a governance structure that includes the following sections:


 	Voting Body — This is every active near account, as qualified by the governance framework
 	House of Merit — A group of experienced community members appointed by members of the ecosystem to represent them during votes and key decisions.
 	Council of Advisors — Advisors appointed to help shape the direction of the House of Merit.
 	Transparency Commission — members of the community appointed to ensure checks and balances, are in place and upheld.
 	Community Treasury — Members of the House of Merit with support from the Council of Advisors help facilitate voting on how community funds are allocated.

You can find more information on the above here.
This is a work in progress, and is currently overseen by the Governance Working Group, or GWG. This is a collection of community members working on refining the models of governance that will help everyone have their say.
The Collective and the GWG invites anyone to share and discuss ideas. All the details on how to do that can be found here.

What is the scope of the NDC?
While the constitution and governance models are key, the NDC will also help to shape, define and deliver the following:


 	NEAR Constitution.
 	Create and deploy Local and global on-chain decision-making.
 	Create and deploy a repository of local and global on-chain journals, logs, and minutes.
 	Establish governing bodies, their operations, powers, and what checks and balances each one needs.
 	Create and maintain a community treasury with a complete set of operating procedures and safeguards.
 	Create and maintain Community Guidelines, Code of Conduct, and Dispute Resolution protocols.
 	Create and deploy a communications strategy to ensure the work carried out by the NDC and GWG is easy to access.
 	A strategy to help the community find, access and use the NDC.
 	Help develop and deploy a DAO Governance Model
 	Facilitate growth of the NEAR ecosystem more broadly.

What role does the NEAR Foundation play in the NDC?
The Foundation is a partner and contributor to the NDC. It supports the work being carried out by the Collective, and will ultimately look to hand over its funding role to the community once it is ready to do so.

Who is working on NEAR Digital Collective?
The Collective is made up for members of the NEAR ecosystem. Some are former members of the Foundation, others are founders of projects, and others still are long term users and supporters of the blockchain and the projects that are built on it.
Feel free to reach out to any of the team leads.

Why is Decentralization Important?
Decentralization is a term that has become synonymous with blockchain, but has its origins as far back as the French Revolution in the 18th century.
Decentralization then, and now is the process by which the activities of an organization, particularly those regarding planning and decision making, are distributed or delegated away from a central, authoritative location or group.
This is important because, as any student of history will tell you, when power becomes overly centralized, the opportunity for abuse increases. In 2022, members of the blockchain community experienced first hand what happens when centralized authorities abuse their power.
Members of the NEAR Community believe that the goal of decentralization is to improve on what came before. It believes that increasing transparency and democracy creates a fair and more equal community for everyone.
But to get there requires a commitment to a process. A process that will need to evolve and adapt to the needs of the community, and for that community to take part in shaping it.
Decentralization is vital for the long term health and sustainability of any collection of people and ideas. The NDC is how the NEAR community is trying to achieve that.

How do I get involved?
Any member of the NEAR community is free to join any of the following workgroups.


 	Constitution
 	Governance & Tech Governance
 	Legal
 	Community Engagement
 	Communications

Get started by completing the Governance Working Group (GWG) onboarding process.
Or if you’re looking for a deeper dive into how all of this works, you can see the Overview page.

Follow the NDC

 	Twitter
 	Discord

### Toolblox Beta Test

Follow @LearnNEAR and @Toolblox on Twitter

Beta test sprint starts: January 3, 9 am ET
Beta Test sprint ends: January 7, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	 Go to www.toolblox.net click "Open App" and create an account* Go to https://academy.toolblox.net and take the 5-min tutorial (https://academy.toolblox.net/docs/tutorials/smart_contract_in_five_minutes)* Before you start make sure you have the latest version of the App

 	Ctrl+click refresh button in the browser
 	Alternatively open developer tools (F12) and choose Update for the Service Worker:



* Try out the following features (Aurora and/or Near):

 	Validation | Toolblox Academy
 	Calculations | Toolblox Academy
 	Payments | Toolblox Academy
 	Access restrictions | Toolblox Academy
 	(optional, only Aurora) Cross-workflow communication | Toolblox Academy
 	(optional, only Aurora) ERC-20 token payments | Toolblox Academy

* Let your imagination run wild and create a custom workflow. Some business process or interaction that would make a great smart contract.

* Tweet a screenshot and a link to your workflow (app.toolblox.net/summary/your_workflow_name) and with hashtag #madewithtoolblox and tag @tool_blox
smth like: "I've just created a workflow at @tool_blox during @LearnNEAR Beta test #madewithtoolblox"

Best 3 implementations win additional 20 NEAR

Submit feedback form
 	Tell us what do you think about the process.

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead @silverb0t at LNC Telegram Beta test topic

### Toolblox, the no-code smart-contract builder

Toolblox, the no-code smart-contract builder
Toolblox is a no-code smart-contract builder and DApp maker. In this post we aim to unwrap everything — what are we doing and why is it important.

Toolblox Workflow Builder and the auto-generated user interface
Brief history
The project started in the beginning of 2022 as a Near Metabuild II hackathon entry. It managed to win the grand prize which served as seed capital. Toolblox has won other prizes over the course of the year such as best of Tooling & Infrastructure at the Polygon BUIDL IT hackathon.

Since the first version the user interface was simplified 10x and a DApp builder was added as well. While it originally supported just one blockchain, five more were added.

Toolblox is soon 1 year old and we are just to pull the wraps and share it with the world.
Self-executing smart contracts
Smart contracts are self-executing agreements coded as computer programs. When a certain trigger is invoked they can immediately take action such as settle payments or transfer ownership. This is possible because on blockchain there is no need for a central authority, digital signatures are employed and program state is immutable.

Self-executing smart contracts are thus uniquely positioned to:

 	Infuse trust, fairness and transparency into any existing system or process.
 	Cut out middle men and centralized agency.
 	Handle diverse set of workflows — from brick and mortar stores to supply chains to digital native organizations called Decentralized Autonomous Organizations or DAOs.

Smart-contract will be ubiquitous, powering the business networks of the future. They can and should replace the backbone of any and all centralized SaaS business process management products.
Our approach
Toolblox provides a super-simple workflow-based smart contract builder to help companies quickly create their presence on the blockchain: build a workflow and deploy it as a usable application.

 	No code.
One can always invest in a development team or hire professionals to code a custom workflow. But for rest — 90% of small and micro businesses, non-profits, DAOs etc — who just want to stay focused a visual no-code approach is the way to go. Less up-front investment, more flexibility, rapid prototyping and quicker to-market.
 	State-machine based workflow.
Blockchain is not about data, its about state, especially about state transitions — the junctions where value is transferred — whether real money, ownership or both. The beating heart of any business process or a contract. Proposed as well by Hyperledger Foundation, a state machine workflow is a great fit for smart-contract visualization.
Learn about our workflow builder.
 	User interface out of the box.
While its great to be able to spin up custom smart-contracts easily they need to be usable as well — whether to share with end users or engage business partners. This is why Toolblox generates a simple app automatically. For more complex user interfaces and customization we have the DApp builder which enables to design a decentralized application without any code.
Learn about our DApp builder.
 	Integrates with the ecosystem.
Many options for integrating with external services (such as token insurance, collateralization, NFT portals, fractionalization etc):
- every workflow can be made ERC721 compatible
- ERC20 tokens (such as USDT, USDC, EURC etc) can be used as payments
- blockchain events can be used for further integration
- decentralized social media integration

Who is it for?

 	Decentralized Autonomous Organizations looking to manage custom workflows and projects.
 	Supply chain and commodities related industries to handle tasks ranging from production to retail and trading.
 	Small and micro businesses who lack specialized know-how and would benefit from a full stack solution (state, logic and payments).

Why would one use Toolblox?
Here are some ways one can think of Toolblox in any organization:

 	Digitalization tool — to build a business process on chain and share the app with users and partners.
 	Rapid prototyping tool — to create usable and shareable DApps to tackle a specific problem.
 	Development kickstarter — to create a smart contract draft and then develop it further with custom resources.
 	Backbone to an existing product — to connect an existing product to use blockchain as a single source of immutable and secure state data.

Workflow examples
Here are a couple of workflows/DApps built with Toolblox. Each workflow consists of the following elements:

 	Item (project, document, offer, proposal etc)
 	Item attributes (name, deadline, author, owner, client etc)
 	Workflow states (active, cancelled, waiting for feedback etc)
 	State transitions (amend, pay, create, agree, update etc)

All of the following projects are usable as a DApp and can be used as template for creating new smart contracts.
DAO fundraising for projects

Summary of DAO Fundraising (toolblox.net)
Distributed Wedding Registry

Summary of Distributed wedding registry (toolblox.net)
Ask me anything (AMA) with bounty

Summary of AMA platform with bounty example (toolblox.net)
Real-estate appraisal workflow

Summary of Real estate price appraisal workflow (toolblox.net)
3d print price offers and prints management

Summary of 3D printing offer registry (toolblox.net)

Check out our web www.toolblox.net and our Twitter for more examples! Also join academy.toolblox.net for tutorials and documentation on how to build with Toolblox.

### Quadratic Poll for Elon



### Tokenomics 101 Untuk Startup Web3

Pada kesempatan ini kami anggap teman-teman sedang berencana untuk membuat aplikasi dApps sendiri dan mulai meramaikan dunia web3. Selamat karena sudah sampai sejauh ini! Bagaimanapun, sebelum kamu merilis aplikasi terobosan dan menjadi game-changing, kamu perlu memahami salah satu inti dari web3 yakni tokenomics. Tokenomics sendiri merupakan istilah gabungan dari “token” dan “economy” yang sudah cukup mencirikan istilahnya itu sendiri. Jadi pada artikel ini kamu akan mengetahui semua hal tentang tokenomics.
Apa itu Tokenomics?
Tokenomics adalah istilah yang masih begitu luas, tetapi masih mencakup beberapa faktor seperti penawaran dan permintaan, perilisan token, fungsi burn, dan lain-lain. Secara sederhana, ini merupakan jumlah total fungsi dan faktor ekonomi yang memengaruhi token tersebut dalam berbagai cara. Token dari sebuah project dengan tokenomik yang solid dianggap sebagai investasi yang lebih menarik. Jadi langsung saja, tanpa basa-basi lagi, mari kita lihat perbedaan dari faktor-faktor tersebut
Faktor 1 : Penawaran dan Permintaan
Persamaan (rumus) dari penawaran dan permintaan merupakan salah satu faktor terpenting untuk menjelaskan tokenomics. Berikut ini adalah satu dari diagram ekonomi yang paling penting yakni : diagram permintaan dan penawaran



Grafik diatas menunjukkan hubungan antara penawaran dan permintaan pada jenis komoditas tertentu. Harga komoditas selanjutnya ditentukan dari permintaan pada pasar dan jumlah komoditas atau barang yang tersedia.

Kelangkaan suatu barang (yaitu persediaan barang yang semakin berkurang) sering dianggap sebagai faktor penting dalam penaksiran harga produk. Pikirkan harga yang melambung tinggi yang menjual mesin PS5 di pasar barang bekas karena kelangkaannya. Namun jangan hanya karena suatu barang itu langka dipasaran, bukan berarti barang itu berharga. Kamu memang bisa mengambil foto diri sendiri (selfie) yang akan menjadikan barang tersebut unik, tetapi bukan berarti kamu akan mendapatkan ribuan dolar untuk itu kan? Tentunya harus ada permintaan di pasar. Pada tahap ekuilibrium (keseimbangan), grafik permintaan dan penawaran saling menyeimbangkan secara sempurna.

Ada dua hal yang dapat kita simpulkan dari grafik tersebut, yaitu:

 	Ketika penawaran / suplai dari suatu aset tinggi tetapi permintaannya rendah, itu tidak akan mempengaruhi harga secara positif
 	Jika permintaan tinggi tetapi penawaran rendah, itu akan mempengaruhi harga secara positif.

Penawaran dan Permintaan dalam Token

Ketika berbicara tentang Bitcoin, salah satu momen value creation yang sangat signifikan dalam protokol adalah peristiwa halving yang secara berkala terjadi setiap empat tahun sekali. Bitcoin memiliki total pasokan atau suplai tetap sebesar 21 juta. Penambang akan menambang Bitcoin untuk mendapatkan hadiah blok untuk melepaskan BTC ke dalam total pasokan yang beredar.

Setiap empat tahun, Bitcoin mengalami fase halving yang mekanismenya adalah memotong hadiah blok hingga setengahnya yang ini akan mengurangi jumlah BTC yang memasuki suplai yang beredar. Satoshi Nakamoto sengaja menambahkan mekanisme ini untuk memastikan pasokan akan berkurang dari waktu ke waktu dan harapannya adalah meningkatkan harga nilai secara keseluruhan.

Beberapa token seperti BNB memiliki mekanisme pembakaran (burning) artifisial. Burning  berarti kita mengirim token ke dompet yang kunci pribadinya tidak dimiliki oleh siapa pun. Dengan demikian, kita berarti menghapus token ini dari peredaran alias membakar token (burning).

Ada juga token tertentu yang bersifat inflasi. Misalnya, EOS memiliki tingkat inflasi tahunan sebesar 1%. 1% ini digunakan untuk membayar produsen blok. Idenya adalah bahwa sistem EOS akan menjadi sangat sibuk dari waktu ke waktu sehingga peningkatan suplai tidak akan memengaruhi jumlah permintaan.
Faktor 2 : Distribusi Token
Sebuah protokol dapat mendistribusikan token melalui mekanisme launching secara adil (fair launch) atau pre-mine. Ketika fair launch terjadi, setiap orang memiliki kesempatan yang adil untuk mendapatkan token. Peluncuran Bitcoin telah adil karena setiap orang memiliki kesempatan yang sama persis untuk memperoleh BTC. Tidak ada pra-penjualan, tidak ada pendanaan investor privat. Jika kamu menginginkan Bitcoin, kamu harus menambangnya dari awal.

Namun, fair launch sangat jarang saat ini. Dimulai dari era ICO, token telah diluncurkan melalui metode yang disebut pre-mine. Dalam pre-mine, token dibuat sebagian atau seluruhnya dan kemudian didistribusikan ke berbagai pihak seperti VC, investor, dll., sebelum dirilis ke publik. Jelas, pre-mining tidak adil karena rata-rata pengguna tidak mendapatkan kesempatan pertama dari “kue yang diberikan”. Namun, dalam lanskap saat ini, hal itu perlu dilakukan karena proyek membutuhkan suntikan likuiditas awal dari VC dan market maker. Mereka membutuhkan likuiditas untuk membayar tenaga kerja, pengembangan, membangun ekosistem, dan lain-lain..

Karena itu, sangat penting bagi kita untuk melihat berapa banyak token yang didistribusikan ke pihak-pihak ini. Misalnya, jika sebuah tim mengalokasikan 5% token untuk dirinya sendiri, maka ini tidaklah mengaoa. Bagaimanapun juga, mereka memang membutuhkan uang untuk mendanai tim mereka. Namun, jika mereka memberikan 50% untuk diri mereka sendiri, maka itu berpotensi menjadi tanda bahaya.




	

	
	
		
			
				Ketika aset memiliki suplai yang rendah dan permintaan yang tinggi, hal ini berarti:
			
		

		
					

		
			
			
			
			Harga akan naik
		
			
			Harga akan turun
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Faktor 3 : Staking
Pada intinya, tokennomics yang baik harus menghasilkan metode yang berbeda untuk memberi insentif kepada para pengguna untuk mempertahankan token mereka. Salah satu cara paling menarik untuk melakukannya adalah memastikan pemegangnya mendapatkan ROI yang terjamin. Banyak proyek melakukannya dengan mekanisme staking.

Idenya sederhana, yakni kunci token anda dalam protokol dan dapatkan hadiah. Misalnya, jika anda memegang token Curve (CRV), Anda dapat melakukan staking  di Convex Finance sebagai cvxCRV dan mendapatkan ~30% vAPR. Aplikasi DeFi memungkinkan anda untuk melakukan staking berbagai token yang dapat membantu anda mendapatkan hasil.

Staking juga memungkinkan pengguna untuk mengunci token milik mereka, secara otomatis menjadikannya pemegang jangka panjang. Lagi pula, kita tidak dapat menjual token yang telah dikunci dengan kuat di ekosistem, bukan?

Sekarang, pertanyaan berikutnya yang perlu dipertimbangkan di sini adalah, bagaimana kita bisa memberi insentif kepada pengguna kita untuk rela men-stake koin tersebut untuk waktu yang lama? Nah, proyek seperti Curve memiliki penawaran bunga majemuk sederhana yang bekerja cukup baik untuk mereka. Semakin lama mereka mengunci CRV milik mereka, maka semakin banyak hadiah yang akan didapatkan.

Staking juga memberi kita hak tata kelola (governance) di beberapa proyek. Men-staking token native memungkinkan kita untuk menjadi anggota dari protokol DAO dan memberikan suara pada berbagai keputusan. Misalnya, di Curve, kita dapat mempertaruhkan CRV dan veCRV kita serta mendapatkan token voting. Semakin banyak CRV yang kita stake, maka semakin banyak veCRV yang kita  dapatkan. veCRV tidak memiliki nilai selain digunakan sebagai token voting dalam DAO.
Faktor 4 : Jadwal Vesting
Di Faktor yang ke-2, kita membahas bagaimana premining memungkinkan proyek mengalokasikan token khusus untuk investor swasta dan VC. Namun, bagaimana jika orang-orang itu segera membuang token tersebut di pasar terbuka? Itu tidak akan membuat proyek kita jadi bagus, bukan?

Jadi, yang dapat kita lakukan di sini adalah menggunakan berbagai jadwal vesting untuk alokasi kita. Vesting memungkinkan kita untuk mengunci token yang didistribusikan untuk waktu tertentu (alias periode vesting). Ini meningkatkan waktu untuk harus menunggu sebelum mendapatkan token.

Sekarang, sebelum kita melangkah lebih jauh, mari kita bicara tentang "cliff". Dalam hal vesting, cliff adalah kunci durasi yang ditempatkan pada token vesting sebelum jadwal vesting dimulai. Ada dua jenis vesting yang bisa kita lakukan:

 	Linear vesting: Distribusi token dilakukan secara konsisten dan dalam porsi yang sama dalam jangka waktu tertentu.
 	Twisted vesting: Distribusi token dapat bervariasi dalam berbagai periode waktu.

Membuat token anda sendiri - Best Practices
Jadi, sekarang setelah kita mengetahui dasar-dasar dari tokenomics, sekarang mari kita buat token milikmu sendiri. Kamu dapat menggunakan token playground ini untuk menguji berbagai struktur token.



Seperti yang kita lihat, kita dapat memasukkan nama token, simbol, persediaan total, dan tempat desimal.

Di bawahnya, kita memiliki daftar alokasi token. Bergantung pada berapa banyak advisor dan VC yang terlibat pada proyek milikmu. Kamu dapat memberikan alokasi yang sesuai. Namun ini hanyalah sebuah saran. Jangan berlebihan dengan alokasi untuk advisor. Pertahankan jumlah mayoritas yang signifikan untuk komunitasmu..

Sebagai contoh:

 	10% untuk tim
 	10% untuk investor awal
 	0,25% -0,5% per advisor
 	Sisanya adalah untuk komunitas




	

	
	
		
			
				Apa jenis vesting berikut ini : Distribusi token disalurkan secara konsisten dan berimbang pada periode waktu dan bagian tertentu
			
		

		
					

		
			
			
			
			Linear
		
			
			Twisted
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kesimpulan
Ketika membangun protokol Web3, model tokenomics yang baru akan sangat krusial untuk kesuksesan jangka panjang dari proyek anda. Pada artikel ini, kita telah mendiskusikan tentang empat fitur yang dapat kamu integrasikan dalam strategi tokenomics untuk menghindari dumping dan memberikan insentif pada para pengguna untuk memegang token anda dan justru menambah jumlahnya lebih banyak lagi.




	

	
	
		
			
				Saat distribusi token, jumlah token mayoritas harusnya dialokasikan kepada:
			
		

		
					

		
			
			
			
			Team
		
			
			VCs
		
			
			Komunitas
		
	
		

		
		
			
				Correct!
				Wrong!

### What Is Quadratic Voting And Quadratic Funding?

If you are an individual who is interested in decentralized governance, you may have come across words such as “Quadratic voting” and “Quadratic funding.” While some may consider these as buzzwords, these concepts have gained considerable traction over the past few years. There have been several instances where both have been implemented, meeting with a high degree of success. Quadratic voting was used to vote on winning projects during the Taiwanese Presidential Hackathon. We saw the system used again when the Colorado Democratic Party used it to determine their party platform. On the other hand, Quadratic funding was used by Gitcoin Grants to fund public goods in the Ethereum ecosystem. 

Both concepts, according to their proponents, have the potential to revolutionize how decisions are made. The ultimate implementation of these concepts could be, in the words of Vitalik Buterin, “deeply transformative as the industrial-era advent of mostly-free markets and constitutional democracy.” The hype is not without any reason, as this article will explain, looking at both concepts and their application and benefits. 

Let’s start with Quadratic voting.
The Problem With Governance Models 
The governance models utilized by blockchain platforms are becoming increasingly crucial, with their ability to impact user participation, platform efficiency, and attractiveness. One of the biggest concerns blockchains had when it came to governance was the potential for the emergence of dominant positions. These “dominant positions” would be made up of users who would have, under their control, a large number of votes or perhaps even a majority of the votes. This would give this group of users unprecedented control over matters related to the platform’s evolution. 

Such a concentration of voting power may discourage users with a smaller number of votes from participating in governance mechanisms or even force them to leave the platform entirely. The promise and potential of blockchain technology and platforms can only be fulfilled if close, thoughtful attention is given to the governance mechanisms of these platforms. Such a concentration of votes and voting power would, doubtless, worry others on the platform. However, a new voting method, which in recent times has found utility in racing social decisions, is emerging as a possible solution to the dilemma plaguing blockchain platforms.
Quadratic Voting: The Mathematical Way To A Fairer Vote 
Quadratic voting is a collective decision-making mechanism that enables a better avenue towards making decisions, avoiding the so-called “tyranny of the majority.” It was first proposed by political economist Glen Weyl and allows participants to express the direction of their preferences, the degree of their preferences, and how strongly they feel about them. Through this, it hopes to address the issue of majority rule and protect the interests of smaller groups of voters that care deeply about specific issues. Quadratic voting allows users to “pay” for additional votes on a particular matter, enabling them to express their support more strongly for specific issues. 

While a regular poll may ask whether you agree or disagree with a particular set of issues, Quadratic voting gives voters a budget of “voice credits” that they can spend to agree or disagree with issues. Voters can cast multiple votes, but each subsequent vote would cost more credits than the last. This type of voting mechanism can be utilized in different areas, such as democratic institutions, corporate governance, and blockchain-enabled collective decision-making.




	

	
	
		
			
				Quadratic voting was first proposed by:
			
		

		
					

		
			
			
			
			Vitalik Buterin
		
			
			Glen Weyl 
		
			
			Zoe Hitzig 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Does Quadratic Voting Work? 
Now, let’s take a look at how Quadratic voting functions. Quadratic voting is based on market principles, with each voter being allocated a budget of vote credits that they can spend to influence the outcome of key deliberations. If a voter strongly supports or opposes a particular decision, they can allocate additional votes to demonstrate the level of their support or opposition to a specific decision. The cost of additional votes is determined through a vote pricing rule, with each vote becoming more expensive than the last. The increasing voter credit cost demonstrates the degree of support or opposition towards a particular decision. 

Quadratic voting uses a simple formula, cost to the voter = (number of votes)2  

Let’s understand this better with the help of an example. Let’s assume a voter has a budget of 16 vote credits and has the liberty of using one credit for 16 different issues that they can vote on. However, If the voter feels more strongly about one particular issue, they can allocate four votes toward that issue at the cost of their entire budget. The four votes cost all 16 vote credits because the cost of each additional vote becomes more expensive quadratically. So 1 vote would cost 1 credit, 2 votes would cost 4, 3 votes would cost 9, and the 4th vote would cost 16. 

This mechanism has been viewed as one potential solution to address governance problems faced by blockchain platforms and communities, preventing a single group from taking over while also protecting the interest of minority groups. The tokens cast as votes are redistributed evenly between voters at the end of each governance cycle. It would take a group several voting cycles and significant costs to take control of a platform. 

But how does Quadratic voting compare to other established voting mechanisms? There are three other major democratic voting mechanisms, 

 	Plurality Systems
 	Proportional Representation Systems
 	Semi-Proportional Systems

Plurality Systems 
In plurality voting systems, the party or position that receives the most votes wins the election, relying on the “one vote, one voter” mechanism. However, plurality voting systems cannot ensure that voters can express their level of support for a particular cause or issue nor allocate their votes to express the degree of support. 
Proportional Representation Systems 
This voting method is primarily seen in national legislatures, where it ensures that the division of an elected body reflects the division of votes in the electorate. While this voting method better reflects the electorates’ point of view, it fails to represent how strongly voters feel about their position over issues. 
Semi-Proportional Systems 
There are several types of semi-proportional voting systems. However, none of these account for the degree of voters’ preference or opposition to issues. 
Quadratic Funding: A New Way To Fund Public Goods 
Let’s move on to Quadratic funding. Quadratic funding is one of the most innovative socio-economic experiments to have come out of the crypto ecosystem. It has been touted as a mathematically optimal way to fund public goods in democratic communities by amplifying donations made by a large community over contributions made by smaller groups with deep pockets. But what are public goods?

Public goods are defined as commodities or services that are available to all members of society. These goods must have the following qualities. 

 	Non-rivalrous - This means one member’s use of these goods does not decrease its availability to other members. 
 	Non-excludable - These goods must be accessible to all. 

Quadratic funding was outlined by Vitalik Buterin, Zoe Hitzig, and Glen Weyl in a research paper published in 2018. However, for the sake of understanding, we should simplify the concept. The driving force behind Quadratic funding is its matching pool, a pool of funds provided by individuals, companies, and protocols collectively known as matching partners. Funds collected in the matching pool are utilized to magnify individual project contributions. Let’s go through a quick example to understand the concept better. 

Let’s assume we have $10,000 in a matching pool and three projects participating in a funding round. Project A gets $1000 in funding from 5 contributors that pitch in $200 each. Project B receives $1000 from 2 contributors, each pitching in $500. Project C also receives $1000, but from 20 contributors, each pitching in $50. Now, the matched amounts are calculated using the Quadratic funding formula. Going by the formula, the first project gets an additional $1851.85, 185% more than the contributed amount. The second project receives $740.74, an additional 74% of the total contributions, while the third gets $7407.41 of the matched funding, a staggering 740% of the original contribution. 

Let’s look at how the formula arrives at these values. 

 	Individuals, companies, and protocols contribute to the projects (A, B, C). 
 	Let’s start with project A. After the funding round was completed, the square root of each contribution was added, and the resulting sum was squared. Let’s assume this is the Quadratic Funding variable.
 	The exact process is repeated for Projects B and C. 
 	Project A’s share of the pool is calculated as the weighted average of its Quadratic funding variable.
 	Projects B and C also received their share of the pool by following the same mathematical model.

Benefits Of Quadratic Funding 
Quadratic funding helps address a problem called the “tragedy of the commons.” This is an economic problem where each individual has the incentive to consume resources at the expense of others, with no way of excluding anyone from consuming the resource, leading to overconsumption and resource depletion. Quadratic funding puts emphasis on the number of donations rather than the size of the donation. Projects bringing in more donations are representative of public goods serving a larger group of users, making the tragedy of commons more severe. 

As a result, projects serving a more extensive group are assumed to be backed by more donors, resulting in higher donations from the matching pool. This is why project C received the highest match funding in our earlier example. 




	

	
	
		
			
				Quadratic funding emphasizes on which of the following?
			
		

		
					

		
			
			
			
			The number of donations
		
			
			The size of the donations
		
			
			Both of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Use Cases Of Quadratic Voting And Quadratic Funding
The Colorado State Legislature has used Quadratic voting to decide which appropriation bills must be funded by the house first. With legislatures more likely to sponsor their own bills and vote for those, the Democrats used Quadratic voting to determine which bills had support across the board. Each legislature was given a budget of 100 credits, where one vote would cost them one token. However, legislatures could cast more votes toward an issue, with the cost of each vote increasing quadratically, as shown below.



The Taiwanese Presidential hackathon was also judged through Quadratic voting.

When it comes to Quadratic funding, the most prominent example is that of Gitcoin, which uses the method to raise funds. Gitcoin enables the community to create and fund projects and has supported various projects, including Uniswap, Finematics, Kickback, and others. Vitalik Buterin uses Gitcoin Grants to discover new projects, while Andre Cronje used it to fund Yearn Finance.




	

	
	
		
			
				Where has the concept of Quadratic voting been put into practice? 
			
		

		
					

		
			
			
			
			Colorado State Legislature 
		
			
			Taiwanese Presidential hackathon 
		
			
			German Volt party during its second congress 
		
			
			All of the Above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Wrapping Up
Traditionally, modern democracies have used the one person-one vote method, while corporations have adopted slightly more sophisticated voting mechanisms. However, more democratic voting systems, such as Ranked Choice Voting and Proportional Voting, have failed to gain traction thanks to the complexity involved. Quadratic voting, by allowing voters to express their preferences and the intensity of these preferences, helps protect the interests of smaller groups within communities.

Quadratic funding, while a relatively new concept, has made a considerable impact, with over $2 million distributed to public goods. A growing number of projects are exploring Quadratic funding, chief among them being Gitcoin Grants, clr.fund, and Downtown Stimulus. However, both concepts have the potential to radically change how blockchain protocols are governed and funded.




	

	
	
		
			
				Which are the most prominent projects exploring Quadratic funding? 
			
		

		
					

		
			
			
			
			Gitcoin Grants
		
			
			Clr.fund
		
			
			Downtown Stimulus 
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Now let's try it IRL - have your Quadratic say, (L)Earner!
        
            qVote guide 
            
                301 votes by,
                619 nLEARNs spent
            
            
            
                                    
                        
                            Yes                            
                                (285 votes,
                                597 nLEARNs)
                            
                        
                        
                             
                            95%
                        
                    
                                    
                        
                            No                            
                                (6 votes,
                                10 nLEARNs)
                            
                        
                        
                             
                            2%
                        
                    
                                    
                        
                            Not sure what that even means                            
                                (10 votes,
                                12 nLEARNs)
                            
                        
                        
                             
                            3%

### Почему Ref v2 лучше Uni v3

Введение
Ref Finance v2 привносит в NEAR будущее торговли: AMM с дискретной ликвидностью (DLAMM) с лимитными ордерами. Запуск произойдет в ближайшие недели,  вскоре вы сможете насладиться торговым опытом, подобным CEX, со всеми преимуществами DEX.

TL;DR

 	Крах FTX указывает на необходимость DEX с торговым опытом, сравнимым с CEX.
 	 Ref Finance запускает свою вторую версию, основными компонентами которой являются дискретизированный AMM ликвидности (DLAMM) и лимитные ордера.
 	 DLAMM — это улучшенная версия концентрированной ликвидности Uniswap v3 с более точным предоставлением ликвидности, повышенной эффективностью использования капитала и почти нулевым проскальзыванием.
 	 Ref v2 также имеет встроенные лимитные ордера. Трейдеры могут размещать рыночные и лимитные ордера с почти нулевым проскальзыванием, что позволяет торговать на DEX в стиле CEX.
 	 Ref v2 можно использовать быстрее и дешевле, чем в любой другой сети, благодаря быстрой завершенности NEAR (1–2 секунды) и маленькой комиссии (<0,01 доллара США).
 	 Дискретная ликвидность AMM — это игра с положительной суммой, в которой выигрывают как LP, так и трейдеры.

После недавнего краха одной из крупнейших в мире централизованных бирж (CEX) FTX, крипто сообщество быстро осознало важность децентрализации. Принятие протоколов децентрализованного финансирования (DeFi), особенно децентрализованных бирж (DEX), росло по мере того, как люди осознавали необходимость прозрачности и самостоятельного хранения своих активов.

Поскольку DEX сейчас важнее, чем когда-либо, давайте посмотрим куда они направляются. В этой статье мы проанализируем эволюцию DEX на ее ярком примере Uniswap и представим следующий этап ее развития: дискретизированную концентрированную ликвидность.



Краткий обзор Uniswap v1, v2 и v3
В ноябре 2018 года Uniswap v1 был запущен в основном как доказательство концепции. Он представил идею AMM, используя математику, стоящую за уравнением постоянного произведения, x * y = k. В то время Uniswap v1 поддерживал только торговые пары ETH-ERC20 и пулы ликвидности (LP).

В мае 2020 года Uniswap v2 был запущен как улучшение по сравнению с v1. Некоторыми из ключевых улучшений были введение пулов ликвидности, пулов ERC20-ERC20, децентрализованного ценового оракула TWAP и флэш-свопов.

В мае 2021 года был запущен Uniswap v3. v3 представила ключевые инновации, такие как концентрированная ликвидность, а также улучшенная безопасность, новые уровни оплаты, разработка оракула и не взаимозаменяемая ликвидность. В целом, основной тезис Uniswap v3 заключался в повышении эффективности капитала для трейдеров платформы и поставщиков ликвидности за счет концепции концентрированной ликвидности.



	

	
	
		
			
				Какой вид торговли поддерживался в Uniswap v1?
			
		

		
					

		
			
			
			
			ETH-ERC20 торговые пары и пулы
		
			
			ERC20-ERC20 пулы
		
			
			ETH-NEAR торговые пары и пулы
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Что такое концентрированная ликвидность? Какие преимущества это приносит?
В отличие от AMM, где ликвидность просто предоставляется без указания диапазона, концентрированная ликвидность означает, что LP могут распределять капитал в своих предпочтительных ценовых интервалах, что позволяет значительно повысить эффективность использования капитала.

Концентрированная ликвидность выгодна всем сторонам: трейдерам и LP.

LP извлекают выгоду из эффективности капитала за счет предоставления узкого диапазона ликвидности, который, как правило, больше используется трейдерами, что, следовательно, может генерировать в 4000 раз больше комиссий по сравнению с Uniswap v2.

Трейдеры, в свою очередь, выигрывают от более глубокой ликвидности




Uniswap V3 получил широкое распространение в криптосообществе благодаря своей новой модели концентрированной ликвидности. Объемы Uniswap v3 непрерывно росли с момента его запуска, быстро достигнув 97,2% превосходства над Uniswap v2 с точки зрения дневного объема.





Дискретная ликвидность на Ref v2

В партнерстве с iZUMi Finance и Arctic компания Ref Finance с гордостью представляет Ref v2: AMM дискретной ликвидности (DLAMM) с лимитными ордерами. Подумайте о концентрированной ликвидности Uniswap V3, но лучше, и теперь с функцией лимитного ордера, позволяющей использовать опыт торговли на CEX в сети.

AMM дискретной ликвидности против AMM концентрированной ликвидности

Дискретная ликвидность — это сокращение от DLAMM, что означает «автоматический маркет-мейкер с дискретной ликвидностью». Существующие AMM с концентрированной ликвидностью, такие как Uniswap v3, следуют формуле постоянного продукта (X*Y=K), где цена постоянно меняется в зависимости от количества токенов X и Y в пуле. Разработанный iZUMi Finance, AMM с дискретной ликвидностью использует синтетическую непрерывную кривую постоянного продукта с формулой дискретной постоянной суммы (x+y=k), где цены дискретизируются в AMM (см. рисунок ниже).




Это приводит к двум основным улучшениям для AMM с дискретной ликвидностью: уменьшению проскальзывания и более точному предоставлению ликвидности в пределах ценового диапазона.



	

	
	
		
			
				Какой маркет-мейкер используется в Ref Finance?
			
		

		
					

		
			
			
			
			Концентрированная ликвидность АММ
		
			
			Дискретная ликвидность АММ
		
			
			Фокусированная ликвидность АММ
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Как Ref v2 улучшает Uniswap V3
Ref v2 не только представляет лучшие части Uniswap v3 (эффективность использования капитала) с его AMM с дискретной ликвидностью, но и делает еще больше, обеспечивает торговый опыт, подобный CEX, который обычно невозможен на DEX со встроенной функцией лимитного ордера. И все это со всеми преимуществами DEX: децентрализованными, безопасными и прозрачными сквозными транзакциями для трейдеров и поставщиков ликвидности.

На Ref v2 вы можете..



 	Наслаждайтесь высокой эффективностью капитала благодаря AMM с дискретной ликвидностью

Как и в Uni v3, Ref v2 позволяет вам предоставлять концентрированную ликвидность, то есть ликвидность, характерную для определенного ценового диапазона. Это означает, что в качестве LP вы можете обеспечить ликвидность в ценовом диапазоне, который, по вашему мнению, трейдеры используют больше, например, и потенциально собирают гораздо больше комиссий, чем раньше. Как трейдер, вы потенциально можете наслаждаться более высокой ликвидностью в ценовых диапазонах, которые вы часто посещаете, поскольку ликвидность больше не должна распределяться по всему диапазону.

 	 Наслаждайтесь AMM в стиле Uni V3 с меньшими затратами и скоростью

Используя NEAR, Ref может предложить свой дискретизированный AMM ликвидности с невероятно быстрой завершенностью (1–2 секунды) и с незначительными затратами/ 

 	 Размещайте лимитные ордера

По определению, лимитный ордер — это ордер на покупку или продажу актива с ограничением максимальной цены, подлежащей уплате, или минимальной цены, по которой вы продаете. Это типичная функция CEX, использующих книгу ордеров, которая позволяет пользователям программировать ордера в пределах предпочитаемого ими ценового диапазона.

В настоящее время в Uniswap v3 нет надлежащей функции лимитного ордера. Единственный способ — предоставить концентрированную ликвидность за пределами текущей цены и, таким образом, имитировать лимитный ордер. Ref v2, с другой стороны, представляет встроенную функциональность лимитных ордеров. Теперь пользователи могут торговать на DEX, как обычно на CEX 🤯

 	 Размещайте лимитные ордера без ограничения цены

Поскольку Uni v3 позволяет размещать лимитные ордера только окольными путями, после исполнения синтетического лимитного ордера, если или когда цена возвращается к исходной точке, LP больше не могут требовать прибыли от своих ордеров, поскольку заработанные токены были бы возвращены. 

В Ref v2 пользователи могут размещать лимитные ордера на покупку по цене, превышающей текущую цену, после чего алгоритм автоматически выбирает лучшую цену. Это также обеспечивает торговый опыт, аналогичный CEX.

 	 Размещайте лимитные ордера с почти нулевым проскальзыванием

Благодаря AMM с дискретной ликвидностью Ref, который использует силу формулы постоянной суммы, трейдеры могут не только размещать лимитные ордера, но и делать это с почти нулевым проскальзыванием.

Более того, когда трейдеры размещают лимитные ордера на Ref v2, они фактически становятся временными LP для этого пула в этом ценовом диапазоне. Помимо самой современной модели DLAMM, емкость лимитного ордера Ref v2 эффективно добавляет дополнительную ликвидность в пулы, тем самым уменьшая еще большее проскальзывание.

 	 Выгода от приоритета лимитного ордера И справедливой структуры комиссии LP

Введение поставщика ликвидности лимитных ордеров в Ref v2 естественным образом вводит конкуренцию по комиссиям с обычными LP, которые предоставляют концентрированную ликвидность. Чтобы наилучшим образом стимулировать каждую сторону, лимитные ордера всегда будут иметь приоритет с точки зрения порядка транзакции, но сборы LP будут распределяться пропорционально поставщикам концентрированной ликвидности.



	

	
	
		
			
				Какая биржа позволяет клиентам размещать лимитные ордера без ограничения цены?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			FTX
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Почему ВАМ это должно быть интересно?




Дискретная ликвидность AMM — это игра с положительной суммой. Все выигрывают на Ref V2.

 	Поставщики ликвидности: как и в Uni v3, LP в Ref v2 могут максимизировать комиссию за транзакции, которую они взимают со сделок, предоставляя концентрированную ликвидность в определенном ценовом диапазоне, который часто посещают трейдеры. Кроме того, LP также получают все сборы, полученные от сделок с лимитными ордерами. Когда лимитный ордер исполняется, комиссию за транзакцию получает не трейдер, а базовый LP в пределах этого диапазона.
 	Трейдеры: Трейдеры теперь могут пользоваться большей ликвидностью, а также размещать рыночные и лимитные ордера с почти нулевым проскальзыванием. Когда трейдеры размещают лимитные ордера, они фактически становятся поставщиками ликвидности, которые «делают рынки», размещая предложения на бирже.
 	Активные маркет-мейкеры: маркет-мейкеры могут снизить стоимость управления LP до гораздо доступной ставки (<0,01 доллара США за транзакцию), с более предсказуемой прибылью и убытком (PnL) и опытом торговли, близким к обмену CLOB.

### Les Explorateurs de la Blockchain NEAR

Les Explorateurs de la Blockchain NEAR

Après le crash de FTX, prendre le contrôle de vos cryptos est devenu plus critique que jamais. L'un des moyens les plus importants d'y parvenir est d'apprendre à lire un explorateur de blocs. Pour le Protocole NEAR, les explorateurs de blocs les plus populaires sont :

 	NEAR Explorer
 	NearBlocks
 	NearScan

Qu'est-ce qu'un explorateur de blockchain ?
Un scanner blockchain (chaîne de blocs) est un logiciel utilisé pour visualiser différentes métriques liées au réseau blockchain, telles que :

 	Hashrate
 	Taille de bloc
 	Difficulté de bloc
 	Commission moyenne par transaction

Alors, que pouvez-vous faire avec l'explorateur de blockchain ? Nous allons voir.

 	Suivre le statut d'une transaction en attente pendant qu'elle attend dans le mempool.
 	Gardez une trace du solde des portefeuilles sans avoir à utiliser le portefeuille lui-même. Cela peut être utile si vous souhaitez vérifier le solde de votre portefeuille matériel.
 	Suivez chaque transaction qui entre et sort d'une adresse particulière.
 	Voir les blocs orphelins, également appelés blocs qui ne sont pas connectés à la chaîne principale.
 	Explorez les transactions de baleines (comptes avec un grand nombre de jetons) qui pourraient avoir un impact important sur le marché.
 	Gardez une trace des adresses (comptes) des leaders connus de la cryptographie.
 	Gardez une trace des pièces après un piratage.

Comment fonctionnent les explorateurs de blockchain ?
Les explorateurs de blockchain fonctionnent en conjonction avec des nœuds de blockchain et utilisent des interfaces de programmation d'application (API), des bases de données relationnelles et des bases de données SQL pour récupérer les informations pertinentes du réseau sous-jacent. Voici quelques éléments à garder à l'esprit :

 	Le navigateur organise toutes ces informations dans une base de données et affiche ces données dans un format plus facile à rechercher et à trouver.
 	Les utilisateurs peuvent effectuer des recherches dans un tableau organisé.
 	Toutes les demandes de recherche sont envoyées au serveur principal, qui fournit les réponses requises.

Comment utiliser un explorateur blockchain ?
Pour nos premières démos, regardons l'explorateur NEAR explorer. Mettons un compte sélectionné au hasard sur le scanner. Pour voir quelles données nous obtenons.

La première section que nous voyons contient les données suivantes :

 	Transactions : le nombre de transactions envoyées et reçues. Ce compte a envoyé 1 816 transactions et n'en a reçu aucune.
 	Stockage utilisé : Le stockage total utilisé par le compte blockchain. Ce compte utilise 390 Kb.
 	Native account balance: la nombre de jetons NEAR  que le compte possède actuellement. Ce compte contient 81.1916 NEAR..
 	Validator stake: Ce compte délègue-t-il NEAR pour prendre en charge un validateur et sécuriser le réseau ? Le compte a délégué 23 439 675,24565 NEAR derrière un validateur.
 	Created at: Le compte a été créé le 15 février 2022 à 4:49:20 AM.
 	Created by Transcation: Le hash  de transaction responsable de la création de ce compte est 4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Lorsque vous faites défiler vers le bas, vous verrez l'historique des transactions pour ce compte.

Vérifier l'état de la transaction
Mettons un hash de transaction aléatoire dans le navigateur et voyons à quoi il ressemble. Tout d'abord, nous allons mettre ce hachage de transaction :

2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3

Il s'agit d'une transaction standard dans laquelle un compte envoie des pièces à un autre. Passons donc aux détails.

 	Sender: Il s'agit du compte qui a signé et envoyé la transaction. Dans ce cas, c'est “Sweat_welcome.near.”
 	Receiver: Il s'agit du compte recevant la transaction – 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Status:  L'état actuel des transactions. Cela peut être En attente, Réussi, Échec/Finalisé ou non finalisé. Dans ce cas, c'est réussi.
 	Transaction fee: Il s'agit des frais requis pour exécuter cette transaction. Dans ce cas, c'est 0.00008 NEAR.
 	Deposit value: Il s'agit de la valeur totale transférée du compte signataire au compte destinataire. Dans ce cas, la valeur du dépôt est 0.5 NEAR.
 	Gas used: Les unités de gaz nécessaires pour exécuter la transaction. Dans ce cas, c'est 1 Tgas ( 1 TeraGas = 10¹² gas units).
 	Created: Cette transaction a été créée le 17 novembre 2022 à 13:18:33.
 	Block hash: L'identifiant unique (hash) du bloc dans lequel cette transaction a été incluse. Dans ce cas, le hachage de bloc est F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN

Reçu de transaction


 	L'explorateur nous montre également un reçu. Le reçu lui-même comporte deux parties.
 	La première partie est le reçu de la transaction elle-même. Il y a un ID de reçu et le total de gaz et de jetons brûlés.
 	La deuxième partie est le reçu du système. "Systema" est un compte spécial utilisé pour identifier les reçus de remboursement.




	

	
	
		
			
				Pour lesquelles des actions suivantes puis-je utiliser un scanner ?
			
		

		
					

		
			
			
			
			Afficher l'historique des transactions d'un compte
		
			
			Vérifiez combien j'ai dépensé en frais d'essence lors de ma dernière transaction
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Utilisation d'autres navigateurs NEAR
Utilisons la même transaction dans NearScan et NearBlocks pour voir comment la présentation des données diffère entre ces scanners.
NearBlocks

L'explorateur NearBlocks affiche les mêmes données que le total de gaz et de jetons brûlés lors de la transaction.




	

	
	
		
			
				A quoi sert le "System account" ?
			
		

		
					

		
			
			
			
			Valider les transactions
		
			
			Identifiant des reçus de remboursement
		
			
			ajouter des opérations
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NearScan

L'interface NearScan vous donne une grande partie des mêmes données, bien que les données sur les gaz affichent plus de décimales que l'explorateur NEAR.




	

	
	
		
			
				Lequel des scanners suivants peut être utilisé pour le protocole NEAR ?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			NearScan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
Il existe des transactions plus compliquées sur la blockchain NEAR. Cependant, cet article devrait vous donner une idée de la manière de lire ces transactions. Les explorateurs vous permettent d'exploiter l'une des caractéristiques les plus essentielles de la technologie blockchain : la transparence. Il vous permet, en tant qu'utilisateur, de suivre méticuleusement vos pièces et de voir où elles vont.
Pour lesquelles des actions suivantes puis-je utiliser un scanner ?

 	Afficher l'historique des transactions d'un compte
 	Vérifiez combien j'ai dépensé en frais d'essence lors de ma dernière transaction
 	Tout ce qui précède

A quoi sert le "System account" ?

 	Valider les transactions
 	Identifiant des reçus de remboursement
 	ajouter des opérations

### Why Ref v2 is Better than Uni v3

Introduction & Background
Ref Finance v2 is bringing the future of trading to NEAR: a Discretized Liquidity AMM (DLAMM) with limit orders. Launching in the coming weeks, you can soon enjoy a CEX-like trading experience with all the DEX benefits.

TL;DR
1. The collapse of FTX points to the necessity for DEXs with trading experience comparable to CEXs.
2. Ref Finance is launching its v2, the core components of which are its discretized liquidity AMM (DLAMM) and limit orders.
3. DLAMM is an improved version of Uniswap v3’s concentrated liquidity, with more accurate liquidity provision, increased capital efficiency, and near-zero slippage.
4. Ref v2 also has built-in limit orders. Traders can place market- and limit orders with near-zero slippage, bringing a CEX-style trading experience on a DEX.
5. Ref v2 can be enjoyed faster and cheaper than almost any other chain, thanks to NEAR’s fast finality (1–2s) and negligible fees (<$0.01).
6. Discretized liquidity AMM is a positive sum game where LPs and traders both win.




With the recent collapse of one of the world’s biggest centralized exchanges (CEX), FTX, the crypto community quickly awakened to the importance of decentralization. Adoption to decentralized finance (DeFi) protocols, especially decentralized exchanges (DEXs), grew as people recognized the necessity for transparency and self-custody over one’s assets.
With DEXs more important now than ever, let us take a look at where they are headed. In this article, we will analyze the evolution of DEXs through its prime example, Uniswap, and introduce the next phase of its development: discretized concentrated liquidity.

Recap of Uniswap v1, v2, and v3
In November 2018, Uniswap v1 launched mostly as a proof of concept. It introduced the idea of an AMM, leveraging the math behind the constant product equation, x * y = k. At the time, Uniswap v1 only supported ETH-ERC20 trading pairs and liquidity pools (LPs).
In May 2020, Uniswap v2 launched as an improvement upon v1. Some of the key improvements were the introduction of liquidity pools, ERC20-ERC20 pools, decentralized TWAP price oracle, and flash swaps.
In May 2021, Uniswap v3 launched. v3 introduced key innovations such as concentrated liquidity, as well as improved security, new fee-tiers, oracle feed development, and non-fungible liquidity. All in all, the main thesis of Uniswap v3 was to achieve better capital efficiency for the platform’s traders and the liquidity providers through the concept of concentrated liquidity.



	

	
	
		
			
				Which kind of trading was supported on Uniswap v1?
			
		

		
					

		
			
			
			
			ETH-ERC20 trading pairs and pools
		
			
			ERC20-ERC20 pools
		
			
			ETH-NEAR trading pairs and pools
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What is concentrated liquidity? What benefits does it bring?
As opposed to AMMs, where liquidity is simply provided without specifying a range, concentrated liquidity means LPs can allocate capital to their preferred price intervals, which allows for a significantly higher capital efficiency.
Concentrated liquidity benefits all parties: traders and LPs.
LPs benefit from the capital efficiency of providing a narrow range of liquidity, generally which is utilized more by traders, which consequently can generate up to 4000x more fees compared to Uniswap v2.
Traders, in turn, benefit from the deeper liquidity





Uniswap V3 saw strong adoption from the crypto community thanks to its new concentrated liquidity model. Uniswap v3 volumes increased non-stop since its launch, quickly reaching a 97.2% dominance over Uniswap v2 in terms of daily volume.





Discretized Liquidity on Ref v2
In partnership with iZUMi Finance and Arctic, Ref Finance is proud to introduce Ref v2: the Discretized Liquidity AMM (DLAMM) with limit orders. Think Uniswap V3’s concentrated liquidity but better, and now with limit order functionality to bring the CEX trading experience on-chain.
Discretized Liquidity AMM vs Concentrated Liquidity AMM
Discretized Liquidity is the shorthand for DLAMM, which means “discretized liquidity automated market maker.” Existing concentrated liquidity AMMs, such as Uniswap v3, follow the constant product formula (X*Y=K), where the price changes continuously with the amount of X and Y tokens in the pool. Designed by iZUMi Finance, the discretized liquidity AMM uses a synthetic continuous constant product curve with a discretized constant sum formula (x+y=k), where prices are discretized in the AMM (see figure below).





This results in two major improvements for discretized liquidity AMMs: reduced slippage and more accurate liquidity provision within a price range.



	

	
	
		
			
				Which market maker is used in Ref Finance?
			
		

		
					

		
			
			
			
			Concentrated Liquidity AMM
		
			
			Discretized Liquidity AMM
		
			
			Focused Liquidity AMM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






How Ref v2 Improves Upon Uniswap V3
Ref v2 not only introduces the best parts of Uniswap v3 (capital efficiency) with its discretized liquidity AMM, but goes even further to enable a CEX-like trading experience normally impossible on DEXs with a built-in limit order functionality. And all of this, with the full benefits of a DEX: decentralized, secure, and transparent end-to-end transactions for traders and liquidity providers.
On Ref v2 you can..


 	Enjoy high capital efficiency thanks to the Discretized Liquidity AMM

Just like on Uni v3, Ref v2 enables you to provide concentrated liquidity — i.e. liquidity that is specific to a price range. This means that as an LP you are able to provide liquidity to a price range that you think traders utilize more, for instance, and potentially collect way more fees than before. As a trader, you can potentially enjoy deeper liquidity in the price ranges that you frequent, as liquidity doesn’t have to be spread out across the entire range anymore.
2. Enjoy Uni V3-style AMM at a fraction of the speed and costs
By leveraging NEAR, Ref is able to offer its discretized liquidity AMM with incredibly fast finality (1–2s) and at negligible costs (fractions of a penny).
3. Place limit orders
By definition, a limit order is an order to buy or sell an asset with a restriction on the maximum price to be paid or the minimum price at which you sell. This is a typical feature on CEXs that use an orderbook, which allows users to program orders within their preferred price range.
Currently, there isn’t a proper limit order function on Uniswap v3. The only way is to provide concentrated liquidity outside the current price and thus mimic a limit order. Ref v2, on the other hand, introduces built-in limit order functionality. Now users can trade on a DEX like they normally would on a CEX 🤯
4. Place limit orders without price limitations
As Uni v3 only allows for limit orders in a roundabout way, once the synthetic limit order is filled, if or when the price returns to its original point, LPs are no longer able to claim their order earnings as the earned tokens would have been reverted.
On Ref v2, users can place limit buy orders at a price higher than current price, and the algorithm will then auto match with the best price. This further provides a trading experience akin to CEXs.
5. Place limit orders with near-zero slippage
Thanks to Ref’s discretized liquidity AMM, which leverages the power of a constant sum formula, traders can not only place limit orders, but do so with near-zero slippage.
Moreover, when traders place limit orders on Ref v2, they effectively become temporary LPs to that pool in that price range. Aside from the state of the art DLAMM model itself, Ref v2’s limit order capacity effectively adds additional liquidity into the pools, thus reducing even more slippage.
6. Benefit from limit order priority AND fair LP fee structure
The introduction of the limit order liquidity provider on Ref v2 naturally introduces competition on fees with the regular LPs who provide concentrated liquidity. To best incentivize each party, limit orders will always be prioritized in terms of the order of transaction, but the LP fees will be distributed proportionally to the concentrated liquidity providers.



	

	
	
		
			
				Which exchange allows customers to place limit orders without price limitations?
			
		

		
					

		
			
			
			
			Uniswap
		
			
			1Inch
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Why should YOU care?




Tldr; Discretized Liquidity AMM is a positive sum game. Everybody wins on Ref V2.


 	Liquidity Providers: Like on Uni v3, LPs on Ref v2 can maximize the transaction fees they collect from trades by providing concentrated liquidity into a specific price range that traders frequent. In addition, LPs also receive all the fees generated from limit order trades. When a limit order gets filled, it is not the trader who receive the transaction fee, but rather the underlying LP within that range.
 	Traders: Traders are able to enjoy deeper liquidity now, as well as place market orders and limit orders with near-zero slippage. When traders place limit orders, they effectively become liquidity providers, who “make markets” by placing offers onto the exchange.
 	Active Market Makers: Market makers can reduce the cost of LP management to a much affordable rate(<$0.01/txn), with more predictable profit and loss (PnL), and trading experience closer to a CLOB exchange.


“Tldr; DL-AMM is a positive sum game”

### Update - December 8, 2022

Brief Summary:

 	
"NameSky" accepted to LNC Barrel- accelerator for NEAR projects!


Results:

 	🏆 Top 10 #NEAR projects who got the most (L)Earners attention in November!
 	 (L)Earn "How build your own NFT market". LNC partner course from Mintbase
 	🧪 Beta test for NameSky is on  🔥🔥🔥🔥


 	 Must read for any web3 user - (L)Earn about "NEAR blockchain explorers" and how to read NEAR transactions
 	🕵️‍♂️Dive in "Auditing Projects on the #NEAR Blockchain: From Zero to Hero" with Pessimistic - our (L)Earn partner
 	💸  November Redeem to $NEAR was a blast! (L)Earn partner of the month - NEAR Social- got quit a bit of new members as well as legit feedback from real users
 	(L)Earner NFT holder now can leave comments at Guides!
Leave meaningful comments, get nLEARNs tips from Guides' authors and readers.


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	🗳️ Quadratic voting is coming to LNC!

### Name Sky Beta Test

Follow @LearnNEAR and NameSky on Twitter

Beta test sprint starts: December 6, 9 am ET
Beta Test sprint ends: December 9, 9 am ET
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Create 2 more cool NEAR testnet accounts at NEAR wallet (hint - try to find cool and funny accounts, you may also try to grab testnet accounts for the NEAR projects - like reffiance.testnet, paras.testent ;)
 	Login to NameSky with main NEAR testnet account
 	Mint and list an account for sale
 	Transfer an NFT to another NEAR account
 	Buy an NFT from the Marketplace
 	Take a screenshot with the NFT you bought
 	Tweet with your screenshot “I’ve just bought cool NEAR account name as NFT at @NameSkyApp  project from @LearnNEAR Barrel” and tag 3 friends
 	Explorer our marketplace, make offer to a favorite NFT
 	Check user activities
 	Check your NFT activities
 	Take back NEAR account with NFT and import the NEAR account to https://wallet.testnet.near.org/
 	Tell us what do you think about the process.

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead at Telegram  https://t.me/nicenearname_support

### nSpot Beta Test

Follow @NearSocial_  @nspot_xyz and  @LearnNEAR on Twitter

Beta test sprint starts: November 30, 9 am ET
Beta Test sprint ends: December 3, 11pm ET.
Requirements:
First of all, read  "What is Near Social?" and "How to use nSpot"?

 	Get yourself our Telegram bot LNC NEAR watcher and Testnet Watcher to get notified on transactions
 	Login to NEAR Social at https://near.social/  with your mainnet NEAR wallet
 	Explore all widgets: AllWidgets
 	Login to nSpot testnet  with your testnet NEAR wallet
 	Go to + List
 	Fill the details for the listing

 	Make a similar screenshot and upload it as a Reference screenshot


 	Submit listing for approval.
 	Once approved (usually within few hours) put this checkmark to publish nSpot at the marketplace

 	Accept LNC offer at nSpot

 	Go back to your Profile https://near.social/#/mob.near/widget/ProfileEditor.
Put to the background image the url like https://testnet-nspot.herokuapp.com/spotBanner/spot_id - replace with your spot_Id from above 
 	Take a screenshot
 	Tweet with your screenshot “I’ve just put @nspot_xyz banner to my profile at @NearSocial_ during  @LearnNEAR  Beta test, Suggest you do the same!” and tag 3 of your friends
 	Settle listing when expired to get the NEAR tokens


Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project leads at nSpot and NEAR Social Telegram groups

### Эксплореры блокчейна NEAR

После краха FTX контроль над вашей криптовалютой стал более важным чем когда-либо. Один из самых важных способов сделать это — научиться читать обозреватель блоков. Для протокола NEAR наиболее популярными обозревателями блоков являются:

 	NEAR Explorer
 	NearBlocks
 	NearScan

Что такое эксплорер блокчейна?
Сканер блокчейна — это программное обеспечение, используемое для визуализации различных показателей сети блокчейна, таких как:

 	Хешрейт
 	Размер блока
 	Сложность блока
 	Средняя комиссия за транзакцию.

Итак, что вы можете сделать с обозревателем блокчейна? Давайте взглянем.

 	Отслеживайте статус незавершенной транзакции, пока она находится в мемпуле.
 	Отслеживайте баланс кошельков, не используя сам кошелек. Это может быть полезно, если вы хотите проверить баланс своего аппаратного кошелька.
 	Отслеживайте каждую транзакцию, входящую и исходящую с определенного адреса.
 	Просмотр потерянных блоков, то есть блоков, которые не присоединены к основной цепочке.
 	Исследуйте транзакции китов, которые могут оказать серьезное влияние на рынок.
 	Следите за адресами известных крипто-лидеров.
 	Следите за монетами после взлома.

Как работает эксплорер блокчейна?
Эксплорер блокчейна работает вместе с узлами блокчейна и использует интерфейсы прикладного программирования (API), рациональные базы данных и базы данных SQL для извлечения соответствующей информации из базовой сети. Вот несколько вещей, о которых следует помнить:

 	эксплорер собирает всю эту информацию в базу данных и отображает эти данные в формате, доступном для поиска.
 	пользователи могут выполнять поиск в организованной таблице.
 	Все поисковые запросы отправляются на внутренний сервер, который предоставляет требуемые ответы.

Как использовать эксплорер блокчейна?
Для наших  нескольких демонстраций давайте проверим NEAR Explorer. Ставим случайно выбранный аккаунт в сканер. Посмотрим, какие данные мы получим.

Первый раздел, который мы видим, имеет следующие данные:

 	Транзакции: количество отправленных и полученных транзакций. Этот аккаунт отправил 1816 транзакций и не получил ни одной.
 	Используемое хранилище: общее хранилище блокчейна, используемое учетной записью. Эта учетная запись использует 390 КБ.
 	Баланс учетной записи: количество токенов NEAR, которые в настоящее время хранятся на учетной записи. Этот счет содержит 81,1916 NEAR.
 	Доля валидатора: эта учетная запись стейкает NEAR для поддержки валидатора и защиты сети. Аккаунт стейкает 23 439 675,24565 NEAR у валидатора.
 	Создание: учетная запись была создана 15 февраля 2022 г. в 4:49:20.
 	Транзакция создания: хэш транзакции, ответственный за создание этой учетной записи — 4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Когда вы прокрутите вниз, вы увидите историю транзакций этой учетной записи.

Проверка статуса транзакции
Давайте поместим случайный хэш транзакции в проводник и посмотрим, как это выглядит. Мы поместим этот хэш транзакции: 2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3

Это стандартная транзакция, при которой один аккаунт отправляет некоторое количество монет другому. Итак, давайте пройдемся по деталям.

 	Отправитель: это аккаунт, который подписал и отправил транзакцию. В данном случае это «Sweat_welcome.near».
 	Получатель: это аккаунт, получающий транзакцию: 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Статус: текущий статус транзакций. Это может быть «Ожидание», «Выполнено успешно», «Ошибка/Завершение» или «Не завершено». В этом случае «Выполнено успешно».
 	Плата за транзакцию: это комиссия, необходимая для выполнения этой транзакции. В данном случае это 0,00008 NEAR.
 	Количество депозита: это общая сумма, которая переводится с подписывающей учетной записи на учетную запись получателя. В этом случае стоимость депозита составляет 0,5 NEAR.
 	Используемый газ: единицы газа, необходимые для выполнения транзакции. В данном случае это 1 Тгаз (1 ТераГаз = 10¹² единиц газа).
 	Создание. Эта транзакция была создана 17 ноября 2022 г. в 13:18:33.
 	Хэш блока. Уникальный идентификатор (хэш) блока, в который была включена эта транзакция. В данном случае хэш блока — F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN.

Квитанция трансакции

Эксплорер также показывает квитанцию. Сама квитанция состоит из двух частей.

 	Первая часть – это получение самой транзакции. Есть идентификатор квитанции и общее количество сожженного газа и токенов.
 	Вторая часть – системный чек. «Система» — это специальная учетная запись, используемая для идентификации квитанций о возмещении.




	

	
	
		
			
				Для чего из следующего я могу использовать сканер?
			
		

		
					

		
			
			
			
			Просмотреть историю транзакций аккаунта
		
			
			Посмотреть количество газа затраченного на последнюю транзакцию
		
			
			Все перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Использование других эксплореров NEAR
Давайте воспользуемся одной и той же транзакцией в NearScan и NearBlocks, чтобы увидеть, как отличается вывод данных в этих обозревателях.
NearBlocks

Эксплорер NearBlocks показывает те же данные, общий газ и токены, сожженные во время транзакции.




	

	
	
		
			
				Что делает «Системный аккаунт»?
			
		

		
					

		
			
			
			
			подтверждает транзакции
		
			
			идентифицирует квитанции о возмещении
		
			
			добавляет транзакции
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NearScan

Интерфейс NearScan дает практически те же данные. Газовые данные показывают больше десятичных разрядов, чем NEAR Explorer.




	

	
	
		
			
				Какие из следующих сканеров можно использовать для протокола NEAR?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			NearScan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Вывод
В блокчейне NEAR есть более сложные транзакции. Тем не менее, эта статья должна дать вам представление о том, как читать эти транзакции. Эксплореры позволяют вам использовать одну из самых важных черт технологии блокчейна — прозрачность. Это дает вам как пользователю возможность тщательно отслеживать ваши монеты и видеть, куда они идут.

### Аудит проектов на блокчейне NEAR с нуля

Приветствую вас, дорогие читатели!

Сегoдня мы рассмотрим несколько профессиональных советов по аудиту смарт-контрактов на блокчейне NEAR. В этой серии мы сосредоточимся только на тех аспектах, которые могут быть действительно полезны для аудита проектов на NEAR. Все, что мы опишем ниже, основано на нашем личном опыте!

В первую очередь, мы хотели бы выразить искреннюю благодарность создателям NEAR и его экосистемных проектов. Всем, кто его поддерживает, авторам всех ресурсных материалов и конечно же нашим аудиторам, которые помогли нам выявить столь необходимую информацию, которая  будет доступна вам.

Мы можем с уверенностью сказать, что такие советы можно прочитать публично в нескольких местах, и наш блог — одно из таких мест! Дальше будут наши наблюдения — только сухие факты для аудиторов, хитрости и лучшие лайфхаки, которыми поделились наши лучшие аудиторы. Давайте начнем!

Кстати, сейчас есть несколько свободных мест, поэтому, если вашему проекту требуется аудит — не стесняйтесь пишите нам, посетите нашу страницу публичных отчетов здесь.
By the way, there are some vacant slots now so if your project needs an audit — feel free to write to us, visit our public reports page here.

l - Что такое NEAR?
NEAR – это платформа для разработки, построенная на сегментированном блокчейне первого уровня с доказательством доли владения. Используя технологию сегментирования, NEAR предлагает решения таких проблем, как низкая скорость обработки, перегрузка сети и высокая плата за газ, что обеспечивает значительную масштабируемость платформы без ущерба для безопасности протокола.

Важно помнить, что NEAR — это масштабируемый сегментированный блокчейн, а это означает, что развернутые смарт-контракты компилируются в WebAssembly (WASM) и могут быть написаны на следующих языках:

 	Rust
 	AssemblyScript (a TypeScript-like language for WebAssembly)
 	Solidity (via Aurora EVM)
 	Javascript (via JS-VM)

Использование WASM приводит к высокому лимиту газа и эффективности, быстрой генерации блоков и более низким комиссиям за транзакции. Смарт-контракты в NEAR можно рассматривать как микросервисы, содержащие данные и исполняемый код. Взаимодействия между контрактами выполняются асинхронно.

При всем при этом, с нашей точки зрения, экосистема NEAR в основном основана на Rust!

https://github.com/rust-in-blockchain/awesome-blockchain-rust
Платформа объединяет тысячи участников сообщества для обеспечения максимально комфортного опыта, а также широкую многофункциональную экосистему:


Платформа основана на нескольких ключевых функциях:

Что касается безопасности производства блоков, они используют механизм, известный как Doomslug. Doomslug, несмотря на свое зловещее название, довольно прост и предполагает, что разные валидаторы по очереди производят блоки в зависимости от того, сколько токенов NEAR они поставили.

Мы не будем вдаваться в подробности в этой статье, так как предполагаем, что вы, уважаемый читатель, уже имеете достаточное представление об экосистеме NEAR, поэтому настоятельно рекомендуем вам посетить их базу знаний и изучить документацию проекта для лучшего понимания:

https://docs.near.org/

II - Процедура проверки проекта NEAR от команды Pessimistic.io:
Поскольку основные препятствия, которые могут возникнуть у аудитора при аудите проектов в NEAR известны. Первое  для любой фирмы будет заключаться в грамотной разработке, результатом которой является наличие документации и тестов. Звучит слишком просто, чтобы быть правдой, но убедитесь, что это работает и доказывает свою эффективность только со временем!

Итак, наша команда аудиторов хотела бы представить вам собственный свод правил, накопленный за многие месяцы и годы работы, в котором мы постараемся не допускать повторений и постараемся донести все очень лаконично и профессионально. При этом мы проводим аудит в соответствии со следующими процедурами:
Автоматический анализ:

 	Составляем договоры; 
 	Прогоняем предоставленные тесты и проверяем код; 
 	Мы запускаем инструменты анализа и вручную проверяем (отклоняем или подтверждаем) все заявленные проблемы (см. ниже);

Ручной аудит:

 	Мы вручную просматриваем код и оцениваем его качество; 
 	Проверяем код на наличие известных уязвимостей; 
 	Проверяем соответствие логики кода предоставленной документации; 
 	Мы предлагаем возможную оптимизацию газа и хранения;

Проблемы:
Мы активно ищем:

 	Проблемы с контролем доступа (неверная идентификация/авторизация администратора или пользователей); 
 	Проблемы с утерянными/украденными активами (активы застревают в контракте или отправляются в никуда или на неправильный счет); 
 	DoS из-за логических проблем (взаимная блокировка, ошибка конечного автомата и т. д.); 
 	DoS из-за технических проблем (ошибка Out-of-Gas, другие ограничения); 
 	Проблемы взаимодействия с контрактами (повторный вход, небезопасные вызовы, предположения вызывающего абонента); 
 	Проблемы с арифметикой (переполнение, недополнение, проблемы с округлением); 
 	Неправильное использование Near SDK; 
 	Другие проблемы.

Газ:
Проверяем, качественно ли выполняются газоемкие операции:

 	Коллекции – коллекции из std::collections читаются все вместе, что увеличивает расход газа. Вы должны использовать near_sdk::collections или Near_sdk::store;
 	Коллекции привязаны к хранилищу, и вы можете случайно забыть их синхронизировать;
 	Карты: LookupMap/UnorderedMap/TreeMap — выбирать нужно по требуемому функционалу (первая — самая дешевая, последняя — самая мощная);
 	LazyOption — для редко используемых «больших данных» (можно использовать только в конструкторе);
 	Borsh/JSON для сериализации сообщений (параметров/возвращаемых значений) — влияет на расход газа;
 	Внимательно изучите атаку «миллион дешевых добавлений данных», чтобы избежать подобных проблем.

Инструменты:
 

Давайте подробно рассмотрим инструменты автоматического анализа, которые вы можете использовать в своей работе, и их возможности:

 	Valgrind — можно использовать, если в коде есть небезопасные блоки с опасным выделением памяти. Тем не менее, такая практика поднимает красный флаг для аудита. В общем, запускать valgrind особого смысла нет!
 	Cargo Geiger — это инструмент, отображающий статистику использования небезопасного кода Rust в крейте Rust и всех его зависимостях. Его способность фокусироваться на возможных проблемах является полезной чертой. Существование опасного кода уже является проблемой в таких проектах, и любые такие записи должны быть перепроверены.
 	Cargo Audit – проверяет файлы на наличие ящиков, содержащих уязвимости в системе безопасности. То есть он отображает устаревшие библиотеки, которыми все еще пользуются. Тем не менее, вы должны использовать его для целей аудита.
 	Статический анализатор Clippy — это отличный линтер кода, который выявляет распространенные ошибки и улучшает ваш код на Rust.
 	Cargo Tarpaulin — для покрытия тестами — очень удобный инструмент, который показывает количество строк кода, не охваченных тестами..




III - Аудит общедоступных отчетов
Публичные отчеты аудита наших собственных проектов экосистемы NEAR структурированы в соответствии с представленной выше схемой потока аудита, поэтому мы рекомендуем вам сравнить эти отчеты, в частности их результаты, с ней:

 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

Надеемся, что эта статья была информативной и полезной для вас! Спасибо за чтение! Какие инструменты мы должны рассмотреть? О чем вам было бы интересно прочитать в нашем блоге?

Если у вас остались вопросы, пожалуйста, не стесняйтесь спрашивать! Мы будем рады ответить на каждый ваш вопрос! Лучшие ответы и вопросы могут быть включены в следующую запись в блоге!
Кстати, сейчас есть несколько вакантных мест, поэтому, если вашему проекту нужен аудит — не стесняйтесь писать нам, посетите нашу страницу публичных отчетов здесь.

### Auditar Proyectos en la Blockchain de NEAR: Desde Cero a Héroe

¡Saludos estimados lectores!
Hoy vamos a mirar algunos consejos profesionales en la auditoría de contratos inteligentes en la blockchain de NEAR. En esta serie, nos vamos a enfocar en esos aspectos que pueden ser realmente útiles para auditar proyectos basados en NEAR. ¡Todo lo que vas a encontrar a continuación, se basa en nuestra experiencia personal! 

En primer lugar, nos gustaría expresar nuestro más sincero agradecimiento a los creadores de NEAR y los proyectos de su ecosistema, a todos los que lo apoyan, los autores de los materiales informativos y por supuesto, a nuestros brillantes auditores que nos han ayudado a revelar información tan necesaria y así levantar la cortina del secreto. Y hoy, queridos lectores, estará disponible para ustedes.

Podemos decir con confianza que estos consejos se pueden leer de forma pública en varios lugares, ¡y nuestro blog es uno de esos lugares! A continuación, te traemos nuestras observaciones: hechos innegables para auditores, trucos y los top hacks compartidos por nuestros mejores auditores. ¡Vamos a comenzar!

Por cierto, en estos momentos tenemos algunos espacios vacantes, así que si tu proyecto necesita una auditoría, escríbenos, visita nuestra página de informes públicos aquí.
I — ¿Qué es NEAR?
NEAR es una plataforma de desarrollo, construida sobre una blockchain de capa uno fragmentada y de Prueba de Participación. Gracias a la tecnología de fragmentación, NEAR ofrece soluciones a problemas como la velocidad de procesamiento, congestión de la red y altas comisiones por gas, permitiendo una escalabilidad significativa de la plataforma sin sacrificar la seguridad del protocolo.

Es importante tener en mente que NEAR es una blockchain fragmentada escalable, lo que quiere decir que los contratos inteligentes que se ejecutan, se compilan en WebAssembly (WASM) y pueden ser escritos en lenguajes como:

 	Rust
 	AssemblyScript (un tipo de lenguaje TypeScript para WebAssembly)
 	Solidity (vía Aurora EVM)c
 	Javascript (vía JS-VM)

El uso de WASM da como resultado un alto límite de gas y eficiencia, una generación rápida de bloques y tarifas de transacción bajas. Los contratos inteligentes en NEAR pueden considerarse como microservicios que contienen datos y códigos ejecutables. Las interacciones entre los contratos cruzados se realizan de forma asíncrona.

Con todo lo dicho, desde nuestra perspectiva, el Ecosistema NEAR está, en su mayoría ¡basado en Rust!

https://github.com/rust-in-blockchain/awesome-blockchain-rust
La plataforma reúne a miles de miembros de la comunidad para brindar la mejor experiencia, así como, un amplio ecosistema multifuncional:


La plataforma se basa en varias características claves:

En términos de seguridad de producción de bloques, emplea un mecanismo conocido como Doomslug. El Doomslug, a pesar de su nombre ominoso, es muy sencillo y asume que diferentes validadores toman turnos para producir bloques en función de la cantidad de tokens NEAR stakeados.

No iremos a los detalles en este artículo porque asumimos que tú, querido lector, ya tienes suficiente entendimiento sobre el ecosistema de NEAR, así que te recomendamos que visites su base de conocimientos y estudies la documentación del proyecto para una mejor comprensión:

https://docs.near.org/

II — Procedimiento de Revisión del Proyecto NEAR por el Equipo de Pessimistic.io:
Debido a que los principales obstáculos que un auditor puede tener mientras audita proyectos en NEAR, son lógicos; la primera sugerencia para cualquier firma será un desarrollo competente, que dé como resultado una documentación sólida y pruebas confiables. Esto parece muy simple para ser verdad, ¡pero asegúrate de que funcione y se pruebe así misma en el tiempo!
Así pues, nuestro brillante equipo de auditoría desea presentarte nuestro conjunto de reglas, acumuladas durante muchos meses y años de trabajo, en el cual trataremos de evitar la redundancia y trataremos de transmitir todo de forma concisa y profesional. Con lo anterior dicho, realizamos nuestras auditorías de acuerdo a los siguientes procedimientos:

Análisis Automatizado:

 	Recopilamos contratos;
 	Corremos las pruebas proporcionadas y revisamos la cobertura del código;
 	Ejecutamos herramientas de análisis y verificamos manualmente (rechazamos o confirmamos) todos los problemas informados (ver a continuación).

Auditoría Manual

 	Revisamos manualmente códigos y evaluamos su calidad;
 	Verificamos el código en búsqueda de vulnerabilidades conocidas;
 	Revisamos si la lógica del código cumple con la documentación entregada;
 	Sugerimos posibles optimizaciones de gas y almacenamiento;

Problemas:
Estamos activamente en la búsqueda de:

 	Problemas de control de acceso (identificación/autorización incorrecta de administradores o usuarios);
 	Problemas de activos perdidos/robados (activos atascados en el contrato o enviados a ninguna parte o a una cuenta incorrecta);
 	DoS debido a problemas lógicos (interbloqueo, error de máquina de estado, etc.);
 	DoS debido a problemas técnicos (error de falta de gas, otras limitaciones);
 	Problemas de interacción del contrato (reentrada, llamadas inseguras, suposiciones de la persona que llama);
 	Problemas aritméticos (desbordamiento, subdesbordamiento, problemas de redondeo);
 	Uso incorrecto de Near SDK;
 	Otros problemas.

Gas:
Verificamos si las operaciones intensivas de gas se ejecutan de forma eficiente: 

 	Colecciones: las colecciones de std::collections se leen todas juntas, lo que infla el consumo de gas. Debes usar near_sdk::collections o near_sdk::store;
 	Las colecciones están vinculadas a un almacenamiento y puedes accidentalmente olvidarte de sincronizarlas;
 	Mapas: LookupMap / UnorderedMap / TreeMap: debes elegir de acuerdo con la funcionalidad requerida (el primero es el más barato, el último el más poderoso);
 	LazyOption: para los "big data" raramente utilizados (solo se pueden usar en el constructor);
 	Borsh/JSON para la serialización de mensajes (parámetros/valores de retorno) — afecta el consumo de gas;
 	Mira de cerca el ataque “million cheap data additions” para evitar problemas similares.

Herramientas:
Vamos a darle una mirada a las herramientas de análisis automáticos que puedes usar en tu trabajo y sus características: 

 	Valgrind: se puede usar si el código incluye bloques inseguros con una asignación de memoria peligrosa. Sin embargo, tal práctica levanta una bandera roja para la auditoría. En general, ejecutar valgrind no tiene mucho sentido.
 	Cargo Geiger es una herramienta que muestra estadísticas sobre el uso inseguro del código Rust, en una caja Rust y todas sus dependencias. Su capacidad para concentrarse en posibles problemas es una característica beneficiosa. La existencia de un código peligroso ya es un problema en dichos proyectos, y dichas entradas deben verificarse dos veces.
 	Cargo Audit: verifica los archivos en busca de cajas que contienen vulnerabilidades de seguridad. Es decir, muestra bibliotecas desactualizadas que todavía se usan. Sin embargo, debes utilizarlo para fines de auditoría.
 	Clippy, el analizador estático, es un filtro de código increíble para detectar errores comunes y mejorar su código Rust.
 	Cargo Tarpaulin, para cobertura de prueba, una herramienta muy útil que revela la cantidad de líneas de código que no están cubiertas por las pruebas.



III —Auditoría de Informes Públicos
Nuestras auditorías de informes públicos de los proyectos del ecosistema NEAR, están estructurados de acuerdo con el esquema de flujo de auditoría presentado anteriormente, por lo que te recomendamos que compares estos informes, en particular sus resultados, con los siguientes:

 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

¡Esperamos que este artículo haya sido informativo y útil! ¡Gracias por leer! ¿Qué instrumentos deberíamos revisar? ¿Qué te interesaría leer en nuestro blog?

Si todavía tiene consultas, ¡no dudes en preguntar! ¡Estaremos encantados de responder todas las interrogantes que tengas! ¡Las mejores preguntas y respuestas pueden incluirse en la próxima publicación del blog!
Por cierto, ahora hay algunos espacios vacantes, así que si tu proyecto necesita una auditoría, no dudes en escribirnos, visita nuestra página de informes públicos aquí.

### Exploradores blockchain en NEAR

Después del colapso de FTX, tomar el control de tus criptos se ha vuelto más crítico que nunca. Una de las formas más importantes de hacerlo es aprender a leer un explorador de bloques. Para el Protocolo NEAR, los exploradores de bloques más populares son:

 	NEAR Explorer
 	NearBlocks
 	NearScan

¿Qué es un explorador de blockchain?
Un escáner de blockchain (cadena de bloques) es un software utilizado para visualizar diferentes métricas referentes a la red de la blockchain, tales como:

 	Hashrate
 	Tamaño de Bloque
 	Dificultad de Bloque
 	Media de comisión por transacción

Entonces, ¿qué puedes hacer con el explorador de blockchain? Vamos a ver.

 	Realizar un seguimiento del estado de una transacción pendiente mientras esta espera en el mempool.
 	Realizar un seguimiento del saldo de las billeteras sin tener que usar la billetera en sí. Esto puede ser útil si deseas verificar el saldo en tu billetera de hardware.
 	Realizar un seguimiento de cada transacción que entra y sale de una dirección en particular.
 	Ver bloques huérfanos, también conocidos como bloques que no están conectados a la cadena principal.
 	Explorar las transacciones de ballenas (Cuentas con una gran cantidad de tokens) que podrían tener un gran impacto en el mercado.
 	Mantener un registro de las direcciones (cuentas) de los líderes cripto conocidos.
 	Llevar un registro de las monedas posteriores a algún hackeo.

¿Cómo funcionan los exploradores de blockchain?
Los exploradores de blockchain funcionan junto con los nodos de blockchain y utilizan interfaces de programación de aplicaciones (API), bases de datos relacionales y bases de datos SQL para recuperar información relevante de la red subyacente. Aquí hay algunas cosas a tener en cuenta:

 	El explorador organiza toda esta información en una base de datos y muestra estos datos en un formato qué sea más fácil de buscar y encontrar.
 	Los usuarios pueden realizar búsquedas a través de una tabla organizada.
 	Todas las solicitudes de búsqueda se envían al servidor backend, que proporciona las respuestas requeridas.

¿Cómo usar un explorador de blockchain?
Para nuestras primeras demostraciones, veamos el NEAR explorer. Pongamos una cuenta seleccionada al azar en el escáner. Para ver qué datos obtenemos.

La primera sección que vemos tiene los siguientes datos:

 	Transacciones: El número de transacciones enviadas y recibidas. Esta cuenta ha enviado 1,816 transacciones y no ha recibido ninguna.
 	Almacenamiento utilizado: El almacenamiento total utilizado por la cuenta de la cadena de bloques. Esta cuenta usa 390 kB.
 	Saldo de cuenta nativo: la cantidad de tokens NEAR que actualmente posee la cuenta. Esta cuenta contiene 81.1916 NEAR.
 	Participación del validador: ¿Esta cuenta está delegando NEAR para respaldar un validador y asegurar la red? La cuenta ha delegado 23,439,675.24565 NEAR detrás de un validador.
 	Creado: La cuenta se creó el 15 de febrero de 2022 a las 4:49:20 a. m.
 	Transacción creada: El hash de transacción responsable de crear esta cuenta es  4Buu2pWuViuXCVPJpLJZgLvYwogzaaazKn5jqoGYqV7Y.

Cuando te desplaces hacia abajo, verás el historial de transacciones de esta cuenta.

Revisar el estado de la transacción
Pongamos un hash de transacción aleatoria en el explorador y veamos cómo se ve. Primero, pondremos este hash de transacción:

2cFARvPto5Pu31jwouLMD2yWdPWYAYVFX5UCRSazsCH3

This is a standard transaction where one account sends some coins to another. So let’s go through the details.

Esta es una transacción estándar en la que una cuenta envía algunas monedas a otra. Así que repasemos los detalles.

 	Remitente: Esta es la cuenta que firmó y envió la transacción, en este caso es: "Sweat_welcome.near".
 	Receptor: Esta es la cuenta que recibe la transacción, en este caso es: 8db1b70f0b7803a29e014d4d03cceffac7347ca54c2410ddc489d263dab27d97.
 	Estado: El estado actual de las transacciones. Esto podría ser Pendiente, Correcto, Fallido/Finalizado o no finalizado. En este caso, es Correcto.
 	Tarifa de transacción: esta es la tarifa requerida para ejecutar esta transacción. En este caso, es 0.00008 NEAR.
 	Valor del depósito: este es el valor total que se transfiere de la cuenta de remitente a la cuenta del receptor. En este caso, el valor del depósito es 0,5 NEAR.
 	Gas utilizado: Las unidades de gas necesarias para ejecutar la transacción. En este caso, es 1 Tgas ( 1 TeraGas = 10¹² unidades de gas).
 	Creado: esta transacción se creó el 17 de noviembre de 2022 a la 1:18:33 pm.
 	Hash de bloque: el identificador único (hash) del bloque en el que se incluyó esta transacción. En este caso, el hash de bloque es F3fPB67dr2VYvfKCWVxQcYwHwdnn7SA3QL1BwpJ3ixKN

Recibo de la transacción


 	El explorador también nos muestra un recibo. El recibo en sí tiene dos partes.
 	La primera parte es el recibo de la transacción en sí. Hay un ID de recibo y el total de gasolina y tokens quemados.
 	La segunda parte es el recibo del sistema. "Systema" es una cuenta especial que se utiliza para identificar recibos de reembolso.

Usando otros exploradores de NEAR
Usemos la misma transacción en NearScan y NearBlocks para ver cómo difiere la presentación de datos entre estos exploradores.
NearBlocks

The NearBlocks explorer shows the same data as the total gas and tokens burnt during the transaction.

El explorador NearBlocks muestra los mismos datos, el gas total y los tokens quemados durante la transacción.
NearScan

La interfaz NearScan le brinda prácticamente los mismos datos, aunque datos de gas muestran más decimales que el NEAR Explorer.
Conclusión
Hay transacciones más complicadas en la cadena de bloques NEAR. Sin embargo, este artículo debería darte una idea de cómo leer estas transacciones. Los exploradores te permiten explotar uno de los rasgos más esenciales de la tecnología blockchain: la transparencia. Te permite a ti como usuario rastrear meticulosamente tus monedas y ver a dónde van.




	

	
	
		
			
				¿Cuál de los siguientes escáneres se puede utilizar para el protocolo NEAR?
			
		

		
					

		
			
			
			
			Etherscan
		
			
			Bitcoin scanner
		
			
			NearScan
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Para cuál de las siguientes acciones puedo usar un escáner?
			
		

		
					

		
			
			
			
			Ver el historial de transacciones de una cuenta
		
			
			Verificar cuánto gasté en tarifas de gas en mi última transacción
		
			
			Todo lo anterior
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Qué hace la "Cuenta System"?
			
		

		
					

		
			
			
			
			Validar transacciones
		
			
			Identificar recibos de reembolso
		
			
			Agregar transacciones
		
	
		

		
		
			
				Correct!
				Wrong!

### Auditar Proyectos en la Blockchain de NEAR: Desde Cero a Héroe

¡Saludos estimados lectores!
Hoy vamos a mirar algunos consejos profesionales en la auditoría de contratos inteligentes en la blockchain de NEAR. En esta serie, nos vamos a enfocar en esos aspectos que pueden ser realmente útiles para auditar proyectos basados en NEAR. ¡Todo lo que vas a encontrar a continuación, se basa en nuestra experiencia personal! 

En primer lugar, nos gustaría expresar nuestro más sincero agradecimiento a los creadores de NEAR y los proyectos de su ecosistema, a todos los que lo apoyan, los autores de los materiales informativos y por supuesto, a nuestros brillantes auditores que nos han ayudado a revelar información tan necesaria y así levantar la cortina del secreto. Y hoy, queridos lectores, estará disponible para ustedes.

Podemos decir con confianza que estos consejos se pueden leer de forma pública en varios lugares, ¡y nuestro blog es uno de esos lugares! A continuación, te traemos nuestras observaciones: hechos innegables para auditores, trucos y los top hacks compartidos por nuestros mejores auditores. ¡Vamos a comenzar!

Por cierto, en estos momentos tenemos algunos espacios vacantes, así que si tu proyecto necesita una auditoría, escríbenos, visita nuestra página de informes públicos aquí.
I — ¿Qué es NEAR?
NEAR es una plataforma de desarrollo, construida sobre una blockchain de capa uno fragmentada y de Prueba de Participación. Gracias a la tecnología de fragmentación, NEAR ofrece soluciones a problemas como la velocidad de procesamiento, congestión de la red y altas comisiones por gas, permitiendo una escalabilidad significativa de la plataforma sin sacrificar la seguridad del protocolo.

Es importante tener en mente que NEAR es una blockchain fragmentada escalable, lo que quiere decir que los contratos inteligentes que se ejecutan, se compilan en WebAssembly (WASM) y pueden ser escritos en lenguajes como:

 	Rust
 	AssemblyScript (un tipo de lenguaje TypeScript para WebAssembly)
 	Solidity (vía Aurora EVM)c
 	Javascript (vía JS-VM)

El uso de WASM da como resultado un alto límite de gas y eficiencia, una generación rápida de bloques y tarifas de transacción bajas. Los contratos inteligentes en NEAR pueden considerarse como microservicios que contienen datos y códigos ejecutables. Las interacciones entre los contratos cruzados se realizan de forma asíncrona.

Con todo lo dicho, desde nuestra perspectiva, el Ecosistema NEAR está, en su mayoría ¡basado en Rust!

https://github.com/rust-in-blockchain/awesome-blockchain-rust
La plataforma reúne a miles de miembros de la comunidad para brindar la mejor experiencia, así como, un amplio ecosistema multifuncional:


La plataforma se basa en varias características claves:

En términos de seguridad de producción de bloques, emplea un mecanismo conocido como Doomslug. El Doomslug, a pesar de su nombre ominoso, es muy sencillo y asume que diferentes validadores toman turnos para producir bloques en función de la cantidad de tokens NEAR stakeados.

No iremos a los detalles en este artículo porque asumimos que tú, querido lector, ya tienes suficiente entendimiento sobre el ecosistema de NEAR, así que te recomendamos que visites su base de conocimientos y estudies la documentación del proyecto para una mejor comprensión:

https://docs.near.org/

II — Procedimiento de Revisión del Proyecto NEAR por el Equipo de Pessimistic.io:
Debido a que los principales obstáculos que un auditor puede tener mientras audita proyectos en NEAR, son lógicos; la primera sugerencia para cualquier firma será un desarrollo competente, que dé como resultado una documentación sólida y pruebas confiables. Esto parece muy simple para ser verdad, ¡pero asegúrate de que funcione y se pruebe así misma en el tiempo!
Así pues, nuestro brillante equipo de auditoría desea presentarte nuestro conjunto de reglas, acumuladas durante muchos meses y años de trabajo, en el cual trataremos de evitar la redundancia y trataremos de transmitir todo de forma concisa y profesional. Con lo anterior dicho, realizamos nuestras auditorías de acuerdo a los siguientes procedimientos:

Análisis Automatizado:

 	Recopilamos contratos;
 	Corremos las pruebas proporcionadas y revisamos la cobertura del código;
 	Ejecutamos herramientas de análisis y verificamos manualmente (rechazamos o confirmamos) todos los problemas informados (ver a continuación).

Auditoría Manual

 	Revisamos manualmente códigos y evaluamos su calidad;
 	Verificamos el código en búsqueda de vulnerabilidades conocidas;
 	Revisamos si la lógica del código cumple con la documentación entregada;
 	Sugerimos posibles optimizaciones de gas y almacenamiento;

Problemas:
Estamos activamente en la búsqueda de:

 	Problemas de control de acceso (identificación/autorización incorrecta de administradores o usuarios);
 	Problemas de activos perdidos/robados (activos atascados en el contrato o enviados a ninguna parte o a una cuenta incorrecta);
 	DoS debido a problemas lógicos (interbloqueo, error de máquina de estado, etc.);
 	DoS debido a problemas técnicos (error de falta de gas, otras limitaciones);
 	Problemas de interacción del contrato (reentrada, llamadas inseguras, suposiciones de la persona que llama);
 	Problemas aritméticos (desbordamiento, subdesbordamiento, problemas de redondeo);
 	Uso incorrecto de Near SDK;
 	Otros problemas.

Gas:
Verificamos si las operaciones intensivas de gas se ejecutan de forma eficiente: 

 	Colecciones: las colecciones de std::collections se leen todas juntas, lo que infla el consumo de gas. Debes usar near_sdk::collections o near_sdk::store;
 	Las colecciones están vinculadas a un almacenamiento y puedes accidentalmente olvidarte de sincronizarlas;
 	Mapas: LookupMap / UnorderedMap / TreeMap: debes elegir de acuerdo con la funcionalidad requerida (el primero es el más barato, el último el más poderoso);
 	LazyOption: para los "big data" raramente utilizados (solo se pueden usar en el constructor);
 	Borsh/JSON para la serialización de mensajes (parámetros/valores de retorno) — afecta el consumo de gas;
 	Mira de cerca el ataque “million cheap data additions” para evitar problemas similares.

Herramientas:
Vamos a darle una mirada a las herramientas de análisis automáticos que puedes usar en tu trabajo y sus características: 

 	Valgrind: se puede usar si el código incluye bloques inseguros con una asignación de memoria peligrosa. Sin embargo, tal práctica levanta una bandera roja para la auditoría. En general, ejecutar valgrind no tiene mucho sentido.
 	Cargo Geiger es una herramienta que muestra estadísticas sobre el uso inseguro del código Rust, en una caja Rust y todas sus dependencias. Su capacidad para concentrarse en posibles problemas es una característica beneficiosa. La existencia de un código peligroso ya es un problema en dichos proyectos, y dichas entradas deben verificarse dos veces.
 	Cargo Audit: verifica los archivos en busca de cajas que contienen vulnerabilidades de seguridad. Es decir, muestra bibliotecas desactualizadas que todavía se usan. Sin embargo, debes utilizarlo para fines de auditoría.
 	Clippy, el analizador estático, es un filtro de código increíble para detectar errores comunes y mejorar su código Rust.
 	Cargo Tarpaulin, para cobertura de prueba, una herramienta muy útil que revela la cantidad de líneas de código que no están cubiertas por las pruebas.



III —Auditoría de Informes Públicos
Nuestras auditorías de informes públicos de los proyectos del ecosistema NEAR, están estructurados de acuerdo con el esquema de flujo de auditoría presentado anteriormente, por lo que te recomendamos que compares estos informes, en particular sus resultados, con los siguientes:

 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

¡Esperamos que este artículo haya sido informativo y útil! ¡Gracias por leer! ¿Qué instrumentos deberíamos revisar? ¿Qué te interesaría leer en nuestro blog?

Si todavía tiene consultas, ¡no dudes en preguntar! ¡Estaremos encantados de responder todas las interrogantes que tengas! ¡Las mejores preguntas y respuestas pueden incluirse en la próxima publicación del blog!
Por cierto, ahora hay algunos espacios vacantes, así que si tu proyecto necesita una auditoría, no dudes en escribirnos, visita nuestra página de informes públicos aquí.

### Auditer de Projets sur la Blockchain NEAR : de Zéro à Héros

Salutations chers lecteurs !

Aujourd'hui, nous allons examiner quelques conseils professionnels sur l'audit des contrats intelligents sur la blockchain NEAR. Dans cette série, nous allons nous concentrer sur les aspects qui peuvent être vraiment utiles pour auditer des projets basés sur NEAR. Tout ce que vous trouverez ci-dessous est basé sur notre expérience personnelle ! 

Tout d'abord, nous voudrions exprimer nos sincères remerciements aux créateurs de NEAR et aux projets de son écosystème, à tous ses supporters, aux auteurs des supports d'information et bien sûr, à nos brillants auditeurs qui nous ont aidés à révéler beaucoup - avaient besoin d'informations et ainsi lever le rideau du secret. Et aujourd'hui, chers lecteurs, il sera à votre disposition.

Nous pouvons dire avec confiance que ces conseils peuvent être lus publiquement à divers endroits, et notre blog  c’est l'un de ces endroits ! Voici notre point de vue : des faits indéniables pour les testeurs, des astuces et les meilleurs hacks partagés par nos meilleurs testeurs. On va commencer !
Au fait, en ce moment nous avons des postes vacants, donc si votre projet a besoin d'un audit, escrivez-nous, visitez notre page de rapports public ici.

I — C'est quoi NEAR ?
NEAR est une plate-forme de développement, construite sur une blockchain de couche un, fragmentée ou sharded et de preuve de participation . Grâce à la technologie de partitionnement, NEAR propose des solutions à des problèmes tels que la lenteur de la vitesse de traitement, la congestion du réseau et les charges de gaz élevées, permettant une évolutilité significative de la plate-forme sans sacrifier la sécurité du protocole.
Il est important de garder à l'esprit que NEAR est une blockchain fragmenée évolutive, ce qui signifie que les contrats intelligents déployés sont compilés en WebAssembly (WASM) et peuvent être écrits dans des langages :


 	Rust
 	AssemblyScript (un langage de type TypeScript pour WebAssembly)
 	Solidity (vía Aurora EVM)c
 	Javascript (vía JS-VM)

L'utilisation de WASM se traduit par une limite et une efficacité de gaz élevées, une génération de blocs rapide et des frais de transaction réduits. Les contrats intelligents dans NEAR peuvent être considérés comme des micro-services contenant des données et du code exécutable. Les interactions entre contrats sont effectuées de manière asynchrone.

Cela dit, de notre point de vue, NEAR Ecosystem est principalement basé sur Rust !

https://github.com/rust-in-blockchain/awesome-blockchain-rust
La plateforme rassemble des milliers de membres de la communauté pour offrir la meilleure expérience, ainsi qu'un vaste écoyisteme multifonctionnel :


La plataforme se base sur plusieurs fonctionnalités clés :

En termes de sécurité de production de blocs, il utilise un mécanisme connu sous le nom de Doomslug. Le Doomslug, malgré son nom inquiétant, est très simple et suppose que différents validateurs produisent à tour de rôle des blocs en fonction du nombre de jetons NEAR stakés.

Nous n'entrerons pas dans les détails dans cet article car nous supposons que vous, cher lecteur, avez déjà une compréhension suffisante de l'écosystème NEAR, nous vous recommandons donc de visiter leur base de connaissances et d'étudier la documentation du projet pour une meilleure compréhension :

https://docs.near.org/

II — Procédure d'examen du Projet NEAR par l'équipe Pessimistic.io :
Parce que les principaux obstacles qu'un auditeur peut rencontrer lors de l'audit de projets dans NEAR sont logiques ; La première suggestion pour toute entreprise sera un développement compétent, résultant en une documentation solide et des tests fiables. Cela semble trop simple pour être vrai, mais assurez-vous que cela fonctionne et fait ses preuves au fil du temps !
Notre brillante équipe d'audit souhaite donc vous présenter notre ensemble de règles, accumulées au fil de nombreux mois et années de travail, dans lesquelles nous essaierons d'éviter les redondances et de tout transmettre de manière concise et professionnelle. Compte tenu de ce qui précède, nous avons effectué nos audits selon les procédures suivantes :

Analyse Automatisée :

 	Nous collectons les contrats;
 	Nous exécutons les tests fournis et examinons la couverture du code ;
 	Nous exécutons des outils d'analyse et vérifions manuellement (rejetons ou confirmons) tous les problèmes signalés (voir ci-dessous).

Vérification Manuelle :

 	Nous examinons manuellement les codes et évaluons leur qualité ;
 	Nous vérifions le code pour les vulnérabilités connues ;
 	Nous vérifions si la logique du code est conforme à la documentation livrée ;
 	Nous suggérons des optimisations possibles de gaz et de stockage ;

Problèmes :
Nous recherchons activement :

 	Problèmes de contrôle d'accès (identification/autorisation incorrecte des administrateurs ou des utilisateurs) ;
 	Problèmes d'actifs perdus/volés (actifs bloqués dans un contrat ou expédiés nulle part ou sur un mauvais compte) ;
 	DoS dû à des problèmes logiques (blocage, erreur de machine d'état, etc.) ;
 	DoS dû à des problèmes techniques (errour de manque de gaz, autres limitations) ;
 	Problèmes d'interaction avec le contrat (réentrance, appels non sécurisés, hypothèses d’appelants);
 	Problèmes arithmétiques (débordement, sous-débit, problèmes d'arrondi);
 	Utilisation incorrecte de Near SDK;
 	D'autres problèmes.

Gaz:
Nous vérifions si les opérations intensives en gaz sont réalisées efficacement :

 	Collections: les collections de std :: collections sont toutes lues ensemble, ce qui gonfle la consommation de gaz. Vous devez utiliser near_sdk::collections ou near_sdk::store ;
 	Les collections sont liées à un stockage et vous pouvez accidentellement oublier de les synchroniser ;
 	Cartes: LookupMap / UnorderedMap / TreeMap - il faut choisir selon la fonctionnalité recherchée (la première est la moins chère, la dernière est la plus puissante) ;
 	LazyOption: para los "big data" raramente utilizados (solo se pueden usar en el constructor);
 	pour les "big data" rarement utilisés (ne peut être utilisé que dans le constructeur) ;
 	Borsh/JSON pour la sérialisation des messages (paramètres/valeurs de retour) — affecte la consommation de gaz ;
 	Examinez attentivement l'attaque «million d’adjouts de données bon marché» pour éviter des problèmes similaires.

Outils :
Examinons les outils d'analyse automatique que vous pouvez utiliser dans votre travail et leurs fonctionnalités :

 	Valgrind : Peut être utilisé si votre code comprend des blocs non sécurisés avec une allocation de mémoire dangereuse. Cependant, une telle pratique lève un drapeau rouge pour l'audit. En général, exécuter valgrind n'a pas beaucoup de sens.
 	Cargo Geiger : est un outil qui affiche des statistiques sur l'utilisation non sécurisée du code Rust, dans une boîte Rust et toutes ses dépendances. Votre capacité à vous concentrer sur les problèmes potentiels est un trait bénéfique. L'existence d'un code dangereux est déjà un problème dans de tels projets, et ces entrées doivent être vérifiées une deuxième fois.
 	Cargo Audit : Vérifie les fichiers pour les boîtes qui contiennent des vulnérabilités de sécurité. Autrement dit, il affiche les bibliothèques obsolètes qui sont toujours utilisées. Cependant, vous devez l'utiliser à des fins d'audit.
 	Clippy : est un filtre de code incroyable pour détecter les erreurs courantes et améliorer votre code Rust.
 	Cargo Tarpaulin : pour la couverture des tests, un outil très utile qui révèle le nombre de lignes de code qui ne sont pas couvertes par les tests.



III —Audit des Rapports Publics
Nos audits des rapports publics des projets de l'écosystème NEAR sont structurés selon le schéma de flux d'audit présenté ci-dessus, nous vous recommandons donc de comparer ces rapports, en particulier leurs résultats, avec les éléments suivants :

 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

Nous espérons que cet article a été informatif et utile ! Merci pour la lecture ! Quels instruments devrions-nous revoir? Qu'aimeriez-vous lire sur notre blog ?

Si vous avez encore des questions, n'hésitez pas à demander ! Nous serons heureux de répondre à toutes vos questions ! Les meilleures questions et réponses peuvent être incluses dans le prochain article du blog !
Au fait, il y a des créneaux vacants en ce moment, donc si votre projet a besoin d'un audit, n'hésitez pas à nous écrire, visitez notre page de rapport public ici.

### La guía para las finanzas de PembRock

Disfruta de las Ventajas de LYF con PembRock
Introducción
En esta guía, analizamos las formas más extendidas de ganar con DeFi (farmeo de rendimiento, préstamos y stakinhg) a través de la lente de PembRock, la primera y única plataforma LYF en NEAR Protocol que funciona con Ref.finance DEX.

Empecemos con lo básico.
¿Qué es el farming de rendimiento?
Para que cualquier proyecto de Finanzas Descentralizadas funcione, debe haber liquidez. La liquidez es lo que hace que las transacciones sean posibles, y los participantes que hacen que las plataformas sean líquidas se denominan proveedores de liquidez o PL. Ahora, por hacer eso, son recompensados ​​con tokens PL de un grupo en particular (también llamados "acciones") a través de un proceso conocido como minería de liquidez. Estos tokens representan la participación del usuario en la liquidez total, que a su vez determina sus ganancias potenciales.

El farming de rendimiento es un incentivo adicional que recompensa a los usuarios por el mero hecho de bloquear sus fondos para que otros participantes puedan usarlos para ganarse la vida. Después de recibir los tokens PL, un proveedor de liquidez puede colocarlos en un grupo de farming de rendimiento para convertirse en farmer. Para eso, obtendrán pagos adicionales en la criptomoneda nativa de la plataforma (en el caso de Ref.finance, sería $REF; en el caso de PembRock, sería $PEM; y así sucesivamente) o una criptomoneda diferente (por ejemplo, USDT), dependiendo de las reglas del progarama de farming dado.
¿Qué es el Farming de Rendimiento Apalancado?
Con el farming de rendimiento regular, solo puede proporcionar la cantidad que tienes, lo que parece lógico. Pero, ¿y si quisieras maximizar los rendimientos (y los riesgos, no lo olvide)? En ese caso, necesitarías pedir prestados fondos de otros, y eso es lo que le ayuda a hacer el farming de rendimiento apalancado.

Si bien muchas plataformas DeFi requieren que los usuarios depositen fondos de un valor mayor que los que se toman prestados (lo que también se conoce como sobrecolateralización), PembRock no lo hace, lo que brinda a los farmers la oportunidad de retirar una cantidad que es hasta tres veces mayor.

Entonces, si, por ejemplo, decidieras proporcionar 100 USN como garantía y tomar prestados 200 USN, tendrías 300 USN en total, lo que significa que el nivel de apalancamiento sería 3 con un índice de deuda del 67%. Si el precio de USN bajó más del 31%, eso significaría que tu pérdida ya no podría cubrirse. Ahí es cuando ocurriría la liquidación.

¿Qué es el préstamo o lending?
Prestar o lending es una estrategia que te permite ganar intereses por permitir que otra persona use tu dinero. Al mismo tiempo, a diferencia de los farmers, los lenders no están propensos al riesgo de liquidación (por ejemplo, piensa en una situación en la que uno de los activos en un grupo cae a $0), mientras que sus rendimientos se capitalizan automáticamente y se pagan de forma regular. Suena justo, ¿verdad?
Antes de que comiences
Dirígete a  app.pembrock.finance y presiona el botón Connect wallet que verás en la esquina superior derecha. Aparecerá la ventana de selección de billetera; elige el que prefieras. Después de eso, accederá a tu billetera, donde deberás habilitar ciertos derechos de acceso y permitir que la aplicación PembRock gaste parte de tus NEAR para cubrir las tarifas de transacción.

Farming de rendimiento apalancado

Para farmear el rendimiento con apalancamiento, primero deberás cargar tu billetera con el activo con el que deseas hacer eso.

Paso 1. Ve a la sección Farm: app.pembrock.finance/farm.

Paso 2. Selecciona el par y cliquea Farm.

Paso 3. Elije el activo que deseas depositar, el que deseas pedir prestado, sus montos y el apalancamiento (entre 1x y 3x con un incremento de 0,5).

Paso 4. Cliquea Farm y confirma la transacción.Ten en cuenta que puedes tener varias posiciones de farming abiertas al mismo tiempo, por lo que si tienes otro grupo en mente, simplemente regresas y repites el proceso.
Cerrar una Posición de Farming y Reclamar Recompensas
Paso 1. Ve a Portfolio y cambiar a la pestaña Farm Positions.

Paso 2. Presiona Close junto a la posición de la que deseas salir.

Paso 3. En la siguiente pantalla, puede cerrar la posición por completo.

Minimize Trading - Minimizar el comercio significa que convertiremos la cantidad mínima requerida de tokens en el token prestado para pagar la deuda y devolverle los activos restantes.

Convert all - Convertir todo significa que toda tu posición se convertirá en el token prestado y se te devolverá después de que se pague la deuda.

Paso 4. Si deseas cerrar tu posición por completo, desplázate hacia abajo y presiona Close Position, luego haz una aprobación en su billetera.




	

	
	
		
			
				Con respecto a la agricultura de rendimiento apalancado, PembRock...
			
		

		
					

		
			
			
			
			Sobrecolateraliza
		
			
			Subcolateraliza
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Lending
Para hacer uso de los préstamos, primero deberás recargar tu billetera con el activo que vas a proporcionar.

Paso 1.  Ve  a app.pembrock.finance/lend, selecciona el activo y cliquea Deposit.

Paso 2. Especifica la cantidad que deseas prestar y confirma la transacción. Ten en cuenta que puedes prestar en más de un grupo a la vez, por lo que si tienes otro activo en mente, simplemente regresa y repite el proceso.

Reclamar Recompensas
PembRock Finance incentiva a ambos lenders y  prestamistas (farmers).

Paso 1. Ve a app.pembrock.finance. Allí, verás una pestaña de Portfolio con una subsección de Unlocked Rewards.

Paso 2. Presiona Claim y aprueba la transacción en de tu billetera.
Hacer Retiros/Ajustes
Paso 1. Ve a app.pembrock.finance/lend-pools. Allí, verás una lista de los activos que ha proporcionado.

Paso 2. Elige el activo que ya no estás dispuesto a prestar y haz clic en el botón de flecha hacia abajo a la derecha del cuadro.

Paso 3. Ingresa la cantidad que deseas retirar y presione Withdraw.

Alternativamente, puedes ajustar la posición agregando más tokens en lending.
Acerca de PembRock
PembRock fue creado por INC4—una empresa profesional de desarrollo de blockchain de origen ucraniano que existe desde 2013.

La idea principal detrás de PembRock era llevar el comercio con apalancamiento, una herramienta ampliamente disponible para los jugadores en los mercados financieros tradicionales, a un sector DeFi incipiente pero en tendencia.

En marzo de 2022, PembRock Finance recibió una subvención de US$75,000 de la Fundación NEAR destinada a ayudar al desarrollo, la mejora adicional y la adopción del protocolo.
Utilidad de $PEM
PEM es el token digital nativo del protocolo de PembRock. Tiene cuatro casos de uso principales:

 	Los titulares de PEM quienes stakean sus tokens comparten todos los ingresos que genera el protocolo.
 	También guían el proceso de toma de decisiones del proyecto a través de la participación en DAO.
 	El token es fundamental para el mecanismo que distribuye recompensas por interactuar con el protocolo.
 	$PEM también se utiliza para proporcionar una bonificación adicional a quienes suministran liquidez a nuestros fondos comunes.

Para lugares donde comprarlo, busca aquí.

 	Nombre: PembRock Finance Token
 	Clave: PEM
 	Suministro total: 160M unidades
 	Red: Protocolo NEAR
 	Dirección del contrato: token.pembrock.near





	

	
	
		
			
				¿Qué utilidad NO tiene el token $PEM?
			
		

		
					

		
			
			
			
			Reparto de beneficios
		
			
			Votación
		
			
			Incentivación
		
			
			Distribución de NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Qué es Staking?
Dentro del protocolo PembRock, staking significa bloquear PEM a cambio del derecho a obtener una parte de los ingresos obtenidos por el protocolo y participar en la Organización Autónoma Descentralizada, lo que influye en las decisiones, incluso sobre cuánto deben ganar los farmers y los lenders mencionados anteriormente. Cuanto mayor sea la cantidad stakeada y más largo el período, mayor será el poder de voto y las recompensas.

Supongamos que apuestas 1000 PEM durante 4 años a cambio de 1000 unidades de poder de voto (que se otorgan en forma de tokens vePEM), mientras que otra persona apuesta 1000 PEM durante 2 años a cambio de 500 unidades de poder de voto (porque aunque apostaron el mismo volumen, lo hicieron por un período dos veces más corto). Juntos, su poder de voto sería de 1.500. Entonces, si un protocolo generara 100 PEM en recompensas semanales, obtendrías 66,66 PEM (porque tu participación en el monto total apostado sería 66,66 %) y otro participante solo 33,33 PEM (el suyo sería 33,33 %).
¿Cómo Stakear
Para stakear y unirte por proxy al DAO, necesitarás el token digital nativo de PembRock llamado PEM. Si aún no posees ningún PEM, aquí puedes solucionarlo.

Paso 1. Ve a app.pembrock.finance/staking;

Paso 2. Escribe la cantidad que desea stakear y la duración (el poder de voto estimado se puede ver debajo de la Fecha de finalización).

Paso 3. Presiona Confirm.
¿Cómo hacer ajustes?
El poder de voto está disminuyendo gradualmente, pero puedes ajustar tu posición (stakear más y/o por más tiempo) para mantener tu influencia al mismo nivel o incluso hacerla más sustancial.

Paso 1. Desplázate hacia abajo hasta la parte inferior de app.pembrock.finance/staking;

Paso 2. Escribe la cantidad que te gustaría stakear además de lo que ya has stakeado y presiona Confirm;

Paso 3. Después de eso, puedes prolongar el período de bloqueo.

Reclamos y Retiro
Para retirar PEM una vez que finaliza el período de bloqueo o solicitar el pago de tus recompensas en PEM, visita app.pembrock.finance/staking. Una vez disponibles, los botones se volverán de color naranja.




	

	
	
		
			
				¿Cuál de las siguientes afirmaciones es verdadera?
			
		

		
					

		
			
			
			
			La cantidad stakeada es el único factor que determina el poder de voto
		
			
			El período de staking es el único factor que determina el poder de voto
		
			
			Tanto la cantidad como el plazo determinan el poder de voto
		
			
			Ninguna de las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cómo participar en els DAO
En el DAO, puede establecer la cantidad de recompensas que se otorgan tanto a los lenders como a los farmers cada mes.

Paso 1. Ve a la  app.pembrock.finance/voting. Allí, verás dos pestañas para Recompensas:—Lenders y Borrowers (prestatarios)

Lenders’ Rewards son ganadas por los participantes que depositan en grupos de préstamos. Borrowers’ Rewards son ganadas por los participantes que toman prestados activos de los grupos de préstamo.

Los pasos a continuación son los mismos para ambos.

Paso 2. Distribuye tu poder de voto a los grupos utilizando el campo Vote. Cuanto mayor sea el porcentaje que proporciones, mayor será el rendimiento que generarás.

Recuerda que todos los % deben sumar 100.

Paso 3. Presiona Vote y confirma la transacción en tu NEAR Wallet.

Si cambias de opinión, puedes volver a votar mientras la ventana aún está abierta. Al hacerlo, asegúrate de especificar % para todos los activos nuevamente.
Conclusión
PembRock está ganando impulso ya que el mercado de DeFi en general y el espacio de farming de rendimiento apalancado en particular todavía están en su infancia. Al igual que Ref Finance fue pionera en el espacio DeFi de NEAR, PembRock se convirtió en el primer y único protocolo de farming de rendimiento apalancado de la red. Entonces, si quieres estar entre la multitud que marca tendencia, ¿por qué no probarlo (sin embargo, ten cuidado con los riesgoss)?

Si deseas mantenerte actualizado sobre todo lo relacionado con PembRock, a continuación encontrarás algunos enlaces para ti:

PembRock Website | Twitter | Telegram | Discord

### Cómo usar NEAR en tu teléfono

Una forma de usar NEAR en tu teléfono celular es con HERE Wallet. Esta es una billetera sin custodia, lo que significa que las claves privadas solo se almacenan en tu teléfono.

HERE Wallet se enfoca en entregarte la forma más fácil de usar NEAR. Puedes utilizar muchas aplicaciones directamente desde la billetera. También hay delegación líquida (de retiro inmediato) integrada en la aplicación con una tarifa de retiro instantáneo del 0%. Cuando realices cualquier transferencia, el dinero dejará de estar delegado instantáneamente.

En este artículo hemos cubierto cómo usar las funciones básicas de la aplicación HERE. Si tienes alguna pregunta, siempre puedes consultar al equipo de HERE en la sala de chat.
Iniciar sesión con la frase semilla
Si tienes una cuenta de NEAR, podrás iniciar sesión usando tu frase semilla:

 	Haz clic en "importar cuenta existente".
 	Haz clic en "usar frase inicial".
 	Ingresamos la frase inicial y hacemos clic en "buscar mi cuenta".


Si tienes cuenta en wallet.near.org

 	Haz clic en “import existing account” (importar cuenta existente).
 	Hacemos clic en “use seed phrase” (usar frase semilla).
 	Ingresa la frase semilla y haz clic en “find my account” (encontrar mi cuenta).
 	Haz clic en “import existing account” (importar cuenta existente).
 	Haz clic en “share the link” (compartir el enlace).
 	Envía el enlace a tu computadora personal.
 	Abre el enlace, selecciona la cuenta y haz clic en “Next” (siguiente).
 	Haz clic en “Connect” (conectar).
 	Ingresa el ID de la cuenta y haz clic en “Confirm” (confirmar).
 	Ahora estarás autorizado en el dispositivo móvil.


Configurar nombre de usuario (es gratis)
NEAR está disponible con nombres de usuario en lugar de direcciones. Por lo general, es necesario tener NEAR para crear un nombre de usuario, pero los asignamos de forma gratuita en la aplicación HERE. Simplemente, ingresa el nombre de usuario y haz clic en continuar.
NOTAS IMPORTANTES

Una vez que selecciones un nombre de usuario, no podrás cambiarlo. Lo único disponible es crear una nueva cuenta y transferir dinero.

No recomendamos usar tu apellido en el nombre de usuario, puede desanonimizarte.


Empezar a obtener ganancias
La billetera HERE tiene incorporada la delegación de liquidez, puedes retirar dinero en cualquier momento sin cargos.

 	Haz clic en el botón grande y redondo de color rosa "Earn" (Ganar).
 	Haz clic en "Start staking" (delegar).
 	Introduce la cantidad.
 	Haz clic en "Stake" (delegar).
 	¡Todo listo! Ahora recibirás un ingreso diario de 8-10% p.a. en tu saldo.


Reclamar dividendos

 	Haz clic en “Claim” (reclamar).
 	Espera a que cargue por completo.
 	¡Listo! Tus dividendos se han transferido a tu balance.


Deposita NEAR con otros activos

 	Hza clic en “Add money” (agregar dinero).
 	Haz clic en “Buy NEAR with other crypto” (comprar NEAR con otra cripto).
 	Seleccionar activo.
 	Deposita BTC en la dirección que se muestra.
 	Haz clic en “Done” (listo) después del depósito.
 	Puedes rastrear el estado del depósito en el historial de transacciones.


Cómo usar dApps

 	Selecciona “HERE Wallet” (billetera HERE) de la lista de aplicaciones en el sitio web.
 	Escanea el código QR con la cámara de  tu teléfono.
 	Serás redirigido a la aplicación. Haz clic en "Confirm" (confirmar).



 

### Transición de NEAR wallet: porqué sucederá y qué deberían hacer sus usuarios ahora

Sin duda, la mayoría de los usuarios de NEAR han oído hablar de la transición de la billetera NEAR. Pero todavía quedan muchas preguntas sobre sus razones, procesos y relación con MyNearWallet. Aquí están las preguntas más frecuentes sobre la transición junto con los comentarios del equipo de MyNearWallet.
¿Por qué debería cambiar de una billetera “oficial” desarrollada por Near Foundation a otra?
Para empezar, los usuarios de NEAR tienen diferentes necesidades y preferencias y es muy poco probable que un producto oficial las cubra todas ellas. En algún momento, los desarrolladores del ecosistema NEAR se dieron cuenta y decidieron que en un futuro cercano el ecosistema NEAR no tendrá una billetera oficial y se alentará a todas las DApps a usar un selector de billetera. La billetera oficial de NEAR, wallet.near.org, se convertirá en una página de listado para todas las billeteras del ecosistema. Las fechas exactas aún no se anuncian.

Los cambios deberían mejorar la descentralización e inspirar una sana competencia en el ecosistema NEAR. Como resultado, sin una billetera oficial, los usuarios obtendrán productos más avanzados.
¿Cómo está conectada MyNearWallet a la NEAR wallet (Billetera NEAR)?
Kikimora Labs está construyendo MyNearWallet sobre la base de código abierto de la billetera NEAR. La base de usuarios no se trasladó a MyNearWallet. La billetera en sí permaneció de código abierto. En el nuevo proyecto, el equipo de MyNearWallet comenzó a mejorar las funciones antiguas, agregar otras nuevas y fortalecer la seguridad. Por el momento, el equipo de soporte de MyNearWallet ayuda a los usuarios de ambas billeteras. Además, el equipo de MyNearWallet resuelve problemas de errores para dos proyectos, aunque, las nuevas funciones estarán disponibles solo en MyNearWallet.

La interfaz de MyNearWallet todavía se ve casi igual que wallet.near.org. Pero como afirma el equipo del proyecto, el diseño se cambiará sin interrupciones ni dificultades y de manera fluida.
¿Qué pasará con mi cuenta https://wallet.near.org/ ?
Los usuarios pueden transferir sus cuentas a cualquier billetera NEAR que deseen sin pérdida de fondos. Aquí están las instrucciones sobre cómo transferir su cuenta a MyNearWallet.
Hoja de ruta y estrategia de transición de billetera

 	Fase 0 — Creación y atracción de la comunidad [ahora]
 	Fase 1: Usuarios externos, habilitar las funcionalidades de exportación de la cuenta [comienza en octubre]
 	Fase 2: Un nuevo portal para lista de billeteras [Se espera que se complete a principios de 2023]
 	Fase 3: Finalizar el reenvío de transacciones
 	Fase 4: Extinción completa de la billetera NEAR

### Calimero là gì? Giới thiệu private sharding trên NEAR

Giải thích về private shard của mạng lưới Calimero - giải pháp cho vấn đề mở rộng quy mô mạng lưới và quyền riêng tư trên Blockchain
Điểm mạnh của công nghệ Blockchain là việc tất cả các bên tham gia vào mạng lưới đều có thể tin tưởng vào những thông tin được ghi trên đó. Lý do là dữ liệu một khi đã được lưu trên Blockchain sẽ không thể thay đổi, ngoài ra tất cả mọi người đều có thể theo dõi và tiếp cận những thông tin này theo thời gian thực. Tuy nhiên, hiện tại công nghệ Web3 vẫn chưa thực sự hoàn hảo, với hai vấn đề lớn còn tồn đọng trong việc áp dụng blockchain cho các doanh nghiệp: sự riêng tư của dữ liệu và khả năng để các doanh nghiệp có thể mở rộng quy mô khi áp dụng công nghệ blockchain.

Nếu như tất cả dữ liệu đều được công khai và minh bạch sẽ nảy sinh một số câu hỏi về quyền riêng tư:

 	Chuyện gì sẽ xảy ra nếu như dữ liệu đó chứa các thông tin cá nhân
 	Chúng ta có cần những cơ chế để bảo vệ dữ liệu cá nhân và yêu cầu mọi người phải tuân thủ theo không? Và ai có thẩm quyền với những cơ chế này?
 	Chuyện gì sẽ xảy ra nếu như dữ liệu đó thuộc dạng bí mật trong kinh doanh?

Việc bảo vệ sự riêng tư của dữ liệu cá nhân và doanh nghiệp là một điều cần thiết. Một giải pháp được đưa ra là kết hợp dữ liệu on-chain cùng với dữ liệu off-chain và khả năng tương tác của blockchain. Giải pháp này là hoàn toàn khả thi với các private shard của Calimero.

Chúng ta sẽ bàn kỹ hơn về Calimero ở phần sau, trước đó chúng ta cần trả lời một câu hỏi khá quan trọng nữa liên quan tới vấn đề mở rộng quy mô mạng lưới (scaling). Khả năng mở rộng là việc một blockchain có thể tăng số lượng giao dịch mà nó có thể xử lý thông qua việc tăng cường thêm các node hay các trình xác thực.

Mối quan tâm tới việc sử dụng tiền mã hóa và công nghệ blockchain ngày càng tăng, nhiều người dùng và công ty bắt đầu phát hành các loại token, xây dựng các Dapp hay tạo ra các NFT. Kết quả là, các mạng lưới blockchain bắt đầu tắc nghẽn, dẫn đến việc người dùng phải trả phí gas cao hơn, từ đó cũng gián tiếp làm giảm số lượng sản phẩm mới ra đời. Các giải pháp mở rộng quy mô mạng lưới ra đời nhằm giải quyết vấn đề này. Một ví dụ điển hình là NEAR, sử dụng công nghệ sharding để mở rộng quy mô và hỗ trợ việc sử dụng blockchain ngày càng tăng. Nhưng ngay cả với sharding, đối với một số doanh nghiệp có nhiều giao dịch blockchain mỗi ngày, chi phí trả cho việc xử lý giao dịch vẫn là khá tốn kém.

Calimero sinh ra nhằm khắc phục vấn đề chi phí sử dụng blockchain cho các doanh nghiệp. Với Calimero, các doanh nghiệp sẽ chỉ phải trả một số tiền cố định hàng tháng dựa trên số trình xác thực mà doanh nghiệp cần chạy, đổi lại các giao dịch trên blockchain sẽ hoàn toàn miễn phí và riêng tư.
Mạng lưới Calimero là gì?
Calimero là một sidechain tùy chỉnh được xây dựng dựa trên NEAR. Có thể được xem như một mạng lưới của các mạng lưới. Một giải pháp cho các doanh nghiệp để tiếp cận các tính năng bảo mật và mở rộng quy mô trên blockchain. Calimero cung cấp cho doanh nghiệp một cơ sở hạ tầng chia sẻ tất cả những lợi ích tốt nhất của NEAR, đồng thời được cải tiến với nhiều tính năng mới tập trung vào quyền riêng tư.

Calimero giúp doanh nghiệp:

 	Thuê các private shards cho riêng doanh nghiệp đó (bạn có thể hiểu shard giống như một blockchain riêng tư nhỏ mà chính bạn là người sở hữu)
 	Giao tiếp giữa các shards mà bạn sở hữu với các mạng lưới khác, hay với các shards thuộc sở hữu của các doanh nghiệp khác

Bằng cách sử dụng các private shards của Calimero, người dùng có thể mở rộng ứng dụng bằng cách tương tác với các ứng dụng và các giao thức mã nguồn mở, từ DeFi đến NFT. Người dùng có thể nắm giữ, quản lý tài sản công và di chuyển chúng giữa các private shards và các blockchain công khai khác một cách dễ dàng.

Hơn nữa, người dùng còn hưởng lợi từ các giao dịch cross-shard (phân đoạn chéo), cung cấp khả năng tương tác với các bên thứ ba trên chuỗi công khai hoặc các shard của các doanh nghiệp khác mà người dùng được phép truy cập. Các private shard có thể tương tác với nhau qua các kênh được mã hóa.

Có thể nói, với Calimero khả năng ứng dụng blockchain là vô tận.
Lợi ích của việc sử dụng các private shard từ Calimero
Các private shard của Calimero có tất cả các lợi ích mà NEAR mang lại như hiệu suất cao, bảo mật và tính bền vững. Nhưng có một điểm khác biệt quan trọng, các shard không sử dụng trình xác thực(validator), thực thi và lưu trữ trạng thái của NEAR, mà là các trình xác thực của riêng doanh nghiệp. Các lợi ích chính bao gồm:

 	Mở rộng quy mô kinh doanh với các giao dịch miễn phí trong các private shard.
 	Đặt một phần (hoặc tất cả) giao dịch của bạn ở chế độ riêng tư, chỉ những người / thực thể có quyền truy cập vào private shard mới có thể xem dữ liệu.
 	Khả năng tương thích của EVM - Bạn có thể sử dụng những DApp đã được xây dựng trên Ethereum thay vì phải xây dựng lại chúng từ đầu.
 	Khả năng tương thích WASM và hỗ trợ Javascript giúp dễ dàng đưa người dùng mới tới với web3
 	Khả năng tương tác - Các shard có thể giao tiếp với mạng NEAR và với các shard khác (mỗi shard có thể đại diện cho một doanh nghiệp khác nhau hoặc các bộ phận của cùng một doanh nghiệp) và nhờ các cầu nối, nhiều loại tài sản khác nhau như token (fungible token, NFT) có thể được chuyển qua lại một cách dễ dàng.
 	Có thể tùy chỉnh, hiệu suất cao và tiết kiệm chi phí. Có thể thực hiện tới 200.000 giao dịch mỗi giây (triển khai shard tiêu chuẩn có thông lượng 5.000 giao dịch mỗi giây). Thời gian đóng block, kích thước hợp đồng thông minh và gas limit có thể được tùy chỉnh. Chuyển giao các loại tài sản hay thực hiện truy xuất dữ liệu nhanh chóng (5-10 giây) và rất rẻ (chi phí chỉ khoảng một vài xu).

Calimero được phát triển để phục vụ những đối tượng nào?

 	Calimero đóng vai trò như cửa ngõ để các doanh nghiệp truyền thống (web2) tham gia vào thế giới web3 với một bảng điều khiển dễ sử dụng để quản lý các private shard của họ.
 	Đối với các doanh nghiệp đã hoạt động trên web3, những người cần các tính năng bảo mật và mở rộng quy mô

Calimero có thể được áp dụng trong những lĩnh vực nào trong thực tế?
Có vô số trường hợp mà Calimero có thể được sử dụng, trí tưởng tượng chính là giới hạn.

Chúng tôi có liệt kê một số ngành khác nhau dưới đây:

1. Quản trị
Hãy nghĩ đến việc các ngân hàng triển khai CBDC, hoặc KYC & các trường hợp chống rửa tiền. Dữ liệu cá nhân được lưu trữ trên một private shard và có thể có sẵn khi cần thiết, nhưng nếu không thì sẽ được ẩn với công chúng, đảm bảo tính riêng tư cho dữ liệu.
2. Fintech
Tài sản kỹ thuật số và mã hóa các loại tài sản tài chính, AML, KYC và danh tính kỹ thuật số, chấm điểm tín dụng, thị trường vốn, tài trợ thương mại, các giải pháp bảo mật (để quản lý lưu ký và ngân quỹ)…
3. Cơ sở hạ tầng
Các công ty trong lĩnh vực năng lượng, y tế, bảo hiểm, bất động sản, viễn thông, chuỗi cung ứng… có thể sử dụng giải pháp do Calimero cung cấp.

Ví dụ: trong chuỗi cung ứng / ngành vận tải, bạn có thể sử dụng Calimero để xác minh dữ liệu, theo dõi lô hàng của nhiều công ty (mỗi công ty có các private shard riêng) và thậm chí mua / bán hàng hóa khi họ vẫn đang vận chuyển.
4. Web3
DAO, DeFi, CeFi - hãy nghĩ về tất cả các hoạt động của các lĩnh vực này, bao gồm sổ đặt hàng, darkpools, quản lý ngân quỹ và trả lương cho cộng tác viên, Ngoài ra các lĩnh vực như trò chơi, metaverse, giải trí, xuất bản (nghệ thuật, âm nhạc, NFT)… đều có thể áp dụng Calimero.
Một số đối tác
Spin đang triển khai trên Private Shard của Calimero, đem tới khả năng đạt TPS 200k/s nhằm cung cấp trải nghiệm trading nhanh giống hệt với các CEX truyền thống đồng thời vẫn đảm bảo tính phi tập trung của blockchain

https://twitter.com/spin_fi/status/1565359714925531139

FreeName

Hợp tác với dịch vụ FreeName – domain trên web3.

https://twitter.com/freenameio/status/1589982108717457409
Liên hệ
Khả năng áp dụng của Calimero vào thực tế là vô tận! Liên hệ với nhóm của Calimero nếu bạn muốn tìm hiểu thêm và thử chạy private shard của riêng bạn để nhận được vô số lợi ích của công nghệ sharding.

Bạn có thể sử dụng Calimero miễn phí khi chúng tôi đang ở chế độ thử nghiệm. Nhóm của chúng tôi có thể cung cấp cho bạn quyền truy cập vào private shard cho dự án của bạn.

Theo dõi dự án trên Twitter để cập nhật tất cả các tin tức xung quanh các private shard! Nếu bạn muốn tìm hiểu thêm, bạn có thể nghe các bài nói chuyện của các thành viên nhóm Calimero tại Nearcon ở Lisbon (tháng 9 năm 2022).

NEARCON 2022 | Nightshade Stage - Day 2

### Near Social là gì?

Near Social (trước đây được gọi là Social08) là một giao thức dữ liệu xã hội được xây dựng trên NEAR Protocol.

Vui lòng tham gia nhóm Telegram @NearSocial để thảo luận.

Xem bài thuyết trình về Near Social tại NEARCON22

Khám phá Near Social: near.social
Link dự án
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

SocialDB Contract:

 	Source code: https://github.com/NearSocial/social- db
 	Mainnet: social.near
 	Testnet: v1.social08.testnet

Standards: https://github.com/NearSocial/standards

Near Social Explorer:

 	Nguồn: https://github.com/NearSocial/viewer
 	Mainnet: https://near.social/
 	Testnet: https://test.near.social/

Nếu bạn đang tìm kiếm một mạng xã hội dựa trên Mastodon (Một dịch vụ mạng xã hội mã nguồn mở) cho người dùng .near, hãy xem bài viết về mastodon.near.social
SocialDB
SocialDB là một hợp đồng thông minh để lưu trữ dữ liệu mạng xã hội trên NEAR.

 	Mã nguồn: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	ID tài khoản Testnet: v1.social08.testnet
 	ID tài khoản Mainnet: social.near

Get API
Lấy danh sách các key và trả về một đối tượng joined JSON với dữ liệu phù hợp.


 	keys – một array của các key pattern cần trả về.

Đọc một profile của tài khoản self.social.near
Để đọc đệ quy tất cả các trường của một đường dẫn đã cho, hãy thêm hậu tố **.



Trả về đối tượng aggregated JSON


Đọc tên của tất cả tài khoản cùng với các profile
Lưu ý rằng truy vấn này sẽ lặp trên tất cả các tài khoản và sẽ không phù hợp với chế độ available view call gas trong tương lai.




Keys API
Lấy danh sách các key và trả về một đối tượng joined JSON với các key khớp với truy vấn.



 	keys - một array của các key pattern cần trả về.

Trả về đối tượng aggregated JSON.
Lấy danh sách các widget của các tài khoản root.near



Lấy danh sách các tài khoản có các widget


Lưu ý rằng truy vấn này lặp trên tất cả các tài khoản và sẽ không phù hợp với chế độ available view call gas trong tương lai.


Các chuẩn
Dữ liệu trong SocialDB được tổ chức như một cây JSON đơn giản. Quy tắc ràng buộc duy nhất chính là các key trong root phải là các ID tài khoản lưu trữ dữ liệu. Điều này được thực hiện có chủ đích, chính nhờ nó mà contract SocialDB không cần ràng buộc bất kỳ cấu trúc hoặc schema nào. Nếu không, ta phải thay đổi contract mỗi khi đổi schema. Việc kiểm soát các schema của contract có thể dẫn đến việc tập trung hóa và nhiều hạn chế kèm theo. Thay vào đó, các tiêu chuẩn của Near Social nằm ngoài contract của SocialDB.

Hiện tại, Github là nơi bạn tìm hiểu về các chuẩn của dự án, nhưng link này cũng có thể thay đổi trong tương lai.
Mô tả Schema

 	in đậm có nghĩa là key bắt buộc.
 	in nghiêng có nghĩa là key tùy chọn.
 	[account_id] có nghĩa là dynamic key là một ID tài khoản. Ví dụ: alex.near như là một key. Nó thường được sử dụng để đề cập đến tài khoản đó.

Root schema
Mỗi tài khoản phải tuân theo Root schema
Các widget
Các widget là các thành phần có thể sử dụng lại, có thể kết hợp cho Near Social.

Bạn có thể xem và tạo các widget tại near.social.

Ví dụ: một data explorer widget cho phép bạn khám phá dữ liệu thô từ SocialDB.


Mã nguồn mở cùng version control
Mã nguồn của mọi widget được lưu trữ công khai trong SocialDB. Chủ sở hữu widget có khả năng nâng cấp widget bằng cách cập nhật mã nguồn. Nhưng vì SocialDB được lưu trữ trên blockchain, nên tất cả các phiên bản trước của widget cũng vẫn tồn tại. Điều này cho phép thực hiện version control tự động cho các widget
Forking
Nếu bạn đã quen thuộc với GitHub, bạn biết rằng bạn có thể fork bất kỳ repo công cộng nào để tạo phiên bản của mình. Tương tự, bạn có thể fork bất kỳ widget nào ngay từ near.social UI.



Việc fork sẽ tạo một bản sao của mã nguồn widget, nhưng là bên trong tài khoản của bạn. Nó cho phép mọi người sửa đổi các widget hiện có. Sau khi bạn lưu widget mới, nó sẽ có thể được sử dụng ngay lập tức. Và dĩ nhiên mọi người cũng sẽ có thể xem hay fork phiên bản widget của bạn.

Phần lớn người dùng có nhu cầu dùng UI để tạo ra một pull request, để cho phép mọi người có thể merge các thay đổi từ những fork khác. Tuy nhiên hiện tại thì việc này vẫn còn phải được thực hiện thủ công.
Ngôn ngữ lập trình
Các widget được triển khai trong một phiên bản giới hạn của JSX (JavaScript với ReactJS). 

Code được thực thi trong máy ảo trong môi trường sandbox. Điều này đảm bảo các widget không thể truy cập local storage hoặc cookie của trình duyệt.

### Panduan Menggunakan Pembrock Finance

Nikmati Keunggulan LYF dari Pembrock
Pendahuluan
Pada panduan ini, kita akan melihat cara yang paling umum untuk dapat menghasilkan uang melalui DeFi yakni yield farming, lending, dan staking—dari kacamata PembRock, platform (Leveraged Yield Farming) LYF pertama dan satu-satunya di NEAR Protocol yang didukung oleh DEX Ref.finance.

Mari kita mulai terlebih dahulu dengan pemahaman dasarnya.
Apa itu Yield Farming?
Agar setiap proyek Keuangan Terdesentralisasi (DeFi) dapat berfungsi, maka diperlukannya likuiditas. Likuiditas merupakan sesuatu yang memungkinkan transaksi dapat terjadi, dan peserta atau kontributor yang membuat platform menjadi likuid disebut Penyedia Likuiditas, atau Liquidity Provider (LP). Sekarang, untuk melakukan itu, mereka mendapat imbalan berupa kumpulan dari token LP tertentu (juga disebut 'saham') melalui proses yang dikenal sebagai penambangan likuiditas atau liquidity mining. Token ini akan mewakili seberapa besar bagian pengguna dalam total likuiditas, yang pada gilirannya menentukan besarnya potensi keuntungan mereka.

Yield Farming adalah insentif tambahan yang diberikan ke pengguna sebagai kompensasi karena mereka telah mengunci sebagian dana mereka sehingga peserta lain dapat menggunakannya untuk menghasilkan sesuatu. Setelah menerima token LP, penyedia likuiditas dapat memasukkannya ke dalam yield farming pool untuk menjadi farmer. Untuk itu, mereka akan mendapatkan pembayaran ekstra dalam crypto asli platform (dalam kasus Ref.finance, ini akan menjadi $REF; dalam kasus PembRock, ini akan menjadi $PEM; dan seterusnya) atau cryptocurrency yang berbeda (mis., USDT), tergantung pada aturan program farming yang diberikan.
Apa itu Leveraged Yield Farming?
Dengan yield farming biasa, kamu hanya dapat memberikan jumlah yang telah kamu miliki, yang tentunya itu logis dan wajar. Tetapi bagaimana jika kita ingin memaksimalkan pengembalian/ penghasilan (dan tentunya risiko, jangan lupakan itu)? Dalam hal ini, kita perlu meminjam dana dari orang lain, dan itulah yang membantu kita melakukannya dengan leverage yield farming.

Ketika banyak platform DeFi mengharuskan pengguna memberikan dana dengan nilai lebih besar daripada nilai yang dipinjam (yang juga dikenal sebagai overcollateralization), PembRock tidak melakukannya, memberi kesempatan kepada farmer untuk mengambil jumlah yang hingga tiga kali lebih besar.

Sebagai contoh, jika kalian misalnya memutuskan untuk memberikan 100 USN sebagai jaminan dan meminjam 200 USN, anda akan memiliki total 300 USN, yang berarti tingkat leverage adalah 3 dengan rasio utang 67%. Jika harga USN turun lebih dari 31%, itu berarti kerugian anda tidak dapat ditanggung lagi. Saat itulah likuidasi akan terjadi.

Apa itu Lending?
Lending atau Pinjaman adalah strategi yang memungkinkan anda untuk memperoleh bunga karena memberikan orang lain kesempatan untuk menggunakan uang milik anda. Pada saat yang sama, tidak seperti farmer, pemberi pinjaman tidak rentan terhadap risiko likuidasi (misalnya, pikirkan situasi ketika salah satu aset dalam pool jatuh ke $0), sementara pengembaliannya digabungkan secara otomatis dan dibayarkan secara teratur. Kedengarannya adil, bukan?
Sebelum Kamu Memulai
Buka aplikasi di app.pembrock.finance dan tekan tombol Connect Wallet yang akan anda temui di sudut kanan atas. Tampilan opsi wallet akan muncul lalu silakan pilih salah satu yang anda akan pilih. Setelah itu, anda akan dibawa ke wallet milik anda, di mana anda harus mengaktifkan hak akses tertentu dan mengizinkan PembRock App untuk membelanjakan sebagian NEAR token milik anda untuk menutupi biaya transaksi Leveraged Yield Farming

Untuk mendapatkan hasil farming dengan leverage, pertama-tama anda harus memuat dompet anda dengan aset yang ingin anda gunakan.

Langkah 1. Buka bagian Farm di  app.pembrock.finance/farm.

Langkah 2. Pilih pair  dan klik Farm

Langkah 3. Pilih aset yang akan anda depostikan, atau aset yang ingin dipinjam, berikut jumlahnya dan opsi leverage (antara 1x dan 3x dengan kelipatan penambangan 0.5)

Langkah 4. Klik Farm dan konfirmasikan transaksi tersebut. Harap diperhatikan jika kamu sebenarnya bisa memiliki banyak posisi farming pada waktu yang bersamaan, jadi ketika kamu ingin memiliki pool lain, tinggal kembali dan ikuti proses yang sama dari awal.
Menutup Posisi Farming dan Klaim Hadiah
Langkah 1. Kunjungi laman portofolio dan berpindah ke laman Farm Position

Langkah 2. Klik tombol Close di posisi yang kamu ingin tutup

Langkah 3. Pada tampilan selanjutnya, kamu dapat menutup posisi tersebut secara keseluruhan

Minimize Trading berarti kita akan mengonversi jumlah minimum token yang diperlukan menjadi token yang dipinjam untuk membayar kembali hutang dan mengembalikan aset yang tersisa kepada anda.

Convert all  artinya seluruh posisi anda akan dikonversi menjadi token yang dipinjam dan dikembalikan kepada anda setelah hutang dilunasi.

Langkah 4. Jika anda ingin menutup posisi anda seluruhnya, scroll down ke bawah dan tekan Close Position, lalu lakukan persetujuan di dompet Anda.




	

	
	
		
			
				Sehubungan dengan Leveraged Yield Farming, Pembrock bersifat
			
		

		
					

		
			
			
			
			Overcollateralizes
		
			
			Undercollateralizes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Lending
Untuk menggunakan lending, anda harus terlebih dahulu mengisi dompet anda dengan aset yang akan diberikan.

Langkah 1. Buka app.pembrock.finance/lend, pilih aset, dan klik Deposit.

Langkah 2. Tentukan jumlah yang ingin anda pinjamkan dan konfirmasi transaksi. Harap perhatikan bahwa anda dapat meminjamkan lebih dari satu pool sekaligus, jadi jika anda memiliki aset lain yang ingin dipinjamkan, silakan kembali ke laman tadi dan ulangi prosesnya.

Mengklaim Hadiah
PembRock Finance memberikan insentif kepada pemberi pinjaman (lenders) dan peminjam (farmers).

Langkah 1. Buka app.pembrock.finance. Di sana, anda akan melihat tab Portofolio dengan subbagian Unlocked Rewards.

Langkah 2. Tekan Klaim dan setujui transaksi di dalam dompet Anda.
Melakukan Penarikan/Penyesuaian
Langkah 1. Buka app.pembrock.finance/lend-pools. Di sana, anda akan melihat daftar aset yang telah anda berikan.

Langkah 2. Pilih aset yang tidak ingin anda pinjamkan lagi dan klik tombol panah bawah di sebelah kanan kotak.

Langkah 3. Masukkan jumlah yang ingin anda tarik kembali dan tekan Withdraw.

Tentang Pembrock
PembRock dibuat oleh INC4—perusahaan pengembangan blockchain profesional asal Ukraina yang telah ada sejak 2013.

Ide utama di balik PembRock adalah untuk membawa perdagangan dengan leverage sebagai alat yang tersedia secara luas untuk pemain di pasar keuangan tradisional kedalam sektor DeFi yang baru hadur namun sedang tren.

Pada bulan Maret 2022, PembRock Finance dianugerahi hibah sebesar US$75.000 dari NEAR Foundation yang bertujuan untuk membantu pengembangan protokol, peningkatan lebih lanjut, dan adopsi.
Utilitas dari $PEM
PEM adalah token digital asli (native token) protokol PembRock. Token ini memiliki empat kasus utama penggunaan yaitu:

 	Pemegang PEM yang melakukan staking token mereka akan mendapatkan semua pendapatan yang dihasilkan oleh protokol.
 	Mereka juga dapat memandu proses pengambilan keputusan proyek melalui partisipasi dalam DAO.
 	Token adalah pusat mekanisme yang mendistribusikan reward untuk berinteraksi dengan protokol.
 	$PEM juga digunakan untuk memberikan bonus tambahan kepada mereka yang memasok likuiditas ke pool Pembrock.

Untuk tempat agar bisa membelinya, bisa dilihat di sini.

 	Nama: PembRock Finance Token
 	Ticker: PEM
 	Total pasokan: 160 juta unit
 	Jaringan: Protokol NEAR
 	Alamat kontrak: token.pembrock.near





	

	
	
		
			
				Apa Kegunaan yang tidak dimiliki Token $PEM?
			
		

		
					

		
			
			
			
			Profit Sharing
		
			
			Voting
		
			
			Insentif
		
			
			Distribusi NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apa itu Staking?
Dalam protokol PembRock, Staking berarti mengunci token PEM dengan imbalan hak untuk mendapatkan sebagian pendapatan yang diperoleh oleh protokol dan untuk berpartisipasi dalam Organisasi Otonomi Terdesentralisasi atau DAO, yang dapat memengaruhi pengambilan keputusan, termasuk berapa banyak yang harus dibuat oleh farmers dan pemberi pinjaman yang telah disebutkan di atas. Semakin besar jumlah yang di-staking dan semakin lama periodenya, semakin tinggi hak suara dan hadiahnya.

Katakanlah anda melakukan staking 1.000 token PEM selama 4 tahun dengan imbalan 1.000 unit hak suara (yang diberikan dalam bentuk token vePEM), sementara orang lain mempertaruhkan 1.000 PEM selama 2 tahun dengan imbalan 500 unit hak suara (karena meskipun mereka mempertaruhkan volume yang sama, mereka melakukannya untuk periode dua kali lebih pendek). Secara bersama-sama, kekuatan suara anda akan menjadi 1.500. Jadi jika protokol menghasilkan 100 PEM sebagai hadiah mingguan, anda akan mendapatkan 66,66 PEM (karena bagian anda dalam jumlah total yang distaking adalah 66,66%), dan peserta lain hanya 33,33 PEM (mereka akan menjadi 33,33%).
Bagaimana Cara untuk Staking
Untuk menstaking dan melalui proxy bergabung dengan DAO, anda memerlukan token asli dari PembRock yang disebut PEM. Jika anda belum memiliki PEM, berikut cara untuk memperolehnya:.

Langkah 1. Buka app.pembrock.finance/staking;

Langkah 2. Ketik jumlah yang ingin anda staking dan periode durasinya (perkiraan kekuatan voting dapat dilihat di bawah Tanggal Berakhir).

Langkah 3. Klik Confirm
Cara untuk Membuat Penyesuaian
Kekuatan voting akan menurun secara bertahap, tetapi anda dapat menyesuaikan posisi anda (staking lebih banyak dan/atau lebih lama) untuk menjaga pengaruh anda pada tingkat yang sama atau bahkan membuatnya lebih substansial.

Langkah 1. Scroll ke bawah ke bagian app.pembrock.finance/staking;

Langkah 2. Ketik jumlah yang ingin anda staking di atas apa yang telah anda staking dan klik Confirm;

Langkah 3. Setelah itu, anda dapat memperpanjang periode penguncian.

Klaim & Penarikan
Untuk menarik PEM setelah periode penguncian berakhir atau meminta hasil hadiah milik anda dalam PEM, kunjungi app.pembrock.finance/staking. Setelah tersedia, tombol akan berubah menjadi oranye.




	

	
	
		
			
				Dimanakah dari statement berikut ini yang benar?
			
		

		
					

		
			
			
			
			Jumlah yang di stake merupakan faktor yang menentukan kekuatan voting
		
			
			Periode dari staking merupakan satu-satunya faktor yang menentukan kekuatan voting
		
			
			Jumlah token dan periode dapat menentukan kekuatan voting
		
			
			Tidak ada yang benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cara Berpartisipasi dalam DAO
Di DAO, anda dapat mengatur jumlah hadiah yang diberikan kepada pemberi pinjaman dan farmers setiap bulan.

Langkah 1. Buka https://app.pembrock.finance/voting. Di sana, anda akan melihat dua tab yakni Lenders and Borrowers Rewards

Imbalan dari Pemberi Pinjaman diperoleh oleh peserta yang menyetor ke pool pinjaman. Hadiah Peminjam diperoleh oleh peserta yang meminjam aset dari pool pinjaman.

Langkah-langkah di bawah ini sama untuk keduanya.

Langkah 2. Bagikan kekuatan voting anda ke pool menggunakan kolom Vote. Semakin tinggi % yang Anda berikan, semakin besar pengembalian yang akan dihasilkan.

Perlu diperhatikan bahwa semua % harus berjumlah 100.

Langkah 3. Tekan Vote dan konfirmasi transaksi di NEAR Wallet.

Jika anda berubah pikiran, Anda dapat memilih ulang saat jendela masih terbuka. Saat melakukannya, harap pastikan untuk menentukan kembali % untuk semua aset.
Kesimpulan
PembRock baru saja mendapatkan momentum karena pasar DeFi pada umumnya ranah Leveraged Yield Farming khususnya kini masih dalam tahap awal. Sama seperti Ref Finance yang menjadi pionir dalam ranah DeFi NEAR, PembRock menjadi protokol yield farming pertama dan satu-satunya yang memanfaatkan jaringan. Jadi, jika anda ingin menjadi salah satu dari kelompok yang menjadi penentu tren, mengapa tidak mencobanya sekarang juga (walaupun harus waspada terhadap risikonya)?

Jika anda ingin tetap mengikuti semua update dari PembRock, di bawah ini adalah beberapa tautan yang dapat anda kunjungi:

### Cara Menggunakan NEAR di Handphone

Salah satu cara untuk menggunakan NEAR di ponsel milik anda adalah dengan menggunakan wallet HERE. Ini adalah dompet non-kustodian dimana ini berarti kunci pribadi hanya akan disimpan di ponsel milik anda

HERE Wallet berfokus pada kemudahan para pengguna untuk bisa menggunakan NEAR. Kita dapat menggunakan banyak aplikasi langsung dari wallet. Ada juga liquid staking yang dibangun ke dalam aplikasi dengan biaya penarikan instan sebesar 0%. Saat kita melakukan transfer apa pun maka dana akan langsung di unstake di balik layar secara otomats.

Dalam artikel ini kami akan membahas cara menggunakan fitur dasar aplikasi HERE, jika teman - teman memiliki pertanyaan, kamu bisa bertanya langsung kepada tim HERE di ruang obrolan (chat room).
Masuk dengan Seed Phrase
Jika kamu sudah memiliki akun NEAR, maka kamu dapat masuk menggunakan seed phrase milikmu:

 	Klik "impor akun yang sudah ada (import existing account)"
 	Klik "gunakan seed phrase (use seed phrase)"
 	Masukkan seed phrase dan klik "temukan akun saya (find my account)"


Jika kamu memiliki akun di wallet.near.org


 	Klik "impor akun yang ada"
 	Klik "gunakan seed phrase"
 	Masukkan seed phrase dan klik "temukan akun saya"
 	Klik "impor akun yang ada"
 	Klik "bagikan tautan"
 	Kirim tautan ke desktop Anda
 	Buka tautan, pilih akun dan klik "Berikutnya"
 	Klik "Hubungkan"
 	Masukkan ID akun dan klik "Konfirmasi"
 	Anda akan diotorisasi di perangkat seluler


Atur nama pengguna (gratis)
Di NEAR tersedia dengan nama pengguna (username), bukan alamat. Biasanya, diperlukan token NEAR untuk bisa membuat nama pengguna, tetapi kami mengalokasikannya secara gratis di aplikasi HERE. Cukup masukkan nama pengguna dan klik Lanjutkan.
CATATAN PENTING

Setelah anda memilih username yang diinginkan, maka kamu tidak dapat mengubahnya. Satu-satunya cara yang tersedia adalah membuat akun baru dan mendeposit sejumlah dana (dalam NEAR)

Kami tidak menyarankan untuk menggunakan nama belakang anda di username, itu dapat membuat anda tidak anonim.

Mulai Mendapatkan Penghasilan
Dompet HERE memiliki fitur liquid stakingbawaan, anda dapat menarik kapan saja dana milik anda tanpa biaya apa pun.

 	Klik pada tombol merah muda bulat besar “Earn”
 	Klik "Start Staking"
 	masukkan jumlah
 	Klik “Stake”
 	Mantap! Sekarang anda akan menerima penghasilan harian sebesar 8-10% p.a. pada saldo Anda

Mengklaim dividen

 	Klik “Klaim”
 	Tunggu sampai dimuat
 	Selesai! Dividen Anda telah ditransfer ke saldo anda


Membeli NEAR menggunakan aset lain

 	Klik “Add Money”
 	Klik “Beli NEAR dengan crypto lain”
 	Pilih aset
 	Setor BTC ke alamat yang ditunjukkan
 	Klik Selesai setelah deposit
 	Anda dapat melacak status setoran di Riwayat transaksi


Cara menggunakan dApps

 	Pilih HERE Wallet dari daftar aplikasi di situs web
 	Pindai kode QR dengan kamera asli ponsel Anda
 	Anda akan diarahkan ke aplikasi. Klik "Konfirmasi"

### Freedom in the digital world: is it achievable?

Today, when our daily life is becoming increasingly digital, people started to understand that some of their possessions in this new digital world are valuable. Various account information, game characters, subscriptions, tickets to access physical and digital events, and club membership: we have more and more things of importance and great value for us. And sometimes even the things connected to life success or security.  It’s a new feeling for many of us to understand that you are significantly dependent on “a piece of information” stored somewhere and we are losing some comfort in a try to manage it well. Most of us end up storing those things in either a cloud file or a proprietary wallet like Apple. It’s a rare thing to realize that those considered to be safe places do not as safe as we think. First, they do not belong to us and are not managed by us. They are somebodies else place where record keeping is done. Second, they are less accessible than we used to think. Just move from the US to mainland China and you will realize that most of your Google-stored possessions are not accessible anymore.  For those who think further, it appears clear that in the digital world we used to operate nothing does really belong to you when it is stored in some kind of cloud or simply unknown by you servers: the server can disappear, service you are using to access the information can disappear too, also the information can be amended by server administrators or as a result of the malicious intervention. 

Ok. There seem to be not many possibilities to truly own something in the digital world. But do we need it? Probably not. At the same time, I personally believe in the words of George Washington:
Freedom and Property Rights are inseparable. You can't have one without the other.


Which is a perfect motivator for me to look around for better digital property rights possibilities than we had before. 

Surprisingly, the answer is pretty simple and quite interesting: the technology we’ve used to think about as “the tokenization of all sorts of art” is perfectly capable to facilitate the self-sovereign storage of digital property rights. Yes, I’m speaking about NFT. By assigning an NFT to any piece of information we can set the initial price and ownership for this piece. And it will be stored in the owner’s wallet to be used if required for any sort of demonstrations, or presentations at the point of checking and accessing control gates. And the evidence of our ownership is stored in a decentral manner which prevents any sort of unauthorized information change and facilitates the necessary resilience: we can be sure that at least some part of the decentralized network will stay accessible, which means still provide the requestor with the information about the fact the owner of the property is still the owner. 

And one step backward for the broader look: by NFT-vising any sort of information we are enabling interoperability between various information systems, IT solutions, metaverse and gaming realms: to access the data we just need to request the owner’s wallet about the provisioning of the certain NFTs and its utility parameters. Further, we can use those parameters for any sort of verification, calculation, or simple visualization. 

So, let’s summarize:  NFT is perfect to represent ownership in the digital world: it has the price, the owner, and the actual data ownership of which the owner is claiming, and on top of all this, it may have visual or audio representation making the possession recognizable. For many of us, it will additionally allow the development of emotional connection which is frequently developed through visual representation. So, even shorter, for kids probably: NFT is something nice and tradable, enabling us to claim our rights in the new digital world.

### Apa itu NEAR Social?

Near Social (sebelumnya dikenal sebagai Social08) adalah protokol data sosial yang dibangun di atas Protokol NEAR.

Silakan bergabung dengan grup Telegram @NearSocial untuk diskusi lebih lanjut.

Tonton presentasi Near Social di NEARCON22

Jelajahi Near Social: near.social
Links
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

SocialDB Contract:

 	Sumber: https://github.com/NearSocial/social-db
 	Mainnet: social.near
 	Testnet: v1.social08.testnet
 	Standar: https://github.com/NearSocial/standards

Browser NEAR Social:

 	Sumber https://github.com/NearSocial/viewer
 	Mainnet: https://near.social/
 	Testnet: https://test.near.social/

Jika Anda mencari jaringan sosial berbasis mastodon untuk pengguna .near, lihat artikel tentang  mastodon.near.social
SocialDB
SocialDB adalah smart contract untuk menyimpan data sosial pada protokol NEAR.

 	

 	Kode sumber: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	ID akun Testnet: v1.social08.testnet
 	ID akun Mainnet: social.near



Get API
Mengambil daftar kunci dan mengembalikan objek JSON yang digabungkan dengan data yang cocok.


 	kunci - array pola kunci untuk dikembalikan.

Membaca profil akun self.social.near
Untuk membaca semua bidang secara rekursif untuk jalur tertentu, tambahkan akhiran **.



Mengembalikan objek JSON teragregasi.


Membaca nama semua akun dengan profil
Perhatikan bahwa kueri ini berulang di semua akun dan tidak akan cocok dengan gas view call yang tersedia di masa mendatang.



Keys API
Mengambil daftar kunci dan mengembalikan objek JSON yang digabungkan dengan kunci yang cocok dengan kueri.



 	kunci - array pola kunci untuk dikembalikan.

Mengembalikan objek JSON teragregasi.
Mendapatkan daftar widget akun root.near



Mendapatkan daftar akun yang memiliki widget

Perhatikan bahwa kueri ini berulang di semua akun dan tidak akan cocok dengan gas panggilan tampilan yang tersedia di masa mendatang.

Standar
Data di SocialDB diatur sebagai JSON tree sederhana. Satu-satunya aturan yang diberlakukan adalah bahwa kunci di root adalah ID akun yang menyimpan data. Ini dilakukan dengan sengaja, sehingga kontrak SocialDB tidak memberlakukan struktur atau skema apa pun. Jika tidak, kontrak harus dimodifikasi untuk setiap perubahan skema. Kontrol skema kontrak dapat menyebabkan sentralisasi dan pembatasan. Sebaliknya, Near Social Standards berada di luar kontrak SocialDB.

Saat ini, Standar di Github adalah tempat default untuk standar, tetapi ini dapat berubah di masa mendatang.
Deskripsi skema

 	bold berarti kuncinya diperlukan.
 	italic berarti kuncinya opsional.
 	[account_id] berarti kunci dinamis adalah ID akun. Misalnya, alex.near sebagai kunci. Biasanya digunakan untuk membuat beberapa keunggulan terhadap akun itu.

Skema akar
Setiap akun harus mengikuti skema Root
Widgets
Widget adalah komponen yang dapat digunakan kembali untuk Near Social.

Anda dapat melihat dan membuat widget di near.social.

Misalnya, widget penjelajah data memungkinkan Anda menjelajahi data mentah dari SocialDB.


Open Source dengan versi kontrol
Source code setiap widget disimpan secara terbuka di SocialDB. Pemilik widget memiliki kemampuan untuk meng-upgrade widget, dengan memperbarui source code. Tetapi karena SocialDB disimpan di blockchain, semua versi widget sebelumnya juga tersedia. Ini memungkinkan kontrol versi otomatis untuk setiap widget.
Fork
Jika anda terbiasa dengan GitHub, anda tahu bahwa anda dapat melakukan fork repositori publik apa pun untuk membuat versi lokal Anda. Demikian pula, anda dapat memotong widget apa pun langsung dari UI near.social.



Forking membuat salinan source code widget, tetapi di bawah akun Anda. Ini memungkinkan semua orang untuk memodifikasi widget yang ada. Setelah Anda menyimpan widget baru, widget akan segera tersedia. Dan semua orang sekarang dapat melihat dan mem-forking versi widget Anda.

Ini sebagian besar pertanyaan UI untuk membuat pull request, sehingga orang dapat menggabungkan perubahan dari fork lain. Saat ini harus dilakukan secara manual.
Bahasa Pemrogramman
Widget diimplementasikan dalam versi terbatas JSX (JavaScript dengan ReactJS). Kode dijalankan di Mesin Virtual khusus untuk membuat sandbox yang aman. Ini memastikan widget tidak dapat mengakses penyimpanan atau cookie lokal.

### NEAR explorers

After the FTX implosion, taking control of your crypto has become more critical than ever. Where can I look up my transactions?

One of the most important ways to do that is by learning to read a block explorer. For the NEAR Protocol, the most popular NEAR explorers are:

 	

 	Pikespeak
 	NearBlocks
 	LNC NEAR Watcher



What is a blockchain explorer?
A blockchain scanner is a software used for visualizing different blockchain network metrics like:

 	Hashrate
 	Block size
 	Block difficulty
 	Average transaction fees.

So, what can you do with the blockchain explorer? Let’s take a look.

 	Track the status of a pending transaction while it's awaiting in the mempool.
 	Track the balance of wallets without having to use the wallet itself. This can be helpful if you want to check the balance in your hardware wallet.
 	Track every single transaction going in and out of a particular address.
 	View orphaned blocks, aka blocks that aren’t attached to the main chain.
 	Explore whale transactions that could have a major impact on the market.
 	Keep track of the addresses of well-known crypto leaders.
 	Keep track of coins post-hack.

How do blockchain explorers work?
Blockchain explorers work alongside blockchain nodes and use application programming interfaces (APIs), rational databases, and SQL databases to retrieve relevant information from the underlying network. Here are a few things to keep in mind:

 	The explorer organizes all this information into a database and displays this data in a searchable format.
 	Users can perform searches through an organized table.
 	All search requests are sent to the backend server, which provides the required responses.

How do I use a blockchain explorer?
Let’s use the same transaction in Pikespeak and NearBlocks to see how the data presentation differs between these explorers.
Pikespeak
Access to live and historical data with visualisations of the most fundamental Web 3 use cases. Pikespeak is a user-centric (vs transaction-oriented) analytics solution, focusing on user engagement with the most successful applications: DeFi, DAOs, NFTs, Gaming, etc.

NearBlocks

The NearBlocks explorer shows the same data as the total gas and tokens burnt during the transaction.




	

	
	
		
			
				What does the “System account" do?
			
		

		
					

		
			
			
			
			Validate transactions
		
			
			Identify refund receipts
		
			
			Add transactions
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





LNC NEAR Watcher
LNC NEAR Watcher is a super easy to use Telegram bot to monitor NEAR accounts. Just type NEAR account and get notified about transactions in real time. LNC NEAR Watcher integrated with PikeSpeak.
Conclusion
There are more complicated transactions on the NEAR blockchain. However, this article should give you an idea of how to read these transactions. Explorers allow you to exploit one of the most essential traits of blockchain technology – transparency. It empowers you as a user to meticulously track your coins and see where they are going.

        
            What is your favorite NEAR explorer? 
            
                224 votes by,
                392 nLEARNs spent
            
            
            
                                    
                        
                            pikespeak.ai                            
                                (21 votes,
                                57 nLEARNs)
                            
                        
                        
                             
                            9%
                        
                    
                                    
                        
                            nearblocks.io                            
                                (126 votes,
                                212 nLEARNs)
                            
                        
                        
                             
                            56%

### Apa itu Calimero? Memperkenalkan Private Sharding di NEAR

Penjelasan mengenai Private Shard dari jaringan Calimero - Solusi blockchain yang memungkinkan penskalaan dan privasi
Keindahan dari teknologi blockchain adalah bahwa semua peserta dalam jaringan blockchain mempercayai informasi di dalamnya, karena data pada blockchain tersebut tidak dapat diubah, terlihat, dan dapat diakses oleh semua orang secara real time. Tetapi web3 saat ini memang masih jauh dari sempurna, karena ada dua tantangan utama yaitu: privasi data dan potensi bisnis untuk ditingkatkan menggunakan teknologi blockchain.

Tantangan dalam menggunakan blockchain untuk bisnis adalah jika semua data tersedia untuk umum dan transparan, pertanyaan terkait bagaimana untuk privasi akan muncul.

 	Apa yang terjadi ketika informasi tersebut diklasifikasikan sebagai informasi pribadi?
 	Apakah ada kebutuhan untuk perlindungan data atau kewajiban untuk patuh? Lalu berdasarkan jalur yurisdiksi yang mana?
 	Apa yang terjadi bila informasi tersebut merupakan rahasia bisnis?

Menjaga privasi data pribadi dan bisnis adalah kebutuhan, bukanlah kemewahan. Di blockchain, itu dapat dilakukan dengan menggabungkan data on-chain dan off-chain dan interoperabilitas. Semuanya dimungkinkan dengan private shard dari Calimero.

Sekarang, kita jangan langsung masuk ke penjelasan Calimero dulu. Ada satu pertanyaan penting lagi yang perlu dijawab: penskalaan. Skalabilitas adalah kemampuan jaringan blockchain untuk mendukung peningkatan jumlah transaksi, dengan meningkatkan jumlah node/validator.

Seiring jumlah minat untuk menggunakan cryptocurrency dan teknologi blockchain yang semakin berkembang, banyak pengguna dan perusahaan mulai mengeluarkan token, membangun dApps, dan membuat NFT semakin banyak setiap hari. Akibatnya, jaringan mulai menjadi padat, yang implikasinya adalah membawa peningkatan biaya gas untuk pengguna baru dan pengguna lama. Hal ini tentunya membuat mereka enggan membangun produk yang lebih menakjubkan. Di sinilah solusi penskalaan baru muncul. Contoh yang baik adalah NEAR, yang menggunakan sharding untuk penskalaan dan mendukung peningkatan penggunaan blockchain. Tetapi bahkan dengan sharding, untuk beberapa bisnis yang memiliki banyak transaksi jaringan setiap hari, biayanya bisa menumpuk.

Di sinilah Calimero hadir karena kita dapat menjalankan shard milik kita sendiri di mana transaksinya gratis dan pribadi. Kita hanya diharuskan membayar jumlah tetap per bulan berdasarkan jumlah validator yang kita jalankan.
Apa itu Jaringan Calimero?
Calimero adalah sidechain yang dapat disesuaikan yang dibangun di atas protokol NEAR. Hal ini dapat dilihat sebagai jaringan dari jaringan. Solusi bagi bisnis untuk mengakses fitur privasi dan mengaktifkan penskalaan. Calimero memberikan kita infrastruktur yang membagikan semua manfaat terbaik dari NEAR sambil ditingkatkan dengan beberapa fitur baru dengan penekanan pada privasi.

Calimero memungkinkan kita untuk:

 	Jalankan shard pribadi milik anda sendiri (anggap shard sebagai jaringan blockchain pribadi kecil yang anda miliki)
 	Berkomunikasi antara shard milik anda dan jaringan lain, atau antara beberapa shard (bahkan jika shard dimiliki oleh perusahaan yang berbeda)

Dengan menggunakan shard pribadi dari Calimero, beberapa diantaranya para pengguna dapat meningkatkan aplikasi dengan bekerja sama dengan protokol dan aplikasi open source, dari DeFi hingga NFT. Pengguna dapat memegang dan mengelola aset publik dan memindahkannya di antara shard pribadi dan rantai publik (public chain) lainnya dengan lancar.

Selain itu, pengguna mendapat manfaat dari transaksi lintas shard, yang menyediakan kemampuan untuk berinteraksi dengan pihak ketiga di rantai publik atau shard dari perusahaan yang diizinkan lainnya. Shard dapat berinteraksi satu sama lain melalui saluran yang tentunya telah terenkripsi. Bersama Calimero, kemungkinan menjadi tidak terbatas.
Manfaat menggunakan shard pribadi menggunakan jaringan Calimero
Shard pribadi Calimero memiliki semua manfaat NEAR dalam hal kinerja yang maksimal, faktor keamanan, dan keberlanjutan. Namun sebagai perbedaan penting, shard tidak menggunakan validator dari NEAR baik secara eksekusi, dan penyimpanan statusnya, melainkan anda menggunakan milik anda sendiri. Manfaat utama lainnya meliputi:

 	Menskalakan bisnis kita dengan memiliki akses ke transaksi gratis di dalam shard.
 	Menjadikan sebagian (atau semua) transaksi kita bersifat pribadi, dengan hanya orang/entitas dengan akses ke shard yang dapat melihat data.
 	Kompatibilitas EVM – kita dapat menggunakan dApps yang sudah dibangun di mainnet Ethereum alih-alih membangunnya dari awal.
 	Kompatibilitas WASM & dukungan Javascript untuk kemudahan orientasi ke web3
 	Interoperabilitas – Shard dapat berkomunikasi dengan mainnet NEAR, dan di antara mereka sendiri (setiap shard dapat mewakili perusahaan yang berbeda atau bagian dari perusahaan yang sama), dan dengan menggunakan bridge, beberapa aset berbeda seperti fungible token (token yang dapat dipertukarkan) dan non-fungible token (token yang tidak dapat dipertukarkan) dapat ditransfer.
 	Dapat disesuaikan, berkinerja, dan hemat biaya. Dimungkinkan untuk melakukan hingga 200.000 transaksi per detik (penyebaran shard standar memiliki throughput 5.000 transaksi per detik). Waktu blok, ukuran kontrak, dan batas gas dapat disesuaikan. Menjembatani aset atau memanggil data dengan cepat (5-10 detik) dan murah (biayanya beberapa sen).

Kepada siapa Private Shard Calimero diperuntukkan?
Calimero dapat digunakan untuk:

 	Sebagai pintu gerbang bagi bisnis tradisional (web2) untuk masuk ke dunia web3 dengan dasbor yang mudah digunakan untuk mengelola shard pribadi mereka.
 	Untuk bisnis yang sudah beroperasi di web3 yang tidak membutuhkan penskalaan zero gas dan fitur privasi.

Di industri mana Calimero dapat digunakan?
Ada banyak kasus untuk penggunaannya, karena hanya imajinasilah yang menjadi batasnya. Untuk memberikan beberapa inspirasi, kami telah membuat daftar beberapa industri berbeda dimana shard pribadi dapat mencapai potensi penuhnya.


 	
Pemerintahan


Pikirkan bank yang menerapkan CBDC, atau KYC & kasus penggunaan anti pencucian uang. Data pribadi disimpan di shard, dan dapat tersedia saat dibutuhkan, tetapi sebaliknya disembunyikan dari publik.

 	
Fintech


Aset digital dan tokenisasi aset keuangan, AML, KYC dan identitas digital, penilaian kredit, pasar modal, pembiayaan perdagangan, solusi privasi (untuk manajemen penyimpanan dan perbendaharaan).

 	
Infrastruktur


Bagi perusahaan yang bergerak di bidang energi, perawatan kesehatan, asuransi, real estat, telekomunikasi maupun supply chain. Misalnya dalam supply chain/industri transportasi, anda dapat menggunakan Calimero untuk memverifikasi data, melacak pengiriman di beberapa perusahaan (masing-masing dengan shard-nya sendiri) dan bahkan membeli/menjual barang saat masih dalam transportasi.

 	
Web3


DAO, DeFi, CeFi – pikirkan semua operasi di dalamnya, termasuk order book, darkpools, manajemen perbendaharaan, dan penggajian kontributor, Juga dalam permainan, metaverse, hiburan, penerbitan (seni, musik, NFT). Contoh penggunaan shard pribadi dalam permainan: anda memulai permainan catur di mainnet. Anda bisa menjembatani seluruh permainan ke shard pribadi. Di atasnya, game ini dimainkan secara GRATIS dan gerakannya disembunyikan (kecuali jika anda ingin mengungkapkannya). Anda menjembatani hasilnya kembali ke mainnet. Dan voila!

Kemungkinannya dari #NEAR adalah tak terbatas! Hubungi tim kami jika anda ingin mempelajari lebih lanjut dan mencoba menjalankan shard pribadi anda sendiri untuk mengakses manfaat sharding yang tak terhitung jumlahnya. Anda dapat menggunakan Calimero secara gratis saat kami dalam mode uji. Tim kami dapat memberi anda akses ke shard pribadi untuk proyek milik anda. Ikuti kami di Twitter untuk menantikan semua berita seputar shard pribadi! Jika anda ingin mempelajari lebih lanjut, anda dapat mendengarkan penjelasan dari anggota tim Calimero di Nearcon di Lisbon (September, 2022).

VIDEO : https://youtu.be/VrK46yUEh9s

### Transisi NEAR Wallet : Apa penyebab terjadinya dan Apa yang harus user lakukan sekarang?

Tidak pelak lagi, sebagian besar pengguna NEAR telah mendengar isu terkait transisi wallet NEAR. Namun masih banyak pertanyaan yang muncul tentang alasan, proses, dan hubungannya dengan MyNearWallet. Berikut adalah pertanyaan-pertanyaan yang paling sering diajukan terkait transisi beserta komentar dari tim MyNearWallet.
Mengapa kita harus beralih dari dompet "resmi" yang telah dikembangkan oleh Near Foundation ke dompet lain?
Untuk memulai ini semua, pengguna NEAR tentunya memiliki kebutuhan dan preferensi yang berbeda-beda dan satu produk resmi tentunya sangat tidak mungkin untuk mencakup semua kebutuhan tersebut. Pada titik tertentu, pengembang ekosistem NEAR menyadarinya dan memutuskan bahwa dalam waktu dekat ekosistem NEAR tidak akan memiliki dompet resmi lagi dan semua dApps akan didorong untuk menggunakan pemilih dompet/ wallet mereka sendiri. Wallet resmi NEAR yakni wallet.near.org, akan menjadi halaman daftar untuk semua dompet yang ada di ekosistem. Kapan tanggal pastinya belum diumumkan untuk saat ini.

Perubahan ini tentunya harus meningkatkan desentralisasi dan menginspirasi persaingan yang sehat di ekosistem NEAR. Harapannya  tanpa dompet resmi, pengguna akan mendapatkan produk yang lebih canggih.
Bagaimana MyNearWallet terhubung ke dompet NEAR?
Kikimora Labs, sedang membangun MyNearWallet di atas basis kode open-source dompet NEAR. Basis pengguna tidak akan dipindahkan ke MyNearWallet. Dompet itu sendiri tetap bersifat open-source. Dalam proyek barunya, tim MyNearWallet mulai meningkatkan kekurangan dari fitur lama, menambahkan yang baru, dan memperkuat dari sisi keamanan. Saat ini, tim dukungan MyNearWallet membantu pengguna dari setiap wallet. Selain itu,, tim MyNearWallet memecahkan masalah bug untuk dua proyek. Sementara itu, fitur baru hanya akan tersedia di MyNearWallet.

Laman Antarmuka dari MyNearWallet masih terlihat hampir sama dengan wallet.near.org. Tapi seperti yang diklaim tim proyek, desainnya akan diubah dengan perlahan.
Apa yang akan terjadi pada akun https://wallet.near.org/ milik pengguna?
Pengguna dapat mentransfer akun mereka ke dompet NEAR mana pun yang mereka suka tanpa kehilangan asetnya. Berikut adalah instruksi tentang cara mentransfer akun Anda ke MyNearWallet.
Peta Jalan & Strategi transisi dompet
Fase 0 — Keterlibatan Komunitas [sekarang]

Fase 1 — Pengguna Offboard, Aktifkan Fungsi Ekspor Akun [Mulai Oktober]

Fase 2 — Portal baru untuk Array dompet [Diharapkan selesai awal 2023]

Fase 3 — Akhiri Transaksi Penerusan

Fase 4 — Menyelesaikan Sunset dari dompet DEKAT

### Гайд по PembRock Finance

Наслаждайтесь преимуществами LYF с PembRock
Вступление
В этом руководстве мы рассмотрим наиболее распространенные способы заработка с помощью DeFi, кредитование и стейкинг — с помощью PembRock, первой и единственной платформы LYF на протоколе NEAR, работающей на базе Ref.finance DEX.

Начнем с основ.
Что такое фарминг?
Для работы любого проекта децентрализованных финансов необходима ликвидность. Ликвидность — это то, что делает транзакции вообще возможными, и участники, которые делают платформы ликвидными, называются поставщиками ликвидности или LP. Теперь за это они получают вознаграждение в виде токенов LP определенного пула (также называемых «акциями») посредством процесса, известного как добыча ликвидности. Эти токены представляют собой долю пользователя в общей ликвидности, которая, в свою очередь, определяет его потенциальную прибыль.

Фармерство — это дополнительный стимул, который вознаграждает пользователей за сам факт блокировки их средств, чтобы другие участники могли использовать их для собственного заработка. После получения токенов LP поставщик ликвидности может поместить их в пул доходного фармерства, чтобы стать фармером. За это они будут получать дополнительные выплаты в собственной криптовалюте платформы (в случае Ref.finance это будет $REF, в случае PembRock это будет $PEM и т. д.) или в другой криптовалюте (например, USDT). в зависимости от правил данной программы.
Что такое доходное фармерство с кредитным плечом?
При регулярном фармерстве вы можете обеспечить только ту сумму, которая у вас есть, что кажется вполне логичным. Но что, если вы хотите максимизировать прибыль и риски (не забывайте об этом)? В этом случае вам нужно будет занимать средства у других, и именно в этом вам поможет доходное фармерство с использованием заемных средств.

В то время как многие платформы DeFi требуют, чтобы пользователи вкладывали средства на сумму, превышающую сумму кредита (что также известно как избыточное обеспечение), PembRock этого не делает, что дает фармерам возможность получить сумму, которая в три раза больше.

Так, если вы, например, решили предоставить 100 долларов США в качестве залога и занять 200 долларов США, у вас будет всего 300 долларов США, что означает, что уровень кредитного плеча будет равен 3 при коэффициенте долга 67%. Если цена USN упадет более чем на 31%, это будет означать, что ваш убыток больше не может быть покрыт. Вот тогда и произойдет ликвидация.

Что такое кредитование?
Кредитование — это стратегия, которая позволяет вам получать проценты за то, что вы позволяете кому-то другому использовать ваши деньги. В то же время, в отличие от фармеров, кредиторы не подвержены риску ликвидации (например, представьте себе ситуацию, когда один из активов в пуле падает до 0 долларов), а их доход автоматически компонуется и выплачивается регулярно. основа. Звучит справедливо, правда?
Прежде чем начать
Перейдите на app.pembrock.finance и нажмите кнопку «Подключить кошелек», которую вы увидите в правом верхнем углу. Появится окно выбора кошелька; выберите тот, который вы предпочитаете. После этого вы попадете в свой кошелек, где вам нужно будет включить определенные права доступа и разрешить приложению PembRock потратить часть ваших NEAR для покрытия транзакционных сборов.

Чтобы получить прибыль с кредитным плечом, вам нужно сначала загрузить в свой кошелек актив, с которым вы хотите это сделать.

Шаг 1.  Перейдите в раздел «Ферма»: app.pembrock.finance/farm.

Шаг 2.  Выберите пару и нажмите «Farm».

Шаг 3. Выберите актив, который вы хотите внести, тот, который вы хотите отдолжить, их суммы и кредитное плечо (от 1x до 3x с шагом 0,5).

Шаг 4. Нажмите Farm и подтвердите транзакцию. Обратите внимание, что у вас может быть открыто несколько позиций для фарма одновременно, поэтому, если вы хотите другой пул, просто вернитесь и повторите процесс.
Закрытие фарм-позиции и получение вознаграждения
Шаг 1. Перейдите в «Портфолио» и перейдите на вкладку «Farm Positions».

Шаг 2. Нажмите «Закрыть» рядом с позицией, из которой вы хотите выйти.

Шаг 3. На следующем скрине вы можете полностью закрыть позицию.

Минимизация торговли означает, что мы конвертируем минимально необходимое количество токенов в заемный токен, чтобы погасить долг и вернуть вам оставшиеся активы.

Конвертировать все означает, что вся ваша позиция будет конвертирована в заимствованный токен и возвращена вам после выплаты долга.

Шаг 4. Если вы хотите полностью закрыть свою позицию, прокрутите вниз и нажмите «Закрыть позицию», затем сделайте подтверждение в своем кошельке.
Кредитование
Чтобы воспользоваться кредитованием, вам нужно сначала пополнить свой кошелек активом, который вы собираетесь предоставить.

Шаг 1. Перейдите на страницу app.pembrock.finance/lend, выберите актив и нажмите «Депозит».

Шаг 2. Укажите сумму, которую хотите отдолжить, и подтвердите транзакцию. Обратите внимание, что вы можете кредитовать более одного пула одновременно, поэтому, если вы хотите другой актив, просто вернитесь и повторите процесс.

Получение вознаграждения
PembRock Finance поощряет как кредиторов, так и заемщиков (фармеров).

Шаг 1. Перейдите на сайт app.pembrock.finance. Там вы увидите вкладку «Портфолио» с подразделом «Разблокированные награды».

Шаг 2. Нажмите Claim и подтвердите транзакцию внутри вашего кошелька.
Вывод средств/корректировка
Шаг 1. Перейдите на страницу app.pembrock.finance/lend-pools. Там вы увидите список активов, которые вы предоставили.

Шаг 2. Выберите актив, который вы больше не хотите одалживать, и нажмите кнопку со стрелкой вниз справа в поле.

Шаг 3. Введите сумму, которую вы хотите забрать, и нажмите «Вывести».

Кроме того, вы можете скорректировать позицию, добавив больше токенов в кредит.
PembRock
PembRock был создан INC4 — профессиональной компанией по разработке блокчейнов украинского происхождения, которая существует с 2013 года.

Основная идея PembRock заключалась в том, чтобы перенести торговлю с кредитным плечом — инструмент, широко доступный для игроков на традиционных финансовых рынках, — в зарождающийся, но развивающийся сектор DeFi.

В марте 2022 года PembRock Finance получила грант в размере 75 000 долларов США от Фонда NEAR, направленный на помощь в разработке, дальнейшем совершенствовании и принятии протокола.
$PEM свойства
PEM — это собственный цифровой токен протокола PembRock. Он имеет четыре основных варианта использования:

 	Владельцы $PEM, которые размещают свои токены, получают долю во всем доходе, который приносит протокол.
 	Они также руководят процессом принятия решений по проекту посредством участия в DAO.
 	Токен занимает центральное место в механизме распределения вознаграждений за взаимодействие с протоколом.
 	$PEM также используется для предоставления дополнительного бонуса тем, кто поставляет ликвидность в наши пулы.

Места, где его купить, смотрите здесь.

Название: Финансовый токен PembRock

Тикер: PEM

Общий объем: 160 млн единиц.

Сеть: протокол NEAR

Адрес контракта: token.pembrock.near

Что такое стейкинг?
В протоколе PembRock стейкинг означает блокировку PEM в обмен на право получать часть доходов, полученных протоколом, и участвовать в Децентрализованной автономной организации, влияющей на решения, в том числе о том, сколько фермеры и кредиторы должны получать. Чем больше внесенная сумма и чем дольше период, тем выше сила голосования и вознаграждения.

Скажем, вы ставите 1000 PEM на 4 года в обмен на 1000 единиц права голоса (которые предоставляются в виде токенов vePEM), в то время как кто-то другой ставит 1000 PEM на 2 года в обмен на 500 единиц права голоса (потому что даже если они поставили тот же объем, сделали за в два раза меньший срок). Вместе ваше право голоса будет 1500. Таким образом, если протокол генерирует еженедельные вознаграждения в размере 100 PEM, вы получите 66,66 PEM (поскольку ваша доля в общей сумме ставок составит 66,66%), а другой участник всего 33,33 PEM (у них будет 33,33%).
Как стейкать
Чтобы сделать ставку и присоединиться к DAO через прокси, вам понадобится собственный цифровой токен PembRock под названием PEM. Если у вас еще нет PEM, вот как вы можете его получить.

Шаг 1. Перейдите на страницу app.pembrock.finance/staking;

Шаг 2. Введите сумму, которую вы хотите поставить, и продолжительность (оценочное количество голосов можно увидеть под датой окончания).

Шаг 3. Нажмите «Подтвердить».
Как внести изменения
Количество голосов постепенно снижается, но вы можете скорректировать свою позицию (ставить больше и/или дольше), чтобы сохранить свое влияние на том же уровне или даже сделать его более существенным.

Шаг 1. Прокрутите до конца app.pembrock.finance/staking;

Шаг 2. Введите сумму, которую вы хотите поставить сверх того, что вы уже поставили, и нажмите «Подтвердить»;

Шаг 3. После этого вы можете продлить период блокировки.

Заявка и снятие
Чтобы снять PEM по истечении периода блокировки или запросить выплату вознаграждения в PEM, посетите app.pembrock.finance/staking. Как только они станут доступными, кнопки станут оранжевыми.

Как принять участие в ДАО
В DAO вы можете установить размер вознаграждения, которое ежемесячно выплачивается как кредиторам, так и фармерам.

Шаг 1. Перейдите в приложение app.pembrock.finance/voting.. Там вы увидите две вкладки — «Вознаграждения кредиторов» и «Вознаграждения заемщиков».

Вознаграждения кредиторов зарабатываются участниками, которые вносят депозиты в кредитные пулы. Вознаграждения заемщиков получают участники, занимающие активы у кредитных пулов.

Следующие шаги одинаковы для обоих.

Шаг 2. Распределите свое право голоса по пулам, используя поле Vote. Чем выше процент, который вы даете, тем больший доход он будет генерировать.

Помните, что все % должны в сумме давать 100.

Шаг 3. Нажмите «Голосовать» и подтвердите транзакцию в NEAR Wallet.

Если вы передумаете, вы можете повторно проголосовать, пока окно все еще открыто. При этом не забудьте снова указать % для всех активов.
Заключение
PembRock только набирает обороты, поскольку рынок DeFi все еще находятся в зачаточном состоянии. Точно так же, как Ref Finance был пионером в пространстве DeFi NEAR, PembRock стал первым и единственным в сети протоколом фармерства с использованием заемных средств. Так что, если вы хотите быть в тренде, почему бы не попробовать ( остерегайтесь рисков)?

Если вы хотите быть в курсе всего, что касается PembRock, ниже приведены несколько ссылок для вас:

PembRock Website | Twitter | Telegram | Discord

### Auditing Projects on the NEAR Blockchain: From Zero to Hero

Greetings dear readers!
Today we’ll look at some professional tips in the auditing smart contracts on NEAR blockchain. In this series we will focus only on those aspects that can be really useful for auditing NEAR-based projects. Everything you see below is based on our personal experience!
First and foremost, we would like to express our sincere gratitude to the creators of NEAR and its ecosystem projects, everyone who supports it, the Authors of all the resource materials, and of course our brilliant auditors who have helped us by revealing much-needed information and lifting the curtain of secrecy. And today, dear readers, it will be made available to you.
We can confidently say that such tips can be read publicly in a few places, and our blog is one of those places! The following will be our observations — only dry facts for auditors, tricks and the best life-hacks shared by our best auditors. Let’s get started!
By the way, there are some vacant slots now so if your project needs an audit — feel free to write to us, visit our public reports page here.

I — What is NEAR?
NEAR is a development platform built on a sharded, proof-of-stake, layer-one blockchain. Using sharding technology, NEAR offers solutions to problems such as slow processing speed, network congestion, and high gas charges, allowing for significant platform scalability without sacrificing protocol security.
It is important to keep in mind that NEAR is a scalable sharded blockchain which means that deployed smart contracts are compiled to WebAssembly (WASM) and can be written in languages:


 	Rust
 	AssemblyScript (a TypeScript-like language for WebAssembly)
 	Solidity (via Aurora EVM)
 	Javascript (via JS-VM)

The use of WASM results in a high gas limit and efficiency, quick block generation, and lower transaction fees. Smart contracts in NEAR can be considered micro-services containing data and executable code. Cross-contract interactions are performed asynchronously.
With all said, from our perspective, NEAR Ecosystem is mostly Rust-based!
https://github.com/rust-in-blockchain/awesome-blockchain-rust

The platform brings together thousands of community members to deliver the most comfortable experience, as well as a wide multifunctional ecosystem:


The platform is based on several key features:
In terms of block production security, they employ a mechanism known as Doomslug. Doomslug, despite its ominous name, is quite simple and assumes that different validators take turns producing blocks based on how many NEAR tokens they staked.
We will not go into detail in this article because we assume you, dear reader, already have a sufficient understanding of the NEAR ecosystem, so we strongly advise you to visit their knowledge-base and study the project documentation for a better understanding:
https://docs.near.org/

II — NEAR Project Review Procedure from the Pessimistic.io Team:
Because the main obstacles that the auditor may have while auditing projects on NEAR are logical, the first suggestion for any firm will be in competent development, which results in solid documentation and reliable tests. It sounds too simple to be true, but be sure it works and it only proves itself over time!
So, our brilliant auditing team would like to present you our own set of rules, accumulated over many months and years of work, in which we will try to avoid redundancy and try to convey everything very concisely and professionally. With all said, we perform our audit according to the following procedures:

Automated analysis:

 	We compile contracts;
 	We run provided tests and check code coverage;
 	We run analysis tools and manually verify (reject or confirm) all reported issues (see below);

Manual audit:

 	We manually review the code and assess its quality;
 	We check the code for known vulnerabilities;
 	We check whether the code logic complies with provided documentation;
 	We suggest possible gas and storage optimizations;

Issues:
We are actively looking for:


 	Access control issues (incorrect admin or users identification/authorization);
 	Lost/stolen assets issues (assets being stuck on the contract or sent to nowhere or to a wrong account);
 	DoS due to logical issues (deadlock, state machine error, etc);
 	DoS due to technical issues (Out-of-Gas error, other limitations);
 	Contract interaction issues (reentrancy, insecure calls, caller assumptions);
 	Arithmetic issues (overflow, underflow, rounding issues);
 	Incorrect Near SDK usage;
 	Other issues.

Gas:
We check whether the gas-intesive operations are performed efficiently:


 	Collections — collections from std::collections are read all together, which inflates gas consumption. You should use near_sdk::collections or near_sdk::store;
 	Collections are tied to a storage, and you can accidentally forget to sync them;
 	Maps: LookupMap / UnorderedMap / TreeMap — You need to choose according to the required functionality (the first is the cheapest, the last the most powerful);
 	LazyOption — for rarely used “big data” (can only be used in the constructor);
 	Borsh/JSON for serialization of messages (parameters/return values) — affects gas consumption;
 	Take a close look at The “million cheap data additions” attack to avoid similar issues.

Tools:
Let’s take a close look at the automatic analysis tools you can use in your work and their features:


 	Valgrind — can be used if the code includes unsafe blocks with dangerous memory allocation. However, such a practice raises a red flag for the audit. In general, running valgrind makes no big sense!
 	Cargo Geiger is a tool that displays statistics about the use of unsafe Rust code in a Rust crate and all of its dependencies. Its ability to focus on possible problems is a beneficial feature. The existence of hazardous code is already an issue in such projects, and any such entries should be double-checked.
 	Cargo Audit — checks files for crates that contain security vulnerabilities. That is, it displays out-of-date libraries that everyone still uses. However, you should use it for audit purposes.
 	Clippy static analyzer is an awesome code linter to catch common mistakes and improve your Rust code.
 	Cargo Tarpaulin — for test coverage — a very handy tool that reveals the number of code lines that are not covered by tests.




III — Audit Public Reports
Our own NEAR ecosystem projects audit public reports are structured according to a presented above audit-flow scheme, so we recommend that you compare these reports, particularly their results, to it:


 	Sweat Economy Security Analysis by Pessimistic
 	Neatar Security Analysis by Pessimistic

We hope that this article was informative and useful for you! Thank you for reading! What instruments should we review? What would you be interested in reading about in our blog?
If you still have questions, please feel free to ask! We will be happy to answer every question you have! The best answers and questions may be included in the next blog post!
By the way, there are some vacant slots now so if your project needs an audit — feel free to write to us, visit our public reports page here.

### Как использовать NEAR на телефоне

Одним из способов использования NEAR на мобильном телефоне является HERE Wallet. Это не кастодиальный кошелек, а это означает, что закрытые ключи хранятся только на вашем телефоне.

HERE Wallet фокусируется на самом простом способе использования NEAR. Вы можете использовать множество приложений прямо из кошелька. В приложение также встроен ликвидный стек с комиссией за мгновенный вывод средств 0%. При совершении любого перевода деньги будут моментально разблокированы.

В этой статье мы расскажем, как использовать основные функции приложения HERE. Если у вас есть какие-либо вопросы, вы всегда можете задать их команде HERE в чате.
Войти с помощью seed-фразы
Если у вас есть учетная запись near, мы можем войти, используя вашу сид фразу:

 	Нажмите «импортировать существующую учетную запись».
 	Нажмите «использовать сид фразу».
 	Введите сид фразу и нажмите «найти мой аккаунт».


Если у вас есть учетная запись на wallet.near.org

 	Нажмите «импортировать существующую учетную запись».
 	Нажмите «использовать сид фразу».
 	Введите сид фразу и нажмите «найти мой аккаунт».
 	Нажмите «импортировать существующую учетную запись».
 	Нажмите «поделиться ссылкой»
 	Отправить ссылку на рабочий стол
 	Откройте ссылку, выберите учетную запись и нажмите «Далее».
 	Нажмите «Подключиться»
 	Введите идентификатор учетной записи и нажмите «Подтвердить».
 	Вы будете авторизованы на мобильном устройстве


Настройка имени пользователя (бесплатно)
NEAR доступен с именами пользователей вместо адресов. Обычно для создания имени пользователя нужно иметь NEAR, но мы выделяем их бесплатно в приложении HERE. Просто введите имя пользователя и нажмите «Продолжить».
ВАЖНО
Выбрав имя пользователя, вы не сможете его изменить. Доступно только создать новую учетную запись и перевести деньги. Мы не рекомендуем использовать вашу фамилию в имени пользователя, это может деанонимизировать вас.

Начни зарабатывать
Кошелек HERE имеет встроенный ликвидный стек, вы можете вывести деньги в любое время без каких-либо комиссий.

 	Нажмите на большую круглую розовую кнопку «Заработать».
 	Нажмите «Начать стекирование».
 	Введите сумму
 	Нажмите «Ставка» Все готово! Теперь вы будете получать ежедневный доход в размере 8-10% годовых.


Выплата дивидендов

 	Нажмите «Claim»
 	Подождите, пока он загрузится
 	Готово! Ваши дивиденды переведены на ваш баланс


Депозит NEAR с другими активами

 	Нажмите «Добавить деньги»
 	Нажмите «Купить NEAR за другую криптовалюту».
 	Выберите объект
 	Внесите BTC на указанный адрес
 	Нажмите «Готово» после внесения депозита.
 	Вы можете отслеживать статус депозита в истории транзакций


Как использовать dApps

 	Выберите HERE Wallet из списка приложений на сайте.
 	Сканируйте QR-код камерой вашего телефона
 	Вы будете перенаправлены в приложение. Нажмите «Подтвердить»

### Что такое Near Social?

Near Social (ранее известный как Social08) — это протокол социальных данных, построенный на основе NEAR Protocol.

Присоединяйтесь к группе Telegram @NearSocial для обсуждения.

Посмотрите презентацию Near Social на NEARCON22

Исследуйте Near Social: near.social
Ссылки
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

Контракт SocialDB:

 	Источник: https://github.com/NearSocial/social-db
 	Майнет: social.near
 	Тестнет: v1.social08.testnet

NEAR Social  браузер

 	Источник: https://github.com/NearSocial/viewer
 	Майнет: https://near.social/
 	Тестнет: https://test.near.social/

Если вы ищете социальную сеть на основе мастодонтов для пользователей .near, см. статью о mastodon.near.social
SocialDB
SocialDB — это смарт-контракт для хранения социальных данных в протоколе NEAR.

 	Источник кода: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	ID аккаунта тестнет: v1.social08.testnet
 	ID аккаунта маунет: social.near

Получить API
Принимает список ключей и возвращает объединенный объект JSON с соответствующими данными.


 	keys  – массив возвращаемых шаблонов клавиш. 

Чтение профиля учетной записи self.social.near
Чтобы рекурсивно прочитать все поля для заданного пути, добавьте суффикс ** .



Возвращает агрегированный JSON-объект.


Чтение имен всех аккаунтов с профилями
Обратите внимание, что этот запрос повторяется по всем учетным записям.



Ключи API
Берет список ключей и возвращает объединенный объект JSON с ключами, соответствующими запросу.



 	keys - массив возвращаемых шаблонов клавиш. 

Возвращает агрегированный объект JSON. 
Получение списка виджетов учетных записей root.near



Получение списка учетных записей, у которых есть виджеты

Обратите внимание, что этот запрос повторяется по всем учетным записям и не будет вписываться в доступный газ вызовов представлений в будущем.

Стандарты
Данные в SocialDB организованы в виде простого дерева JSON. Единственное принудительное правило заключается в том, что ключи в корне — это идентификаторы учетных записей, в которых хранятся данные. Это сделано специально, поэтому контракт SocialDB не навязывает какую-либо структуру или схему. В противном случае контракт необходимо модифицировать при каждом изменении схемы. Контроль схем контрактов может привести к централизации и ограничениям. Вместо этого  социальные стандарты живут вне контракта SocialDB.

В настоящее время Стандарты хранятся на Github по умолчанию, но в будущем это может измениться.
Описание схемы

 	жирный шрифт означает, что ключ требуется. 
 	курсив означает, что ключ является необязательным. 
 	[account_id] означает, что динамический ключ является идентификатором учетной записи. Например, alex.near в качестве ключа. Обычно это используется, чтобы создать некоторое преимущество по отношению к этой учетной записи.

Корневая схема
Каждая учетная запись должна соответствовать корневой схеме.
Виджеты
Виджеты — это многоразовые компоненты для Near Social.

Вы можете просматривать и создавать виджеты на Near.social.

Например, виджет проводника данных позволяет просматривать необработанные данные из SocialDB.


Открытый исходный код с контролем версий
Исходный код каждого виджета открыто хранится в SocialDB. Владелец виджета имеет возможность обновить виджет, обновив исходный код. Но поскольку SocialDB хранится в блокчейне, все предыдущие версии виджета также доступны. Это включает автоматический контроль версий для каждого виджета.
Разветвление
Если вы знакомы с GitHub, вы знаете, что вы можете разветвить любой общедоступный репозиторий, чтобы создать свою локальную версию. Точно так же вы можете разветвить любой виджет прямо из пользовательского интерфейса Near.social.



Форкинг создает копию исходного кода виджета, но под вашей учетной записью. Это позволяет каждому изменять существующие виджеты. Как только вы сохраните новый виджет, он сразу станет доступен. Теперь каждый может просмотреть и разветвить вашу версию виджета.

В основном это вопрос пользовательского интерфейса для создания запросов на вытягивание, чтобы люди могли объединять изменения из других форков. В настоящее время это приходится делать вручную.
Язык программирования
Виджеты реализованы в ограниченной версии JSX (JavaScript с ReactJS). Код выполняется в пользовательской виртуальной машине для создания безопасной песочницы. Это гарантирует, что виджеты не смогут получить доступ к локальному хранилищу или файлам cookie.

### Что такое Calimero? Представляем приватный шардинг на NEAR

Шарды сети Calimero —  Blockchain решение, которое обеспечивает масштабирование и конфиденциальность
Прелесть технологии блокчейн заключается в том, что все участники сетей блокчейн доверяют информации о ней, поскольку данные в этой цепочке блоков неизменны, видны и доступны всем в режиме реального времени. Но, web3, в настоящее время, далек от совершенства, поскольку существуют две основные проблемы: конфиденциальность данных и возможность масштабирования бизнеса с использованием технологии блокчейн и проблемы использования блокчейна для бизнеса.
Если все данные общедоступны и прозрачны, то возникают вопросы конфиденциальности

 	Что происходит, когда информация классифицируется как личная информация?
 	Есть ли необходимость в защите данных или соблюдении обязательств? Под какой юрисдикцией?
 	Что происходит, когда информация является коммерческой тайной?

Сохранение конфиденциальности личных и коммерческих данных — это необходимость, а не роскошь. В цепочке блоков это можно сделать за счет объединения данных. Все это возможно с приватными шардами Calimero.

Давайте пока не будем углубляться в объяснение Calimero. Есть еще один важный вопрос, который необходимо решить: масштабирование. Масштабируемость — это способность сети блокчейна поддерживать растущее количество транзакций за счет увеличения количества узлов/валидаторов.

По мере роста интереса к использованию криптовалюты и технологии блокчейн многие пользователи и компании начали выпускать токены, создавать Dapps и NFT с каждым днем все больше и больше. В результате сети стали перегружаться, что привело к увеличению расходов на газ для новых и существующих пользователей. Это отбивает у них желание создавать новые, удивительные продукты. Именно поэтому появились новые решения для масштабирования. Хорошим примером является NEAR, который использует сегментирование для масштабирования и поддержки растущего использования блокчейна. Но даже с шардингом для некоторых предприятий, которые ежедневно проводят много сетевых транзакций, затраты могут накапливаться.

Вот тут-то и появляется Calimero — вы можете создать свой собственный шард, в котором транзакции будут бесплатными и конфиденциальными. Вы должны платить только фиксированную сумму в месяц в зависимости от количества валидаторов, которые вы используете.
Что такое сеть Calimero ?
Calimero — это настраиваемый сайдчейн, построенный поверх протокола NEAR. Его можно рассматривать как сеть сетей. Решение для бизнеса, позволяющее получить доступ к функциям конфиденциальности и обеспечить масштабирование. Calimero предоставляет вам инфраструктуру, в которой используются все лучшие преимущества NEAR, а также добавлено множество новых функций с упором на конфиденциальность.

Calimero позволяет:

 	Выделить свои собственные частные сегменты (представьте себе сегмент как небольшую частную сеть блокчейнов, которой вы владеете).
 	Общаться между своими сегментами и другими сетями или между несколькими сегментами (даже если сегменты принадлежат разным компаниям).

Используя частные сегменты Calimero, пользователи могут улучшать приложения, взаимодействуя с протоколами и приложениями с открытым исходным кодом, от DeFi до NFT. Пользователи могут хранить общедоступные активы и управлять ими, а также беспрепятственно перемещать их между частными сегментами и другими общедоступными цепочками.

Кроме того, пользователи получают выгоду от транзакций между сегментами, которые дают возможность взаимодействовать с третьими сторонами в общедоступной цепочке или других разрешенных корпоративных сегментах. Частные шарды могут взаимодействовать друг с другом по зашифрованным каналам.
С Calimero возможности безграничны.
Преимущества использования приватных шардов в сети Calimero
Частные сегменты Calimero обладают всеми преимуществами NEAR с точки зрения высокой производительности, безопасности и устойчивости. Но важным отличием является то, что шарды не используют валидаторы NEAR, выполнение и хранилище состояний, а вы используете свои собственные. К основным преимуществам относятся:

 	Масштабирование вашего бизнеса за счет доступа к бесплатным транзакциям внутри сегмента.
 	Сделать часть (или все) ваших транзакций конфиденциальными, чтобы только люди/организации, имеющие доступ к сегменту, могли просматривать данные.
 	Совместимость с EVM — вы можете использовать DApp, уже созданные в основной сети Ethereum, вместо того, чтобы создавать их с нуля.
 	Совместимость с WASM и поддержка Javascript для легкой адаптации к web3
 	Интероперабельность — шарды могут взаимодействовать с основной сетью NEAR и между собой (каждый шард может представлять другую компанию или части одной и той же компании), а благодаря мосту можно передавать множество различных активов, таких как взаимозаменяемые и не взаимозаменяемые токены.
 	Настраиваемый, производительный и экономичный. Возможно выполнение до 200 000 транзакций в секунду (стандартное развертывание шарда имеет пропускную способность 5 000 транзакций в секунду). Время блокировки, размеры контрактов и лимиты газа настраиваются. Соединение активов или данных вызовов происходит быстро (5-10 секунд) и дешево (стоит пару центов).

Для кого предназначены приватные шарды Calimero?
Calimero можно использовать:

 	В качестве шлюза для традиционных (web2) приложений, чтобы попасть в мир web3 с простой в использовании панелью инструментов для управления своим частным сегментом.
 	Для компаний, уже работающих в web3, которым требуется масштабирование с нулевым газом и функции конфиденциальности.

В каких отраслях можно использовать Calimero?
Существует бесчисленное множество вариантов использования, поскольку пределом является только воображение. Для вдохновения мы перечислили несколько разных отраслей, в которых частные шарды полностью раскрывают свой потенциал.



 	
Управление


Подумайте о банках, внедряющих CBDC или варианты использования KYC и борьбы с отмыванием денег. Частные данные хранятся в сегменте и могут быть доступны при необходимости, но в остальном они скрыты от общественности.

 	
Финансовые технологии


Цифровые активы и токенизация финансовых активов, AML, KYC и цифровая идентификация, кредитный скоринг, рынки капитала, торговое финансирование, решения для конфиденциальности (для хранения и управления казначейством).

 	
Инфраструктура


Для компаний в сфере энергетики, здравоохранения, страхования, недвижимости, телекоммуникаций, логистики… Например, в логистической отрасли вы можете использовать Calimero для проверки данных, отслеживания отгрузки по нескольким компаниям (каждая со своим сегментом) и даже для покупки/продажи товаров, пока они еще находятся в пути.

 	
Веб 3


DAO, DeFi, CeFi — подумайте обо всех операциях внутри них, включая книгу заказов, даркпулы, управление казначейством и начисление заработной платы вкладчикам, а также в играх, метавселенной, развлечениях, публикациях (искусство, музыка, NFT)… Пример использования приватных шардов в играх: вы запускаете игру в шахматы в основной сети. Вы соединяете всю игру с частным шардом. На нем игра проходит БЕСПЛАТНО и ходы скрыты (если только вы не захотите их раскрыть). Вы связываете результат обратно с основной сетью. И, вуаля!

Возможности #NEAR почти безграничны! Свяжитесь с нашей командой, если вы хотите узнать больше и попробовать запустить свой собственный сегмент,  получите доступ к бесчисленным преимуществам сегментирования. Вы можете использовать Calimero бесплатно, пока мы находимся в тестовом режиме. Наша команда может предоставить вам доступ к частному шарду для вашего проекта. Подпишитесь на нас в Твиттере, чтобы быть в курсе всех новостей о приватных шардах! Если вы хотите узнать больше, вы можете послушать лекции членов команды Calimero на выставке Nearcon в Лиссабоне (сентябрь 2022 г.).

NEARCON 2022 | Nightshade Stage - Day 2

### Multiverse Fighters - первый патч

Список изменений и обновлений в Multiverse Fighters. Для игры вам понадобится NEAR Wallet в тестовой сети (не забудьте сохранить сид-фразу)
Инструменты разработки
1. Реализован функционал для геймдизайнеров, дающий возможность:

 	 -формировать навыки
 	 создавать и редактировать ботов (инвентарь, колода и т.д.)
 	 создавать вещи для ботов
 	 настроить баланс без участия разработчика

2. Обновлена тестовая база NFT, добавлены новые типы NFT
Игровая механика
1. Добавлен уровень и прокачка персонажа (возможность для игрока распределять атрибуты, полученные с каждым уровнем)

2. В игру добавлены гонки (NFT)

3. Класс и раса теперь еще больше влияют на стиль игры: - при использовании Класса помимо карт меняются характеристики игрока - при использовании Расы одни характеристики меняются в лучшую сторону, а другие в худшую. Примеры рас: Человек, Эльф, Зверолюд.

4. Добавлено 2 новых класса, которые проходят балансировку

5. Добавлено новое оружие и броня (двуручное оружие, легкая и тяжелая броня) теперь дает характеристики персонажу

6. Реализована Сила игрока (или бота), от Силы зависит количество получаемых жетонов и опыта в бою, а так же поиск соперника

7. Реализована карта мира с многоуровневыми мобами (пока в тестовой версии)

8. Добавлено 16 первых мобов, с особыми навыками и разным уровнем сложности

9. Обновлена система поиска боя.
Экономика / Токены / NFT / Блокчейн
1. Базовая экономика запущена:

 	 Добавлен токен MFIGHT для рефинансирования в тестовой сети NEAR, создана пара NEAR/FIGHT
 	 Добавлена возможность чеканить и покупать NFT за игровой токен

2. Каждый NFT имеет уникальные характеристики, которые варьируются в зависимости от редкости.

3. Добавлен смарт-контракт для токена опыта

4. Реализован апгрейд NFT за счет токена опыта и токена игры

5. Реализовано начисление наград в боях (основной жетон и жетон опыта)

6. Подготовлен инструмент для генерации признаков NFT.
Профиль персонажа
1.Система Кланов реализована базовым образом. Вы можете создать клан, загрузить логотип и пригласить пользователей, в дальнейшем функционал будет расширен и перенесен на блокчейн 2. ОРДЕРА

3. Обновлен дизайн страницы профиля

4. Реализованы звания игроков (их можно получить за активность в проекте)

5. PvP/PvE статистика разделена

6. Реализован Избранный NFT, теперь вы можете выбрать NFT, который будет отображаться в вашем профиле

7. Реализован просмотр достижений (NFT получаемых за особые события в игре)

8. Добавлен просмотр последних боев

9. Добавлено заявка токена

10. Добавлен график игры по классам

11. Добавлена страница редактирования профиля (ник, девиз, описание и аватар)

12. Реализован параметр порядочности игрока, он меняется от хорошего/плохого поведения игрока в игре (не сдаваться, не выходить из игры до конца)

13. Реализован игровой чат (базовый), реализован просмотр Онлайн игроков на локации

14. Добавлена таблица лидеров (в тестовой версии) с отображением лучших игроков по винрейту и другим параметрам

15. Турнирная сетка разделена на группы для удобства просмотра при большом количестве людей

16. В игру внедрен смарт-контракт на репутацию (токен)

17. Теперь вы можете просматривать профили других игроков.
Сайт
1. Реализован функционал по наполнению Вики-страниц, а также отдельных страниц на сайте для просмотра вики (Работа над Вики ведется)

2. Реализована система уведомлений на сайте (как личных, так и общих)
База/Сервер
На сервере подготовлен функционал для создания аналитики в игре (количество новых игроков по датам, использование классов, соотношение побед классов, количество боев по датам, количество полученных жетонов (базовых и опыта) по датам)

### ¿Qué es Near Social?

Near Social (anteriormente conocido como Social08) es un protocolo de datos sociales construido sobre el Protocolo NEAR.

Por favor, únete al grupo de Telegram de @NearSocial y sé parte de la conversación.

Mira la presentación de Near Social en el NEARCON22

Explora Near Social: near.social
Enlaces
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

Contrato de SocialDB:

 	Fuente: https://github.com/NearSocial/social-db
 	Mainnet: social.near
 	Testnet: v1.social08.testnet

Standards: https://github.com/NearSocial/standards

Navegador de Near Social:

 	Fuente: https://github.com/NearSocial/viewer
 	Mainnet: https://near.social/
 	Testnet: https://test.near.social/

Si estás buscando una red social basada en mastodon para usuarios .near, consulta el artículo sobre mastodon.near.social
SocialDB
SocialDB es un contrato inteligente que almacena datos en NEAR Protocol.

 	Código Fuente: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	ID de la cuenta Testnet: v1.social08.testnet
 	ID de la cuenta Mainnet: social.near

Obtener la API
Toma una lista de claves y devuelve un objeto JSON unido a los datos que coinciden.


 	keys - una serie de patrones claves para regresar.

Leer un perfil de la cuenta self.social.near

Para leer todos los campos de forma recursiva para una ruta determinada, agrega el sufijo **.

Regresa el objeto JSON agregado.

Leyendo los nombres de todas las cuentas con perfiles.

Toma en cuenta que esta consulta itera sobre todas la cuentas y no se ajustará en el gas disponible para vistas en el futuro.


Claves de API
Toma una lista de claves y regresa un objeto JSON unido con las claves que coincidan con la solicitud.


 	keys - una serie de patrones claves para regresar.

Regresa al objeto JSON agregado.

Obtener una lista de los widgets de las cuentas root.near


Obtener una lista de cuentas que tienen widgets.

Toma en cuenta que esta consulta itera sobre todas la cuentas y no se ajustará en el gas disponible para vistas en el futuro.

Standards
Los datos en SocialDB están organizados como un simple árbol JSON. La única regla aplicada es que las claves en la raíz son los ID de las cuentas que almacenan los datos. Esto se hace a propósito, para que el contrato de SocialDB no imponga ninguna estructura o esquema. De lo contrario, el contrato deberá ser modificado por cada cambio en el esquema. El control de los esquemas del contrato, puede llevar a las restricciones y a la centralización. En cambio, los Near Social Standards viven fuera del contrato de SocialDB.

En la actualidad, Standards on Github es el lugar predeterminado de los estándares, pero esto puede cambiar en el futuro.

Descripción del Esquema

 	Bold quiere decir que la clave es requerida.
 	Italic quiere decir que la clave es opcional
 	[account_id] significa que la clave dinámica es un ID de una cuenta. Por ejemplo, alex.near como clave. Es usada, generalmente, para crear alguna ventaja sobre esa cuenta.

Esquema de Raíz

Cada cuenta debería seguir el Esquema de Raíz
Widgets
Los Widgets son componentes reutilizables y combinables para Near Social.

Puedes ver y crear widgets en near.social .

Por ejemplo, un widget para explorar datos te permite explorar datos en bruto de SocialDB.

Código abierto con control de versiones 
El código fuente de cada widget está almacenado abiertamente en SocialDB. El dueño del widget tiene la habilidad de hacer mejoras al widget, mediante la actualización del código fuente. Pero como SocialDB está almacenado en una blockchain, todas las versiones previas del widget también estarán disponibles. Esto permite el control automático de la versión de cada widget.
Bifurcación
Si estás familiarizado con GitHub, sabes que puedes bifurcar cualquier repositorio público para crear tu versión local. De igual forma, puedes bifurcar cualquier widget directo desde la interfaz de usuario de near.social .

La bifurcación crea una copia de la fuente de código del widget, pero bajo tu cuenta. Permite a cualquier persona modificar el widget existente. Una vez que guardes el nuevo widget, estará disponible de inmediato. Y todos podrán ver y bifurcar tu versión del widget.

Se trata principalmente de una interfaz de usuario para crear un pull request, para que las personas puedan fusionar cambios de otras bifurcaciones. Actualmente, se debe hacer de forma manual.
Lenguaje de Programación
Los widgets están implementados en una versión limitada de JSX (un JavaScript con ReactJS). El código se ejecuta en una Virtual Machine personalizada para crear un espacio aislado y seguro. Esto garantiza que los widgets no puedan acceder al almacenamiento local ni a las cookies.

### ¿Qué es Calimero? Presentamos la Fragmentación Privada en NEAR

Explicación de los fragmentos privados de la red Calimero: solución de cadena de bloques que permite el escalado y la privacidad
La belleza de la tecnología blockchain es que todos los participantes en las redes blockchain confían en la información que ésta contiene, porque los datos de esa cadena son inmutables, visibles y accesibles para todos en tiempo real. Pero actualmente la web3 está lejos de ser perfecta, ya que existen dos desafíos principales: la privacidad de los datos y el potencial para que las empresas escalen utilizando la tecnología blockchain.

Desafíos en el uso de blockchain para empresas.

Si todos los datos están disponibles públicamente y son transparentes, surgen cuestiones de privacidad.

 	¿Qué sucede cuando la información se clasifica como información personal?
 	¿Existe la necesidad de protección de datos o de obligaciones de cumplimiento? ¿Bajo qué jurisdicción?
 	¿Qué sucede cuando la información es un secreto comercial?

Preservar la privacidad de los datos personales y comerciales es una necesidad, no un lujo. En la blockchain, se puede hacer mediante la combinación de datos e interoperabilidad dentro y fuera de ésta. Todo lo cual es posible con los fragmentos privados de Calimero.

No saltemos a la explicación de Calimero todavía. Hay una pregunta más importante que debe abordarse: la escalabilidad. La escalabilidad es la capacidad de una red blockchain para admitir una cantidad cada vez mayor de transacciones, al aumentar la cantidad de nodos/validadores.

A medida que crecía el interés por usar la criptomoneda y la tecnología blockchain, muchos usuarios y empresas comenzaron, cada día con mayor frecuencia, a emitir tokens, construir Dapps y crear NFT. Como consecuencia, las redes comenzaron a congestionarse, lo que resultó en un aumento de los costos de gas para los usuarios nuevos y existentes, lo que los desanimó a construir productos más sorprendentes. Es aquí donde surgieron nuevas soluciones de escalado. Un buen ejemplo es  NEAR, que utiliza  la fragmentación o Sharding para escalar y respaldar el uso cada vez mayor de la blockchain. Pero incluso con la fragmentación, para algunas empresas que tienen muchas transacciones de red a diario, los costos pueden acumularse.

Aquí es donde entra Calimero, ya que puedes crear tu propio fragmento o shard dentro del cual las transacciones son gratuitas y privadas. Solo debes pagar una cantidad fija por mes según la cantidad de validadores que estés ejecutando.
¿Qué es la red Calimero?
Calimero es una cadena lateral personalizable construida sobre el Protocolo NEAR. Puede ser visto como una red de redes. Una solución para que las empresas accedan a funciones de privacidad y les permita escalar. Calimero te brinda una infraestructura que comparte lo mejor de los beneficios de NEAR, mientras se mejora con múltiples características nuevas con énfasis en la privacidad.

Calimero te permite:

 	Escindir tus propios shards privados (piensa en un shard como una pequeña red privada de blockchain de tu propiedad).
 	Comunicarte entre tus shards y otras redes, o entre múltiples shards (incluso si estos son propiedad de diferentes empresas).

Mediante el uso de los shards privados de Calimero, entre otras cosas, los usuarios pueden mejorar las aplicaciones interoperando con protocolos y aplicaciones de código abierto, desde DeFi a NFTs. Los usuarios pueden mantener y administrar activos públicos y moverlos entre shards privados y otras cadenas públicas sin problemas.

Además, los usuarios se benefician de las transacciones de shards cruzados, que brindan la capacidad de interactuar con terceros en la cadena pública u otros shards empresariales autorizados. Los shards privados pueden interactuar entre sí a través de canales encriptados.

Con Calimero, las posibilidades son infinitas.
Beneficios de usar fragmentos o shards privados de la red Calimero
Los shards privados de Calimero tienen todos los beneficios de NEAR en términos de alto rendimiento, seguridad y sostenibilidad. Pero como una distinción importante, los shards no usan los validadores, la ejecución y el almacenamiento de estado de NEAR, sino que tú usas los tuyos propios. Los principales beneficios incluyen:

 	Escalar tu negocio al tener acceso a transacciones gratuitas dentro del shard.
 	Hacer que parte (o todas) tus transacciones sean privadas, y que solo las personas/entidades con acceso al fragmento puedan ver los datos.
 	Compatibilidad con EVM: puedes usar DApps ya integradas Ethereum mainnet en lugar de construirlas desde cero.
 	Compatibilidad con WASM y compatibilidad con Javascript para una fácil incorporación a web3.
 	Interoperabilidad: los shards pueden comunicarse con la red principal NEAR y entre ellos (cada fragmento puede representar una empresa diferente o partes de la misma empresa) y, gracias al puente, se pueden transferir múltiples activos diferentes, como tokens fungibles y no fungibles.
 	Personalizable, eficaz y rentable. Es posible realizar hasta 200.000 transacciones por segundo (la implementación de shards estándar tiene un rendimiento de 5.000 transacciones por segundo). Los tiempos de bloque, los tamaños de contrato y los límites de gas son personalizables. Unir los activos o llamar a los datos es rápido (5-10 segundos) y económico (cuesta un par de centavos).

¿Para quién son los shards privados de Calimero?
Calimero puede ser usada:

 	Como una puerta de entrada para que las empresas tradicionales (web2) ingresen al mundo web3 con un tablero fácil de usar para administrar su shard privado.
 	Para empresas que ya operan en web3 que necesitan características de privacidad y escalado de gas cero.

¿En qué industrias se puede utilizar Calimero?
Hay innumerables casos de uso, ya que solo la imaginación es el límite. Para brindar algo de inspiración, hemos enumerado un par de industrias diferentes donde los shards privados alcanzan su máximo potencial.


 	Gobernanza
Piensa en los bancos que implementan casos de uso de CBDC o KYC y antilavado de dinero. Los datos privados se almacenan en un shard y pueden estar disponibles cuando sea necesario, pero por lo demás están ocultos al público.
 	Fintech
Activos digitales y tokenización de activos financieros, AML, KYC e identidad digital, credit scoring, mercado de capitales, trade finance, soluciones de privacidad (para gestión de custodia y tesorería)…
 	Infraestructura
Para empresas de energía, sanidad, seguros, inmobiliaria, telecomunicaciones, cadena de suministro…Por ejemplo, en la industria de la cadena de suministro/transporte, puede usar Calimero para verificar datos, realizar un seguimiento del envío en varias empresas (cada una con su propio shard) e incluso comprar/vender los productos mientras aún están en el transporte.
 	Web3
DAO, DeFi, CeFi: piensa en todas las operaciones dentro de ellos, incluido el libro de pedidos, los darkpools, la gestión de tesorería y la nómina de contribuyentes. También en juegos, metaverso, entretenimiento, publicación (arte, música, NFT)...Ejemplo de uso de shards privados en juegos: inicia un juego de ajedrez en la red principal. Conectas todo el juego a un shard privado. En él, el juego se desarrolla GRATIS y los movimientos están ocultos (a menos que quieras revelarlos). Haces un puente entre el resultado y la red principal. ¡Y voilá!

¡Las posibilidades de #NEAR son infinitas! Contacta nuestro equipo si deseas obtener más información e intentar ejecutar tu propio shard privado para acceder a los innumerables beneficios del sharding. Puedes usar Calimero gratis mientras estamos en modo de prueba. Nuestro equipo puede darte acceso a un shard privado para tu proyecto. Síguenos en Twitter ¡Para estar atento a todas las noticias sobre shards privados! Si deseas obtener más información, puedes escuchar las conferencias que los miembros del equipo de Calimero tuvieron en Nearcon en Lisboa (septiembre de 2022).

https://youtu.be/VrK46yUEh9s

### Redeem poll December 2022



### Update - November 10, 2022

Brief Summary:

 	
NEAR Social is (L)Earning Partner of the month!


Results:

 	🏆Top 10 #NEAR projects who got the most (L)Earners attention in October!📚

 	(L)Earn "What is@NearSocial_?"
 	🕺 956 (L)Earner NFTs minted so far! Minting cost increases gradually with every mint and will reach 10 $NEAR for (L)Earner #10,000
 	💸  68 $NEAR were sent to the best LNC Beta Testers who explored dWork.
Well done, (L)Earners!

 	🧪Beta test for (L)Earning partner @NearSocial_ was a 🔥🔥🔥🔥!
Sent 40 $NEAR for to legit feedback provider!
 	🧑‍🤝‍🧑 LNC community members is over 42,800 (L)Earners!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	 LNC community members is getting to  50,000 (L)Earners!

### Comment utiliser NEAR sur votre téléphone

Une façon d'utiliser NEAR sur votre téléphone portable est le portefeuille HERE Wallet. Il s'agit d'un portefeuille non dépositaire, ce qui signifie que les clés privées ne sont stockées que sur votre téléphone

HERE Wallet se concentre sur la manière la plus simple d'utiliser NEAR. Vous pouvez utiliser de nombreuses applications directement depuis le portefeuille. Il y a aussi un empilement de liquide intégré à l'application avec des frais de retrait instantané de 0 %. Lorsque vous effectuez un transfert, l'argent sera instantanément débloqué par l'arrière-plan.

Dans cet article, nous avons expliqué comment utiliser les fonctionnalités de base de l'application HERE. Si vous avez des questions, vous pouvez toujours les poser à l'équipe HERE dans la salle de discussion.
Connectez-vous avec la phrase de départ
Si vous avez compte NEAR, nous pouvons nous connecter en utilisant votre phrase de départ :

 	Cliquez sur “import existing account”
 	Cliquez sur “use seed phrase”
 	Entrez la phrase de départ et cliquez sur “find my account”


Si vous avez un compte sur wallet.near.org

 	Cliquez sur “import existing account”
 	Cliquez sur “use seed phrase”
 	Entrez la phrase de départ et cliquez sur “find my account”
 	Cliquez sur “import existing account”
 	Cliquez sur “share the link”
 	Envoyez le lien sur votre bureau
 	Ouvrez le lien, sélectionnez le compte et cliquez sur “Next”
 	Cliquez sur “Connect”
 	Entrez l'ID du compte et cliquez sur “Confirm”
 	Vous serez autorisé sur un appareil mobile


Configurer le nom d'utilisateur (gratuit)
NEAR est disponible avec des noms d'utilisateur au lieu d'adresses. Habituellement, vous devez avoir NEAR pour créer un nom d'utilisateur, mais nous les attribuons gratuitement dans l'application HERE. Entrez simplement le nom d'utilisateur et cliquez sur Continue

NOTES IMPORTANTES

Une fois que vous avez sélectionné un nom d'utilisateur, vous ne pouvez pas le modifier. Le seul disponible est de créer un nouveau compte et de transférer de l'argent

Nous vous déconseillons d'utiliser votre nom de famille dans le nom d'utilisateur, cela peut vous désanonymiser

Commencer a gagner
Le HERE Wallet a un staking de liquide intégré, vous pouvez retirer de l'argent à tout moment sans aucun frais

 	Cliquez sur le gros bouton rond rose “Earn”
 	Cliquez sur “Start stacking”
 	Entrez le montant
 	Cliquez sur “Stake”
 	Tout est prêt ! Maintenant, vous recevrez un revenu quotidien au taux de 8-10% par an. sur votre solde


Réclamer des dividendes

 	Cliquez sur “Claim”
 	Attendez qu'il soit chargé
 	Fait! Vos dividendes ont été transférés sur votre solde


Dépôt NEAR avec d'autres actifs

 	Cliquez sur  “Add money”
 	Cliquez sur  “Buy NEAR with other crypto”
 	Sélectionnez l'actif
 	Déposez BTC à l'adresse indiquée
 	Cliquez sur Terminé après le dépôt
 	Vous pouvez suivre l'état du dépôt dans l'historique des transactions


Comment utiliser les dApps

 	Sélectionnez HERE Wallet dans la liste des applications sur le site
 	Scannez le code QR avec l'appareil photo natif de votre téléphone
 	Vous serez redirigé vers l'application. Cliquez sur "Confirm"

### Transition du portefeuille NEAR : pourquoi cela se produira-t-il et que devraient faire ses utilisateurs maintenant

Sans aucun doute, la plupart des utilisateurs NEAR ont entendu parler de la transition du portefeuille NEAR. Mais il reste encore beaucoup de questions sur ses raisons, ses processus et sa relation avec MyNearWallet . Voici les questions les plus posées sur la transition avec les commentaires de l'équipe MyNearWallet.
Pourquoi devrais-je passer d'un portefeuille "officiel" développé par la Near Foundation à un autre ?
Pour commencer, les utilisateurs NEAR ont des besoins et des préférences différents et il est peu probable qu'un seul produit officiel les couvre tous. À un moment donné, les développeurs de l'écosystème NEAR l'ont réalisé et ont décidé que dans un proche avenir, l'écosystème NEAR n'aurait pas de portefeuille officiel et que tous les DApps seraient encouragés à utiliser un sélecteur de portefeuille. Le portefeuille NEAR officiel, wallet.near.org , deviendra une page de liste pour tous les portefeuilles de l'écosystème. Les dates exactes ne sont pas encore annoncées.

Les changements devraient renforcer la décentralisation et inspirer une saine concurrence dans l'écosystème NEAR. En conséquence, sans portefeuille officiel, les utilisateurs obtiendront des produits plus avancés.
Comment MyNearWallet est-il connecté au portefeuille NEAR ?
Kikimora Labs construit MyNearWallet au -dessus de la base de code open source  du portefeuille NEAR . La base d'utilisateurs n'a pas été déplacée vers MyNearWallet. Le portefeuille lui-même est resté open source. Dans le nouveau projet, l'équipe MyNearWallet a commencé à améliorer les anciennes fonctionnalités, à en ajouter de nouvelles et à renforcer la sécurité. Pour le moment, l'équipe d'assistance de MyNearWallet aide les utilisateurs des deux portefeuilles. En outre, l'équipe Mhttps://www.mynearwallet.com/yNearWallet résout les problèmes de bugs pour deux projets. Pendant ce temps, les nouvelles fonctionnalités seront disponibles uniquement dans MyNearWallet.

L'interface de MyNearWallet ressemble toujours presque à celle de wallet.near.org . Mais comme le prétend l'équipe du projet, la conception sera modifiée en douceur.
Qu'adviendra-t-il de mon compte https://wallet.near.org/ ?
Les utilisateurs peuvent transférer leurs comptes vers n'importe quel portefeuille NEAR de leur choix sans perte de fonds. Voici les instructions pour transférer votre compte vers MyNearWallet.
Feuille de route et stratégie de transition du portefeuille

 	Phase 0 — Engagement communautaire [maintenant]
 	Phase 1 - Utilisateurs externes, activer les fonctionnalités du compte d'exportation [début octobre]
 	Phase 2 - Un nouveau portail pour Array of wallets [devrait s'achever début 2023]
 	Phase 3 — Terminer le transfert de la transaction
 	Phase 4 — Arrêt complet du portefeuille NEAR

### Qu'est-ce que Caliméro ? Présentation du Sharding privé sur NEAR

Explication des fragments privés du réseau Calimero : solution de chaîne de blocs permettant l'évolutivité et la confidentialité

La beauté de la technologie blockchain est que tous les participants aux réseaux blockchain font confiance aux informations qu'elle contient, car les données de cette chaîne sont immuables, visibles et accessibles à tous en temps réel. Mais actuellement, le web3 est loin d'être parfait, car il y a deux défis principaux : la confidentialité des données et la possibilité pour les entreprises d'évoluer en utilisant la technologie blockchain.

Les défis de l'utilisation de la blockchain pour les entreprises

Si toutes les données sont accessibles au public et transparentes, des problèmes de confidentialité se posent.

 	Que se passe-t-il lorsque des informations sont classées comme informations personnelles ?
 	Existe-t-il un besoin de protection des données ou d'obligations de conformité ? Sous quelle juridiction ?
 	Que se passe-t-il lorsque l'information est un secret commercial ?

Préserver la confidentialité des données personnelles et professionnelles est une nécessité, pas un luxe. Dans la blockchain, cela peut se faire en combinant données et interopérabilité à l'intérieur et à l'extérieur de la blockchain. Tout cela est possible avec les fragments ou shards privés de Calimero.

Ne sautons pas tout de suite dans l'explication de Calimero. Il y a une autre question importante qui doit être abordée : l'évolutivité. L'évolutivité est la capacité d'un réseau blockchain à prendre en charge un nombre croissant de transactions, en augmentant le nombre de nœuds/validateurs.

Au fur et à mesure que l'intérêt pour l'utilisation de la crypto-monnaie et de la technologie blockchain augmentait, de nombreux utilisateurs et entreprises ont commencé à émettre des jetons, à créer des Dapps et à créer de plus en plus de NFT chaque jour. En conséquence, les réseaux ont commencé à être congestionnés, entraînant une augmentation des coûts du gaz pour les utilisateurs nouveaux et existants, les décourageant de construire des produits plus étonnants. C'est là que de nouvelles solutions de mise à l'échelle sont apparues. Un bon exemple est  NEAR, qui utilise le sharding pour évoluer et prendre en charge l'utilisation toujours croissante de la blockchain. Mais même avec le sharding, pour certaines entreprises qui effectuent quotidiennement de nombreuses transactions sur le réseau, les coûts peuvent s'accumuler.

C'est là qu'intervient Calimero, car vous pouvez créer votre propre shard dans laquelle les transactions sont gratuites et privées. Vous n'avez qu'à payer un montant fixe par mois en fonction du nombre de validateurs que vous utilisez.
Qu'est-ce que le réseau Calimero ?
Calimero est une chaîne latérale personnalisable construite sur Protocole NEAR. Il peut être vu comme un réseau de réseaux. Une solution pour les entreprises pour accéder aux fonctionnalités de confidentialité et à l'échelle. Calimero vous offre une infrastructure qui partage le meilleur de bénéfices de NEAR tout en étant amélioré avec de multiples nouvelles fonctionnalités mettant l'accent sur la confidentialité.

Calimero vous permet de :

 	Faites tourner vos propres shards privés (considérez un shard comme un petit réseau de blockchain privé que vous possédez)
 	Communiquez entre vos shards et d'autres réseaux, ou entre plusieurs shards (même s'ils appartiennent à des sociétés différentes)

Grâce à l'utilisation de shards Calimero privés, entre autres, les utilisateurs peuvent améliorer les applications en interopérant avec des protocoles et des applications open source, dès DeFi à NFTs. Les utilisateurs peuvent maintenir et gérer les actifs publics et les déplacer entre les shards privés et d'autres chaînes publiques de manière transparente.

De plus, les utilisateurs bénéficient de transactions entre shards, qui permettent d'interagir avec des tiers sur la chaîne publique ou d'autres shards d'entreprise autorisés. Les shards privés peuvent interagir les uns avec les autres via des canaux cryptés.

Avec Calimero, les possibilités sont infinies.
Avantages de l'utilisation de shards privées par le réseau Calimero
Les shards privés Calimero présentent tous les avantages de NEAR en termes de hautes performances, de sécurité et de durabilité. Mais comme distinction importante, les shrads n'utilisent pas les validateurs, l'exécution et le stockage d'état de NEAR, vous utilisez les vôtres. Les principaux avantages incluent :

 	Développez votre entreprise en ayant accès à des transactions gratuites au sein du shard.
 	Rendez certaines (ou toutes) vos transactions privées, et seules les personnes/entités ayant accès au shard peuvent voir les données.
 	Prise en charge EVM : vous pouvez utiliser des DApp déjà intégrés Ethereum mainnet au lieu de les construire à partir de zéro.
 	Prise en charge de WASM et prise en charge de Javascript pour une intégration facile dans web3
 	Interopérabilité : les fragments peuvent communiquer avec et avec le réseau principal NEAR (chaque shard peut représenter une entreprise différente ou des parties de la même entreprise), et grâce au pont, plusieurs actifs différents tels que des jetons fongibles et non fongibles peuvent être transférés.
 	Personnalisable, efficace et rentable. Jusqu'à 200 000 transactions par seconde sont possibles (l'implémentation du shard standard fonctionne à 5 000 transactions par seconde). Les temps de bloc, les tailles de contrat et les limites de gaz sont personnalisables. Lier des actifs ou appeler des données est rapide (5 à 10 secondes) et bon marché (coûte quelques centimes).

À qui sont destinés les shards privés Calimero ?
Calimero peut être utilisé :

 	En tant que passerelle permettant aux entreprises traditionnelles (web2) d'entrer dans le monde du web3 avec un tableau de bord facile à utiliser pour gérer votre shard privée.
 	Pour les entreprises opérant déjà sur le Web3 qui ont besoin d'une mise à l'échelle sans gaz et de fonctionnalités de confidentialité.

Dans quelles industries Calimero peut-il être utilisé ?
Il existe d'innombrables cas d'utilisation, car seule votre imagination est la limite. Pour vous inspirer, nous avons répertorié quelques industries différentes dans lesquelles les shards privés atteignent leur plein potentiel.


 	Gouvernement
Pensez aux banques mettant en œuvre la CBDC ou KYC et les cas d'utilisation de la lutte contre le blanchiment d'argent. Les données privées sont stockées sur un shard et peuvent être disponibles en cas de besoin, mais sont autrement cachées au public.
 	Fintech
Actifs numériques et tokenisation des actifs financiers, AML, KYC et identité numérique, notation de crédit, marchés de capitaux, financement du commerce, solutions de confidentialité (pour la conservation et la gestion de trésorerie)...
 	Infrastructure
Pour les entreprises des secteurs de l'énergie, de la santé, des assurances, de l'immobilier, des télécommunications, de la chaîne d'approvisionnement... Par exemple, dans l'industrie du transport/de la chaîne d'approvisionnement, vous pouvez utiliser Calimero pour vérifier les données, suivre les expéditions entre plusieurs entreprises (chacun avec votre propre shard) et même acheter/vendre les produits pendant qu'ils sont encore en transit.
 	Web3
DAO, DeFi, CeFi - pensez à toutes les opérations en leur sein, y compris le carnet de commandes, les darkpools, la gestion de la trésorerie et la paie des contributeurs. Également dans les jeux, le métaverse, le divertissement, l'édition (art, musique, NFT)... Exemple d'utilisation de shards privés dans les jeux : lancez une partie d'échecs sur le réseau principal. Vous connectez tout le jeu à un shard privé. Dans celui-ci, le jeu est joué GRATUITEMENT et les mouvements sont masqués (sauf si vous souhaitez les révéler). Vous faites un pont entre le résultat et le réseau principal. Et voila !

Les possibilités de #NEAR sont infinies ! Contactez notre équipe si vous souhaitez en savoir plus et essayez de gérer votre propre partition privée pour accéder aux innombrables avantages du partitionnement. Vous pouvez utiliser Calimero gratuitement pendant que nous sommes en mode d'essai. Notre équipe peut vous donner accès à un shard privé pour votre projet. Suivez-nous sur Twitter Pour rester à l'écoute de toutes les nouvelles concernant les fragments privés ! Si vous voulez en savoir plus, vous pouvez écouter les conférences que les membres de l'équipe Calimero ont eues au Nearcon à Lisbonne (septembre 2022).

https://youtu.be/VrK46yUEh9s

### Que sont les NFT (L)Earner

Que sont les NFT (L)Earner ?
Une nouvelle collection NFT passionnante récemment lancée dans l'Écosystème NEAR. Avant d'explorer ce qu'est la collection (L)Earner NFT, voici un bref résumé de ce qu'est un NFT. N'hésitez pas à l'ignorer si vous connaissez déjà les NFT.
Qu'est-ce qu'un NFT ?
NFT signifie jeton non fongible. Les NFT sont des actifs numériques uniques dont les informations d'identification sont enregistrées dans un contrat intelligent. Les informations contenues dans le contrat intelligent sont ce qui rend un NFT unique. Un NFT est un actif non fongible. Les biens durables ne sont pas divisibles. Par exemple, vous ne pouvez pas envoyer à quelqu'un une partie d'un tableau ou un billet.

Les NFT sont des certificats numériques de propriété d'actifs numériques. Un NFT est un contrat intelligent utilisé pour sécuriser un actif numérique. Une fois écrite, elle est publiée dans un token (ERC-721 ou NEP-171) sur la blockchain. Tout peut être converti en NFT, les plus populaires étant la vidéo, le GIF ou le JPEG.
Qu'est-ce que la collection (L)Earner NFT ?
La collection (L)Earner NFT est une collaboration entre la communauté Learn Near Club (LNC) community et Denis Bashev, l'un des meilleurs graphistes primés d'Europe.
Concept de Conception
Le concept de conception est basé sur la diversité dynamique de l'intelligence humaine entraînée par le caractère unique de chaque apprenant. Chaque être humain est un individu unique qui a des modèles d'apprentissage, des forces et des faiblesses divers. La collection (L)Earner NFT vise à mettre en évidence l'individualité de chaque apprenant et la manière dont les différents rouages ​​de la machine interagissent pour créer une personne holistique, chacun avec ses propres rêves, peurs, expériences et personnalité.

Pour ceux qui ne connaissent pas la façon dont nous apprenons au niveau scientifique, voici l'essentiel :

Lorsque vous participez activement à l'apprentissage de quelque chose, les neurones (cellules du cerveau) commencent à établir des connexions les uns avec les autres. Au début, ces connexions sont très faibles et la connaissance n'est pas entièrement engagée dans la mémoire à long terme. Au fur et à mesure que le temps passe et que vous passez plus de temps à apprendre un concept, ces liens se renforcent et s'engagent dans la mémoire à long terme. Vos connaissances sont en fait stockées dans des milliards de connexions neuronales entre les neurones du cerveau humain. Ce processus est appelé apprentissage hebbien.

L'idée des figures de bâton est basée sur le système nerveux humain. Les segments qui composent une personne bâton sont inspirés des gaines de myéline qui aident à transmettre les impulsions électriques à travers les neurones.


Les poses de personnages incarnent la myriade de combinaisons de connexions neuronales qui fusionnent dans leurs propres microcosmes pour former des souvenirs à long terme distincts d'un concept ou d'une activité. Les segments de ligne sont dessinés sur un plan de coordonnées pour créer des poses amusantes.


Denis a soigneusement sélectionné la palette de couleurs pour lui donner vie et donner un ton plus ludique aux stick people. Il symbolise la joie d'apprendre. La joie d'apprendre n'est pas quelque chose qui peut être ressenti avec une gratification instantanée. C'est l'aboutissement de toutes les façons dont une soif de nouvelles compétences et connaissances a amélioré votre vie et celle de ceux qui vous entourent.

Mint
Tous les minteurs NFT sont invités à participer à ce projet de pointe. Le  coût du mint a commencé à partir de 2 $ NEAR et augmente progressivement à mesure que la collection grandit vers sa limite de 10 000 NFT. Les monnayeurs peuvent :

 	Générer- Le logiciel génère une pose aléatoire et un mélange de couleurs autant de fois que vous le souhaitez, de sorte que vous obtenez le (L)Earner NFT que vous souhaitez. La plupart des NFT sur le marché sont "générés" à partir de modèles préfabriqués, tandis que les NFT de (L)Earner ont un nombre pratiquement illimité de combinaisons qui créent un NFT qui vous est vraiment unique.


 	Nom- attribuez un nom à votre (L)Earner NFT, rendez-le aussi unique que votre personnage


 	Mint- Mintez votre NFT et sécurisez-le sur la blockchain NEAR.


 	Sélectionner- collectez autant que vous le souhaitez et sélectionnez votre collection personnelle d'origine
 	Trade- Acheter et vendre des NFT (L)Earner dans les Paras NEAR NFT Marketplace

Avantages du (L)Earner NFT LNC
Non seulement vous obtenez un NFT cool lorsque vous mintez un NFT (L)Earner, mais vous bénéficiez également d'avantages utiles en tant que membre officiel de la communauté LNC :

 	Priorité d'accès anticipé de 2 heures à Échanger à la fenêtre NEAR
 	Preuve de  Mint (L)Earn des NFT
 	Plus à venir dans le futur…

Rejoignez le groupe de LNC telegram group pour partager votre NFT (L)Earner avec d'autres membres de la communauté
Conclusion
La collection (L)Earner NFT est une collaboration de pointe entre LNC et Denish Bashev (graphiste primé). L'objectif du projet est d'encapsuler l'expérience d'apprentissage individuelle de chaque étudiant dans un NFT. La collection est limitée à 10 000 NFT, alors procurez-vous le vôtre tant que vous le pouvez !

### The Guide to PembRock Finance

Enjoy the Advantages of LYF with PembRock
Intro
In this guide, we look at the most widespread ways to earn with DeFi —yield farming, lending, and staking—through the lens of PembRock, the first and only LYF platform on NEAR Protocol that is powered by Ref.finance DEX.

Let’s start with the basics.
What’s Yield Farming?
For any Decentralized Finance project to function, there needs to be liquidity. Liquidity is what makes transactions possible at all, and participants that make platforms liquid are called Liquidity Providers, or LPs. Now, for doing that, they get rewarded with a particular pool’s LP tokens (also called ‘shares’) through a process known as liquidity mining. These tokens represent the user’s share in total liquidity, which in its turn determines their potential profits.

Yield farming is an extra incentive that rewards users for the very fact of locking their funds so that other participants can use them to earn themselves. After receiving the LP tokens, a liquidity provider can put them into a yield farming pool to become a farmer. For that, they will get extra payouts in the platform’s native crypto (in Ref.finance’s case, this would be $REF; in PembRock’s case, this would be $PEM; and so on) or a different cryptocurrency (e.g., USDT), depending on a given farming program’s rules.
What’s Leveraged Yield Farming?
With regular yield farming, you can only provide the amount that you have, which seems only logical. But what if you wanted to maximize returns (and risks, don’t forget that)? In that case, you’d need to borrow funds from others, and that’s what leveraged yield farming helps you do.

 

While many DeFi platforms require that users put up funds of a greater value than those being borrowed (which is also known as overcollateralization), PembRock doesn’t, giving farmers the opportunity to take out the amount that’s up to three times bigger.

So if you, for example, decided to provide 100 USN as collateral and borrow 200 USN, you’d have 300 USN in total, meaning the leverage level would be 3 at a debt ratio of 67%. If the price of USN went down by more than 31%, that would mean that your loss could no longer be covered. That’s when liquidation would happen.


What’s Lending?
Lending is a strategy that enables you to earn interest for letting someone else use your money. At the same time, unlike farmers, lenders are not prone to the risk of liquidation (e.g., think of a situation when one of the assets in a pool falls to $0), while their returns are auto-compounded and paid out on a regular basis. Sounds fair, right?
Before You Start
Head to app.pembrock.finance and press the Connect wallet button you’ll see in the upper-right corner. The wallet selector window will pop up; pick the one that you prefer. After that, you’ll be taken to your wallet, where you’ll have to enable certain access rights and allow PembRock App to spend some of your NEAR to cover transaction fees.Leveraged Yield Farming

To farm yield with leverage, you’ll need to first load your wallet with the asset that you want to do that with.

Step 1. Go to the Farm section: app.pembrock.finance/farm.

Step 2. Select the pair and click Farm.

Step 3. Pick the asset you want to deposit, the one you want to borrow, their amounts, and the leverage (between 1x and 3x with an increment of .5).

 

Step 4. Click Farm and confirm the transaction. Please note that you can have multiple farming positions open at the same time, so if you have another pool in mind, just go back and repeat the process.
Closing a Farming Position & Claiming Rewards
Step 1. Go to Portfolio and switch to the Farm Positions tab.

Step 2. Press Close next to the position you want to exit.

Step 3. On the next screen, you can close the position in full.

Minimize Trading means that we will convert the minimum required amount of tokens into the borrowed token to pay back the debt and return the remaining assets to you.

Convert all means that your entire position will be converted to the borrowed token and returned to you after the debt is paid.

Step 4. If you want to close your position entirely, scroll down to the bottom and press Close Position, then make an approval in your wallet.




	

	
	
		
			
				With regards to leveraged yield farming, PembRock…
			
		

		
					

		
			
			
			
			Overcollateralizes
		
			
			Undercollateralizes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Lending
To make use of lending, you’ll need to first top up your wallet with the asset that you are going to provide.

Step 1. Go to app.pembrock.finance/lend, select the asset, and click Deposit.

Step 2. Specify the amount you wish to lend and confirm the transaction. Please note that you can lend in more than one pool at a time, so if you have another asset in mind, just go back and repeat the process.

Claiming Rewards
PembRock Finance incentivizes both lenders and borrowers (farmers).

Step 1. Go to app.pembrock.finance. There, you’ll see a Portfolio tab with an Unlocked Rewards subsection.

Step 2. Press Claim and approve the transaction inside your wallet.
Making Withdrawals/Adjustments
Step 1. Go to app.pembrock.finance/lend-pools. There, you’ll see a list of assets you’ve provided.

Step 2. Pick the asset you are no longer willing to lend and click on the down arrow button on the right in the box.

Step 3. Enter the amount you wish to de-lend and press Withdraw.

Alternatively, you can adjust the position by adding more tokens into lending.
About PembRock
PembRock was created by INC4—a professional blockchain development company of Ukrainian origin that’s been around since 2013.

The main idea behind PembRock was to bring trading with leverage—a tool widely available to players in the traditional financial markets—to a nascent yet trending DeFi sector.

In March 2022, PembRock Finance was awarded a US$75,000 grant from NEAR Foundation aimed to assist the protocol’s development, further improvement, and adoption.
$PEM Utility
PEM is PembRock’s protocol-native digital token. It has four primary use cases:

 	PEM holders who stake their tokens share in all of the income the protocol makes.
 	They also guide the project’s decision-making process through participation in DAO.
 	The token is central to the mechanism that distributes rewards for interacting with the protocol.
 	$PEM is also used to provide an additional bonus to those who supply liquidity to our pools.

For places to buy it, look here.

 	Name: PembRock Finance Token
 	Ticker: PEM
 	Total supply: 160M units
 	Network: NEAR Protocol
 	Contract address: token.pembrock.near





	

	
	
		
			
				Which utility does $PEM token NOT have?
			
		

		
					

		
			
			
			
			Profit sharing
		
			
			Voting
		
			
			Incentivization
		
			
			NFT distribution
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What’s Staking?
Within the PembRock protocol, staking means locking PEM in exchange for a right to get a portion of revenues earned by the protocol and to participate in the Decentralized Autonomous Organization, influencing decisions—including on how much farmers and lenders mentioned above should make. The bigger the amount staked and the longer the period, the higher the voting power and the rewards.

Say you stake 1,000 PEM for 4 years in exchange for 1,000 units of voting power (which is granted in the form of vePEM tokens), while someone else stakes 1,000 PEM for 2 years in exchange for 500 units of voting power (because even though they staked the same volume, they did it for a two times shorter period). Together, your voting power would be 1,500. So if a protocol generated 100 PEM in weekly rewards, you’d get 66.66 PEM (because your share in total amount staked would be 66.66%), and another participant just 33.33 PEM (theirs would be 33.33%).
How to Stake
To stake and by proxy join the DAO, you’ll need PembRock’s native digital token called PEM. If you don’t own any PEM yet, here’s how you can fix that.

Step 1. Go to app.pembrock.finance/staking;

Step 2. Type in the amount you wish to stake and the duration (the estimated voting power can be seen below the End Date).

Step 3. Press Confirm.
How to Make Adjustments
The voting power is decreasing gradually, but you can adjust your position (stake more and/or for longer) to keep your influence at the same level or even make it more substantial.

Step 1. Scroll down to the bottom of app.pembrock.finance/staking;

Step 2. Type in the amount you’d like to stake on top of what you’ve already staked and press Confirm;

Step 3. After that, you can prolong the lockup period.

Claiming & Withdrawing
To withdraw PEM once the lock period is up or request the payout of your rewards in PEM, visit app.pembrock.finance/staking. Once available, the buttons will turn orange.




	

	
	
		
			
				Which of the following statements is true?
			
		

		
					

		
			
			
			
			The amount staked is the only factor that determines the voting power
		
			
			The period of staking is the only factor that determines the voting power
		
			
			Both the amount and period determine the voting power
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How to Take Part in DAO
In DAO, you can set the amount of rewards that go out to both lenders and farmers every month.

Step 1. Go to the app.pembrock.finance/voting. There, you’ll see two tabs—Lenders’ and Borrowers’ Rewards.

Lenders’ Rewards are earned by participants that deposit into lending pools. Borrowers’ Rewards are earned by participants that borrow assets from lending pools.

The steps below are the same for both.

Step 2. Distribute your voting power to pools using the Vote field. The higher % you give, the bigger the return it will generate.

Remember that all % should add up to 100.

Step 3. Press Vote and confirm the transaction in NEAR Wallet.

If you change your mind, you can re-vote while the window is still open. When doing so, please make sure to specify % for all assets again.
Conclusion
PembRock is just gaining momentum as the DeFi market in general and leveraged yield farming space in particular are still in their infancy. Just like Ref Finance was a pioneer in the NEAR’s DeFi space, PembRock became the network’s first and only leveraged yield farming protocol. So if you want to be among the trend-setting crowd, why not try it out (beware of the risks, though)?

If you want to stay current on everything PembRock, below are some links for you:

PembRock Website | Twitter | Telegram | Discord

### How to use NEAR on your phone

One way to use NEAR on your cell phone is the HERE Wallet. This is a non-custodial wallet, which means private keys are only stored on your phone

HERE Wallet focuses on the easiest way to use NEAR. You can use many apps directly from the wallet. There's also liquid stacking built into the app with a 0% instant withdrawal fee. When you make any transfer the money will be instantly unstaked by the background.

In this article we have covered how to use the basic features of the HERE app, if you have any questions you can always ask the HERE team in the chat room
Log in with seed phrase
If you have a near account, we can log in using your seed phrase:

 	Click "import existing account"
 	Click "use seed phrase"
 	Enter seed phrase and click “find my account”


If you have account at wallet.near.org

 	Click "import existing account"
 	Click "use seed phrase"
 	Enter seed phrase and click “find my account”
 	Click "import existing account"
 	Click "share the link"
 	Send the link to your desktop
 	Open the link, select account and click “Next”
 	Click “Connect”
 	Enter account ID and click “Confirm”
 	You will be authorized on mobile device


Setup username (free)
NEAR is available with usernames instead of addresses. Usually, need to have NEAR to create a username, but we allocate them for free in the HERE app. Just enter the username and click Continue
IMPORTANT NOTES

Once you select a username, you cannot change it. The only available is to create a new account and transfer money

We do not recommend using your last name in the username, it can deanonymize you


Start earning
HERE wallet has built-in liquid stacking, you can withdraw money at any time without any fees

 	Click on the big round pink button “Earn”
 	Click “Start stacking”
 	Enter the amount
 	Click “Stake”
 	All set! Now you will receive a daily income at the rate of 8-10% p.a. on your balance


Claiming dividends

 	Click “Claim”
 	Wait till it is loaded
 	Done! Your dividends have been transferred to your balance


Deposit NEAR with other assets

 	Click “Add money”
 	Click “Buy NEAR with other crypto”
 	Select asset
 	Deposit BTC to the shown address
 	Click Done after deposit
 	You can track deposit status in Transaction history


How to use dApps

 	Select HERE Wallet from the list of applications on the website
 	Scan the QR code with your phone’s native camera
 	You will be redirected to the app. Click "Confirm"



 

### NEAR Social Beta Test

Follow @NearSocial_ and  @LearnNEAR on Twitter

Beta test sprint starts: November 2, 9 am ET
Beta Test sprint ends: November 4, 11pm ET.
Requirements:
First of all read the Guide "What is Near Social?"

 	Get yourself our Telegram bot LNC NEAR watcher to get notified on transactions
 	Login to NEAR Social at https://near.social/
 	Explore all widgets: AllWidgets
 	Edit your Profile https://near.social/#/mob.near/widget/ProfileEditor. Please make it as beautiful and funny as possible! HINT: use your (L)Earner NFT as PFP and cover image

 	Add tag that describe you best

 	Take a screenshot
 	Tweet with your screenshot “I’ve just created my profile at @NearSocial_ during  @LearnNEAR  Beta test, Suggest you do the same!” and tag 3 of your friends
 	Have some fun exploring Memes https://near.social/#/mob.near/widget/Memes . Feel free to create your own!

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead at NEAR Social Telegram

### What is Near Social?

Near Social (previously known as Social08) is a social data protocol built on top of NEAR Protocol.

Please join Telegram group @NearSocial for discussions.

Watch presentation Near Social at NEARCON22

Explore Near Social: near.social
Links
Github: https://github.com/NearSocial

Twitter: @NearSocial_

Telegram: @NearSocial

SocialDB Contract:

 	Source: https://github.com/NearSocial/social-db
 	Mainnet: social.near
 	Testnet: v1.social08.testnet

Standards: https://github.com/NearSocial/standards

Near Social Browser:

 	Source: https://github.com/NearSocial/viewer
 	Mainnet: https://near.social/
 	Testnet: https://test.near.social/

If you are looking for a mastodon based social network for .near users, see an article about mastodon.near.social
SocialDB
SocialDB is a smart contract to store social data on NEAR protocol.

 	Source code: https://github.com/NearSocial/social-db
 	API: https://github.com/NearSocial/social-db#api
 	Testnet account ID: v1.social08.testnet
 	Mainnet account ID: social.near

Get API
Takes a list of keys and returns a joined JSON object with the matched data.


 	keys - an array of key patterns to return.

Reading a profile of account self.social.near
To read all fields recursively for a given path add ** suffix.



Returns the aggregated JSON object.


Reading names of all account with profiles
Note that this query iterates over all accounts and will not fit into the available view call gas in the future.




Keys API
Takes a list of keys and returns a joined JSON object with the keys matched the query.



 	keys - an array of key patterns to return.

Returns the aggregated JSON object.
Getting a list of widgets of accounts root.near



Getting a list of accounts that have widgets


Note that this query iterates over all accounts and will not fit into the available view call gas in the future.


Standards
The data in SocialDB is organized as a simple JSON tree. The only enforced rule is that the keys in the root are the account IDs that store the data. This is done on purpose, so the SocialDB contract is not enforcing any structure or a schema. Otherwise, the contract has to be modified for every schema change. The control of the contract schemas can lead to the centralization and restrictions. Instead, Near Social Standards live outside the SocialDB contract.

Currently, Standards on Github is the default place for the standards, but this may change in the future.
Schema description

 	bold means the key is required.
 	italic means the key is optional.
 	[account_id] means the dynamic key is an account ID. For example, alex.near as a key. It usually used to create some edge towards that account.

Root schema
Each account should follow the Root schema
Widgets
Widgets are reusable composable components for Near Social.

You can view and create widgets at near.social.

For example, a data explorer widget allows you to explore raw data from SocialDB.


Open source with version control
The source code of every widget is openly stored in SocialDB. The owner of the widget has ability to upgrade the widget, by updating the source code. But because SocialDB is stored on a blockchain, all the previous versions of the widget are also available. This enables automatic version control for every widget.
Forking
If you are familiar with GitHub, you know that you can fork any public repository to create your local version. Similarly, you can fork any widget straight from the near.social UI.



Forking creates a copy of the widget source code, but under your account. It allows everyone to modify the existing widgets. Once you save the new widget, it becomes immediately available. And everyone can now view and fork your version of the widget.

It's mostly the question of a UI to create a pull requests, so people can merge changes from other forks. Currently, it has to be done manually.
Programming language
The widgets are implemented in a limited version of JSX (a JavaScript with ReactJS). The code is executed in custom Virtual Machine to create a secure sandbox. This ensures the widgets can't access local storage or cookies.

### What is Calimero? Introducing private sharding on NEAR

Calimero network’s private shards explained - Blockchain solution that enables scaling and privacy
The beauty of the blockchain technology is that all participants in blockchain networks trust the information on it, because the data on that blockchain is immutable, visible and accessible to everyone in real time. But web3 is currently far from perfect, as two major challenges exist: privacy of data and potential for businesses to scale using blockchain technology.
Challenges in using blockchain for businesses

If all the data is publicly available and transparent, questions of privacy appear.

 	What happens when the information is classified as personal information?
 	Is there a need for data protection or compliance obligations? Under which jurisdiction?
 	What happens when the information is a business secret?

Preserving the privacy of personal and business data is a necessity, not a luxury. On the blockchain, it can be done through combining on-chain and off-chain data and interoperability. All of which is possible with Calimero private shards.
Let’s not jump into Calimero's explanation just yet. There is one more important question that needs to be addressed: scaling. Scalability is the ability of a blockchain network to support an increasing amount of transactions, by increasing the number of nodes/validators.
As the interest for using cryptocurrency and blockchain technology grew, many users and companies started issuing tokens, building Dapps and creating NFTs more and more each day. As a result, networks started getting congested, which as a result brought increasing gas costs for new and existing users, discouraging them from building more amazing products. This is where new scaling solutions came into being. A good example is NEAR, which uses sharding for scaling and supporting the increasing blockchain usage. But even with sharding, for some businesses that have a lot of network transactions on a daily basis, the costs can pile up.
This is where Calimero comes in - as you can spin off your own shard within which the transactions are free and private. You’re only required to pay a fixed amount per month based on the number of validators you’re running.
What is Calimero network
Calimero is a customizable sidechain built on top of NEAR protocol. It can be viewed as a network of networks. A solution for businesses to access privacy features and enable scaling. Calimero provides you with an infrastructure which shares all the best benefits of NEAR while being enhanced with multiple new features with emphasis on privacy.
Calimero enables you to:

 	Spin off your own private shards (think of a shard as a small private blockchain network that you own)
 	Communicate between your shards and other networks, or between multiple shards (even if the shards are owned by different companies)

By using Calimero private shards, among other things, users can enhance applications by interoperating with open source protocols and applications, from DeFi to NFTs. Users can hold and manage public assets and move them between private shards and other public chains seamlessly.
Furthermore, users are benefiting from cross shard transactions, which provide the ability to interact with third parties on the public chain or other permissioned enterprise shards. Private shards can interact with each other over encrypted channels.
With Calimero, possibilities are endless.
Benefits of using private shards by Calimero network
Calimero’s private shards have all the benefits of NEAR in terms of high performance, security and sustainability. But as an important distinction, shards are not using NEAR’s validators, execution and state storage, but rather you’re using your own. The main benefits include:

 	Scaling your business by having access to free transactions within the shard.
 	Making part (or all) of your transactions private, with only people/entities with the access to the shard being able to view the data.
 	EVM compatibility - You can use DApps already built on Ethereum mainnet instead of building them from scratch.
 	WASM compatibility & Javascript support for easy onboarding to web3
 	Interoperability - Shards can communicate with the NEAR mainnet, and between themselves (each shard can represent a different company or parts of the same company ), and thanks to the bridge, multiple different assets such as fungible and non-fungible tokens can be transferred.
 	Customizable, performant and cost efficient. It’s possible to perform up to 200.000 transactions per second (standard shard deployment has the throughput of 5.000 transactions per second). Block times, contract sizes and gas limits are customizable. Bridging the assets or calling data is fast (5-10sec) and cheap (it costs a couple of cents).




	

	
	
		
			
				Calimero enables you to:
			
		

		
					

		
			
			
			
			Spin off your own private shards (think of a shard as a small private blockchain network that you own)
		
			
			Communicate between your shards and other networks, or between multiple shards (even if the shards are owned by different companies)
		
			
			Interoperate with applications from DeFi to NFTs, and more
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Who are Calimero’s private shards for?
Calimero can be used:

 	As a gateway for traditional (web2) businesses to get into the web3 world with an easy to use dashboard for managing their private shard.
 	For businesses already operating in web3 who need zero gas scaling and privacy features.




	

	
	
		
			
				Does Calimero use NEAR's validators?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Which industries can Calimero be used in?
There are countless use cases, as only the imagination is the limit. To provide some inspiration, we’ve listed a couple different industries where private shards achieve their full potential.

 

 	
Governments
Think of banks implementing CBDC, or KYC & anti-money laundering use cases. The private data is stored on a shard, and can be available when needed, but is otherwise hidden from the public.
 	
Fintech
Digital assets and tokenization of financial assets, AML, KYC and digital identity, credit scoring, capital markets, trade finance, privacy solutions (for custody and treasury management)…
 	
Infrastructure
For companies into energy, healthcare, insurance, real estate, telecommunications, supply chain…
For example in the supply chain/transportation industry, you can use Calimero to verify data, keep track of the shipment across multiple companies (each with its own shard) and even buy/sell the goods while they’re still in transport.
 	
Web3
DAOs, DeFi, CeFi - think of all the operations within them, including orderbook, darkpools, treasury management and contributors payroll, Also in gaming, metaverse, entertainment, publishing (art, music, NFTs)…
Example of using private shards in gaming: you start a chess game on the mainnet. You bridge the whole game to a private shard. On it, the game plays out for FREE and the moves are hidden (unless you want to reveal them). You bridge the outcome back to the mainnet. And voila!

The possibilities are #NEAR endless! Contact our team if you want to learn more and try running your own private shard to access the countless sharding benefits. You can use Calimero for free while we’re in test mode. Our team can give you access to a private shard for your project. Follow us on Twitter to stay tuned for all the news surrounding private shards! If you want to learn more, you can listen to the lectures Calimero team members had at Nearcon in Lisbon (September, 2022).




	

	
	
		
			
				Who can make us of Calimero's private sharding?
			
		

		
					

		
			
			
			
			Web3 organizations
		
			
			Supply chain/transportation industry
		
			
			Banks
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






https://www.youtube.com/watch?t=4814&v=VrK46yUEh9s&feature=youtu.be

### Update - October 24, 2022

Brief Summary:

 	
Learn NEAR Club invites NEAR project to (L)Earn!


Results:

 	
Building on #NEAR?
Come to LNC to onboard thousands hungry (L)Earners your project!


 	💸 Over  Ⓝ600 were claimed by (L)Earners participated in October Redeem to NEAR window
 	LNC super NFT  edition #1/1 "10(L)Earners Squared" with first 100 (L)Earners was SOLD for whopping 256 #NEAR

 	 "NEAR wallet transition" A Guide by our (L)Earning Partner @MyNearWallet

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	✅ CalenD is coming to (L)Earner NFT holders!

### Apa itu NFT (L)Earner?

Sebuah Koleksi NFT baru yang tak kalah menarik dan baru kini telah dirilis di Ekosistem NEAR. Sebelum kita mempelajari apa itu koleksi (L)Earner NFT, berikut adalah ringkasan singkat tentang apa itu NFT. Jangan sungkan untuk langsung melewatinya saja jika kamu sudah familiar dengan NFT.
Apa itu NFT?
NFT adalah singkatan dari Non-Fungible Token. NFT adalah aset digital unik yang informasi pengenalnya direkam pada smart contract. Informasi pada smart contract inilah yang membuat NFT unik. NFT adalah aset yang bersifat non-fungible. Aset non-fungible bersifat tidak dapat dibagi. Sebagai contoh, kamu tidak dapat mengirim seseorang bagian atau pecahan dari sebuah lukisan atau tiket.

NFT adalah sertifikat kepemilikan digital untuk aset digital. NFT adalah smart contract yang digunakan untuk mengamankan aset digital. Setelah ditulis, NFT tersebut akan diterbitkan menjadi token (ERC-721 atau NEP-171) di blockchain. Apa pun dapat diubah menjadi NFT, dan yang paling populer adalah dalam bentuk video, GIF, atau JPEG.
Apa itu Koleksi NFT (L)Earner?
Koleksi (L)Earner NFT adalah kolaborasi antara komunitas Learn Near Club (LNC) dan Denis Bashev, salah satu desainer grafis pemenang penghargaan terbaik di Eropa.
Konsep Desain
Konsep desain didasarkan pada keragaman kecerdasan manusia yang dinamis yang didukung oleh keunikan setiap peserta belajar. Setiap manusia adalah individu yang unik yang memiliki pola belajar yang beragam, kekuatan dan kelemahan. Koleksi NFT (L)Earner bertujuan untuk menyoroti individualitas dari setiap pelajar dan bagaimana roda penggerak yang berbeda saling berinteraksi dalam mesin untuk menciptakan manusia yang holistik, masing-masing dengan impian, ketakutan, pengalaman, dan kepribadian unik mereka sendiri.



Bagi mereka yang tidak terbiasa dengan bagaimana kita belajar pada tingkat ilmiah, inilah intinya:
Ketika Anda secara aktif terlibat dalam mempelajari sesuatu, neuron (sel otak) mulai membentuk hubungan antara satu sama lain. Pada awalnya koneksi ini sangat lemah, dan pengetahuan tidak sepenuhnya terikat pada memori jangka panjang. Seiring berjalannya waktu dan anda menghabiskan lebih banyak waktu untuk mempelajari suatu konsep, koneksi ini menjadi lebih kuat dan berkomitmen pada memori jangka panjang. Pengetahuan anda sebenarnya tersimpan dalam miliaran koneksi saraf antar neuron di otak manusia. Proses ini disebut pembelajaran Hebbian



Ide mengenai figur tongkat/ stick people didasarkan pada sistem saraf manusia. Segmen yang terdiri dari “stick people” terinspirasi oleh selubung mielin yang membantu impuls listrik ditransmisikan melalui neuron.

 

Pose karakter mewujudkan kombinasi tak terhitung dari koneksi saraf yang menyatu dalam mikrosom mereka sendiri untuk membentuk ingatan jangka panjang yang berbeda dari suatu konsep atau aktivitas. Segmen garis diplot pada bidang kartesius untuk menciptakan pose yang menyenangkan.

 

Palet warna dipilih dengan cermat oleh Denis untuk memberikan penghidupan, dan menambahkan nada yang lebih menyenangkan pada manusia tongkat ini. Ini melambangkan kegembiraan dalam belajar. Kegembiraan belajar bukanlah sesuatu yang hanya bisa dirasakan dengan kepuasan instan. Ini adalah puncak dari semua cara bahwa kehausan akan keterampilan dan pengetahuan baru telah meningkatkan kehidupan kita dan kehidupan orang-orang di sekitar kita.


Minting
Semua minters NFT diundang untuk berpartisipasi dalam proyek teranyar ini. Biaya mint mulai dari 2 $NEAR dan secara bertahap meningkat seiring bertambahnya koleksi hingga mencapai batas 10.000 NFT. Para minters bisa melakukan:

 	Membuat- perangkat lunak menghasilkan postur acak, dan mencampur warna sebanyak yang kita suka, sehingga kita mendapatkan (L)Earner NFT yang kita inginkan. Sebagian besar NFT di pasar "dibuat" dari model yang dibuat sebelumnya, sedangkan (L)Earner NFT memiliki jumlah kombinasi yang hampir tidak terbatas yang menciptakan NFT yang benar-benar unik untuk kita.
 	Nama- beri nama untuk (L)Earner NFT milikmu, buat seunik karakter milikmu dan keinginanmu
 	Mint- minting NFT anda dan amankan di blockchain NEAR.
 	Kurasi- kumpulkan sebanyak yang anda inginkan dan kurasi koleksi pribadi asli milik anda
 	Perdagangkan- beli dan jual (L)Earn NFT di Paras NEAR NFT Marketplace

Manfaat NFT (L)Earner LNC
Kamu tidak hanya mendapatkan NFT keren saat minting (L)Earner NFT, kamu juga mendapatkan fasilitas praktis sebagai anggota komunitas LNC resmi seperti:

 	Prioritas akses awal 2 jam ke laman Redeem to NEAR
 	Bukti Mint (L)Earn NFT
 	Lebih banyak lagi yang akan datang nantinya

Bergabunglah dengan grup telegram LNC untuk membagikan (L)Earner NFT anda dengan anggota komunitas lainnya.
Kesimpulan
Koleksi (L)Earner NFT adalah kolaborasi mutakhir antara LNC dan Denish Bashev (desainer grafis pemenang penghargaan). Tujuan dari proyek ini adalah untuk merangkum pengalaman belajar individu dari setiap pelajar ke dalam NFT. Koleksinya terbatas hingga 10.000 NFT. Jadi, dapatkan NFT milikmu selagi bisa!

### NEAR Wallet

Sebuah Panduan Terkait NEAR Wallet
Saat ini di pasar kripto, Ethereum adalah platform pilihan untuk aplikasi terdesentralisasi, kontrak pintar (smart contract), dan keuangan terdesentralisasi (DeFi). Namun, Ethereum memiliki beberapa masalah yang menjadi menghambat, seperti biaya gas (gas fee) yang tinggi dan masalah yang cukup signifikan terkait isu skalabilitas. Jadi untuk saat ini mungkin Ethereum menjadi yang nomor satu, namun beberapa protokol lain hadir sebagai penantang Ethereum di jajaran kripto.

Protokol NEAR merupakan salah satu blockchain yang muncul sebagai penantang yang patut diperhitungkan untuk melawan dominasi Ethereum saat ini. Tim dari NEAR melihat kekurangan Ethereum dan membuat protokol yang langsung dapat mengatasi kekurangannya yang paling mencolok, yakni kurangnya skalabilitas dan biaya gas yang tinggi. NEAR menggunakan proses yang disebut sharding, dimana ini memungkinkan protokol untuk menskalakan secara eksponensial. NEAR juga telah berhasil mengumpulkan pendanaan yang signifikan dari beberapa Venture Capital terbesar, termasuk a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital, dan beberapa lainnya. Pada panduan ini, kita akan melihat lebih jauh khususnya NEAR wallet.
NEAR Protocol
Didirikan pada tahun 2018, NEAR Protocol merupakan platform pengembangan terdesentralisasi yang dirancang untuk menciptakan lingkungan yang mendukung dan nyaris sempurna untuk aplikasi terdesentralisasi (dApps) dan smart contract. NEAR dibuat setelah menganalisis kekurangan protokol yang sudah ada, khususnya Ethereum. Protokol ini berfokus untuk mengatasi masalah tersebut dan ingin menjadi platform yang siap pakai (go-to platform) untuk Aplikasi Terdesentralisasi (dApps) dan Keuangan Terdesentralisasi (DeFi). Penggunaan sharding NEAR memungkinkan protokol untuk ditingkatkan secara eksponensial serta mengatasi masalah skalabilitas yang lazim di dunia kripto.

Blockchain Proof-of-Stake NEAR sangat ramah untuk para developer karena biayanya yang rendah dan sangat skalabel, selain itu developer dapat dengan lancar membuat dApps. Protokol NEAR juga memiliki beberapa fitur lain, seperti dompet NEAR (NEAR Wallet) dan komponen lainnya. Fokus kita pada artikel ini akan lebih kepada ulasan terhadap NEAR wallet dimana itu akan lebih dibahas lebih jauh  nantinya. NEAR juga menggunakan Doomslug, memungkinkan blok untuk mencapai finalitas dalam hitungan detik. Blockchain lain biasanya memusatkan pemrosesan, membatasi kegunaannya untuk perangkat keras yang sangat canggih. Sementara dengan pendekatan ini meningkatkan throughput dibandingkan yang tadi hanya bersifat sementara. NEAR mampu menskalakan secara linier, mendukung miliaran transaksi secara terdesentralisasi.

NEAR telah dibuat oleh NEAR Collective, sebuah komunitas yang terdiri dari peneliti dan developer. Fokus NEAR Collective adalah pengembangan berkelanjutan dan peningkatan protokol. NEAR Collective juga telah mengerjakan kode awal dari Protokol NEAR dan implementasi Jaringan NEAR. Sementara NEAR Collective memang berada di balik pengembangan Protokol NEAR, pada akhirnya ini semua akan beroperasi sepenuhnya secara independen dan terdesentralisasi, bahkan NEAR Collective sendiri tidak akan dapat menghentikannya.
Keuntungan dari NEAR Protocol

 	Pengguna NEAR tidak memerlukan ekstensi dari browser yang menyulitkan atau kunci untuk mendaftar. Bermodalkan email dan kata sandi sederhana, pengguna sudah bisa untuk mendaftar.
 	Smart Contract NEAR telah kompatibel dengan WebAssembly Virtual Machine (WASM).
 	Protokol ini memungkinkan pengembang untuk menyebarkan aplikasi blockchain yang skalabel dan berkinerja tinggi.
 	Biaya gas yang lebih sedikit jika dibandingkan dengan yang lain seperti Ethereum.

Apa itu Dompet Crypto?
Sebelum beralih ke NEAR Wallet, penting untuk memahami apa itu sebuah wallet. Dalam istilah yang paling sederhana, wallet crypto dapat dengan aman menyimpan kunci pribadi anda, memastikan bahwa cryptocurrency anda aman dan dapat diakses. Kamu juga dapat menggunakan wallet kripto untuk melakukan transaksi, mengirim dan menerima kripto, atau bahkan membelanjakan kripto milik anda. Saat memilih wallet kripto, Anda memiliki beberapa opsi untuk dipilih. Ini adalah paper wallet, hardware wallet, dan online wallet.
Hot Wallet
Hot Wallet adalah dompet berbasis online yang memungkinkan pengguna mentransfer kripto mereka dengan cepat. Sebagian besar bursa online memiliki dompet sendiri yang dapat diakses pengguna. Hot Wallet  mudah diakses melalui ponsel atau desktop. Sementara Hot Wallet menawarkan konektivitas yang mudah, namun ini juga berisiko dari ancaman seperti peretasan. Desktop wallet, online wallet, dan mobile wallet adalah contoh dari hot wallet.
Cold Wallet 
Cold Wallet atau dompet perangkat keras (hardware wallet) adalah perangkat yang mirip dengan perangkat USB sebagai tempat pengguna untuk dapat menyimpan kunci mereka. Dompet ini portabel dan dapat dihubungkan ke laptop/desktop kapan pun pengguna ingin mengakses kripto mereka. Dompet perangkat keras jauh lebih aman terhadap ancaman seperti peretasan atau serangan berbahaya lainnya yang dapat terjadi secara online.
Paper Wallet
Paper Wallet pada dasarnya adalah selembar kertas yang dicetak dimana berisi kunci publik dan kunci pribadi Anda. Kunci hanya dapat diakses melalui kode QR. Paper Wallet digunakan untuk menyimpan sejumlah besar cryptocurrency karena dianggap sangat aman.
NEAR Wallet
Pengembang di Protokol NEAR telah mengembangkan aplikasi dompet yang nyaman untuk menyimpan token NEAR. Wallet merupakan dompet dalam browser yang berbasis web sehingga memungkinkan pengguna untuk bisa menggunakan wallet NEAR agar berinteraksi dengan akun NEAR lainnya. Wallet juga dibutuhkan agar bisa berinteraksi dengan Protokol NEAR. Wallet digunakan untuk menyimpan token NEAR dan standar token NEP21, yang didukung pada jaringan blockchain NEAR. Wallet memungkinkan pengguna untuk mengirim atau menerima token NEP21 maupun token NEAR, berinteraksi dengan aplikasi yang ada pada protokol. Saat menggunakan wallet NEAR, penting untuk memahami informasi berikut.

Perbedaan utama dari akun NEAR adalah: NEAR menggunakan akun yang dapat dibaca oleh manusia, dan bukan dalam bentuk hash. Hal ini membuat akun di NEAR tidak akan terbaca sebagai 0x71C7656EC7ab88b098defB751B7401B5f6d8976F tetapi sebagai alice.near atau bob.near. Akun NEAR juga dapat dibuatkan beberapa sub-akun, tetapi hanya akun root yang dapat melakukannya. Hal pembeda penting lainnya adalah bahwa sebagian besar blockchain memiliki satu pasangan kunci publik/pribadi untuk di setiap akun. Di NEAR, akun dapat memiliki beberapa pasangan kunci yang terkait dengannya. Ini disebut "kunci akses." Kunci akses terdiri dari dua jenis, kunci akses penuh (full access key), dan panggilan fungsional (functional call). Kunci akses penuh memberi pengguna kontrol penuh atas akun NEAR mereka. Di sisi lain, panggilan Fungsional memungkinkan penandatanganan transaksi non-moneter.

Alamat Wallet – Alamat wallet pada dasarnya adalah urutan karakter atau angka atau kombinasi keduanya yang digunakan untuk mengirim atau menerima token menggunakan wallet NEAR.Private Key Dan Passphrase – Frasa sandi (Passphrase) dan kunci keamanan adalah jenis dari kata sandi. Passphrase terdiri dari 12 kata, sedangkan private key terdiri dari urutan huruf dan angka. Keduanya hal tersebut merupakan sesuatu yang sangat penting untuk memulihkan wallet anda
Membuat NEAR Wallet
Near wallet memungkinkan pengguna untuk mengirim ataupun menerima token NEAR dan melakukan staking terhadap token NEAR miliknya. Bagaimanapun juga, kita diharuskan untuk membuat wallet di NEAR agar bisa mengakses fitur-fitur tersebut. Jadi, ayo kita mulai!

 	Langkah pertama adalah mengunjungi situs https://wallet.near.org/. Setelah kamu mengunjungi situs tersebut, kamu akan dihadapkan pada dua pilihan yakni membuat akun atau mengekspor akun yang sudah ada sebelumnya. Untuk kasus ini kita akan menggunakan opsi pertama.



 	Ketika kamu sudah mengklik tombol “create an ID”, kalian diharuskan membuat sebuah nama akun. Buat dan pilih nama akun, jika pilihan nama tersebut tersedia, klik pada “Reserve My Account ID.”



 	Tahapan selanjutnya adalah memilih bagaimana cara kita akan memulihkan akses dari akun tersebut jika terjadi sesuatu hal. Disana akan ada tiga metode pemulihan akun yang dapat dipilih. Kamu dapat menggunakan seed phrase, terhubung ke dompet hardware ledger ataupun email. Protokol merekomendasikan untuk memilih opsi yakni seed phrase maupun terhubung ke ledger hardware wallet dimana kedua opsi ini jauh lebih aman ketimbang mengamankan akun menggunakan email. Kita akan memilih opsi “Secure Passphrase” pada contoh kali ini dan melanjutkan ke tahap selanjutnya.



 

 

 	Sangat disarankan agar kamu menggunakan Ledger Nano S atau X. Dengan menggunakan ledger, dapat dipastikan bahwa kunci pribadi kamu akan disimpan dengan aman di ledger milikmu. Ledger memberikan tingkat keamanan tertinggi saat menggunakan NEAR wallet. Menyetel ledger sangatlah mudah, yang harus kamu lakukan adalah mengunduh Ledger Live, dan memperbarui firmware. Untuk menginstal aplikasi NEAR Ledger, buka aplikasi Ledger Live, buka Pengaturan dan klik pada Fitur Eksperimental. Dari sini kamu akan dapat mengaktifkan Developer Mode. Setelah langkah ini selesai, pilih Manager, Cari NEAR dan klik Instal.
 	Setelah kamu mengklik “Secure Passphrase”, sebuah seed phrase akan muncul di layar, berisi 12 kata mnemonic. Anda harus menyimpan kata-kata ini dengan aman, dan cara terbaik untuk melakukannya adalah dengan menuliskannya di buku atau selembar kertas dan menyimpannya di tempat yang aman. Harap JANGAN mengambil screenshot atau menyimpan frasa atau menyimpannya di media online mana pun. Seedphrase milikmu adalah untuk diketahui oleh dirimu sendiri.



 	Konfirmasi dan verifikasi jika kamu sudah memasukkan seed phrase secara benar dan menyelesaikan proses penyetingan.
 	Ketika kamu sudah menyelesaikan verifikasi seed phrase, kamu akan dialihkan ke tampilan “Fund Your Account”. Proses ini dibutuhkan untuk mendapatkan ID yang telah kamu pilih di tahap awal sebelumnya. Ada beberapa cara untuk bisa mendanai atau mengisi saldo untuk akunmu. Kamu bisa melakukannya entah melalui akun exchange dan mengirimkan NEAR ke alamat yang sudah ditentukan. Kamu juga bisa melakukan deposit dengan menggunakan Moonpay atau meminta bantuan teman yang memiliki token NEAR dan mengirimkan sekitar 1 NEAR ke alamat sementara tersebut. Ketika transaksi telah berhasil, deposit awalmu akan tercantum pada wallet tadi.



 	Sekarang akunmu terlah berhasil terisikan dana, klik pada “Continue to Account” dan kamu akan dialihkan ke laman antarmuka utama dari wallet.

Ketika akunmu telah berhasil dibuat, sangat direkomendasikan untuk mengaktifkan 2FA. Step ini sangatlah krusial dan secara signifikan menambah tingkat keamanan dari akun NEAR walletmu.
Membuat Akun Menggunakan Ledger
Mari kita pahami lebih lanjut bagaimana cara untuk membuat akun menggunakan perangkat Ledger.

 	Buka wallet.testnet.near.org dan pilih “Buat Akun.”
 	Gunakan langkah yang sama yang dijelaskan dalam metode sebelumnya dan pilih ID akun. Setelah kamu memasukkan ID yang kamu inginkan, klik "Buat Akun".
 	Selanjutnya, kamu harus memilih metode keamanan yang ingin dipilih. Di sinilah pembuatan akun berbeda karena kamu akan menggunakan perangkat Ledger yang telah miliki. Jadi, alih-alih "Recovery Phrase", pilih "Ledger Nano S atau X."



 	Setelah memilih opsi Ledger, pilih “Continue” dan kamu akan diarahkan untuk terhubung ke perangkat ledger



 	Ketika kamu telah terhubung ke perangkat Ledger, lepaskan kunci (unlock). Jika kamu sudah memiliki aplikasi NEAR yang terinstal, pilih aplikasi tersebut. Perangkat Ledger milikmu akan menampilkan “Pending Ledger Review”. Klik setiap tombol yang ada di bagian atas perangkat dan perangkat akan memunculkan tulisan “Use Wallet to View Account”. Ketika pesan tersebut muncul, kamu dapat melanjutkan dan mengklik tombol “Continue”
 	Setelah kamu memilih untuk melanjutkan, public key akan muncul pada layar Ledger. Terima public key dan konfirmasi operasi pada Ledger
 	Selanjutnya, kamu akan diarahkan untuk menambahkan kunci pada wallet Ledger. Ketika kamu mengklik “Approve” pada ledger. Pada saat proses sudah diterima, akun milikmu telah berhasil dibuat.


Staking Menggunakan NEAR Wallet 
Jaringan NEAR dijalankan oleh beberapa pengguna yang mengoperasikan nodes yang disebut sebagai para validator. Komunitas NEAR mendukung validator melalui mekanisme staking. Para validator akan menyimpan jumlah minimum untuk distaking dan memungkinkan mereka untuk tetap menjadi validator. Para pemegang token NEAR dapat mendelegasikan token mereka (staking) dengan setiap validator yang bebas untuk mereka pilih yang memungkinkan mereka untuk mendapatkan reward dari jaringan. NEAR wallet memiliki tampilan antarmuka pengguna untuk staking dimana itu dibangun secara langsung pada aplikasi websitenya.

Mari kita memahami bagaimana melakukan staking dengan menggunakan NEAR wallet. Staking menggunakan NEAR wallet merupakan proses yang dapat dilakukan secara langsung dengan melalui tahapan sebagai berikut:

 	Pilih opsi untuk melakukan staking pada kolom tab navigasi. Jika kamu menggunakan perangkat mobile, selanjutnya kamu dapat menemukan opsi di dragdown menu. 
 	Pilih tombol yang menunjukkan “Staking validator”
 	Pilih validator yang kamu pilih dari daftar para validator. Perlu diingat bahwa sebagai pemegang token NEAR, kamu dapat mendelegasikannya kepada setiap validator yang kamu pilih.
 	Ketika kamu sudah mengkonfirmasi validator yang akan dipilih, kamu dapat memilih “Stake with Validator”
 	Setelah kamu memilih “Stake with validator”, kamu akan dihadapkan untuk memilih jumlah token NEAR yang akan kamu stake. Setelah menentukan jumlah token, klik “Submit Stake”

Unstaking Stake Anda
Untuk melakukan unstaking stake anda sangatlah sederhana. Cukup dengan membuka dasbor staking dan pilih validator pilihan yang sudah anda pilih sebelumnya. Setelah dipilih, klik “Unstake” dan konfirmasi. Anda akan dapat mengakses dan menarik stake dengan menunggu selama 36-48 jam. Untuk menarik jumlah stake milik anda, cukup buka halaman validator dan klik “Tarik.”
Monitoring Informasi Staking
Laman antarmuka dari NEAR wallet memungkinkan kita untuk memilih validator dan juga untuk melihat informasi seperti berikut:

 	Jumlah total stake – Ini memungkinkan kita untuk melihat jumlah total token NEAR dengan validator yang sedang mengakumulasi reward.
 	Reward yang belum diklaim – Ini merupakan reward yang telah diperoleh tetapi belum ditarik dari staking pool. Reward yang belum diklaim ini secara otomatis distaking lagi guna meningkatkan jumlah total yang distaking dan compounding reward.
 	Token untuk penarikan – Ini adalah token yang tidak distaking dan siap untuk ditarik.
 	Token yang pending release – Token yang tidak distaking namun masih menunggu hingga periode 36-48 jam berakhir.
 	Biaya validator – Biaya validator dibayarkan kepada validator untuk distaking atas nama anda. Biaya validator dibebankan pada reward yang diperoleh dan bukan dari saldo token yang distake ke validator.

Menghubungkan NEAR Wallet ke dApp yang ada di NEAR
Untuk menghubungkan NEAR wallet milik kita ke aplikasi terdesentralisasi (dApps) di NEAR sangatlah sederhana. Kita bisa menuju ke Awesome NEAR dan memilih salah satu dari banyak dApps yang tersedia. Klik pada aplikasi yang diinginkan, dan kita akan melihat opsi untuk "Masuk Dengan NEAR wallet" pada laman antarmuka. Setelah kita mengklik, kita akan mendapatkan notifikasi yang muncul di layar yang menyatakan bahwa dApp meminta izin untuk mengakses akun kita. Klik "Izinkan", dan dApp akan secara otomatis terhubung ke dApp.
Wallet Lain yang Didukung Oleh NEAR

MyNearWallet adalah dompet web yang memungkinkan pengguna untuk menyimpan dan mempertaruhkan token NEAR dan aset yang kompatibel dengan aman. Ini adalah penerus resmi dari Dompet NEAR warisan. MyNearWallet juga menyediakan swap wNEAR dan USN, serta cara untuk membeli NEAR.
Trust Wallet
Trust Wallet adalah dompet non-kustodian dan terdesentralisasi yang memungkinkan pengguna untuk menyimpan aset cryptocurrency mereka. Aset disimpan dalam alamat digital yang hanya dapat diakses oleh pengguna yang menjadikannya sebagai cara yang aman dan efisien untuk menyimpan aset digital. Trust wallet berfokus pada kesederhanaan dan kemudahan pengguna. Dompet ini adalah dompet multi-currency, bersifat open-source, berbasis komunitas yang mampu menyimpan hampir semua jenis mata uang kripto. Ini memberi pengguna cara yang mudah untuk mengelola cryptocurrency mereka dan memungkinkan mereka untuk mengontrol private key mereka sepenuhnya.



Trust Wallet diakuisisi oleh Binance dan merupakan dompet resmi dari Binance exchange. Wallet ini memungkinkan para pengguna untuk mempertahankan kendali penuh atas aset dan kunci pribadi mereka yang tersimpan di perangkat masing-masing pengguna. Developer juga dapat membangun dApps, tanpa banyak hambatan seperti detail implementasi tingkat dasar. Trust Wallet ini juga mendukung staking di wallet, yang berarti pengguna dapat memperoleh reward pada token Proof-of-Stake atau Delegated Proof-of-Stake yang didukung. Trust Wallet memungkinkan pengguna untuk mendapatkan reward dan terus menambahkan lebih banyak lagi aset stablecoin dan cryptocurrency.
Cara Membuat Dompet Trust Wallet
Untuk membuat wallet anda menggunakan Trust Wallet cukuplah sederhana.

 	Kunjungi situs web Trust Wallet Resmi.
 	Unduh dan instal aplikasi, buka aplikasi dan pilih "Create a new Wallet."



 	Langkah selanjutnya adalah menyimpan seed phrase anda. Tuliskan seed phrase yang terdiri dari 12 kata, dan pastikan kamu menuliskan kata-kata dalam urutan yang tepat.
 	And that’s it!. Trust Wallet pribadi milik anda telah berhasil dibuat.

Penutup
Ekosistem NEAR memungkinkan pengguna untuk mengakses sejumlah NFT, aplikasi terdesentralisasi, dan solusi DeFi. NEAR mengatasi kekurangan blockchain seperti Ethereum, menawarkan solusi untuk masalah laten seperti kemacetan jaringan, biaya gas yang tinggi, dan pemrosesan yang lambat. NEAR wallet memungkinkan pengguna untuk membuat akun dan berinteraksi dengan akun NEAR lainnya. Selain itu  memungkinkan pengguna untuk menyimpan token NEAR milik mereka, dan mendelegasikan (staking) untuk mendapatkan reward. Kami berharap panduan ini memberikan kejelasan tentang fungsi NEAR wallet dan contoh penggunaannya.

### Aliran Data NEAR

Penjelasan via Video​
Pada video dibawah ini, kami akan mencoba memberikan gambaran singkat mengenai konsep utama bagaimana aliran data terjadi di blockchain NEAR Protocol. Untuk versi teks akan tersedia di bagian bawah video


Versi Teks​






Aliran data dari blockchain NEAR Protocol sekilas mungkin terlihat sedikit rumit. Tapi ini cukup mudah dipahami dan sebenarnya mengikuti aturan yang jelas. Pada artikel ini, kita akan melihat lebih jauh bagaimana aliran data terjadi di blockchain NEAR Protocol.

Faktanya, setiap aliran blockchain dapat direpresentasikan sebagai garis waktu tak terhingga yang memiliki awal namun tidak memiliki akhir.





Kemudian sebuah blok muncul di antara rentang waktu tersebut dengan beberapa interval. Masing-masing blok ini menyimpan informasi tentang blok sebelumnya, sehingga menciptakan kumpulan rantai blok.

NEAR Protocol bersifat sharded, artinya lebih dari satu jaringan yang secara paralel atau yang disebut Shard, dapat berjalan setiap saat. Selanjutnya, setiap Shard menghasilkan sebuah blok kepingan (chunck) pada interval waktu tertentu. Blok di NEAR Blockchain adalah kumpulan blok chunck dari semua Shard yang ada. Blok chunk disingkat menjadi Chunk dalam terminologi dan dokumentasi pada NEAR Protocol.

Kembali ke pembahasan aliran data itu sendiri, hal terbaik yang bisa kita lakukan adalah membayangkan jalur seperti yang bisa kita lihat di aplikasi pengeditan audio/video. Setiap Shard memiliki kumpulan jalur sendiri. Jalur paling atas adalah untuk Chunks. Mereka akan muncul kapanpun pada interval tertentu, untuk NEAR Blockchain intervalnya sekitar satu detik. Chunk akan tetap diproduksi walaupun  jika tidak ada yang terjadi di blockchain.



Namun apa yang akan terjadi jika sesuatu sedang terjadi? Maksudnya jika ada sesuatu yang memicu beberapa perubahan di dalam jaringan blockchain. Metode paling terkenal untuk memicu perubahan sedemikian rupa  adalah mengirim Transaksi ke blockchain dengan instruksi tentang apa yang ingin kita ubah dan siapa yang meminta terikait perubahan itu.

Sebuah transaksi perlu dibangun, disahkan, dan dikirim ke jaringan blockchain. Setelah dijalankan, tentunya kita berharap akan mendapatkan hasil ataupun output dari hasil eksekusi tersebut. Tentunya ini terlihat sederhana, namun ternyata itu tidak terlalu relevan untuk NEAR Blockchain.



Pada awal mula jika terjadi transaksi, ini akan berisikan instruksi yang ingin kita eksekusi di jaringan blockchain. Selanjutnya transaksi dikirim ke NEAR Blockchain.

Dan tentunya hal tersebut akan dieksekusi dengan segera,  NAMUN hasil langsung dari eksekusi transaksi hanya akan selalu dalam bentuk pengakuan bahwa itu akan dieksekusi di rantai jaringan; permintaan eksekusi internal ini dikenal sebagai Receipt (tanda terima).. Anda dapat menganggap Receipt ini sebagai transaksi internal yang ada untuk menyampaikan informasi melintasi Shard..

Mari kembali ke jalur tadi untuk melihat contohnya.

Dengan asumsi kita memiliki dua akun yang berada di Shards yang berbeda yakni alice.near dan bob.near. alice.near membuat Transaksi untuk mengirim beberapa token ke bob.near. Transaksi segera dieksekusi dan hasil eksekusi untuk transaksi selalu berupa receipt.

Namun, receipt tersebut tidak bisa dieksekusi di sini, karena bob.near tidak berada di Shard yang sama dengan alice.near, jadi receipt harus dieksekusi di Shard penerima. Jadi receipt akan pindah ke Shard tempat bob.near berada.

Saat berada di Shard tujuan, receipt akan dijalankan dan proses dianggap selesai.


PENJELASANNYA DI SINI SANGAT SEDERHANA



Silakan merujuk ke artikel alur transfer Token

Jadi skema akhir akan terlihat seperti:




Kesimpulan​
Kita telah mempelajari prinsip-prinsip utama bagaimana aliran data terjadi di Protokol NEAR. Kita telah memahami bahwa Transaksi dijalankan dan Output (hasil) Eksekusi Transaksi selalu berupa Tanda Terima (receipt).

Sekarang kita tahu bahwa Receipt adalah aset internal utama untuk blockchain NEAR Protocol dan memiliki kekuatan untuk berpindah antar Shards. Kami mempelajari aliran Data NEAR pada contoh sederhana. Tentu saja dalam kehidupan nyata dengan transaksi yang lebih kompleks, yang melibatkan panggilan lintas kontrak, akan ada lebih banyak Receipt dan Hasil Eksekusi.

Semoga artikel ini bermanfaat dan anda dapat membangun dApps dan indexer milik anda dengan mudah dengan pengetahuan tentang bagaimana data mengalir di jaringan NEAR Protocol.

### Переход кошелька NEAR: зачем он и что делать сейчас  его пользователям

Большинство пользователей NEAR слышали о переходе кошелька NEAR. Но остается еще много вопросов о его причинах, процессах и отношении к MyNearWallet. Вот наиболее часто задаваемые вопросы о переходе с комментариями команды MyNearWallet.
Почему я должен переходить с «официального» кошелька, разработанного Near Foundation, на другой?
Начнем с того, что у пользователей NEAR разные потребности и предпочтения, и вряд ли один, официальный продукт сможет их все покрыть. В какой-то момент разработчики экосистемы NEAR поняли это и решили, что в ближайшем будущем у экосистемы NEAR не будет официального кошелька, и всем DApps будет предложено использовать селектор кошельков. Официальный кошелек NEAR, wallet.near.org, станет страницей со списком всех кошельков экосистемы. Точные даты пока не называются.Изменения должны усилить децентрализацию и стимулировать здоровую конкуренцию в экосистеме NEAR. В результате без официального кошелька пользователи получат более продвинутые продукты.
Как MyNearWallet подключен к кошельку NEAR?
Kikimora Labs создает MyNearWallet на базе открытого исходного кода кошелька NEAR. База пользователей не была перемещена в MyNearWallet. Сам кошелек остался открытым. В новом проекте команда MyNearWallet начала улучшать старые функции, добавлять новые и усиливать безопасность. На данный момент служба поддержки MyNearWallet помогает пользователям обоих кошельков. Также команда NearWallet решает проблемы с ошибками в двух проектах. При этом новые функции будут доступны только в MyNearWallet. Интерфейс MyNearWallet по-прежнему выглядит почти так же, как и wallet.near.org. Но, как утверждает команда проекта, дизайн будет меняться плавно.
Что произойдет с моей учетной записью https://wallet.near.org/?
Пользователи могут переводить свои учетные записи на любой понравившийся кошелек NEAR без потери средств. Вот инструкция о том, как перенести свою учетную запись в MyNearWallet.
Дорожная карта перехода кошелька и стратегия

 	Фаза 0 — Взаимодействие с сообществом [сейчас] 
 	Фаза 1 — внештатные пользователи, включение функций экспорта учетной записи [начинается в октябре] 
 	Фаза 2 — Новый портал для массива кошельков [ожидается завершение в начале 2023 года] 
 	Фаза 3 — Завершение транзакции Переадресация 
 	Фаза 4 — Завершение закрытия кошелька NEAR

### Что такое NFT (L)Earner?

Захватывающая новая коллекция NFT недавно появилась в экосистеме NEAR. Прежде чем мы рассмотрим, что такое коллекция (L)Earner NFT, напомним, что такое NFT. Если вы уже знакомы с NFT, можете это пропустить .
Что такое NFT?
NFT расшифровывается как Non-Fungible Token. NFT — это уникальные цифровые активы, идентифицирующая информация которых записана в смарт-контракте. Информация о смарт-контракте — это то, что делает NFT уникальным. NFT — это не взаимозаменяемый актив. Не взаимозаменяемые активы не подлежат разделению. Например, нельзя отправить кому-то часть картины или билет.

NFT — это цифровые сертификаты владения цифровыми активами. NFT — это смарт-контракт, который используется для защиты цифрового актива. После записи он публикуется в виде токена (ERC-721 или NEP-171) в блокчейне. Что угодно можно превратить в NFT, наиболее популярными из которых являются видео, GIF или JPEG.
Что такое коллекция (L)Earner NFT?
Коллекция (L)Earner NFT — результат сотрудничества сообщества Learn Near Club (LNC) и Дениса Башева, одного из лучших графических дизайнеров Европы, отмеченного наградами.
Концепция дизайна
Концепция дизайна основана на динамическом разнообразии человеческого интеллекта, основанном на уникальности каждого. Каждый человек — уникальная личность, которая имеет разнообразные модели обучения, сильные и слабые стороны. Коллекция (L)Earner NFT призвана подчеркнуть индивидуальность каждого участника и то, как различные винтики взаимодействуют в машине, чтобы создать целостного человека, у каждого из которых есть свои уникальные мечты, страхи, переживания и индивидуальность.



Для тех, кто не знаком с тем, как мы учимся на научном уровне, вот его суть:
Когда вы активно чему-то учитесь, нейроны (клетки мозга) начинают формировать связи между собой. Сначала эти связи очень слабые, и знания не полностью фиксируются в долговременной памяти. Со временем, когда вы тратите больше времени на изучение концепции, эти связи становятся сильнее и фиксируются в долговременной памяти. Ваши знания на самом деле хранятся в миллиардах нейронных связей между нейронами в человеческом мозгу. Этот процесс называется обучением по Хеббу.



Идея фигурок из палочек основана на нервной системе человека. Сегменты, из которых состоят люди-палки, вдохновлены миелиновыми оболочками, которые помогают передавать электрические импульсы через нейроны.

 

Позы персонажей воплощают в себе бесчисленные комбинации нейронных связей, которые объединяются в свой собственный микрокосм, чтобы сформировать отчетливые долговременные воспоминания о концепции или действии. Отрезки линий нанесены на декартовой плоскости для создания забавных поз.

 

Цветовая палитра была тщательно подобрана Денисом, чтобы оживить и добавить более игривый тон людям из палочек. Он символизирует радость обучения. Радость обучения — это не то, что можно просто почувствовать с мгновенным удовлетворением. Это кульминация всех способов, которыми жажда новых навыков и знаний улучшила вашу жизнь и жизнь окружающих вас людей.


Чеканка
Все минтеры NFT приглашаются к участию в этом передовом проекте. Стоимость чеканки начиналась с 2 NEAR и постепенно увеличивалась по мере того, как коллекция росла до предела в 10 000 NFT. Минтеры могут:

 	Генерировать — программа генерирует случайную позу и смешивает цвета столько раз, сколько вам нужно, чтобы вы получили (L)Earner NFT, который вы хотите. Большинство NFT на рынке «генерируются» из готовых моделей, в то время как NFT (L)Earner имеют практически неограниченное количество комбинаций, создавая NFT, который действительно уникален для вас.
 	Имя - дайте имя вашему (L)Earner NFT, сделайте его таким же уникальным, как ваш персонаж.
 	Выпустите свой NFT и защитите его в блокчейне NEAR.
 	Собиратель — собирайте столько, сколько хотите, и курируйте свою оригинальную личную коллекцию.
 	Торгуйте – покупайте и продавайте (L)Earner NFT на торговой площадке Paras NEAR NFT.

(L) Преимущества Earner NFT LNC
Вы не только получаете крутой NFT, когда создаете NFT (L)Earner, но и получаете полезные привилегии в качестве официального члена сообщества LNC:

 	Приоритетный 2-часовой ранний доступ к окну Redeem to NEAR
 	В будущем появится больше…

Присоединяйтесь к группе телеграмм LNC, чтобы поделиться своим (L)Earner NFT с другими членами сообщества.
Вывод
Коллекция (L)Earner NFT — это передовое сотрудничество между LNC и Денишем Башевым (отмеченный наградами графический дизайнер). Цель проекта — инкапсулировать индивидуальный опыт обучения каждого учащегося в NFT. Коллекция ограничена 10 000 NFT, так что покупайте, пока есть возможность!

### NEAR x Flutter Hola Match Guide

Primeira Parte – Contrato Inteligente para se conectar.



Olá, em este guia vamos criar um Olá + Nome, usando o padrão de correspondência RUST, para que ele esteja disponível em vários idiomas.
Usaremos então a NEAR-RPC-API para comunicar com esta função a partir de uma aplicação multiplataforma feita em Flutter, demonstrando assim que podemos acionar esta função desde qualquer dispositivo e assim construir sobre NEAR para qualquer plataforma.
 
-A quarta instalação é o VS CODE, mas você pode usar seu editor de texto/código favorito”-
Para isso precisamos ter instalado:
RUST = https://www.rust-lang.org/tools/install
NEAR-CLI = https://docs.near.org/docs/tools/near-cli#mac-and-linux
Flutter = https://docs.flutter.dev/get-started/install
VS CODE = https://code.visualstudio.com/#alt-downloads
A primeira coisa que faremos é abrir uma terminal para criar o projeto, recomendo abrir a terminal desde dentro do VS CODE por conveniência, mas você pode usar um externo.
No NEAR criamos contratos inteligentes com Bibliotecas, não com Binários, portanto o comando que irá criar um arquivo lib para nós ao invés do main, será:



cargo new --lib <nombre_de_tu_elección>







Neste caso, vou chamá-lo: near_hola_match
O próximo passo é adicionar a dependência NEAR SDK, e algumas configurações especiais dentro do TOML, já comentei no código o que a maioria dessas configurações fazem, as configurações são as seguintes:



[lib]
crate-type = ["cdylib"]
 
[dependencies]
near-sdk = "4.0.0-pre.7"
 
[profile.release]
codegen-units = 1 # Podría mejorar el desempeño, a cambio de ser más lento en compilación.
opt-level = "z" # Optimizaciones de velocidad.
lto = true # Optimizaciones de velocidad.
debug = false # Optimizaciones de velocidad.
panic = "abort" # Detener la ejecución en caso de error.
overflow-checks = true # No permitimos el desbordamiento de ints.







Estamos usando a versão mais recente (da data – 15/04) do NEAR SDK.
No arquivo lib.rs teremos uma função de exemplo, que vamos deletar, para construir nosso Smart Contract do zero.
Começaremos escrevendo as mais básicas, que são a struct (estrutura) do Contrato e a impl (implementação) do Contrato:
Eu adicionei a macro #[near_bindgen] que é típica do NEAR SDK; ela inclui tudo o que é necessário internamente para gerar o contrato e suas conexões.



use near_sdk::{ near_bindgen };
 
#[near_bindgen]
pub struct Contrato {
 
}
 
#[near_bindgen]
impl Contrato {
 
}








Para este exemplo vou incluir uma função de inicialização de contrato e um proprietário do mesmo, embora não sejam necessários para a função Olá + Nome, eles nos ajudarão a mostrar como incluir chamadas View e Call em um contrato, pois Olá + Nome não modifica o estado do blockchain, mas a função Call de inicialização sim.
Para isso vou incluir mais algumas importações, como o borsh, que é usado para serialização e desserialização na comunicação com o NEAR, bem como AccountId e PanicOnDefault, que são responsáveis ​​por verificar se o AccountId tem um formato válido, e que no caso de não inicializando o contrato entra no Panic, respectivamente.
Também criei a função de inicialização do contrato, ele recebe uma variável do tipo AccountId, que será atribuída como proprietária no momento da inicialização, esta chamada deve ser feita apenas uma vez



use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::{near_bindgen, AccountId, PanicOnDefault};
 
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct Contrato {
   pub owner_id: AccountId,
}
 
#[near_bindgen]
impl Contrato {
   #[init]
   pub fn new(owner_id: AccountId) -> Self {
       let this = Self { owner_id };
       this
   }
}








Começaremos a criar a função que devolverá a saudação, dependendo de qual idioma queremos:
A função será chamada hello_name, que recebe de parâmetros o contrato mesmo, o nome a ser vinculado à String e o idioma desejado. Colocamos os idiomas possíveis em um padrão de correspondência, e na parte inferior, um último elemento que será usado como padrão caso não haja correspondência.



   pub fn hello_name(&self, name: String, language: String) -> String {
       match language.as_str() {
           "en" => format!("Hello {}!", name),
           "es" => format!("Hola {}!", name),
           "fr" => format!("Bonjour {}!", name),
           "de" => format!("Hallo {}!", name),
           "it" => format!("Ciao {}!", name),
           "pt" => format!("Olá {}!", name),
           "ru" => format!("Привет {}!", name),
           "zh" => format!("你好 {}!", name),
           "tr" => format!("Merhaba {}!", name),
           "ua" => format!("Привіт {}!", name),
           _ => format!("Hello {}!", name),
       }
   }








A próxima coisa será adicionar o destino wasm32-unknown-unknown se ainda não o tivermos feito:



rustup target add wasm32-unknown-unknown







E então vamos fazer o build e ver se tudo deu certo até agora:



cargo build --target wasm32-unknown-unknown --release







Uma nova pasta terá sido criada, o arquivo específico que estamos procurando é near_hola_match.wasm , e aí está:







No começo eu disse que é necessário instalar near-cli, e este é o momento em que ele vai nos servir.
Primeiro passo:



near login



Estaremos lhe dando acesso total à nossa conta TESTNET, com isso iremos criar uma subconta e implantar o contrato.
Segundo passo:



near create-account <subcuenta>.<nuestra_cuenta_de_testnet> --masterAccount <nuestra_cuenta_de_testnet>



Exemplo:



near create-account contrato1.jeph.testnet --masterAccount jeph.testnet



Este comando não nos dará uma frase-semente, mas armazenará a chave diretamente em nosso computador.
O comando a seguir implantará o contrato na testnet para que possa ser acessado por qualquer pessoa:



near deploy --wasmFile target/wasm32-unknown-unknown/release/<nombre_del_archivo_wasm>.wasm --accountId <nombre_de_la_cuenta>



Exemplo:



near deploy --wasmFile target/wasm32-unknown-unknown/release/near_hola_match.wasm --accountId contrato1.jeph.testnet







Tx ID



Como podemos ver, ele foi implantado sem problemas, e podemos ver a transação no navegador:
Então, para chamar a função VIEW, usamos:



near view <id_del_contrato> <nombre_de_la_función> '{"name": "<cualquier_nombre>", "language": "<alguno_de_los_lenguajes_que_pusimos>"}'



Exemplo:



near view contrato1.jeph.testnet hello_name '{"name": "jeph.testnet", "language": "es"}'







No entanto, encontramos isto, o contrato não foi inicializado e, como não queríamos deixar um padrão, ele entrou em pânico, o que fazemos?, inicialize-o:
Esta será uma CALL, não uma VIEW, então adicionamos um parâmetro ao final –account-id <conta_com_asesso>.
Exemplo:



near call contrato1.jeph.testnet new '{"owner_id": "contrato1.jeph.testnet"}' --account-id contrato1.jeph.testnet







Tx ID



Foi inicializado com sucesso.
E podemos prosseguir com a chamada VIEW anterior:



near view contrato1.jeph.testnet hello_name '{"name": "jeph.testnet", "language": "es"}'



(Podemos colocar qualquer um dos idiomas e até alterar o nome que enviamos)







Segunda Parte - Conexão Flutter para NEAR



Continuamos com a parte do Flutter, lembrando que este não é um curso de Flutter, mas sim como conectar sua aplicação feita em Flutter e fazer chamadas para os Nodos RPC do NEAR, portanto é um requisito já ter o Flutter instalado.
Vamos criar um novo projeto no Flutter com (command + shift + p) ou (control + shift + p).







Ele nos perguntará se será um Aplicativo, um Módulo, etc… Escolhemos o Aplicativo.







Escolhemos o nome desejado.







Ele criará um arquivo principal muito longo, que eu deletei:

Todos os comentários.
A função “increment”. 
O body. 
O fab (Floating Action Button – botão de ação flutuante).

A única coisa que adicionei foi a String “title”, e passei como argumento em dois lugares.







Ainda teremos o arquivo “pubspec.yaml”, que é semelhante ao JS/TS “package.json”, aqui declaramos os pacotes a serem usados, a versão da aplicação e várias outras configurações.
Neste arquivo vamos adicionar uma única linha, e esta será para adicionar um pacote:



“ http: ^0.13.4“.




Este pacote nos ajudará a fazer requisições http simples, existem várias que são um pouco mais personalizáveis, como a DIO, mas para este exemplo não precisamos das opções extras, e normalmente o http é suficiente.

Nota: Tome cuidado para manter o mesmo recuo, como “flutter” ou “cupertino_icons”.







Vamos criar um arquivo chamado “name_and_language.dart” dentro de uma nova pasta que chamei de “models” dentro de “lib”.







Neste arquivo vamos criar apenas uma Classe, para passar somente um objeto nas funções a seguir.







Vamos criar um arquivo chamado “rpc_fun.dart” dentro de uma nova pasta que chamarei de “utils” dentro de “lib”.











Nesse arquivo vamos colocar a requisição para o nodo RPC do NEAR Protocol, vou lhe mencionar de uma vez que é uma requisição http do tipo post, portanto tem três requisitos: url, headers (cabeçalhos) e body (corpo).
Iniciamos o arquivo com as importações, precisamos importar de “convert” para JSON,  importar para “math” para criar um id único aleatório para solicitações a blockchain (neste caso, não é muito importante que o ID seja único e funcionaria sem ele, mas ainda o consideraremos), Eu também importei “foundation” para fazer essa solicitação em um thread separado do thread principal (o Dart geralmente é executado em um único thread e você precisa de Isolates se quiser usar outro) (Para esta solicitação, pode ser desnecessário, mas suponha que um dia você decida solicitar dados de 100 NFTs para a blockchain, provavelmente faria a tela do seu usuário desacelerar ou até parar por alguns segundos), importamos http para fazer as solicitações.
Da mesma forma, no topo declaramos as constantes dos headers, a URL do nodo RPC da Testnet, o nome do contrato que criamos na parte 1 deste guia, o método do contrato que chamaremos e declaramos a instância de Random (Aleatório).
Note que eu nunca uso “var” para declarar variáveis, e você que trabalha com RUST também não deve, também tornando os valores que você não altera de constantes, tornamos a execução da aplicação um pouco mais rápida.







Como você bem sabe, as solicitações http têm o mesmo body (corpo) e o referido body tem:

O nome do contrato.
O método de contrato.
O propósito que precisamos pode ser otimista ou final.
Os argumentos que a função requer, vão para um Map, mas convertidos para Base64.
O ID da solicitação.








Os nodos RPC nos retornam muitos dados, mas o que mais importa para nós é o encontrado em <result> (dentro de outro <result>), mas ele retorna na forma de um buffer (que é uma lista de u8 (números) e Eles têm uma mensagem que nem você nem eu podemos entender à primeira vista.
Existe uma extensão para que você possa decifrá-lo desde seu navegador – RPC Parser (Feita por mim 
Mas tudo bem, nossa app deve entendê-lo, para devolver a saudação ao usuário, e essa função é a seguinte:







Lhe passamos uma lista de valores Dinâmicos (Que significa isso? – Que só Deus sabe quê tipo de dados está recebendo), nós sabemos que seguramente sejam números, mas Dart/Flutter não, e pessoalmente tenho experimentado erros, algumas vezes crê que são strings, número e em outras simplesmente não entende.
É então que a função anterior pede a lista Dinâmica, cada um dos elementos é convertido a String (cadeia de texto), depois apaga os espaços em branco e por último os passa a Int (número) e então volta a gerar uma nova lista na qual está assegurado que são números. Logo após converte esses números em nossa esperada mensagem.
Más também para tal efeito necessitamos uma resposta, e para isso é necessário uma petição, e a seguinte função faz:
Passa a URL de String a Uri.

Passa a URL de String a Uri.
Cria o Mapa com os argumentos.
Passa os argumentos a Base64 depois de passá-los a utf8, depois de passá-los a json.
Chama a função que nos gera o body com os dados requeridos e o passa a json.
Finalmente realiza a petição http post passando pelos três parâmetros que mencionei ao princípio (ur, headers e body)
No caso de haver uma resposta, a passamos para um mapa.
Chamamos a função que decodifica o buffer (e faz mais coisas as quais expliquei anteriormente)
E o resultado é nada mais e nada menos que a mensagem que esperávamos








Tudo lindo e maravilhoso mas... mas são muitos passos e é possível que algum dispositivo apresenta uma diminuição de fps, especialmente se a sua petição fora maior ainda.
Que tal se a chamamos através de outra linha?







Então não chamamos diretamente a "fetchRpc” senão a "CallFetch" o qual vai mandar chamar a “fetchRpc” através de outra linha.
Muito bem, já temos o mais difícil e agora, ¿onde o vemos? Necessitamos uma interface simples que nos permita ingressar um nome, escolher um idioma e dar click em enviar. Tudo isso o faremos no arquivo "main.dart. Na parte até em cima vamos adir 2 "imports:







(O material já estava, somente vamos adir "name_and_languaje.dart" e “rpc_fun.dart”)
Não iremos tocar a função "main" nem a classe "MyApp", mas em "MyHomePage" sim faremos muitas mudanças:
Vamos Criar um "TextEditingController para poder tomar o valor do nome, uma lista de idiomas aceitados (os mesmos que pusemos no Contrato), um simples valor Booleano que nos indica que o usuário não clickou, e o mais importante, uma nova instância da classe "NameAndLanguaje" que anteriormente criamos.. ¿Porque é o final?; Por que apesar de que os valores internos não ser finais, a instância, sim o é.
Inicializamos o "TextEditingController" no "iniState" e logo nos desfazemos dele no "dispose".







Logo após incluiremos um input para ser possível adir um nome, um dropdown para escolher entre os idiomas possíveis (para tal fin passamos a constante accepted), dito dropdown não se abrirá si não tivermos incluido um nome e um botão para realizar a primeira petição (As seguintes vão se realizar no momento em que se mude o idioma no dropdown), dito botão só será ativado se tivermos escolhido um idioma no dropdown.







Aqui adicionei dois "Text", um que nos dará as boas vindas e nos mostrará o nosso nome e outro, que em caso de não haver escolhido um idioma, que pedirá que o ingressemos e em caso de já haver escolhido, nos dirá o idioma que falamos (até aqui ainda não enviamos nada a NEAR.







Aqui o usuário ingressa seu nome, este será armazenado na instância da classe chamada “nameAndLanguage” e chamamos um “setState”.







No Dropdown escolhemos um idioma dos que colocamos na lista e chamamos outro “setState”.







Um simples botão para designar o valor booleano true em "clicked" já que somente ao ser true (verdadeiro) chamamos ao seguinte “FutureBuilder”.







Este “FutureBuilder" chama a callFetch passando “nameAndLanguage” e o que devolve é mostrado na tela, ponha atenção na velocidade de carregamento, Bastante rápida um pedido ao Nodo RCP da Near, ¿certo?
¿Quer vê-lo em ação?




https://youtube.com/shorts/9r4jmVBZRec?feature=share




¿Quer ver o código completo?



https://github.com/JuEnPeHa/near_hola_match_flutter/tree/main/lib



	

	
	
		
			
				¿Em qual das seguintes plataformas podemos construir con a Near?
			
		

		
					

		
			
			
			
			web
		
			
			código
		
			
			escritorio
		
			
			todas as anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Podemos fazer petições ao Nodo RCP da Near para pedir informação sobre NFTs e ou FTs?
			
		

		
					

		
			
			
			
			Falso
		
			
			Verdadeiro
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Em qual formato enviamos o httpBody (Ou simplesmente o Body da repetição) ao RCP?
			
		

		
					

		
			
			
			
			Lib
		
			
			JSON
		
			
			BSON
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿As petições VIEW que NÃO modificam o estado da blockchain (Mas, sim, podem fazer certo tipo de processamento) tem um custo para nós?
			
		

		
					

		
			
			
			
			Falso
		
			
			Verdadeiro
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








 





 

### ¿Qué son los NFT de (L)Earner?

Una nueva y emocionante colección NFT recientemente lanzada en el Ecosistema NEAR. Antes de explorar qué es la colección (L)Earner NFT, aquí hay un breve resumen de lo que es un NFT. Siéntete libre de omitirlo si ya estás familiarizado con los NFT.
¿Qué es un NFT?
NFT significa token no fungible. Los NFT son activos digitales únicos que tienen su información de identificación registrada en un contrato inteligente. La información del contrato inteligente es lo que hace que un NFT sea único. Un NFT es un activo no fungible. Los bienes no fungibles no son divisibles. Por ejemplo, no puedes enviarle a alguien una parte de una pintura o de un boleto.

Los NFT son certificados digitales de propiedad de activos digitales. Un NFT es un contrato inteligente que se utiliza para asegurar un activo digital. Una vez escrito, se publica en un token (ERC-721 o NEP-171) en la cadena de bloques. Cualquier cosa se puede convertir en un NFT, siendo los más populares videos, GIF o JPEG.
¿Qué es la colección (L)Earner NFT?
La colección (L)Earner NFT es una colaboración entre la comunidad Learn Near Club (LNC) community y Denis Bashev, uno de los mejores diseñadores gráficos galardonados de Europa.
Concepto de Diseño
El concepto de diseño se basa en la diversidad dinámica de la inteligencia humana impulsada por la singularidad de cada alumno. Cada ser humano es un individuo único que tiene diversos patrones de aprendizaje, fortalezas y debilidades. La colección (L)Earner NFT tiene como objetivo resaltar la individualidad de cada alumno y cómo los diferentes engranajes interactúan en la máquina para crear una persona holística, cada uno con sus propios sueños, miedos, experiencias y personalidad.



Para aquellos que no están familiarizados con la forma en que aprendemos a nivel científico, aquí está la esencia:
Cuando participas activamente en el aprendizaje de algo, las neuronas (células cerebrales) comienzan a formar conexiones entre sí. Al principio, estas conexiones son muy débiles y el conocimiento no está completamente comprometido con la memoria a largo plazo. A medida que avanza el tiempo y pasas más tiempo aprendiendo sobre un concepto, estas conexiones se fortalecen y se comprometen con la memoria a largo plazo. Tu conocimiento en realidad se almacena en miles de millones de conexiones neuronales entre las neuronas del cerebro humano. Este proceso se llama aprendizaje hebbiano.



La idea de las figuras de palitos se basa en el sistema nervioso humano. Los segmentos que componen una persona de palitos están inspirados en las vainas de mielina que ayudan a que los impulsos eléctricos se transmitan a través de las neuronas.

 

Las poses de los personajes encarnan las innumerables combinaciones de conexiones neuronales que se fusionan en sus propios microcosmos para formar distintos recuerdos a largo plazo de un concepto o actividad. Los segmentos de línea se trazan en un plano cartesiano para crear poses divertidas.

 

Denis seleccionó cuidadosamente la paleta de colores para darle vida y agregar un tono más divertido a las personas de palitos. Simboliza la alegría de aprender. La alegría de aprender no es algo que se pueda sentir con una gratificación instantánea. Es la culminación de todas las formas en que la sed de nuevas habilidades y conocimientos ha mejorado tu vida y la vida de quienes te rodean.


Minteo
Todos los minters de NFT están invitados a participar en este proyecto de vanguardia. El costo de minteo comenzó desde 2 $NEAR y aumenta gradualmente a medida que la colección crece hacia su límite de 10,000 NFT. Los Minters pueden:

 	Generar- el software genera una postura aleatoria y una mezcla de colores tantas veces como desee, para que obtenga el (L)Earner NFT que desea. La mayoría de los NFT en el mercado se "generan" a partir de modelos prefabricados, mientras que los NFT de (L)Earner tienen una cantidad prácticamente ilimitada de combinaciones que crean un NFT que es realmente único para tí.


 	Nombre- asigna un nombre a su (L)Earner NFT, hazlo tan único como tu personaje


 	Mint- mintea tu NFT y asegúralo en la cadena de bloques NEAR.


 	Seleccionar- colecciona tantos como quieras y selecciona tu colección personal original
 	Tradear- Comprar y vender (L)Earner NFTs en el Paras NEAR NFT Marketplace

Beneficios del (L)Earner NFT LNC
No solo obtienes un NFT genial cuando acuñas o minteas un NFT de (L)Earner, sino que también obtienes beneficios útiles como miembro oficial de la comunidad LNC:

 	Prioridad de acceso temprano por 2 horas para canjear en la ventana de  NEAR 
 	Minteo de Prueba de los NFTs de (L)Earn
 	Más por venir en el futuro…

Únete al grupo LNC telegram group para compartir tus NFT (L)Earner con otros miembros de la comnidad
Conclusión
La colección (L)Earner NFT es una colaboración de vanguardia entre LNC y Denish Bashev (diseñador gráfico galardonado). El objetivo del proyecto es encapsular la experiencia de aprendizaje individual de cada alumno en un NFT. La colección está limitada a 10 000 NFT, ¡así que consigue el tuyo mientras puedas!

### Multiverse Fighters – Primer parche

 
Lista de cambios y actualizaciones realizadas en Multiverse Fighters. Para jugar, necesitarás tener la NEAR Wallet en testnet, y, no se te olvide guardar la frase semilla
Herramientas de desarrollo

 Se implementó una funcionalidad para diseñadores de juegos, brindando la oportunidad:




para crear habilidades
para crear y editar bots (inventario, mazo, etc.)
para crear cosas para bots
para ajustar el saldo sin la participación del desarrollador




 Se actualizó la base de pruebas de NFT, se agregaron nuevos tipos de NFT

Juego / Mecánica del juego

 Se agregó un nivel y nivelación del personaje (la capacidad para que el jugador distribuya los atributos obtenidos con cada nivel)
 Razas (NFT) añadidas al juego
 La clase y la raza ahora tienen aún más influencia en el estilo de juego:




al usar Clases, además de las cartas, las características del jugador cambian
al usar Raza, algunas características cambian para mejor y otras para peor. Ejemplos de razas: Humano, Elfo, Beastman (Hombre - Bestia).




 Se agregaron 2 nuevas clases que se están equilibrando.
 Se agregaron nuevas armas y armaduras (armas de dos manos, armaduras ligeras y pesadas) que ahora le dan características al personaje.
 Se implementó el Poder del jugador (o bot). La cantidad de tokens recibidos y la experiencia en batalla, así como la búsqueda de un oponente dependen del Poder
 Se implementó un mapa mundial con turbas de varios niveles (todavía en la versión de prueba)
 Se agregaron 16 primeras turbas, con habilidades especiales y diferentes niveles de dificultad.
 Sistema de búsqueda de batalla actualizado 

Economía / Token / NFT / Blockchain

 Economía básica lanzada:




El token MFIGHT se agregó a ref finance en la red testnet (De pruebas) de NEAR, se creó un par NEAR/FIGHT
Se agregó la capacidad de mintear y comprar NFT con el token de juego




 Cada NFT tiene características únicas que varían según la rareza
 Se agregó un contrato inteligente para el token de experiencia.
 Actualización de NFT implementada debido al token de experiencia y el token de juego
 Se implementó la acumulación de recompensas en batallas (token principal y token de experiencia)
 Se ha preparado una herramienta para generar rasgos NFT

Perfil de personaje / Pestañas sociales

El sistema de Clanes está implementado de forma básica. Puedes crear un clan, cargar un logotipo e invitar a los usuarios, en el futuro, la funcionalidad se ampliará y se transferirá a la cadena de bloques.
ÓRDENES
 Se actualizó el diseño de la página de perfil.
 Se implementan títulos de jugadores (se pueden obtener por actividad en el proyecto)
 Las estadísticas de PvP (Jugador contra Jugador)/PvE (Jugador contra la Computadora) se separaron
 NFT favorito se implementó, ahora puedes elegir el NFT que se mostrará en tu perfil
 Se implementó la visualización de logros (Se reciben NFT para eventos especiales en el juego)
 Visualización de peleas recientes añadida
 Posibilidad de reclamación de tokens añadida
 Se agregó un diagrama gráfico del juego en las clases.
 Se agregó una página de edición de perfil (apodo, lema, descripción y avatar)
 Se implementó el parámetro de decencia del jugador, cambia con respecto al buen o mal comportamiento del jugador en el juego (no rendirse, no dejar el juego hasta el final)
 Chat de juego implementado (básico)

Se implementó la visualización de jugadores en línea en la ubicación

 Se agregó una tabla de clasificación (en la versión de prueba) con la visualización de los mejores jugadores por índice de victorias y otros parámetros
 El torneo se divide en grupos para facilitar la visualización con una gran cantidad de personas
 Se ha implementado un contrato inteligente para la reputación (token) en el juego.
 Ahora puedes ver el perfil de otros jugadores.

Sitio web

 Se implementó la funcionalidad para llenar páginas de wiki, así como páginas individuales en el sitio para ver el wiki (el trabajo en el wiki está en marcha)
 Se implementó un sistema de notificaciones en el sitio (tanto personales como generales)

Base / Servidor
Se ha preparado la funcionalidad en el servidor para crear analíticas en el juego (la cantidad de nuevos jugadores por fechas, el uso de clases, la proporción de victorias de clase, la cantidad de peleas por fechas, la cantidad de tokens recibidos (básico y experiencia) por fechas)

### TokenHub: zona de pruebas de DeFi en NEAR testnet

1. ¿Qué es TokenHub?

 	TokenHub es un patio de recreo (Un espacio que no afecta a otras partes) en donde puedes crear tu propio token con solo unos pocos clics y luego probar libremente todas las funciones del mundo Defi.

2. ¿Por qué TokenHub?

 	Desde la reducción a la mitad de las recompensas de Bitcoin en 2020, el espacio DeFi ha crecido continuamente y está bien desarrollado en la diversidad de productos y base de usuarios. El valor total bloqueado en todos los productos DeFi una vez incluso alcanzó un máximo de $250 mil millones. Esto demuestra que la necesidad de DeFi aumenta cada día, pero la mayoría de las personas solo reconocen los riesgos de DeFi después de perder dinero real. Esta es la motivación para la creación de TokenHub. La misión del equipo de TokenHub es ayudar a los usuarios de DeFi a obtener experiencia práctica en muchos campos de DeFi, como el farming (cultivo de rendimientos) y el intercambio de tokens... sin el costo de tu dinero real. Al usar TokenHub, los usuarios pueden aprender mucho sobre DeFi sin correr el riesgo de perder dinero, exclusivamente en NEAR testnet.

3. Guía de TokenHub: Cómo crear tu propio token en TokenHub
Paso 1: Conecta tu cuenta de NEAR testnet a TokenHub
Si no tienes una cuenta de NEAR testnet, sigue la guía oficial.

Ve a https://app.tokenhub.tk/token/create y haz clic en "Conectar a la billetera":



Una vez que hayas sido redirigido a este sitio, haz clic en "Siguiente":


Después haz clic en “Conectar”:



Tu cuenta está ahora conectada a TokenHub:


Paso 2: Ve a https://app.tokenhub.tk/token/create o haz clic en el botón "Crear token" en el panel izquierdo del sitio web sitio web de TokenHub:

Paso 3: Completa la información de tu token deseado
Esto incluye el nombre de tu token, su símbolo, su suministro total y su valor decimal (de 8 a 24). En este ejemplo, crearé un token llamado "Bitcoin" y tendrá el símbolo "BTC", su suministro total será de 21,000,000 tokens y un valor decimal de 8.



Una explicación simple del valor decimal es el número de dígitos que tiene después del punto decimal. Por ejemplo, mi token de Bitcoin tiene un valor decimal de 8, por lo que una cuenta cualquiera podría tener 1.12345678 BTC o 49.37603856 BTC, y el suministro total de mi token de BTC será de 21,000,000.00000000. Cuanto mayor sea el valor decimal, más divisible será su ficha.
Paso 4: Configura la asignación de tu token
Paso 4.1: Configurar las cuentas de asignación
Dos cuentas predeterminadas recibirán una parte del suministro total de tokens: la cuenta de tesorería de TokenHub (treasury.tokenhub.testnet) y la cuenta que has conectado a TokenHub. Para agregar más cuentas que puedan recibir una parte de su suministro total de tokens, haz clic en "Agregar más asignación" y luego completa la dirección de esas cuentas, ten en cuenta que las cuentas que agregues deben ser de NEAR pero en testnet, que son cuentas que terminan con “.testnet”, no “.near”:



Mi token BTC solo se asignará a las dos cuentas predeterminadas:






	

	
	
		
			
				Las cuentas predeterminadas a las que se asignará tu token son la tesorería de TokenHub y tu estás conectado a la billetera NEAR.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paso 4.2: Determina la asignacion de tokens para cada cuenta
Indica cuánto de tu suministro total (en %) se le dará a cada cuenta en el cuadro "Asignación (%)". La cantidad que obtendrá la cuenta de tesorería tiene tres opciones a elegir entre 3, 5 o 7%. Recuerda que no importa a cuántas cuentas se asignen tus tokens, la asignación total (%) de todas las cuentas debe ser del 100%. Mi token BTC le dará a la tesorería de TokenHub el 3% (630,000 BTC), y el 97% restante se enviará a mi cuenta:


4.3: Establece el lanzamiento inicial para cada cuenta.
Determina cuánto (de 0 a 100 %) de la asignación que configuraste en el Paso 4.2 se enviará inmediatamente a cada cuenta una vez que hayas creado tu token. En este ejemplo, la tesorería recibirá instantáneamente el 10% del 3% del suministro total de 21,000,000 BTC, que son 63,000 BTC. En cuanto a mi cuenta, es el 50% del 97% de 21,000,000 BTC, que son 10,185,000 BTC.

Quizás te estés preguntando, "¿Cómo se liberará el resto de los tokens?". Aquí es donde entran los parámetros de adquisición.


Paso 4.4: Configura los parámetros de adquisición de derechos
El Vesting (La adquisición) es la liberación gradual y periódica de tokens a las cuentas designadas. En este ejemplo, significa que los tokens restantes que no se liberan inicialmente se bloquearán después de la creación y se liberarán en intervalos seleccionados en el futuro. En TokenHub, se pueden configurar 3 parámetros para la concesión de tokens: la fecha de inicio, la duración de la concesión y el intervalo de concesión.

La fecha de inicio de la concesión determina cuándo comienza el proceso de liberación de su token. Puedes configurar esta fecha individualmente para cada cuenta de asignación.



 

A continuación, establece la duración de la concesión de cada cuenta. La duración de la concesión es el tiempo que llevará liberar completamente los tokens. Para la cuenta de tesorería de TokenHub, hay 3 opciones para elegir entre 1, 2 o 3 años. En cuanto a otras cuentas, puedes completar cualquier duración (en días) que desees. En este ejemplo, la adjudicación de la tesorería completará su liberación de tokens en 1 año. Para mi cuenta, se completará en 30 días.

 

Finalmente, establece los intervalos de adjudicación (en días) para cada cuenta. El intervalo de consolidación es el período entre cada liberación. Por ejemplo, una duración de adquisición de 30 días y un intervalo de 10 días significa que los tokens se dividirán en 3 partes iguales y cada parte se liberará cada 10 días. Para la cuenta de tesorería también hay 3 opciones: 30, 90 o 180 días. Para otras cuentas, puedes elegir cualquier duración.






	

	
	
		
			
				Aparte de las dos cuentas de asignación, no puedes agregar ninguna otra cuenta que pueda recibir tu token.
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paso 5: Crea tu token
Una vez que hayas completado todos los pasos anteriores, haz clic en "Crear token"



Luego serás redirigido a este sitio, y aquí da clic en “Aprobar”

Después de un tiempo, serás redirigido a la pestaña "Mi token", que incluye todos tus tokens creados.
Guía: Inicia tu venta de tokens
Para lanzar tu venta de tokens en TokenHub, por favor completa este formulario: https://forms.gle/vgagVRQpKrEQJ8D86

Luego, comuníquese con Harry: el fundador de TokenHub a través de:

 	Discord: harrynguyen#0629
 	Telegram: @harrynguyen0991

Para que podamos ayudarte a configurar tu contrato de venta de tokens de acuerdo con tu registro de venta. Te informaremos sobre la dirección del contrato, por lo que deberás enviar suficientes tokens a ese contrato. Finalmente, te pondremos en el sitio web de TokenHub para comenzar la promoción. Luego, todo lo que tienes que hacer es esperar y tu venta estará en marcha. Fundamentalmente, debes decidir cuántos tokens se asignan para la venta y cuál es el cronograma. Depende totalmente de ti, pero la venta no debería durar demasiado. La venta de tokens LNC duró 3 días, incluidos 2 días de venta y 1 día de gracia, lo que puede ser una buena referencia para que estimes el tiempo que consideres conveniente. Consulta Venta de Tokens LNC para obtener más detalles.

### TokenHub – Aire de jeux DeFi sur NEAR testnet

1. Qu'est-ce que TokenHub ?


 	TokenHub est un terrain de jeu où vous pouvez créer votre propre jeton en quelques clics, puis essayer librement toutes les fonctionnalités du monde Defi.

2. Pourquoi TokenHub ?

 	Depuis la réduction de moitié du Bitcoin en 2020, l'espace DeFi n'a cessé de croître et est bien développé dans la diversité des produits et de la base d'utilisateurs. La valeur totale verrouillée sur tous les produits DeFi a même culminé à 250 milliards de dollars. Cela prouve que le besoin de DeFi augmente chaque jour, mais la plupart des gens ne reconnaissent les risques de DeFi qu'après avoir perdu de l'argent réel. C'est la motivation pour la création de TokenHub. La mission de l'équipe TokenHub est d'aider les utilisateurs de DeFi à acquérir une expérience pratique de nombreux domaines de DeFi comme l'agriculture de rendement et l'échange de jetons,… sans le coût de leur argent réel. En utilisant TokenHub, les utilisateurs peuvent en apprendre beaucoup sur DeFi sans prendre le risque de perdre de l'argent, exclusivement sur NEAR testnet.

3. Guide TokenHub : comment créer votre propre token sur TokenHub
Étape 1 : Connectez votre compte NEAR testnet à TokenHub
Si vous n'avez pas de compte NEAR testnet, veuillez suivre le guide officiel.

Allez sur https://app.tokenhub.tk/token/create et cliquez sur "Connet To Wallet":



Une fois que vous êtes redirigé vers ce site, cliquez sur "Next":


Puis clique “Connect”:



Votre compte est maintenant connecté à TokenHub:


Step 2: Allez sur  https://app.tokenhub.tk/token/create ou cliquez sur le bouton "Create Token" sur le panneau de gauche de TokenHub website:

Étape 3 : Remplissez les informations de jeton souhaitées
Cela inclut le nom de votre jeton, son symbole, son approvisionnement total et sa valeur décimale (de 8 à 24). Dans cet exemple, je vais créer un jeton nommé "Bitcoin" et avoir le symbole "BTC", son approvisionnement total sera de 21 000 000 de jetons et une valeur décimale de 8.



Une explication simple de la valeur décimale est le nombre de chiffres qui vient après la virgule décimale. Par exemple, mon jeton Bitcoin a une valeur décimale de 8, donc un compte arbitraire pourrait avoir 1,12345678 BTC ou 49,37603856 BTC, et l'offre totale de mon jeton BTC sera de 21 000 000,00000000. Plus la valeur décimale est élevée, plus votre jeton sera divisible.
Etape 4 : Configurez l'allocation de votre token
Étape 4.1 : Configurer les comptes de répartition
Deux comptes par défaut recevront une partie de l'offre totale de jetons : le compte de trésorerie de TokenHub (treasury.tokenhub.testnet) et le compte que vous avez connecté à TokenHub. Pour ajouter d'autres comptes pouvant recevoir une partie de votre approvisionnement total en jetons, cliquez sur "Ajouter plus d'allocation", puis remplissez l'adresse de ces comptes, notez que les comptes que vous ajoutez doivent être des comptes NEAR testnet, qui sont des comptes qui se terminent avec ".testnet", pas ".near":



Mon jeton BTC n'allouera qu'aux deux comptes par défaut :






	

	
	
		
			
				Les comptes par défaut auxquels votre jeton sera attribué sont la trésorerie de TokenHub et vous êtes connecté au portefeuille NEAR testnet.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Étape 4.2 : déterminer l'allocation de jetons pour chaque compte
Indiquez la part de votre approvisionnement total (en %) qui sera attribuée à chaque compte dans la case « Allocation (%) ». Le montant que le compte du Trésor obtiendra a trois options à choisir entre 3, 5 ou 7 %. N'oubliez pas que quelque soit le nombre de comptes auxquels vos jetons seront attribués, l'allocation totale (%) de tous les comptes doit être de 100 %. Mon jeton BTC donnera à la trésorerie de TokenHub 3 % (630 000 BTC), et les 97 % restants seront envoyés sur mon compte :


Étape 4.3 : Définir la version initiale pour chaque compte
Déterminez la part (de 0 à 100 %) de l'allocation que vous avez définie à l'étape 4.2 qui sera immédiatement envoyée à chaque compte une fois que vous aurez créé votre jeton. Dans cet exemple, le Trésor recevra instantanément 10% de 3% de l'offre totale de 21 000 000 de BTC, soit 63 000 BTC. Quant à mon compte, c'est 50% de 97% de 21 000 000 BTC, soit 10 185 000 BTC.

Vous vous demandez peut-être : « Comment le reste du jeton sera-t-il libéré ? ». C'est là qu'interviennent les paramètres d'acquisition.


Étape 4.4 : Configurer les paramètres d'acquisition
L'acquisition est la libération progressive et périodique de jetons sur les comptes désignés. Dans cet exemple, cela signifie que les jetons restants qui ne sont pas initialement libérés seront verrouillés après la création et seront libérés à des intervalles sélectionnés à l'avenir. Chez TokenHub, vous pouvez configurer 3 paramètres pour l'acquisition de votre token : la date de début, la durée d'acquisition et l'intervalle d'acquisition.

La date de début d'acquisition détermine le moment où le processus de libération de votre jeton commence. Vous pouvez configurer cette date individuellement pour chaque compte d'allocation.



 

Ensuite, définissez la durée d'acquisition pour chaque compte. La durée d'acquisition est le temps qu'il faudra pour libérer complètement les jetons. Pour le compte de trésorerie de TokenHub, vous avez le choix entre 3 options de 1, 2 ou 3 ans. Comme pour les autres comptes, vous pouvez indiquer la durée (en jours) que vous souhaitez. Dans cet exemple, l'acquisition pour le Trésor achèvera sa libération de jetons en 1 an. Pour mon compte, ce sera terminé dans 30 jours.

 

Enfin, définissez les intervalles d'acquisition (en jours) pour chaque compte. L'intervalle d'acquisition est la période entre chaque publication. Par exemple, une durée d'acquisition de 30 jours et un intervalle de 10 jours signifierait que les jetons seront divisés en 3 parties égales, et chaque partie sera libérée tous les 10 jours. Pour le compte de trésorerie, il existe également 3 options : 30, 90 ou 180 jours. Pour les autres comptes, vous pouvez choisir n'importe quelle durée.






	

	
	
		
			
				Outre les deux comptes d'attribution, vous ne pouvez pas ajouter d'autres comptes pouvant recevoir votre jeton.
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Étape 5 : Créez votre jeton
Une fois que vous avez terminé toutes les étapes ci-dessus, cliquez sur "Create Token"



Ensuite, vous serez redirigé vers ce site, cliquez sur "Approve"

Au bout d'un moment, vous serez redirigé vers l'onglet "My token" qui regroupe tous vos jetons créés.
Guide : Lancez votre vente de jetons
Pour lancer votre vente de jetons sur TokenHub, merci de remplir ce formulaire : https://forms.gle/vgagVRQpKrEQJ8D86 

Alors contactez Harry – fondateur de TokenHub via :

 	Discord: harrynguyen#0629
 	Telegram: @harrynguyen0991

Afin que nous puissions vous aider à mettre en place votre contrat de vente de jetons en fonction de votre enregistrement de vente. Nous vous informerons de l'adresse du contrat afin que vous deviez envoyer suffisamment de jetons à ce contrat. Enfin, nous le mettrons sur le site Web de TokenHub pour commencer la promotion. Ensuite, tout ce que vous avez à faire est d'attendre et votre vente sera opérationnelle. Fondamentalement, vous devez décider combien de jetons sont alloués à la vente et quel est le délai. Cela ne dépend que de vous, mais la vente ne devrait pas durer trop longtemps. La vente de jetons LNC a duré 3 jours dont 2 jours de vente et 1 jour de grâce ce qui peut être une bonne référence pour vous. Reportez-vous à la vente de jetons LNC pour plus de détails.

### NearKits: lo que necesitas saber

NearKits
Bien, Nearkits es un rastreador de carteras... O eso es como empezó. Todos lo conocemos como una herramienta en la que podemos verificar nuestra cartera de NFTs en NEAR. Por mi parte, la he usado innumerables veces para verificar este mercado rojo. También permiten un servicio de transferencia NFT entre billeteras y luego un servicio de mensajería NFT, llegaré a esa parte en un momento.
Mientras escribo esto hoy 21/05/22, mintearán (acuñarán) su NFT a las 7 P.M. UTC, una colección de 333 NFTs con diferentes niveles, Plata, Oro y Rubí, y el costo de minteo es de 10N, el 50% de las regalías secundarias se distribuirán entre los poseedores de estos NFTs… Ah, igual te menciono que también están bajo el paraguas de Antisocial Studios.




La hoja de ruta




Fase 1
Ok, con la Fase 1 completa, que incluía un lugar para verificar el valor de su cartera NEAR NFT en USD y NEAR con un precio promedio de todos los NFT, la capacidad de poder transferir NFT entre diferentes billeteras, la capacidad de poder enviar un mensaje NFT propietario, por lo que, por ejemplo, ve un NFT que desea o tal vez tiene una oferta, entonces puede encontrar su dirección y enviar un mensaje directamente a la billetera que lo posee. También tienes una galería NFT muy simplificada, aunque no hay nada que celebrar.

Fase 2
This is the minting stage, so a collection of 333 NFTs and different tiers called access cards, what else comes with this is:

Esta es la etapa de minteo, por lo que una colección de 333 NFT y diferentes niveles llamados tarjetas de acceso, lo que viene con esto es:

 	Listado de herramientas por lotes
 	Herramienta de transferencia NFT por lotes
 	Herramienta de ofertas de NFT por lotes
 	Marketplace y rastreador de ballenas
 	Enlaces de galería personalizados
 	Robots francotiradores de precio más bajo
 	Rastreador de precios NFT basado en rareza

Fase 3
Entonces, después de que se haya completado toda la fase 2, pasamos a la fase tres y lo que obtenemos es:

 	Sofisticados bots de servidor de discord
 	Un servicio de suscripción (No poseedores)
 	Protocolo de lanzamiento justo NEAR
 	Herramienta de análisis de tokens
 	Extensión del navegador NEARKits
 	Vista previa de NEARKits NFT




Vista previa de NEARKits NFT








Estos nos recuerdan los tipos de portales, tipo de acceso, tipo de tarjeta, tipo NFT, pero son las herramientas detrás de esto las que harán que los inversores quieran tener uno y con solo 333 suministros y un Whitelist mint (Solo pueden mintear los que estén en la lista blanca), seguramente estarás interesado en ver cómo va en las ventas secundarias.

Aquí te muestro también es lo que hacen diariamente en su Twitter para mantener a su comunidad al día con los precios NEAR NFT FP.




Estos son un proyecto que llegó al ecosistema de NEAR con la mentalidad de creación de utilidades y para proporcionar la utilidad que queremos o necesitamos.

(Descargo de responsabilidad: Soy parte de su equipo como Asesor)
Conclusión
Entonces, dependiendo de cuándo estés leyendo esto, es posible que estés minteando o comprando uno en el mercado secundario. Espero haberte dado suficiente información para tomar una decisión informada por GURU, como de costumbre, siempre ve con ese instinto también.

Enlaces para encontrarlos en:

Twitter: https://twitter.com/NearKits_io

NearKits: https://nearkits.io/#my_nfts
Discord: https://discord.gg/wh3GrGhbfB

### What do you want (L)Earn next?

GM,  (L)Earners!

Let's think together about what is the next big thing we want to (L)Earn at LNC!

Please come with urgent and important thoughts and get a chance to get some $NEAR!

The best request will get 10 $NEAR and 2 🕺(L)Earner NFTs!

2nd and 3rd place will get 5 $NEAR and  1 🕺(L)Earner NFT!

### NEAR wallet transition: why will it happen and what should its users do now

No doubt, most NEAR users have heard about the transition of the NEAR wallet. But there are still a lot of questions left about its reasons, processes, and relation to MyNearWallet. Here are the most asked questions about the transition with the comments of MyNearWallet team. 
Why should I switch from an “official” wallet developed by the Near Foundation to another one?

To begin with, NEAR users have different needs and preferences and one, official, product is really unlikely to cover them all. At some point, NEAR ecosystem developers realized it and decided that in the near future NEAR ecosystem will not have an official wallet and all the DApps will be encouraged to use a wallet-selector. The official NEAR wallet, wallet.near.org, will become a listing page for all ecosystem wallets. The exact dates are not announced yet.

The changes should enhance decentralization and inspire healthy competition in the NEAR ecosystem. As a result, without an official wallet, users will get more advanced products. 
How is MyNearWallet connected to NEAR wallet?
Kikimora Labs, is building MyNearWallet on top of the NEAR wallet open source  codebase. The user base was not moved to MyNearWallet. The wallet itself remained open-sourced. In the new project, MyNearWallet team started improving old features, adding new ones, and strengthening the security. At the moment, the support team of MyNearWallet helps users of both wallets. Also, MyNearWallet team solves bug-issues for two projects. Meanwhile, new features will be available only in MyNearWallet. 

MyNearWallet interface still looks almost the same as wallet.near.org. But as the project team claims, the design will be changed smoothly. 
What will happen to my https://wallet.near.org/ account?
Users can transfer their accounts to any NEAR wallet they like without funds loss. Here is the instruction on how to transfer your account to MyNearWallet.
Wallet transition Roadmap & Strategy 

 	Phase 0 — Community Engagement [now]
 	Phase 1 — Offboard Users, Enable Export Account Functionalities [Starts October]
 	Phase 2 — A new portal for Array of wallets [Expected to complete early 2023]
 	Phase 3 — End transaction Forwarding
 	Phase 4 — Complete Sunsetting of the NEAR wallet

### Multiverse Fighters – Premier Correctif

Liste des changements et mises à jour dans Multiverse Fighters. Pour jouer, vous aurez besoin de NEAR Wallet sur testnet et n'oubliez pas de sauvegarder la phrase de départOutils de développement

Fonctionnalité implémentée pour les concepteurs de jeux, donnant l'opportunité :

– créer des compétences
– pour créer et éditer des bots (inventaire, deck, etc.)
– pour créer des trucs pour les bots
– pour ajuster l'équilibre sans la participation du développeur
       2. La base de test  NFT a été mise à jour, de nouveaux types de NFT ont été ajoutésJeu / Mécanique du jeu

 Ajout d'un niveau et d'un leveling du personnage (la possibilité pour le joueur de répartir les attributs obtenus à chaque niveau)
 Courses (NFT) ajoutées au jeu
 La Class et la race ont désormais encore plus d'influence sur le style de jeu :


lors de l'utilisation de la Class, en plus des cartes, les caractéristiques du joueur changent
lors de l'utilisation de Race, certaines caractéristiques changent pour le mieux et d'autres pour le pire. Exemples de races : humain, elfe, homme-bête.


 Ajout de 2 nouvelles classes en cours d'équilibrage
 Ajout de nouvelles armes et armures (armes à deux mains, armures légères et lourdes) il donne maintenant des caractéristiques au personnage
 La puissance du joueur (ou du bot) est mise en œuvre, le nombre de jetons reçus et l'expérience au combat, ainsi que la recherche d'un adversaire dépendent de la puissance
 Implémentation d'une carte du monde avec des foules à plusieurs niveaux (toujours dans la version de test)
 Ajout de 16 premiers mobs, avec des compétences spéciales et différents niveaux de difficulté
 Système de recherche de combat mis à jour

Économie / Token / NFT / Blockchain

 Lancement de l'économie de base :


Le jeton MFIGHT a été ajouté à ref finance dans le réseau de test NEAR, une paire NEAR/FIGHT a été créée
Ajout de la possibilité de frapper et d'acheter NFT pour un jeton de jeu


 Chaque NFT a des caractéristiques uniques qui varient en fonction de la rareté
 Ajout d'un contrat intelligent pour le jeton d'expérience
 Mise à niveau NFT mise en œuvre en raison d'un jeton d'expérience et d'un jeton de jeu
 Mise en œuvre de l'accumulation de récompenses dans les batailles (jeton principal et jeton d'expérience)
 Un outil pour générer des traits NFT a été préparé

Profil de personnage / Onglets sociaux

Le système de Clans est implémenté de manière basique. Vous pouvez créer un clan, télécharger un logo et inviter des utilisateurs, à l'avenir, la fonctionnalité sera étendue et transférée à la blockchain
 COMMANDES
 Mise à jour du design de la page Profil
 Les titres des joueurs sont mis en œuvre (ils peuvent être obtenus pour une activité dans le projet)
 Les statistiques PvP/PvE ont été séparées
 NFT favori implémenté, vous pouvez maintenant choisir le NFT qui sera affiché dans votre profil
 Mise en œuvre de la visualisation des réalisations (NFT reçu pour des événements spéciaux dans le jeu)
 Ajout de la visualisation des combats récents
 Revendication de jeton ajoutée
 Ajout d'un graphique-diagramme du jeu sur les classes
 Ajout d'une page d'édition de profil (pseudo, devise, description et avatar)
 Le paramètre de décence du joueur est implémenté, il change du bon / mauvais comportement du joueur dans le jeu (ne pas se rendre, ne pas quitter le jeu jusqu'à la fin)
 Chat de jeu implémenté (basique)

Mise en œuvre de la visualisation des joueurs en ligne sur le site

 Ajout d'un classement (dans la version de test) avec l'affichage des meilleurs joueurs par winrate et d'autres paramètres
 Le support du tournoi est divisé en groupes pour une visualisation facile avec un grand nombre de personnes
 Un contrat intelligent pour la réputation (jeton) a été implémenté dans le jeu
 Vous pouvez maintenant voir le profil des autres joueurs.

Site Internet

 Fonctionnalité implémentée pour remplir les pages Wiki, ainsi que des pages individuelles sur le site pour visualiser le wiki (le travail sur le Wiki est en cours)
 Mise en place d'un système de notifications sur le site (à la fois personnelles et générales)

Base / ServeurUne fonctionnalité a été préparée sur le serveur pour créer des analyses dans le jeu (le nombre de nouveaux joueurs par dates, l'utilisation des classes, le ratio de victoires de classe, le nombre de combats par dates, le nombre de jetons reçus (de base et d'expérience) par dates)

### Tokenomics 101 pour les startups du web3

D'accord, vous avez donc décidé de créer votre propre dApp et d'entrer dans l'espace web3. Félicitations pour avoir franchi cette étape. Cependant, avant de lancer votre application qui change la donne, vous devez définir l'un des principes fondamentaux de Web3 - Tokenomics. Tokenomics est le portemanteau de « jeton » et « économie », ce qui est assez explicite. Ainsi, dans cet article, vous apprendrez tout ce que vous devez savoir sur les tokenomics.
Qu'est-ce que Tokenomics?
Tokenomics est un terme vague, mais il comprend plusieurs facteurs tels que l'offre et la demande, l'émission de jetons, les fonctions de gravure, etc. En termes simples, il s'agit d'une somme totale de fonctions et de facteurs économiques qui affectent vos jetons de différentes manières. Un jeton appartenant à un projet avec une solide tokenomics est considéré comme un investissement plus attractif. Alors, sans plus tarder, examinons les différents facteurs.
Facteur 1 : Offre et Demande
L'équation de l'offre et de la demande est l'un des facteurs les plus critiques déterminant la tokenomics. Ce qui suit est l'un des graphiques les plus importants en économie - le graphique de l'offre et de la demande.



Le graphique ci-dessus montre la relation entre l'offre et la demande d'un produit particulier. Le prix ultérieur d'une marchandise est déterminé par sa demande sur le marché et la quantité qui est facilement disponible.

La rareté d'un article (c'est-à-dire la diminution de l'offre) est souvent considérée comme un facteur important dans l'évaluation du produit. Pensez aux prix gonflés auxquels les machines PS5 se vendaient sur le marché de l'occasion en raison de leur rareté. Cependant, ce n'est pas parce qu'un objet est rare qu'il a de la valeur. Vous pouvez prendre un selfie de vous-même - qui sera un article unique, mais cela ne signifie pas que vous obtiendrez des milliers de dollars pour cela, n'est-ce pas ? Il doit y avoir une demande sur le marché. Dans la phase d'équilibre, les graphiques de la demande et de l'offre s'équilibrent parfaitement.

Il y a deux choses que nous pouvons conclure du graphique :

 	Lorsque l'offre d'un actif est élevée mais que la demande est faible, cela n'affectera pas positivement le prix.
 	Si la demande est élevée mais que l'offre est faible, cela affectera positivement le prix.

Offre et demande en jetons

En ce qui concerne Bitcoin, l'un des moments les plus importants de création de valeur dans le protocole est les événements périodiques de réduction de moitié qui se produisent tous les quatre ans. Bitcoin a une offre fixe totale de 21 millions. Les mineurs exploitent Bitcoin pour obtenir une récompense globale pour libérer BTC dans l'offre en circulation.

Tous les quatre ans, Bitcoin subit une réduction de moitié qui réduit de moitié cette récompense globale, ce qui réduit la quantité de BTC entrant dans l'offre en circulation. Satoshi Nakamoto a délibérément ajouté ce mécanisme pour garantir une offre décroissante au fil du temps et, espérons-le, augmenter la valorisation globale des prix.

Plusieurs jetons comme BNB ont un mécanisme de combustion artificielle. La gravure signifie que vous envoyez les jetons à un portefeuille dont les clés privées n'appartiennent à personne. Ce faisant, vous supprimez ces jetons de la circulation, c'est-à-dire que vous brûlez les jetons.

Il y a aussi certains jetons qui sont inflationnistes. Par exemple, EOS a un taux d'inflation annuel de 1 %. Ce 1% sert à payer les producteurs de blocs. L'idée était que le système EOS deviendrait si occupé au fil du temps que l'augmentation de l'offre n'affecterait pas la demande.
Facteur 2 : Distribution de Jetons
Un protocole peut distribuer des jetons via un lancement équitable ou une pré-mine. Lorsqu'un lancement équitable a lieu, tout le monde a une opportunité équitable d'acquérir les jetons. Le lancement de Bitcoin était juste puisque tout le monde avait exactement la même opportunité d'acquérir BTC. Il n'y a pas eu de prévente, pas de ronde d'investisseurs privés. Si vous vouliez Bitcoin, vous auriez dû les exploiter à partir de zéro.

Cependant, les lancements équitables sont très rares de nos jours. À partir de l'ère ICO, les jetons ont été lancés via une méthode appelée premine. Dans une prémine, les jetons sont partiellement ou entièrement créés, puis distribués à diverses parties telles que des VC, des investisseurs, etc., avant d'être rendus publics. De toute évidence, le préminage est injuste car un utilisateur moyen n'obtient pas la première bouchée du gâteau. Cependant, dans le paysage actuel, il est nécessaire de le faire car les projets ont besoin de cette injection initiale de liquidités de la part des VC et des teneurs de marché. Ils ont besoin de liquidités pour payer la main-d'œuvre, le développement, la construction de l'écosystème, etc.

Cela dit, il est crucial de voir combien de jetons sont distribués à ces parties. Par exemple, si une équipe s'attribue 5 % des jetons, alors tout va bien. Ils ont besoin d'argent pour financer leur équipe, après tout. Cependant, s'ils se donnent 50% à eux-mêmes, c'est un signal d'alarme potentiel.




	

	
	
		
			
				Lorsqu'un asset une offre faible et une demande élevée, cela signifie que :
			
		

		
					

		
			
			
			
			le prix devrait monter
		
			
			le prix devrait baisser
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Facteur 3 : Staking
À la base, une bonne tokenomics devrait proposer différentes méthodes pour inciter les utilisateurs à conserver leurs jetons. L'une des façons les plus cool de le faire est d'assurer au titulaire une certaine forme de retour sur investissement assuré. De nombreux projets le font avec un mécanisme de staking.

L'idée est simple - enfermez vos jetons dans le protocole et gagnez des récompenses. Par exemple, si vous détenez des jetons Curve (CRV), vous pouvez les miser sur Convex Finance en tant que cvxCRV et gagner environ 30 % de vAPR. Les applications DeFi vous permettent de miser divers jetons qui peuvent vous aider à gagner du rendement.

Le staking permet également aux utilisateurs de verrouiller votre jeton, ce qui en fait automatiquement des détenteurs à long terme. Après tout, vous ne pouvez pas vendre un jeton que vous avez fermement enfermé dans l'écosystème, n'est-ce pas ?

Maintenant, la prochaine question à considérer ici est la suivante : comment pouvez-vous inciter vos utilisateurs à miser volontairement vos pièces pendant longtemps ? Eh bien, des projets comme Curve ont une offre d'intérêts composés simple qui fonctionne plutôt bien pour eux. Plus longtemps vous gardez votre CRV verrouillé, plus vous obtenez de récompenses.

Le staking vous donne également des droits de gouvernance dans certains projets. Le staking du jeton natif vous permet de devenir membre du protocole DAO et de voter sur diverses décisions. Par exemple, dans Curve, vous pouvez staker votre CRV et veCRV, le jeton de vote. Plus vous misez de CRV, plus vous obtenez de veCRV. veCRV n'a aucune valeur en dehors d'être utilisé comme jeton de vote au sein du DAO.
Facteur 4 : Calendriers d'Acquisition
Dans le facteur 2, nous avons expliqué comment le préminage permet aux projets d'allouer des jetons spécifiques aux investisseurs privés et aux VC. Cependant, que se passe-t-il si ces personnes jettent immédiatement vos jetons sur le marché libre ? Cela ne servira à rien votre projet, n'est-ce pas?

Donc, ce que vous pouvez faire ici, c'est utiliser différents calendriers d'acquisition pour vos allocations. L'acquisition vous permet de verrouiller les jetons distribués pendant un temps donné (c'est-à-dire la période d'acquisition). Cela augmente le temps d'attente avant de mettre la main sur les jetons.

Maintenant, avant d'aller plus loin, parlons de la "falaise". En ce qui concerne l'acquisition, la falaise est un verrou de durée qui est placé sur les jetons acquis avant le début du calendrier d'acquisition. Il existe deux types d'acquisition que vous pouvez faire :

 	Acquisition linéaire : la distribution des jetons est effectuée de manière cohérente et à parts égales dans un certain laps de temps.- 
 	Acquisition torsadée : la distribution des jetons peut varier au cours de diverses périodes.

Créer votre propre jeton – Bonnes pratiques
Alors, maintenant que vous connaissez les bases, créons votre jeton. Vous pouvez utiliser ce terrain de jeu de jetons pour tester diverses structures de jetons.



Comme vous pouvez le voir, vous mettez votre nom de jeton, votre symbole, votre offre totale et vos décimales.

En dessous, vous avez une liste d'allocations de jetons. Selon le nombre de conseillers et de VC que votre projet aura, vous pouvez attribuer les allocations en conséquence. Cependant, juste un conseil. N'exagérez pas avec les allocations pour les conseillers. Gardez une majorité significative pour votre communauté.

Par exemple:

10% pour l'équipe

10% pour les premiers investisseurs

0,25 % à 0,5 % par conseiller

Repos pour la communauté.




	

	
	
		
			
				De quel type d'acquisition s'agit-il ? "La distribution des jetons se fait de manière cohérente et à parts égales dans un certain laps de temps"
			
		

		
					

		
			
			
			
			Linéaire
		
			
			Tordu
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
Lors de la construction de votre protocole Web3, une tokenomics robuste est cruciale pour le succès à long terme de votre projet. Dans cet article, nous avons parlé de quatre fonctionnalités que vous pouvez intégrer à votre tokenomics pour éviter le dumping et inciter les utilisateurs à conserver vos jetons et à en accumuler davantage.




	

	
	
		
			
				Lors de la distribution des jetons, la majorité des jetons doit être allouée à :
			
		

		
					

		
			
			
			
			Equipe
		
			
			VCs
		
			
			Communauté
		
	
		

		
		
			
				Correct!
				Wrong!

### dWork2 Beta test

Follow @LearnNEAR on Twitter

Beta test sprint starts: October 13, 9 am ET
Beta Test sprint ends: October 15, 11pm ET.
dWork 2.0 new features:

 	A user can create tasks and also can solve other tasks.


 	The task owner has to deposit 110% rewards. 10% will be used for solving bad behaviors. If not, the protocol will refund.


 	If you want to reject workers’ work. You have to input your reason.


 	Workers can report if they don’t agree with this reason. Or they see bad behaviours from the task owner.


 	Admin will solve this problem.


 	In our next milestone. We will introduce the REVIEWER role. So the community can solve bad behaviours and earn rewards.

Requirements:

 	

 	Follow https://twitter.com/dworkisnear and ask five friends to follow too.
 	Join dWork Community https://t.me/dwork_community and ask five friends to join too.
 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Login at https://www.dwork.tk/


 	Create five meaningful tasks.


 	Try to solve at least five tasks.


 	Try to reject workers’ work with your reason.


 	Try to do something wrong and let the owner and admin solve it.


 	Bugs report is a big plus.


 	Tell me your feeling. It will help us make dWork even better.


 	Tweet your feeling about dWork on Twitter. Remember to tag dworkisnear  project from @LearnNEAR Barrel



For every requirement, you have to submit your proof in a screenshot.
Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead https://t.me/ChrisNguyen99

### Qu'est-ce que Sweatcoin : Une Brève Introduction

Grâce à la technologie blockchain et aux crypto-monnaies, le monde voit l'innovation à une échelle stupéfiante. L'une de ces innovations est Sweatcoin, une application de santé et de remise en forme de premier plan qui encourage les utilisateurs à adopter un mode de vie plus sain en utilisant diverses récompenses comme incitation. En 2022, Sweatcoin a annoncé qu'il lancerait sa propre crypto-monnaie, le jeton Sweatcoin (SWEAT). Le jeton est basé sur les blockchains NEAR et Ethereum et sera utilisé comme une incitation pour attirer plus d'utilisateurs vers l'application.

Cet article vous aidera à comprendre le concept de Sweatcoin, son fonctionnement et ses différents cas d'utilisation.




Qu'est-ce que Sweatcoin?
Sweatcoin peut être décrit comme un projet de jeu pour gagner fondé sur la conviction que le mouvement et un mode de vie actif pourraient avoir une réelle valeur. Sweatcoin utilise la finance décentralisée (DeFi) et les jetons non fongibles (NFT) pour débloquer la valeur qui est restituée à l'utilisateur. Pendant ce temps, le DAO permet aux utilisateurs de participer au processus de gouvernance, de développement et de prise de décision de l'écosystème Sweatcoin.

Le projet offre aux utilisateurs une nouvelle avenue de création de valeur, permettant aux utilisateurs de gagner grâce aux mouvements enregistrés sur l'application. Sweatcoin est également un projet open-source, permettant à chacun de faire avancer le projet.

Initialement, le jeton Sweatcoin était un jeton non crypté, et lorsque les utilisateurs qui téléchargeaient l'application atteignaient un nombre spécifié d'étapes, ils recevaient des jetons Sweatcoin. Les détenteurs de jetons peuvent échanger ces jetons contre des récompenses d'organisations telles que Headspace et Audible. Alternativement, les utilisateurs peuvent également faire don de ces jetons à des causes caritatives. En théorie, le jeton Sweatcoin offre plusieurs similitudes avec les crypto-monnaies, ce qui a incité l'équipe à créer le jeton Sweatcoin (SWEAT)







Le jeton Sweatcoin (SWEAT)
L'événement de génération de jetons de Sweatcoin a eu lieu le 12 septembre. Après l'événement de génération de jetons, le seul moyen de créer de nouveaux jetons SWEAT est le mouvement, vérifié par les validateurs de mouvement. Initialement, SWEAT ne sera disponible que pour les utilisateurs Sweatcoin éligibles qui s'inscrivent. Après l'événement de génération de jetons, le solde actuel des utilisateurs Sweatcoin sera mis en correspondance 1: 1 avec les jetons SWEAT. Après le 12, gagner du SWEAT devient plus délicat, car vos 5000 premiers pas chaque jour vous permettraient de créer de nouveaux SWEAT, tandis que toute autre étape générerait des Sweatcoins comme d'habitude. Alors que 1 Sweatcoin sera toujours égal à 1000 pas, SWEAT deviendra plus difficile à frapper au fil du temps.










	

	
	
		
			
				Quel terme décrit le mieux Sweatcoin en tant que projet?
			
		

		
					

		
			
			
			
			Jouez pour gagner projet
		
			
			Déplacer pour gagner projet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment fonctionne Sweatcoin ?


Comprenons comment Sweatcoin et l'économie Sweat fonctionnent tous les deux. L'application Sweatcoin gratuite est disponible sur l'App Store d'Apple et sur Google Play. Une fois que vous téléchargez et installez l'application sur votre appareil, l'application surveille votre activité tout au long de la journée, en suivant le nombre de pas effectués. En tant qu'utilisateur, vous pouvez gagner un Sweatcoin pour 1000 pas enregistrés. Les utilisateurs peuvent échanger ces pièces et acheter diverses choses telles que des chaussures de course, des montres numériques, des téléchargements de musique, des boissons énergisantes, etc. Plus vous marchez, plus vous gagnez de Sweatcoins.

Selon le livre blanc, Sweatcoin a été créé pour inciter les gens à continuer à bouger, à récompenser le mouvement et à créer une planète plus saine. N'importe qui dans l'économie de la sueur peut gagner et y contribuer. Initialement, le SWEAT n'était disponible que pour les utilisateurs éligibles qui pouvaient télécharger l'application Sweatcoin. Au premier trimestre 2022, Sweatcoin était passé à 65 millions d'utilisateurs, un nombre qui a atteint 110 millions d'utilisateurs en août 2022, et ce nombre devrait encore augmenter.

Le jeton SWEAT ne peut être frappé que par un mouvement vérifiable. Un nombre stable d'utilisateurs aide à augmenter l'entrée (pas); à mesure que de plus en plus d'utilisateurs rejoindraient le réseau, l'entrée augmenterait de façon exponentielle. De plus, chaque nouveau jeton SWEAT nécessiterait plus d'étapes pour être frappé que le jeton précédent. Cela correspond à l'objectif de Sweatcoin de rendre le monde plus actif physiquement. Avec chaque nouveau jeton SWEAT de plus en plus difficile à frapper, il agit non seulement comme une incitation pour les utilisateurs à continuer à bouger, mais préserve également l'utilité du jeton SWEAT.

Les mouvements des utilisateurs sont validés par des validateurs de mouvements qui mettent à jour la blockchain. Une validation cohérente est essentielle pour garantir l'intégrité de l'actif sous-jacent (SWEAT). Comme mentionné précédemment, les utilisateurs peuvent gagner un jeton SWEAT pour 1 000 étapes franchies. Les validateurs reçoivent des données des appareils des utilisateurs et détectent tout mouvement frauduleux grâce à un algorithme, garantissant que seuls les vrais mouvements sont enregistrés.






	

	
	
		
			
				Le jeton SWEAT est basé sur quelles blockchains?
			
		

		
					

		
			
			
			
			Near et Ethereum
		
			
			Polygon et Cardano 
		
			
			Ethereum et Cardano 
		
			
			Near et Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Plans futurs pour Sweatcoin
L'économie Sweat a également son propre portefeuille crypto, le Sweat Wallet, et prévoit également d'introduire les NFT dans l'écosystème. De plus, il est prévu de permettre aux utilisateurs d'acheter SWEAT directement en utilisant la monnaie fiduciaire d'ici la fin de 2022. L'équipe a également annoncé son intention de créer un marché NFT et de rendre le jeton SWEAT disponible sur les échanges décentralisés. A terme, la gouvernance de l'économie SWEAT et SWEAT sera transmise à une organisation autonome décentralisée (DAO). À terme, la frappe de Sweatcoin sera étendue à d'autres méthodes d'activités telles que le vélo, la natation, etc.




	

	
	
		
			
				Après l'événement de génération de jeton, les utilisateurs peuvent frapper SWEAT en
			
		

		
					

		
			
			
			
			Enregistrement des 5000 premiers pas sur l'application sweatcoin
		
			
			Enregistrement des 1000 premières pas sur l'application sweatcoin
		
			
			Acheter le jeton de SWEAT directement
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Apprendre sur le club NEAR
Learn NEAR Club (LNC) est une plate-forme d'intégration pratique tout compris pour le protocole NEAR, où vous pouvez apprendre à utiliser et à développer le protocole NEAR, et gagner des jetons NEAR. LNC propose une multitude de guides et de cours d'intégration. Les utilisateurs de LNC peuvent également gagner des nLearns, qui sont essentiellement des points internes, qui agissent comme une récompense pour les apprenants exceptionnels. Les utilisateurs de LNC peuvent commencer avec les guides NEAR, les cours NEAR ou créer leur propre NFT (L)Earner.

Maintenant que vous avez appris à SWEAT, vous pouvez passer au Learn NEAR Club et (L)Earn. Vous pouvez également consulter le Guide Sweatcoin disponible sur LNC, ainsi qu'une foule d'autres guides et cours.







	

	
	
		
			
				Que pouvez-vous faire avec vos Sweatcoins?
			
		

		
					

		
			
			
			
			Acheter des offres, des produits et des offres numériques
		
			
			Mise aux enchères de grande valeur ( Playstation 5, GoPro Hero 9)
		
			
			Faire un don à des organismes de bienfaisance comme Save the Children
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!

### ¿Qué es Sweatcoin? Una Breve Introducción

Gracias a la tecnología blockchain y a las criptomonedas, el mundo está contemplando la innovación a una escala asombrosa. Una de esas innovaciones es Sweatcoin, una aplicación sobre salud y fitness, ubicada entre las mejores apps que anima a sus usuarios a adoptar un estilo de vida más saludable mediante el uso de recompensas como incentivo. En 2022, Swaetcoin anunció que lanzaría su propia criptomoneda, el Token Swaetcoin (SWEAT). Este token está basado en la blockchain de NEAR y de Ethereum y será utilizado como incentivo para atraer a más usuarios a la aplicación.

Este artículo te ayudará a entender el concepto detrás de Sweatcoin, cómo funciona y cuáles son sus diferentes usos.




¿Qué Es Sweatcoin?
Sweatcoin puede ser descrito como un proyecto tipo "jugar para ganar", fundado en la creencia de que el movimiento y un estilo de vida activo, puede tener un valor real. Sweatcoin utiliza las Finanzas Descentralizadas (DeFi) y los Tokens no Fungibles (NFTs) para desbloquear el valor que es devuelto al usuario. Mientras tanto, la DAO permite a los usuarios participar en la gobernanza, el desarrollo y el proceso de toma de decisiones en el Ecosistema de Sweatcoin.

El proyecto da a los usuarios un nuevo camino para crear valor, permitiéndoles ganar, a través del movimiento registrado en la aplicación. Sweatcoin también es de código abierto, permitiendo que todos puedan impulsar el proyecto.

Inicialmente, el token de Sweatcoin no era un token de criptomoneda, cuando los usuarios que descargaban la aplicación lograban un número específico de pasos, se les daba token Sweatcoin. Los titulares de ese token podían canjear esos tokens por recompensas en plataformas como Headspace y Audible. Alternativamente, los usuarios podían donar esos tokens a causas benéficas. En teoría, el token Sweatcoin ofrece muchas similitudes con una criptomoneda, lo que impulsó al equipo a crear el token Sweatcoin (SWEAT).







El Token De Sweatcoin (SWEAT)
El evento de creación de tokens Sweatcoin, tuvo lugar el 12 de septiembre. Después del evento de creación de token, la única forma de mintear nuevos tokens SWEAT es a través del movimiento, verificado por validadores de movimiento. Inicialmente, SWEAT estará solo disponible para usuarios de Sweatcoin elegibles que opten por participar. Pasado el evento de creación de tokens, el saldo actual de Sweatcoin de los usuarios será igual a 1:1 con los tokens SWEAT. Posterior al día 12, ganar SWEAT será un poco más complicado, ya que tus primeros 5000 pasos diarios te permitirán mintear un nuevo SWEAT, mientras que cualquier paso extra te permitirá mintear Sweatcoins, como ocurre usualmente. Si bien, 1 Sweatcoin siempre será igual a 1000 pasos, un SWEAT se volverá más difícil de mintear mientras el tiempo pase.










	

	
	
		
			
				¿Qué término describe mejor a Sweatcoin como un proyecto?
			
		

		
					

		
			
			
			
			Proyecto Jugar para ganar
		
			
			Proyecto Mover para ganar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo Funciona Sweatcoin?


Vamos a entender cómo funcionan la economía de Sweatcoin y de SWEAT. La aplicación gratuita Sweatcoin se encuentra disponible en las tiendas de aplicaciones de  Apple y Google Play. Una vez que descargues e instales la aplicación en tu dispositivo, la aplicación monitorea tu actividad a lo largo del día, llevando un registro de los pasos dados. Como usuario, tú puedes ganar un Sweatcoin por cada 1000 pasos registrados. Los usuarios pueden canjear esos tokens y comprar varias cosas como zapatos para correr, relojes digitales, descargar música, bebidas energéticas y mucho más. Mientras más camines, más Sweatcoin puedes ganar.

De acuerdo al libro blanco, Sweatcoin fue creada para incentivar a que las personas se mantengan moviendo, recompensar el movimiento y crear un planeta más saludable. Cualquiera puede ganar y contribuir en la economía Sweat. Originalmente, el SWEAT estaba disponible solo para usuarios elegibles que podían descargar la aplicación Sweatcoin. Para el primer trimestre de 2022, Sweatcoin había crecido a 65 millones de usuarios, un número que llegó a 110 millones en agosto de 2022, y se espera que ese número se incremente aún más.

El token SWEAT solo se puede mintear a través del movimiento verificable. Un número estable de usuarios ayuda a incrementar la entrada (pasos); a medida que más personas se unan a la red, la entrada aumentará exponencialmente. Además, cada nuevo token SWEAT, necesitará más pasos para mintear el token anterior. Esto se alinea con el objetivo de Sweatcoin de hacer el mundo más activo. Cada nuevo token SWEAT, que es más difícil de mintear, no solo actúa como incentivo para que los usuarios se sigan moviendo, sino que también preserva la utilidad del token SWEAT.

Los movimientos de los usuarios son verificados por los validadores del movimiento que actualizan la blockchain. La validación consistente es crucial para garantizar la integridad de los activos subyacentes (SWEAT). Como mencionamos anteriormente, los usuarios pueden ganar un token SWEAT por cada 1000 pasos alcanzados. Los validadores reciben la información del dispositivo del usuario y detectan cualquier movimiento fraudulento a través de un algoritmo, asegurando que solo se registren los movimientos reales.






	

	
	
		
			
				¿En cuál blockchain está establecido el token SWEAT?
			
		

		
					

		
			
			
			
			Ethereum y NEAR
		
			
			Polygon y Cardano
		
			
			Ethereum y Cardano
		
			
			NEAR y Polygon
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planes Futuros Para Sweatcoin
La economía Sweat también cuenta con su propia billetera de criptomonedas, la Sweat Wallet, y también tiene planeado introducir NFTs a su ecosistema. Adicionalmente, hay planes para permitir a los usuarios comprar SWEAT directamente usando moneda fiduciaria para fines del 2022. El equipo ha anunciado también los planes para crear una tienda NFT y hacer que el token SWEAT esté disponible en los exchanges descentralizados. Eventualmente, la gobernanza de la economía Sweat y el token SWEAT, pasará a una organización autónoma descentralizada (DAO). Más adelante, el minteo de Sweatcoin se expandirá a otros tipos de actividades como el ciclismo, la natación, etc.




	

	
	
		
			
				Después del evento de creación de Token, los usuarios pueden mintear SWEAT por
			
		

		
					

		
			
			
			
			Registrar sus primeros 5000 pasos en la aplicación Sweatcoin
		
			
			Registrar sus primeros 1000 pasos en la aplicación Sweatcoin
		
			
			Adquiriendo el token SWEAT directamente
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aprender En Learn Near Club
Learn Near Club (LNC) es una plataforma de inducción práctica, todo incluído, para el Protocolo NEAR, donde puedes aprender como usar y desarrollar en el Protocolo NEAR, además de ganar tokens NEAR. LNC trae una gran cantidad de guías y cursos de inducción. Los usuarios de LNC también ganan nLearns, que son puntos internos que actúan como recompensa para estudiantes destacados. Los usuarios de LNC pueden comenzar a revisar las Guías sobre NEAR, los cursos NEAR o crear su propio NFT (L)Earner.

Ahora que has aprendido sobre SWEAT, puedes revisar la página Learn NEAR Club y (L)Earn (aprender). También puedes repasar la guía de Sweatcoin en LNC junto con otra serie de guías y cursos disponibles en la plataforma.







	

	
	
		
			
				¿Qué puedes hacer con tus Sweatcoins?
			
		

		
					

		
			
			
			
			Comprar ofertas, productos y servicios digitales
		
			
			Ofertar en subastas de alto valor (PlayStation 5, GoPro Hero 9)
		
			
			Dar en caridad como Rescatemos los Niños
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!

### NearKits — что нужно знать

NearKits
Итак, Nearkits — это инструмент для отслеживания портфелей NFT, именно с этого он начинался. Я, например, использовал его бесчисленное количество раз для проверки на этом красном рынке. Nearkits также позволяют использовать службу передачи NFT между кошельками, а затем службу обмена сообщениями NFT, я скоро перейду к этой части.

21.05.22 Nearkits отчеканили свою коллекцию NFT из 333 с разными уровнями, серебром, золотом и рубином,  стоимость монетного двора составляет 10 N. Также отметим, что Nearkits находятся под эгидой Antisocial Studios.




Дорожная карта




Фаза 1
Завершена фаза 1, которая включала место для проверки стоимости вашего портфеля Near NFT в долларах США и NEAR со средней ценой всех NFT, возможность передачи NFT между разными кошельками, возможность отправлять сообщения NFT. Например, вы видите NFT который вы хотите купить, тогда вы можете найти  адрес владельца и отправить сообщение прямо на его кошелек. 

Фаза 2
Это этап чеканки, набор из 333 NFT и различных уровней, называемых картами доступа, что она еще включает в себя:

 	Список пакетных инструментов
 	Инструмент пакетной передачи NFT 
 	Инструмент для пакетных торгов NFT 
 	Торговая площадка и трекер китов 
 	Ссылки на индивидуальную галерею 
 	Боты 
 	Трекер цен NFT на основе редкости

Фаза 3
Итак, после того, как вся фаза 2 была завершена, мы переходим к фазе 3, и что мы получаем:

 	боты на дискорд-сервере 
 	Служба подписки (не держатели) 
 	Протокол запуска NEAR 
 	Инструмент аналитики токенов NEARKits 
 	расширение для браузера




Краткий обзор NFT NearKits








Они напоминают типы карт NFT с доступом разного уровня. Инструменты, стоящие за ними, заставят инвесторов захотеть иметь одну, будет интересно посмотреть как она пойдет на вторичном уровне.

Вот также то, что они делают ежедневно в своем Твиттере, чтобы держать свое сообщество в курсе цен NEAR NFT FP.




Это проект, который пришел в экосистему NEAR с менталитетом создания утилит в первую очередь и предоставлением полезности, которую мы хотим или в которой нуждаемся.

(Отказ от ответственности: я вхожу в их команду в качестве консультанта)
Вывод
Вы можете чеканить или покупать один из вторичных, я надеюсь, что дал вам достаточно информации, чтобы принять решение. Всегда руководствуйтесь своей интуицией.

Ссылки, где их можно найти:

Twitter: https://twitter.com/NearKits_io

NearKits: https://nearkits.io/#my_nfts
Discord: https://discord.gg/wh3GrGhbfB

### Update - October 3, 2022

Brief Summary:

 	
Learn NEAR Club is Top DAPP on NEAR!


Results:

 	
NEARCON 2022: Highlights, Talks and Videos

 	 Read in depth article about (L)Earner NFT. Top tier community creative NFT with utilities that finally makes sense! "What are (L)Earner NFTs?"
 	💸 Over  Ⓝ1,000 were claimed by (L)Earners participated in September Redeem to NEAR window
 	We listened to you and changed minimum LNC membership age for Redeemers to 2 weeks!!!

 	🧑‍🤝‍🧑You are is what in your wallet! Now you can mint LNC referral QR NFT and invite your friends to start using NEAR in a super sexy way!

 	 (L)Earn What is Sweatcoin?

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	✅LNC for NEAR projects is coming!

### Essais de simulation (Rust)

Avant de commencer
Cet article ne montre pas les possibilités qu'un cadre de test de simulation peut faire ; il explique comment créer un cadre de test de simulation MVP pour votre projet. Pour des modifications plus avancées, faites vos propres recherches (DYOR) et consultez quelques liens inclus dans cet article.

REMARQUE : Les tests de simulation deviendront obsolètes à mesure que Sandbox apparaîtra. Consultez workspaces-rs et workspaces-js.
Courte introduction
La différence entre les tests unitaires et les tests de simulation est ; le premier est limité aux tests au sein de la bibliothèque ; tandis que ces derniers simulent un appel de l'extérieur vers l'intérieur. Les tests unitaires testent principalement les cadres internes pour une logique correcte ; tandis que les tests de simulation tentent de simuler les actions de l'utilisateur et de vérifier si les choses se passent comme prévu par le développeur. Traitez chaque fonction comme une simulation.


Si vous fantasmez sur un test, une affirmation, ne le faites pas. Même pour les tests unitaires, on n'est pas d'accord avec une assertion par cadre de fonction de test ; ce qui dit que les tests de simulation nécessitent plus d'une assertion dans une seule fonction/simulation.

Comme d'habitude, l'exemple le plus simple est l'application de salutation; nous allons donc l'utiliser et écrire un test de simulation pour cela.

Test de simulation de salutation
Vous n'avez pas besoin d'écrire votre propre application de salutation: exécutez simplement cette commande:

npx create-near-app --contract=rust <your_project_name>
Voila ! Vous avez maintenant un exemple d'application de salutation avec une interface simple. Suivez les instructions pour déployer le contrat et testez-le jusqu'à ce que vous soyez familier avant de continuer. Vérification des dernières lignes de la sortie.
We suggest that you begin by typing: 
cd <your_project_name>
yarn dev
Copiez la commande et testez le fonctionnement de l'application jusqu'à ce que vous la connaissiez. Après le test, stoppez temporairement le déploiement : c'est assez embêtant de redéployer à chaque fois qu'on fait un ou des petits changement(s) de son point de vue si on n'a pas besoin du frontend.

Créer un dossier de test de simulation
Sans tenir compte de NEAR, les tests de simulation sont également appelés tests d'intégration dans (pur) Rust. Si vous souhaitez en savoir plus, veuillez consulter The Rust Book ou Rust By Example pour savoir comment effectuer des tests d'intégration.

En bref, vous avez besoin d'un dossier entièrement en dehors de src appelé tests. Nous allons donc le faire maintenant. En supposant que vous êtes déjà dans le répertoire de votre projet, exécutez ceci:
cd contract
mkdir tests 
mkdir tests/sim
touch tests/sim/main.rs
Naviguez et ouvrez <your_project_name>/contract/tests/sim/main.rs et ouvrez-le dans l'éditeur de votre choix.

Maintenant, vous pouvez soit tout vider dans un seul fichier, soit le diviser. Généralement, vous avez un utils.rs pour faire des fonctions non test qui sont réutilisées. Vous pouvez avoir un autre fichier .rs pour plusieurs tests courts. Si vous avez des épreuves plus longues, comme les épreuves de simulation du contrat de huis clos, on propose un dossier par épreuve ; et nommez votre fichier en conséquence. Vous ne voudriez pas que vos lecteurs voient un fichier avec plus de 1000 lignes de code.

Maintenant, même si le Greeting n'aurait pas de longs tests de simulation, on va vous montrer ce que l'on entend par un test par fichier en les séparant volontairement. Vous n'êtes pas obligé de le faire, cependant.
Inclure les dépendances
Nous avons besoin d'une bibliothèque appelée near-sdk-sim. Cet exemple utilise le quasi-sdk v3.1.0, nous utiliserons donc le quasi-sdk-sim v3.2.0 correspondant (on ne sait pas pourquoi ils ne correspondent pas, cependant). Gardez à l'esprit, cependant, si la version ne correspond pas, les tests de simulation ne s'exécuteront pas, car il indique Import near_sdk :: some_fn n'est pas égal à near_sdk :: some_fn, ce qui est déroutant (mais en fait near_sdk :: some_fn est en effet différent de near_sdk::some_fn : ils ont des versions différentes !)


On aime en fait écrire avec le quasi-sdk v4.0.0-pre.4, mais cela nécessite quelques modifications du contrat pour qu'il fonctionne. Les changements ne sont pas compliqués, principalement à propos de AccountId n'est plus String et d'autres éléments plus petits ; mais ce n'est pas le but de cet article, nous allons donc nous en tenir à 3.1.0 et peut-être mettre à jour cet article à l'avenir s'il est mis à jour. (De plus, il y a un bug avec la simulation v4 dont nous parlerons plus tard).

Passons à Cargo.toml : il devrait maintenant ressembler à ceci : (voir nouvelle section dev-dependencies). Il est important de s'assurer que rlib est également présent !

[package]
name = "greeter"
version = "0.1.0"
authors = ["Near Inc <hello@near.org>"]
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "3.1.0"

[dev-dependencies]
near-sdk-sim = "3.2.0"

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

[workspace]
members = []

Auparavant, l'un d'entre eux avait rédigé un guide sur la réduction de la taille des contrats ; y compris la suppression de "rlib". Pour utiliser des tests de simulation, cependant, cela nécessite "rlib", c'est donc un compromis entre la taille du contrat et la réalisation de tests de simulation.

Si vous avez arrêté le développement de fils, compilez maintenant le contrat une fois pour télécharger la bibliothèque. En contrat, lancez:

cargo build
Assurez-vous d'avoir beaucoup d'espace disque (espace libre recommandé de 20 Go) car cela prend beaucoup d'espace !

Pour une expérience fluide lors de la première compilation, essayez de compiler sur une machine dotée de 16 vCPU et de 8 Go de RAM. En particulier, librocksdb-sys prendra beaucoup de temps à compiler. Il n'est pas clair si la compilation est transférable (certainement pas à travers le système d'exploitation, mais incertain au sein du même système d'exploitation). Depuis que l'on a loué une VM sur Azure, on pouvait facilement changer la taille temporairement et la changer à une taille plus petite (et moins chère) après la compilation, donc pas de conflit.
Revenons en arrière pour écrire les tests de simulation dans main.rs.

Préparer le fichier wasm
Attention: chaque fois que vous apportez des modifications à votre contrat, vous devez reconstruire le wasm. Nous avons créé un script ici pour créer votre fichier wasm et le déplacer vers le dossier res du répertoire supérieur.

Alors exécutez ceci: (depuis le répertoire du contrat)
mkdir res 
touch build.sh
Ensuite, incluez le contenu ci-dessous dans contract/build.sh afin de pouvoir exécuter bash build.sh (dans le dossier contract) au lieu de taper la commande à chaque fois.
#!/bin/bash 
set -e 

export WASM=greeter.wasm 

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release 
cp target/wasm32-unknown-unknown/release/$WASM res/
Import
C'est facile : nous traitons la bibliothèque comme une bibliothèque. Rappelez-vous, ceux qui sont pub(crate) à l'origine dans la bibliothèque ne peuvent pas être utilisés dans les tests de simulation (puisque c'est à l'extérieur). C'est comme si vous le compiliez et que quelqu'un utilise votre code. Assurez-vous d'importer les fonctions dont vous avez besoin.

Si nous vérifions src.lib.rs, nous voyons qu'il y a (seulement) une structure Welcome. Lorsque vous l'importez, vous ajoutez le mot-clé Contract derrière. Par example:
use greeter::{
    WelcomeContract 
};
Pour le contrat de blocage, leur structure principale s'appelle LockupContract, donc quand ils importent, c'est LockupContractContract. On ne sait pas pourquoi ils l'ont fait de cette façon, peut-être pour le non-conflit ; il suffit de l'ajouter !

Inclure les fichiers de contrat
La prochaine chose avant de tester que cela fonctionne, est d'inclure le fichier wasm. C'est un must. De plus, si vous avez un utils.rs, cela ne devrait PAS y être placé ; sinon, vous devez réfléchir sérieusement à la manière de le rendre détectable à partir d'autres fichiers. Pour ne pas trop réfléchir, on le met dans main.rs:

// Directories are relative to top-level Cargo directory. 
near_sdk_sim::lazy_static_include_bytes! {
      GREETER_WASM_BYTES => "res/greeter.wasm" 
      // other wasm bytes.  
}
Ce que l'on entend par « annuaire de fret de premier niveau », on entend l'annuaire des contrats. Vous pouvez certainement découvrir des choses en dehors avec ../../some_file si vous en avez besoin. Par exemple, si vous n'utilisez pas le res mais le yarn dev, le out/main.wasm est en dehors du répertoire contract. Pour importer cela, nous faisons:
near_sdk_sim::lazy_static_include_bytes! {
     GREETER_WASM_BYTES => "../out/main.wasm" 
}

Puisqu'il s'agit d'une macro, assurez-vous de ne pas mettre accidentellement une "virgule" (","") après le dernier élément ; sinon, vous pourriez recevoir des messages d'erreur bizarres et Rust refuserait de compiler.

Malheureusement, nous n'avons pas pu vraiment tester cette fonction jusqu'à ce que nous ayons créé la fonction d'assistance (un MVP complet) et un test MVP.

Fonction d'initialisation
Pour ne pas répéter la fonction de configuration, nous les incluons dans basic_setup(). Vérifiez basic_setup() du contrat de verrouillage pour un autre exemple (qui inclut le déploiement d'autres contrats que leur contrat de test principal). Ici, nous ferons également la même chose, mais nous n'avons pas d'autre contrat à configurer, nous allons donc ignorer cela et inclure simplement les fonctions nécessaires dans basic_setup().

Créez un fichier utils.rs:
touch tests/sim/utils.rs
Dans utils.rs, nous insérons le contenu:
use crate::*; 

/// 300 TGas 
pub const MAX_GAS: u64 = 300_000_000_000_000; 

/// 1 NEAR (just a random number) 
pub const MIN_BALANCE_FOR_STORAGE: u128 = 1_000_000_000_000_000_000_000_000; 

pub const GREETER_ACCOUNT_ID: &str = "greeter"; 

pub(crate) fn basic_setup() -> (UserAccount, UserAccount) { 
  let mut genesis_config = GenesisConfig::default(); 
  genesis_config.block_prod_time = 0; 
  let root = init_simulator(Some(genesis_config)); 

  let alice = root.create_user( 
    "alice".to_string(), to_yocto("200") 
  ); 

  (root, alice) 
}
Il y a des choses importantes à noter ici. Le premier est ce bloc de code:
let mut genesis_config = GenesisConfig::default(); 
genesis_config.block_prod_time = 0; 
let root = init_simulator(Some(genesis_config));
La Genesis est le premier bloc de la blockchain. Cependant, la genèse et le temps de genèse ne sont pas vraiment les mêmes. Par exemple, la racine représente la blockchain elle-même. Ce n'est pas le compte de niveau supérieur proche ou testnet : c'est la blockchain. Cependant, si vous consultez l'explorateur sur testnet, nous voyons qu'il a été créé pendant la Genèse. Ainsi, la racine vient en premier, puis elle est emballée avec certains des comptes à l'époque de Genesis. Nous créons un simulateur de la Genesis appelé root.

Ici, ce que nous entendons par Genèse n'est pas le temps de la genèse, mais la « racine ultime ». C'est le "compte parent" de tous les comptes de niveau supérieur.

Habituellement, nous n'avons pas besoin de modifier GenesisConfig ; et si vous avez besoin, c'est un exemple.

Si vous avez besoin d'apporter des modifications à la genèse, consultez la documentation pour les valeurs que vous pouvez modifier. Ensuite, vous pouvez le modifier ligne 2 dans le bloc de code ci-dessus en attribuant une valeur à chaque champ. Enfin, vous devez initialiser le simulateur avec init_simulator.

Si vous n'avez pas besoin de modification, vous pouvez initialiser un simulateur sans configuration (qui utilisera la valeur par défaut) comme ceci :
let root = init_simulator(None);
Ensuite, nous avons la racine qui crée un compte appelé "alice" pour nous. Le premier argument est le nom du compte, le second est le nombre de NEAR à donner au compte.


Parce que root est Genesis, il ne peut créer que des comptes de niveau supérieur comme near, testnet, alice. Il ne peut pas créer de sous-comptes comme alice.near : seul le compte parent near peut créer alice.near, pas Genesis.

Une chose que nous n'avons pas ici est le déploiement avec root. Pour notre contrat, nous utilisons le déploiement! macro que nous ferons dans la fonction de test au lieu d'ici. Mais si vous avez un autre fichier wasm, comme le fait le contrat de verrouillage, ils ne peuvent pas utiliser le déploiement ! macro, donc c'est comme ça qu'ils l'ont fait.

Par exemple sur le contrat whitelist ; il est déployé sur root comme ceci:
let _whitelist = root.deploy_and_init( 
  &WHITELIST_WASM_BYTES, 
  STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(), 
  "new", &json!({
    "foundation_account_id": foundation.valid_account_id(), 
  }).to_string().into_bytes(), 
  to_yocto("30"), 
  MAX_GAS, 
);
Parce que l'exigence pour une fonction init d'être appelée une fois pendant le déploiement est si courante, il y a une fonction deploy_and_init. Si le contrat n'a pas de fonction de déploiement (en supposant que la liste blanche n'en ait pas ici), nous pouvons le faire.
let _whitelist = root.deploy(
 &WHITELIST_WASM_BYTES,
 STAKING_POOL_WHITELIST_ACCOUNT_ID.parse().unwrap(),
 to_yocto("30") 
);
et en réalité il n'y a pas de fonction deploy_and_init, nous l'appelons donc manuellement. Pour ce faire, nous avons besoin d'un compte pour l'appeler qui ont la capacité de le faire. Pour le huis clos, c'est la fondation.
let foundation = root.create_user("foundation".to_string(), to_yocto("10000"));
 foundation.call(
   STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(),
   "new", 
   &json!({
      "foundation_account_id": foundation.valid_account_id()
   }).to_string().into_bytes(),
   MAX_GAS,
   NO_DEPOSIT, 
).assert_success();

Nous notons que la réalité et la simulation présentent quelques différences.

Enfin, n'oubliez pas de l'importer dans main.rs et d'importer les fonctions requises:

use near_sdk::Balance;
 use near_sdk_sim::runtime::GenesisConfig;
 use near_sdk_sim::{init_simulator, to_yocto, UserAccount};
 pub(crate) mod utils;
 use utils::*;
Construire la première fonction de test
Nous sommes prêts à créer la première fonction de test. Tout d'abord, importez les fonctions requises dans main.rs:

use near_sdk_sim::{deploy};
Il s'agit de la macro de déploiement.

Créez un fichier pour le test :
touch tests/sim/test_set_and_get_greeting.rs
Comme on vient d'un milieu Python, on aime nommer les fonctions en commençant par test. Vous n'êtes pas obligé. Ici, on adopte de nommer le nom du fichier commençant par test_; tandis que la fonction de test d'action à l'intérieur sans. Par exemple, nous aurons une fonction set_and_get_greeting() dans test_set_and_get_greeting.rs (fichier).

Importez le fichier dans main.rs avant d'oublier :
mod test_set_and_get_greeting;
Nous n'avons pas besoin de pub(crate) comme utils car il n'a pas besoin de partager quoi que ce soit avec d'autres fichiers.

La première chose dont nous avons besoin dans la fonction set_and_get_greeting est de déployer le contrat.
 let greeter_amount = to_yocto("1000");
 let (root, alice) = basic_setup();

 let greeter = deploy!(
   contract: WelcomeContract, 
   contract_id: GREETER_ACCOUNT_ID.to_string(),
   bytes: &GREETER_WASM_BYTES,
   signer_account: root,
   deposit: MIN_BALANCE_FOR_STORAGE + greeter_amount 
);
Si nous avons une méthode personnalisée #[init], nous incluons ces arguments après le dépôt:
gas: MAX_GAS,
 init_method: <method_name>(method_args)
Cependant, si nous n'en avons pas, nous les supprimons. Pour un tas de traits qui correspondent à la macro, consultez la documentation. Vous devez correspondre à au moins l'un d'entre eux ; sinon Rust refuse de compiler.

(Question : l'ordre est-il important ? Ou simplement le groupe de kwargs doit correspondre à l'un des traits ?)

Notez que contrairement à la réalité, le déploiement se fait à nouveau par root (vous pouvez le voir à partir de signer_account). En réalité, c'est fait par un compte qui en est responsable.

Ensuite, définissons une salutation et obtenons la salutation et affirmons qu'ils sont comme prévu.

Il semble que les gens aiment attribuer à une variable un appel res qui est réutilisé maintes et maintes fois. Ce n'est pas le moyen le plus clair; mais nous pouvons sûrement le faire pour ne pas nous casser la tête et penser à des noms de variables. res signifie simplement "résultats" renvoyés par un appel de fonction particulier.

C'est une bonne pratique d'attribuer à votre résolution un type (indépendamment du fait que Rust puisse déduire le type ou non), afin que vous sachiez quel type est renvoyé.

N'oubliez pas que nous avons view_method et change_method dans le contrat intelligent. Pour le contrat déployé avec deploy! (qui est le contrat intelligent que vous pouvez importer et celui que vous testez principalement), nous pouvons utiliser respectivement view_method_call et function_call. Nous parlerons dans un moment si nous avons un savoir externe sur la façon d'appeler.

Notre set_greeting est une change_method, nous allons donc utiliser un function_call. Un function_call prend un PendingContractTx, Gas et Deposit.

Le PendingContractTx n'est que la fonction, et les autres arguments sont faciles à interpréter. Voyons notre set_greeting :
let greeting: String = "Hello, NEAR!".to_owned();
alice.function_call(
  greeter.contract.set_greeting(greeting),
  MAX_GAS, 0 
).assert_success();
Assurez-vous de transmettre les arguments respectifs dans la fonction. Nous appelons également assert_success() à la fin pour nous assurer que la promesse est tenue. Ce qui précède imite le quasi-cli:
near call $GREETER_CONTRACT set_greeting '{
  "message": "Hello, NEAR!"
 }' --gas=$MAX_GAS --amount=0 --accountId=$ALICE_ACCOUNT_ID
Ensuite, nous pouvons avoir l'appel de la fonction de vue. Si vous cochez la fonction, get_greeting prend un identifiant de compte de type chaîne et renvoie une chaîne.
let res: String = alice.view_method_call( 
  greeter.contract.get_greeting(alice.account_id().to_string())
 ).unwrap_json();

On soupçonne que vous n'avez pas besoin de .account_id().to_string(), juste .account_id() est suffisant. Ici, nous le rendons juste explicite parce qu'il prend une chaîne. S'il prend AccountId, nous pourrions simplement appeler .account_id() sans aucune confusion. (Surtout lorsque AccountId n'est plus égal à String commençant près de sdk-rs v4.)

Comme le résultat renvoyé est un JSON, nous le déballons avec unwrap_json().

Ensuite, nous pourrions faire des affirmations sur le résultat.
assert_eq!(res, greeting);
Le message d'accueil de rappel est une variable que nous avons assignée plus tôt, qui est "Hello, NEAR!".

Exécution du test d'intégration
Si vous souhaitez simplement exécuter le test d'intégration, exécutez cargo test --tests sim (car il se trouve dans le dossier tests/sim). Si vous souhaitez exécuter tous les tests, y compris les tests unitaires, exécutez le test de chargement.

Notez que pour une raison quelconque, cela prend environ 30 secondes ou plus (quel que soit le nombre de cœurs de processeur dont vous disposez); vous devez attendre avant même que le test ne commence.

Encore un rappel : si vous apportez des modifications au contrat, vous devez le reconstruire ; sinon, vous vous demanderez pourquoi il ne fonctionne pas et vous pensez qu'il fonctionnera maintenant, alors…
Complete Code
Vous pouvez trouver le code complet ici : https://github.com/Wabinab/NEAR_greeter_integration_testshttps://github.com/Wabinab/NEAR_greeter_integration_tests

Conclusion
Maintenant, vous pouvez répéter d'autres tests (si vous en avez) en créant un nouveau fichier, le lier en utilisant mod à main.rs, écrire les tests à l'intérieur. C'est un exercice amusant : plus vous écrivez, plus vous comprenez.

Remarque sur la mise à niveau vers v4.0.0-pre.4
La fonction deploy_and_init du contrat de liste blanche doit être modifiée:

AccountId n'est plus une chaîne

 	Remplacez donc tous les "alice".to_string() par "alice".parse().unwrap(). Si le remplacement se trouve dans une fonction qu'il ne peut pas analyser, vous devez créer une variable. (Cela est particulièrement vrai dans la macro deploy!, qui n'a pas d'inférence de type).

let alice_account: AccountId = "alice".parse().unwrap(); 

// pass it to the function. 

 	valid_account_id est obsolète. Utilisez plutôt account_id(). Cela se produit dans json!.
 	Tout entier passé à json ! nécessite une spécification. Exemple : la v3.2.0 autorise 10, mais la v4.0.0-pre.4 ne l'autorise pas : vous devez dire 10u64 ou tout autre type.
 	La macro #[quickcheck] a un bogue et échoue au test avec la v4. Un fichier d'erreur sur Github ; au moment de la rédaction, l'équipe de développement ne répond pas encore.

### Flux de données NEAR

Explication vidéo​
Dans la vidéo ci-dessous, nous avons essayé de donner un aperçu rapide du concept principal de la façon dont les données circulent dans la blockchain NEAR Protocol. Vous trouverez une version texte sous la vidéo


Version texte​​






Le flux de données de la blockchain du protocole NEAR peut être un peu délicat en un coup d'œil. Mais c'est assez simple et suit des règles bien définies. Dans cet article, nous allons examiner de plus près comment les données circulent dans la blockchain NEAR Protocol.

En fait, tout flux de blockchain peut être représenté comme une chronologie infinie qui a un début mais n'a pas de fin.





Et un bloc apparaît sur cette chronologie avec un certain intervalle. Chacun de ces blocs contient les informations sur le précédent, créant ainsi une chaîne de blocs.

Le protocole NEAR a une nature fragmentée, ce qui signifie que plusieurs réseaux parallèles, appelés fragments, peuvent être actifs à tout moment. Et chaque fragment produit un morceau d'un bloc à un intervalle donné. Un bloc dans NEAR Blockchain est une collection de blocs de tous les fragments. Block chunk est raccourci en Chunk dans la documentation du protocole NEAR.

Revenons au flux de données lui-même. Le mieux que nous puissions faire est d'imaginer des pistes comme celles que nous pourrions voir dans les applications de montage audio/vidéo. Chaque fragment a son propre ensemble de pistes. La piste du haut est pour Chunks. Ils apparaissent quoi qu'il arrive à un intervalle donné, pour NEAR Blockchain l'intervalle est d'environ une seconde. Des morceaux sont produits même si rien ne se passe sur la blockchain.



Mais qu'entend-on par dire qu'il se passe quelque chose ? Nous voulons dire que quelque chose a déclenché des changements dans la blockchain. Et la méthode la plus connue pour déclencher des changements est d'envoyer une transaction à la blockchain avec des instructions sur ce que nous voulons changer et qui a demandé ces changements.

Une transaction doit être construite, signée et envoyée à la blockchain. Une fois qu'il est exécuté, nous nous attendons à avoir un résultat - ExecutionOutcome. Ah, c'est simple. Mais ce n'est pas vraiment précis pour NEAR Blockchain.



Au début, il y a une transaction, elle contient des instructions que nous voulons exécuter sur la blockchain. La transaction est envoyée à NEAR Blockchain.

Et oui, elle y est exécutée immédiatement MAIS le résultat immédiat de l'exécution de la transaction est toujours juste un accusé de réception qu'elle sera exécutée sur la chaîne ; cette demande d'exécution interne est connue sous le nom de reçu. Vous pouvez considérer le reçu comme une transaction interne qui existe pour transmettre des informations entre les fragments.

Revenons aux pistes pour regarder l'exemple.

En supposant que nous ayons deux comptes vivant sur différents Shards alice.near et bob.near. alice.near crée une transaction pour envoyer quelques jetons à bob.near. La Transaction est immédiatement exécutée et l'ExecutionOutcome de la Transaction est toujours un Reçu.

Mais ce reçu ne peut pas être exécuté ici, car bob.near ne vit pas sur le même fragment qu'alice.near, donc le reçu doit être exécuté sur le fragment du destinataire. Ainsi, le reçu se déplace vers le fragment auquel appartient bob.near.

Sur le fragment de destination, le reçu est exécuté et le processus est considéré comme terminé.


L'EXPLICATION ICI EST SIMPLIFIÉE



Veuillez vous référer à l'article sur le flux de transfert de jetons

Ainsi, le schéma final ressemblera à :




Résumé​​
Nous avons appris les grands principes de la circulation des données dans le protocole NEAR. Nous avons découvert que les transactions s'exécutent et que le résultat d'exécution de la transaction est toujours un reçu.

Nous savons maintenant que le reçu est un atout interne principal pour la blockchain du protocole NEAR et qu'il a le pouvoir de voyager entre les fragments. Nous avons appris le flux de données NEAR sur un exemple simple. Bien sûr, dans la vraie vie, avec des transactions plus complexes, qui impliquent des appels croisés, il y aura plus de reçus et de résultats d'exécution.

Nous espérons que cet article vous sera utile et que vous pourrez créer facilement vos dApps et vos indexeurs en sachant comment les données circulent dans le protocole NEAR.

### Qu'est-ce que Roketo?

‘Alors, qu’est-ce que Roketo exactement ? Pourquoi choisiriez-vous la crypto-monnaie comme mode de paiement ? Et en quoi êtes-vous différent des dizaines d'autres services de paiement cryptographiques? ' - Nous entendons beaucoup ces questions et avons rassemblé nos meilleures réponses dans cet article.
Ci-dessous, nous allons expliquer comment Roketo fonctionne et pourquoi cela changera radicalement votre processus de paiement.
De nombreuses entreprises ont du mal à trouver un moyen de paiement rapide et fiable, surtout si leurs équipes sont réparties sur plusieurs juridictions. Dans ce cas, la crypto-monnaie vous évite les tracas des virements électroniques internationaux qui peuvent prendre du temps et nécessiter des formalités administratives.

Roketo est un service de streaming crypto qui vous permet de payer des personnes et des services à la seconde. La faible commission, la rapidité des transactions et la transparence en font une solution parfaite pour la livraison de la paie. Nos clients utilisent notre service pour payer les employés, envoyer des fonds de subvention de manière transparente, déposer leurs propres jetons et les attribuer à leurs investisseurs. Le streaming en temps réel est également pratique lorsqu'il s'agit de services payants à la minute tels que le parking, la location d'équipement ou le coworking.
Comment ça marche?
Roketo est lié à un portefeuille utilisateur et transmet les fonds aux destinataires en temps réel. Le payeur se connecte avec le portefeuille NEAR, configure un flux, sa durée et d'autres paramètres, entre l'adresse du portefeuille du destinataire, puis commence à diffuser l'argent. Les fonds sont livrés au portefeuille stream du destinataire, qui peut ensuite les retirer pour les convertir.





En quoi est-ce différent des autres solutions du marché?
Faible commission
Roketo est construit sur NEAR et cela nous permet de conserver l'une des commissions les plus basses du marché. Alors que nos concurrents prennent 50$ à 100$ par flux, la configuration de chaque flux de Roketo coûte moins de 1$. En plus de cela, vous devrez payer les frais de gaz pour vos transactions qui, dans l'écosystème NEAR, sont également inférieurs à ceux des autres chaînes de blocs. Juste une comparaison : dans Etherium, le coût par transaction est légèrement supérieur à 1 $ et dans NEAR, il ne coûte que quelques centimes.

Cela signifie qu'avec Roketo, les expéditeurs peuvent configurer efficacement des centaines de flux au coût le plus bas possible et les destinataires peuvent retirer de l'argent aussi souvent qu'ils le souhaitent.
Transactions rapides
Le streaming en temps réel signifie que vos fonds arrivent toutes les secondes à une certaine vitesse et que vos destinataires peuvent les retirer à tout moment. Vous pouvez oublier les heures d'attente dans d'autres services, sans parler des jours où il s'agit d'instruments financiers traditionnels.
Transparence
Nos clients bénéficient d'une transparence totale sur l'allocation des fonds et la livraison de la paie. Même lorsqu'elles effectuent des paiements de masse à leurs investisseurs ou à leur communauté, les entreprises ont toujours un contrôle total sur l'allocation de jetons en temps réel. Chaque flux a une URL unique où vous pouvez suivre la distribution. Il facilite la planification financière, le paiement des impôts et le reporting.
Interface intuitive
Vous n'avez pas besoin de plus d'une minute pour configurer votre premier flux dans Roketo. Chaque option de contrôle de flux peut être consultée et mise à jour facilement à la fois du destinataire et de l'expéditeur sans tiers. Mettez en pause, reprenez, arrêtez, prolongez les flux et obtenez l'historique complet des opérations dans la dApp. L'interface utilisateur est confortable à utiliser même pour les membres de l'équipe sans connaissances en cryptographie.

Récemment, nous avons obtenu 900 000 $ lors du tour de table avec la participation de Move Capital, MetaWeb Ventures et A&T Capital. Cet investissement nous aidera à développer notre produit encore plus rapidement, alors restez à l'écoute pour les nouvelles mises à jour.


Liens:


 	Rejoignez notre communauté sur Twitter
 	Discutez avec nous sur Telegram
 	Rejoignez-nous sur Github
 	Essaie Roketo Protocol
 	Visitez notre Website

### NEAR x Flutter Hola Match Guide

Primera Parte - Contrato Inteligente para conectarnos.



Hola, en esta guía vamos a crear un Hola + Nombre usando el patrón match de RUST, para que nos lo de en diferentes lenguajes.Después usaremos la NEAR-RPC-API para comunicarnos con esta función desde una aplicación multiplataforma hecha en Flutter, demostrando así que podemos llamar esta función desde cualquier dispositivo y así construir sobre NEAR para cualquier plataforma.-La cuarta instalación es VS CODE, pero tu puedes usar tu Editor de Textos/Código favorito”-



Para esto necesitamos tener instalados:



RUST = https://www.rust-lang.org/tools/install



NEAR-CLI = https://docs.near.org/docs/tools/near-cli#mac-and-linux



Flutter = https://docs.flutter.dev/get-started/install



VS CODE = https://code.visualstudio.com/#alt-downloads



Lo primero que haremos es abrir una terminal para crear el proyecto, recomiendo abrir la terminal desde adentro de VS CODE por comodidad, pero puedes usar una externa.



En NEAR creamos los contratos inteligentes con Librerías, no con Binarios, entonces el comando que nos creará un archivo lib en lugar de main será:



cargo new --lib <nombre_de_tu_elección>







En este caso lo llamaré: near_hola_match



El siguiente paso es agregar la dependencia del SDK de NEAR, y unos ajustes para especiales dentro del TOML, ya comenté en el código lo que hace la mayoría de estos ajustes, los ajustes son los siguientes:



[lib]
crate-type = ["cdylib"]
 
[dependencies]
near-sdk = "4.0.0-pre.7"
 
[profile.release]
codegen-units = 1 # Podría mejorar el desempeño, a cambio de ser más lento en compilación.
opt-level = "z" # Optimizaciones de velocidad.
lto = true # Optimizaciones de velocidad.
debug = false # Optimizaciones de velocidad.
panic = "abort" # Detener la ejecución en caso de error.
overflow-checks = true # No permitimos el desbordamiento de ints.







Estamos usando la versión más reciente (Hasta la fecha - 15/04) del SDK de NEAR.



En el archivo lib.rs tendremos una función de ejemplo, la cual vamos a borrar, para construir desde cero nuestro Smart Contract.



Empezaremos escribiendo lo más básico, lo que son la struct del Contrato y la impl del Contrato:He añadido el macro #[near_bindgen] que es propio del NEAR SDK, este incluye todo lo necesario internamente para generar el contrato y sus conexiones.



use near_sdk::{ near_bindgen };
 
#[near_bindgen]
pub struct Contrato {
 
}
 
#[near_bindgen]
impl Contrato {
 
}








Para este ejemplo incluiré una función de inicialización del contrato, y un owner del mismo, aunque no son necesarios para la función Hola Nombre, nos servirán para mostrarte como incluír llamadas View y Call en un contrato, ya que Hola Nombre no modifica el estado de la blockchain, sin embargo la función Call de inicialización si lo hace.



Para esto incluiré unas importaciones más, como son borsh, la cual nos sirve para la serialización y deserialización al momento de comunicarnos con NEAR, al igual que AccountId y PanicOnDefault, las cuales se encargan de revisar que el AccountId tenga un formato válido, y de que en caso de no inicializar el contrato este entre en Pánico, respectivamente.



Además he creado la función de inicialización del contrato, recibe una variable de tipo AccountId, la cual asignará como la owner al momento de inicializar, esta llamada debe hacerse solamente una vez.



use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::{near_bindgen, AccountId, PanicOnDefault};
 
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
pub struct Contrato {
   pub owner_id: AccountId,
}
 
#[near_bindgen]
impl Contrato {
   #[init]
   pub fn new(owner_id: AccountId) -> Self {
       let this = Self { owner_id };
       this
   }
}








Comenzaremos a crear la función que nos devolverá el saludo, dependiendo qué lenguaje queramos:



La función se llamará hello_name, recibe de parámetros el mismo contrato, el nombre para unir al String, y el lenguaje deseado. Ponemos en un patrón match los lenguajes posibles, y hasta abajo un último elemento que será usado como default en caso de no haber match.



   pub fn hello_name(&self, name: String, language: String) -> String {
       match language.as_str() {
           "en" => format!("Hello {}!", name),
           "es" => format!("Hola {}!", name),
           "fr" => format!("Bonjour {}!", name),
           "de" => format!("Hallo {}!", name),
           "it" => format!("Ciao {}!", name),
           "pt" => format!("Olá {}!", name),
           "ru" => format!("Привет {}!", name),
           "zh" => format!("你好 {}!", name),
           "tr" => format!("Merhaba {}!", name),
           "ua" => format!("Привіт {}!", name),
           _ => format!("Hello {}!", name),
       }
   }








Lo siguiente será agregar el target wasm32-unknown-unknown si aun no lo hemos hecho:



rustup target add wasm32-unknown-unknown







Y entonces hagamos el build y veamos si todo va correcto hasta ahora:



cargo build --target wasm32-unknown-unknown --release







Se habrá creado una nueva carpeta, el archivo específico que buscamos es near_hola_match.wasm , y ahí está:







Al principio les dije que era necesario instalar near-cli, y este es el momento en el que nos va a servir.



Primer paso:



near login



Le estaremos dando acceso completo a nuestra cuenta de TESTNET, con esto procederemos a crear una subcuenta y desplegar el contrato.



Segundo paso:



near create-account <subcuenta>.<nuestra_cuenta_de_testnet> --masterAccount <nuestra_cuenta_de_testnet>



Ejemplo:



near create-account contrato1.jeph.testnet --masterAccount jeph.testnet



Este comando no nos dará una frase semilla, sino que almacenará la key directamente en nuestra computadora.



El siguiente comando desplegará el contrato a testnet para que pueda ser accedido por cualquier persona:



near deploy --wasmFile target/wasm32-unknown-unknown/release/<nombre_del_archivo_wasm>.wasm --accountId <nombre_de_la_cuenta>



Ejemplo:



near deploy --wasmFile target/wasm32-unknown-unknown/release/near_hola_match.wasm --accountId contrato1.jeph.testnet







Tx ID



Como vemos se ha desplegado sin problemas, y podemos ver la transacción en el explorador:



Entonces para llamar a la función VIEW usamos:



near view <id_del_contrato> <nombre_de_la_función> '{"name": "<cualquier_nombre>", "language": "<alguno_de_los_lenguajes_que_pusimos>"}'



Ejemplo:



near view contrato1.jeph.testnet hello_name '{"name": "jeph.testnet", "language": "es"}'







Sin embargo nos encontramos con esto, el contrato no ha sido inicializado, y como no quisimos dejar un default, entró en panico, ¿Qué hacemos?, inicializarlo:



Esta será una llamada CALL, no VIEW y entonces le añadimos un parámetro al final –account-id <cuenta_a_la_que_poseamos_acceso>.



Ejemplo:



near call contrato1.jeph.testnet new '{"owner_id": "contrato1.jeph.testnet"}' --account-id contrato1.jeph.testnet







Tx ID



Se ha inicializado con éxito.



Y podemos proceder con la llamada VIEW anterior:



near view contrato1.jeph.testnet hello_name '{"name": "jeph.testnet", "language": "es"}'



(Podemos poner cualquiera de los idiomas, e incluso cambiar el nombre que le mandamos)







Segunda Parte - Conexión Flutter a NEAR



Continuamos con la parte de Flutter, recordemos que este no es un curso de Flutter, sino de como conectar tu aplicación hecha en Flutter y hacer llamadas a los Nodos RPC de NEAR Protocol, por lo que es un requisito el ya tener instalado Flutter.



Crearemos un nuevo proyecto en Flutter con (command + shift + p) o (control + shift + p).







Nos preguntará si será una Aplicación, un Módulo, etc… Elegimos Aplicación.







Elegimos el nombre deseado.







Nos creará un archivo principal muy largo, al cual le he eliminado: 




Todos los comentarios.
La función “increment”.
El body.
El fab (Floating Action Button - Botón Flotante).




Lo único que he agregado es el String “title”, y lo he pasado como argumento en 2 lugares.







Igual tendremos el archivo “pubspec.yaml”, es como el “package.json” de JS/TS, aquí declaramos los paquetes a usar, la versión de la aplicación y varios ajustes más.



En este archivo añadiremos una sola linea, y esto será para añadir un paquete:



“ http: ^0.13.4“.




Este paquete nos servirá para hacer peticiones http sencillas, existen varias un poco más personalizables como DIO, pero para este ejemplo no necesitamos las opciones extras, además de que http suele ser suficiente.




Ojo. Tener cuidado en mantener la misma sangría tal como “flutter” o “cupertino_icons”.







Crearemos un archivo llamado “name_and_language.dart” dentro de una nueva carpeta a la que he llamado “models” dentro de “lib”.







En este archivo crearemos solamente una Clase, para pasar solamente un objeto en las siguientes funciones.







Crearemos un archivo llamado “rpc_fun.dart” dentro de una nueva carpeta a la que llamaré “utils” dentro de “lib”.











En este archivo pondremos la petición hacia el Nodo RPC de NEAR Protocol, que desde ya te menciono que es una petición http de tipo post, por ello lleva 3 requisitos: url, headers y body.



Iniciamos el archivo con las importaciones, necesitamos importar a “convert” para JSON, importar a “math” para crear un id único aleatorio para las peticiones a la blockchain (En este caso no es muy importante que el ID sea único y funcionaría sin ello pero aun así vamos a considerarlo), igual he importado a “foundation” para hacer esta petición en un hilo separado del principal (Dart generalmente corre en un solo hilo, y necesitas Isolates si deseas usar otro) (Para esta petición quizás es innecesario, pero supongamos que algún día decides pedir datos de 100 NFTs a la blockchain, muy seguramente haría que la pantalla de tu usuario se ponga lenta o incluso se detenga por algunos segundos), importamos a http para hacer las peticiones.



De igual manera hasta arriba declaramos las constantes de los headers, la URL del Nodo RPC de Testnet, el nombre del contrato que creamos en la parte 1 de esta guía, el método del contrato al que llamaremos y declaramos la instancia de Random.



Fijate que yo nunca uso “var” para declarar variables, y tu que trabajas con RUST tampoco deberías, además haciendo constantes los valores que no cambias hacemos un poco más rápida la ejecución de la aplicación.







Como bien sabes, las peticiones http llevan igual un body, dicho body lleva:




El nombre del contrato.
El método del contrato.
La finalidad que necesitamos, puede ser optimista o final.
Los argumentos que la función requiere, van en un Mapa, pero convertido a Base64.
El ID de la petición.








Los Nodos RPC nos devuelven muchos datos, pero el que más nos importa es el que se encuentra en “result” (Dentro de otro “result”), pero lo devuelve en forma de buffer (Que es una lista de u8 (números)) que tienen un mensaje que ni tu ni yo podemos entender a simple vista.



(Hay una extensión para que puedas descifrarlo desde tu navegador - RPC Parser (Hecha por mi)).



Pero bueno, nuestra app debe entenderlo, para devolverle su saludo al usuario, y esa función es la siguiente:







Le pasamos una Lista de valores Dinámicos (¿Qué significa eso? - Que solo Dios sabe que tipo de dato está recibiendo), nosotros sabemos que seguramente sean números, pero Dart/Flutter no, y personalmente he experimentado errores, a veces cree que son String, a veces Números y otras simplemente no lo entiende.



Entonces la anterior función pide esa lista dinámica, cada uno de los elementos es convertido a String (Cadena de texto), después borra los espacios en blanco y de último los pasa a Int (Numero), entonces vuelve a generar una lista nueva en la que ya está seguro que son números. Luego convierte esos números a nuestro esperado mensaje.



Pero bueno, para ello necesitamos una respuesta, y para eso necesitamos una petición, la siguiente función hace:




Pasa la URL de String a Uri.
Crea el Mapa con los argumentos.
Pasa los argumentos a Base64 después de pasarlos a utf8 después de pasarlos a json.
Llama a la función que nos genera el body con los datos requeridos y lo pasa a json.
Finalmente realiza la petición http post pasando los tres parámetros que mencioné al principio (url, headers, body).
En caso de que haya respuesta la pasamos a un Mapa.
Llamamos a la función que decodifica el buffer (Y hace más cosas que ya expliqué más arriba).
Y el resultado es nada más y nada menos que el mensaje que esperábamos.








Muy bonito y todo, pero… Son muchos pasos y a lo mejor algún dispositivo presente un bajón de fps, especialmente si tu petición fuera aún más grande.



¿Qué tal si la llamamos a través de otro hilo?







Entonces no llamamos directamente a “fetchRpc” sino a “callFetch”, el cual mandará llamar a “fetchRpc” a través de otro hilo.



Muy bien, ya tenemos lo más difícil, y ahora, ¿En donde lo vemos?,necesitamos una interfaz sencilla que nos deje ingresar un nombre, elegir un idioma y darle click a enviar. Todo eso lo vamos a hacer en el archivo “main.dart”. En la parte de hasta arriba añadiremos 2 “imports”:







(Material ya estaba, solo añadimos “name_and_language.dart” y “rpc_fun.dart”)



No tocaremos la función main ni la clase MyApp, pero en MyHomePage si haremos muchos cambios:



Crearemos un TextEditingController para poder tomar el valor del nombre, una lista de los lenguajes aceptados (Los mismos que pusimos en el Contrato), un simple valor booleano que nos indica que el usuario no ha clickeado, y lo más importante, una nueva instancia de la clase NameAndLanguage que anteriormente creamos… ¿Por qué es final?, Porque a pesar de que los valores internos no son finales, la instancia si lo es.



Inicializamos el TextEditingController en “initState” y nos deshacemos de él en “dispose”.







Después añadiremos un input para que podamos añadir un nombre, un un dropdown para elegir entre los lenguajes posibles (Para ello pasamos la constante accepted), dicho Dropdown no se abrirá si no hemos incluído un nombre, y un botón para realizar la primera petición (Las siguientes se realizarán ni bien se cambie el lenguaje en el dropdown), dicho botón sólo será activado si hemos elegido un lenguaje en el dropdown​.







Aquí he añadido dos “Text”, uno que nos saludará y mostrará nuestro nombre y otro que en caso de no haber elegido un lenguaje nos pedirá que lo ingresemos, y en caso de que ya, nos dirá el lenguaje que hablamos (Hasta acá todavía no enviamos nada a NEAR).







Aquí el usuario ingresa su nombre, este se almacena en la instancia de la clase llamada “nameAndLanguage” y llamamos un “setState”.







En el DropDown elegimos un lenguaje de los que hemos puesto en la lista y llamamos otro “setState”.







Un botón simple para asignar el valor booleano true en “clicked”, ya que solo al ser true llamamos al siguiente “FutureBuilder”.







Este “FutureBuilder” llama a callFetch pasando “nameAndLanguage”, y lo que retorna es mostrado en pantalla, fijate en la velocidad de carga, ¿Bastante rápida una petición al Nodo RPC de NEAR verdad?



¿Quieres verlo en acción?




https://youtube.com/shorts/9r4jmVBZRec?feature=share




¿Quieres ver el código completo?



https://github.com/JuEnPeHa/near_hola_match_flutter/tree/main/lib



	

	
	
		
			
				¿En cuál de las siguientes plataformas podemos construir con NEAR?
			
		

		
					

		
			
			
			
			Web
		
			
			Móvil
		
			
			Escritorio
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Podemos hacer peticiones al Nodo RPC de NEAR para pedir información sobre NFTs y/o FTs?
			
		

		
					

		
			
			
			
			Falso
		
			
			Verdadero
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿En qué formato envíamos el httpBody (O simplemente el Body de la petición) al RPC?
			
		

		
					

		
			
			
			
			List
		
			
			JSON
		
			
			BSON
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	



	
	
		
			
				¿Las peticiones VIEW qué NO modifican el estado de la blockchain (Pero que sí pueden hacer cierto procesamiento) nos cuestan?
			
		

		
					

		
			
			
			
			Falso
		
			
			Verdadero
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








 





 

### Apa itu Sweatcoin? : Penjelasan Singkat

Terima kasih atas kehadiran teknologi blockchain dan cryptocurrency, dunia saat ini tengah melihat perkembangan inovasi pada skala yang sungguh mengejutkan. Salah satu dari inovasi tersebut adalah munculnya Sweatcoin, yakni aplikasi kesehatan dan kebugaran yang cukup terkenal belakangan ini dimana para penggunanya diajak untuk menjalani gaya hidup sehat dengan memberikan berbagai macam hadiah dan insentif. Pada tahun 2022, Sweatcoin telah mengumumkan bahwa mereka akan meluncurkan cryptocurrency mereka sendiri berupa token Sweatcoin yakni SWEAT. Token ini berbasiskan blockchain NEAR dan Ethereum dan akan memiliki kegunaan sebagai insentif untuk mengajak pengguna lebih banyak lagi agar bisa ikut menggunakan aplikasi ini.

Artikel kali ini akan membantu menerangkan konsep dibalik Sweatcoin berikut bagaimana mekanisme kerjanya dan apa saja contoh kegunaannya.




Apa Itu Sweatcoin?
Sweatcoin dapat digambarkan sebagai proyek play-to-earn yang lahir berdasarkan sebuah keyakinan bahwa pergerakan dan gaya hidup yang aktif ternyata juga memiliki nilai di dunia nyata. Sweatcoin menggunakan sistem keuangan terdesentralisasi (DeFi) dan token yang bersifat non-fungible (NFT) untuk membuka nilai yang sepenuhnya dikembalikan kepada pengguna. Sementara itu, DAO memungkinkan pengguna untuk berpartisipasi dalam proses tata kelola (governance), pengembangan, dan pengambilan keputusan dari ekosistem Sweatcoin.

Proyek ini memberi user / pengguna sebuah jalan baru untuk menciptakan nilai (value creation), yang memungkinkan pengguna memperoleh penghasilan melalui gerakan yang direkam di aplikasi. Sweatcoin juga merupakan proyek open-source dimana ini memungkinkan semua orang untuk mengembangkan proyek.

Pada awal mulanya, token Sweatcoin adalah token non-crypto, dimana ketika pengguna yang mengunduh aplikasi telah mencapai sejumlah langkah kaki tertentu, maka mereka akan diberi token Sweatcoin sebagai kompensasi. Pemegang Token ini dapat menukarkannya dengan hadiah dari lembaga maupun perusahaan yang telah bekerjasama seperti Headspace dan Audible. Di sisi lain, pengguna juga dapat menyumbangkan token ini untuk tujuan amal maupun donasi. Secara teori, token Sweatcoin menawarkan beberapa kesamaan dengan cryptocurrency, yang mendorong tim untuk membuat token Sweatcoin (SWEAT)







Token Sweatcoin (SWEAT)
Acara peluncuran token Sweatcoin telah berlangsung pada 12 September lalu. Setelah acara peluncuran token, satu-satunya cara untuk merilis token SWEAT baru adalah melalui pergerakan atau langkah yang dibuat, selanjutnya diverifikasi oleh validator gerakan. Awalnya, SWEAT hanya akan tersedia untuk pengguna Sweatcoin yang memenuhi syarat yang ikut serta. Setelah acara peluncuran token, saldo pengguna Sweatcoin yang sudah ada akan dikonversikan senilai 1:1 dengan token SWEAT. Setelah tanggal 12 September untuk mendapatkan SWEAT menjadi lebih sulit, karena butuh 5000 langkah setiap harinya bagi pengguna untuk bisa mencetak token SWEAT baru. Sementara langkah kaki selanjutnya  akan mencetak Sweatcoin seperti biasa. Jika selanjutnya 1 Sweatcoin akan setara dengan 1000 langkah, maka SWEAT akan menjadi lebih sulit untuk diproduksi seiring berjalannya waktu.










	

	
	
		
			
				Istilah apa yang tepat untuk menggambarkan proyek Sweatcoin?
			
		

		
					

		
			
			
			
			Proyek Play-to-Earn
		
			
			Proyek Move-to-Earn
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Sweatcoin bekerja?


Mari kita pahami bagaimana Sweatcoin dan Sweat Economy berjalan. Aplikasi Sweatcoin secara gratis telah tersedia di Apple App store dan Google Play. Setelah anda mengunduh dan menginstal aplikasi tersebut di perangkat masing-masing, aplikasi akan memantau aktivitas kita sepanjang hari, termasuk melacak jumlah langkah yang diambil. Sebagai pengguna, kita bisa mendapatkan satu token Sweatcoin untuk setiap 1000 langkah yang telah berhasil direkam. Pengguna dapat menukarkan koin ini dan membeli berbagai hal seperti sepatu lari, jam tangan digital, musik, minuman energi, dan masih banyak lagi. Semakin banyak kita bergerak dan berjakan maka semakin banyak Sweatcoin yang bisa kita hasilkan.

Menurut penjelasan dari whitepaper, Sweatcoin dibuat untuk memberi insentif kepada orang-orang agar terus bergerak, menghargai aktivitas gerakan, dan menciptakan dunia yang lebih sehat. Siapa pun dalam Sweat Economy dapat menghasilkan sesuatu dan berkontribusi untuk itu. Pada awalnya, SWEAT hanya tersedia untuk pengguna yang memenuhi syarat yang dapat mengunduh aplikasi Sweatcoin. Pada kuartal pertama (Q1) 2022, Sweatcoin terus berkembang hingga mencapai lebih dari 65 juta pengguna, lalu mencapai 110 juta jumlah pengguna pada Agustus 2022 dan tentunya jumlah ini diperkirakan akan terus bertambah.

Token SWEAT hanya dapat dicetak (mint) melalui gerakan yang dapat diverifikasi. Jumlah pengguna yang stabil membantu meningkatkan input (langkah); karena lebih banyak pengguna bergabung dengan jaringan, input akan meningkat secara eksponensial. Selanjutnya, setiap token SWEAT yang baru akan membutuhkan lebih banyak langkah untuk dibuat daripada token sebelumnya. Ini sejalan dengan tujuan Sweatcoin untuk membuat dunia lebih aktif secara fisik. Melalui setiap token SWEAT baru yang akan semakin sulit untuk dihasilkan, ini tidak hanya bertindak sebagai insentif bagi pengguna untuk terus bergerak tetapi juga mempertahankan utilitas atau kegunaan dari token SWEAT.

Pergerakan dari pengguna akan divalidasi oleh validator pergerakan yang mengupdate blockchain. Validasi yang konsisten sangatlah penting untuk memastikan integritas dari underlying asset (SWEAT). Seperti yang sudah disebutkan sebelumnya, pengguna bisa mendapatkan satu token SWEAT untuk setiap 1000 langkah yang berhasil dicapai. Validator menerima data dari perangkat pengguna dan akan mendeteksi gerakan palsu atau buatan apa pun melalui algoritma, ini dilakukan untuk memastikan bahwa hanya gerakan yang sebenarnya yang akan dicatat (valid).






	

	
	
		
			
				Apa basis blockchain dari token SWEAT?
			
		

		
					

		
			
			
			
			Ethereum dan NEAR
		
			
			Polygon dan Cardano
		
			
			Ethereum dan Cardano
		
			
			NEAR dan Polygon
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Rencana Kedepan untuk Sweatcoin
Sweat Economy  juga telah memiliki dompet kripto (crypto wallet) sendiri, Sweat Wallet, dan juga berencana untuk memperkenalkan NFT ke dalam ekosistemnya. Selain itu, ada rencana yang memungkinkan para pengguna untuk bisa membeli token SWEAT secara langsung menggunakan mata uang fiat pada akhir tahun 2022. Tim juga telah mengumumkan rencana untuk membuat pasar NFT dan membuat token SWEAT tersedia di bursa desentral atau sering disebut DEX / Decentralized Exchange. Selanjutnya, tata kelola Sweat economy dan token SWEAT akan diteruskan ke organisasi desentral otonom (DAO/ Decentralized Autonomous Organization). Pada akhirnya, proses minting / mencetak token Sweatcoin selanjutnya akan diperluas ke metode aktivitas lain seperti bersepeda, berenang, dan lain-lain.




	

	
	
		
			
				Setelah acara Token Generation, pengguna dapat menghasilkan SWEAT token melalui:
			
		

		
					

		
			
			
			
			Mencatatkan 5000 langkah pertama pada aplikasi Sweatcoin
		
			
			Mencatatkan 1000 langkah pertama pada aplikasi Sweatcoin
		
			
			Membeli secara langsung token SWEAT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Belajar di NEAR Club
Learn NEAR Club (LNC) merupakan platform yang inklusif,  orientasi yang mudah dan lengkap untuk protokol NEAR, yakni tempat dimana kamu dapat mempelajari cara menggunakan dan membangun project di protokol NEAR, dan juga mendapatkan token NEAR. LNC menampilkan sejumlah panduan dan pelatihan/ kursus.. Pengguna di LNC juga dapat memperoleh nLearns yang pada dasarnya adalah poin internal dimana ini bertindak sebagai hadiah bagi para pelajar/pengguna yang berprestasi. Pengguna di LNC dapat memulai pelajaran dengan panduan di NEAR Guides, NEAR Courses, atau membuat (L)Earner NFT milikmu sendiri.

Sekarang setelah kamu belajar mengenai token SWEAT, kamu dapat pergi ke Learn NEAR Club, dan hasilkan (L)earn sesuatu!. Kamujuga dapat melihat Panduan dari Sweatcoin yang tersedia di LNC, bersama dengan sejumlah panduan dan kursus lainnya.







	

	
	
		
			
				Apa yang bisa kamu lakukan menggunakan Sweatcoin?
			
		

		
					

		
			
			
			
			Membeli penawaran diskon, produk fisik dan produk digital
		
			
			Berpartisipasi pada lelang produk (PS5, GoPro Hero 9)
		
			
			Berdonasi ke yayasan seperti Save the Children
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!

### Что такое Sweatcoin: краткое руководство

Благодаря технологии блокчейна и криптовалютам мир видит инновации в ошеломляющем масштабе. Одной из таких инноваций является Sweatcoin, популярное приложение для здоровья и фитнеса, которое побуждает пользователей вести более здоровый образ жизни, используя различные вознаграждения в качестве стимула. В 2022 году Sweatcoin объявила о запуске собственной криптовалюты — токена Sweatcoin (SWEAT). Токен основан на блокчейнах NEAR и Ethereum и будет использоваться для привлечения большего числа пользователей в приложение.

Этот гайд поможет понять концепцию Sweatcoin, как она работает и каковы ее варианты использования.




Что такое Sweatcoin?
Sweatcoin можно охарактеризовать как проект, основанный на вере в то, что движение и активный образ жизни могут иметь реальную ценность. Sweatcoin использует децентрализованные финансы (DeFi) и не взаимозаменяемые токены (NFT), чтобы разблокировать ценность, возвращаемую пользователю. DAO позволяет пользователям участвовать в управлении, разработке и процессе принятия решений в экосистеме Sweatcoin.

Проект дает пользователям новую возможность для создания ценности, позволяя пользователям зарабатывать на движениях, записанных в приложении. Sweatcoin также является проектом с открытым исходным кодом, что позволяет каждому дорабатывать проект.

Первоначально токен Sweatcoin был некриптовым токеном, и когда пользователи, загрузившие приложение, прошли определенное количество шагов, им были выданы токены Sweatcoin. Владельцы токенов могут обменять эти токены на вознаграждения от таких организаций, как Headspace и Audible. Кроме того, пользователи могут пожертвовать эти токены на благотворительные цели. Теоретически токен Sweatcoin имеет несколько сходств с криптовалютами, что побудило команду создать токен Sweatcoin (SWEAT).







Токен Sweatcoin (SWEAT)
Событие по генерации токенов Sweatcoin состоялось 12 сентября. После события генерации токенов единственный способ чеканить новые токены SWEAT — это движение, проверенное валидаторами движения. Первоначально SWEAT будет доступен только для соответствующих требованиям пользователей Sweatcoin, которые зарегистрируются. После события генерации токенов текущий баланс пользователей Sweatcoin будет совпадать 1:1 с токенами SWEAT. После 12 числа зарабатывать SWEAT становится сложнее, так как ваши первые 5000 шагов каждый день позволят вам чеканить новый SWEAT, любые другие шаги будут чеканить Sweatcoins, как обычно. 1 Sweatcoin всегда будет равен 1000 шагам, SWEAT станет сложнее чеканить со временем.










	

	
	
		
			
				Какой термин лучше всего описывает Sweatcoin как проект?
			
		

		
					

		
			
			
			
			играй и зарабатывай
		
			
			шагай и зарабатывай
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как работает Sweatcoin?


Давайте разберемся, как работают Sweatcoin и экономика Sweat. Бесплатное приложение Sweatcoin доступно в магазинах Apple App Store и Google Play. Как только вы загрузите и установите приложение на свое устройство, оно отслеживает вашу активность в течение дня, отслеживая количество пройденных шагов. Как пользователь, вы можете зарабатывать один Sweatcoin за каждые 1000 записанных шагов. Пользователи могут использовать эти монеты для покупки различных вещей, таких как кроссовки, цифровые часы, загрузка музыки, энергетические напитки и многое другое. Чем больше вы шагаете, тем больше Sweatcoins вы сможете заработать.

Согласно белой бумаге, Sweatcoin был создан, чтобы стимулировать людей продолжать двигаться, вознаграждать движение и создавать более здоровую планету. Любой участник экономики Sweat может заработать и внести в нее свой вклад. Первоначально SWEAT был доступен только соответствующим пользователям, которые могли загрузить приложение Sweatcoin. К первому кварталу 2022 года количество пользователей Sweatcoin выросло до 65 миллионов, а к августу 2022 года число пользователей достигло 110 миллионов, и ожидается, что это число будет расти и дальше.

Токен SWEAT можно отчеканить только посредством поддающегося проверке движения. Стабильное количество пользователей помогает увеличить ввод (шаги), по мере того, как все больше пользователей присоединяются к сети, вход будет увеличиваться в геометрической прогрессии. Кроме того, для чеканки каждого нового токена SWEAT потребуется больше шагов, чем для предыдущего токена. Это согласуется с целью Sweatcoin сделать мир более физически активным. С каждым новым токеном SWEAT становится все труднее чеканить, он не только стимулирует пользователей продолжать движение, но и сохраняет полезность токена SWEAT.

Движения пользователей проверяются валидаторами движений, которые обновляют блокчейн. Последовательная проверка имеет решающее значение для обеспечения целостности базового актива (SWEAT). Как упоминалось ранее, пользователи могут зарабатывать один токен SWEAT за каждые 1000 пройденных шагов. Валидаторы получают данные с пользовательских устройств и обнаруживают любое мошенническое движение с помощью алгоритма, гарантируя, что будут записаны только истинные движения.






	

	
	
		
			
				Токен SWEAT основан на каких блокчейнах?
			
		

		
					

		
			
			
			
			Ethereum и NEAR
		
			
			Polygon и Cordano
		
			
			Ethereum и Cordano
		
			
			NEAR и Polygon
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Планы на будущее для Sweatcoin
Экономика Sweat имеет собственный крипто-кошелек - Sweat Wallet, а также планирует внедрить NFT в экосистему. Кроме того, к концу 2022 года планируется разрешить пользователям покупать SWEAT напрямую за фиатную валюту. Команда объявила о планах по созданию торговой площадки NFT и размещению токена SWEAT на децентрализованных биржах. В конечном итоге управление экономикой Sweat и SWEAT будет передано децентрализованной автономной организации (DAO). Чеканка Sweatcoin будет распространена на другие виды деятельности, такие как езда на велосипеде, плавание и т. д.




	

	
	
		
			
				После события генерации токена пользователи могут выпускать SWEAT с помощью
			
		

		
					

		
			
			
			
			Регистрация и первые 5000 шагов в приложении Sweatcoin
		
			
			Регистрация и первые 1000 шагов в приложении Sweatcoin
		
			
			покупка Sweat токенов
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Учитесь в NEAR Club
Learn NEAR Club (LNC) — это комплексная практическая платформа для знакомства с протоколом NEAR, где вы можете узнать, как использовать и развивать протокол NEAR, а также зарабатывать токены NEAR. LNC предлагает множество гайдов и курсов по адаптации. Пользователи LNC также могут зарабатывать nLearns, которые в основном представляют собой внутренние баллы, которые служат наградой для выдающихся учеников. Пользователи LNC могут начать с гайдов NEAR, курсов NEAR или создать собственный (L)Earner NFT.

Теперь, когда вы узнали что такое SWEAT, вы можете перейти в клуб Learn NEAR и учиться. Вы также можете ознакомиться с гайдом Sweatcoin, доступным на LNC, а также множеством других гайдов и курсов.







	

	
	
		
			
				Что вы можете сделать со своими Sweatcoins?
			
		

		
					

		
			
			
			
			покупать продукты и цифровые предложения
		
			
			делать ставки на аукционах (PS5, Go Pro Hero 9)
		
			
			жертвовать на благотворительность
		
			
			все вместе взятое
		
	
		

		
		
			
				Correct!
				Wrong!

### O que é Sweatcoin: uma breve introdução

Graças à tecnologia blockchain e criptomoedas, o mundo está vendo a inovação em uma escala impressionante. Uma dessas inovações é o Sweatcoin, um aplicativo de saúde e condicionamento físico de primeira linha que incentiva os usuários a adotar um estilo de vida mais saudável usando várias recompensas como incentivo. Em 2022, a Sweatcoin anunciou que lançaria sua própria criptomoeda, o token Sweatcoin (SWEAT). O token é baseado nas blockchains NEAR e Ethereum e será utilizado como incentivo para atrair mais usuários para o aplicativo.

Este post ajudará a entender o conceito por trás do Sweatcoin, como ele funciona e quais são seus vários casos de uso.




O que é Sweatcoin?
Sweatcoin pode ser descrito como um projeto de jogar para ganhar, baseado na crença de que o movimento e um estilo de vida ativo podem ter valor real. A Sweatcoin utiliza finanças descentralizadas ( DeFi ) e tokens não fungíveis (NFTs) para desbloquear o valor que é devolvido ao usuário. Enquanto isso, a DAO permite que os usuários participem do processo de governança, desenvolvimento e tomada de decisão do ecossistema Sweatcoin.

O projeto oferece aos usuários um novo caminho para a criação de valor, permitindo que os usuários ganhem com os movimentos registrados no aplicativo. Sweatcoin também é um projeto de código aberto, permitindo que qualquer pessoa possa avançar o projeto.

Inicialmente, o token Sweatcoin era um token não criptográfico, e quando os usuários que baixavam o aplicativo e atingiam um número especificado de passos, recebiam tokens Sweatcoin. Os detentores de tokens podem resgatar esses tokens por recompensas de organizações como Headspace e Audible. Alternativamente, os usuários também podem doar esses tokens para causas de caridade. Em teoria, o token Sweatcoin oferece várias semelhanças com as criptomoedas, o que levou a equipe a criar o token Sweatcoin (SWEAT)







O token Sweatcoin (SWEAT)
O evento de geração de tokens da Sweatcoin ocorreu no dia 12 de setembro. Após o evento de geração de token, a única maneira de cunhar novos tokens SWEAT é por meio de movimento, verificado por validadores de movimento. Inicialmente, o SWEAT estará disponível apenas para usuários qualificados do Sweatcoin que optarem por participar. Após o evento de geração do token, o saldo atual do Sweatcoin dos usuários será correspondido 1:1 com os tokens SWEAT. Após o dia 12, ganhar SWEAT se torna mais complicado, pois seus primeiros 5.000 passos por dia permitiriam que você cunhasse um novo SWEAT, enquanto quaisquer outros passos cunhariam Sweatcoins como de costume. Enquanto 1 Sweatcoin sempre será igual a 1000 passos, SWEAT se tornará mais difícil de cunhar com o passar do tempo.










	

	
	
		
			
				Qual termo melhor descreve o Sweatcoin como um projeto?
			
		

		
					

		
			
			
			
			Projeto Jogue para Ganhar
		
			
			Projeto Mova-se para Ganhar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como funciona o Sweatcoin?


Vamos entender como o Sweatcoin e a economia do Sweat funcionam. O aplicativo Sweatcoin gratuito está disponível na Apple App Store e no Google Play. Depois de baixar e instalar o aplicativo no seu dispositivo, o aplicativo monitora sua atividade ao longo do dia, rastreando o número de passos realizados. Como usuário, você pode ganhar um Sweatcoin para cada 1.000 passos registrados. Os usuários podem resgatar essas moedas e comprar várias coisas, como tênis de corrida, relógios digitais, downloads de música, bebidas energéticas e muito mais. Quanto mais você anda, mais Sweatcoins você ganha.

De acordo com o whitepaper, o Sweatcoin foi criado para incentivar as pessoas a continuarem em movimento, recompensar o movimento e criar um planeta mais saudável. Qualquer pessoa na economia Sweat pode ganhar e contribuir para isso. Inicialmente, o SWEAT estava disponível apenas para usuários qualificados que podiam baixar o aplicativo Sweatcoin. No primeiro trimestre de 2022, o Sweatcoin havia crescido para 65 milhões de usuários, número que atingiu 110 milhões de usuários em agosto de 2022, com expectativa de crescimento ainda maior.

O token SWEAT pode ser cunhado apenas por meio de movimento verificável. Um número estável de usuários ajuda a aumentar a entrada (passos); à medida que mais usuários se juntam à rede, a entrada aumentaria exponencialmente. Além disso, cada novo token SWEAT exigiria mais passos para cunhar do que o token anterior. Isso se alinha com o objetivo da Sweatcoin de tornar o mundo mais fisicamente ativo. Com cada novo token SWEAT cada vez mais difícil de cunhar, ele não apenas atua como um incentivo para os usuários continuarem em movimento, mas também preserva a utilidade do token SWEAT.

Os movimentos do usuário são validados por validadores de movimento que atualizam a blockchain. A validação consistente é fundamental para garantir a integridade do ativo subjacente (SWEAT). Como mencionado anteriormente, os usuários podem ganhar um token SWEAT para cada 1.000 passos alcançados. Os validadores recebem dados dos dispositivos do usuário e detectam qualquer movimento fraudulento por meio de um algoritmo, garantindo que apenas movimentos verdadeiros sejam registrados.






	

	
	
		
			
				O token SWEAT é baseado em quais blockchains?
			
		

		
					

		
			
			
			
			Ethereum e Near
		
			
			Polygon e Cardano
		
			
			Ethereum e Cardano
		
			
			Near e Polygon
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Planos futuros para Sweatcoin
A economia Sweat também tem sua própria carteira de criptomoedas, a Sweat Wallet, e também planeja introduzir NFTs no ecossistema. Além disso, existem planos para permitir que os usuários comprem SWEAT diretamente usando moeda fiduciária até o final de 2022. A equipe também anunciou planos para criar um mercado NFT e disponibilizar o token SWEAT em exchanges descentralizadas. Eventualmente, a governança da economia Sweat e SWEAT será passada para uma organização autônoma descentralizada (DAO). Eventualmente, a cunhagem de Sweatcoin será expandida para outros métodos de atividades como ciclismo, natação, etc.




	

	
	
		
			
				Após o evento de geração de token, os usuários podem cunhar SWEAT
			
		

		
					

		
			
			
			
			Registrando os primeiros 5000 passos no Aplicativo Sweatcoin
		
			
			Registrando os primeiros 1000 passos no Aplicativo Sweatcoin
		
			
			Comprando o token Sweat diretamente
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aprenda no Clube NEAR
O Learn NEAR Club (LNC) é uma plataforma de integração prática e completa para o protocolo NEAR , onde você pode aprender como usar e construir no protocolo NEAR, e ganhar tokens NEAR. O LNC apresenta uma série de guias e cursos de integração. Os usuários do LNC também podem ganhar nLearns, que são basicamente pontos internos, que agem como uma recompensa para alunos excelentes. Os usuários do LNC podem começar com NEAR Guides, NEAR Courses ou criar seu próprio (L)Earner NFT. 

Agora que você aprendeu a SWEAT, você pode ir para o Learn NEAR Club e (L)Earn. Você também pode conferir o Guia Sweatcoin disponível no LNC, juntamente com uma série de outros guias e cursos.







	

	
	
		
			
				O que você pode fazer com suas Sweatcoins?
			
		

		
					

		
			
			
			
			Compre ofertas e produtos originais
		
			
			Dê lances em leilões de alto valor (Play Station 5, GoPro Hero 9)
		
			
			Doe para instituições de caridade como Sve the Children
		
			
			Todos acima
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Portefeuilles

Un guide des portefeuilles NEAR 
Sur le marché actuel de la cryptographie, Ethereum est la plate-forme de choix pour les applications décentralisées, les contrats intelligents et la finance décentralisée. Cependant, Ethereum a plusieurs problèmes qui constituent un obstacle, tels que des frais de gas élevés et des problèmes importants liés à l'évolutivité. Ainsi, alors qu'Ethereum peut être Numero Uno, plusieurs autres protocoles émergent pour défier Ethereum sur le marché.

Le protocole NEAR est l'une des chaînes de blocs qui est devenue un véritable challenger de la domination d'Ethereum dans l'espace. L'équipe de NEAR a examiné les lacunes d'Ethereum et a créé un protocole qui va directement à sa lacune la plus flagrante, son manque d'évolutivité et ses frais de gas élevés. NEAR utilise un processus appelé sharding, permettant au protocole d'évoluer de manière exponentielle. NEAR a également réussi à lever des fonds importants auprès de certains des plus grands investisseurs en capital-risque, notamment a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital et plusieurs autres. Dans ce guide, nous examinerons NEAR, et en particulier le portefeuille NEAR.
Le protocole NEAR 
Fondé en 2018, le protocole NEAR est une plate-forme de développement décentralisée conçue pour créer un environnement transparent et presque parfait pour les applications décentralisées (dApps) et les contrats intelligents. NEAR a été créé après avoir analysé les lacunes des protocoles existants, notamment Ethereum. Le protocole se concentre sur la résolution de ces problèmes et cherche à devenir la plate-forme de référence pour les applications décentralisées et la finance décentralisée. L'utilisation du sharding par NEAR permet au protocole d'évoluer de manière exponentielle, en résolvant les problèmes d'évolutivité répandus dans l'espace.

La blockchain Proof-of-Stake de NEAR est extrêmement conviviale pour les développeurs, car elle est peu coûteuse et hautement évolutive, et les développeurs peuvent créer de manière transparente des applications décentralisées. Le protocole NEAR possède également plusieurs autres fonctionnalités, telles que le portefeuille NEAR et d'autres composants. Dans cet article, nous nous concentrerons sur le portefeuille NEAR, mais nous en reparlerons un peu plus tard. NEAR utilise également Doomslug, permettant aux blocs d'atteindre la finalité en quelques secondes. D'autres blockchains centralisent généralement le traitement, limitant sa convivialité à du matériel très haut de gamme. Bien que cette approche augmente le débit, elle ne le fait que temporairement. NEAR est capable d'évoluer de manière linéaire, prenant en charge des milliards de transactions de manière décentralisée.

NEAR a été créé par le Collectif NEAR, une communauté de chercheurs et de développeurs. L'objectif du collectif NEAR est le développement et l'amélioration continus du protocole. Le collectif a également travaillé sur le code initial du protocole NEAR et la mise en œuvre du réseau NEAR. Alors que le Collectif NEAR est à l'origine du développement du Protocole NEAR, ce dernier fonctionne de manière totalement indépendante et est entièrement décentralisé, même le Collectif NEAR étant incapable de le fermer.
Avantages du protocole NEAR 

 	Les utilisateurs de NEAR n'ont pas besoin d'extensions de navigateur ou de clés compliquées pour s'inscrire. Un simple email et un mot de passe suffisent pour s'inscrire.
 	Les contrats intelligents NEAR sont compatibles avec WebAssembly Virtual Machine (WASM).
 	Le protocole permet aux développeurs de déployer des applications blockchain évolutives et performantes.
 	Une fraction des frais de gas par rapport à d'autres comme Ethereum.

Qu'est-ce qu'un portefeuille cryptographique
Avant de passer au portefeuille NEAR, il est essentiel de comprendre ce qu'est un portefeuille. En termes simples, les portefeuilles cryptographiques stockent en toute sécurité vos clés privées, garantissant que votre crypto-monnaie est sûre et accessible. Vous pouvez également utiliser des portefeuilles cryptographiques pour effectuer des transactions, envoyer et recevoir de la crypto-monnaie, ou même dépenser votre crypto. Lors de la sélection d'un portefeuille crypto, vous avez le choix entre plusieurs options. Il s'agit de portefeuilles papier, de portefeuilles matériels et de portefeuilles en ligne.
Portefeuilles chauds
Les portefeuilles chauds sont des portefeuilles en ligne qui permettent aux utilisateurs de transférer rapidement leur crypto. La plupart des échanges en ligne ont leurs propres portefeuilles auxquels les utilisateurs peuvent accéder. Les portefeuilles chauds sont faciles d'accès via un mobile ou un ordinateur de bureau. Alors que les portefeuilles chauds offrent une connectivité facile, ils sont également exposés à des menaces telles que le piratage. Les portefeuilles de bureau, les portefeuilles en ligne et les portefeuilles mobiles sont des exemples de portefeuilles chauds.
Portefeuilles froids
Un portefeuille froid ou portefeuille matériel est un appareil similaire à un périphérique USB où les utilisateurs peuvent stocker leurs clés. Le portefeuille est portable et peut être connecté à un ordinateur portable/de bureau chaque fois que l'utilisateur souhaite accéder à sa crypto. Les portefeuilles matériels sont beaucoup moins sujets aux menaces telles que le piratage ou toute autre attaque malveillante qui pourrait se produire en ligne.
Portefeuilles en papier
Un portefeuille en papier est essentiellement une feuille de papier imprimée contenant votre clé publique et votre clé privée. Les clés sont accessibles uniquement via un code QR. Les portefeuilles en papier sont utilisés pour stocker une quantité importante de crypto-monnaie car ils sont considérés comme extrêmement sûrs.
Le portefeuille NEAR
Les développeurs du protocole NEAR ont développé une application de portefeuille pratique pour les jetons NEAR. Le portefeuille est un portefeuille intégré au navigateur et basé sur le Web que les utilisateurs peuvent utiliser le portefeuille NEAR pour créer et interagir avec d'autres comptes NEAR. Le portefeuille est également nécessaire pour interagir avec le protocole NEAR. Le portefeuille est utilisé pour stocker les jetons NEAR et les normes de jetons NEP21, qui sont pris en charge sur la blockchain NEAR. Le portefeuille permet aux utilisateurs d'envoyer ou de recevoir des jetons NEP21 et NEAR et d'interagir avec des applications sur le protocole. Lors de l'utilisation du portefeuille NEAR, il est essentiel de se souvenir des informations suivantes.

Un différenciateur clé pour les comptes NEAR est que NEAR utilise des comptes lisibles par l'homme, et non un hachage. Ainsi, un compte sur NEAR ne se lirait pas comme 0x71C7656EC7ab88b098defB751B7401B5f6d8976F mais comme alice.near ou bob.near. Les comptes NEAR peuvent également créer des sous-comptes, mais seul le compte racine peut les créer. Un autre différenciateur critique est que la plupart des blockchains ont une paire de clés publique/privée pour chaque compte. Sur NEAR, les comptes peuvent être associés à plusieurs paires de clés. Celles-ci sont appelées "clés d'accès". Les clés d'accès sont de deux types, une clé d'accès complet et un appel fonctionnel. Une clé d'accès complet accorde à l'utilisateur le contrôle total de son compte NEAR. D'autre part, l'appel fonctionnel permet la signature de transactions non monétaires.

Adresse du portefeuille - L'adresse du portefeuille est essentiellement une séquence de caractères ou de chiffres ou les deux qui sont utilisés pour envoyer ou recevoir des jetons à l'aide du portefeuille NEAR.

Clé privée et phrase secrète – La phrase secrète et la clé de sécurité sont un type de mot de passe. La phrase secrète comprend 12 mots, tandis que la clé privée consiste en une séquence de lettres et de chiffres. Les deux sont des étapes extrêmement importantes en matière de récupération de portefeuille.
Créer un portefeuille NEAR
Le portefeuille NEAR permet aux utilisateurs d'envoyer et de recevoir des jetons NEAR et de miser leurs jetons NEAR. Cependant, vous devez créer un portefeuille sur NEAR pour accéder à ces fonctionnalités. Commençons.

 	La première étape consiste à aller sur https://wallet.near.org/. Une fois sur cette page, vous aurez deux options, Créer un compte ou Importer un compte existant. Nous irons avec la première option.



 	Une fois que vous avez cliqué sur "créer un identifiant", vous devez créer un nom de compte. Créez votre nom de compte et si le nom est disponible, cliquez sur "Réserver mon identifiant de compte".



 	L'étape suivante consiste à choisir comment restaurer l'accès à votre compte. Il existe trois méthodes de récupération à considérer. Vous pouvez utiliser une phrase de départ, connecter un portefeuille matériel de grand livre ou envoyer un e-mail. Le protocole recommande de choisir une phrase de départ ou de connecter un portefeuille matériel de grand livre, car ceux-ci sont plus sécurisés que la sécurisation de votre compte par e-mail. Nous allons sélectionner "Secure Passphrase" dans cet exemple et continuer.



 

 

 	Il est fortement recommandé d'utiliser le grand livre Nano S ou X. L'utilisation du grand livre garantit que vos clés privées sont stockées en toute sécurité dans votre grand livre. Le Ledger offre le plus haut niveau de sécurité lors de l'utilisation du portefeuille NEAR. La configuration de votre grand livre est simple, il vous suffit de télécharger Ledger Live et de mettre à jour le micrologiciel. Pour installer l'application NEAR Ledger, ouvrez l'application Ledger Live, accédez à Paramètres et cliquez sur Fonctionnalités expérimentales. De là, vous pourrez activer le mode développeur. Une fois cette étape terminée, sélectionnez Manager, Rechercher NEAR et cliquez sur Installer.
 	Une fois que vous avez cliqué sur Secure Passphrase », une phrase de départ apparaîtra à l'écran, contenant 12 mots mnémoniques. Vous devez stocker ces mots en toute sécurité, et la meilleure façon de le faire est simplement de les écrire dans un livre ou une feuille de papier et de les stocker dans un endroit sûr. Veuillez NE PAS prendre de capture d'écran et enregistrer la phrase ou la stocker sur un support en ligne. Votre phrase de départ est pour vous seul.



 	Confirmez et vérifiez que vous avez correctement saisi la phrase de départ et terminé le processus de configuration.
 	Une fois que vous avez terminé de vérifier votre phrase de départ, vous serez redirigé vers l'écran "Financer votre compte". Ce processus est nécessaire pour obtenir l'ID que vous avez sélectionné précédemment. Il existe plusieurs façons d'approvisionner votre compte. Vous pouvez soit le faire vous-même en accédant à votre compte d'échange et en envoyant NEAR à l'adresse de financement unique. Vous pouvez également approvisionner votre compte en utilisant Moonpay ou demander à un ami qui a NEAR d'envoyer 1 NEAR à votre adresse temporaire. Une fois la transaction confirmée, votre dépôt initial sera reflété dans le portefeuille.



 	Maintenant que votre compte est financé avec succès, cliquez sur "Continuer vers le compte" et vous serez redirigé vers l'interface d'accueil de votre portefeuille.

Une fois votre compte créé, il est recommandé d'activer 2FA. Cette étape est essentielle car elle augmente considérablement la sécurité de votre compte de portefeuille NEAR.
Création de compte avec grand livre (Ledger)
Voyons comment vous pouvez créer un compte à l'aide d'un appareil Ledger.

 	Allez sur wallet.testnet.near.org et sélectionnez "Créer un compte".
 	Utilisez la même étape décrite dans la méthode précédente et réservez un ID de compte. Une fois que vous avez entré votre identifiant, cliquez sur "Créer le compte".
 	Ensuite, vous devrez choisir votre méthode de sécurité. C'est là que la création de compte est différente car vous utiliserez votre appareil Ledger. Ainsi, au lieu de "Recovery Phrase", sélectionnez le "Ledger Nano S ou X".



 	Après avoir sélectionné l'option Ledger, appuyez sur "continuer" et vous serez invité à connecter votre appareil de grand livre.



 	Une fois que vous avez connecté votre appareil Ledger, déverrouillez-le. Si l'application NEAR est installée, sélectionnez-la. Votre appareil Ledger indiquera "Pending Ledger Review". Cliquez sur les deux boutons en haut de l'appareil et votre appareil vous invitera à "Utiliser le portefeuille pour afficher les comptes". Une fois que ce message apparaît, vous pouvez continuer et cliquer sur "Continuer".
 	Une fois que vous avez cliqué sur Continuer, la clé publique apparaîtra sur votre écran Ledger. Approuvez la clé publique et confirmez l'opération sur le Ledger.
 	Ensuite, vous serez invité à ajouter une clé sur votre portefeuille Ledger. Une fois que vous avez cliqué sur "Approuver" sur le grand livre. Une fois l'opération validée, votre compte a été créé avec succès.


Staking à l'aide du portefeuille NEAR 
Le réseau NEAR est géré par des utilisateurs qui exploitent des nœuds, appelés validateurs. La communauté NEAR soutient les validateurs via le jalonnement. Les validateurs conservent un montant minimum misé, ce qui leur permet de rester en tant que validateurs. Les détenteurs de jetons NEAR peuvent miser avec n'importe quel validateur de leur choix, ce qui leur permet de gagner des récompenses du réseau. Le portefeuille NEAR possède une interface utilisateur de jalonnement intégrée directement dans l'application Web.

Comprenons comment miser en utilisant le portefeuille NEAR. Le jalonnement à l'aide du portefeuille NEAR est un processus assez simple et comprend les étapes suivantes.

 	Sélectionnez l'option d'implantation dans la barre de navigation. Si vous êtes sur mobile, vous trouverez l'option dans votre menu déroulant.
 	Sélectionnez le bouton qui dit "Staking Validator".
 	Sélectionnez le valideur de votre choix dans la liste des validateurs. N'oubliez pas, en tant que détenteur de jeton NEAR ; vous pouvez miser avec n'importe quel validateur de votre choix.
 	Une fois que vous avez confirmé votre choix, vous pouvez sélectionner "Stake with Validator".
 	Une fois que vous aurez cliqué sur "Stake with Validator", vous serez invité à entrer le nombre de jetons NEAR que vous souhaitez miser. Une fois que vous avez entré le nombre de jetons, cliquez sur « Submit Stake ».

Pour terminer le processus de jalonnement, vous devez confirmer deux transactions : une transaction pour sélectionner le validateur et l'autre pour déposer et jalonner avec le validateur sélectionné.
Annuler votre Staking
Le détachement de votre mise est extrêmement simple. Accédez simplement au tableau de bord de jalonnement et sélectionnez le validateur que vous avez choisi. Une fois sélectionné, cliquez sur « Unstake » et validez. Vous ne pourrez accéder et retirer votre mise qu'après 36 à 48 heures. Pour retirer votre participation, rendez-vous simplement sur la page du validateur et cliquez sur « Retirer ».
Surveiller les informations de Staking
L'interface du portefeuille NEAR vous permet de choisir des validateurs et vous permet également de visualiser des informations telles que

 	Le montant total staké - Cela vous permet de voir le nombre total de jetons NEAR avec des validateurs qui accumulent des récompenses.
 	Récompenses non réclamées - Ce sont des récompenses qui ont été gagnées mais qui n'ont pas été retirées du pool de mise. Ces récompenses non réclamées sont automatiquement mises à nouveau, augmentant le montant total misé et les récompenses composées.
 	Jetons de retrait – Ce sont des jetons qui ont été débloqués et qui sont prêts à être retirés.
 	Jetons en attente de publication - Ces jetons non jalonnés attendent toujours que la fenêtre de 36 à 48 heures se soit écoulée.

Frais de validateur - Les frais de validateur sont payés aux validateurs pour miser en votre nom. Les frais du validateur sont facturés sur les récompenses gagnées et non sur le solde du jeton misé sur les validateurs
Connecter votre portefeuille NEAR à une dApp sur NEAR
Connecter votre portefeuille NEAR à une application décentralisée sur NEAR est extrêmement simple. Vous devez vous rendre sur Awesome NEAR et choisir l'une des nombreuses dApps disponibles. Cliquez sur l'application souhaitée, et vous verrez une option pour "Se connecter avec NEAR Wallet" sur l'interface. Une fois que vous aurez cliqué, vous recevrez un message sur votre écran indiquant que la dApp demande l'autorisation d'accéder à votre compte. Cliquez sur "Autoriser" et la dApp sera automatiquement connectée à la dApp.
Autres portefeuilles pris en charge par NEAR
Trust Wallet

MyNearWallet est un portefeuille Web qui permet aux utilisateurs de stocker et de miser en toute sécurité des jetons NEAR et des actifs compatibles. C'est le successeur officiel de l'héritage NEAR Wallet. MyNearWallet propose également des swaps wNEAR et USN, ainsi que des moyens d'acheter NEAR.
Trust Wallet
Le Trust Wallet est un portefeuille non dépositaire et décentralisé qui permet aux utilisateurs de stocker leurs crypto-monnaies. Les actifs sont stockés dans une adresse numérique accessible uniquement par l'utilisateur, ce qui en fait un moyen sûr et efficace de stocker des actifs numériques. Le portefeuille Trust met l'accent sur la simplicité et la facilité d'utilisation. Le portefeuille est un portefeuille multi-devises open source, piloté par la communauté, capable de stocker presque toutes les crypto-monnaies. Il offre aux utilisateurs un moyen pratique de gérer leurs crypto-monnaies et leur permet de contrôler complètement leurs clés privées.



Le portefeuille a été acquis par Binance et est le portefeuille officiel de la bourse Binance. Le portefeuille permet aux utilisateurs de conserver le contrôle total de leurs actifs et de leurs clés privées stockées sur l'appareil de l'utilisateur. Les développeurs peuvent également créer des dApps, sans aucune complication telle que des détails de mise en œuvre de bas niveau. Le portefeuille prend également en charge le jalonnement sur portefeuille, ce qui signifie que les utilisateurs peuvent gagner des récompenses sur tous les jetons de preuve de participation ou de preuve de participation déléguée pris en charge. Trust Wallet permet aux utilisateurs de gagner des récompenses et ajoute continuellement plus de stablecoins et de crypto-monnaies.
Création de votre Trust wallet
La création de votre portefeuille à l'aide de Trust Wallet est un processus simple.

 	Accédez au site Web officiel du Trust Wallet.
 	Téléchargez et installez l'application, ouvrez l'application et sélectionnez "Créer un nouveau portefeuille".



 	L'étape suivante consiste à enregistrer votre phrase de départ. Écrivez votre phrase de départ de 12 mots et assurez-vous d'écrire les mots dans l'ordre exact.
 	Et c'est tout. Votre Trust Wallet a été créé.

Réflexions finales
L'écosystème de NEAR permet aux utilisateurs d'accéder à une multitude de NFT, d'applications décentralisées et de solutions DeFi. NEAR corrige les lacunes des chaînes de blocs telles qu'Ethereum, offrant des solutions à des problèmes de longue date tels que la congestion du réseau, les frais de gas élevés et les frais de traitement lents. Le portefeuille NEAR permet aux utilisateurs de créer et d'interagir avec des comptes NEAR, permettant aux utilisateurs de stocker leurs jetons NEAR et de les miser pour gagner des récompenses. Nous espérons que ce guide apportera des éclaircissements sur le fonctionnement du portefeuille NEAR et ses cas d'utilisation.

### Meilleures pratiques de cryptographie : conseils pour une expérience de cryptographie transparente

L'espace de crypto-monnaie peut être quelque peu écrasant, même pour les têtes les plus expérimentées. À mesure que la crypto gagne en popularité, les risques pour vos actifs augmentent également de manière exponentielle. Les investisseurs en crypto sont de plus en plus préoccupés par la sécurité de leurs investissements et de leurs actifs. Alors que les crypto-actifs et les crypto-monnaies sont sécurisés par les plateformes sur lesquelles ils sont échangés, les investisseurs et les utilisateurs de ces bourses doivent être plus proactifs lors de la sécurisation de leurs actifs numériques.

Il est impératif que les utilisateurs aient une idée approfondie de l'espace des crypto-monnaies avant d'investir dans les crypto-monnaies. Il est également essentiel d'avoir une idée du paysage réglementaire de votre pays afin de connaître le statut juridique des crypto-monnaies et de savoir comment investir. Suivre un ensemble de meilleures pratiques est idéal pour protéger vos investissements cryptographiques et avoir une expérience cryptographique transparente.
Risques potentiels pour les consommateurs de crypto
La volatilité est un risque considéré comme faisant partie intégrante de l'espace crypto. Toute personne investissant dans la cryptographie est bien consciente des aspects de volatilité de la cryptographie. Cependant, plusieurs autres risques pourraient constituer une menace importante pour les investisseurs en crypto-monnaie et leurs investissements. Certains de ces risques sont

 	Blanchiment d'argent
 	Escroqueries aux faux investissements via les ICO.
 	Escroqueries à la pompe et au vidage cryptographiques
 	Faux échanges de crypto-monnaie
 	Les escroqueries par phishing.

Outre les risques mentionnés ci-dessus, il y a toujours la menace imminente des pirates. Les investisseurs doivent toujours être attentifs à la possibilité de fraude, de vol, de perte d'actifs. Examinons quelques-unes des façons dont les investisseurs peuvent protéger leurs crypto-monnaies et s'assurer qu'ils ont une expérience crypto fluide.




	

	
	
		
			
				Lequel des éléments suivants n'est pas considéré comme une bonne stratégie pour investir dans la cryptographie?
			
		

		
					

		
			
			
			
			Étudier et comprendre le paysage réglementaire de votre juridiction avant d'investir
		
			
			Comparer soigneusement les échanges de crypto-monnaie et vérifier lequel fonctionne le mieux pour vous
		
			
			à la recherche du prochain bitcoin ou ethereum
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meilleures pratiques de cryptographie pour garantir une expérience de cryptographie transparente
Notre crypto peut être compromise par plusieurs voies telles que les portefeuilles de crypto-monnaies, un échange compromis ou une phrase de départ compromise. Voici quelques étapes simples qui peuvent grandement contribuer à vous garantir une expérience de cryptographie transparente.
Utilisez toujours un mot de passe fort
Lorsque vous utilisez un échange pour échanger des cryptos, vous devrez créer un compte. Il est impératif que vous sécurisez ce compte de trading avec un mot de passe fort composé de chiffres et de caractères spéciaux. Un mot de passe fort est votre première ligne de défense contre tout pirate ou tiers malveillant. L'utilisation d'un gestionnaire de mots de passe aide également, vous permettant de créer et de mémoriser des mots de passe complexes. Vous pouvez utiliser des gestionnaires de mots de passe tels que Dashlane pour vous aider à créer un mot de passe sécurisé. Il est également impératif de changer régulièrement votre mot de passe et d'utiliser un gestionnaire de mots de passe, comme mentionné ci-dessus, ainsi qu'une authentification à deux facteurs.




	

	
	
		
			
				Que peut-on considérer comme des risques potentiels pour les investisseurs en crypto?
			
		

		
					

		
			
			
			
			Fausses escroqueries à l'investissement via ICO’s
		
			
			Pump  et Dump escroqueries
		
			
			blanchiment d'argent
		
			
			Tout ce qui précède
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Utiliser 2FA (authentification à deux facteurs)
En plus de conserver un mot de passe fort, implémentez 2FA lors de l'utilisation d'échanges de crypto-monnaie. Au lieu d'utiliser l'authentification par SMS, vous pouvez utiliser des applications telles que Google Authenticator ou Authy. Idéalement, il serait utile que vous utilisiez le 2FA le plus puissant autorisé par la plate-forme. Les clés de sécurité matérielles telles que Yubikey sont idéales, ainsi que des applications telles que Google Authenticator et Authy, qui ont déjà été mentionnées ci-dessus. Si vous n'avez pas le choix et une 2FA basée sur SMS, vous devez activer l'envoi d'un code à usage unique sur votre appareil mobile chaque fois que vous vous connectez à votre compte de trading crypto.
Protégez vos clés privées
Pour stocker vos crypto-monnaies, vous aurez besoin d'un portefeuille qui contiendra vos clés publiques et privées pour envoyer, recevoir et stocker des crypto-monnaies. Bien que votre adresse publique doive être partagée avec d'autres utilisateurs, vous ne devez pas partager vos clés privées avec une personne ou une entité. Si quelqu'un accède à votre clé privée, vous risquez de perdre tous les fonds présents dans votre portefeuille. Il en va de même pour vos clés privées en ce qui concerne votre blockchain ou votre compte de trading. Vous pouvez sécuriser vos clés en suivant quelques étapes simples.

 	Utilisation d'une clé aléatoire ou d'une passphrase
 	Garder le contrôle de vos clés et ne pas les confier à un échange centralisé.
 	Utiliser un portefeuille matériel

Utilisez un portefeuille froid 
Comme nous le savons, les portefeuilles de crypto-monnaie se divisent en deux catégories, les portefeuilles chauds et les portefeuilles froids. Les portefeuilles chauds offrent facilité et simplicité, mais aussi une vulnérabilité importante. Bien que vous ayez un accès facile à votre crypto-monnaie, ils sont également vulnérables aux menaces de sécurité telles que le piratage. Un portefeuille froid est ce que la plupart des experts de l'espace crypto recommandent, surtout si vous avez l'intention de conserver vos crypto-monnaies pendant une durée significative. Un portefeuille froid est essentiellement un portefeuille hors ligne, ce qui signifie que vos actifs sont stockés hors ligne, sécurisant vos actifs contre toute tentative de piratage. Les portefeuilles froids garantissent une sécurité totale contre les menaces auxquelles vous auriez généralement à faire face lors de l'utilisation d'un portefeuille chaud. Des exemples de portefeuilles froids sont les portefeuilles matériels et les portefeuilles en papier.
Adoptez une approche hybride
Adopter une approche hybride implique d'utiliser à la fois des portefeuilles chauds et des portefeuilles froids. Lorsque vous utilisez cette approche, vous pouvez stocker vos crypto-monnaies hors ligne lorsqu'elles ne sont pas échangées. Cependant, lors de l'exécution d'une transaction, vous pouvez simplement transférer les actifs que vous avez l'intention de vendre dans votre portefeuille chaud, terminer la transaction, puis transférer vos actifs dans le portefeuille froid.
Utiliser un VPN
Il est extrêmement important d'utiliser une connexion Internet sécurisée lorsque vous accédez à votre compte de trading de crypto-monnaie et effectuez des transactions cryptographiques. N'essayez jamais d'effectuer une transaction sur un réseau Wi-Fi public, et même lorsque vous utilisez votre réseau domestique, l'utilisation d'un VPN est recommandée pour plus de sécurité. L'utilisation d'un VPN vous aidera à protéger votre activité de navigation contre les pirates potentiels ou les entités malveillantes. Il est également important de sécuriser votre appareil personnel, que vous utiliseriez pour effectuer des transactions. Gardez toujours votre appareil à jour et assurez-vous de ne pas cliquer sur un lien malveillant ou de visiter un site Web malveillant.
Ne mettez pas tous vos œufs dans le même panier
Tout comme pour le marché boursier traditionnel, la diversification est essentielle sur le marché de la cryptographie. En tant qu'investisseur, la diversification est toujours saine pour votre portefeuille crypto. Au lieu de mettre tout votre argent, disons BTC, investir dans une combinaison de BTC, ETH et une poignée d'autres crypto-monnaies pourrait vous aider à vous protéger de la volatilité potentielle du marché tout en vous permettant de bénéficier de plusieurs sources lorsque le marché est sur un taureau Cours.
La diligence raisonnable est la clé
Avant d'investir dans une crypto-monnaie, il est important de comprendre l'actif sous-jacent, ses utilisations et son fonctionnement. Presque chaque pièce a des livres blancs disponibles en ligne, ce qui peut vous aider à mieux comprendre la pièce et à améliorer vos connaissances sur le potentiel de la pièce. S'il n'y a pas de livre blanc disponible ou si le livre blanc ne mentionne ni ne décrit le fonctionnement de la pièce, il vaut mieux éviter cette pièce.
Le timing est également essentiel
Tout comme la diligence raisonnable, le timing est également considéré comme un facteur clé lorsqu'il s'agit d'investir dans le marché de la cryptographie. Si vous pensez savoir ce qu'il y a à savoir sur la cryptographie, vous devez être en mesure de chronométrer parfaitement votre investissement. Le marché des crypto-monnaies est volatil et les fluctuations de prix sont courantes. N'investissez pas dans de nouvelles pièces à la recherche du prochain Bitcoin ou du prochain Ethereum. Soyez toujours minutieux sur le projet avant d'investir, suivez les modèles de prix et gardez une trace des nouvelles pour rester en avance sur les événements qui pourraient avoir un impact négatif sur la valeur de votre investissement (hack d'échange, manipulation des prix). Les crypto-monnaies sont hautement spéculatives, alors faites toujours vos devoirs avant de sauter dans l'espace.
Vérifiez tous les détails de la transaction 
N'oubliez pas que les transactions blockchain sont immuables, ce qui signifie qu'une fois exécutées, elles ne peuvent pas être annulées. Il est donc extrêmement important de revérifier tous les détails de la transaction avant de poursuivre la transaction. Vos fonds ne peuvent vous être restitués que si la partie adverse accepte de le faire.
N'investissez pas plus que vous ne pouvez vous permettre de perdre
C'est l'un des points les plus critiques que vous devez garder à l'esprit en tant qu'investisseur. Bien que les crypto-monnaies puissent être considérées comme un refuge sûr, et oui, elles le sont pour les pays qui sont destinés aux citoyens de comtés comme le Venezuela, qui est sous le choc de l'hyperinflation. Mais les crypto-monnaies sont un investissement à haut risque avec une volatilité importante. Ce qui était rentable le matin pouvait être rouge l'après-midi. Si vous êtes débutant, il est toujours conseillé de commencer par investir des sommes moins importantes.
En conclusion
Les crypto-monnaies sont un investissement quelque peu risqué pour les débutants et pour les têtes expérimentées. En règle générale, les placements à haut risque ne devraient représenter qu'une petite partie de votre portefeuille. Dans le cas des crypto-monnaies, il est toujours bon de diversifier vos investissements en plusieurs pièces afin que vos investissements puissent s'apprécier ou se déprécier à des degrés divers, vous isolant dans une certaine mesure.

Les points mentionnés ci-dessus sont généralement considérés comme les tactiques les plus élémentaires que vous pouvez utiliser pour garantir une expérience crypto transparente. L'espace est en constante évolution et vous devez être proactif pour assurer la sécurité de vos investissements et de vos fonds en sécurisant soigneusement vos comptes et vos portefeuilles. Tenez-vous toujours au courant des dernières nouvelles et des derniers développements dans le domaine de la cryptographie.




	

	
	
		
			
				L'utilisation d'un mot de passe fort, de 2FA, d'un portefeuille froid et d'un VPN lors de la réalisation de transactions est considérée comme faisant partie des meilleures pratiques en matière de cryptographie
			
		

		
					

		
			
			
			
			Vrai
		
			
			Faux
		
	
		

		
		
			
				Correct!
				Wrong!

### Sweatcoin là gì?

Nhờ công nghệ blockchain và tiền điện tử, thế giới đang có nhiều sự đổi mới với quy mô đáng kinh ngạc. Một trong số đó là Sweatcoin - ứng dụng sức khỏe và thể thao được xếp hạng hàng đầu với mục tiêu khuyến khích người dùng áp dụng lối sống lành mạnh hơn bằng cách sử dụng các phần thưởng khác nhau làm động lực cho người sử dụng. Vào năm 2022, Sweatcoin thông báo tung ra tiền điện tử của riêng mình, với mã thông báo(token) là Sweatcoin (SWEAT). Token chạy trên blockchain của NEAR và Ethereum, Sweatcoin được sử dụng để thưởng và thu hút nhiều người sử dụng hơn nữa.

Bài viết này sẽ giúp bạn hiểu khái niệm, mô hình kinh tế đằng sau Sweatcoin, cách nó hoạt động và các ứng dụng của dự án.




Sweatcoin là gì?
Sweatcoin có thể được mô tả như một dự án play-to-earn(chơi để kiếm tiền), mô hình này được Sweat team gọi là sweat-to-earn(vận động để kiếm tiền), Sweat được thành lập dựa trên niềm tin rằng phong trào và lối sống năng động có thể có giá trị thực. Sweatcoin sử dụng tài chính phi tập trung ( DeFi ) và token không thể thay thế (NFT) để mở khóa giá trị được trả lại cho người dùng. Trong khi đó, DAO cho phép người dùng tham gia vào quá trình quản trị, phát triển và ra quyết định của hệ sinh thái Sweatcoin.

Dự án mang đến cho người dùng một cách mới để tạo ra giá trị, cho phép người dùng kiếm tiền thông qua các chuyển động được ghi lại trên ứng dụng. Sweatcoin cũng là một dự án mã nguồn mở, cho phép mọi người cùng tham gia thúc đẩy dự án.

Ban đầu, Sweatcoin là một dạng điểm chứ không phải là tiền mã hóa, khi người dùng tải xuống ứng dụng, hoàn thành được một số bước cụ thể sẽ nhận được điểm Sweatcoin. Chủ sở hữu điểm Sweatcoin có thể đổi lấy phần thưởng từ các tổ chức như Headspace và Audible hay NetFlix. Ngoài ra, người dùng cũng có thể quyên góp những điểm này cho các hoạt động từ thiện. Về lý thuyết, Sweatcoin cung cấp một số điểm tương đồng với tiền điện tử, điều này đã thúc đẩy nhóm tạo ra token Sweatcoin (SWEAT)







Token Sweatcoin (SWEAT)
Sự kiện ra mắt token (TGE) chính thức của Sweatcoin đã diễn ra vào ngày 12 tháng 9. Sau sự kiện này, cách duy nhất để đúc token SWEAT mới là thông qua chuyển động, được xác minh bởi trình xác thực chuyển động của ứng dụng. Ban đầu, SWEAT sẽ chỉ có sẵn cho những người dùng Sweatcoin đủ điều kiện tham gia. Sau sự kiện TGE, số dư điểm thưởng Sweatcoin hiện tại của người dùng sẽ được khớp 1: 1 với token SWEAT. Sau ngày 12, việc kiếm SWEAT sẽ trở nên phức tạp hơn, vì 5000 bước đầu tiên của bạn mỗi ngày sẽ cho phép bạn kiếm SWEAT mới, và bất kỳ bước nào nữa sẽ kiếm được Sweatcoins như bình thường. Do phải đi 1000 bước thì bạn mới kiếm được 1 SWEAT, việc kiếm SWEAT sẽ ngày càng khó hơn theo thời gian.










	

	
	
		
			
				Đâu là thuật ngữ được dùng để mô tả dự án Sweatcoin?
			
		

		
					

		
			
			
			
			Dự án Play-to-Earn
		
			
			Dự án Move-to-Earn
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sweatcoin hoạt động như thế nào?


Ở phần này, chúng ta sẽ tìm hiểu xem ứng dụng Sweatcoin và nền kinh tế phía sau ứng dụng này hoạt động như thế nào. Ứng dụng Sweatcoin là một ứng dụng di động miễn phí và bạn có thể tải từ các chợ ứng dụng Apple App hoặc Google Play. Sau khi bạn tải ứng dụng này về thiết bị, ứng dụng sẽ theo dõi hoạt động của bạn trong ngày, đếm số bước chân mà bạn đi. Người dùng sẽ được thưởng 1 Sweatcoin cho mỗi 1000 bước đi. Người dùng có thể dùng phần thưởng này để chi tiêu cho các vật phẩm như giày thể thao, đồng hồ điện tử, tải nhạc, nước tăng lực, … Bạn càng đi lại nhiều thì càng kiếm được nhiều Sweatcoin.

Theo whitepaper của dự án, token Sweatcoin được tạo ra để khuyến khích mọi người di chuyển và vận động và tạo ra một hành tinh khỏe mạnh hơn. Bất kỳ ai trong nền kinh tế Sweat đều có thể kiếm tiền và đóng góp cho nó. Ban đầu, SWEAT chỉ có sẵn cho những người dùng đủ điều kiện có thể tải xuống ứng dụng Sweatcoin. Đến quý 1 năm 2022, Sweatcoin đã có tới 65 triệu người dùng, con số đạt 110 triệu người dùng vào tháng 8 năm 2022, và dự kiến còn tăng hơn nữa.

Token SWEAT chỉ có thể được đúc thông qua các chuyển động đã được xác minh. Lượng người dùng ổn định giúp tăng đầu vào (số bước đi); khi nhiều người dùng tham gia vào mạng lưới hơn, số bước đi sẽ tăng theo cấp số nhân. Hơn nữa, mỗi token SWEAT mới sẽ yêu cầu nhiều bước để đúc hơn token trước đó. Điều này phù hợp với mục tiêu của Sweatcoin là làm cho thế giới vận động thể chất nhiều hơn. Cơ chế mỗi token SWEAT mới ngày càng khó kiếm hơn là động lực để người dùng tiếp tục di chuyển mà còn giúp bảo toàn giá trị của token SWEAT.

Các chuyển động của người dùng được xác nhận bởi các trình xác thực chuyển động - các node giúp cập nhật blockchain. Xác thực nhất quán là rất quan trọng để đảm bảo tính toàn vẹn của tài sản (SWEAT). Như đã đề cập trước đó, người dùng có thể kiếm được một token SWEAT cho mỗi 1000 bước đi. Trình xác thực nhận dữ liệu từ thiết bị của người dùng và phát hiện bất kỳ chuyển động gian lận nào thông qua một thuật toán, đảm bảo rằng chỉ các chuyển động thực sự mới được ghi lại.






	

	
	
		
			
				Token SWEAT được lưu hành trên blockchain nào?
			
		

		
					

		
			
			
			
			Ethereum và NEAR
		
			
			Polygon và Cardano
		
			
			Ethereum và Cardano
		
			
			NEAR và Polygon
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kế hoạch trong tương lai gần của Sweatcoin
Nền kinh tế Sweatcoin cũng có ví tiền điện tử của riêng mình - Sweat Wallet và cũng có kế hoạch đưa NFT vào hệ sinh thái. Ngoài ra, Sweatcoin còn có kế hoạch cho phép người dùng mua SWEAT trực tiếp bằng tiền pháp định vào cuối năm 2022. Nhóm cũng đã công bố kế hoạch tạo thị trường NFT và cung cấp token SWEAT trên các sàn giao dịch phi tập trung. Việc quản lý nền kinh tế Sweat và token SWEAT cũng sẽ được chuyển giao cho một tổ chức tự trị phi tập trung (DAO). Cuối cùng, việc đúc Sweatcoin sẽ được mở rộng sang các phương thức vận động khác như đạp xe, bơi lội, v.v.




	

	
	
		
			
				Sau sự kiện sinh token (TGE), người dùng có thể đúc token SWEAT bằng cách nào?
			
		

		
					

		
			
			
			
			Sử dụng ứng dụng và bước 5000 bước đi
		
			
			Sử dụng ứng dụng và bước 1000 bước đi
		
			
			Mua token SWEAT trực tiếp
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Học tập trên Learn NEAR Club
Learn NEAR Club (LNC) là một nền tảng tích hợp thực hành, nơi bạn có thể học cách sử dụng và xây dựng trên giao thức NEAR, đồng thời kiếm được token NEAR. LNC đã xây dựng một loạt các hướng dẫn và khóa học. Người dùng trên LNC cũng có thể kiếm được nLearns, một dạng điểm nội bộ, đóng vai trò như một phần thưởng cho những người học xuất sắc. Người dùng trên LNC có thể bắt đầu với Hướng dẫn NEAR, Khóa học NEAR hoặc đúc NFT (L)earner của riêng họ.

Sau khi đã tìm hiểu về Sweatcoin, bạn có thể ghé qua Learn NEAR Club và (L)Earn. 







	

	
	
		
			
				Bạn có thể làm gì với Sweatcoin?
			
		

		
					

		
			
			
			
			Mua bán các sản phẩm online
		
			
			Đấu giá các vật phẩm giá trị cao (PlayStation 5, GoPro Hero 9)
		
			
			Quyên góp cho các tổ chức từ thiện như Save the Children
		
			
			Tất cả các ý trên
		
	
		

		
		
			
				Correct!
				Wrong!

### What Is Sweatcoin: A Brief Introduction

Thanks to blockchain technology and cryptocurrencies, the world is seeing innovation at a staggering scale. One such innovation is Sweatcoin, a top-ranked health and fitness application that encourages users to adopt a healthier lifestyle by using various rewards as an incentive. In 2022, Sweatcoin announced that it would launch its own cryptocurrency, the Sweatcoin token (SWEAT). The token is based on the NEAR and Ethereum blockchains and will be utilized as an incentive to attract more users to the app.

This post will help understand the concept behind Sweatcoin, how it works, and what are its various use cases.




What Is Sweatcoin?
Sweatcoin can be described as a play-to-earn project founded on the belief that movement and an active lifestyle could have real value. Sweatcoin utilizes decentralized finance (DeFi) and non-fungible tokens (NFTs) to unlock value that is returned to the user. Meanwhile, the DAO allows users to participate in the governance, development, and decision-making process of the Sweatcoin ecosystem.

The project gives users a new avenue for value creation, allowing users to earn through movements recorded on the app. Sweatcoin is also an open-source project, allowing everyone to advance the project.

Initially, the Sweatcoin token was a non-crypto token, and when users who downloaded the application attained a specified number of steps, they were given Sweatcoin tokens. Token holders can redeem these tokens for rewards from organizations such as Headspace and Audible. Alternatively, users could also donate these tokens towards charitable causes. In theory, the Sweatcoin token offers several similarities to cryptocurrencies, which prompted the team to create the Sweatcoin token (SWEAT)







The Sweatcoin Token (SWEAT)
Sweatcoin’s token generation event took place on the 12th of September. After the token generation event, the only way to mint new SWEAT tokens is through movement, verified by movement validators. Initially, SWEAT will only be available to eligible Sweatcoin users who opt in. After the token generation event, the current Sweatcoin balance of users will be matched 1:1 with the SWEAT tokens. After the 12th, earning SWEAT becomes trickier, as your first 5000 steps each day would allow you to mint new SWEAT, while any more steps would mint Sweatcoins as usual. While 1 Sweatcoin will always be equal to 1000 steps, SWEAT will become more difficult to mint as time passes.










	

	
	
		
			
				What term best describes Sweatcoin as a project? 
			
		

		
					

		
			
			
			
			Play-to-Earn project 
		
			
			Move-to-Earn project
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Does Sweatcoin Work?


Let’s understand how Sweatcoin and the Sweat economy both function. The free Sweatcoin app is available on the Apple App store and Google Play. Once you download and install the app on your device, the app monitors your activity throughout the day, tracking the number of steps taken. As a user, you can earn one Sweatcoin for every 1000 steps recorded. Users can redeem these coins and purchase various things such as running shoes, digital watches, music downloads, energy drinks, and more. The more you walk, the more Sweatcoins you stand to earn.

According to the whitepaper, Sweatcoin was created to incentivize people to keep moving, reward movement, and create a healthier planet. Anyone in the Sweat economy can earn and contribute to it. Initially, the SWEAT was available only to eligible users who could download the Sweatcoin app. By Q1 2022, Sweatcoin had grown to 65 million users, a number that reached 110 million users by August 2022, with the number expected to grow further.

The SWEAT token can be minted only through verifiable movement. A stable number of users helps increase the input (steps); as more users join the network, the input would increase exponentially. Furthermore, each new SWEAT token would require more steps to mint than the previous token. This aligns with Sweatcoin’s goal of making the world more physically active. With each new SWEAT token increasingly harder to mint, it not only acts as an incentive for users to keep moving but also preserves the utility of the SWEAT token.

The user movements are validated by movement validators who update the blockchain. Consistent validation is critical to ensure the integrity of the underlying asset (SWEAT). As mentioned earlier, users can earn one SWEAT token for every 1000 steps achieved. Validators receive data from the user devices and detect any fraudulent movement through an algorithm, ensuring that only true movements are recorded.






	

	
	
		
			
				SWEAT token is based on which blockchains? 
			
		

		
					

		
			
			
			
			Ethereum and NEAR 
		
			
			Polygon and Cardano 
		
			
			Ethereum and Cardano
		
			
			NEAR and Polygon 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Future Plans For Sweatcoin
The Sweat economy also has its own crypto wallet, the Sweat Wallet, and also plans to introduce NFTs into the ecosystem. Additionally, there are plans to allow users to purchase SWEAT directly using fiat currency by the end of 2022. The team has also announced plans to create an NFT marketplace and make the SWEAT token available on decentralized exchanges. Eventually, the governance of the Sweat economy and SWEAT will be passed on to a decentralized autonomous organization (DAO). Eventually, the minting of Sweatcoin will be expanded to other methods of activities such as cycling, swimming, etc.




	

	
	
		
			
				After the token generation event, users can mint SWEAT by 
			
		

		
					

		
			
			
			
			Registering the first 5000 steps on the Sweatcoin app
		
			
			Registering the first 1000 steps on the Sweatcoin app
		
			
			Purchasing the SWEAT token directly 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Learn On NEAR Club
Learn NEAR Club (LNC) is an all-inclusive, hands-on onboarding platform for the NEAR protocol, where you can learn how to use and build on the NEAR protocol, and earn NEAR tokens. LNC features a host of onboarding guides and courses. Users on LNC also stand to earn nLearns, which are basically internal points, which act as a reward for outstanding learners. Users on LNC can start with NEAR Guides, NEAR Courses, or mint their own (L)Earner NFT. 

Now that you have learned to SWEAT, you can go over to the Learn NEAR Club, and (L)Earn. You can also check out the Sweatcoin Guide available on LNC, along with a host of other guides and courses. 







	

	
	
		
			
				What can you do with your Sweatcoins?
			
		

		
					

		
			
			
			
			Buy deals, products, and digital offers
		
			
			Bid in high-value auctions (PlayStation 5, GoPro Hero 9)
		
			
			Donate to charities like Save the Children
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### Tokenomics 101 para iniciar en la web3

Muy bien, entonces has decidido crear tu propia dApp e ingresar al espacio web3. Enhorabuena por dar este paso. Sin embargo, antes de lanzar tu aplicación revolucionaria, debes establecer uno de los principios básicos de web3: la tokenómica. La Tokenómica es el acrónimo de "token" y "economía", que se explica por sí mismo. Entonces, en este artículo, aprenderás todo lo que necesitas saber sobre tokenómica.
¿Qué es la Tokenómica?
La Tokenómica es un término vago, pero incluye varios factores como oferta y demanda, emisión de tokens, funciones de quema, etc. En pocas palabras, es una suma total de funciones y factores económicos que afectan sus tokens de varias maneras. Un token perteneciente a un proyecto con tokenómica sólida se considera una inversión más atractiva. Entonces, sin más preámbulos, veamos los diferentes factores.
Factor 1: Oferta y Demanda
La ecuación de oferta y demanda es uno de los factores más críticos que determinan la tokenómica. El siguiente es uno de los gráficos más importantes en economía: el gráfico de oferta y demanda.



El gráfico anterior muestra la relación entre la oferta y la demanda de un producto en particular. El precio posterior de una mercancía está determinado por su demanda en el mercado y la cantidad que está fácilmente disponible. 

La rareza de un artículo (es decir, la disminución de la oferta) a menudo se considera un factor importante en la valoración del producto. Piense en los precios inflados por los que se vendían las máquinas PS5 en el mercado de segunda mano debido a su rareza. Sin embargo, el hecho de que un artículo sea raro no significa que sea valioso. Puedes tomarte una selfie, que será un elemento único, pero eso no significa que obtendrás miles de dólares por ello, ¿verdad? Tiene que haber demanda en el mercado. En la etapa de equilibrio, los gráficos de oferta y demanda hacen perfectamente un balance entre sí.

Hay dos cosas que podemos concluir del gráfico:

 	Cuando la oferta de un activo es alta pero la demanda es baja, no afectará positivamente el precio.
 	Si la demanda es alta pero la oferta es baja, afectará positivamente el precio

Oferta y demanda en tokens

Cuando se trata de Bitcoin, uno de los momentos de creación de valor más significativos en el protocolo son los eventos periódicos de reducción a la mitad que ocurren cada cuatro años. Bitcoin tiene un suministro fijo total de 21 millones. Los mineros extraen Bitcoin para obtener una recompensa en bloque para liberar BTC en el suministro circulante.

Cada cuatro años, Bitcoin pasa por una reducción a la mitad que reduce la recompensa de este bloque a la mitad, lo que reduce la cantidad de BTC que ingresa al suministro circulante. Satoshi Nakamoto agregó esta mecánica a propósito para garantizar una oferta decreciente con el tiempo y, con suerte, aumentar la valoración general del precio.

Varios tokens como BNB tienen un mecanismo de combustión artificial. Quemar significa que envía los tokens a una billetera cuyas claves privadas no pertenecen a nadie. Al hacerlo, está eliminando estos tokens de la circulación, es decir, quemándolos.

También hay ciertos tokens que son inflacionarios. Por ejemplo, EOS tiene una tasa de inflación anual del 1%. Este 1% se utiliza para pagar a los productores de bloques. La idea era que el sistema EOS estaría tan ocupado con el tiempo que el aumento de la oferta no afectaría la demanda.
Factor 2: Distribución de Token
Un protocolo puede distribuir tokens a través de un lanzamiento justo o previo a la mina. Cuando ocurre un lanzamiento justo, todos tienen la oportunidad justa de adquirir los tokens. El lanzamiento de Bitcoin fue justo ya que todos tuvieron exactamente la misma oportunidad de adquirir BTC. No hubo preventa, ni ronda de inversores privados. Si quieres Bitcoin, habrías tenido que minarlos desde cero.

Sin embargo, los lanzamientos justos son muy raros hoy en día. A partir de la era ICO, los tokens se lanzaron a través de un método llamado preminado. En un premine, los tokens se crean parcial o totalmente y luego se distribuyen a varias partes como VC, inversores, etc., antes de ser lanzados al público. Obviamente, la minería previa es injusta ya que un usuario promedio no obtiene el primer bocado del pastel. Sin embargo, en el panorama actual, es necesario hacerlo ya que los proyectos necesitan esa inyección de liquidez inicial de los capitalistas de riesgo y los creadores de mercado. Necesitan la liquidez para pagar la mano de obra, el desarrollo, la construcción del ecosistema, etc.

Habiendo dicho eso, es crucial ver cuántos de los tokens se distribuyen a estas partes. Por ejemplo, si un equipo se asigna el 5 % de los tokens, está bien. Después de todo, necesitan dinero para financiar su equipo. Sin embargo, si se dan el 50% a sí mismos, entonces eso es una señal de alerta potencial.




	

	
	
		
			
				Cuando un activo tiene baja oferta y alta demanda, significa que:
			
		

		
					

		
			
			
			
			El precio debería subir.
		
			
			El precio debería bajar.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Factor 3: Staking
En esencia, una buena tokenómica debería idear diferentes métodos para incentivar a los usuarios a conservar sus tokens. Una de las mejores maneras de hacerlo es asegurarle al titular algún tipo de ROI garantizado. Muchos proyectos hacen eso con un mecanismo de participación.

La idea es simple: guardas tus tokens en el protocolo y ganas recompensas. Por ejemplo, si tieness tokens de Curve (CRV), puede stakearlos en Convex Finance como cvxCRV y ganar ~30% vAPR. Las aplicaciones DeFi te permiten stakear varios tokens que pueden ayudarte a obtener rendimiento. 

El staking también permite a los usuarios bloquear tu token, lo que los convierte automáticamente en titulares a largo plazo. Después de todo, no puedes vender un token que has bloqueado firmemente en el ecosistema, ¿verdad?

Ahora, la siguiente pregunta a considerar aquí es, ¿cómo puedes incentivar a tus usuarios a stakear voluntariamente sus monedas durante mucho tiempo? Bueno, proyectos como Curve tienen una oferta de interés compuesto simple que funciona bastante bien para ellos. Cuanto más tiempo mantengas tu CRV bloqueado, más recompensas obtendrás.

El staking también te otorga derechos de gobernanza en algunos proyectos. Stakear el token nativo te permite convertirte en miembro del DAO del Protocolo y votar en varias decisiones. Por ejemplo, en Curve, puedes stakear tu CRV y veCRV, el token de votación. Mientras más CRV stakeas, más veCRV obtienes. El veCRV no tiene ningún valor aparte de ser utilizado como token de votación dentro de la DAO.
Factor 4: Programas de Adquisición de Derechos
En el Factor 2, discutimos cómo la minería previa permite que los proyectos asignen tokens específicos a inversores privados y capitalistas de riesgo. Sin embargo, ¿qué sucede si esas personas arrojan inmediatamente sus tokens en el mercado abierto? Eso no va a hacer ningún bien a tu proyecto, ¿verdad?

Entonces, lo que puedes hacer aquí es usar varios calendarios de  vesting o de adquisición de derechos para tus asignaciones. El vesting te permite bloquear tokens distribuidos durante un tiempo determinado (también conocido como período de vesting). Aumenta el tiempo que tienes que esperar antes de tener en tus manos los tokens.

Ahora, antes de continuar, hablemos del "cliff". Cuando se trata del vesting o adjudicación, el cliff es un bloqueo de duración que se coloca en los tokens adjudicados antes de que comience el programa de vesting. Hay dos tipos de vestings que puede hacer:

 	Linear vesting: La distribución de tokens se realiza de manera consistente y en partes iguales dentro de un período de tiempo determinado.
 	Twisted vesting: La distribución de tokens puede variar dentro de una variedad de períodos de tiempo.

Creación de su propio token: mejores prácticas
Entonces, ahora que conoces los conceptos básicos, creemos tu token. Puedes usar este patio de juegos de tokens para probar varias estructuras de tokens.



Como puedes ver, pone el nombre de tu token, el símbolo, el suministro total y los lugares decimales.

Debajo de eso, tienes una lista de asignaciones de tokens. Dependiendo de cuántos asesores y VC tendrá tu proyecto, puedes dar las asignaciones correspondientes. Sin embargo, solo un consejo. No te excedas con las asignaciones para asesores. Mantén una mayoría significativa para tu comunidad.

Por ejemplo:

 	10% para el equipo
 	10% para primeros inversores
 	0,25%-0,5% por asesor
 	Resto de la comunidad.




	

	
	
		
			
				¿Qué tipo de vesting es este? “La distribución de tokens se realiza de manera consistente y en partes iguales dentro de un período de tiempo determinado”
			
		

		
					

		
			
			
			
			Lineal
		
			
			Retorcido
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusión
WAl crear tu protocolo web3, una tokenómica robusta es crucial para el éxito a largo plazo de tu proyecto. En este artículo, hemos hablado sobre cuatro funciones que puedes integrar en tu tokenómica para evitar el dumping e incentivar a los usuarios a conservar sus tokens y acumular más.




	

	
	
		
			
				Durante la distribución de tokens, la mayoría de los tokens deben asignarse a:
			
		

		
					

		
			
			
			
			Equipo
		
			
			VC
		
			
			Comunidad
		
	
		

		
		
			
				Correct!
				Wrong!

### Токеномика 101 для стартапов web3

Итак, вы решили создать собственное децентрализованное приложение и войти в пространство web3. Поздравляю с тем, что вы сделали этот шаг. Однако, прежде чем вы запустите свое революционное приложение, вы должны усвоить один из основных принципов web3 — токеномику. Токеномика — это смесь «токена» и «экономики», что говорит само за себя. Итак, в этой статье вы узнаете все, что вам нужно знать о токеномике.
Что такое токеномика?
Токеномика — это расплывчатый термин, но он включает в себя несколько факторов, таких как спрос-предложение, выпуск токенов, функции сжигания и т. д. Проще говоря, это совокупность функций и экономических факторов, которые по-разному влияют на ваши токены. Токен, принадлежащий проекту с солидной токеномикой, считается более привлекательной инвестицией. Итак, без лишних слов, давайте рассмотрим различные факторы.
Фактор 1: спрос и предложение
Уравнение спроса и предложения является одним из важнейших факторов, определяющих токеномику. Ниже представлена одна из самых важных диаграмм в экономике — диаграмма спроса и предложения.



На приведенном выше графике показана взаимосвязь между спросом и предложением конкретного товара. Последующая цена товара определяется спросом на него на рынке и его количеством, которое доступно.

Редкость предмета (то есть уменьшение предложения) часто считается важным фактором при оценке продукта. Подумайте о завышенных ценах, по которым приставки PS5 продавались на вторичном рынке из-за их редкости. Однако то, что предмет редкий, не означает, что он ценный. Вы можете сделать селфи самого себя — это будет уникальная вещь, но это не значит, что вы получите за это тысячи долларов, верно? На рынке должен быть спрос. На стадии равновесия графики спроса и предложения идеально уравновешивают друг друга.

Из графика можно сделать два вывода:

 	Когда предложение актива высокое, а спрос низкий, это не окажет положительного влияния на цену. 
 	Если спрос высок, а предложение низкое, это положительно повлияет на цену.

Спрос и предложение в токенах

Когда дело доходит до Биткойна, одним из наиболее важных моментов создания стоимости в протоколе являются периодические события, связанные с уменьшением вдвое, которые происходят каждые четыре года. Общий фиксированный запас биткойнов составляет 21 миллион. Майнеры добывают биткойн, чтобы получить вознаграждение за блок, чтобы выпустить BTC в оборот.

Каждые четыре года Биткойн проходит халвинг, который сокращает вознаграждение за блок вдвое, уменьшая количество BTC, поступающих в оборот. Сатоши Накамото намеренно добавил эту механику, чтобы обеспечить сокращение предложения с течением времени и, как мы надеемся, увеличить цену актива.

Несколько токенов, таких как BNB, имеют искусственный механизм сжигания. Сжигание означает, что вы отправляете токены на кошелек, закрытые ключи которого никому не принадлежат. Поступая таким образом, вы удаляете эти токены из обращения, то есть сжигаете токены.

Есть также определенные токены, которые являются инфляционными. Например, EOS имеет годовой уровень инфляции 1%. Этот 1% используется для оплаты производителей блоков. Мысль заключалась в том, что система EOS со временем станет настолько загруженной, что увеличение предложения не повлияет на спрос.
Фактор 2: Распределение токенов
Протокол может распределять токены через честный запуск или предварительную добычу. Когда происходит честный запуск, у каждого есть справедливая возможность приобрести токены. Запуск Биткойна был справедливым, поскольку у всех была одинаковая возможность приобрести BTC. Не было ни предпродажи, ни раунда частного инвестора. Если вы хотите биткойн, вам пришлось бы добывать их с нуля.

Тем не менее, честные запуски в настоящее время очень редки. Начиная с эпохи ICO, токены запускались методом премайнинга. В премайне токены создаются частично или полностью, а затем распространяются среди различных сторон, таких как венчурные капиталисты, инвесторы и т. д., прежде чем они будут выпущены для широкой публики. Очевидно, что предварительный майнинг несправедлив, поскольку средний пользователь не получает первый кусок пирога. Однако в нынешних условиях это необходимо сделать, поскольку проектам требуется первоначальное вливание ликвидности от венчурных капиталистов и маркет-мейкеров. Им нужна ликвидность для оплаты труда, разработки, построения экосистемы и т. д.

При этом крайне важно увидеть, сколько токенов распределяется между этими сторонами. Например, если команда выделяет себе 5% токенов, то это нормально. В конце концов, им нужны деньги, чтобы финансировать свою команду. Однако, если они отдают 50% себе, то это потенциальный красный флаг.




	

	
	
		
			
				Когда актив имеет низкое предложение и высокий спрос, это означает, что:
			
		

		
					

		
			
			
			
			цена должна вырасти
		
			
			цена должна упасть
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Фактор 3: Стэйкинг
По своей сути, хорошая токеномика должна придумывать различные методы, чтобы стимулировать пользователей удерживать свои токены. Один из самых крутых способов сделать это — обеспечить держателю некую форму гарантированной рентабельности инвестиций. Многие проекты делают это с помощью механизма стэйкинга.

Идея проста — заблокируйте свои токены в протоколе и получайте вознаграждение. Например, если у вас есть токены Curve (CRV), вы можете поставить их на Convex Finance как cvxCRV и заработать ~30% vAPR. Приложения DeFi позволяют вам размещать различные токены, которые могут помочь вам получить доход.

Стейкинг также позволяет пользователям заблокировать ваш токен, автоматически делая их долгосрочными держателями. В конце концов, вы не можете продать токен, который вы прочно заперли в экосистеме, верно?

Теперь следующий вопрос, который следует рассмотреть, заключается в том, как вы можете стимулировать своих пользователей охотно стэйкать ваши монеты в течение длительного времени? Ну, такие проекты, как Curve, предлагают простые сложные проценты, которые очень хорошо для них работают. Чем дольше вы держите свой CRV заблокированным, тем больше наград вы получите.

Стэйкинг также дает вам права управления в некоторых проектах. Стейкинг нативного токена позволяет вам стать участником протокола DAO и голосовать за различные решения. Например, в Curve вы можете поставить свои CRV и veCRV, токен для голосования. Чем больше CRV вы ставите, тем больше veCRV получаете. veCRV не имеет никакой ценности, кроме использования в качестве токена для голосования в DAO.
Фактор 4: Графики вестинга
В Факторе 2 мы обсуждали, как предварительный майнинг позволяет проектам выделять определенные токены частным инвесторам и венчурным капиталистам. Однако что, если эти люди немедленно выбросят ваши токены на открытый рынок? Это не пойдет на пользу вашему проекту, верно?

Итак, что вы можете сделать здесь, так это использовать различные графики наделения правами для ваших ассигнований. Вестинг позволяет заблокировать распределенные токены на определенное время (период наделения). Это увеличивает время ожидания, прежде чем получить токены.

Теперь, прежде чем мы пойдем дальше, давайте поговорим о «обрыве». Когда дело доходит до наделения правами, скала представляет собой временную блокировку, которая размещается на переданных токенах до начала графика наделения правами. Есть два вида вестинга, которые вы можете сделать:

 	Линейное наделение: распределение токенов осуществляется последовательно и равными частями в течение определенного периода времени. 
 	Витой вестинг: распределение токенов может варьироваться в разные периоды времени.

Создание собственного токена — лучшие практики
Итак, теперь, когда вы знаете основы, давайте создадим свой токен. Вы можете использовать эту игровую площадку для проверки различных свойств токенов.



Как видите, вы указали имя своего токена, символ, общий запас и десятичные разряды.

Ниже у вас есть список распределений токенов. В зависимости от того, сколько советников и венчурных капиталистов будет у вашего проекта, вы можете выделить соответствующие средства. Впрочем, просто совет. Не переусердствуйте с ассигнованиями на советников. Держите значительное большинство для вашего сообщества.

Например: 

10% для команды 

10% для ранних инвесторов 

0,25%-0,5% советникам

остальные для сообщества.




	

	
	
		
			
				Что это за вестирование? «Распределение токенов осуществляется последовательно и равными частями в течение определенного периода времени»
			
		

		
					

		
			
			
			
			линейное
		
			
			витое
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Вывод
При создании вашего протокола web3 надежная токеномика имеет решающее значение для долгосрочного успеха вашего проекта. В этой статье мы рассказали о четырех функциях, которые вы можете интегрировать в свою токеномику, чтобы предотвратить демпинг и стимулировать пользователей хранить ваши токены и накапливать больше.




	

	
	
		
			
				Во время распределения токенов большинство токенов должно быть выделено:
			
		

		
					

		
			
			
			
			команде
		
			
			VCs
		
			
			комьюнити
		
	
		

		
		
			
				Correct!
				Wrong!

### Apa itu Octopus Network?

Luaran yang diharapkan : pengetahuan umum terkait Octopus Network dari sudut pandang end-user

Seekor gurita tentu sangat berbeda dari manusia. Alih-alih memiliki sistem saraf terpusat seperti yang dimiliki manusia, dua pertiga neuron gurita tersebar di seluruh tubuhnya dan didistribusikan di antara lengannya. Neuron-neuron itu dapat membuat keputusan sendiri tanpa masukan atau input dari otak, sehingga pada dasarnya membuat gurita menjadi contoh bentuk kehidupan cerdas yang terdesentralisasi.

Octopus Network adalah jaringan kripto yang dapat dioperasikan secara multichain yang mengemulasi Octopus. Seperti layaknya lengan gurita, setiap blockchain khusus aplikasi yang terhubung (appchain) diberdayakan dengan kecerdasannya sendiri dan mekanisme pengambilan keputusan untuk beradaptasi dengan lingkungan yang selalu berubah. Saat terhubung secara keseluruhan, semua anggota mendapat manfaat dari efek jaringan yang signifikan dan skala ekonomi yang  menciptakan Internet Blockchain.



Octopus Network adalah jaringan kripto multichain untuk dapat meluncurkan dan menjalankan blockchain khusus aplikasi Web3.0 yakni appchain atau  rantai aplikasi.

Appchain di Jaringan Octopus mendapat manfaat dari keamanan yang disewakan (LPoS) yang fleksibel dan hemat biaya, interoperabilitas multi rantai yang siap pakai, infrastruktur yang lengkap, dan komunitas yang siap dan dapat dilibatkan.

Jaringan Octopus menurunkan biaya untuk meluncurkan appchain dari nominal beberapa juta dolar hingga menjadi kurang dari seratus ribu dolar sehingga hal ini dapat menstimulus Gelombang Inovasi ke-3 dari jaringan Crypto.
Evolusi dari Aplikasi Web 3.0
Web3.0 belum sepenuhnya terlaksana hingga saat ini. Tetapi berdasarkan prinsip pertama, kami yakin pada akhirnya akan terealisasi.

Perdagangan selalu mengalir ke pasar dengan biaya transaksi yang lebih rendah, seperti air yang selalu mengalir ke bawah.

Platform Web2.0 dimiliki dan dijalankan oleh perusahaan yang tujuannya secara langsung selaras dengan memaksimalkan nilai pemegang saham. Mereka mengambil keuntungan sebanyak mungkin dari kegiatan ekonomi yang mereka koordinasikan. Jaringan Crypto adalah pasar layanan digital dengan biaya transaksi yang diminimalkan. Jadi platform Web2.0 tidak memiliki pertahanan terhadap akhirnya digantikan oleh jaringan kripto..

Web3 mengacu pada aplikasi terdesentralisasi yang berjalan di blockchain yang dimiliki oleh komunitas pengguna daripada perusahaan pengeruk dan pencari keuntungan. Web3.0 bercita-cita untuk mengembalikan nilai kepada pencipta yang sebenarnya.

Namun, platform Web2.0 sangat fantastis untuk Pengguna Internet. Untuk aplikasi Web3.0 agar dapat menggantikan aplikasi Web2.0, itu awal mulanya harus menjadi aplikasi Web yang hebat dan memberikan pengalaman pengguna (user experience) yang setidaknya sebagus generasi Web2.0-nya.

Pengembangan aplikasi Web3.0 biasanya harus mengorbankan pengalaman pengguna karena teknologi buku besar terdistribusi melibatkan lebih banyak kerumitan dan peningkatan biaya daripada Web2.0 — yang menghasilkan UX yang diturunkan.

Tetapi Gelombang Inovasi Jaringan Kripto ke-3 ada di depan kita dan itu membawa solusi aplikasi Web3.0 yang menjanjikan dengan arus kemajuan.
Gelombang Inovasi Cryptonetwork ke-3
Bitcoin adalah blockchain khusus aplikasi (appchain) — yang pertama dan paling sukses.

Terinspirasi oleh Bitcoin, bermacam-macam rantai aplikasi kemudian dikembangkan dari 2011 hingga 2015. Beberapa mencoba menjadi Bitcoin yang lebih baik, sementara yang lain menargetkan berbagai kasus penggunaan selain mata uang dan  meninggalkan kita dengan sejumlah besar koin mati dan tidak berkelanjutan. Alasan yang disepakati secara umum untuk ini adalah bahwa blockchain Bitcoin dibuat khusus dan tidak cocok untuk menangani kasus penggunaan lain dengan cara ditiru atau dikembangkan. Kita dapat menyebut periode ini sebagai “Gelombang Inovasi Cryptonetwork Pertama.”

Gelombang Inovasi Cryptonetwork ke-2 lahir dengan Ethereum. Ethereum adalah blockchain publik tujuan umum yang dilengkapi dengan mesin virtual Turing-Complete (yang secara teoritis dapat mengeksekusi komputasi apa pun, selama tetap dalam batasan kompleksitas, alias batas gas.) Bahasa pemrograman EVM utama, Solidity, dengan Javascript-nya -seperti sintaks, mudah dipelajari dan sangat baik dalam mengontrol aset on-chain.

Ethereum memungkinkan ribuan pengembang untuk membangun aplikasi terdesentralisasi (dApps). Sayangnya, sangat sedikit yang dapat mempertahankan banyak pengguna untuk waktu yang lama hingga ledakan DeFi terjadi di 2020.

Tetapi tantangan utama yang dihadapi Ethereum adalah skalabilitas — dan biaya gas untuk menjalankan smart contract  telah membuat kasus penggunaan tertentu menjadi sangat mahal. Sementara Ethereum 2.0 bertujuan untuk menargetkan masalah ini dengan protokol sharded blockchain, Ethereum 2.0 adalah peta jalan beberapa tahun dengan risiko eksekusi yang tidak diketahui.

Namun, Gelombang Inovasi Cryptonetwork ke-3 sudah dekat. Kerangka kerja Blockchain seperti Substrate dan Cosmos SDK dapat memberikan ruang desain kolosal yang belum pernah ada sebelumnya untuk pengembang aplikasi Web3.0.

Pengembang sekarang dapat menghadirkan aplikasi Web3.0 yang sepenuhnya dioptimalkan dengan membangun rantai aplikasi.


Apa itu Appchain?
Aplikasi terdesentralisasi atau dApp, adalah aplikasi web dengan setidaknya sebagian dari backendnya berada di blockchain. Backend dApp dapat diimplementasikan dengan dua cara – smart contract dapat di-host di platform blockchain, atau aplikasi terdesentralisasi dapat hidup di blockchain khusus miliknya sendiri.

Ketika dApp memiliki blockchainnya sendiri, itu disebut blockchain khusus aplikasi, atau singkatnya appchain. Tidak seperti dApps, rantai aplikasi memungkinkan pengembang untuk menyesuaikan aplikasi mereka dalam hal struktur tata kelola, desain ekonomi, dan bahkan algoritma konsensus yang mendasarinya.

Rantai aplikasi juga memberi pengembang kapasitas pemrosesan transaksi khusus, yang berarti bahwa aplikasi di rantai aplikasi tidak harus bersaing dengan aplikasi lain untuk kapasitas pemrosesan transaksi di jaringan.

Sebagai ilustrasi, sementara ribuan aplikasi berbeda mungkin berbagi satu set konfigurasi standar pada platform kontrak pintar generik, setiap rantai aplikasi dalam pengaturan PoS dapat dengan mudah mencapai throughput 1K+ TPS dan finalitas cepat — dan semua kapasitas pemrosesan transaksi ini akan didedikasikan hanya untuk satu aplikasi.

Tidak seperti kontrak pintar, rantai aplikasi dapat berkembang dengan cepat dengan legitimasi. Setiap rantai aplikasi adalah ekonomi yang diatur sendiri dengan proses eksplisit yang ditentukan kode untuk mencapai kesepakatan tentang peningkatan protokol. Dan, berkat Substrat, fungsi utama tata kelola on-chain siap digunakan. Setiap cryptonetwork dapat mencerminkan proses tata kelola yang lain dengan kode salin-tempel. Tata kelola Blockchain itu sendiri dapat berkembang seperti perangkat lunak sumber terbuka.

Namun, tidak ada yang bisa mengabaikan bahwa kontrak pintar sangat bagus untuk kasus penggunaan perdagangan aset, misalnya, DeFi. Karena kontrak pintar berjalan berdasarkan asumsi keamanan yang sama, komposisi di antara mereka adalah resep penting untuk ledakan DeFi.

Namun, meskipun pengalaman pengguna DeFi tidak seburuk perbankan online, ia masih memiliki banyak ruang untuk perbaikan, terutama ketika mempertimbangkan blockchain layer 1 yang lebih mampu daripada Ethereum — seperti NEAR Protocol.
Mengapa Octopus memilih NEAR?
Sementara Substrat dan Cosmos SDK telah menurunkan biaya pengembangan rantai aplikasi ke tingkat yang setidaknya sebanding dengan kontrak pintar, bootstrap rantai aplikasi masih merupakan pekerjaan yang rumit secara teknis dan padat modal bagi pengembang.

NEAR Protocol adalah sharded proof-of-stake (PoS) blockchain yang menekankan skalabilitas dan kegunaan. NEAR sering disebut sebagai solusi skalabilitas siap pakai untuk Ethereum dApps yang ada, tetapi juga mampu menangani serangkaian jenis solusi terdesentralisasi lainnya — seperti rantai aplikasi.

Dibandingkan dengan platform Layer 1 lainnya yang juga dapat mengakomodasi rantai aplikasi, seperti Polkadot atau Cosmos, NEAR memiliki beberapa keunggulan teknis dan ekonomi utama.

Dibandingkan dengan Cosmos, meluncurkan appchain di NEAR lebih mudah karena validator tidak perlu di-bootstrap untuk setiap appchain individu.

Misalnya, di Cosmos, setiap rantai aplikasi harus mengamankan dirinya sendiri dengan set validator terdesentralisasi yang cukup dipertaruhkan. Jadi, pengembang rantai aplikasi harus terlebih dahulu mendapatkan pengakuan nilai dari token asli rantai aplikasi di pasar aset kripto, kemudian mem-bootstrap komunitas validator aktif dari bawah ke atas.

Dibandingkan dengan Polkadot, NEAR menawarkan rantai aplikasi sewa keamanan yang jauh lebih murah dan tidak memiliki batasan jumlah rantai aplikasi yang dapat diluncurkan.

Parachain Polkadot harus mampu membayar biaya konsensus satu pecahan jaringan — yang bisa setara dengan puluhan juta dolar per tahun.

Dalam sistem komputasi, keamanan yang lebih tinggi tidak selalu sama dengan keamanan yang lebih baik, karena tingkat keamanan yang lebih tinggi selalu disertai dengan tingkat biaya yang lebih tinggi. Jadi, yang dibutuhkan sebuah sistem komputasi adalah keamanan yang tepat dan memadai.

Di Polkadot, pengembang tidak dapat memutuskan tingkat keamanan yang sesuai dan memadai untuk parachain mereka. Mereka hanya punya satu pilihan — memenangkan slot dalam pelelangan. Tetapi bahkan jika parachain memenangkan pelelangan, biasanya membayar lebih untuk keamanan karena jaringan kripto dalam fase peluncurannya tidak memerlukan tingkat keamanan multi-miliar dolar.

Selain itu, beban biaya keamanan tingkat tinggi sejak awal dapat menjerumuskan parachain ke dalam hiperinflasi karena harus berjanji untuk mengeluarkan sebagian besar token asli kepada pemberi pinjaman Crowdloan. Paling tidak, beban ekonomi ini menyisakan ruang yang sangat kecil bagi parachain untuk memberi insentif kepada pencipta nilai nyata dari protokolnya — para peserta yang membantu membangun efek jaringan dari cryptonetwork.

Sederhananya, NEAR dipilih oleh Octopus daripada Polkadot dan Cosmos karena lebih hemat biaya, terukur, ramah pengguna, dan dapat dioperasikan dengan jaringan seperti Ethereum daripada solusi L1 lain yang ada.

Kami percaya bahwa rantai aplikasi akan menjadi Gelombang Inovasi Cryptonetworks ke-3 yang mengantar kami ke Web3.0 — dan Jaringan Octopus akan membuat rantai aplikasi dapat diakses oleh banyak proyek dengan semua jenis anggaran.




	

	
	
		
			
				Apa itu Appchain?
			
		

		
					

		
			
			
			
			Sebuah aplikasi terdesentralisasi
		
			
			Sebuah blockchain multi fungsi
		
			
			Aplikasi blockchain spesifik
		
			
			Sebuah smart contract
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Keunggulan dari Leased PoS (LPoS)

Apa itu keamanan dalam konteks blockchain?

Sederhananya, keamanan adalah tingkat kepastian bahwa protokol yang telah ditentukan akan diterapkan seperti yang diharapkan oleh sebagian besar pemangku kepentingan — baik di lapisan dasar maupun lapisan aplikasi.

Keamanan Blockchain umumnya dianggap sebagai properti yang dapat diukur. Tidak mungkin ada keamanan mutlak atau tidak terbatas. Jika blockchain memiliki keamanan mutlak, itu pasti tidak dapat digunakan dan tidak terjangkau.

Dibandingkan dengan model keamanan bersama parachain Polkadot, appchain Leased PoS (LPoS) dari Octopus Network jauh lebih terukur dan fleksibel. Karena leasing jaminan pada dasarnya adalah leasing modal atau leasing agunan, skalanya tanpa batasan fisik.

Di Polkadot, setiap parachain akan menampung sejumlah validator tertentu di kumpulan secara eksklusif di zaman tertentu. Algoritme konsensus membatasi ukuran total kumpulan. (Itulah sebabnya jumlah total parachain diperkirakan di bawah 100 dengan kurang dari 10 slot parachain tersedia tahun ini.)

Leased PoS Octopus jauh lebih hemat biaya daripada Polkadot. Karena Octopus tidak memiliki blockchain sendiri, dan token $OCT dikeluarkan dan dikelola oleh kontrak pintar, Octopus tidak perlu membayar biaya konsensus secara langsung. Jadi, tingkat inflasi $OCT dapat diatur ke nol, yang berarti tingkat bunga dasar sistem ekonomi Octopus adalah nol.

Ketika tingkat bunga dasar adalah nol, APY 3% -5% adalah pengembalian tahunan yang layak, (yang merupakan kisaran yang kami harapkan akan dibayar oleh rantai aplikasi untuk keamanan yang mereka sewa.) Sebaliknya, parachain Polkadot harus membayar 20% atau lebih APY untuk membuat dirinya menarik bagi pemberi pinjaman Crowdloan $DOT karena mempertaruhkan pada Relay Polkadot akan memberi investor pengembalian tahunan bebas risiko 14%.

Karena LPoS adalah keamanan berbasis kebutuhan dan menawarkan rantai aplikasi leverage yang hemat biaya untuk menskalakan secara organik, kami percaya bahwa LPoS lebih kondusif untuk pengembangan rantai aplikasi jangka panjang daripada PoS independen. Namun, kami juga percaya bahwa hak untuk memilih selalu dimiliki oleh komunitas rantai aplikasi mana pun.

Jika ada appchain di Jaringan Octopus memilih untuk berhenti menggunakan LPoS untuk berubah menjadi blockchain PoS independen, Octopus bahkan akan menyediakan alat untuk mendukung transformasinya — Koneksinya dengan Jaringan Octopus kemudian akan diturunkan ke jembatan IBC standar dan aset lintas rantai yang ada tidak akan terpengaruh.
Gambaran Umum Jaringan Octopus

Legenda: D-Delegator, S– Staking, V– Validator, RT – Runtime, N– Node
Relay Octopus terletak di inti Jaringan Octopus. Octopus Relay adalah satu set kontrak pintar yang berjalan di blockchain NEAR (alias mainchain) yang mengimplementasikan pasar leasing keamanan.

Rantai aplikasi gurita duduk di sisi permintaan pasar. Rantai aplikasi Octopus menyewakan keamanan dari pemegang $OCT dengan membayar sewa dalam token asli mereka. Setiap rantai aplikasi dapat memilih model ekonominya sendiri, termasuk berapa banyak token asli yang bersedia membayar Validator untuk keamanan.

Validator dan Delegator Octopus duduk di sisi penawaran pasar leasing keamanan.

Octopus Validators mempertaruhkan token $OCT untuk memvalidasi rantai aplikasi tertentu dan menyiapkan simpul untuk menjalankan protokol rantai aplikasi itu. Sebagai imbalannya, Validator berhak menerima token asli masing-masing dari rantai aplikasi yang mereka validasi.

Delegator Octopus dapat mendelegasikan $OCT mereka ke Validator untuk mendapatkan bagian dalam hadiah taruhan token asli rantai aplikasi. Hadiah staking didistribusikan ke Delegator langsung setelah Validator mengumpulkan komisi terpadu.

Jika Validator berperilaku buruk (misalnya offline, menyerang jaringan, atau menjalankan perangkat lunak yang dimodifikasi), mereka (dan Delegatornya) dipotong dengan kehilangan persentase dari $OCT yang dipertaruhkan. Semua hukuman diterapkan pada Delegator secara proporsional ketika Validator mereka ditebas. Dengan cara ini, mengintai bertindak sebagai disinsentif untuk perilaku jahat.

Karena pemegang $OCT bertanggung jawab untuk memutuskan rantai aplikasi mana yang ingin mereka pertaruhkan, Jaringan Octopus berfungsi sebagai pasar bebas di mana rantai aplikasi dapat menyewakan tingkat keamanan yang mereka butuhkan dengan harga pasar kapan saja.

Octopus Network juga memiliki serangkaian alat untuk penyedia keamanan, seperti alat manajemen dan penyebaran otomatis node validator appchain, pandangan ekonomi jaringan, dan alat analisis statistik.

Pasar Octopus Network LPoS memungkinkan pengembang, proyek, atau pengusaha mana pun dengan cepat, efisien, dan terjangkau membuat rantai aplikasi mereka sendiri di NEAR.

Tetapi Jaringan Octopus juga mendukung rantai aplikasi dalam banyak cara lain termasuk menyediakan interoperabilitas lintas rantai, infrastruktur bawaan, dan komunitas yang siap terlibat.




	

	
	
		
			
				Apa keuntungan dari LPos?
			
		

		
					

		
			
			
			
			LPoS lebih cost-effective
		
			
			LPoS sangat flexible
		
			
			LPoS bersifat skalabel
		
			
			Semua benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interopabilitas
Sekarang tidak terlalu kontroversial untuk menegaskan bahwa semua blockchain publik dan jaringan multichain pada akhirnya akan saling berhubungan — membentuk Internet Blockchain. Octopus Network secara khusus dirancang untuk menjadi bagian dari ini.

Tim Octopus (sebelumnya dikenal sebagai Cdot) telah mengerjakan protokol interoperabilitas blockchain universal IBC dan integrasi lintas-rantai selama lebih dari dua tahun.

Relay Octopus memungkinkan interoperabilitas rantai aplikasi dengan protokol NEAR dan Ethereum melalui Rainbow Bridge. Selain itu, rantai aplikasi dapat menggunakan palet IBC out-of-box untuk terhubung dengan blockchain yang diaktifkan IBC secara langsung.

Aset apa pun yang dikeluarkan di Ethereum, NEAR, atau blockchain yang diaktifkan IBC dapat ditransfer ke dan digunakan oleh rantai aplikasi Octopus tanpa kepercayaan. Sebaliknya, aset apa pun yang dikeluarkan pada rantai aplikasi dapat ditransfer tanpa kepercayaan ke Ethereum, DEKAT, dan semua blockchain yang diaktifkan IBC.

Berdasarkan interoperabilitas tanpa batas antara Octopus Network dan NEAR, berbagai aset kripto yang dikeluarkan pada rantai aplikasi Octopus juga akan berkontribusi pada kemakmuran ekosistem DeFi NEAR.
Infrastruktur
Jaringan Octopus menyediakan satu set lengkap infrastruktur untuk rantai aplikasi — termasuk API Gateway, Blockchain Explorer, Archive Gateway, dll.

Octopus Bridge akan menerapkan kontrak pembungkus NEP-141 di NEAR untuk setiap token asli appchain. Kemudian dompet dan pertukaran dapat mengintegrasikan token pembungkus standar daripada harus berintegrasi dengan setiap rantai aplikasi secara individual.

Jadi, tim rantai aplikasi hanya perlu fokus pada waktu proses Substrat dan pengembangan front-end sementara Jaringan Octopus menangani semua kebutuhan teknis lainnya.
Komunitas
Sebuah cryptonetwork dimiliki oleh komunitasnya. Inilah inti dari desentralisasi dan perbedaan mendasar dari platform Web2.0.

Octopus Network bertindak sebagai komunitas meta untuk memelihara ratusan komunitas aplikasi Web3.0. Pengembang aplikasi Web3.0 dan pendiri rantai aplikasi dapat menampilkan keunggulan jaringan kripto mereka untuk menarik berbagai pendukung — seperti investor, Validator, Delegator, dan peserta protokol.

Pengguna yang tertarik dengan aplikasi Web3.0 yang berbeda akan memperhatikan aplikasi favorit mereka melalui acara seperti peluncuran rantai aplikasi Octopus. Dengan cara ini, Octopus adalah basis komunitas untuk rantai aplikasi untuk mendukung perjalanan mereka sendiri dalam membangun komunitas aktif di sekitar mereka.

Octopus Network juga menyediakan forkability yang hebat untuk semua rantai aplikasinya, sehingga tidak ada artinya bagi semua jenis taipan atau tiran untuk mengambil alih rantai aplikasi tanpa persetujuan dari komunitas — menjaganya agar tetap terdesentralisasi. Octopus akan melayani semua rantai aplikasinya dengan kemampuan fork dengan mengarsipkan riwayat blok rantai aplikasi ke Arweave — protokol penyimpanan permanen terdesentralisasi.

Berdasarkan riwayat blok yang diarsipkan, setiap rantai aplikasi dapat di-fork pada ketinggian berapa pun untuk menjadi rantai aplikasi baru jika komunitasnya mendukung fork tersebut. Dan tim inti rantai aplikasi mana pun dapat diganti jika kehilangan kepercayaan dari komunitasnya. Ini adalah bagaimana kesadaran pengguna memastikan desentralisasi.
Apa itu Program Akselerator Octopus?
 



Tim Octopus sangat menyadari bahwa ruang blockchain masih hanya sebagian kecil dari seluruh industri internet. Dan di dalam ruang blockchain, pengembang kontrak pintar Solidity jauh lebih produktif daripada pengembang Substrat.

Untuk menemukan dan menarik proyek rantai aplikasi yang luar biasa, tugas pertama adalah mengubah pengembang Web dan Soliditas menjadi pengembang Substrat. Dalam hal ini, tim Octopus sangat berpengalaman.

Tim Gurita telah berhasil membangun IBC untuk Substrat dan juga telah menawarkan kursus pelatihan online Substrat di China dengan penggemar Substrat lainnya. Kursus-kursus ini melatih batch pertama pengembang Substrat di China, yang menginisialisasi asal-usul Komunitas Substrat China. Pengembang Octopus juga merupakan penyelenggara komunitas Rust di China (termasuk RustCon).

Hingga saat ini, banyak anggota tim Octopus telah menjabat sebagai asisten pengajar untuk kursus tersebut, yang sekarang menjadi kursus resmi yang didanai oleh Parity, Inc. Berdasarkan pengalaman ini, kami sedang bernegosiasi dengan mitra di seluruh dunia, termasuk tim pendidikan NEAR, untuk menyediakan kursus pelatihan serupa secara global.

Tetapi Octopus menyadari bahwa pengembang Substrat yang memenuhi syarat bukanlah segalanya yang dibutuhkan oleh proyek aplikasi Web3.0 yang sukses. Inilah sebabnya kami meluncurkan Program Akselerator Gurita — kumpulan kursus dan seminar terbuka dan dapat disusun yang tersedia untuk pengembang Substrat dan tim Web3.0 di seluruh dunia.

Setiap kuartal, Program Akselerator Gurita akan mengadakan serangkaian kursus yang berlangsung selama sepuluh minggu. Selama setiap periode kursus, mata pelajaran yang ditawarkan akan mencakup topik seperti Token Economics, Web3.0 Product Design, Community Building, Blockchain Governance, Crypto Regulation, dan Crypto Project Fundraising. Pakar yang diundang akan berpartisipasi dalam seminar, memberikan video tentang topik tertentu, dan tersedia sebagai mentor.

Di akhir setiap batch kursus, Octopus Foundation akan mengadakan acara Demo Day untuk memilih lima proyek rantai aplikasi teratas dan memberi mereka total hadiah hingga $250 ribu per kuartal.

Dengan cara ini, Yayasan Octopus akan secara langsung mendanai 20 proyek rantai aplikasi melalui Program Akselerator Gurita setiap tahun, memberi mereka lebih dari $1 juta secara total.




	

	
	
		
			
				Apa yang benar terkait Development Octopus Team?
			
		

		
					

		
			
			
			
			Team Development Octopus membantu pembangunan IBC untuk substrate
		
			
			Team Dev Octopus membantu training Substrate dev di China
		
			
			Team Dev Octopus sebelumnya dikenal sebagai Cdot
		
			
			Semuanya benar
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Bagaimana Appchain Go Live di Octopus


Desain arsitektur Jaringan Octopus — bersama dengan kekuatan pemrosesan Protokol NEAR — memudahkan untuk menampung ratusan rantai aplikasi. Proses pemilihan rantai aplikasi adalah bagian dari protokol Octopus dan kekuatan pengambilan keputusan dimiliki oleh Komunitas Octopus.

Selain menjadi Validator dan Delegator rantai aplikasi, pemegang token $OCT memiliki hak untuk memilih proyek rantai aplikasi terbaik dengan menaikkan atau menurunkan suara dalam antrian kandidat di rantai.

Rantai berbasis substrat dapat menjadi rantai aplikasi Octopus dengan berhasil menyelesaikan tahapan berikut:

 	Registrasi
 	Audit
 	Pemungutan suara
 	Memanggungkan
 	Booting

Registration Stage
Rantai berbasis substrat apa pun dapat mengajukan permohonan untuk menjadi rantai aplikasi Octopus. Pendaftaran memerlukan kertas putih atau spesifikasi dan rilis runtime yang telah diuji dan diaudit secara internal. Untuk mencegah penyalahgunaan, pendaftaran memerlukan setoran kecil sebesar $OCT.
Tahap Audit
Setelah rantai aplikasi terdaftar, anggota gugus tugas komunitas akan mengauditnya. Tujuan audit adalah untuk memastikan bahwa rantai aplikasi tidak memiliki kerentanan keamanan yang diketahui dan bahwa logika aplikasinya konsisten dengan kertas putih atau spesifikasinya.

Audit Appchain sendiri saat ini merupakan kebutuhan yang tidak terpenuhi di ruang blockchain. Hanya beberapa perusahaan di industri yang memiliki pengalaman yang relevan dan layanan yang mereka berikan mahal.

Audit yang dilakukan oleh Jaringan Octopus tidak hanya sangat mengurangi biaya peluncuran rantai aplikasi untuk para pendirinya, tetapi juga berkontribusi pada akumulasi pengetahuan yang relevan dan kemampuan profesional.
Tahap Voting
Setelah rantai aplikasi melewati fase audit, ia memasuki antrian kandidat di mana ia akan di-upvote atau diturunkan oleh pemegang $OCT.

Dalam periode bergulir yang berlangsung selama satu hingga dua minggu, rantai aplikasi yang menempati urutan pertama dengan jumlah upvotes paling banyak dikurangi dengan downvotes dalam antrian akan memasuki staging state sebagai rantai aplikasi yang paling didukung oleh Komunitas Octopus.
Tahap Staging
Pada tahap pementasan, pemegang $OCT dapat mempertaruhkan atau mendelegasikan pada rantai aplikasi.

Ketika periode pementasan berakhir, jika rantai aplikasi telah menarik cukup banyak taruhan di luar garis dasar keamanan, itu akan memasuki status booting.
Booting Stage
Pada tahap booting, anggota gugus tugas akan menjalankan 4 node bootstrap untuk memulai rantai aplikasi. Kemudian Validator harus menjalankan node mereka untuk bergabung dengan konvensi appchain.

Jaringan Octopus juga akan menjalankan cluster node penuh untuk setiap rantai aplikasi dan menyediakan layanan akses API ke front-end rantai aplikasi. Pengembang Appchain kemudian hanya perlu menyiapkan front-end, dan appchain siap untuk pengguna akhir.
Appchain Rewards
Octopus mengakui bahwa proyek rantai aplikasi adalah pencipta nilai jaringan. Sementara jaringan multirantai lainnya mengenakan biaya masuk untuk rantai aplikasi, Octopus menganggap tim rantai aplikasi sebagai bagian paling penting dari komunitas dan dengan senang hati berbagi manfaat perluasan efek jaringan dengan mereka.

Oleh karena itu, 100 rantai aplikasi Octopus pertama yang diluncurkan akan langsung diberi hadiah 100rb $OCT.

Selain itu, yayasan telah memutuskan untuk memberikan hadiah tambahan 1 juta $OCT untuk sepuluh rantai aplikasi pertama yang mengakui mereka sebagai rantai aplikasi pendiri.
Apa itu token $OCT?
$OCT, token asli dari Octopus Network, adalah token non-inflasi yang sepadan dengan tiga utilitas utama:

 	Jaminan untuk menjamin keamanan rantai aplikasi
 	Pemerintahan
 	Mendukung kandidat rantai aplikasi dengan meningkatkan mereka dalam antrian kandidat

Jaminan Keamanan
$OCT memainkan peran kunci dalam Jaringan Octopus melalui staking rantai aplikasi. Pemegang mempertaruhkan $OCT mereka untuk memberikan keamanan pada rantai aplikasi yang mereka yakini untuk mendapatkan hadiah di token asli masing-masing rantai aplikasi.

Staking $OCT juga bertindak sebagai disinsentif bagi peserta jahat yang akan dihukum dengan memotong $OCT mereka, yang merupakan sumber keamanan yang disewa untuk rantai aplikasi Octopus.

Ketika Octopus berjalan dalam kapasitas penuhnya, 30-50 rantai aplikasi akan diluncurkan di jaringan setiap tahun.

Jika tingkat pengembalian ekuilibrium jangka panjang dari taruhan rantai aplikasi adalah 5% per tahun, rantai aplikasi yang baru diluncurkan saja akan menghasilkan sekitar $400 juta dalam tuntutan jaminan setiap tahun.
Pemerintahan
Fungsi kedua $OCT adalah memberikan hak kepada pemegangnya untuk mengontrol tata kelola jaringan, (lebih khusus lagi, Relay Octopus di mana semua aturan ekonomi berlaku,) dengan membentuk Octopus DAO.

Dewan DAO Octopus memiliki maksimal 100 anggota, tetapi kemungkinan besar akan bertambah dari beberapa anggota di awal menjadi beberapa lusin saat stabil.

Kekuatan pemerintahan setiap anggota Dewan sangat berharga tetapi masih cukup tersebar untuk menghindari kolusi.

Menurut pendapat kami, dalam banyak kasus, nilai tata kelola token tidak dapat dipisahkan dari nilai utilitasnya. Tata kelola yang baik dan berpartisipasi secara luas akan memberikan harapan nilai yang lebih stabil kepada pemegang token dan menekan fluktuasi ekstrim dalam harga token, sehingga mengurangi biaya opsi implisit dari taruhan rantai aplikasi.
Voting Rantai Aplikasi
Fungsi ketiga dari $OCT melalui pemegang $OCT adalah pemilihan rantai aplikasi mana yang akan terus hidup di jaringan dengan menaikkan atau menurunkan suara pada kandidat rantai aplikasi.

Tim Appchain perlu meyakinkan komunitas Octopus bahwa aplikasi Web3.0 mereka bermakna dan akan menciptakan aliran nilai berkelanjutan bagi investor yang mempertaruhkan $OCT di rantai aplikasi mereka.

Pemegang $OCT akan memilih rantai aplikasi mana yang mereka dukung dengan hati-hati, karena ada biaya peluang kehilangan rantai aplikasi yang bisa lebih berharga.
Kesimpulan
Kami menamai Jaringan Gurita setelah makhluk bentik laut yang paling cerdas. Dari perspektif evolusi, gurita, yang terdiri dari sekitar 300 spesies, adalah organisme yang sangat sukses. Sudah ada selama 155 juta tahun, hidup di setiap lautan, dan banyak spesiesnya telah berhasil beradaptasi dengan berbagai habitat laut yang beragam.

Kami sepenuhnya mengharapkan Jaringan Octopus untuk memberikan aplikasi terdesentralisasi untuk setiap industri online yang sebelumnya telah dikendalikan oleh perantara tradisional Web2.0 — dan mengembalikan nilai kepada pencipta sebenarnya.

Di Octopus Network, kami dapat membangun aplikasi Web3.0 dengan pengalaman pengguna yang luar biasa dengan memanfaatkan teknologi rantai aplikasi — baik dalam game, NFT, DAO, periklanan, ekonomi kreator (video, audio, grafik, teks), pasar prediksi, token curated registry (TCR), dan banyak lagi.

### What are (L)Earner NFTs?

An exciting new NFT collection recently dropped in the NEAR Ecosystem. Before we explore what the (L)Earner NFT collection is, here is a brief summary of what an NFT is. Feel free to skip over it if you’re already familiar with NFTs.
What is an NFT?
NFT stands for Non-Fungible Token. NFTs are unique digital assets that have their identifying information recorded on a smart contract. The information on the smart contract is what makes an NFT unique. An NFT is a non-fungible asset. Non-fungible assets are not divisible. For example, you can’t send someone a part of a painting or a ticket.

NFTs are digital certificates of ownership for digital assets. An NFT is a smart contract that is utilized for securing a digital asset. Once written, it is published into a token (ERC-721 or NEP-171) on the blockchain. Anything can be turned into an NFT, with the most popular being videos, GIFs, or JPEGs.
What is the (L)Earner NFT Collection?
The (L)Earner NFT Collection is a collaboration between the Learn Near Club (LNC) community and Denis Bashev, one of the best award winning graphic designers in Europe. 
Design Concept
The design concept is based on dynamic human intelligence diversity powered by the uniqueness of every learner. Every human is a unique individual that has diverse learning patterns, strengths and weaknesses. The (L)Earner NFT Collection aims to highlight the individuality of each learner and how different cogs interact in the machine to create a holistic person, each with their own unique dreams, fears, experiences and personality.



For those unfamiliar with how we learn on a scientific level here is the gist of it: 
When you actively engage in learning something, neurons (brain cells) begin forming connections between each other. At first these connections are very weak, and the knowledge isn’t fully committed to long term memory. As time progresses and you spend more time learning about a concept, these connections become stronger and get committed to long term memory. Your knowledge is actually stored in billions of neural connections between neurons in the human brain. This process is called Hebbian learning.



The idea of the stick figures is based on the human nervous system. The segments that the stick people are composed of are inspired by the Myelin sheaths which help electric impulses be transmitted through neurons.

 

The character poses embody the countless combinations of neural connections that amalgamate in their own microcosms to form distinct long term memories of a concept or activity. Line segments are plotted on a cartesian plane to create fun poses.

 

The color pallet was carefully selected by Denis to bring life, and add a more playful tone to the stick people. It symbolizes the joy of learning. The joy of learning isn’t something that can just be felt with instant gratification. It is the culmination of all of the ways that the thirst for new skills and knowledge has improved your life and the lives of those around you.


Now you know what this emoji 🕺 actually stands for - 🕺 is basically a (l)earner!
Check out Sasha's talk about NFTs in general and (L)Earner in particular

https://youtu.be/Z9gYY-z2tms
Minting
All NFT minters are invited to participate in this cutting edge project. The mint cost started from 2 $NEAR and gradually increases as the collection grows towards its limit of 10,000 NFTs. Minters can:

 	Generate- the software generates a random posture, and mix of colors as many times as you like, so that you get the (L)Earner NFT that you want. Most NFTs on the market are “generated” from pre-built models, while (L)Earner NFTs have a virtually unlimited number of combinations creating an NFT that is truly unique to you.


 	Name- give a name to your (L)Earner NFT, make it as unique as your character 


 	Mint- mint your NFT and secure it on the NEAR blockchain.


 	Curate- collect as many as you want and curate your original, personal collection
 	Trade- buy and sell (L)Earner NFTs on the Paras NEAR NFT Marketplace

(L)Earner  NFT LNC Benefits
Not only do you get a cool NFT when you mint a (L)Earner NFT, you also get handy perks as an official LNC community member:

 	Priority 2 hour early access to the Redeem to NEAR window
 	Your own CalenD
 	Mint Proof of (L)Earn NFTs
 	More to come in the future…

Join the LNC telegram group to share your (L)Earner NFT with other members of the community.
Learn NEAR Club Swag store
NEW! Now you order your very own (L)Earner NFT as real life sticker from LNC Swag store


Conclusion
The (L)Earner NFT collection is a cutting edge collaboration between LNC and Denish Bashev (award winning graphic designer). The aim of the project is to encapsulate the individual learning experience of each learner into an NFT. The collection is limited to 10 000 NFTs so get yours while you can!

### Update - August 23, 2022

Brief Summary:

 	
(L)Earner NFT is getting momentum!


Results:

 	Compete express community course and become a "NEAR Power User"
 	🕺 618 (L)Earner NFTs minted so far! Minting cost increases gradually with every mint and will reach 10 $NEAR for (L)Earner #10,000
 	
 	💸  Ⓝ876 July and Ⓝ812 August Redeem window were sent to participated (L)Earners

 	Bye-bye, spammers! We gonna [not] miss you! Hello, nCaptcha - web3 Catpcha is live on LNC!


 	🧑‍🤝‍🧑 LNC community members is over 42,800 (L)Earners!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	✅LNC for NEAR projects is coming!

### Multiverse Fighters - First Patch

List of changes and updates in Multiverse Fighters. To play, you will need NEAR Wallet on testnet and don't forget to save the seed phraseDevelopment tools1. Implemented functionality for game designers, giving the opportunity:- to create skills- to create and edit bots (inventory, deck, etc.)- to create stuff for bots- to adjust the balance without the participation of the developer2. The NFT test base has been updated, new types of NFT have been addedGame / Game Mechanics1. Added a level and leveling of the character (the ability for the player to distribute the attributes obtained with each level)2. Races (NFT) added to the game3. Class and Race now have even more influence on the style of play:- when using Class, in addition to cards, the characteristics of the player change- when using Race, some characteristics change for the better, and others for the worse. Examples of races: Human, Elf, Beastman.4. Added 2 new classes that are undergoing balancing 5. Added new weapons and armor (two-handed weapons, light and heavy armor) it now gives characteristics to the character6. The Power of the player (or bot) is implemented, the number of tokens received and experience in battle, as well as the search for an opponent depends on the Power7. Implemented a world map with multi-level mobs (still in the test version)8. Added 16 first mobs, with special skills and different difficulty levels9. Updated battle search systemEconomy / Token / NFT / Blockchain 1. Basic economy launched:- The MFIGHT token was added to ref finance in the NEAR test network, a NEAR/FIGHT pair was created- Added the ability to mint and buy NFT for a game token2. Each NFT has unique characteristics that vary depending on the rarity3. Added a smart contract for the experience token4. Implemented NFT upgrade due to experience token and a game token5. Implemented accrual of rewards in battles (main token and experience token)6. A tool for generating NFT traits has been preparedCharacter Profile / Social Tabs1.The system of Clans is implemented in a basic way. You can create a clan, upload a logo and invite users, in the future the functionality will be expanded and transferred to the blockchain2. ORDERS3. Updated the design of the Profile page4. Player titles are implemented (they can be obtained for activity in the project)5. PvP/PvE statistics were separated6. Implemented Favorite NFT, now you can choose the NFT that will be displayed in your profile7. Implemented viewing of achievements (NFT received for special events in the game)8. Added viewing of recent fights9. Token claim added10. Added a graph-diagram of the game on the classes11. Added a profile editing page (nickname, motto, description and avatar)12. The player's decency parameter is implemented, it changes from the good / bad behavior of the player in the game (do not surrender, do not leave the game until the end)13. Implemented game chat (basic)Implemented viewing of Online players at the location14. Added a leaderboard (in the test version) with the display of top players by winrate and other parameters15. The tournament bracket is divided into groups for easy viewing with a large number of people16. A smart contract for reputation (token) has been implemented into the game17. Now you can view the profile of other players.Website1. Implemented functionality for filling Wiki pages, as well as individual pages on the site for viewing the wiki (Work on the Wiki is underway)2. Implemented a system of notifications on the site (both personal and general)Base / ServerFunctionality has been prepared on the server to create analytics in the game (the number of new players by dates, the use of classes, the ratio of class wins, the number of fights by dates, the number of tokens received (basic and experience) by dates)

### NearKits: Ce Que Vous Devez Savoir

NearKits
Ok donc Nearkits est un Portfolio Tracker… Ou c'est comme ça qu'il a commencé. Nous le connaissons tous comme un outil sur lequel nous pouvons vérifier notre portefeuille NEAR NFT, pour ma part, je l'ai utilisé d'innombrables fois pour vérifier tout au long de ce marché rouge. Ils permettent également un service de transfert NFT entre portefeuilles, puis un service de messagerie NFT, j'y reviendrai dans un instant.

Au moment où j'écris ceci aujourd'hui 21/05/22, ils frapperont leur NFT 7PM UTC une collection 333 avec différents niveaux, argent, or et rubis et le coût du mint est de 10N et 50% des redevances secondaires seront distribuées aux détenteurs… Oh et oui Je mentionne qu'ils sont également sous l'égide d'Antisocial Studios




La Feuille de Route




Phase 1
Ok donc avec la phase 1 terminée qui comprenait un endroit pour vérifier la valeur de votre portefeuille Near NFT en USD et NEAR avec un prix moyen de tous les NFT, la possibilité de pouvoir transférer des NFT entre différents portefeuilles, la possibilité de pouvoir envoyer un message à un NFT propriétaire, ainsi, par exemple, si vous voyez un NFT que vous souhaitez ou si vous avez peut-être une offre, vous pouvez trouver son adresse et envoyer un message directement à son portefeuille. Vous avez également une galerie NFT très simplifiée, mais rien à célébrer.

Phase 2
C'est l'étape de Minting, donc une collection de 333 NFT et différents niveaux appelés cartes d'accès, ce qui vient d'autre avec ceci est :

 	Liste d'outils par lots
 	Outil de transfert NFT par lots
 	Outil d'enchères NFT par lots
 	Marché et traqueur de baleines
 	Liens de galerie personnalisés
 	Robots tireurs d'élite
 	Suivi des prix NFT basé sur la rareté

Phase 3
Ainsi, une fois la phase 2 terminée, nous passons à la phase 3 et nous obtenons :

 	Des robots de serveur Discord sophistiqués
 	Un service d'abonnement (Non titulaires)
 	Salle de lancement Protocole NEAR
 	Outil d'analyse de jetons
 	Extension de navigateur NEARKits




Avant-goût du NearKits NFT








Ceux-ci rappellent les types de cartes d'accès de type portails NFT, mais ce sont les outils derrière ceux-ci qui donneront envie aux investisseurs d'en avoir un et avec seulement 333 fournitures et un mint  WL seulement, il sera intéressé de voir comment cela se passe en secondaire.

Voici également ce qu'ils font quotidiennement sur leur Twitter pour tenir leur communauté au courant des prix NEAR NFT FP




Il s'agit d'un projet qui est venu dans l'écosystème NEAR avec une mentalité de construction des services publics d'abord et de fournir les services publics que nous voulons ou dont nous avons besoin.

(Avis de non-responsabilité : je fais partie de leur équipe en tant que conseiller)
Conclusion
Donc, selon le moment où vous lisez ceci, vous pourriez minting ou saisir l'un des secondaires, j'espère que je vous ai donné suffisamment d'informations pour prendre une décision éclairée GURU, comme d'habitude, suivez toujours cet instinct aussi

Liens pour les retrouver sur :

Twitter: https://twitter.com/NearKits_io

NearKits: https://nearkits.io/#my_nfts
Discord: https://discord.gg/wh3GrGhbfB

### ¿Qué es Roketo?

Entonces, ¿qué es exactamente Roketo? ¿Por qué elegirías la criptomoneda como método de pago? ¿Y en qué se diferencia de las docenas de otros servicios de criptopagos que existen?’ — Escuchamos muchas veces estas preguntas y recopilamos nuestras mejores respuestas en este artículo.
A continuación, explicaremos cómo funciona Roketo y por qué cambiará radicalmente tu proceso de pago.

Muchas empresas luchan por encontrar una forma de pago rápida y confiable, especialmente si sus equipos están distribuidos en varias jurisdicciones. En este caso, la criptomoneda te ahorra la molestia de las transferencias bancarias internacionales, que pueden llevar mucho tiempo y requerir algunos trámites.
Roketo es un servicio de transmisión de criptomonedas que te permite pagarle a personas y a servicios por segundo. La baja comisión, la alta velocidad de las transacciones y la transparencia lo convierten en una solución perfecta para la entrega de nómina. Nuestros clientes utilizan nuestro servicio para pagar a los empleados, enviar fondos de subvención de forma transparente,  depositar sus propios tokens y otorgar ganancias a sus inversores. La transmisión en tiempo real también es útil cuando se trata de servicios de pago por minuto, como estacionamiento de automóviles, alquiler de equipos o trabajo conjunto.

¿Cómo funciona?
Roketo se vincula a la billetera de un usuario y transmite fondos a los destinatarios en tiempo real. El pagador inicia sesión con NEAR wallet, configura una transmisión, su duración y otras configuraciones, ingresa la dirección de la billetera del destinatario y luego comienza a transmitir el dinero. Los fondos se entregan a la billetera de flujo del destinatario, quien luego puede retirarlos para convertirlos.





¿En qué se diferencia de otras soluciones del mercado?
Comisiones bajas

Roketo está construido y corriendo en NEAR y esto nos permite mantener una de las comisiones más bajas del mercado. Mientras que nuestros competidores cobran entre 50 y 100 dólares por transmisión, la configuración de cada transmisión de Roketo cuesta menos de 1 dólar. Además de eso, tendrás que pagar la tarifa de gas por tus transacciones, que en el ecosistema NEAR también es más baja que en otras cadenas de bloques. Solo una comparación: en Etherium el costo por transacción es un poco más de $1 y en NEAR cuesta solo unos centavos.

Esto significa que con Roketo, los remitentes pueden configurar eficientemente cientos de transmisiones al menor costo posible y los destinatarios pueden retirar dinero con la frecuencia que prefieran.

Transacciones rápidas.

La transmisión en tiempo real significa que sus fondos llegan cada segundo a cierta velocidad y sus destinatarios pueden retirarlos en cualquier momento. Puedes olvidarte de las horas de espera en otros servicios, por no hablar de los días cuando se trata de instrumentos financieros tradicionales.

Transparencia

Nuestros clientes obtienen total transparencia en la asignación de fondos y la entrega de nómina. Incluso cuando realizan pagos masivos a sus inversores o comunidad, las empresas aún tienen control total sobre la asignación de tokens en tiempo real. Cada transmisión tiene una URL única en donde puedes realizar un seguimiento de la distribución. Facilita la planificación financiera, el pago de impuestos y la presentación de informes.

Interfaz intuitiva

No necesitas más de un minuto para configurar tu primera transmisión en Roketo. Se puede acceder y actualizar fácilmente todas las opciones para el control de flujo tanto desde el receptor como desde el remitente sin terceros. Pausa, reanuda, detén, extiende las transmisiones y obtén el historial completo de operaciones en la dApp. La interfaz de usuario es cómoda de usar incluso para los miembros del equipo sin conocimientos de cripto.
Recientemente hemos asegurado $900,000 en la ronda inicial con la participación de Move Capital, MetaWeb Ventures y A&T Capital. Esta inversión nos ayudará a desarrollar nuestro producto aún más rápido, así que será mejor qué estés atento a las nuevas actualizaciones.



Enlaces:

 	Únete a nuestra comunidad en Twitter
 	Chatea con nosotros en Telegram
 	Únete a nosotros en Github
 	Prueba Roketo Protocol

Visita nuestro Website

### Flujo de Datos NEAR

Explicación del Video ​​
En el video a continuación, hemos tratado de brindar una descripción general rápida del concepto principal de cómo fluyen los datos en la cadena de bloques NEAR Protocol. Encontrarás una versión en texto debajo del video.


Versión en Texto






El flujo de datos de la cadena de bloques del Protocolo NEAR puede ser un poco complicado a simple vista. Pero es bastante sencillo y sigue reglas bien definidas. En este artículo, veremos más de cerca cómo fluyen los datos en la cadena de bloques del Protocolo NEAR.

De hecho, cualquier flujo de blockchain se puede representar como una línea de tiempo infinita que tiene un comienzo pero no un final.





Y aparece un bloque en esa línea de tiempo con algún intervalo. Cada uno de estos bloques contiene la información sobre el anterior, creando así una cadena de bloques.

El protocolo NEAR tiene una naturaleza fragmentada (sharded), lo que significa que más de una red paralela, denominada Shard, puede ser en vivo en cualquier momento. Y cada Fragmento produce una parte de un bloque en un intervalo determinado. Un bloque en ma cadena de bloques NEAR es una colección de fragmentos de bloques de todos los fragmentos. El fragmento de bloque se reduce a Chunk en la documentación del Protocolo NEAR.

Volviendo al flujo de datos en sí. Lo mejor que podemos hacer es imaginar pistas como las que podríamos ver en las aplicaciones de edición de audio/video. Cada fragmento tiene su propio conjunto de pistas. La pista superior es para Chunks. Aparecen sin importar qué, en un intervalo dado; para NEAR Blockchain el intervalo es de aproximadamente un segundo. Se producen fragmentos incluso si no sucede nada en la cadena de bloques.



Pero, ¿qué queremos decir cuando decimos que algo está pasando? Queremos decir que algo ha desencadenado algunos cambios en la cadena de bloques. Y el método más conocido para activar cualquier cambio es enviar una Transacción a la cadena de bloques con instrucciones de lo que queremos cambiar y quién ha solicitado esos cambios.

Una transacción debe construirse, firmarse y enviarse a la cadena de bloques. Una vez ejecutado esperamos tener un resultado – ExecutionOutcome. Oh, eso es simple. Pero no es realmente preciso para NEAR Blockchain.



Al principio hay una Transacción, contiene instrucciones que queremos que se ejecuten en la cadena de bloques. La transacción se envía a NEAR Blockchain.

Y sí, se ejecuta allí inmediatamente PERO el resultado inmediato de la ejecución de la transacción siempre es sólo un reconocimiento de que se ejecutará en la cadena; esta solicitud de ejecución interna se conoce como Recibo o Receipt. Puede pensar en el Receipt como una transacción interna que existe para pasar información a través de fragmentos.

Volvamos a las pistas para ver el ejemplo.

Suponiendo que tenemos dos cuentas viviendo en diferentes Shards alice.near y bob.near. alice.near crea una Transaction para enviar algunos tokens a bob.near. La transaction se ejecuta inmediatamente y el resultado de ejecución (ExcecitionOutcome) de la transaction es siempre un recibo.

Pero este recibo no se puede ejecutar aquí, porque bob.near no vive en el mismo fragmento que alice.near, por lo que el recibo (Receipt) debe ejecutarse en el fragmento (Shard) del recibo (Receipt). Entonces, el recibo se está moviendo al fragmento al que pertenece bob.near.

En el Shard de destino se ejecuta el Receipt y el proceso se considera finalizado.
LA EXPLICACIÓN AQUÍ ES SIMPLIFICADA
Consulta el artículo Flujo de transferencia de tokens

Así que el esquema final se verá así:


Resumen​
Hemos aprendido los principios fundamentales de cómo fluyen los datos en NEAR Protocol. Hemos descubierto que las Transacciones se ejecutan y el Resultado de la Ejecución de la Transacción es siempre un Recibo.

Ahora sabemos que Receipt es un activo interno principal para la cadena de bloques del Protocolo NEAR y tiene el poder de viajar entre Shards. Aprendimos el flujo de datos NEAR en un ejemplo simple. Por supuesto, en la vida real, con transacciones más complejas, que implican llamadas entre contratos, habrá más recibos (Receipts) y resultados de ejecución (ExecutionOutcomes).

Esperamos que este artículo sea útil y que puedas crear tus dApps e indexadores fácilmente con el conocimiento de cómo fluyen los datos en el Protocolo NEAR.

### Pruebas de Simulación (Rust)

Antes de qué empecemos
Este artículo no muestra las posibilidades de lo qué un marco de prueba de simulación puede hacer; Este artículo analiza cómo crear un marco de prueba de simulación MVP (Producto Mínimo Viable) para su proyecto.  Para cambios más avanzados, haga su propia investigación (DYOR) y consulte algunos enlaces incluidos en este artículo.
NOTA: Las pruebas de simulación quedarán obsoletas cuando aparezca Sandbox.  Consulte workspaces-rs y workspaces-js.

Breve Introducción
La diferencia entre las pruebas unitarias y las pruebas de simulación es qué las primeras están restringidas a las pruebas dentro de la biblioteca; mientras que las últimas simulan una llamada de afuera hacia adentro. Las pruebas unitarias en su mayoría prueban los marcos internos para la lógica correcta; mientras que las pruebas de simulación intentan simular las acciones del usuario y verificar si las cosas salen como espera el desarrollador. Trata cada función como una simulación.


Si estás pensando qué con una prueba de afirmación es suficiente, por favor no lo hagas. Incluso para las pruebas unitarias, yo no estoy de acuerdo en qué con una afirmación por marco de función de prueba basta; lo que significa que las pruebas de simulación requieren más de una afirmación dentro de una sola función/simulación.

Como de costumbre, el ejemplo más simple es la aplicación de Greeting (saludo); así que usaremos eso y escribiremos una prueba de simulación para ello.

Prueba de simulación de Greeting (saludo)
No necesitas escribir tu propia aplicación de saludo: simplemente ejecuta este comando:

npx create-near-app --contract=rust <your_project_name>
¡Listo! Ahora tienes un ejemplo de aplicación de saludo con una interfaz simple. Sigue las instrucciones para implementar el contrato y prueba con él hasta que estés familiarizado antes de continuar. Revisa las últimas líneas de la salida.
We suggest that you begin by typing: 
cd <your_project_name>
yarn dev
Copia el comando y prueba cómo funciona la aplicación hasta que estés familiarizado con ella. Después de la prueba, detén la implementación temporalmente: es bastante molesto volver a desplegar cada vez qué se realiza un pequeño cambio si no necesitamos la interfaz, desde mi punto de vista.

Crear carpeta de prueba de simulación
Sin considerar a NEAR, las pruebas de simulación también se denominan pruebas de integración en Rust (puro). Si deseas obtener más información, consulta The Rust Book (El libro de Rust) o Rust By Example (Ejemplos de Rust) para ver cómo realizar pruebas de integración.
En resumen, necesitas una carpeta completamente fuera de src llamada tests. Así que haremos eso ahora. Suponiendo que ya hiciste cd en el directorio de tu proyecto, ejecuta esto:

cd contract
mkdir tests 
mkdir tests/sim
touch tests/sim/main.rs
Navega y abre: <tu_nombre_de_proyecto>/contract/tests/sim/main.rs y ábrelo en el editor de tu elección.

Ahora, puedes volcar todo en un archivo o dividirlo. Generalmente, tienes un archivo utils.rs para hacer funciones que no son de prueba que se reutilizan. Puedes tener otro archivo .rs para múltiples pruebas cortas. Si tienes pruebas más largas, como las pruebas de simulación del contrato lockup (De bloqueo), se sugiere un archivo por prueba; y nombrar tu archivo en consecuencia. No querrás que tus lectores vean un archivo con más de 1000 líneas de código.

Ahora, aunque el contrato Greeting (Saludo) no tendría largas pruebas de simulación, yo te mostraré lo qué quiero decir con una prueba por archivo separándolos deliberadamente. Sin embargo, no tienes que hacerlo.
Incluye las Dependencias
Necesitamos una biblioteca llamada near-sdk-sim.  Este ejemplo usa near-sdk v3.1.0, por lo que usaremos el near-sdk-sim v3.2.0 correspondiente (aunque no sé por qué no coinciden).  Sin embargo, debes tener en cuenta que si la versión no coincide, las pruebas de simulación no se ejecutarán, porque dice Import near_sdk::some_fn is not equal to near_sdk::some_fn, lo cual es confuso (Porque en realidad near_sdk::some_fn es de hecho diferente de near_sdk::some_fn.


A mi realmente me gusta escribir con near-sdk v4.0.0-pre.4, pero eso requiere algunos cambios en el contrato para que funcione. Los cambios no son complicados, principalmente sobre AccountId que ya no es String y algunas otras cosas más pequeñas; pero ese no es el punto de este artículo, así que nos quedaremos con 3.1.0 y tal vez actualicemos este artículo en el futuro. (Además, hay un error con la simulación v4 del que hablaremos más adelante).

Vayamos a Cargo.toml: ahora debería verse así: (ver nueva sección dev-dependencies). ¡Es importante asegurarse de que rlib también esté presente!

[package]
name = "greeter"
version = "0.1.0"
authors = ["Near Inc <hello@near.org>"]
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "3.1.0"

[dev-dependencies]
near-sdk-sim = "3.2.0"

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

[workspace]
members = []

Anteriormente, escribí una guía sobre cómo reducir el tamaño del contrato; incluida la eliminación de "rlib". Sin embargo, para usar pruebas de simulación, se requiere "rlib", por lo que es una compensación entre el tamaño del contrato y la realización de pruebas de simulación.

Si has detenido yarn dev, ahora compila el contrato una vez para descargar la biblioteca. En contract, ejecuta:

cargo build
¡Asegúrate de tener mucho espacio en disco (se recomiendan 20 GB de espacio libre) ya qué ocupa bastante espacio!
Para una experiencia fluida durante la compilación por primera vez, intenta compilar en una máquina que tenga 16 vCPU y 8 GB de RAM. Especialmente librocksdb-sys tomará mucho tiempo para compilar. No está claro si la compilación es transferible (ciertamente no entre sistemas operativos, pero no estoy seguro dentro del mismo sistema operativo). Dado que alquilé una máquina virtual en Azure, fácilmente podría cambiar el tamaño temporalmente y volver a cambiarlo a un tamaño más pequeño (y más barato) después de la compilación, por lo tanto, no hay conflicto.

Volvamos a escribir las pruebas de simulación en main.rs.

Prepara el archivo wasm
Ten en cuenta: cada vez que realizas cambios en tu contrato, debes reconstruir el archivo wasm. Hicimos un script aquí para construir tu archivo wasm y moverlo a la carpeta res del directorio superior.
Así que ejecuta esto: (desde el directorio contract)

mkdir res 
touch build.sh
Luego, incluye el contenido a continuación dentro de contract/build.sh para que puedas ejecutar bash build.sh (dentro de la carpeta contract) en lugar de escribir el comando cada vez.
#!/bin/bash 
set -e 

export WASM=greeter.wasm 

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release 
cp target/wasm32-unknown-unknown/release/$WASM res/
Imports
Esto es fácil: tratamos a la biblioteca como una biblioteca. Recuerde, los que están pub(crate) originalmente en la biblioteca no se pueden usar en pruebas de simulación (ya que esto está afuera). Es como si lo compilaras y alguien estuviera usando tu código. Asegúrese de importar las funciones que necesita.
Si revisamos src.lib.rs, vemos que (solo) hay una estructura de Welcome (Bienvenida). Cuando lo importas, agregas la palabra clave Contract detrás. Por ejemplo:

use greeter::{
    WelcomeContract 
};
Para el contrato de bloqueo, su estructura principal se llama LockupContract, por lo que cuando lo importan, es LockupContractContract. Yo no sé por qué lo hicieron así, tal vez para evitar algún conflicto; solo agrégalo.

Incluir archivos de contrato
Lo siguiente antes de probar que funciona es incluir el archivo wasm. Esto es un requisito. Además, si tienes un utils.rs, NO debes colocarlo allí; de lo contrario, debes pensar mucho en cómo hacerlo reconocible desde otros archivos. Para no pensarlo mucho, lo ponemos en main.rs:

// Directories are relative to top-level Cargo directory. 
near_sdk_sim::lazy_static_include_bytes! {
      GREETER_WASM_BYTES => "res/greeter.wasm" 
      // other wasm bytes.  
}
Lo que significa "directorio de Cargo de nivel superior" es el directorio de contract. Ciertamente, puedes descubrir cosas fuera de él con ../../algun_archivo si alguna vez lo necesitas. Por ejemplo, si no usas res sino yarn dev,  out/main.wasm está fuera del directorio de contratos. Para importar eso, hacemos:
near_sdk_sim::lazy_static_include_bytes! {
     GREETER_WASM_BYTES => "../out/main.wasm" 
}

Dado que se trata de una macro, asegúrate de no poner accidentalmente una "coma" (",") después del último elemento; de lo contrario, puede recibir mensajes de error extraños y Rust se puede negar a compilar.

Desafortunadamente, no podemos probar esta función mientras, hasta que creemos la función auxiliar (un MVP completo) y una prueba MVP.

Función de inicialización
Para no repetir la función de configuración, las incluimos dentro de basic_setup(). Verifica basic_setup() del contrato lockup para ver otro ejemplo (que incluye la implementación de otros contratos además de su contrato de prueba principal). Aquí, también haremos lo mismo, pero no tenemos otro contrato para configurar, así que lo omitiremos y sólo incluiremos las funciones necesarias en basic_setup().
Crea un archivo utils.rs:

touch tests/sim/utils.rs
Dentro de utils.rs, insertamos el contenido:
use crate::*; 

/// 300 TGas 
pub const MAX_GAS: u64 = 300_000_000_000_000; 

/// 1 NEAR (just a random number) 
pub const MIN_BALANCE_FOR_STORAGE: u128 = 1_000_000_000_000_000_000_000_000; 

pub const GREETER_ACCOUNT_ID: &str = "greeter"; 

pub(crate) fn basic_setup() -> (UserAccount, UserAccount) { 
  let mut genesis_config = GenesisConfig::default(); 
  genesis_config.block_prod_time = 0; 
  let root = init_simulator(Some(genesis_config)); 

  let alice = root.create_user( 
    "alice".to_string(), to_yocto("200") 
  ); 

  (root, alice) 
}
Hay algunas cosas importantes a tener en cuenta aquí. El primero es este bloque de código:
let mut genesis_config = GenesisConfig::default(); 
genesis_config.block_prod_time = 0; 
let root = init_simulator(Some(genesis_config));
El Génesis es el primer bloque de la blockchain (cadena de bloques). Sin embargo, el tiempo de génesis y génesis no es realmente lo mismo. Por ejemplo, root representa la propia cadena de bloques. No es la cuenta de nivel superior near o testnet: es la cadena de bloques. Sin embargo, si revisamos el explorador de testnet, vemos que se creó durante el Génesis. Entonces, root viene primero, luego se empaqueta con algunas de las cuentas durante  Genesis time. Creamos un simulador del Génesis llamado root.

Aquí, lo que queremos decir con Génesis no es el tiempo de génesis, sino la "mismísima raíz". Es la "cuenta principal" de todas las cuentas de nivel superior.

Por lo general, no necesitamos modificar GenesisConfig; y si lo necesitas, este es un ejemplo.

Si alguna vez necesitas realizar cambios en el génesis, consulta los documentos para conocer los valores que puedes cambiar. Luego, puedes modificar la línea 2 en el bloque de código anterior asignando un valor a cada campo. Finalmente, debes inicializar el simulador con init_simulator.

Si no necesitas modificaciones, puedes inicializar un simulador sin configuración (que usará el valor predeterminado) de esta manera:
let root = init_simulator(None);
A continuación, hacemos que el root cree una cuenta llamada "alicia" para nosotros. El primer argumento es el nombre de la cuenta, el segundo es cuántos NEAR dar a la cuenta.


Debido a que root es el Génesis, sólo puede crear cuentas de nivel superior como near, testnet, alice. No puede crear subcuentas como alice.near: solo la cuenta principal near puede crear alice.near, no Genesis.

Una cosa que no tenemos aquí es la implementación con root. Para nuestro contrato, usamos el macro deploy! que haremos en la función de prueba en lugar de aquí. Pero si tienes otro archivo wasm, como el contrato de bloqueo, ¡No puedes usar el despliegue! macro, entonces así es como lo hicieron.

Por ejemplo, en el contrato de la lista blanca; se implementa en la raíz de esta manera:
let _whitelist = root.deploy_and_init( 
  &WHITELIST_WASM_BYTES, 
  STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(), 
  "new", &json!({
    "foundation_account_id": foundation.valid_account_id(), 
  }).to_string().into_bytes(), 
  to_yocto("30"), 
  MAX_GAS, 
);
Debido a que el requisito de qué una función de inicio se llame una vez durante la implementación es tan común, existe una función deploy_and_init. Si el contrato no tiene una función de implementación (asumiendo que la lista blanca no tiene una aquí), podemos hacer esto.
let _whitelist = root.deploy(
 &WHITELIST_WASM_BYTES,
 STAKING_POOL_WHITELIST_ACCOUNT_ID.parse().unwrap(),
 to_yocto("30") 
);
y en realidad no existe la función deploy_and_init, por lo qué la llamamos manualmente. Para hacer esto, necesitamos una cuenta para llamarlo, que tenga la capacidad de hacerlo. para lockup, dicha cuenta es la fundación.
let foundation = root.create_user("foundation".to_string(), to_yocto("10000"));
 foundation.call(
   STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(),
   "new", 
   &json!({
      "foundation_account_id": foundation.valid_account_id()
   }).to_string().into_bytes(),
   MAX_GAS,
   NO_DEPOSIT, 
).assert_success();

Notamos que la realidad y la simulación tienen algunas diferencias.

Por último, no olvides importarlo a main.rs e importar las funciones requeridas:

use near_sdk::Balance;
 use near_sdk_sim::runtime::GenesisConfig;
 use near_sdk_sim::{init_simulator, to_yocto, UserAccount};
 pub(crate) mod utils;
 use utils::*;
Construyendo la primera función de prueba
Estamos listos para construir la primera función de prueba. Primero, importa las funciones requeridas en main.rs:

use near_sdk_sim::{deploy};
Esta es la macro de implementación.

Cree un archivo para la prueba:
touch tests/sim/test_set_and_get_greeting.rs
AComo yo provengo de trabajar con Python, a mi me gusta nombrar funciones que comienzan con test. No tienes que hacerlo. Aquí, yo adopté el llamar el nombre del archivo comenzando con test_; mientras que la función a probar qué está dentro sin test_. Ejemplo, tendremos una función set_and_get_greeting() dentro de test_set_and_get_greeting.rs (archivo).
Importa el archivo en main.rs antes de qué lo olvidemos:

mod test_set_and_get_greeting;
No necesitamos pub(crate) como lo hace utils, ya que no necesitas compartir nada con otros archivos.
Lo primero que necesitamos en la función set_and_get_greeting es implementar el contrato.

 let greeter_amount = to_yocto("1000");
 let (root, alice) = basic_setup();

 let greeter = deploy!(
   contract: WelcomeContract, 
   contract_id: GREETER_ACCOUNT_ID.to_string(),
   bytes: &GREETER_WASM_BYTES,
   signer_account: root,
   deposit: MIN_BALANCE_FOR_STORAGE + greeter_amount 
);
Si tenemos un método #[init] personalizado, incluimos esto después de los argumentos de depósito:
gas: MAX_GAS,
 init_method: <method_name>(method_args)
Sin embargo, si no los tenemos, eliminamos dichos argumentos. Para ver un montón de rasgos que coinciden con la macro, consulta los documentos. Debes hacer coincidir al menos uno de ellos; de lo contrario, Rust se negará a compilar.

(Pregunta: ¿Importa el orden? ¿O solo el grupo de kwargs (argumentos) debe coincidir con uno de los traits?)

Ten en cuenta qué, a diferencia de la realidad, la implementación se realiza nuevamente por root (puedes verlo por signer_account). En realidad, lo hace alguna cuenta responsable de ello.

A continuación, configuremos un saludo y obtengamos el saludo y afirmemos que son como se esperaba.
Parece que a la gente le gusta asignar una res de llamada variable que se reutiliza una y otra vez. No es la forma más clara; pero seguramente podemos hacer eso para no llenarnos la cabeza y pensar en nombres de variables. res simplemente significa "resultados" devueltos por una llamada de función en particular.


Es una buena práctica asignar su res con un tipo (independientemente de si Rust puede inferir el tipo o no), para que sepa qué tipo se devuelve.

Recuerda que tenemos view_method y change_method en el contrato inteligente. Por el contrato desplegado con deploy! (que es el contrato inteligente que puede importar y el que está probando principalmente), podemos usar view_method_call y function_call respectivamente. Hablaremos en un momento como llamar un archivo externo wasm, si lo tuvieramos.

Nuestro set_greeting es un change_method, por lo que usaremos una function_call. Una function_call toma un PendingContractTx, Gas y Deposit.
PendingContractTx es solo la función, y otros argumentos son fáciles de interpretar. Veamos nuestro set_greeting:

let greeting: String = "Hello, NEAR!".to_owned();
alice.function_call(
  greeter.contract.set_greeting(greeting),
  MAX_GAS, 0 
).assert_success();
Asegúrate de pasar los argumentos respectivos en la función.  También llamamos a assert_success() al final para asegurarnos de que se cumpla la Promesa.  Lo anterior está imitando el near-cli:
near call $GREETER_CONTRACT set_greeting '{
  "message": "Hello, NEAR!"
 }' --gas=$MAX_GAS --amount=0 --accountId=$ALICE_ACCOUNT_ID
Entonces, podemos usar la función view. Si revisas, la función get_greeting toma un ID de cuenta de tipo String y devuelve un String.
let res: String = alice.view_method_call( 
  greeter.contract.get_greeting(alice.account_id().to_string())
 ).unwrap_json();

Yo creo que no necesitas .account_id().to_string(), con solo .account_id() es suficiente.  Aquí, solo lo hacemos explícito porque admite un String.  Si tomara AccountId, podríamos simplemente llamar a .account_id() sin ninguna confusión.  (Especialmente cuando AccountId ya no es igual a String que comienza con near-sdk-rs v4).

Como el resultado devuelto es un JSON, lo desenvolvemos con unwrap_json().

 Entonces, podríamos hacer afirmaciones sobre el resultado.
assert_eq!(res, greeting);
El saludo (greeting) qué recibiremos es una variable que asignamos anteriormente, que es “¡Hola, NEAR!”.

Ejecutando la prueba de integración
Si solo deseas ejecutar la prueba de integración, ejecuta:

cargo test --tests sim (Porque está en la carpeta: tests/sim ). Si deseas ejecutar todas las pruebas, incluidas las pruebas unitarias, ejecuta cargo test.

Ten en cuenta que, por alguna razón, demora como 30 segundos o más (independientemente de cuántos núcleos de CPU tengas);  hay que esperar antes de que comience la prueba.

Un recordatorio nuevamente: si realizas cambios en el contrato, debes reconstruirlo;  de lo contrario, te preguntarás por qué no se ejecuta y creeras que se ejecutará, así que no lo olvides.
Código Completo
Puedes encontrar el código completo aquí:  https://github.com/Wabinab/NEAR_greeter_integration_tests

Conclusión 
Ahora, puedes repetir otras pruebas (si tienes alguna otra) creando un nuevo archivo, vinculándolo usando mod a main.rs, escribe las pruebas dentro. Es un ejercicio divertido: cuanto más escribes, más entiendes.

Una nota sobre la actualización a v4.0.0-pre.4
La función de contrato de lista blanca deploy_and_init necesita cambios en esto:
AccountId ya no es String


 	Así que reemplaza todo "alice".to_string() con "alice".parse().unwrap(). Si el reemplazo está dentro de una función en la que no puede llamar a parse, debes crear una variable. (Esto es especialmente cierto en la macro deploy!, que no tiene inferencia de tipo).
let alice_account: AccountId = "alice".parse().unwrap(); 

// pass it to the function. 

 	valid_account_id está en desuso. Usa account_id() en su lugar. Esto ocurre en json!.
 	Cualquier número pasado en json! requiere especificación. Ejemplo: v3.2.0 permite 10, pero v4.0.0-pre.4 no lo permite: tu debes especificar 10u64 o algún otro tipo, dependiendo de lo qué necesites..
 	Siéntete libre de consultar la prueba de simulación del contrato de bloqueo en mi libro (actualmente en pre-Alfa al momento de escribir) para quizás más consejos y trucos que no se enumeran aquí. (Esto es MVP, de todos modos).



Referencias

 	https://www.near-sdk.io/
 	https://www.near-sdk.io/testing/simulation-tests
 	https://wabinab.github.io/NEAR-book/simulation/sim_01.html
 	Lockup contract: https://github.com/near/core-contracts/tree/master/lockup/tests

### Update - July 12, 2022

Brief Summary:

 	
(L)Earner NFT is getting momentum!


Results:

 	🕺 347 (L)Earner NFTs minted so far! Minting cost increases gradually with every mint and will reach 10 $NEAR for (L)Earner #10,000
 	💸  Ⓝ222 to be sent to 4 NCD teams from NEAR-China! Check GitHub repo to explore.
 	🎢"NEAR SocialFi Playground" is LIVE! Get hands-on experience with web3 token tools on NEAR Testnet
 	🧙‍♂️ Job alert form LNC partner - Dapplets!
 	 (L)Earm new Guide: "Tokenomics 101 for web3 startups"

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	✅LNC NEAR Validator node is coming to testnet!

### Tokenomics 101 for web3 startups

Alright, so you have decided to build your own dApp and enter the web3 space. Congratulations on making this step. However, before you launch your game-changing app, you have to nail one of the core tenets of web3 – tokenomics. Tokenomics is the portmanteau of “token” and “economics,” – which is pretty self-explanatory. So, in this article, you will learn everything you need to know about tokenomics.
What is Tokenomics?
Tokenomics is a loose term, but it includes several factors like supply-demand, token issuance, burn functions, etc. Simply put, it is a sum total of functions and economic factors that affect your tokens in various ways. A token belonging to a project with solid tokenomics is considered a more attractive investment. So, without any further ado, let’s look at the different factors.
Factor 1: Supply and Demand
The supply and demand equation is one of the most critical factors determining tokenomics. The following is one of the most important charts in economics – the supply-demand chart.



The graph above shows the relationship between the supply and demand of a particular commodity. The subsequent price of a commodity is determined by its demand in the marketplace and the amount of it that is readily available. 

The rarity of an item (i.e. diminishing supply) is often considered an important factor in product valuation. Think of the inflated prices that PS5 machines were selling for in the secondhand market due to their rarity. However, just because an item is rare doesn’t mean it is valuable. You can take a selfie of yourself – which will be a unique item, but that doesn’t mean you will get thousands of dollars for it, right? There has to be demand in the market. In the equilibrium stage, the demand and supply graphs perfectly balance each other.

There are two things that we can conclude from the graph:

 	When the supply of an asset is high but the demand is low, it will not affect the price positively.
 	If the demand is high but the supply is low, it will affect the price positively.

Supply and demand in tokens

When it comes to Bitcoin, one of the more significant value-creation moments in the protocol is the periodic halving events that occur every four years. Bitcoin has a total fixed supply of 21 million. Miners mine Bitcoin to get a block reward to release BTC into the circulating supply. 

Every four years, Bitcoin goes through a halving which cuts this block reward by half – reducing the amount of BTC entering the circulating supply. Satoshi Nakamoto purposefully added this mechanic to ensure decreasing supply over time and hopefully increasing the overall price valuation.

Several tokens like BNB have an artificial burning mechanism. Burning means you send the tokens to a wallet whose private keys aren’t owned by anyone. By doing so, you are removing these tokens from circulation – aka burning the tokens.

There are also certain tokens that are inflationary. For example, EOS has an annual inflation rate of 1%. This 1% is used to pay the block producers. The thought was that the EOS system would become so busy over time that increasing supply won’t affect the demand.
Factor 2: Token Distribution
A protocol can distribute tokens via a fair launch or a pre-mine. When a fair launch happens, everyone has a fair opportunity to acquire the tokens. Bitcoin’s launch was fair since everyone had the same exact opportunity to acquire BTC. There was no pre-sale, no private investor round. If you want Bitcoin, you would have had to mine them from scratch.

However, fair launches are very rare nowadays. Starting from the ICO era, tokens have been launched via a method called premine. In a premine, the tokens are either partially or fully created and then distributed to various parties like VCs, investors, etc., before being released to the public. Obviously, premining is unfair since an average user isn’t getting the first bite of the pie. However, in the current landscape, it is necessary to do so as projects need that initial liquidity injection from VCs and market makers. They need the liquidity to pay for labor, development, building out the ecosystem, etc. 

Having said that, it is crucial to see how many of the tokens are being distributed to these parties. For example, if a team allocates 5% of the tokens to itself, then it's fine. They do need money to fund their team, after all. However, if they give 50% to themselves, then that’s a potential red flag.




	

	
	
		
			
				When an asset has low supply and high demand, it means that:
			
		

		
					

		
			
			
			
			The price should go up.
		
			
			The price should go down.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Factor 3: Staking
At its core, good tokenomics should come up with different methods to incentivize users to hold on to their tokens. One of the coolest ways to do that is to ensure the holder some form of assured ROI. Many projects do that with a staking mechanism.

The idea is simple – lock up your tokens in the protocol and earn rewards. For example, if you hold Curve tokens (CRV), you can stake them on Convex Finance as cvxCRV and earn ~30% vAPR. DeFi apps allow you to stake various tokens that can help you earn yield. 

Staking also allows users to lock away your token, automatically making them long-term holders. After all, you can’t sell a token that you have locked up firmly in the ecosystem, right?

Now, the next question to consider here is, how can you incentivize your users to willingly stake your coins for a long time? Well, projects like Curve have a simple compound interest offering that works pretty well for them. The longer you keep your CRV locked up, the more rewards you get.

Staking also gives you governance rights in some projects. Staking the native token allows you to become a member of the protocol DAO and vote on various decisions. For example, in Curve, you can stake your CRV and veCRV, the voting token. More CRV you stake, more veCRV you get. veCRV has no value apart from being used as a voting token within the DAO.
Factor 4: Vesting Schedules
In Factor 2, we discussed how premining allows projects to allocate specific tokens to private investors and VCs. However, what if those folks immediately dump your tokens in the open market? That’s not going to do your project any good, right?

So, what you can do here is to use various vesting schedules for your allocations. Vesting allows you to lock distributed tokens for a given time (aka vesting period). It increases the time you have to wait before getting your hands on the tokens.

Now, before we go any further, let’s talk about the “cliff.” When it comes to vesting, the cliff is a durational lock that is placed on the vested tokens before the vesting schedule begins. There are two kinds of vesting you can do:

 	Linear vesting: Token distribution is done consistently and in equal parts within a certain time period.
 	Twisted vesting: Token distribution can vary within a variety of time periods.

Creating your own token – Best practices
So, now that you know the basics, let’s create your token. You can use this token playground to test out various token structures.



As you can see, you put your token name, symbol, total supply, and decimal places.

Below that, you have a list of token allocations. Depending on how many advisors and VCs your project will have, you can give the allocations accordingly. However, just a word of advice. Don’t go overboard with allocations for advisors. Keep a significant majority for your community.

For example:

 	10% for the team
 	10% for early investors
 	0.25%-0.5% per advisor
 	Rest for the community.




	

	
	
		
			
				What kind of vesting is this? “Token distribution is done consistently and in equal parts within a certain time period”
			
		

		
					

		
			
			
			
			Linear
		
			
			Twisted
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
When building your web3 protocol, robust tokenomics is crucial for the long-term success of your project. In this article, we have talked about four features you can integrate into your tokenomics to prevent dumping and incentivize users to hold your tokens and accumulate more.




	

	
	
		
			
				During token distribution, majority of the tokens should be allocated to:
			
		

		
					

		
			
			
			
			Team
		
			
			VCs
		
			
			Community
		
	
		

		
		
			
				Correct!
				Wrong!

### Поток данных NEAR

Видео объяснение
В видео ниже мы попытались дать краткий обзор основной концепции того, как данные передаются в блокчейне NEAR Protocol. Под видео вы найдете текстовую версию.


Текстовая версия​






На первый взгляд поток данных блокчейна протокола NEAR может показаться немного сложным. Но это довольно просто и следует четко определенным правилам. В этой статье мы более подробно рассмотрим, как данные передаются в блокчейне NEAR Protocol.

По сути, любой поток блокчейна можно представить как бесконечную временную шкалу, у которой есть начало, но нет конца.





Блок появляется на этой временной шкале с некоторым интервалом. Каждый из этих блоков содержит информацию о предыдущем, таким образом, создавая цепочку блоков.

Протокол NEAR имеет сегментированную природу, что означает, что в любой момент может работать более одной параллельной сети, называемой сегментом. И каждый шард производит кусок блока с заданным интервалом. Блок в NEAR Blockchain — это набор фрагментов блоков из всех сегментов. Чанк блока сокращен до Chunk в документации протокола NEAR.

Возвращаясь к самому потоку данных. Лучшее, что мы можем сделать, это представить треки, которые мы могли бы видеть в приложениях для редактирования аудио/видео. Каждый шард имеет свой набор дорожек. Верхний трек предназначен для кусков. Они появляются несмотря ни на что с заданным интервалом, для NEAR Blockchain интервал составляет около одной секунды. Чанки создаются, даже если в блокчейне ничего не происходит.



Но что мы имеем в виду, говоря, что что-то происходит? Мы имеем в виду, что что-то вызвало какие-то изменения в блокчейне. И самый известный способ инициировать любые изменения — отправить транзакцию в блокчейн с инструкциями о том, что мы хотим изменить, и кто запросил эти изменения.

Транзакция должна быть создана, подписана и отправлена в блокчейн. После его выполнения мы ожидаем получить результат — ExecutionOutcome. О, это просто. Но это не совсем точно для NEAR Blockchain.



В начале есть транзакция, она содержит инструкции, которые мы хотим выполнить в блокчейне. Транзакция отправляется в NEAR Blockchain.

И да, она выполняется там немедленно, НО непосредственным результатом выполнения транзакции всегда является просто подтверждение того, что она будет выполнена в цепочке; этот внутренний запрос на выполнение известен как Квитанция. Вы можете думать о Квитанция как о внутренней транзакции, которая существует для передачи информации между осколками.

Вернемся к дорожкам, чтобы посмотреть на пример.

Предположим, у нас есть две учетные записи, живущие на разных шардах alice.near и bob.near. alice.near создает транзакцию для отправки нескольких токенов bob.near. Транзакция выполняется немедленно, и ExecutionOutcome для Транзакции всегда является Квитанцией.

Но этот Квитанция не может быть выполнен здесь, потому что bob.near не живет на том же шарде, что и alice.near, поэтому Квитанция должна быть выполнена на шарде получателя. Таким образом, Квитанция перемещается в тот шард, которому принадлежит bob.near.

На целевом шарде выполняется квитанция, и процесс считается выполненным.
ОБЪЯСНЕНИЕ ЗДЕСЬ УПРОЩЕННОЕ
См. статью о передаче токенов

Итак, окончательная схема будет выглядеть так:


Резюме​
Мы изучили основные принципы передачи данных в протоколе NEAR. Мы выяснили, что Транзакции выполняются, и Результатом выполнения Транзакции всегда является Квитанция.

Теперь мы знаем, что Квитанция является основным внутренним активом блокчейна NEAR Protocol и обладает способностью перемещаться между шардами. Мы изучили поток данных NEAR на простом примере. Конечно, в реальной жизни с более сложными транзакциями, которые включают вызовы между контрактами, будет больше квитанций и результатов выполнения.

Мы надеемся, что эта статья окажется полезной, и вы сможете легко создавать свои dApps и индексаторы, зная, как данные передаются в протоколе NEAR.

### TokenHub — площадка DeFi в тестовой сети NEAR

1. Что такое TokenHub?

 	TokenHub — это площадка, где вы можете создать свой собственный токен всего за несколько кликов, а затем свободно опробовать все функции мира Defi.

2. Почему TokenHub?

 	После того, как биткойн сократился вдвое в 2020 году, пространство DeFi постоянно растет и хорошо развито в разнообразии продуктов и пользовательской базы. Общая заблокированная стоимость всех продуктов DeFi когда-то даже достигла своего пика в 250 миллиардов долларов. Это доказывает, что потребность в DeFi растет с каждым днем, но большинство людей осознают риски DeFi только после того, как потеряли из-за него реальные деньги. Это мотивация для создания TokenHub. Миссия команды TokenHub состоит в том, чтобы помочь пользователям DeFi получить практический опыт работы во многих областях DeFi, таких как выращивание урожая и обмен токенами, … без затрат их реальных денег. Используя TokenHub, пользователи могут многое узнать о DeFi, не рискуя потерять деньги, исключительно в тестовой сети NEAR.

3. Руководство по TokenHub: как создать собственный токен на TokenHub
Шаг 1. Подключите свою учетную запись тестовой сети NEAR к TokenHub.
Если у вас нет учетной записи
Если у вас нет учетной записи NEAR testnet, следуйте официальному руководству.

Перейдите на https://app.tokenhub.tk/token/create и нажмите «Подключиться к кошельку»:



Как только вы будете перенаправлены на, нажмите «Далее»:


Затем нажмите «Подключить»:



Теперь ваша учетная запись подключена к TokenHub:


Шаг 2: Перейдите на https://app.tokenhub.tk/token/create или нажмите кнопку «Создать токен» на левой панели веб-сайта TokenHub:

Шаг 3: Заполните информацию о токене
Это включает в себя имя вашего токена, его символ, его общий запас и его десятичное значение (от 8 до 24). В этом примере я создам токен с именем «Биткойн» и буду иметь символ «BTC», его общий запас составит 21 000 000 токенов и десятичное значение 8.



Простое объяснение десятичного значения — это количество цифр после запятой. Например, мой биткойн-токен имеет десятичное значение 8, поэтому на произвольной учетной записи может быть 1,12345678 BTC или 49,37603856 BTC, а общий запас моего токена BTC составит 21 000 000,00000000. Чем выше десятичное значение, тем более делимым будет ваш токен.
Шаг 4. Настройте распределение вашего токена
Шаг 4.1. Настройте учетные записи распределения
Две учетные записи по умолчанию получат часть общего количества токенов: учетная запись казначейства TokenHub (treasury.tokenhub.testnet) и учетная запись, которую вы подключили к TokenHub. Чтобы добавить больше учетных записей, которые могут получить часть вашего общего количества токенов, нажмите «Добавить дополнительное распределение», а затем введите адрес этих учетных записей. Обратите внимание, что добавляемые учетные записи должны быть учетными записями NEAR testnet, которые заканчиваются с «.testnet», а не «.near»:



Мой токен BTC будет распределяться только между двумя учетными записями по умолчанию:






	

	
	
		
			
				Аккаунты по умолчанию, которым будет выделен ваш токен, — это казначейство TokenHub, и вы подключены к кошельку NEAR testnet.
			
		

		
					

		
			
			
			
			истина
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Шаг 4.2: Определите распределение токенов для каждой учетной записи
Укажите, какая часть вашего общего предложения (в %) будет предоставлена каждой учетной записи в поле «Распределение (%)». Сумма, которую получит казначейский счет, имеет три варианта на выбор: 3, 5 или 7%. Помните, что независимо от того, скольким учетным записям будут распределены ваши токены, общее распределение (%) всех учетных записей должно составлять 100%. Мой токен BTC отдаст в казну TokenHub 3% (630 000 BTC), а остальные 97% будут отправлены на мой счет:


Шаг 4.3: Установите первоначальный выпуск для каждой учетной записи
Определите, какая часть (от 0 до 100%) распределения, установленного вами на шаге 4.2, будет немедленно отправлена каждой учетной записи после создания токена. В этом примере казна мгновенно получит 10% от 3% от общего количества 21 000 000 BTC, что составляет 63 000 BTC. Что касается моего счета, то это 50% от 97% от 21 000 000 BTC, что составляет 10 185 000 BTC.

Вы можете задаться вопросом: «Как будет выпущена остальная часть токена?». Здесь вступают в силу параметры вестинга.


Шаг 4.4: Настройте параметры наделения правами
Вестинг — это постепенный и периодический выпуск токенов на назначенные счета. В этом примере это означает, что оставшиеся токены, которые изначально не были выпущены, будут заблокированы после создания и будут выпущены через определенные промежутки времени в будущем. В TokenHub вы можете настроить 3 параметра для передачи токенов: дату начала, продолжительность передачи и интервал передачи.

Дата начала наделения определяет, когда начнется процесс выпуска вашего токена. Вы можете настроить эту дату индивидуально для каждой учетной записи распределения.



 

Затем установите продолжительность наделения для каждой учетной записи. Продолжительность наделения — это время, необходимое для полного выпуска токенов. Для казначейского счета TokenHub есть 3 варианта на выбор: 1, 2 или 3 года. Что касается других учетных записей, вы можете указать любую продолжительность (в днях), которую вы хотите. В этом примере наделение казны завершит выпуск токенов через 1 год. Для моей учетной записи это будет завершено через 30 дней.

 

Наконец, установите интервалы наделения правами (в днях) для каждой учетной записи. Интервал наделения правами — это период между каждым выпуском. Например, продолжительность наделения 30 дней и интервал в 10 дней будут означать, что токены будут разделены на 3 равные части, и каждая часть будет выпускаться каждые 10 дней. Для казначейского счета тоже есть 3 варианта: 30, 90 или 180 дней. Для других аккаунтов можно выбрать любую продолжительность.






	

	
	
		
			
				Кроме двух учетных записей распределения, вы не можете добавлять никакие другие учетные записи, которые могут получить ваш токен.
			
		

		
					

		
			
			
			
			истина
		
			
			ложь
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Шаг 5: Создайте свой токен
После того, как вы выполнили все шаги, описанные выше, нажмите «Создать токен».



Затем вы будете перенаправлены на этот сайт, нажмите «Подтвердить».

Через некоторое время вы будете перенаправлены на вкладку «Мой токен», которая включает все созданные вами токены.
Руководство: запустите продажу токенов
Чтобы начать продажу токенов на TokenHub, заполните эту форму: https://forms.gle/vgagVRQpKrEQJ8D86.

Затем свяжитесь с Гарри — основателем TokenHub через:

 	Discord: harrynguyen#0629
 	Telegram: @harrynguyen0991

Чтобы мы могли помочь вам с настройкой контракта на продажу токенов в соответствии с вашей регистрацией продажи. Мы сообщим вам адрес контракта, чтобы вам нужно было отправить достаточное количество токенов на этот контракт. Наконец, мы разместим его на сайте TokenHub, чтобы начать продвижение. Тогда все, что вам нужно сделать, это подождать, и ваша продажа будет запущена. По сути, вам нужно решить, сколько токенов будет выделено для продажи и каковы сроки. Это полностью зависит от вас, но распродажа не должна длиться слишком долго. Продажа токенов LNC длилась 3 дня, включая 2 дня продажи и 1 день отсрочки, что может быть для вас хорошим ориентиром. Подробности см. в разделе Продажа токенов LNC.

### Como construir na NEAR? Guia de iniciação

Pré-requisitos

 	Leia “O que é NEAR?”
 	Experiência de desenvolvimento JavaScript

Os desenvolvedores são a força vital do ecossistema blockchain. Para que a tecnologia blockchain ganhe a adoção popular, ela precisa reduzir as barreiras de entrada para os desenvolvedores e permitir que eles criem aplicativos divertidos e sofisticados para as pessoas comuns aproveitarem. É exatamente por isso que os contratos inteligentes da NEAR são escritos usando AssemblyScript devido à sua semelhança com o JavaScript.

Então, se você está interessado em construir no NEAR, você pode usar as seguintes ferramentas

 	JavaScript SDK. Conecte, assine, transacione e implante em qualquer rede NEAR a partir de qualquer contexto JS
 	Contrato Rust SDK. Crie contratos seguros e protegidos que gerenciem ativos de alto valor
 	Contrato AssemblyScript SDK. Aprenda e faça protótipos com zero atrito usando a sintaxe JS
 	API JSON RPC. Todas as comunicações com a plataforma passam por esta API incluindo a nossa
 	Command Line Interface. Kit de ferramentas de linha de comando completo para desenvolvedores e validadores
 	NEAR Explorer. Uma ferramenta de pesquisa de blockchain que permite aos desenvolvedores visualizar detalhes de transações, contas, detalhes de blocos e muito mais
 	NEAR Wallet. Crie contas, gerencie chaves de acesso e muito mais com nossa interface de usuário amigável 
 	Nearup. Gerencie implantações localmente e junte-se a qualquer rede pública ou privada
 	Bridge. Interoperabilidade rápida e segura
 	EVM. Máquina virtual compatível com Ethereum.

Tudo bem, vamos dar os primeiros passos.
Uma breve visão geral
Os aplicativos no NEAR têm duas partes distintas – um back-end e um front-end.

 	Smart Contract (back-end): Armazenar e modificar dados na cadeia. Os contratos precisam expor métodos que permitam aos clientes “visualizar” e “alterar” o estado.
 	Interações com Smart Contract (front-end): Você pode interagir com seus contratos ou contratos implantados por outras pessoas. Você faz isso usando o início rápido e os trechos de código near-api-js em seu aplicativo.




	

	
	
		
			
				Os aplicativos no NEAR têm duas partes distintas – um back-end e um front-end. O back-end é o…
			
		

		
					

		
			
			
			
			Rede principal (Mainnet)
		
			
			Rede de teste (Testnet)
		
			
			Contratos inteligentes ( Smart contracts)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Como construir e chamar contratos inteligentes 

NEAR atualmente suporta: 

 	Rust – near-sdk-rs: Um wrapper (envelopador) que fornece segurança aprimorada para a linguagem de programação Rust para contratos de alto valor. 
 	AssemblyScript near-sdk-as: uma coleção de auxiliares que fazem seus contratos inteligentes parecerem semelhantes ao TypeScript durante a compilação para Wasm para execução. 

NOTA: Atualmente, o AssemblyScript não é recomendado para aplicativos financeiros de produção devido à novidade da linguagem e das ferramentas de compilação disponíveis. 

Tudo bem, vamos falar sério.
Configurando o Testnet 
A maneira mais fácil de criar uma conta na NEAR é com a NEAR Wallet a carteira da rede Near. A NEAR tem várias redes de desenvolvimento operando independentemente umas das outras com seus próprios IDs de conta. Vá, siga os passos para criar uma carteira. Certifique-se de ter seguido as etapas necessárias para o backup de segurança. 

NOTA: Criar uma conta na mainnet é quase idêntico ao testnet, mas exigirá um financiamento inicial para a conta. Aqui está um guia para a criação de conta mainnet. 

Não importa, ao implantar, se o aplicativo é escrito em Rust ou AssemblyScript. Todo o código do contrato é compilado no WebAssembly e implantado na rede para ser executado dentro de uma máquina virtual compatível com Wasm. Você usará um comando como yarn dev para a maioria dos aplicativos, mas pode facilmente implantar um aplicativo usando NEAR CLI com near dev-deploy para TestNet (ou near deploy se já tiver criado uma conta).




	

	
	
		
			
				Todo o código do contrato é compilado no WebAssembly e implantado na rede para ser executado dentro de um _______
			
		

		
					

		
			
			
			
			Sandbox
		
			
			Máquina virtual compatível com Wasm
		
			
			EVM (Máquina Virtual Ethereum)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Agora, faça o seguinte para se aquecer:

 	Olhe ao redor no NEAR Explorer. Aqui você pode pesquisar todas as transações e blocos produzidos no NEAR. Tente pesquisar a conta que você acabou de criar e veja as transações que você criou.
 	Agora instale near-cli. Esta é uma interface de linha de comando que permite que você interaja perfeitamente com o NEAR. Este documento NEAR tem todos os comandos near-cli com exemplos.
 	Tente executar seu primeiro comando: near login. Isso irá redirecioná-lo para sua carteira NEAR e salvar suas chaves de conta testnet localmente.

Depois de verificar o testnet, você pode se sentir à vontade para executar seu nó local. No entanto, se você quiser apenas brincar com os códigos, sugerimos que você fique com o testnet.
Como executo um nó?
Como em qualquer ecossistema baseado em blockchain, o NEAR Protocol é executado em uma coleção de computadores mantidos publicamente (ou “nós”). 

Você pode decidir executar um nó próprio por alguns motivos: 

 	Para desenvolver e implantar contratos em um nó conectado a MainNet, TestNet ou BetaNet Para desenvolver e implantar contratos em um nó local (independente e isolado) (às vezes chamado de "LocalNet" ). 
 	Para ingressar em uma rede como um validador executando um “nó validador” 

Você pode iniciar NEAR betanet e nós testnet instalando nearup. Você pode fazer isso seguindo as instruções em https://github.com/near/nearup




	

	
	
		
			
				Como em qualquer ecossistema baseado em blockchain, o NEAR Protocol é executado em uma coleção de computadores mantidos publicamente chamados ______
			
		

		
					

		
			
			
			
			Nós
		
			
			Blockchain
		
			
			Near Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Executando um nó oficial usando o Docker 
Por padrão, o NEAR usa o Docker para executar o cliente. Então, a primeira coisa que você faz é instalar o Docker e Nearup. Agora, execute seu sistema com isto: 
nearup betanet
(Se você preferir usar TestNet, basta substituir betanet por testnet no comando acima) 

Você será solicitado a fornecer um ID de conta. Você pode deixar isso em branco se quiser apenas executar um nó. Os validadores devem usar o ID da conta com a qual você deseja apostar. Depois disso, você precisa digitar este código: 

Digite o ID da sua conta (deixe em branco se não for um validador) 

Agora, seu nó será iniciado em segundo plano com o Docker. Para verificar os logs dentro do Docker, execute docker logs –follow nearcore.
Criando um código simples em NEAR
NEAR tem uma lista de programas úteis ou códigos de exemplo que você pode verificar com facilidade. Portanto, o código que iremos verificar é o Livro de Visitas. O uso do programa permite que você faça login com NEAR e adicione uma mensagem ao livro de visitas! Um aplicativo inicial criado com um back-end AssemblyScript e um front-end React.

Examinando o código do livro de visitas 
Para executar este projeto localmente, você precisa garantir o seguinte.

 	Certifique-se de ter o Node.js ≥ 12 instalado (https://nodejs.org) e use-o para instalar o yarn: npm install –global yarn (ou apenas npm i -g yarn)


 	Instalar dependências: yarn install (ou apenas yarn)
 	Execute o servidor de desenvolvimento local: yarn dev (consulte package.json para obter uma lista completa de scripts que você pode executar com yarn)

Agora você terá um ambiente de desenvolvimento local apoiado pelo NEAR TestNet! A execução do yarn dev informará a URL que você pode visitar no seu navegador para ver o aplicativo.

Ah, e certifique-se de ter a página do GitHub aberta. 

Você pode achar este vídeo útil também.

https://youtu.be/B6Gc_OQjX9E

Explorando o código
Como você pode ver, existem dois lados do código – backend e frontend:

 	O código de back-end fica na pasta /assembly. Esse código é implantado na blockchain NEAR quando você executa yarn deploy:contract. Este é um contrato inteligente NEAR.
 	O código frontend fica na pasta /src. /src/index.html é um ótimo lugar para começar a explorar. Observe que ele carrega em /src/index.js, onde você pode aprender como o frontend se conecta a blockchain NEAR.

Código de back-end
#1 Modelo de dados de contrato: assembly/model.ts

[code lang="js"]import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");[/code]

Análise

A classe “PostedMessage” tem três recursos:

 	premium para sinalizar mensagens com tokens NEAR anexados
 	remetente para rastrear o signatário da mensagem do livro de visitas
 	texto para guardar a mensagem do livro de visitas

Finalmente, “messages” é uma coleção de mensagens do livro de visitas armazenadas como um PersistentVector de objetos PostedMessage
#2 Comportamento do contrato: assembly/main.ts

[code lang="js"]import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}[/code]

Análise

MESSAGE_LIMIT é usado para evitar chamadas ilimitadas (ou seja, potencialmente caras) para recuperar mensagens do livro de visitas do armazenamento

Também estamos usando duas funções públicas diferentes neste contrato – addMessage() e getMessages()
Código Front-end
#1 Conexão de rede: src/config.js

[code lang="js"]const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;[/code]

Análise

O código acima define os dados e endpoints necessários para se conectar à rede NEAR. As informações de conexão definidas aqui estão incluídas para MainNet, TestNet e BetaNet, bem como a configuração padrão do LocalNet
#2 Configuração: src/index.js

[code lang="js"]import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });[/code]

Análise

Este é o filé da seção frontend, quando você configura a conexão com a rede NEAR. Você pode configurar a interface do contrato injetando a conexão da carteira e conectando os dois métodos de contrato.
Como implantar um contrato inteligente
Cada contrato inteligente na NEAR tem sua própria conta associada. Quando você executa o yarn dev, seus contratos inteligentes são implantados na NEAR TestNet ao vivo com uma conta temporária. Se agora você deseja torná-lo permanente, aqui está o que você precisa fazer.
Etapa 0: instalar near-cli
Veja como você instala globalmente near-cli
npm install --global near-cli
Isso lhe dará a ferramenta CLI próxima. Certifique-se de que está instalado com:
near --version
Etapa 1: criar uma conta para o contrato 
Visite NEAR Wallet e crie uma nova conta. Você implantará esses contratos inteligentes nessa nova conta. 

Agora autorize o NEAR CLI para esta nova conta e siga as instruções fornecidas:
near login
Etapa 2: definir o nome do contrato no código
Modifique a linha em src/config.js que define o nome da conta do contrato. Defina-o para o ID da conta que você usou acima.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Etapa 3: altere o URL remoto se você clonou este repositório
Se você bifurcar o repositório, precisará alterar a URL remota para um repositório ao qual você tenha acesso de “commit”. Isso permitirá a implantação automática no Github Pages a partir da linha de comando.

 	Acesse o GitHub e crie um novo repositório para este projeto.
 	Abra seu terminal e na raiz deste projeto digite o seguinte:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`
Etapa 4: implantar!
Você só precisa do seguinte comando para implantar seu contrato inteligente:
yarn deploy
Este comando faz duas coisas:

 	Cria e implanta contratos inteligentes no TestNet NEAR 
 	Cria e implanta código de contrato de front-end no GitHub usando gh-pages. Isso só funcionará se o projeto já tiver um repositório configurado no GitHub. Sinta-se à vontade para modificar o script de implantação em package.json para implantar em outro lugar.




	

	
	
		
			
				Cada contrato inteligente no NEAR tem seu próprio ____ associado
			
		

		
					

		
			
			
			
			Token
		
			
			Carteira
		
			
			Conta
		
			
			Todas acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O que vem agora? 
Tudo bem, agora que você sabe como executar um código básico, talvez queira se aprofundar na NEAR. Para isso, confira os documentos do desenvolvedor da NEAR.

### Что такое Roketo

«Так что же такое Roketo? Почему вы выбрали криптовалюту в качестве способа оплаты? И чем вы отличаетесь от десятков других сервисов криптоплатежей?» — Мы часто слышим эти вопросы и собрали лучшие ответы в этой статье.

Мы расскажем, как работает Roketo и почему он радикально изменит ваш процесс оплаты.

Многие компании изо всех сил пытаются найти быстрый и надежный способ оплаты, особенно если их команды распределены по нескольким юрисдикциям. В этом случае криптовалюта избавит вас от хлопот международных банковских переводов, которые могут занять много времени и потребовать оформления некоторых документов.
Roketo — это служба криптографии, которая позволяет вам платить людям и за услуги в считанные секунды. Низкая комиссия, высокая скорость транзакций и прозрачность делают его идеальным решением для выплаты заработной платы. Наши клиенты используют наш сервис для оплаты труда сотрудников, прозрачной отправки грантовых средств, выпуска собственных токенов и передачи их инвесторам. Потоковая передача в реальном времени также удобна, когда речь идет об услугах с поминутной оплатой, таких как парковка, аренда оборудования или коворкинг.

Как это работает?
Roketo подключается к кошельку пользователя и отправляет средства получателям в режиме реального времени. Плательщик авторизуется в кошельке NEAR, настраивает стрим, его продолжительность и другие параметры, вводит адрес кошелька получателя и начинает стримить деньги. Средства доставляются на потоковый кошелек получателя, который затем может вывести их для конвертации.





Чем Roketo отличается от других решений на рынке?
Низкая комиссия

Roketo построен на NEAR, и это позволяет нам поддерживать одну из самых низких комиссий на рынке. В то время как наши конкуренты берут 50–100 долларов за операцию, настройка каждой операции Roketo стоит менее 1 доллара. Кроме того, вам придется платить комиссию за газ ваших транзакций, которая в экосистеме NEAR также ниже, чем в других блокчейнах. Просто для сравнения: в Эфириуме стоимость транзакции чуть больше $1, а в NEAR — всего несколько центов.

Это означает, что с помощью Roketo отправители могут эффективно настроить сотни потоков с минимально возможной стоимостью, а получатели могут снимать деньги так часто, как они предпочитают.

Быстрые транзакции

Потоковая передача в реальном времени означает, что ваши средства поступают каждую секунду с определенной скоростью, и ваши получатели могут вывести их в любой момент. Вы можете забыть о часах ожидания в других сервисах, не говоря уже о днях, когда речь идет о традиционных финансовых инструментах.

Прозрачность

Наши клиенты получают полную прозрачность распределения средств и выплаты заработной платы. Даже при массовых выплатах своим инвесторам или сообществу компании по-прежнему имеют полный контроль над распределением токенов в реальном времени. Каждый поток имеет уникальный URL-адрес, по которому вы можете отслеживать распространение. Это облегчает финансовое планирование, налоговые платежи и отчетность.

Интуитивно понятный интерфейс

Вам понадобится не более одной минуты, чтобы настроить свой первый поток в Roketo. Каждый параметр управления потоком может быть легко доступен и обновлен как получателем, так и отправителем без участия третьих лиц. Приостанавливайте, возобновляйте, останавливайте, может снять их для конвертации, продлевайте потоки и получайте полную историю операций в dApp. Пользовательский интерфейс удобен в использовании даже для членов команды без знаний в области криптографии.

Недавно мы получили 900 000 долларов в начальном раунде с участием Move Capital, MetaWeb Ventures и A&T Capital. Эти инвестиции помогут нам развивать наш продукт еще быстрее, так что следите за новыми обновлениями.



Ссылки:

 	Twitter
 	Telegram
 	Github
 	Roketo Protocol
 	Website

### Что такое Ref Finance? Пошаговое руководство

Протокол NEAR набирает обороты, как один из ведущих протоколов DeFi. На данный момент общая стоимость, заблокированная в NEAR DeFi, составляет почти полумиллиард долларов. 

Метрика, в которой мы это видим, находится в левом нижнем углу.



Ref Finance контролирует более 50% TVL, что делает его в целом крупнейшим приложением DeFi на NEAR. Ref Finance - это первое приложением DeFi на NEAR, которое сочетает в себе множество функций, таких как децентрализованный обмен (DEX), протокол кредитования, эмитент синтетических активов и т. д.
Ref Finance - Краткое введение
Ref Finance создан сооснователем NEAR Protocol Ильей Полосухиным. Приложение было официально развернуто в апреле 2021 года. Proximity Labs получила грант от NEAR Foundation на запуск и масштабирование Ref Finance.

Ref закрыл частную продажу в марте 2022 года с инвестициями от Jump Crypto (Lead), Alameda Research, Dragonfly Capital и т. д. Основная цель финансирования заключалась в том, чтобы получить достаточно ликвидности, чтобы оставаться на плаву в течение 24 месяцев, начиная с марта 2022 года. Ref Finance привлек 4,8 миллиона долларов в стейблкоинах за 3 664 943 токена REF.
REF — утилита токенов
Родным токеном Ref Finance является REF. Это взаимозаменяемый токен NEP-141 с общим запасом 100 миллионов. Токены распределяются следующим образом:





Основные роли токена REF заключаются в следующем:

 	Пользователи могут стейкать REF, чтобы получать плату за протокол.
 	пользователь может обеспечить ликвидность для пар токенов с REF и заработать комиссию за своп.
 	Токены REF LP можно дополнительно обработать, чтобы заработать больше вознаграждений.
 	Участники REF могут участвовать в управлении сетью.

Посмотрим на Ref Finance
Давайте подробнее рассмотрим Ref Finance и то, что он предлагает. Приложение имеет следующие функции:

 	Обмены (включая обмены стейблкоинов)
 	Агрегация ликвидности 
 	Пулы
 	Фермы 
 	разбивка xREF.

Обмены
Первая особенность, которую следует отметить, — это обмен. Пользовательский опыт здесь довольно прост. Сначала вы подключаете свой кошелек NEAR к Ref Finance → выбираете токены, которые хотите обменять → завершаете обмен.



На бэкэнде своп Ref очень похож на Uniswap. Несколько пулов содержат разные пары токенов с соответствующей ликвидностью. Каждый своп имеет соответствующую комиссию за своп (0,005 доллара США), распределяемую между поставщиками ликвидности.

Хотите протестировать функцию обмена? Перейдите в тестовую сеть и обменяйтесь с помощью токенов LNC.



Не волнуйтесь, это тестовая сеть, поэтому вы не будете использовать настоящие токены. В основе функции обмена лежит формула постоянного продукта, популяризированная Uniswap: x * y = k

Итак, что именно означает эта формула?

Каждый пул ликвидности в Ref имеет два токена — x и y. «К» — это константа, определяемая руководством. Формула гласит, что сделки не должны изменять значение x*y от k. Согласно формуле, крупные транзакции обычно выполняются с худшими ставками, чем мелкие.
Обмен на стейблкоины
Есть еще одна крутая особенность функции обмена. Эта функция позволяет переключаться между следующими стейблкоинами — USN, USDT, USDC и DAI.

Основная формула здесь — та, которую популяризировали Михаил Егоров и Curve Finance.



В этом уравнении: 

 	D - является инвариантом
 	A - когерентный фактор, который установлен на 240 (может быть отрегулирован DAO) 
 	n - количество стейблкоинов

Итак, зачем свопам стейблкоинов нужна новая формула? По словам Егорова, поскольку проскальзывание настолько велико, доходность пула стейблкоинов, использующего формулу постоянного продукта, будет ничтожной.

Формула стейблкоинов предоставляет лучший инструмент для обмена стейблкоинов и уменьшает трения на рынке за счет улучшения арбитража DeFi.
Агрегация ликвидности в нескольких цепочках


Одна из основных целей Ref Finance — создать многоцепочечное будущее с помощью агрегатора ликвидности. В качестве первого шага Ref Finance будет использовать агрегатор ликвидности Aurora, совместимый с EVM. Агрегатор накапливает данные по всем дексам в цепочке Aurora и NEAR. Агрегатор позволяет пользователям свободно взаимодействовать как с NEAR, так и с дружественными к EVM экосистемами DeFi.

Агрегатор работает следующим образом:

Во-первых, он запрашивает соответствующие торговые данные на Aurorа.

Затем он находит оптимальный маршрут по всем пулам ликвидности на NEAR и Aurora, чтобы обменять токен A на токен B.

Обмен на агрегаторе ликвидатора Aurora работает следующим образом:

 	Токены передаются на адрес сопоставления в Aurora.
 	Обмен происходит на Aurora через ключи учетной записи NEAR пользователя.
 	Токены переводятся с адреса сопоставления Aurora на кошелек NEAR пользователя.




	

	
	
		
			
				Формула постоянного произведения x*y = k идеальна для?
			
		

		
					

		
			
			
			
			простой обмен
		
			
			обмен стейблкоинов
		
			
			кросс-чейн обмен
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Пулы ликвидности


Далее у нас есть основные протоколы DeFi — пулы ликвидности. Пул ликвидности состоит из двух (или более) токенов, которые позволяют пользователям торговать без посредников. Вместо этого пользователи могут предоставить ликвидность, заблокировав токены в пуле. Взамен они зарабатывают токены LP и комиссию за торговлю.

Ref Finance взимает комиссию за использование своих пулов. Комиссия пула варьируется от 0,05% до 0,3%. Комиссии начисляются в режиме реального времени и может быть списана при выводе ликвидности.

Давайте поближе познакомимся с одним из самых популярных пулов на Ref — пулом WBTC/ETH. Обычно эта пара довольно популярна в DeFi.



Как видите, пул WBTC/ETH имеет следующие важные показатели:

 	ТВЛ: 28 миллионов долларов
 	24-часовой объем: 512 000
 	Всего WBTC: 424,69 
 	Всего ЕН: 5860

Если вы хотите создать новый пул, вам просто нужно будет ввести пару токенов и принятые комиссии.


Фермы


Далее у нас есть фермерство. Обязательным условием для фарма является то, что вы должны предоставлять ликвидность одному из пулов Ref Finance. Когда вы предоставляете ликвидность, вы получаете токены LP в качестве квитанции о вашем вкладе. Таким образом, вы можете зарабатывать в дополнение к своим вознаграждениям LP, дополнительно размещая свои токены LP. Этот процесс размещения вашего LP и получения вознаграждения называется доходным фермерством.Зайдя в меню «Ферма», вы сможете увидеть как живые, так и не работающие фермы. В настоящее время фермой с высоким APR является ферма REF-wNEAR.



Ферма REF-wNEAR имеет ошеломляющие 71,1% годовых с двукратным увеличением. Кроме того, на прошлой неделе эта ферма выплатила вознаграждение в размере 133 000 долларов США. Награды за фермерство выплачиваются в токенах marmaj, DBIO, SKYWARD, REF, MYRIA и PARAS.
xREF стейкинг
Далее у нас есть стекинг xREF. Ставя свой REF, вы обмениваете его на xREF. Со временем вы будете постоянно зарабатывать больше REF, удерживая токены xREF.

Став стейкером REF, вы имеете право получать комиссию, генерируемую протоколом. 100% генерируемых комиссий за протокол используются для выкупа REF, из которых:

 	75% переводится на контракт xREF. 
 	25% выделено в казну. Казначейство отвечает за финансирование грантов и общественных инициатив.

Награды за стекинг выплачиваются линейно каждый квартал и имеют встроенные повышения в течение первых трех лет (которые могут быть изменены руководством):

 	Год 1: 2x
 	Год 2: 1,5x
 	3-й год: 1,2x
 	Год 4: 1x

Вот некоторые цифры для стейкинга xREF:



Feature
Number


Staking APR
12.22%


Number of Unique Stakers
5465


Revenue Shared with xREF Holders
105,561.75 REF


Total REF Staked
3,101,195.30 REF


Total xREF Minted
2,916,845.51 xREF


Cumulative REF Buyback
132,011.31 REF



 
Кроссчейн совместимость
Allbridge — это кроссчейн-мост, запущенный по протоколу NEAR, который позволяет ему взаимодействовать с другими блокчейнами, такими как Solana, Celo и Terra. Однако для совместимости Ethereum-NEAR мост по-прежнему остается лучшим вариантом. Пользователи могут получить доступ к этим разрозненным экосистемам блокчейна через эти мосты через Ref Finance.

Таким образом, вы можете не только получить доступ к лучшему из DeFi NEAR на Ref, но также можете перейти к доступу к ликвидности в других блокчейнах, богатых DeFi.

Пользователи Ref Finance могут взаимодействовать с EVM-совместимыми экосистемами через:




	

	
	
		
			
				Пользователи Ref Finance могут взаимодействовать с EVM-совместимыми экосистемами через:
			
		

		
					

		
			
			
			
			пул ликвидности
		
			
			фермы
		
			
			мультичейн
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Управление Ref Finance
Управление Ref Finance осуществляется через DAO, созданную Proximity в июне 2021 года. В настоящее время DAO использует контракт SputnikDAO для управления своими делами. В DAO есть два разных типа членов — Совет и Сообщество.

 	Совет: Члены совета могут создавать предложения и голосовать за них. Только члены совета могут вносить предложения. 
 	Сообщество: члены сообщества могут голосовать за предложения.

Вывод
Ref Finance — это платформа экосистемы NEAR DeFi. Она хорошо разбирается в токеномике и объединяет функции Uniswap и Curve Finance под одной крышей. Проверьте приложение из первых рук, перейдя в тестовую сеть. Попробуйте поменяться токенами LNC. Тестовая сеть позволяет вам торговать без использования реальных денег.




	

	
	
		
			
				У меня есть токены USN-USDT LP, но я хочу заработать больше. Какую функцию следует использовать в Ref Finance?
			
		

		
					

		
			
			
			
			обмен
		
			
			ферму
		
			
			пул
		
	
		

		
		
			
				Correct!
				Wrong!

### Otimização para Armazenamento On-Chain em NEAR (reduzindo o tamanho do contrato)

Nota: Deixamos algumas “perguntas” para você experimentar quais são os resultados finais.

O armazenamento na cadeia é caro. Para cada 100kB usados, 1 NEAR é bloqueado. Esses NEAR podem ser retornados se você remover o armazenamento usado. Existem duas causas principais de uso de armazenamento:

 	Transações: Cada transação é um recibo, que é salvo na cadeia, portanto, ocupando algum espaço de armazenamento. Cada recibo de transação tem um comprimento diferente (alguns chamam mais funções, portanto, um recibo mais longo; outros chamam apenas 1 função, portanto, um recibo mais curto), portanto, a quantidade de armazenamento usada é diferente. Assim como você precisa de mais papel para imprimir um recibo longo, você usa mais espaço de armazenamento para armazenar recibos mais longos.
 	Implantação de contrato inteligente: quando você implanta um contrato inteligente, ele ocupa o tamanho do contrato inteligente (pode ser um pouco diferente do que você vê no arquivo wasm local, mas no geral as diferenças são pequenas).
 Para transações, a menos que você reduza as transações que fez, você não pode realmente reduzir quanto espaço é ocupado devido às transações.

(Pergunta: Podemos excluir nossa conta de nível superior via near-cli? Se excluirmos, isso libera o custo de armazenamento? (PS: verifique o explorer após excluir uma subconta) Certamente, as transações não serão excluídas, portanto ele ainda bloqueará o custo de armazenamento, portanto, nunca poderá ser lançado?)

Aqui, falaremos sobre como otimizar o tamanho do seu contrato inteligente.
Nota: diz-se que o desenvolvimento em AssemblyScript leva a um tamanho de wasm menor, para o mesmo código escrito, em comparação com Rust. Eu não sou um desenvolvedor AS (prefira usar Rust), então não falaremos sobre isso; na verdade, não é preciso falar sobre isso, é o trabalho do compilador de qualquer maneira.
Otimizar o tamanho do contrato
Armazenamento persistente
Near tem uma lista de coleções, a lista está aqui. Essas coleções armazenam dados em cache para reduzir a taxa de gás. A compensação é: quanto de taxa de gás você deseja reduzir? Quanto custo de armazenamento você está disposto a pagar pela redução da taxa de gás? De quantos armazenamentos persistentes exclusivos você precisa?

A diferença é mencionada no link acima (as palavras exatas são as abaixo):

É importante ter em mente que ao usar std::collections (ou seja, HashMap, etc Rust locals), que cada vez que o estado é carregado, todas as entradas na estrutura de dados serão lidas rapidamente do armazenamento e desserializadas. Isso terá um grande custo para qualquer quantidade de dados não trivial, portanto, para minimizar a quantidade de gás usada, as coleções do SDK devem ser usadas na maioria dos casos.

Considere este exemplo: Temos um contrato principal que possui um dicionário/hash/map para vincular um ArticleId a um artigo. O artigo é um objeto (em Rust, também é chamado de Struct) com seus atributos.
use near_sdk::AccountId;
use near_sdk::collections::LookupMap;
use std::collections::HashMap;

pub struct Contract {
pub article_by_id: LookupMap<ArticleId, Article>,
}

pub struct Article {
pub owner_id: AccountId,
pub article_id: String,
pub royalty: HashMap<Account, u16>,
}
We see that Contract.article_by_id uses LookupMap and Article.royalty uses HashMap. We shall discuss why we don’t use other types.
Considere article_by_id, quando criamos um artigo, o id será único e específico para aquele artigo. Ficará guardado para sempre. Um LookupMap armazena em cache os resultados na memória para que não tenhamos que “calcular” (usando a taxa de gás) toda vez que precisarmos dos resultados.

Como mencionado anteriormente, como tudo será desserializado se lido ao usar HashMap, e LookupMap<AccountId, Article> não é uma quantidade trivial de dados (quando há muitos artigos sendo criados), deve ser cache on-chain.

Agora, por que estamos usando LookupMap em vez de UnorderedMap? O último oferece iteração sobre a funcionalidade de coleta, da qual não precisamos. Se precisar, use o último.

Então, para royalties, estamos usando HashMap. O fato é que temos muitos artigos, cada um com seu próprio Article.royalty. Para cada Article.royalty exclusivo, precisamos criar uma nova chave para salvar o armazenamento.
PS: Se você ainda não sabe, precisa de uma chave exclusiva para cada objeto das coleções NEAR SDK. Se duas coleções NEAR SDK compartilham a mesma chave, elas compartilham os mesmos dados (independentemente de funcionar ou falhar se você compartilhar memória entre dois objetos diferentes, como Vector e LookupMap)
Vamos ilustrar o mesmo cenário de armazenamento compartilhado de chaves. Digamos que criamos dois artigos, Artigo A e Artigo B. Esses são seus equivalentes Article.royalty.
// Values are percentage, 100.00% == 10_000.

// Article A
{
"alice.near": 1_000,
"bob.near": 500,
}

// Article B
{
"alice.near": 1_500,
"charlie.near": 2_000,
}
For some reason, there’s a repeat royalty for alice.near. If you use the same storage key, it will lead to error, complaining that: you already have an alice.near stored in Article A, and you are repeatingly storage another value to that key, and this is not possible. We also want them to be independent of each other; and same storage key used by 2 different HashMap means they share the same values.
(Pergunta: você pode buscar os valores armazenados no Artigo A se inicializar com a mesma chave de armazenamento no Artigo B?)

A solução é criar uma chave de armazenamento separada para cada coleção. No entanto, se temos 1 milhão de artigos, precisamos de 1 milhão de chaves de coleção diferentes para armazená-los separadamente. Isso parece estranho! Portanto, faz sentido armazená-los como HashMap. Além disso, eles são triviais. Esses royalties são originalmente projetados para limitar a quantidade de dados que eles podem armazenar, de modo que a busca de dados é pequena e a desserialização é barata. Isso fortalece nossa escolha de usar HashMap do que as coleções de SDK equivalentes, apesar do uso (ligeiramente) maior de Gás (que é insignificante, pois a coleção é tão pequena que é insignificante).

Concluindo, ao projetar seu contrato inteligente, escolha se deseja usar coleções NEAR SDK ou coleções Rust com base na trivialidade e quantas repetições você precisa para o mesmo Mapa.
Redução de código
O primeiro código que escrevemos, são ruins. Na verdade, eles são apenas um rascunho. Precisamos de alguma refatoração para excluir código desnecessário. Há uma compensação entre o código mais fácil de entender e a otimização do armazenamento.

Por exemplo, talvez um tenha um PayoutObject e seja usado apenas em uma única função.
use near_sdk::json_types::U128;
use near_sdk::AccountId;

pub struct Payout {
pub payout: HashMap<ArticleId, U128>,
}

impl Default for Payout {
fn default() -> Self {
Self [
payout: HashMap::new(),
]
}
}
Por que não podemos simplesmente definir um
HashMap::new()
na função específica que usa isso? Claro, se você fizer o último, seria mais difícil entender o código. O primeiro torna as coisas mais fáceis de entender, de uma perspectiva orientada a objetos. No entanto, (significativamente) mais código leva a mais armazenamento usado após a compilação para WASM. Então é hora de fazer algumas trocas.
Na opinião de One, a legibilidade é mais importante do que a otimização do espaço de armazenamento. Se necessário, clone o componente legível original e faça algumas otimizações sempre que fizer alterações, para que as pessoas possam entender o que você está fazendo lendo seu código original. Claro, isso significa mais trabalho para você.
(Pergunta: Quanto espaço é economizado se você substituir o primeiro pelo último? Se você tiver um cenário semelhante em seu programa, tente otimizá-lo escrevendo menos código e veja quanto espaço ele compila, há diferenças? (Às vezes não há, às vezes há. Para aqueles que não, prefira manter o código legível para facilitar a depuração no futuro. ))
Wasm-Opt
Depois de compilar a versão de lançamento otimizada, você ainda pode reduzir ainda mais o tamanho do contrato usando wasm-opt. Para instalar, baixe o binário aqui para o seu sistema operacional e descompacte-o. Dentro, há uma pasta “bin”, que você deve copiar o caminho exato para essa pasta e adicioná-la ao caminho do seu ambiente. Depois disso, tente chamar wasm-opt na linha de comando/terminal, seja executado ou não. Se não, pesquise online como resolvê-lo (talvez você não o tenha adicionado à variável de ambiente correta, talvez seu terminal já esteja aberto, o que não atualiza o caminho mais recente, são os dois problemas mais comuns).

Executá-los reduziria o tamanho do arquivo:
#!/bin/bash
set -e

export WASM_NAME=tipping.wasm
z
mkdir res

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
cp target/wasm32-unknown-unknown/release/$WASM_NAME ./res/
wasm-opt -Os -o res/output_s.wasm res/$WASM_NAME
ls res -lh
Aqui, assumimos que o contrato original é compilado para tipping.wasm, (o nome Cargo.toml é tipping). Em seguida, o nome otimizado é output_s.wasm. Em seguida, executamos ls (no Linux) para verificar a diferença no tamanho do arquivo. Deve ser menor.

Nota: você também pode use -Oz para os sinalizadores, mas One achou desnecessário, quanto ao projeto em que se trabalha, isso não leva a um tamanho de arquivo menor.

Nota importante: O RUSTFLAGS deve ser “link-arg=-s”, se você acidentalmente alterá-lo para “-z”, você pode ter um grande problema. Pelo menos para um, ele gera um arquivo wasm muito maior. Você deve experimentá-lo e verificar o seu próprio projeto.
Talvez no futuro, eles permitam o arquivo .wasm.gz para que você possa otimizar ainda mais o tamanho do arquivo. Atualmente, One tentou e não pôde desserializar um arquivo gzipado, suportando apenas o arquivo .wasm on-chain.
Cargo.toml
Estas são as bandeiras usuais para cargo.toml.
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
Você pode escolher opt-level = “z” também, pode ou não gerar um binário menor.
Algumas outras pequenas vitórias
Evite a formatação de strings
format! e to_string() pode trazer inchaço de código; então use string estático (&str) quando possível.

Removendo rlib se não for necessário
Se você não precisar fazer testes de simulação, remova rlib.

Use serialização Borsh
Prefira não usar serde quando possível. Aqui está uma página sobre como substituir o protocolo de serialização.

Evitar asserções padrão Rust e Panic macro

Estes contêm informações sobre o erro retornado, o que introduz inchaço desnecessário. Em vez disso, tente estes métodos:
// Instead of this
assert_eq!(
contract_owner,
predecessor_account,
"ERR_NOT_OWNER"
);

// Try this (for all versions of near-sdk-rs)
if contract_owner != predecessor_account {
env::panic_str("ERR_NOT_OWNER")
}

// For near-sdk-rs v4.0 pre-release
use near_sdk::require;
require!(
contract_owner == predecessor_account,
"ERR_NOT_OWNER"
);
require! é uma macro leve introduzida no near-sdk-rs v4 (e também é a macro favorita) para substituir assert! macro. Funciona principalmente como assert!, exceto por uma pequena diferença: não pode especificar o format! por si.
// assert! can specify format
assert!(
some_conditions,
"{}: {}"
error_type,
error_message
);

// require! cannot
require!(
some_conditions,
format!( // you need format! yourself
"{}: {}",
error_type,
error_message
)
);
E, como mencionamos antes, para evitar a formatação de strings, é melhor codificar a mensagem. Claro, se você realmente precisar, apenas sacrifique alguns bytes para usar o format! Está ok: ocupa apenas um espaço insignificante se você não o usar extensivamente.

Não use .expect()

Em vez disso, use unwrap_or_else. Alguém escreveu a função auxiliar na caixa de ajuda Near que você pode querer verificar.

Caso contrário, você sempre pode colocar isso em internal.rs:
fn expect_lightweight(option: Option, message: &str) -> T {
option.unwrap_or_else(||
env::panic_str(message)
)
}

// instead of:
let owner_id = self.owner_by_id
.get(&token_id)
.expect("Token not found");

// use this:
let owner_id = expect_lightweight(
self.owner_by_id.get(&token_id),
"Token not found"
);
Evite entrar em pânico
Estes são alguns erros comuns aos pânicos:

 	 Indexando uma fatia fora dos limites. my_slice[i]
 	Divisão de zero: dividend / 0
 	unwrap(): prefira usar unwrap_or ou unwrap_or_else ou outros métodos mais seguros para não entrar em pânico. No near-sdk, também há env::panic_str (env::panic está obsoleto) para entrar em pânico, e eles mencionaram aqui que poderia ser preferido. No entanto, você também pode usar a correspondência antiga para lidar com coisas e ver se funciona melhor que panic_str; caso contrário, use panic_str para facilitar a compreensão do código. Caso contrário, você pode mudar para combinar se valer a pena.

Tente implementar a solução alternativa para que ela retorne None ou não imponha nenhum pânico durante o desenvolvimento do contrato.
Abordagens de nível inferior
Confira o link na referência para outras formas de reduzir o tamanho do contrato não mencionadas aqui. (As coisas mencionadas aqui também não são mencionados aqui).

Lembre-se de que este exemplo não é mais atualizado, portanto, é necessário derivar manualmente para a atualização mais recente.

A lista está aqui:

 	Contrato minúsculo (obsoleto)
 	Contrato para fuzzing rs (você pode visualizar o branch master, este é um branch fixo para evitar que ele seja removido no futuro). Não se sabe o que esse contrato faz, nem o que significa “fuzzing”; você precisaria entender por si próprio.
 	O exemplo de Eugene para token fungível rápido, e você pode assistir ao vídeo do youtube aqui. Ele implementa sem usar near-sdk. Experiência de programação muito infeliz, mas otimizada para tamanho.
 	O Aurora usa rjson como uma caixa de serialização JSON leve. Ele tem uma pegada menor do que o serde atualmente empacotado com o Rust SDK. Veja este exemplo e o leitor exige derivar como ele é usado. Outro a considerar é a caixa de miniserde, exemplo aqui.

A ferramenta Wasm-snip
Pode ser útil substituir funções não usadas por instruções inacessíveis. Normalmente, você não precisa fazer isso: somente se você realmente precisar economizar esse espaço, poderá seguir em frente.

Eles mencionaram que a ferramenta também é útil para remover a infraestrutura em panic!

Você também pode executar wasm-opt com o sinalizador –dce após o recorte, para que essas funções recortadas sejam removidas.
Conclusão
Há muitas maneiras de otimizar um contrato. Algumas otimizações são feitas facilmente sem nenhuma alteração, outras têm compromissos e trocas que você deve decidir se vale a pena ou não as trocas. Em geral, a menos que seu contrato seja muito grande, o que geralmente resulta de muitas linhas de código sendo escritas e que você é encorajado a verificar a necessidade de código escrito; caso contrário, o uso simples, como wasm-opt e escolha de armazenamento persistente, deve ser suficiente.
Referências
Documentação SDK Near sobre como reduzir o tamanho do contrato

Reduzindo o tamanho do Wasm para Rust

### Teste de Simulação (Rust)

Antes de começarmos

Este artigo não mostra as possibilidades que um framework de teste de simulação pode fazer; ele discute sobre  como criar uma estrutura de teste de simulação MVP  para seu projeto. Para alterações mais avançadas, faça sua própria pesquisa (DYOR) e confira alguns links incluídos neste artigo.
NOTA:  Os testes de simulação ficarão obsoletos quando o Sandbox surgir. Confira  workspaces-rs  e  workspaces-js .

Breve introdução
A diferença entre teste de unidade e teste de simulação é: o primeiro é restrito a testes dentro da biblioteca; enquanto o último simula uma chamada  de fora para dentro. Os testes de unidade testam principalmente os frameworks internos para a lógica correta; enquanto o teste de simulação tenta simular as ações do usuário e verificar se as coisas acontecem como o desenvolvedor espera. Trate cada função como uma simulação.


Se você imaginou com Um teste Uma afirmação,  por favor, não faça isso. Mesmo para teste de unidade, não se concorda com uma afirmação por estrutura de função de teste; o que diz que testes de simulação requerem mais de uma afirmação dentro de uma única função/simulação.

Como sempre, o exemplo mais simples é o aplicativo Greeting; então vamos usar isso e escrever um teste de simulação para ele.

Teste de simulação do Greeting
Você não precisa escrever seu próprio aplicativo de saudação: basta executar este comando:

npx create-near-app --contract=rust <your_project_name>
Pronto! Agora você tem um exemplo de aplicativo de saudação com um frontend simples. Siga as instruções para implantar o contrato e testá-lo até se familiarizar antes de prosseguir. Verificando as últimas linhas da saída.
We suggest that you begin by typing: 
cd <your_project_name>
yarn dev
Copie o comando e teste como o aplicativo funciona até se familiarizar com ele. Após o teste, pare a implantação temporariamente: é muito chato reimplantar toda vez que você faz uma(s) pequena(s) alteração(ões) do ponto de vista de alguém, se não precisarmos do frontend.

Criar pasta de teste de simulação
Sem considerar NEAR, o teste de simulação também é chamado  de teste de integração  em (puro) Rust. Se você quiser saber mais, consulte  O Livro Rust  ou  Exemplos de Rust para verificar como realizar testes de integração.
Em suma, você precisa de uma pasta totalmente fora do  src chamado  tests. Então vamos fazer isso agora. Supondo que você já esteja  cd no diretório do seu projeto, execute isto:

cd contract
mkdir tests 
mkdir tests/sim
touch tests/sim/main.rs
Navegue e abra  <your_project_name>/contract/tests/sim/main.rs e abra-o no editor de sua escolha.

Agora, você pode despejar tudo em um arquivo ou dividi-lo. Geralmente, você tem  utils.rs para fazer funções que não sejam de teste que são reutilizadas. Você pode ter outro  arquivo .rs para vários testes curtos. Se você tiver testes mais longos, como os  testes de simulação do contrato de bloqueio , sugere-se um arquivo por teste; e nomeie seu arquivo de acordo. Você não gostaria que seus leitores vissem um arquivo com mais de 1.000 linhas de código.

Agora, mesmo que o Greeting não tenha longos testes de simulação, você vai mostrar o que se quer dizer com um teste por arquivo separando-os deliberadamente. Você não tem que fazer isso, no entanto.
Incluir dependências
Precisamos de uma biblioteca chamada  near-sdk-sim. Este exemplo usa  near-sdk v3.1.0, então usaremos a  near-sdk-sim v3.2.0 correspondente (não se sabe por que eles não combinam). Tenha em mente, no entanto, se a versão não corresponder, os testes de simulação não serão executados, porque diz  Import near_sdk::some_fn is not equal to near_sdk::some_fn, o que é confuso (mas na verdade  near_sdk::some_fn é  diferente de near_sdk::some_fn: eles têm versões diferentes!)


Na verdade, gostamos de escrever com  near-sdk v4.0.0-pre.4, mas isso requer algumas alterações no contrato para que ele seja executado. As mudanças não são complicadas, principalmente sobre  AccountId não é mais  String e algumas outras coisas menores; mas esse não é o objetivo deste artigo, então vamos ficar com o 3.1.0 e talvez atualizar este artigo no futuro se ele for atualizado. (Além disso, há algum bug com a simulação v4, sobre o qual falaremos mais tarde).

Vamos para  Cargo.toml: agora deve ficar assim: (veja nova seção  dev-dependencies). É importante garantir que  rlib está presente também!

[package]
name = "greeter"
version = "0.1.0"
authors = ["Near Inc <hello@near.org>"]
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "3.1.0"

[dev-dependencies]
near-sdk-sim = "3.2.0"

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

[workspace]
members = []

Anteriormente, escreveu-se um guia sobre a  redução do tamanho do contrato ; incluindo a remoção de “rlib”. Para usar testes de simulação, no entanto, é necessário “rlib”, então é uma troca entre o tamanho do contrato e fazer testes de simulação.

Se você parou em  yarn dev, agora compile o contrato uma vez para baixar a biblioteca. Em  contract, execute:

cargo build
Certifique-se de ter muito espaço em disco (recomendado 20 GB de espaço livre), pois isso ocupa bastante espaço!
Para uma experiência tranquila durante  a primeira compilação , tente compilar em uma máquina com 16 vCPU e 8 GB de RAM. Especialmente  librocksdb-sys levará muito tempo para compilar. Não está claro se a compilação é transferível (certamente não no sistema operacional, mas não tenho certeza se no mesmo sistema operacional). Como alguém alugou uma VM no Azure, pode-se facilmente alterar o tamanho temporariamente e alterá-lo de volta para um tamanho menor (e mais barato) após a compilação, portanto, sem conflito.

Vamos voltar para escrever os testes de simulação em  main.rs.

Prepare o arquivo wasm
Esteja ciente : toda vez que você fizer alterações em seu contrato, precisará reconstruir o wasm. Fizemos um script aqui para construir seu arquivo wasm e movê-lo para a pasta res do diretório superior.

Então execute isto: (do  diretório de contrato)
mkdir res 
touch build.sh
Em seguida, inclua o conteúdo abaixo  contract/build.sh para que você possa executar  bash build.sh (dentro  da pasta contract) em vez de digitar o comando todas as vezes.
#!/bin/bash 
set -e 

export WASM=greeter.wasm 

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release 
cp target/wasm32-unknown-unknown/release/$WASM res/
Importações
Isso é fácil: tratamos a biblioteca como uma biblioteca. Lembre-se, aqueles que estão  pub(crate) originalmente na biblioteca não podem ser usados ​​em testes de simulação (já que está fora). É como se você compilasse e alguém estivesse usando seu código. Certifique-se de importar as funções que você precisa.
Se verificarmos o  src.lib.rs, veremos que há (apenas) uma estrutura Welcome. Ao importá-lo, você adiciona a  palavra-chave Contract atrás. Por exemplo:

use greeter::{
    WelcomeContract 
};
Para o  contrato de bloqueio , sua estrutura principal é chamada  LockupContract, portanto, quando eles importam, é  LockupContractContract. Não se sabe por que fizeram assim, talvez para não ter conflito; basta adicionar!

Incluir arquivos de contrato
A próxima coisa antes de testarmos se funciona é incluir o arquivo wasm. Esta é uma obrigação. Além disso, se você tiver um  utils.rs, isso  NÃO deve  ser colocado lá; caso contrário, você precisa pensar muito em como torná-lo detectável de outros arquivos. Para não pensar muito, colocamos em  main.rs:

// Directories are relative to top-level Cargo directory. 
near_sdk_sim::lazy_static_include_bytes! {
      GREETER_WASM_BYTES => "res/greeter.wasm" 
      // other wasm bytes.  
}
O que se entende por “diretório de carga de nível superior” significa o  diretório contract. Certamente você pode descobrir coisas fora dele  ../../some_file se precisar. Por exemplo, se você não usar o  res mas o  yarn dev, o  out/main.wasm estará fora do diretório do contrato. Para importar, fazemos:
near_sdk_sim::lazy_static_include_bytes! {
     GREETER_WASM_BYTES => "../out/main.wasm" 
}

Como esta  é uma macro , certifique-  se de não colocar acidentalmente uma “vírgula” (“,””) após o último item ; caso contrário, você pode receber mensagens de erro estranhas e o Rust se recusa a compilar.

Infelizmente, não pudemos testar essa função enquanto ela funciona até que criamos a função auxiliar (um MVP completo) e um teste de MVP.

Função de inicialização
Para não repetir a função de configuração, nós os incluímos dentro de basic_setup(). Verifique o  contrato basic_setup() de  bloqueio  para outro exemplo (que inclui a implantação de outros contratos além do contrato de teste principal). Aqui, também faremos o mesmo, mas não temos outro contrato para configurar, então vamos pular isso e apenas incluir as funções necessárias em  basic_setup().
Faça um  utils.rs:

touch tests/sim/utils.rs
Dentro  de utils.rs, inserimos o conteúdo:
use crate::*; 

/// 300 TGas 
pub const MAX_GAS: u64 = 300_000_000_000_000; 

/// 1 NEAR (just a random number) 
pub const MIN_BALANCE_FOR_STORAGE: u128 = 1_000_000_000_000_000_000_000_000; 

pub const GREETER_ACCOUNT_ID: &str = "greeter"; 

pub(crate) fn basic_setup() -> (UserAccount, UserAccount) { 
  let mut genesis_config = GenesisConfig::default(); 
  genesis_config.block_prod_time = 0; 
  let root = init_simulator(Some(genesis_config)); 

  let alice = root.create_user( 
    "alice".to_string(), to_yocto("200") 
  ); 

  (root, alice) 
}
Há algumas coisas importantes a serem observadas aqui. O primeiro é este bloco de código:
let mut genesis_config = GenesisConfig::default(); 
genesis_config.block_prod_time = 0; 
let root = init_simulator(Some(genesis_config));
O Genesis é o primeiro bloco do blockchain. No entanto, gênese e tempo de gênese não são realmente os mesmos. Por exemplo, o  root representa o próprio blockchain. Não é a  conta near de  testnet nível superior: é a blockchain. No entanto, se você verificar  o explorer em testnet , veremos que ele foi criado durante o Genesis. Então, o  root vem primeiro, depois é empacotado com algumas das contas durante o  Genesis time. Criamos um simulador do Genesis chamado  root.

Aqui, o que queremos dizer com Gênesis não é o tempo da gênese, mas a “raiz última”. É a “conta pai” de todas as contas de nível superior.

Normalmente, não precisamos modificar o  GenesisConfig;  e se precisar, este é um exemplo.
Se você precisar fazer alterações no genesis,  confira os documentos para valores que você pode alterar. Em seguida, você pode modificá-la na linha 2 no bloco de código acima, atribuindo um valor a cada campo. Finalmente, você precisa inicializar o simulador com  init_simulator.
Se você não precisa de modificação, você pode inicializar um simulador sem configuração (que usará o padrão) assim:

let root = init_simulator(None);
Em seguida, temos a  criação root de uma conta chamada “alice” para nós. O primeiro argumento é o nome da conta, o segundo é quantos NEAR dar à conta.


Por  root ser o Genesis, ele só pode criar contas de nível superior como  near,  testnet,  alice. Ele não pode criar subcontas como  alice.near: apenas a conta pai  near pode criar  alice.near, não o Genesis.

Uma coisa que não temos aqui é a implantação com  root. Para nosso contrato, usamos a  deploy! macro que faremos na função de teste em vez de aqui. Mas se você tiver outro arquivo wasm, como o  contrato de bloqueio, eles não podem usar a  deploy! macro, então foi assim que eles fizeram.

Por exemplo, no contrato da lista de permissões; ele é implantado na raiz assim:
let _whitelist = root.deploy_and_init( 
  &WHITELIST_WASM_BYTES, 
  STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(), 
  "new", &json!({
    "foundation_account_id": foundation.valid_account_id(), 
  }).to_string().into_bytes(), 
  to_yocto("30"), 
  MAX_GAS, 
);
Como o requisito de uma  função init ser chamada  uma vez  durante a implantação é tão comum, existe uma função  deploy_and_init. Se o contrato não tiver uma função de implantação (supondo que a lista de permissões não tenha uma aqui), podemos fazer isso.
let _whitelist = root.deploy(
 &WHITELIST_WASM_BYTES,
 STAKING_POOL_WHITELIST_ACCOUNT_ID.parse().unwrap(),
 to_yocto("30") 
);
e na realidade não há  função deploy_and_init, então a chamamos manualmente. Para fazer isso, precisamos de uma conta para chamá-lo que tenha a capacidade de fazê-lo. Para o bloqueio, é a base
let foundation = root.create_user("foundation".to_string(), to_yocto("10000"));
 foundation.call(
   STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(),
   "new", 
   &json!({
      "foundation_account_id": foundation.valid_account_id()
   }).to_string().into_bytes(),
   MAX_GAS,
   NO_DEPOSIT, 
).assert_success();

Notamos que a realidade e a simulação possuem algumas diferenças.

Por fim, não se esqueça de importá-lo  main.rs e importar as funções necessárias:
use near_sdk::Balance;
 use near_sdk_sim::runtime::GenesisConfig;
 use near_sdk_sim::{init_simulator, to_yocto, UserAccount};
 pub(crate) mod utils;
 use utils::*;
Construindo a primeira função de teste
Estamos prontos para construir a primeira função de teste. Primeiro, importe as funções necessárias em  main.rs:
use near_sdk_sim::{deploy};
Esta é a macro de implantação.

Crie um arquivo para o teste:
touch tests/sim/test_set_and_get_greeting.rs
Como venho de um background em Python, gosto de nomear funções começando com  test. Você não precisa. Aqui, adoto nomear o nome do arquivo começando com  test_; enquanto a função de teste de ação dentro sem. Exemplo, teremos uma  set_and_get_greeting() função dentro test_set_and_get_greeting.rs de (arquivo).
Importe o arquivo  main.rs antes que esqueçamos:

mod test_set_and_get_greeting;
Não precisamos  de pub(crate) como  utils, pois não precisa compartilhar nada com outros arquivos.
A primeira coisa que precisamos na função set_and_get_greeting é implantar o contrato.

 let greeter_amount = to_yocto("1000");
 let (root, alice) = basic_setup();

 let greeter = deploy!(
   contract: WelcomeContract, 
   contract_id: GREETER_ACCOUNT_ID.to_string(),
   bytes: &GREETER_WASM_BYTES,
   signer_account: root,
   deposit: MIN_BALANCE_FOR_STORAGE + greeter_amount 
);
Se tivermos um  método personalizado #[init], incluímos estes após os  argumentos deposit:
gas: MAX_GAS,
 init_method: <method_name>(method_args)
No entanto, se não tivermos, nós os removemos. Para um monte de características que correspondem à macro,  verifique os documentos . Você precisa combinar pelo menos um deles; caso contrário, Rust se recusa a compilar.

(Pergunta: A ordem importa? Ou apenas o bando de kwargs precisa corresponder a uma das características?)

Observe que, diferentemente da realidade, a implantação é feita  root novamente (você pode ver em  signer_account). Na realidade, é feito por alguma conta responsável por isso.

Em seguida, vamos definir uma saudação e obter a saudação e afirmar que estão conforme o esperado.
Parece que as pessoas gostam de atribuir uma chamada de variável  res que é reutilizada repetidamente. Não é a maneira mais clara; mas certamente podemos fazer isso para não sobrecarregar nossa cabeça e pensar em nomes de variáveis. res significa apenas “resultados” retornados de uma chamada de função específica.


É uma boa prática atribuir seu res um tipo (independentemente de Rust poder inferir o tipo ou não), para que você saiba qual tipo é retornado.

Lembre-se que temos  view_method e  change_method em contrato inteligente. Para o contrato implantado  deploy! (que é o contrato inteligente que você pode importar e aquele que você está testando principalmente), podemos usar  view_method_call e  function_call respectivamente. Falaremos daqui a pouco se tivermos como chamar externo.

Nosso  set_greeting é um  change_method, então usaremos uma  function_call. Uma .function_call leva em a um PendingContractTx, Gas e Deposit.
O  PendingContractTx é apenas a função, e outros argumentos são fáceis de interpretar o que é. Vamos ver o nosso  set_greeting:

let greeting: String = "Hello, NEAR!".to_owned();
alice.function_call(
  greeter.contract.set_greeting(greeting),
  MAX_GAS, 0 
).assert_success();
Certifique-se de passar os respectivos argumentos na função. Também chamamos  assert_success() no final para garantir que a Promessa seja cumprida. O acima está imitando o near-cli:
near call $GREETER_CONTRACT set_greeting '{
  "message": "Hello, NEAR!"
 }' --gas=$MAX_GAS --amount=0 --accountId=$ALICE_ACCOUNT_ID
Então, podemos ter a chamada da função view. Se você verificar a função,  get_greeting pega um ID de conta do tipo  String e retorna um  String.
let res: String = alice.view_method_call( 
  greeter.contract.get_greeting(alice.account_id().to_string())
 ).unwrap_json();

Suspeita-se que você não precisa  .account_id().to_string(). Apenas  .account_id() é suficiente. Aqui, estamos apenas tornando-o explícito porque ele recebe uma String. Se  AccountId receber , podemos simplesmente chamar  .account_id() sem qualquer confusão. (Especialmente quando  AccountId não é mais igual a  String iniciar near-sdk-rs v4.)

Como o resultado retornado é um JSON, nós o desempacotamos com  unwrap_json().

Então, poderíamos fazer asserções sobre o resultado.
assert_eq!(res, greeting);
Recall  greeting é uma variável que atribuímos anteriormente, que é “Olá, NEAR!”.

Executando o teste de integração
Se você quiser apenas executar o teste de integração, execute

cargo test --tests sim (porque está na  pasta tests/sim). Se você deseja executar todos os testes, incluindo testes de unidade, execute  cargo test.

Observe que, por algum motivo, leva 30 segundos ou mais (independentemente de quantos núcleos de CPU você possui); você tem que esperar antes mesmo do teste começar.

Um lembrete novamente: se você fizer alterações no contrato, precisará reconstruí-lo; caso contrário, você se perguntará por que não funciona e acredita que funcionará agora, então…
Código completo
Você pode encontrar o código completo aqui:  https://github.com/Wabinab/NEAR_greeter_integration_tests

Conclusão
Agora, você pode repetir outros testes (se houver) criando um novo arquivo, vinculá-lo usando  mod para  main.rs, escrever os testes dentro. É um exercício divertido: quanto mais você escreve, mais você entende.

Uma nota sobre a atualização para v4.0.0-pre.4
A função de contrato da lista  de permissões deploy_and_init precisa de alterações nestes:

AccountId não é mais String

 	Então substitua tudo  "alice".to_string() por  "alice".parse().unwrap(). Se a substituição estiver dentro de uma função que não pode  parse, você precisa criar uma variável. (Isso é especialmente verdadeiro na  deploy! macro, que não tem inferência de tipo).


let alice_account: AccountId = "alice".parse().unwrap(); 

// pass it to the function. 

 	valid_account_id é preterido. Use  account_id() em vez disso. Isso ocorre em  json!.
 	Qualquer número inteiro passado para  json! requer especificação. Exemplo: v3.2.0 permite  10, mas v4.0.0-pre.4 não permite: você deve dizer  10u64 ou qualquer outro tipo.
 	A  #[quickcheck] macro tem um bug e falha no teste com v4. Um arquivo um erro  no Github ; até o momento, a equipe de desenvolvimento ainda não respondeu.

### Multiverse Fighters – Jogo P2E em NEAR

Neste artigo, veremos alguns aspectos do Multiverse Fighters, graças aos quais nosso projeto pode se tornar o carro-chefe do P2E no Near Protocol.
Jogabilidade
Clãs
Esta já é uma mecânica familiar para MMORPGs. Pessoas com objetivos comuns nos jogos se unem para espalhar sua influência. Em geral, nada de novo, mas você não pode ficar sem eles.
DAO e pedidos
Decidimos combinar esses 2 itens, porque eles estão intimamente relacionados. As encomendas representam um importante componente social do projeto. Moderadores, artistas, escritores e jornalistas são todos representantes da comunidade e se desenvolvem em conjunto com o projeto, e seu trabalho é recompensado pela pool (piscina) do ecossistema. Mais sobre o sistema de pedidos aqui –  blog/Order-System

DAO no projeto é um voto para inovações importantes, por exemplo, escolher uma descrição adequada para um item, o nome de um personagem ou adicionar uma nova arma desenvolvida por um dos jogadores ao jogo. A participação direta da comunidade no trabalho e desenvolvimento do projeto diferencia o Multiverse Fighters dos concorrentes!

O projeto é construído na blockchain de ponta NEAR, nos dando a capacidade de recompensar jogadores e membros da comunidade de forma transparente por meio de NFT e um token.
Arenas e torneios
As arenas, assim como as lutas normais, podem ser tanto individuais quanto em grupo, assim como com diferentes condições de lutas, por exemplo, apenas brigas de socos, ou sem equipamento e apenas com faca. Muitas opções 😉. Os próprios jogadores em um duelo na arena fazem uma aposta pela vitória, que pode ser um token ou qualquer NFT, isso adiciona emoção às lutas comuns.

As condições de algumas arenas também podem ser oferecidas pela comunidade e colocadas em votação na DAO. No final de cada mês, a arena mais impopular é removida e uma nova votação é realizada. Os torneios são realizados todos os dias e são divididos em diários, semanais e mensais. Eles diferem na premiação e acontecem em uma das arenas, as condições das lutas dependerão disso.
Movendo e interagindo
Um mapa interativo e interação com NPCs interessantes não deixarão você ficar entediado mesmo quando se cansar de lutar, nada impede que você obtenha prazer pela beleza estética do mundo ao seu redor no multiverso.

Mesmo escolhendo um caminho ao se mover entre os locais pode criar uma aventura interessante para você, que pode terminar tanto com um ataque de ladrões (outros jogadores) quanto com um encontro com NPCs únicos que até muitos elfos não conheceram, anões contam lendas sobre eles.

 



Jogabilidade diversificada
Belo componente visual e situações únicas criadas pelo Multiverse são ótimas para streams e conteúdo de vídeo, o que permite não apenas jogar Multiverse Fighters, mas também assistir outros jogadores com interesse.



Utilidade de token
Graças à extensa aplicação e modelo deflacionário, o valor do token MF só crescerá.

Comércio e aluguel de NFT, upgrade e reparo de alguns NFT, staking, seleção e reset de atributos, mais detalhes podem ser vistos no diagrama anexo.



Pool (Piscina) do ecossistema
Graças à pool do ecossistema, nosso modelo econômico difere da pirâmide usual, em que os primeiros investidores ganham com os recém-chegados. Com a ajuda das atividades de jogo, devolvemos ao jogador a maior parte de seu investimento no primeiro mês de jogo. E a partir do segundo mês ele já pode começar a ter lucro. Mas como nem todos os jogadores dedicam todo o seu tempo ao jogo, as recompensas permanecem na pool do ecossistema para possibilitar que jogadores ativos ganhem.

Graças à pool do ecossistema constantemente reabastecido – Multiverse Fighters é um excelente projeto de jogo com uma economia sustentável.




Web3
Web3 é uma ideia para uma nova iteração da World Wide Web baseada na tecnologia blockchain, que incorpora conceitos como descentralização e economia baseada em tokens. Alguns tecnólogos e jornalistas o compararam com a Web 2.0, onde dizem que os dados e o conteúdo são centralizados em um pequeno grupo de empresas às vezes chamado de “Big Tech”….

Sim, a Web3 ainda não foi formada, o que nos permite participar diretamente dela. Graças aos nossos princípios de construção de comunidade e à introdução do sistema DAO, nós mesmos nos tornamos parte da Web3, onde o conteúdo do Multiverse Fighters é descentralizado entre a comunidade e os próprios jogadores.

### O que é Ref Finance? Um guia passo a passo

O protocolo NEAR está lentamente ganhando força como um dos principais protocolos DeFi. A partir de agora, o valor total bloqueado em NEAR DeFi está próximo de meio bilhão de dólares. No entanto, a métrica a ser observada está no canto inferior esquerdo.



Mais de 50% do TVL é dominado pelo Ref Finance, tornando-o – em geral – o maior aplicativo DeFi no NEAR. Ref Finance foi o primeiro aplicativo DeFi na NEAR e combina várias funcionalidades, como câmbio descentralizado (DEX), protocolo de empréstimo, emissor de ativos sintéticos, etc.
Ref Finance - Uma Breve Introdução
A Ref Finance foi criada pelo cofundador do NEAR Protocol – Illia Polosukhin. O aplicativo foi implantado oficialmente em abril de 2021. A Proximity Labs recebeu uma doação da NEAR Foundation para inicializar e dimensionar o Ref Finance.

A Ref fechou uma venda privada em março de 2022 com investimentos da Jump Crypto (Lead), Alameda Research, Dragonfly Capital, etc. O objetivo principal do financiamento era obter liquidez suficiente para permanecer à tona por 24 meses a partir de março de 2022. Ref Finance levantou US$ 4,8 milhões em stablecoins por 3.664.943 tokens REF. 
REF – Utilitário de Token
O token nativo do Ref Finance é o REF. É um token fungível NEP-141 com um suprimento total de 100 milhões. Os tokens são distribuídos da seguinte forma:





As principais funções do token REF são as seguintes:

 	Os usuários podem fazer stake REF para ganhar taxas de protocolo.
 	Os usuários podem fornecer liquidez a pares de tokens com REF e ganhar taxas de swap.
 	Os tokens REF LP podem ser cultivados ainda mais para ganhar mais recompensas.
 	Os participantes do REF podem participar da governança da rede.

Olhando para Ref Finance
Vamos dar uma olhada mais de perto na Ref Finance e o que ela traz para a mesa. O aplicativo possui os seguintes recursos:

 	Trocas ou Swaps (incluindo stableswaps)
 	Agregação de liquidez
 	Piscinas de liquidez de tokens (Pools)
 	Fazendas derendimento (Farms)
 	Staking de xREF.

Swaps
A primeira característica da nota é o swap - ou as trocas. A experiência do usuário aqui é bastante simples. Primeiro, você conecta sua carteira NEAR ao Ref Finance → Escolha os tokens que deseja trocar → Complete a troca.



No backend, o swap Ref é bastante semelhante ao do Uniswap. Vários pools contêm diferentes pares de tokens com sua liquidez correspondente. Cada swap tem uma taxa de swap correspondente ($0,005), distribuída aos provedores de liquidez.

Deseja testar o recurso de troca? Vá para o testnet e troque usando os tokens LNC.



Ah, e não se preocupe. Esta é uma rede de teste, então você não usará nenhum token real.  No centro da função de troca está a fórmula do produto constante popularizada pela Uniswap: x * y = k

Então, o que exatamente essa fórmula significa?

Cada pool de liquidez em Ref tem dois tokens – x e y. “K” é uma constante que é determinada pela governança. A fórmula afirma que as negociações não devem alterar o valor de x*y de k. De acordo com a fórmula, transações grandes geralmente são executadas a taxas piores do que as menores.
Trocas de Moedas Estáveis - Stablecoins (Stableswaps)
Há mais um sub-recurso legal da função de troca. Esse recurso permite que você troque entre as seguintes stablecoins – USN, USDT, USDC e DAI.

A fórmula subjacente aqui é aquela que Michael Egorov e a Curve Finance popularizaram.



Nesta equação:

 	D é o invariante
 	A é um fator coerente, que é definido como 240 (pode ser ajustado pelo DAO)
 	n é o número de tokens estáveis

Então, por que os swaps de stablecoin precisam de uma nova fórmula? De acordo com Egorov, como a tolerância é tão alta, os retornos de uma pool de stablecoin que usa a fórmula de produto constante produzirão retornos insignificantes.

A fórmula stableswap fornece uma ferramenta melhor para trocar stablecoins e reduz o atrito do mercado, melhorando a arbitragem DeFi.
Agregação de liquidez multicadeia


Um dos principais objetivos da Ref Finance é criar um futuro multi-cadeia através de um agregador de liquidez. Como primeiro passo, a Ref Finance usará o Aurora Liquidity Aggregator compatível com EVM. O agregador acumula dados em todos os Dexes (Corretoras Descentralizadas) na cadeia do Aurora e NEAR. O agregador permite que os usuários interajam livremente com ecossistemas DeFi compatíveis com NEAR e EVM.

O agregador funciona assim:

 	Primeiro, ele consulta dados comerciais relevantes no Aurora.
 	Em seguida, ele encontra a rota ideal em todos as pools de liquidez em NEAR e Aurora para trocar o token A pelo token B.

A troca no agregador liquidante da Aurora funciona assim:

 	Os tokens são transferidos para um endereço de mapeamento em Aurora.
 	A troca acontece em Aurora por meio das chaves de conta NEAR do usuário.
 	Os tokens são transferidos do endereço de mapeamento da Aurora para a carteira NEAR do usuário.




	

	
	
		
			
				A fórmula do produto constante x*y = k é ideal para?
			
		

		
					

		
			
			
			
			Trocas normais
		
			
			Trocas de stablecoins
		
			
			Trocas de cadeia cruzada
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Piscinas de liquidez (Pools)


A seguir, temos o arroz com feijão dos protocolos DeFi – pools de liquidez. Uma pool de liquidez tem dois (ou mais) tokens que permitem que os usuários negociem sem passar por um intermediário. Em vez disso, os usuários podem fornecer liquidez bloqueando tokens no pool. Em troca, eles ganham tokens LP e taxas de negociação. 

A Ref Finance cobra uma taxa pelo uso de suas piscinas. A taxa da pool varia de 0,05% a 0,3%. As taxas são acumuladas em tempo real e podem ser reivindicadas quando você retira liquidez.

Vamos olhar mais de perto um das pools mais populares na Ref – a pool WBTC/ETH. Normalmente, esse par é bastante popular no DeFi.



Como você pode ver, a pool WBTC/ETH possui as seguintes métricas relevantes:

 	TVL: US$ 28 milhões
 	Volume de 24 horas: 512.000
 	Total WBTC: 424,69
 	Total EH: 5.860

Se você deseja criar uma nova pool, basta inserir o par de tokens e as taxas aceitas.


Fazendas de rendimento (Farms)


A seguir, temos o Farm. O pré-requisito para o farm é que você deve fornecer liquidez a um dos pools da Ref Finance. Ao fornecer liquidez, você recebe tokens LP como recibo de sua contribuição. Assim, você pode ganhar além de suas recompensas de LP apostando ainda mais seus tokens de LP. Esse processo de apostar seu LP e ganhar recompensas é chamado de farm de rendimento.

Ao acessar o menu “Farm”, você pode ver farms ao vivo e terminadas. Atualmente, a farm com a TAEG alta é a REF-wNEAR.



A farm REF-wNEAR tem uma TAEG impressionante de 71,1% com um aumento de 2X. Além disso, esta fazenda pagou US$ 133.000 em recompensas na semana passada. As recompensas de farm são pagas em tokens marmaj, DBIO, SKYWARD, REF, MYRIA e PARAS.
Staking de xREF
A seguir, temos o staking de xREF. Ao fazer stake de sua REF, você a troca por xREF. Com o tempo, você ganhará continuamente mais REF mantendo tokens xREF. 

Fazer staking de REF lhe dá o direito de ganhar taxas geradas pelo protocolo. 100% das taxas de protocolo geradas são usadas para recomprar REF, sendo:

 	75% é transferido para o contrato xREF.
 	25% são destinados à tesouraria. A tesouraria é responsável por financiar subsídios e iniciativas comunitárias.

As recompensas de staking são lançadas linearmente a cada trimestre e têm reforços integrados para os primeiros três anos (que podem ser alterados pela governança):

 	Ano 1: 2x
 	Ano 2: 1,5x
 	Ano 3: 1,2x
 	Ano 4: 1x

Aqui estão alguns números para staking de xREF:



Característica
Número


APR de Staking
12,22%


Número de stakes Únicos
5465


Receita Compartilhada com Detentores de xREF
105.561,75 REF


Total REF em staking
3.101.195,30 REF


Total xREF cunhado
2.916.845,51 xREF


Recompra cumulativa de REF
132.011,31 REF



Interoperabilidade entre cadeias
Allbridge é uma ponte de cadeia cruzada lançada no protocolo NEAR que permite interagir com outras blockchains como Solana , Celo e Terra. No entanto, para a interoperabilidade Ethereum-NEAR, a Rainbow Bridge ainda continua sendo a melhor opção. Os usuários podem acessar esses diferentes ecossistemas de blockchain por meio dessas pontes via Ref Finance.

Portanto, você não apenas pode acessar o melhor do DeFi da NEAR na Ref, mas também pode pular para acessar a liquidez em outras blockchains ricas em DeFi.




	

	
	
		
			
				Os usuários do Ref Finance podem interagir com ecossistemas compatíveis com EVM por meio de:
			
		

		
					

		
			
			
			
			Pools de liquidez
		
			
			Farm
		
			
			Agregador de várias cadeias
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ref Governança Financeira
A governança da Ref Finance acontece por meio da DAO que foi criada pela Proximity em junho de 2021. Atualmente, a DAO usa o contrato SputnikDAO para gerenciar seus negócios. A DAO tem dois tipos diferentes de membros – Conselho e Comunidade.

 	Conselho: Os membros do conselho podem criar propostas e votar nelas. Somente membros do conselho podem criar propostas.
 	Comunidade: os membros da comunidade podem votar nas propostas.

Conclusão
Ref Finance é uma das principais ferramentas do ecossistema NEAR DeFi. Ele tem bom tokenomics e reúne as funcionalidades do Uniswap e do Curve Finance sob o mesmo teto. Confira o aplicativo em primeira mão acessando a testnet . Tente trocar com os tokens LNC. A testnet permite que você negocie sem usar dinheiro real.




	

	
	
		
			
				Tenho tokens USN-USDT LP, mas quero ganhar mais rendimento. Qual recurso devo usar no Ref FINance?
			
		

		
					

		
			
			
			
			Fazendo Swaps
		
			
			Farms
		
			
			Pools
		
	
		

		
		
			
				Correct!
				Wrong!

### O que é Roketo

Então, o que exatamente é Roketo? Por que você escolheria a criptomoeda como método de pagamento? E como ele é diferente das dezenas de outros serviços de pagamento de criptomoedas por aí?' — Ouvimos muito essas perguntas e coletamos nossas melhores respostas neste artigo.

Abaixo, abordaremos como o Roketo funciona e por que ele mudará radicalmente seu processo de pagamento.

Muitas empresas lutam para encontrar uma forma de pagamento rápida e confiável, especialmente se suas equipes estiverem distribuídas em várias jurisdições. Nesse caso, a criptomoeda evita o incômodo das transferências eletrônicas internacionais, que podem ser demoradas e exigir alguma papelada.
Roketo é um serviço de streaming de criptografia que permite pagar pessoas e serviços por segundo. Baixa comissão, alta velocidade de transações e transparência o tornam uma solução perfeita para entrega de folha de pagamento. Nossos clientes usam nosso serviço para pagar funcionários, enviar fundos de subsídios de forma transparente,  liberar seus próprios tokens e investir em seus investidores. O streaming em tempo real também é útil quando se trata de serviços de pagamento por minuto, como estacionamento, equipamentos ou aluguel de coworking.

Como funciona?
O Roketo se vincula a uma carteira de usuário e transmite fundos aos destinatários em tempo real. O pagador faz login com a carteira NEAR, configura um fluxo, sua duração e outras configurações, insere o endereço da carteira do destinatário e começa a transmitir o dinheiro. Os fundos são entregues na carteira de fluxo do destinatário, que pode retirá-los para convertê-los.





Qual é a diferença de outras soluções no mercado?



Comissão baixa

Roketo  é construído em NEAR e isso nos permite manter uma das comissões mais baixas do mercado. Enquanto nossos concorrentes cobram 50$–100$ por stream, cada configuração de stream do Roketo custa menos de 1$. Além disso, você terá que pagar a taxa de gás por suas transações, que no ecossistema NEAR também é menor do que em outras blockchains. Apenas uma comparação: no Ethereum o custo por transação é ligeiramente superior a US$ 1 e no NEAR custa apenas alguns centavos.

Isso significa que, com o Roketo, os remetentes podem configurar com eficiência centenas de fluxos com o menor custo possível e os destinatários podem sacar dinheiro com a frequência que preferirem.

Transações rápidas

O streaming em tempo real significa que seus fundos chegam a cada segundo em uma certa velocidade e seus destinatários podem retirá-los a qualquer momento. Você pode esquecer as horas de espera em outros serviços, sem falar nos dias em que se trata de instrumentos financeiros tradicionais.

Transparência

Nossos clientes obtêm total transparência na alocação de fundos e na entrega da folha de pagamento. Mesmo ao fazer pagamentos em massa para seus investidores ou comunidade, as empresas ainda têm controle total sobre a alocação de tokens em tempo real. Cada stream tem um URL exclusivo onde você pode acompanhar a distribuição. Facilita o planejamento financeiro, pagamentos de impostos e relatórios.

Interface intuitiva

Você não precisa de mais de um minuto para configurar sua primeira transmissão no Roketo. Todas as opções de controle de fluxo podem ser acessadas e atualizadas facilmente, tanto do receptor quanto do remetente, sem terceiros. Pause, retome, pare, estenda fluxos e obtenha o histórico completo de operações no dApp. A interface do usuário é confortável de usar, mesmo para os membros da equipe sem conhecimento de criptografia.

Recentemente, garantimos US$ 900.000  na rodada inicial com a participação da Move Capital, MetaWeb Ventures e A&T Capital. Esse investimento nos ajudará a desenvolver nosso produto ainda mais rápido, portanto, fique atento às novas atualizações.

Links:

 	Junte-se à nossa comunidade no  Twitter
 	Fale conosco no  Telegram
 	Junte-se a nós no  Github
 	Experimente o  protocolo Roketo

### NearKits - O que você precisa saber

NearKits
Ok, então Nearkits é um Portfolio Tracker... Ou pelo menos foi assim que começou. Todos nós o conhecemos como uma ferramenta em que podemos verificar nosso portfólio NFT em NEAR. Eu, pelo menos, a usei inúmeras vezes para verificar isso durante este mercado de baixa. Eles também permitem um serviço de transferência NFT entre carteiras e, em seguida, um serviço de mensagens NFT. Chegarei a essa parte logo.
Enquanto escrevo isso hoje, 21/05/22, eles estarão cunhando sua coleção NFT às 7PM. Uma coleção de 333 ítens com diferentes níveis: Silver, Gold e Ruby e o custo para Mintar é de 10N e 50% dos royalties secundários serão distribuídos aos detentores… Ah, e tenho que mencionar que eles também estão envolvidos com a  Antisocial Studios




O roteiro




Fase 1
Ok, então com a Fase 1 completa, que incluiu um local para verificar o valor do seu portfólio NFT em Near em USD ou NEAR, com um preço médio de todos os NFTs.  Além disso, a capacidade de transferir NFTs entre diferentes carteiras, a capacidade de enviar uma mensagem ao proprietário de um NFT. 

Então, por exemplo, você vê uma NFT que deseja ou talvez tenha uma oferta para ela. Você então encontra o endereço e envia uma mensagem diretamente para a carteira. Você também tem uma galeria NFT muito simplificada, mas nada para comemorar ainda.
Fase 2
Este é o estágio de cunhagem. É uma coleção de 333 NFTs e diferentes camadas chamadas de cartões de acesso. O que mais vem com isso é:

 	Listagem de ferramentas em lote
 	Ferramenta de transferência NFT em lote
 	Ferramenta de lances NFT em lote
 	Mercado e rastreador de baleias
 	Links de galerias personalizadas
 	Bots para preços de base
 	Rastreador de preços NFT com base na raridade

Fase 3
Então, depois que toda a fase 2 foi concluída, passamos para a fase três e o que obtemos é:

 	Bots de servidor de Discord sofisticados
 	Um serviço de assinatura (não titulares)
 	Protocolo de Lançamento em NEAR
 	Ferramenta de análise de token
 	Extensão do navegador NEARKits




Uma espiada no NearKits NFT








Eles lembram os cartões de portais de acesso ao estilo cartão NFT, mas são as ferramentas por trás deles que farão os investidores desejar ter um e com apenas 333 ítens de oferta e um mint apenas para quem está na Lista Branca, será interessante ver como será a ação no mercado secundário.

Aqui está também o que eles fazem diariamente em seu Twitter para manter sua comunidade atualizada com os preços NEAR NFT FP




Este é um projeto que veio para o ecossistema NEAR com uma mentalidade de construir utilitários em primeiro lugar e fornecer a utilidade que queremos ou precisamos.

(Isenção de responsabilidade: faço parte da equipe deles como Conselheiro)
Conclusão
Então, dependendo de quando você estiver lendo isso, você pode estar cunhando ou pegando um no mercado secundário. Espero ter lhe dado informações suficientes para tomar uma decisão informada.

Links para encontrá-los em:

Twitter:  https://twitter.com/NearKits_io

NearKits:  https://nearkits.io/#my_nfts
Discord:  https://discord.gg/wh3GrGhbfB

### Fluxo de dados em NEAR

Explicação em vídeo​
No vídeo abaixo, tentamos dar uma visão geral rápida do conceito principal de como os dados estão fluindo na blockchain da NEAR. Você encontrará uma versão em texto abaixo do vídeo.


Versão em texto​






O fluxo de dados da blockchain NEAR pode ser um pouco complicado à primeira vista. Mas é bastante simples e segue regras bem definidas. Neste artigo, veremos mais de perto como os dados fluem na NEAR.

De fato, qualquer fluxo de blockchain pode ser representado como uma linha do tempo infinita que tem um início, mas não tem fim.





E um bloco aparece nessa linha do tempo com algum intervalo. Cada um desses blocos contém as informações sobre o anterior, criando assim uma  cadeia de blocos .

O protocolo NEAR tem uma natureza fragmentada, o que significa que mais de uma rede paralela, chamada de Shard , pode estar ativa a qualquer momento. E cada Shard produz um pedaço de um bloco em um determinado intervalo. Um bloco na NEAR é uma coleção de blocos de todos os fragmentos. O bloco de blocos é encurtado para  Chunk  na documentação do protocolo NEAR.

Retornando ao próprio fluxo de dados. O melhor que podemos fazer é imaginar faixas como podemos ver em aplicativos de edição de áudio/vídeo. Cada Shard tem seu próprio conjunto de faixas. A faixa superior é para Chunks. Eles aparecem não importa o que em um determinado intervalo. Para NEAR, o intervalo é de cerca de um segundo. Pedaços estão sendo produzidos mesmo que nada esteja acontecendo na blockchain.



Mas o que significa dizer que algo está acontecendo? Queremos dizer que algo desencadeou algumas mudanças na blockchain. E o método mais conhecido para acionar qualquer alteração é enviar uma transação para a blockchain com instruções do que queremos alterar e quem solicitou essas alterações.

Uma transação precisa ser construída, assinada e enviada para a blockchain. Uma vez executado, esperamos ter um resultado –  Resultado da Execução. Ah, isso é simples. Mas não é realmente exato para o NEAR Blockchain.



No início existe uma Transação, ela contém instruções que queremos que sejam executadas no blockchain. A transação é enviada para a NEAR Blockchain.

E sim, ela é executada lá imediatamente, MAS o resultado imediato da execução da transação é sempre apenas  um reconhecimento de que ela será executada na cadeia;  essa solicitação de execução interna é conhecida como  Recibo. Você pode pensar no  recibo  como uma transação interna que existe para passar informações entre os fragmentos (shards).

Vamos voltar às faixas para ver o exemplo.

Supondo que temos duas contas vivendo em  Shards diferentes:  alice.near  e  bob.near. 

Alice.near  cria uma transação para enviar alguns tokens para bob.near. A  Transação é executada imediatamente e o Resultado da Execução da Transação  é sempre um Recibo.

Mas este Recibo  não pode ser executado aqui, pois bob.near  não mora no mesmo Shard que alice.near, então o recibo deve ser executado no fragmento (Shard) do receptor. Portanto, o Recibo está se movendo para o Shard ao qual bob.near  pertence.

No Fragmento de destino é executado o Recibo e o processo é considerado concluído.
A EXPLICAÇÃO AQUI É SIMPLIFICADA
Consulte o artigo Fluxo de transferência de token

Assim, o esquema final ficará assim:


Resumo​
Aprendemos os principais princípios de como os dados estão fluindo na blockchain da NEAR. Descobrimos que as  transações são executadas e o Resultado da Execução da transação é sempre um recibo .

Agora sabemos que o Recibo é um ativo interno principal para a blockchain NEAR e tem o poder de viajar entre Shards. Aprendemos o fluxo de dados NEAR em um exemplo simples. Claro que na vida real com transações mais complexas, que envolvem chamadas entre contratos, haverá mais Recibos e Resultados de Execução.

Esperamos que este artigo seja útil e que você possa construir seus dApps e indexadores facilmente com o conhecimento de como os dados estão fluindo no protocolo NEAR.

### TokenHub – DeFi playground na NEAR testnet

1. O quê é um TokenHub?

 	O TokenHub é um playground (sala de treinamento) onde você pode criar seu próprio token com apenas alguns cliques e depois experimentar livremente todos os recursos do mundo Defi. 

2. Por que TokenHub?

 	Desde o halving do Bitcoin em 2020, o espaço DeFi cresceu continuamente e está bem desenvolvido na diversidade de produtos e base de usuários. O valor total bloqueado em todos os produtos DeFi chegou a atingir o pico de US $250 bilhões. Isso prova que a necessidade de DeFi está aumentando a cada dia, porém a maioria das pessoas só entendem os riscos do DeFi depois de perder dinheiro real com isso. E este é o motivo principal para a criação do TokenHub. A missão da equipe do TokenHub é ajudar os usuários do DeFi a adquirir experiência prática com muitos campos do DeFi, …  sem o custo de seu dinheiro real. Utilizando o TokenHub,  os usuários podem aprender muito sobre DeFi sem correr o risco de perder dinheiro, exclusivamente na testnet NEAR.

3. Manual de usuário do TokenHub
Guia passo a passo: Como criar o seu próprio token no TokenHub
Nº 1: Conecte sua conta NEAR testnet ao TokenHub
Se você não tiver uma conta NEAR testnet, siga as instruções do seguinte site official guide.

Entre a https://app.tokenhub.tk/token/create e clique em “Connect To Wallet”:



Assim que você for redirecionado para o site, clique em “NEXT”:


Em seguida clique “Connect”:



A partir desse momento, sua conta estará conectada ao TokenHub:


Nº 2: Ingresse a https://app.tokenhub.tk/token/create ou clique no botão “Criar Token” no painel esquerdo do TokenHub website:

Nº 3: Preencha as informações do token que você deseja
Isso inclui o nome do seu token, seu símbolo, sua oferta total e seu valor decimal (de 8 a 24). Neste exemplo, vou criar um token chamado “Bitcoin” e o seu símbolo será “BTC”, sua oferta total será de 21.000.000 tokens e um valor decimal de 8.



Uma maneira fácil de saber o que significa valor decimal é contar o número de dígitos que vem após o ponto decimal. Por exemplo, meu token Bitcoin tem um valor decimal de 8, então uma conta arbitrária pode ter 1,12345678 BTC ou 49,37603856 BTC, e o fornecimento total do meu token BTC será 21.000.000,00000000. Quanto maior o valor decimal, mais divisível será o seu token.
Nº 4: Configure a alocação do seu token 
Nº 4.1: Configurar as contas de alocação
Duas contas padrão receberão uma parte do fornecimento total de tokens: a conta de tesouraria do TokenHub (treasury.tokenhub.testnet) e a conta que você conectou ao TokenHub. Para adicionar mais contas que podem receber uma parte do seu fornecimento total de tokens, clique em “Add More Allocation” e preencha o endereço dessas contas, observe que as contas que você adicionar devem ser contas NEAR testnet, que são contas que terminam com “.testnet”, e não “.near”:



Meu token BTC será alocado apenas para as duas contas padrão:






	

	
	
		
			
				As contas padrão às quais seu token será alocado são a tesouraria do TokenHub e você estará conectado à sua carteira NEAR testnet.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nº 4.2: Determinar a alocação de token para cada conta.
Preencha quanto do sua reserva total (em %) será dado a cada conta na caixa “Alocação(%)”. O valor que a conta do tesouro receberá tem três opções para escolher entre 3, 5 ou 7%. Lembre-se de que não importa a quantas contas seus tokens serão alocados, a alocação total (%) de todas as contas deve ser 100%. Meu token BTC dará ao tesouro do TokenHub 3% (630.000 BTC), e os 97% restantes serão enviados para minha conta:


Nº 4.3: Definir o lançamento inicial para cada conta
Determine quanto (de 0 a 100%) da alocação que você definiu na Etapa 4.2 será enviada imediatamente para cada conta assim que você criar seu token. Neste exemplo, o tesouro receberá instantaneamente 10% de 3% de 21.000.000 de oferta total de BTC, que é 63.000 BTC. Quanto à minha conta, é 50% de 97% de 21.000.000 BTC, que é 10.185.000 BTC. Você pode estar se perguntando: “Como o restante do token será liberado?”. É aqui que entram os parâmetros de aquisição.


Nº 4.4: Configurar parâmetros de aquisição
A aquisição é a liberação gradual e periódica de tokens para as contas designadas. Por exemplo: Neste caso, isso significa que os tokens restantes, que não foram liberados inicialmente, serão bloqueados após sua criação e serão liberados em intervalos selecionados posteriormente. No TokenHub, você pode configurar 3 parâmetros para a aquisição do token: a data de início, a duração da aquisição e o intervalo de aquisição.

A data de início de aquisição determina quando o processo de liberação do seu token vai começar. Você pode configurar essa data individualmente para cada conta de alocação.



 

Em seguida, defina a duração da aquisição para cada conta. A duração da aquisição é quanto tempo irá demorar para liberar completamente os tokens. Para a conta de tesouraria do TokenHub, existem 3 opções a escolher (entre 1, 2 ou 3 anos). Quanto às outras contas, você pode preencher qualquer duração (em dias) que desejar. Neste exemplo, a aquisição do tesouro completará sua liberação de tokens em 1 ano. Para minha conta, será concluído em 30 dias.

 

Para terminar, defina os intervalos de aquisição (em dias) para cada conta. O intervalo de aquisição é o período entre cada liberação. Por exemplo, uma duração de aquisição de 30 dias e um intervalo de 10 dias significaria que os tokens serão divididos em 3 partes iguais e cada parte será liberada a cada 10 dias. Para a conta do tesouro, também existem 3 opções: 30, 90 ou 180 dias. Para outras contas, você pode escolher qualquer duração.






	

	
	
		
			
				Você não pode adicionar outras contas que possam receber seu token além das duas contas de alocação.
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Nº 5: Criar o seu token
Depois de concluir todas as etapas acima, clique em “Create Token”

Então você será redirecionado para este site, clique em “Aprovar” Depois de um tempo, você será redirecionado para a guia “Meu Token”, que inclui todos os seus tokens criados.
Guia: Iniciar sua venda de Tokens
Para iniciar sua venda de token no TokenHub, preencha este formulário:https://forms.gle/vgagVRQpKrEQJ8D86

Entre em contato com Harry – Fundador da TokenHub via: 

 	Discord: harrynguyen#0629
 	Telegram: @harrynguyen0991

Para que possamos ajudá-lo a configurar seu contrato de venda de tokens de acordo com seu registro de venda. Vamos informá-lo sobre o endereço do contrato para que você tenha que enviar tokens suficientes para esse contrato. Por fim, vamos colocá-lo no site do TokenHub para iniciar a promoção. Então tudo o que você precisa fazer é esperar e sua venda estará funcionando. Fundamentalmente, você precisa decidir quantos tokens serão alocados para venda e qual é o cronograma. Depende totalmente de você, mas a venda não deve durar muito. A venda do token LNC durou 3 dias, incluindo 2 dias da venda e 1 dia de graça, o que pode ser uma boa referência para você. Consulte a venda LNC Token Sale para mais detalhes.

### The Nephilim Beta Test

Follow @LearnNEAR on Twitter

Beta test sprint starts: June 22, 9 am ET
Beta Test sprint ends: June 24, 11pm ET.
Requirements:

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	Login the app  with NEAR account https://testnet.fp.thenephilim.io/
 	Join DAO and create a job post with NEAR token as payment method
 	If you have any NEP141-Tokens. e.g LNC testnet, register that token and create a post to use as payment method
 	Apply for the job you just created and approve applicant in dashboard
 	Complete the job and finalize payment
 	Take a screenshot
 	Tweet with your screenshot “I’ve just paid for the freelance project at @HouseOfNephilim, project from @LearnNEAR Barrel”

Fill the Feedback form
The top 20 beta testers will get 4 NEAR, the best feedback submitter will get 20 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

If any question for the test feel free to contact project lead  https://t.me/ymc182

### Multivers Fighters - Jeu P2E sur NEAR

Dans cet article, nous allons jeter un œil à certains aspects de Multiverse Fighters, grâce auxquels notre projet peut devenir le fleuron du P2E en Near Protocol.
Jouabilité
Clans
C'est déjà un mécanisme familier pour les MMORPG. Les personnes ayant des objectifs de jeu communs s'unissent pour étendre leur influence. En général, rien de nouveau, mais vous ne pouvez pas vous en passer.
DAO et commandes
Nous avons décidé de combiner ces 2 éléments, car ils sont étroitement liés. Les commandes représentent une composante sociale importante du projet. Les modérateurs, artistes, écrivains et journalistes sont tous des représentants de la communauté et se développent avec le projet, et leur travail est récompensé par le pool de l'écosystème. En savoir plus sur le système de commande ici – blog/Order-System

DAO dans le projet est un vote pour les innovations clés, par exemple, choisir une description appropriée pour un objet, le nom d'un personnage ou ajouter une nouvelle arme développée par l'un des joueurs au jeu. La participation directe de la communauté au travail et au développement du projet distingue Multiverse Fighters de ses concurrents !

Le projet est construit sur la blockchain de pointe NEAR, ce qui nous donne la possibilité de récompenser de manière transparente les joueurs et les membres de la communauté via NFT et un jeton.
Arènes et tournois
Les arènes, comme les combats réguliers, peuvent être à la fois simples et en groupe, ainsi qu'avec différentes conditions de combats, par exemple, uniquement des combats au poing, ou sans équipement et uniquement avec un couteau. Beaucoup d'options 😉 Les joueurs d'un duel dans l'arène fixent eux-mêmes un pari pour la victoire, qui peut être soit un jeton, soit n'importe quel NFT, cela ajoute de l'excitation aux combats ordinaires.

Les conditions de certaines arènes peuvent également être proposées par la communauté et mises au vote en DAO. À la fin de chaque mois, l'arène la plus impopulaire est supprimée et un nouveau vote est organisé. Les tournois ont lieu tous les jours et sont divisés en tournois quotidiens, hebdomadaires et mensuels. Ils diffèrent par la cagnotte et se déroulent dans l'une des arènes, les conditions des combats en dépendront.
Bouger et interagir
Une carte interactive et une interaction avec des PNJ intéressants ne vous laisseront pas vous ennuyer même lorsque vous en aurez assez de vous battre, rien ne vous empêche de tirer un plaisir esthétique du monde qui vous entoure dans le multivers.

Même choisir un chemin lorsque vous vous déplacez entre des lieux peut créer une aventure intéressante pour vous, qui peut se terminer à la fois par une attaque de voleurs (autres joueurs) et une rencontre avec des PNJ uniques que même de nombreux elfes n'ont pas rencontrés, les nains racontent des légendes à leur sujet.

 



Jeu varié
La belle composante visuelle et les situations uniques créées par le multivers sont idéales pour les flux et le contenu vidéo, ce qui vous permet non seulement de jouer à Multiverse Fighters, mais également de regarder d'autres joueurs avec intérêt.



Utilité du jeton
Grâce à l'application étendue et au modèle déflationniste, la valeur du jeton MF ne fera qu'augmenter.

Le commerce et location de NFT, mise à niveau et réparation de certains NFT, staking ou jalonnement, sélection et réinitialisation des attributs, plus de détails peuvent être vus sur le schéma ci-joint.



Pool de l'écosystème
Grâce au pool de  l'écosystème pool, notre modèle économique diffère de la pyramide habituelle, dans laquelle les premiers investisseurs gagnent sur les nouveaux entrants. Avec l'aide des activités de jeu, nous reversons au joueur la majeure partie de son investissement au cours du premier mois de jeu. Et dès le deuxième mois, il peut déjà commencer à faire des bénéfices. Mais comme tous les joueurs ne consacrent pas tout leur temps au jeu, les récompenses restent dans le pool de l'écosystème pour permettre aux joueurs actifs de gagner.

Grâce au pool de l’écosystème constamment renouvelé, Multiverse Fighters est un excellent projet de jeu avec une économie durable.




Web3
Web3 est une idée pour une nouvelle itération du World Wide Web basée sur la technologie blockchain, qui intègre des concepts tels que la décentralisation et l'économie basée sur les jetons. Certains technologues et journalistes l'ont opposé au Web 2.0, dans lequel, selon eux, les données et le contenu sont centralisés dans un petit groupe d'entreprises parfois appelées "Big Tech"….

Oui, Web3 n'a pas encore été formé du tout, ce qui nous permet d'y participer directement nous-mêmes. Grâce à nos principes de construction de communauté et à l'introduction du système DAO, nous faisons nous-mêmes partie de Web3, où le contenu de Multiverse Fighters est décentralisé entre la communauté et les joueurs eux-mêmes.

### Qu'est-ce que Ref Finance ? Un Guide Étape par Étape

Le protocole NEAR prend lentement de l'ampleur en tant que l'un des meilleurs protocoles DeFi. À l'heure actuelle, la valeur totale enfermée dans NEAR DeFi est d'un peu plus de 500 millions de dollars. Cependant, la métrique à surveiller se trouve dans le coin inférieur gauche.



Plus de 50% de TVL est dominé par Ref Finance, ce qui en fait la plus grande application DeFi de NEAR dans l'ensemble. Ref Finance a été la première application DeFi dans NEAR et elle combine plusieurs fonctionnalités telles que l'échange décentralisé (DEX), le protocole de prêt, l'émetteur d'actifs synthétiques, etc.
Ref Finance - Une Brève introduction
Ref Finance a été créé par Illia Polosukhin, cofondateur de NEAR Protocol. L'application a été officiellement déployée en avril 2021. Proximity Labs a reçu une subvention de la Fondation NEAR pour démarrer et faire évoluer Ref Finance.

Ref a conclu une vente privée en mars 2022 avec des investissements de Jump Crypto (Lead), Alameda Research, Dragonfly Capital, etc. L'objectif principal du financement était de lever suffisamment de liquidités pour rester à flot pendant 24 mois à compter de mars 2022. Ref Finance a levé 4,8 millions de dollars de pièces stables pour 3 664 943 jetons REF.
REF - Utilitaire de jeton
Le jeton natif de Ref Finance est REF. Il s'agit d'un jeton fongible NEP-141 avec une offre totale de 100 millions. Les jetons sont distribués comme ceci :





Les principales fonctions du jeton REF sont les suivantes :

 	Les utilisateurs peuvent staker REF pour gagner des frais de protocole.
 	Les utilisations peuvent fournir des liquidités aux paires de jetons avec des REF et gagner des frais de négociation.
 	Les jetons REF LP peuvent être davantage cultivés pour gagner plus de récompenses.
 	Les stakers du REF peuvent participer à la gouvernance du réseau.

En regardant Ref Finance
Examinons de plus près Ref Finance et ce qu'elle apporte à la table. L'application possède les fonctionnalités suivantes :

 	Swaps (y compris les stableswaps)
 	Agrégation de liquidité
 	Pools
 	Farms
 	Staking de xREF

Swaps
La première caractéristique du billet est le swapping. L'expérience utilisateur ici est assez simple. Tout d'abord, vous connectez votre portefeuille NEAR à Ref Finance → Choisissez les jetons que vous souhaitez échanger → Terminez le swap.



Sur le backend, l'échange ou swap sur Ref est assez similaire à celui d'Uniswap. Plusieurs pools contiennent différentes paires de jetons avec leur liquidité correspondante. Chaque swap a des frais d'échange correspondants (0,005 $), distribués aux fournisseurs de liquidités.

Voulez-vous essayer la fonction swap ? Accédez au testnet et échangez en utilisant les jetons LNC.



Oh, et ne vous inquiétez pas, il s'agit d'un testnet, vous n'utiliserez donc pas de vrais jetons. Au cœur de la fonction de swapping se trouve la formule du produit constant popularisée par Uniswap : x * y = k

Alors que signifie exactement cette formule ?

Chaque pool de liquidités dans Ref a deux jetons : x et y. "K" est une constante déterminée par la gouvernance. La formule indique que les transactions ne doivent pas modifier la valeur x*y de k. Selon la formule, les grosses transactions sont généralement exécutées à des taux moins bons que les plus petites.
Stableswaps
Il existe une autre sous-fonctionnalité intéressante de la fonction de swapping. Cette fonctionnalité vous permet d'échanger entre les stablecoins suivants : USN, USDT, USDC et DAI.

La formule sous-jacente ici est celle popularisée par Michael Egorov et Curve Finance.



Dans cette équation :

 	D est l'invariant
 	A est un facteur cohérent, qui est fixé à 240 (peut être ajusté par le DAO)
 	n est le nombre de jetons stables

Alors pourquoi les swaps de stablecoins ont-ils besoin d'une nouvelle formule ? Selon Egorov, étant donné que le slippage est si élevé, les rendements d'un pool de stablecoins utilisant la formule du produit constant produiront des rendements négligeables.

La formule stablecoin fournit un meilleur outil pour négocier des pièces stables et réduit les frictions du marché en améliorant l'arbitrage DeFi.
Agrégation de liquidité multi-chaînes


L'un des principaux objectifs de Ref Finance est de créer un avenir multi-chaînes grâce à un agrégateur de liquidités. Dans un premier temps, Ref Finance utilisera l'agrégateur de liquidité Aurora compatible EVM. L'agrégateur accumule des données sur tous les Dex de la chaîne Aurora et NEAR. L'agrégateur permet aux utilisateurs d'interagir librement avec NEAR et les écosystèmes DeFi amicales avec EVM.

L'agrégateur fonctionne comme ceci :

 	Tout d'abord, consultez les données commerciales pertinentes sur Auror.
 	Il trouve ensuite le chemin optimal à travers tous les pools de liquidités dans NEAR et Aurora pour échanger le Token A contre le Token B.

Le swapping dans l'agrégateur de liquidateurs Aurora fonctionne comme ceci :

 	Les jetons sont transférés vers une adresse de mapping dans Aurora.
 	L'échange se produit dans Aurora via les clés de compte NEAR de l'utilisateur.
 	Les jetons sont transférés de l'adresse de mapping Aurora vers le portefeuille NEAR de l'utilisateur.




	

	
	
		
			
				A quoi sert la formule du produit constant x*y = k idéale ?
			
		

		
					

		
			
			
			
			Swaps normaux
		
			
			Swaps de stablecoins
		
			
			Swaps inter-chaînes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pools de Liquidité


Ensuite, nous avons le pain et le beurre des protocoles DeFi : les pools de liquidités. Un pool de liquidité a deux (ou plus) jetons qui permettent aux utilisateurs de négocier sans passer par un intermédiaire. Au lieu de cela, les utilisateurs peuvent donner des liquidités en verrouillant des jetons dans le pool. En échange, ils gagnent des jetons LP et des frais de négociation.

Ref Finance facture des frais pour utiliser ses pools. Les frais de pool varient de 0,05% à 0,3%. Les frais s'accumulent en temps réel et peuvent être réclamés lorsque vous retirez des liquidités.

Examinons de plus près l'un des pools les plus populaires sur Ref : le pool WBTC/ETH. Habituellement, cette paire est assez populaire dans DeFi.



Comme vous pouvez le voir, le pool WBTC/ETH a les métriques pertinentes suivantes :

 	TVL : 28 millions de dollars
 	Volume sur 24 heures : 512 000
 	Total WBTC : 424,69
 	EH total : 5 860

Si vous souhaitez créer un nouveau pool, vous devrez simplement entrer la paire de jetons et les frais acceptés.


Farms


Ensuite, nous avons le farming. La condition préalable au farming est que vous devez fournir des liquidités à l'un des pools de Ref Finance. Lorsque vous fournissez des liquidités, vous obtenez des jetons LP en guise de reçu de votre contribution. Ainsi, vous pouvez gagner en plus de vos récompenses LP en staking davantage vos jetons LP. Ce processus de staking de votre LP et de gain de récompenses s'appelle rendement du farming.

En allant dans le menu "Farm", vous pouvez voir les farms en direct et terminées. Actuellement, la farm avec l'APR élevé est celle de REF-wNEAR.



La farm REF-wNEAR a un APR étonnant de 71,1 % avec une augmentation de 2X. De plus, cette farm a versé 133 000 $ en primes la semaine dernière. Les récompenses de farming sont payées en jetons marmaj, DBIO, SKYWARD, REF, MYRIA et PARAS.
Staking xREF
Ensuite, nous avons le staking xREF. En stakeant votre REF, vous l'échangez contre xREF. Au fil du temps, vous gagnerez continuellement plus de REF par holding des jetons xREF.

Être un staker de REF donne droit à percevoir les honoraires générés par le protocole. 100% des frais généraux de protocole servent au rachat de REF, dont :

 	Le 75 % se transfère au contrat xREF.
 	Le 25 % se destine à la tesorería. Le trésor est responsable des subventions financières et des initiatives communautaires.

Les récompenses de staking sont publiées de manière linéaire chaque trimestre et ont des bonus intégrés pour les trois premières années (qui pourraient être modifiés par le gouvernement) :

 	An 1 : 2x
 	An 2 : 1,5x
 	An 3 : 1,2x
 	An 4 : 1x

Voici quelques chiffres pour  le staking de xREF :



Fonction
Numéro


Staking APR
12,22%


Nombre de Stakers Uniques
5465


Revenu partagé avec les Holders de xREF 
105 561,75 REF


REF total Stakés
3 101 195,30 REF


Total xREF Mintés
2 916 845,51 xREF


Rachat cumulé de REF
132 011,31 REF



Interopérabilité EntreCes chaînes
Allbridge est un pont inter-chaînes lancé sur le protocole NEAR qui vous permet de vous interfacer avec d'autres chaînes de blocs comme Solana, Celo et Terra. Cependant, pour l'interopérabilité d'Ethereum-NEAR, le pont de Rainbow Bridge reste la meilleure option. Les utilisateurs peuvent accéder à ces écosystèmes de blockchain disparates à travers ces ponts via Ref Finance.

Pour autant, non seulement vous pouvez accéder au meilleur de DeFi en Ref de NEAR, mais vous pouvez également sauter pour accéder à des liquidités sur d'autres blockchains riches en DeFi.




	

	
	
		
			
				Les utilisateurs de Ref Finance peuvent interagir avec les écosystèmes compatibles avec EVM à travers :
			
		

		
					

		
			
			
			
			Pools de liquidités
		
			
			Farming
		
			
			Agrégateur multichaîne
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Gouvernance de Ref Finance
La gouvernance de Ref Finance s'effectue par l'intermédiaire du DAO qui a été créé par Proximity en juin 2021. Le DAO utilise actuellement le contrat SputnikDAO pour gérer ses affaires. Le DAO a deux types de membres différents : le Conseil et la Communauté.

 	Conseil : les membres du conseil peuvent créer des propositions et voter pour celles-ci. Seuls les membres du conseil peuvent créer des propositions.
 	Communauté : les membres de la communauté peuvent voter sur les propositions.

Conclusion
Ref Finance est l'OG de l'écosystème NEAR DeFi. Il fonctionne bien en tokenomics et rassemble les fonctionnalités d'Uniswap et de Curve Finance sous un même toit. Jetez un coup d'œil à l'application en vous rendant sur testnet. Essayez d'échanger avec des jetons LNC. Le testnet vous permet de trader sans utiliser d'argent réel.




	

	
	
		
			
				J'ai des jetons USN-USDT LP mais je veux obtenir plus de rendement. Quelle fonction dois-je utiliser dans Ref Finance ?
			
		

		
					

		
			
			
			
			Swapping
		
			
			Farm
		
			
			Pools
		
	
		

		
		
			
				Correct!
				Wrong!

### Multiverse Fighters - Juego P2E en NEAR

En este artículo, veremos algunos aspectos de Multiverse Fighters, gracias a los cuales nuestro proyecto puede convertirse en el buque insignia de P2E en Near Protocol.
Como se Juega
Clanes
Esta ya es una mecánica familiar para los MMORPG. Las personas con objetivos de juego comunes se unen para difundir su influencia. En general, nada nuevo, pero no puedes prescindir de ellos.
DAO y Órdenes
Decidimos combinar estos 2 elementos, porque están estrechamente relacionados. Las órdenes representan un importante componente social del proyecto. Los moderadores, artistas, escritores y periodistas son todos representantes de la comunidad y se desarrollan junto con el proyecto, y su trabajo es recompensado por el ecosistema. Más sobre el sistema de órdenes aquí – blog/Order-System

DAO en el proyecto es un voto por innovaciones clave, por ejemplo, elegir una descripción adecuada para un artículo, el nombre de un personaje o agregar una nueva arma desarrollada por uno de los jugadores al juego. ¡La participación directa de la comunidad en el trabajo y desarrollo del proyecto distingue a Multiverse Fighters de sus competidores!

El proyecto se basa en la vanguardia de la blockchain NEAR, lo que nos brinda la capacidad de recompensar de manera transparente a los jugadores y miembros de la comunidad a través de NFT y un token.
Arenas y Torneos
Las arenas, al igual que las peleas regulares, pueden ser individuales y grupales, así como con diferentes condiciones de peleas, por ejemplo, sólo peleas a puñetazos, o sin equipo y sólo con un cuchillo. Muchas opciones 😉 Los propios jugadores en un duelo en la arena establecen una apuesta por la victoria, que puede ser una ficha o cualquier NFT, agrega emoción a las peleas ordinarias.

Las condiciones de algunas arenas también pueden ser ofrecidas por la comunidad y puestas a votación en DAO. Al final de cada mes, se elimina la arena más impopular y se realiza una nueva votación. Los torneos se realizan todos los días y se dividen en diarios, semanales y mensuales. Se diferencian en el pozo de premios y tienen lugar en una de las arenas, las condiciones de las peleas dependerán de ello.
Moverse e Interactuar
Un mapa interactivo y la interacción con PNJ o <Personajes No Jugadores> interesantes no dejarán que te aburras incluso cuando te canses de pelear, nada te impide obtener placer estético del mundo que te rodea en el multiverso.

Incluso elegir un camino cuando se mueve entre ubicaciones puede crear una aventura interesante para usted, que puede terminar tanto con un ataque de ladrones (otros jugadores) como con una reunión con PNJ únicos que incluso muchos elfos no han conocido, los enanos cuentan leyendas sobre ellos.

 


Modo de Juego Diverso
El hermoso componente visual y las situaciones únicas creadas por Multiverse son excelentes para transmisiones y contenido de video, lo que le permite no sólo jugar Multiverse Fighters, sino también mirar a otros jugadores con interés.



Utilidad de Token
Gracias a la amplia aplicación y al modelo deflacionario, el valor del token MF sólo crecerá.

Los intercambios y alquiler de NFT, actualización y reparación de algunos NFT, staking, selección y restablecimiento de atributos, se pueden ver más detalles en el diagrama adjunto.



Pool del Ecosistema
Gracias al pool del ecosistema, nuestro modelo económico difiere de la pirámide habitual, en la que los primeros inversores ganan a los recién llegados. Con la ayuda de las actividades de juego, le devolvemos al jugador la mayor parte de su inversión en el primer mes del juego. Y a partir del segundo mes ya puede empezar a obtener beneficios. Pero dado que no todos los jugadores dedican todo su tiempo al juego, las recompensas permanecen en el pool del ecosistema para que los jugadores activos puedan ganarlas.

Gracias a que el pool de ecosistemas se repone constantemente, Multiverse Fighters es un excelente proyecto de juego con una economía sostenible.




Web3
Web3 es una idea para una nueva iteración de la World Wide Web basada en la tecnología blockchain, que incorpora conceptos como la descentralización y la economía basada en tokens. Algunos tecnólogos y periodistas lo han comparado con la Web 2.0, en lo dicen que los datos y el contenido están centralizados en un pequeño grupo de empresas a las que a veces se hace referencia como "Big Tech"...

Sí, Web3 aún no se ha formado del todo todavía, lo que nos permite participar directamente en él. Gracias a nuestros principios de creación de comunidades y la introducción del sistema DAO, nosotros mismos nos convertimos en parte de Web3, donde el contenido de Multiverse Fighters se descentraliza entre la comunidad y los propios jugadores.

### ¿Qué es Ref Finance? Una guía paso a paso

El protocolo NEAR está ganando impulso lentamente como uno de los principales protocolos DeFi. A partir de ahora, el valor total encerrado en NEAR DeFi está un poco por encima de los 500 millones de dólares. Sin embargo, la métrica a tener en cuenta está en la esquina inferior izquierda.



Más del 50 % de la TVL está dominada por Ref Finance, lo que la convierte, en general, en la aplicación DeFi más grande de NEAR. Ref Finance fue la primera aplicación DeFi en NEAR y combina múltiples funcionalidades como intercambio descentralizado (DEX), protocolo de préstamo, emisor de activos sintéticos, etc.
Ref Finance – Una breve introducción
Ref Finance fue creado por el cofundador de NEAR Protocol, Illia Polosukhin. La aplicación se implementó oficialmente en abril de 2021. Proximity Labs recibió una subvención de NEAR Foundation para arrancar y escalar Ref Finance.

Ref cerró una venta privada en marzo de 2022 con inversiones de Jump Crypto (Lead), Alameda Research, Dragonfly Capital, etc. El objetivo principal de la financiación era obtener suficiente liquidez para mantenerse a flote durante 24 meses a partir de marzo de 2022. Ref Finance recaudó 4,8 millones de dólares en monedas estables por 3 664 943 tokens REF.
REF - Utilidad de token
El token nativo de Ref Finance es REF. Es un token fungible NEP-141 con un suministro total de 100 millones. Los tokens se distribuyen así:





Las funciones principales del token REF son las siguientes:

 	Los usuarios pueden stakear REF para ganar impuestos del protocolo.
 	Los usos pueden proporcionar liquidez a los pares de tokens con REF y ganar impuestos de intercambio.
 	Los tokens REF LP se pueden farmear aún más para ganar más recompensas.
 	Los stakers de REF pueden participar en la gobernanza de la red.

Una Mirada a Ref Finance
Echemos un vistazo más de cerca a Ref Finance y lo que trae a la mesa. La aplicación tiene las siguientes características:

 	Intercambios o swaps (incluídos los intercambios estables o swapstables)
 	Agregación de liquidez
 	Pools
 	Granjas
 	Stakeo de xREF.

Swaps
La primera característica de la nota es el intercambio o swapping. La experiencia del usuario aquí es bastante simple. Primero, conecta su billetera NEAR a Ref Finance → Elija los tokens que desea intercambiar → Complete el intercambio.



En el backend, el swap de Ref es bastante similar al de Uniswap. Múltiples grupos contienen diferentes pares de tokens con su liquidez correspondiente. Cada intercambio tiene una tarifa de intercambio correspondiente ($ 0.005), distribuida a los proveedores de liquidez.

¿Quieres probar la función de intercambio? Vaya a la red de prueba e intercambie usando los tokens LNC.



Ah, y no se preocupe, ésta es una red de prueba, por lo que no utilizará tokens reales. En el centro de la función de intercambio se encuentra la fórmula del producto constante popularizada por Uniswap: x * y = k

Entonces, ¿qué significa exactamente esta fórmula? 

Cada grupo de liquidez en Ref tiene dos tokens: x e y. "K" es una constante determinada por la gobernanza. La fórmula establece que las transacciones no deben cambiar el valor de x*y de k. Según la fórmula, las transacciones grandes generalmente se ejecutan a tasas peores que las más pequeñas.
Intercambios de Monedas Estables o Stableswaps
Hay una subcaracterística interesante más de la función de intercambio. Esta función le permite intercambiar entre las siguientes monedas estables: USN, USDT, USDC y DAI.

La fórmula subyacente aquí es la que popularizaron Michael Egorov y Curve Finance.



En esta ecuación:

 	D es el invariante
 	A es un factor coherente, que se establece en 240 (puede ser ajustado por el DAO)
 	n es el número de tokens estables

Entonces, ¿por qué los intercambios de monedas estables necesitan una nueva fórmula? Según Egorov, dado que el deslizamiento es tan alto, los rendimientos de un grupo de monedas estables que utiliza la fórmula de producto constante producirán rendimientos insignificantes.

La fórmula de intercambio estable proporciona una mejor herramienta para intercambiar monedas estables y reduce la fricción del mercado al mejorar el arbitraje de DeFi.
Agregación de Liquidez Multicadena


Uno de los principales objetivos de Ref Finance es crear un futuro multicadena a través de un agregador de liquidez. Como primer paso, Ref Finance utilizará el agregador de liquidez Aurora compatible con EVM. El agregador acumula datos en todos los Dexes en la cadena Aurora y NEAR. El agregador permite a los usuarios interactuar libremente con los ecosistemas DeFi compatibles con NEAR y EVM.

El agregador funciona así:

 	Primero, consulta datos comerciales relevantes sobre Aurora.
 	Luego, encuentra la ruta óptima en todos los fondos de liquidez: en NEAR y Aurora para intercambiar el Token A por el Token B.

El intercambio en el agregador liquidador de Aurora funciona así:

 	Los tokens se transfieren a una dirección de mapeo en Aurora.
 	El intercambio ocurre en Aurora a través de las claves de cuenta NEAR del usuario.
 	Los tokens se transfieren desde la dirección de mapeo de Aurora a la billetera NEAR del usuario.




	

	
	
		
			
				¿Para qué es ideal la fórmula del producto constante x*y = k?
			
		

		
					

		
			
			
			
			Intercambios normales
		
			
			Intercambios de Stablecoins
		
			
			Intercambios de cadena cruzada
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pools de Liquidez


A continuación, tenemos el pan nuestro de cada día de los protocolos DeFi: Pools o grupos de liquidez. Un pool de liquidez tiene dos (o más) tokens que permiten a los usuarios operar sin pasar por un intermediario. En cambio, los usuarios pueden dar liquidez bloqueando tokens en el grupo. A cambio, ganan tokens del  LP e impuestos por comercio.o

Ref Finance cobra un impuesto por usar sus pools. El impuesto del pool varía de 0,05% a 0,3%. Los impuestos se acumulan en tiempo real y se pueden reclamar cuando se retira liquidez.

Echemos un vistazo más de cerca a uno de los pools más populares en Ref: el pool WBTC/ETH. Por lo general, este par es bastante popular en DeFi.



Como puede ver, el pool WBTC/ETH tiene las siguientes métricas relevantes:

 	TVL: $ 28 millones
 	Volumen de 24 horas: 512.000
 	WBTC total: 424,69
 	EH totales: 5.860

Si desea crear un nuevo pool, simplemente deberá ingresar el par de tokens y aceptar los impuestos.


Granjas


A continuación, tenemos el farmeo. El requisito previo para el farmeo es que debe proporcionar liquidez a uno de los pools de Ref Finance. Cuando proporciona liquidez, obtiene tokens del LP como recibo de su contribución. Por lo tanto, puede ganar además de sus recompensas, aún más sus tokens LP por stakear sus LP. Este proceso de stakear sus LP y ganar recompensas se llama farming de rendimiento o yield farming.

Al ir al menú "Farm", puede ver las granjas activas y finalizadas. Actualmente, la granja con TAE alta es la REF-wNEAR.



La granja REF-wNEAR tiene una asombrosa APR del 71,1 % con un aumento de 2X. Además, esta granja pagó $133,000 en recompensas la semana pasada. Las recompensas por farming se pagan en tokens marmaj, DBIO, SKYWARD, REF, MYRIA y PARAS.
Staking xREF
A continuación, tenemos el staking de xREF. Al stakear sus REF, lo cambia por xREF. Con el tiempo, obtendrá continuamente más REF al holdear o mantener  tokens xREF.

Ser un staker REF le da derecho a ganar impuestos generados por el protocolo. El 100% de los impuestos del protocolo generados se utilizan para recomprar REF, de las cuales:

 	El 75% se transfiere al contrato xREF.
 	El 25% se destina a la tesorería. La tesorería es responsable de financiar subvenciones e iniciativas comunitarias.

Las recompensas de staking se liberan linealmente cada trimestre y tienen impulsos incorporados durante los primeros tres años (que podrían ser cambiados por la gobernanza):

 	Año 1: 2x
 	Año 2: 1.5x
 	Año 3: 1.2x
 	Año 4: 1x

Aquí hay algunos números para el staking de xREF:




Función
Número


Staking APR
12,22%


Número de Stakers Únicos
5465


Ingresos Compartidos con Holders de xREF 
105.561,75 REF


REF total Stakeado 
3.101.195,30 REF


Total xREF Minteados
2.916.845,51 xREF


REF acumulados por  Recompra 
132.011,31 REF



Interoperabilidad entre Cadenas Cruzadas
Allbridge es un puente de cadena cruzada lanzado en el Protocolo NEAR que le permite interactuar con otras cadenas de bloques como Solana, Celo y Terra. Sin embargo, para la interoperabilidad de Ethereum-NEAR, el puente Rainbow Bridge sigue siendo la mejor opción. Los usuarios pueden acceder a estos ecosistemas de cadenas de bloques dispares a través de estos puentes por medio de Ref Finance.

Por lo tanto, no sólo puede acceder a lo mejor de DeFi en Ref de NEAR, sino que también puede saltar para acceder a la liquidez en otras cadenas de bloques ricas en DeFi.




	

	
	
		
			
				Los usuarios de Ref Finance pueden interactuar con ecosistemas compatibles con EVM a través de:
			
		

		
					

		
			
			
			
			Pools de liquidez
		
			
			Farmeo
		
			
			Agregador Multicadena
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ref Finanzas Gobernanza
La gobernanza de Ref Finance ocurre a través de la DAO que fue establecida por Proximity en junio de 2021. La DAO actualmente utiliza el contrato SputnikDAO para administrar sus asuntos. La DAO tiene dos tipos diferentes de miembros: Consejo y Comunidad.

 	Consejo: Los miembros del consejo pueden crear propuestas y votar sobre ellas. Sólo los miembros del consejo pueden crear propuestas.
 	Comunidad: Los miembros de la comunidad pueden votar sobre las propuestas.

Conclusión
Ref Finance es el OG o el <Ganster de la vieja escuela> del ecosistema NEAR DeFi. Funciona bien en tokenómica y reúne las funcionalidades de Uniswap y Curve Finance bajo un mismo techo. Echa un vistazo a la aplicación de primera mano yendo a testnet. Intente intercambiar con los tokens LNC. La red de prueba le permite operar sin usar dinero real.




	

	
	
		
			
				Tengo tokens LP de USN-USDT pero quiero obtener más rendimiento. ¿Qué función debo usar en Ref Finance?
			
		

		
					

		
			
			
			
			Swapping o Intercambio
		
			
			Farm o Granjas
		
			
			Pools o Fondos
		
	
		

		
		
			
				Correct!
				Wrong!

### Crypto Hero, Game di NEAR Protocol

Apa itu Crypto Hero?

Crypto Hero merupakan game berbasis blockchain yang berfokus pada PvE (Player vs Environment) di mana pada game ini kamu bisa menjelajahi ruang bawah tanah, menukar item dengan pemain lain dan bermain bersama teman dalam sistem penyerangan di mana kamu bisa mendapatkan hadiah Pixel Token setiap minggunya.

Ide ini terinspirasi oleh RPG tradisional, serta action RPG seperti Diablo.



Game ini menerapkan mekanisme dari game pada umumnya secara sederhana, yakni memungkinkan pengalaman yang efisien di mana pemain dapat mengembangkan karakter mereka, bersaing dengan orang lain dan yang terpenting menghasilkan uang.

Kenapa kamu harus memainkan game Crypto Hero?

Crypto Hero merupakan game kedua yang dibangun oleh PixelDapps dan tentunya tidak akan menjadi yang terakhir. PixelDapps terdiri dari tim yang telah berhasil menghasilkan game blockchain di mana para pemain dapat menemukan peluang untuk mendapatkan hadiah sambil bersenang-senang. Token Pixel  saat ini stabil dan semakin meningkat, dimana itu merupakan waktu yang tepat untuk berinvestasi di awal.

Selain itu, Crypto Hero sangat menyenangkan. Ini menciptakan sistem perkembangan dari RPG ke tingkat yang sama sekali baru dengan item NFT yang dikumpulkan dan diperdagangkan di seluruh komunitas yang pertama  dan utama terhubung dengan ide dan aspirasi dalam ekosistem.

Bagaimana cara memainkan Crypto Hero?

Peraturan terkait Crypto Hero 

Kapan kita dapat memainkannya?

Saat ini game sudah berjalan sejak MainNet diluncurkan pada Januari 2022

Dimana saya dapat memainkannya?

Silakan mengunjungi laman ini

1.  The Auction House (Rumah Pelelangan)

Item dapat ditukar di pada rumah lelang dengan Pixel Tokens. Anda dapat menyeleksi item melalui kategori serta berbagai jenis peralatan yang ingin dicari untuk melakukan pencarian dengan lebih mudah.



2. The Items (Barang dan Senjata)

Hero anda dapat dilengkapi hingga 6 item berbeda seperti senjata, baju besi, sepatu boot, kalung, cincin, dan helmet.

Item ditentukan berdasarkan tingkat kelangkaan: legendary, rare, epic, dan legendary.

Item dapat disimpan di dungeon rune, jika semakin besar level dungeon, semakin baik jika item yang dijatuhkan.

Item akan membuat Hero anda jadi lebih kuat.



3. The Hero (Pahlawan)

Hero anda  memiliki HP (health point), Level, dan Pengalaman.

Hero anda juga dapat naik level ketika mendapatkan pengalaman yang cukup.

Semakin tinggi level Hero milik anda maka akan semakin kuat dia.



 	The Dungeon (Ruang Bawah Tanah)

Kamu dapat mengirimkan pahlawan anda untuk menjelajahi ruang bawah tanah, di mana nantinya Hero akan menghadapi sekelompok makhluk.

Anda dapat memilih seberapa dalam anda ingin masuk ke ruang bawah tanah, level yang lebih dalam memberikan jarahan dan nilai pengalaman (exp) yang lebih baik, tetapi menjadi lebih sulit secara eksponensial.

Setelah anda mengalahkan dungeon, anda akan dihadiahi dengan loot dan exp dan harus menunggu untuk masuk ke dungeon lagi.



 	The Ranking Ladder (Tangga Peringkat)

Tangga peringkat menampilkan level tertinggi + level item dalam game, menciptakan skenario kompetitif antar pemain.



 	The Raids (Penyerbuan)

Sistem penyerbuan atau penyerangan  adalah dorongan sosial bagi pemain untuk terhubung satu sama lain, serta menjadi bagian utama dari permainan. Anda dapat berkelompok dengan 7 pemain lain untuk melawan bos yang memiliki kesulitan peringkat dan hadiah berbeda.

### Pengenalan Singkat Tentang The DeBio Network

Solusi Biomedis Terdesentralisasi di Octopus Network
Di kondisi sekarang, sistem biomedis saat ini masih banyak yang harus dibenahi. Status quo mencegah pasien untuk dapat mengakses data mereka secara bebas, dan penyedia layanan kesehatan tidak dapat menjamin keamanan data pasien mereka. DeBio Network hadir bertujuan untuk mengubah itu semua.
Apa itu DeBio Network?
DeBio Network merupakan platform anonim terdesentralisasi pertama untuk medis dan bioinformatika yang berspesialisasi dalam pengujian genomik. DeBio bertujuan untuk merevolusi industri biomedis saat ini dengan memberikan pasien kedaulatan penuh atas data mereka dengan menggunakan teknologi blockchain yang mutakhir saat ini..

Pengenalan blockchain di ekosistem teknologi saat ini memainkan peran besar dalam mengejar keuangan global yang terdesentralisasi, tetapi kasus penggunaan yang ditawarkan oleh blockchain lebih dari sekadar keuangan. DeBio percaya bahwa masa depan data medis sebagian bergantung pada penggunaan blockchain, terutama dalam spesialisasi kasus penggunaan teknologi serta interoperabilitas.
Pengujian Genetik Terpusat Adalah Risiko Terhadap Privasi
Selama beberapa tahun terakhir, pengujian genetik telah meledak dan menjadi cukup populer. Akibatnya, platform pengujian genetik langsung terhadap konsumen seperti 23andMe, dan AncestryDNA mengalami peningkatan dari sisi jumlah konsumen. Tetapi apa yang gagal disadari oleh banyak orang adalah risiko privasi implisit dari penggunaan platform ini.

Platform pengujian genetik langsung-ke-konsumen bersifat tersentralisasi, menjadikannya sasaran empuk bagi pelanggaran privasi data. Pada tahun 2020 terdapat sebanyak 1001 pelanggaran data di Amerika Serikat dengan industri perawatan kesehatan menerima beban tersebut, berdasarkan laporan dari Govtech.

Yang lebih memprihatinkan lagi adalah bahwa data genetik bersifat tidak unik untuk individu tetapi unik untuk silsilah keluarga dari individu tersebut. Dengan menggunakan layanan bioinformatika terpusat, anda tidak hanya membahayakan privasi anda, tetapi juga privasi kerabat jauh anda sendiri

Kerugian dari hal ini tidak diragukan lagi karena ada kemungkinan kerabat jauh anda, misalnya sepupu anda dapat terkena dampak dari keputusan yang anda buat. Yang mengkhawatirkan adalah bayangkan jika kerabat jauh yang bahkan anda tidak ketahui keberadaannya, melakukan tes genetika dan meminta data genetik mereka dilacak kembali kepada anda.

Data genetik dapat dilacak kembali ke anda bahkan dengan sedikit informasi demografis, seperti usia dan keadaan mereka. Jenis informasi ini dapat digunakan untuk menggugat anda oleh perusahaan asuransi, untuk memaksimalkan klien mereka.
Konsep DeBio Network
Konsep utama dibalik DeBio didasarkan kepada gagasan untuk meningkatkan pengujian biomedis dan genetik kepada konsumen tanpa mengorbankan privasi mereka. Tetapi DeBio juga ingin mendorong penelitian genetika dengan menawarkan kolaborasi antara laboratorium yang resmi.
Jembatan dari Fisik ke Digital untuk Pengujian Anonim
Konsumen dapat memilih berbagai macam produk dan rekomendasi dari laboratorium berdasarkan marketplace pengujian genetik dari DeBio. Setelah konsumen memutuskan suatu produk, mereka hanya perlu mengambil dua sampel DNA melalui metode buccal swab atau mengambil sampel sel rongga mulut dengan menggunakan cotton swab.

Konsumen kemudian mengirimkan sampel DNA ke laboratorium di dalam amplop dengan berisikan satu-satunya informasi yang dapat diidentifikasi yang tertulis pada amplop berupa ID pelacakan genetik untuk sampel tersebut. Laboratorium tidak dapat mengidentifikasi sampel tanpa ID pelacakan karena untuk tujuan anonimitas, DeBio tidak akan mengumpulkan informasi pengenal pribadi dalam bentuk apa pun, membuat sampel DNA tidak dapat dilacak kembali ke konsumen.

Hasilnya (misalnya, tes dan genom) kemudian dienkripsi dengan kunci publik konsumen yang diambil dari blockchain DeBio dan disimpan kemudian diunggah pada penyimpanan terdesentralisasi. Hal ini memungkinkan konsumen untuk mempertahankan kendali penuh atas data terenkripsi milik mereka  dan  konsumen harus memiliki kunci pribadi mereka untuk melakukan dekripsi hasil tersebut.

Tim DeBio Network memperluas konsep "penghubung fisik-ke-digital" ini untuk menggunakan kasus-kasus di luar pasar pengujian genetik, dimana hal ini dapat mencakup pengujian laboratorium untuk penyakit dan data rekam medis elektronik lainnya atau mengenai informasi kesehatan pribadi.
Kolaborasi Sovereign Lab Untuk Menawarkan Layanan Integrasi Produk Gabungan Dari Beberapa Laboratorium
Setelah konsumen mengirimkan sampel DNA ke lab, lab akan diberitahu. Ketika sampel tiba, lab akan mulai mengurutkan sampel fisik atau akan memulai tes biomarker apa pun. Setelah menyelesaikan pengujian berikutnya, lab kemudian akan mengenkripsi hasilnya menggunakan kunci publik konsumen dan mengunggahnya ke penyimpanan terdesentralisasi.

Hasil tidak dapat didekripsi tanpa menggunakan private key milik konsumen, sehingga kendali penuh konsumen atas hasil pengujian biomedis mereka aman. Namun, untuk lebih mendorong pengujian genetik, konsumen dapat memilih untuk melakukan staking data pengujian genetik mereka untuk digunakan oleh laboratorium lain.

Tujuan memiliki sovereign lab adalah untuk meningkatkan ketersediaan produk dan memungkinkan produk gabungan dengan mengintegrasikan layanan dari beberapa laboratorium. Ini juga memungkinkan DeBio untuk menskalakan karena lab tidak perlu dipusatkan sehingga memungkinkan beberapa fasilitas genetika mandiri lainnya bisa berpartisipasi.




	

	
	
		
			
				Apa masalah yang ingin diselesaikan oleh DeBio Network?
			
		

		
					

		
			
			
			
			masalah privasi di antara platform genetik online
		
			
			Hambatan di sovereign lab untuk melakukan pekerjaan mereka
		
			
			Kurangnya penelitian dalam genomik
		
			
			Biaya kesehatan yang mahal
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Techstack Debio Network
Bioinformatika dan ekosistem biomedis keduanya memiliki tuntutan unik tentang bagaimana keduanya harus dapat diakses oleh para profesional yang melakukan penelitian tetapi juga cukup aman untuk menjaga privasi dan kendali pasien atas data. Jadi, untuk menjamin kedaulatan pasien atas data mereka, seluruh tumpukan teknologi terdiri dari solusi terdesentralisasi mulai dari autentikasi yang  terdesentralisasi hingga penyimpanan file terdesentralisasi.



Image is taken from DeBio Deck

DeBio telah menyertakan banyak teknologi mutakhir ke dalam solusi, termasuk namun tidak terbatas pada:

 	Substrate
 	Protokol KILT
 	Octopus Network
 	The InterPlanetary File System (IPFS)
 	Ocean Protocol

Substrate
Teknologi penting pertama yang tergabung adalah Substrat. Substrat adalah kerangka kerja di balik token Polkadot, memungkinkan pengembang untuk membangun blockchain yang memiliki tujuan tertentu. Layanan inti akan dibangun menggunakan Substrat, menjadikannya sebagai inti pembuatan blocks dari solusi. DeBio memilih Substrat karena dua alasan berikut:

 	Interoperabilitas Blockchain (pada dasarnya untuk mampu berkomunikasi antara blockchain yang berbeda).
 	Relay Chain security (menerapkan standar keamanan yang lebih ketat dari host relay chain).

Selain memungkinkan blockchain untuk berkomunikasi satu sama lain, fitur interoperabilitas juga memberlakukan standar keamanan yang akan diwarisi oleh setiap parachain yang terhubung ke relay chain utama. Akibatnya, keamanan blockchain DeBio ditingkatkan dengan mengikuti standar relay chain yang sesuai.
KILT Protocol
Pembahasan penting berikutnya adalah Protokol KILT. KILT adalah protokol untuk membuat, membuktikan, dan memverifikasi identitas secara anonim di Web3. Untuk mengautentikasi dirinya sendiri, setiap pengguna perlu membuat klaim, yang kemudian akan dikirim ke attester terpercaya.

Seorang attester memiliki tanggung jawab untuk mensertifikasi klaim pengguna, yang kemudian akan diubah menjadi hash untuk disimpan di blockchain KILT. Klaim pengguna terkadang dapat berisikan data sensitif tentang pengguna, tetapi karena hash tidak dapat diubah kembali menjadi klaim pengguna, privasi pengguna menjadi terjamin.

Setelah menerima sertifikat dari attester terpercaya, pengguna kini dapat menggunakan klaimnya pada aplikasi yang menggunakan KILT dan mempercayai penguji tersebut. KILT merupakan privasi secara desain. Aplikasi yang akan memverifikasi klaim tidak perlu melalui attester dan akan langsung membandingkan klaim dengan yang disimpan di blockchain KILT, memotong attester dari proses verifikasi dan membuatnya sepenuhnya terdesentralisasi.

Protokol KILT memberikan solusi yang mencegah data terkonsentrasi dalam satu entitas. Hal ini memungkinkan kedaulatan data untuk yang sadar akan privasi. DeBio telah bermitra dengan KILT untuk menerapkan sistem otentikasi terdesentralisasi karena sangat cocok dengan kasus penggunaan anonim-pertama dari DeBio.
The Octopus Network
Octopus adalah jaringan kripto untuk meluncurkan dan menjalankan aplikasi blockchain yang spesifik dengan biaya yang lebih murah. Salah satu pertimbangan menggunakan Octopus adalah, dibandingkan dengan Polkadot, mereka menawarkan biaya sewa keamanan yang jauh lebih murah dan kemampuan cross-chain yang sebanding. Octopus didukung oleh Protokol NEAR, NEAR adalah blockchain berkinerja tinggi yang dimaksudkan untuk memecahkan masalah skalabilitas, dan untuk meningkatkan produktivitas developer dengan menyederhanakan proses pengembangan dan menciptakan lingkungan yang ramah bagi developer.

DeBio telah bermitra dengan Octopus dan akan menjadi salah satu dari lima blockchain (app chain) khusus aplikasi pertama yang diluncurkan di Jaringan Octopus. DeBio juga sudah menjadi bagian dari Octopus Guild, sebuah komunitas pengembang dan app chain di Octopus Network.
The InterPlanetary File System (IPFS)
InterPlanetary File System adalah protokol yang dibuat untuk berbagi dan penyimpanan data peer-to-peer yang sepenuhnya terdesentralisasi. IPFS dibuat sebagai solusi untuk proyek terdesentralisasi yang ingin menyimpan sejumlah data yang terlalu besar untuk disimpan di blockchain itu sendiri. IPFS membuat alamat konten unik dengan melakukan hashing konten itu sendiri. Setiap konten unik akan memiliki alamat berbeda yang menunjuk ke lokasinya. DeBio menambahkan IPFS untuk menyimpan data biomedis seperti genom manusia terenkripsi dan catatan medis elektronik terenkripsi.
Ocean Protocol
Ocean Protocol dibuat untuk konsumsi aset data dengan cara yang aman dan menjaga privasi. Ini dilakukan dengan fitur komputasi-ke-data dan memungkinkan monetisasi data tanpa harus meninggalkan lokasi dari pemilik data. Pasar data open-source dari Ocean Protocol yang disebut Ocean Market bisa di-forkable; tim Jaringan DeBio akan menggunakan Ocean untuk melakukan staking data biomedis.
Komputasi Privasi
Untuk melakukan staking data biomedis, DeBio akan meng-host data biomedis anonim di penyimpanan data pribadi mereka. Proses ini tidak melibatkan IPFS yang disebutkan di atas karena penyimpanan data akan sepenuhnya terpisah dari IPFS. Pengguna yang ingin melakukan staking data mereka perlu mendekripsi dan mengunggah data biomedis mereka ke penyimpanan data pribadi mereka. Saat mentransfer data biomedis yang didekripsi ke penyimpanan data pribadi memang terdengar menakutkan, namun DeBio akan menerapkan konsep komputasi privasi di dalam penyimpanan data untuk melindungi privasi Anda.



Image retrieved from DeBio Whitepaper

Hanya setelah persetujuan pengguna, kumpulan data lalu dikumpulkan melalui proxy komputasi-ke-data Ocean, dan pihak ketiga akan dapat membuat analitik dan memproses data selama itu tetap di tempat.

Dengan memberi insentif kepada pengguna untuk staking data genomik/biomedis mereka, dan harapannya itu akan jadi mendorong kegiatan penelitian di lapangan. Selain itu, penyimpanan data pribadi tidak akan mengumpulkan informasi pengenal pribadi sehingga tidak perlu khawatir sampel Anda dilacak kembali kepada anda.

Pandu Sastrowardoyo, CEO DeBio, menyatakan bahwa salah satu alasan dia menciptakan DeBio adalah untuk membantu penelitian genetik berkembang dengan menciptakan pasar data genetik yang sepenuhnya anonim. “DeBio adalah sistem ekonomi baru untuk genomik — memungkinkan kendali penuh atas genetik, memastikan partisipasi laboratorium yang lebih kecil sambil meningkatkan penelitian genetik. Semua dilakukan di atas model seperti DeFi yang sepenuhnya terdesentralisasi, ”kata Pandu.




	

	
	
		
			
				Dimana DeBio menyimpan data yang distaking?
			
		

		
					

		
			
			
			
			Didalam blockchain DeBio
		
			
			Didalam data token
		
			
			Penyimpanan data pribadi
		
			
			Di IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Lapisan Arsitektur Teknis
Arsitektur teknis kami terdiri dari empat lapisan yaitu : infrastruktur blockchain utama, lapisan transportasi, lapisan logika bisnis generik, dan terakhir lapisan logika bisnis tingkat atas.



DeBio Proposed Technical Architecture, Image retrieved from DeBio Whitepaper
Layer 1: Infrastruktur Blockchain
Lapisan pertama akan berisi layanan inti. Layanan inti dibangun di atas Substrat, Octopus, dan IPFS. Substrat adalah core building block untuk layanan blockchain. Untuk menyimpan file besar DeBio akan menggunakan IPFS dan menyimpan alamat konten di dalam Substrat. Terakhir, seluruh rantai aplikasi akan terhubung dengan relay chain dari Octopus.
Layer 2 & 3: The Transport and Generic Business Logic Layer
Lapisan kedua dan ketiga berisi transportasi dan logika bisnis generik. Lapisan ini bertanggung jawab untuk menyajikan data langsung ke pengguna. Setiap palet berisi logika bisnis dasar untuk interaksi dengan blockchain dan akan berfungsi sebagai lapisan abstraksi dari lapisan keempat untuk berkomunikasi dengan layanan Substrat pada lapisan pertama.
Lapisan 4: Lapisan Logika Bisnis Tingkat Atas
Lapisan keempat terdiri dari DeBio UI dan Metamask. Semua interaksi antara pengguna dan blockchain akan dilakukan pada lapisan keempat. Semua kueri juga akan ditentukan dari tingkat atas, dan kemudian akan diproses pada semua lapisan yang disebutkan sebelumnya. Untuk mendanai setiap transaksi, pengguna dapat menggunakan Metamask untuk membayar menggunakan stable coin ERC20. Dalam hal ini, DeBio akan menggunakan DAI sebagai stablecoin pilihan.
Model Token


Image retrieved from DeBio Whitepaper

Tim DeBio Network bermaksud untuk merilis enam jenis token:

 	Reward Transaksi Mainnet & Token Validator ($DBIO)
 	Token Tata Kelola ($GBIO)
 	Token Data Genomics ($GEN, melalui Ocean Protocol)
 	Token Data Biomed ($MED, melalui Ocean Protocol)
 	Token Data Rekam Medis Elektronik ($EMR, melalui Ocean Protocol)

Mainnet Coin (stable coin, dll)
Koin mainnet akan didukung oleh stable coin. DeBio memutuskan untuk menggunakan stable coin karena perlu digunakan sebagai pertukaran yang stabil untuk transaksi, dan biaya yang terkait dengan pekerjaan yang dilakukan oleh lab terkait. DeBio akan menggunakan $DAI sebagai stable tokennya.
Governance Token ($GBIO)
Token tata kelola akan digunakan terutama untuk voting oleh lab terdaftar. DeBio Network adalah organisasi yang terdesentralisasi sehingga perlu ada skema tata kelola untuk pemungutan suara di marketplace DAOGenics. Atau, token tata kelola juga dapat berfungsi sebagai metode untuk onboarding lab.
The Data Tokens ($GENE, $MED, and $EMR)
Token ini digunakan sebagai metode transaksi di marketplace data. Saat melakukan staking  data biomedis di marketplace Ocean, konsumen akan diberi token data yang dapat dikonversi ke $OCEAN.
Validator & Transaction Rewards ($DBIO)
Token validator digunakan untuk memberi insentif kepada pemilik node untuk memvalidasi transaksi dan mengamankan dApp dari pengguna yang tidak sah. Insentif yang diberikan untuk validator adalah hadiah Liquidity Provider dan token tata kelola.
Transaksi Konsumen Di Debio Network
$DAI adalah koin stabil mainnet yang digunakan untuk transaksi di platform DeBio. Konsumen dapat menggunakan koin mainnet untuk membayar produk dan biaya layanan. Produk yang akan tersedia di pasar antara lain produk pengujian genomik, produk pengujian biomedis, dan layanan penyimpanan rekam medis elektronik (EMR) yang berdaulat.



Image retrieved from DeBio Whitepaper
Imbalan dari Transaksi
Setiap transaksi yang dilakukan oleh konsumen akan dihargai dengan token validator, lebih khusus lagi token $DBIO. Harga satu token $DBIO ditentukan oleh pasar data DeBio Network yang menampung data genom konsumen yang tersedia untuk distaking.
Data Staking Di DeBio Network
Setelah membeli produk di marketplace, konsumen dapat memilih untuk melakukan staking hasil mereka di Ocean Marketplace. Data yang distaking oleh konsumen akan dikategorikan sebagai token data, masing-masing disebut $GEN, $MED, dan $EMR untuk data genomik, data biomedis, dan rekam medis elektronik (EMR). Token data akan disimpan di Jaringan DeBio dan dikumpulkan ke pasar data melalui Ocean Protocol sebagai token ERC20. Karena data genomik, data biomedis, atau EMR itu sendiri terlalu besar untuk disimpan di dalam token data ERC20, token data terutama akan berfungsi sebagai penunjuk/tautan ke data terkait.

Konsumen yang melakukan staking token data mereka akan memiliki peran sebagai “penyedia data” di pasar data. Semua transaksi di pasar data Ocean akan menggunakan token $OCEAN. Jadi, jika transaksi berhasil, pembeli akan menukar token $OCEAN dengan token data ($GENE atau $EMR atau $MED). Sedangkan “penyedia data” akan menerima token $OCEAN berikutnya.



Image retrieved from DeBio Whitepaper

Jika pembeli data ingin mengakses data yang ditautkan dalam token data, mereka harus mengirim token data ke penyedia data terlebih dahulu. Akibatnya, penyedia data akan memiliki token $OCEAN dan token data sementara pembeli data akan dikirimi data yang ditautkan oleh token data.



Image retrieved from DeBio Whitepaper

Sebaliknya, token data ($GENE atau $MED atau $EMR) yang diterima oleh DAOGenics Foundation akan diubah menjadi token $OCEAN. Setelah jangka waktu tertentu, token $OCEAN yang diterima oleh DAOGenics Foundation akan diubah menjadi token $DBIO melalui non-permission smart contract.

Hasilnya, DAOGenics Foundation akan selalu membeli kembali token $DBIO melalui non-permission smart contract berdasarkan volume transaksi yang dilakukan di pasar data. Lebih banyak transaksi di pasar data akan meningkatkan permintaan token $DBIO.




	

	
	
		
			
				Kapan kita dapat melakukan stake data di marketplace data Debio Network, lalu apa yang akan didapatkan?
			
		

		
					

		
			
			
			
			Mainnet Coin ($DAI)
		
			
			Governance token ($GBIO)
		
			
			Hadiah transaksi token ($DBIO)
		
			
			Ocean token ($OCEAN) 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kesimpulan
Ada banyak manfaat dari melakukan tes genetik. Untuk pertama kalinya dalam sejarah umat manusia, manusia dapat menentukan gaya hidup mereka sendiri untuk mengejar umur yang panjang dan keuntungan dari pengetahuan seperti itu tentu sangat mencengangkan. Tetapi sementara pengujian genetik memiliki manfaat yang luar biasa tanpa peraturan dan standar yang tepat, ia juga dapat memiliki kekurangan. Tanpa jaminan kerahasiaan dan keamanan pada data genetik milik, hal itu dapat menyebabkan masalah di masa depan.

DeBio bertujuan untuk menyelesaikan masalah itu sebelum terlambat. DeBio sedang membangun platform terdesentralisasi untuk kebutuhan medis pribadi milik anda, dimulai dengan genetika. Konsep kami memungkinkan sinergi antar lab dari semua skala sekaligus menjamin anonimitas dan kendali penuh pengguna di setiap langkah alur kerja ilmu data genom mulai  dari pengumpulan sampel, penyimpanan data, hingga pembuatan laporan.

Beberapa orang mungkin mengatakan bahwa DNA miliknya merupakan hal paling pribadi yang dimiliki, dan kami menanggapinya dengan sangat serius. Pengujian genetik yang mengutamakan anonimitas harus menjadi fokus nomor satu untuk semua perusahaan.

Masa depan ada di sini, DeBio menciptakan solusi untuk merevolusi industri perawatan kesehatan dan pengujian genetik. Apakah Anda siap untuk mengubah dunia bersama kami?

Diadaptasi dan disadur dari artikel asli di Medium.

 

### Apa Hal yang Bisa Dilakukan Di NEAR Protocol

Di dunia crypto, Ethereum mendominasi sebagai platform utama ketika kita berbicara tentang smart contract, aplikasi terdesentralisasi (dApps), dan Keuangan Terdesentralisasi (DeFi). Namun, Ethereum bukan satu-satunya protokol dalam urusan smart contract dan hal terkait dApps, ada beberapa protokol lain yang telah tersedia. Meskipun Ethereum merupakan platform nomor satu di dunia, ia memiliki beberapa kekurangan, salah satu yang cukup fenomenal adalah biaya gas (gas fee) yang sangat tinggi dan masalah skalabilitas yang signifikan.

NEAR Protocol adalah salah satu blockchain yang dapat menyaingi Ethereum dengan secara langsung mengatasi kekurangan yang paling mencolok dari protokol tersebut, kurangnya skalabilitas, dengan menggunakan sesuatu yang dikenal sebagai mekanisme sharding. Ini memungkinkan NEAR untuk meningkatkan skalabilitasnya secara eksponensial. NEAR Protocol juga telah mengumpulkan dana yang signifikan dan mendapatkan dana Andreessen Horowitz a16z sebagai salah satu pendukung dibaliknya.
Melihat Lebih Dekat tentang NEAR Protocol
NEAR Protocol adalah platform pengembangan terdesentralisasi yang didirikan pada tahun 2018. NEAR menciptakan lingkungan yang sempurna untuk aplikasi terdesentralisasi dan smart contract dengan berfokus pada kekurangan protokol lain di ruang yang sama dimana seperti yang telah disebutkan kekurangannya sebelumnya. NEAR menggunakan protokol NEAR, blockchain Proof-of-Stake (PoS) yang familiar oleh publik, ramah kepada pengembang, dan bersifat sharded. Protokol yang digunakan merupakan platform berbiaya rendah dan sangat skalabel yang dapat digunakan pengembang untuk membuat aplikasi terdesentralisasi (dApps). Fitur lain yang dapat digunakan pengembang termasuk aplikasi dompet dan komponen interoperabilitas yang memungkinkan pengembang untuk dengan mudah memanfaatkan ekosistem NEAR dan bisa membuat dan mengembangkan aplikasi.

NEAR memperkenalkan Doomslug, mekanisme pembuatan blok yang diusulkan dan digunakan mulai pada tahun 2019. Ini memungkinkan finalitas yang praktis dimana berarti blok dapat mencapai finalitas dalam hitungan detik. NEAR berfungsi pada teknologi yang sama yang mendukung teknologi seperti Bitcoin dan menggabungkannya dengan fitur seperti sharding basis data. Untuk blockchain lain yang memusatkan pemrosesan, ini akan menjadikannya terbatas pada perangkat keras canggih saja yang harus digunakan. Pendekatan ini hanya memberikan dorongan sementara untuk throughput. Di sisi lain, NEAR menskalakan secara linier dan dapat mendukung bahkan miliaran transaksi dengan cara yang sepenuhnya terdesentralisasi.
Fitur Penting dari NEAR 
NEAR Protocol dikembangkan oleh NEAR Collective. Beberapa fitur yang ada di protokol adalah sebagai berikut :

 	NEAR sebagai protokol mudah digunakan, dan pengembang dapat dengan mudah dan cepat membuat aplikasi di atasnya
 	NEAR memungkinkan skalabilitas yang hampir tak terbatas berkat penggunaan sharding
 	NEAR merupakan protokol Layer-1.

Memahami Apa Itu NEAR Collective 
NEAR Collective merupakan sebuah komunitas peneliti dan pengembang yang berada di balik pengembangan NEAR Protocol. Kolektif ini terus bekerja untuk mengembangkan dan meningkatkan NEAR Protocol dan juga telah mengerjakan proyek-proyek seperti menulis kode awal protokol dan implementasi pada Jaringan NEAR. NEAR Protocol beroperasi sepenuhnya secara independen dan terdesentralisasi, dan bahkan para pengembang dan peneliti yang membangunnya tidak dapat mematikannya.

NEAR Collective terdiri dari NEAR Foundation, yang merupakan organisasi nirlaba yang menciptakan ekosistem di sekitar NEAR Protocol. NEAR Collective membantu dalam pengembangan dan kegiatan tata kelola pada protokol. NEAR Protocol hanyalah salah satu dari beberapa proyek di bawah naungan kolektif.
Apa yang bisa kamu lakukan di NEAR Protocol
NEAR Protocol memungkinkan pengguna untuk mengakses beberapa proyek dan protokol mulai dari NFT hingga DAO dan DeFi. NEAR telah mengembangkan ekosistem asli yang dinamis memiliki beberapa proyek yang sudah hadir dan berjalan pada protokol sedanglan di saat bersamaan juga ada banyak proyek sedang dalam proses. 
Memulai Menggunakan NEAR
Untuk memulai menggunakan NEAR, hal pertama yang perlu anda lakukan adalah membuat akun NEAR. Anda dapat mempelajari cara mengatur akun NEAR di sini. Setelah Anda membuat akun NEAR milikmu, kamu dapat menghubungkannya ke wallet NEAR anda yang memungkinkan kita untuk melakukan panggilan kontrak ke blockchain, mengirim atau menerima dana dan mengatur node lokal. Untuk membuat akun NEAR, Anda harus memiliki setidaknya 0.2 NEAR sehingga anda dapat mengamankan tempat anda di jaringan NEAR.
Token NEAR
Ada dua cara untuk mendapatkan token NEAR, pertama kita bisa mendapatkannya atau langsung membelinya. Token NEAR dapat diperoleh dengan berpartisipasi di jaringan, berpartisipasi dalam pengembangan, atau menjalankan node komunitas yang memungkinkan orang-orang di komunitas untuk membangun di NEAR. Kita juga dapat membeli token NEAR yang tersedia di semua bursa mata uang kripto utama.
Apa yang Dapat Kita Lakukan Dengan NEAR Token?
Token NEAR memungkinkan kita untuk melakukan beberapa aktifitas, diantaranya kita dapat mentransfer token NEAR ke akun lainnya dan melacak transaksi di Block Explorer. Biaya transaksi di NEAR sangat rendah, memungkinkan kita untuk memindahkan token dengan mudah. Kita juga dapat mengirim NEAR ke siapa saja yang mereka juga perlu membuat akun NEAR menggunakan NEAR Drops. Token NEAR juga memungkinkan kita untuk mengakses semakin banyak aplikasi yang telah didevelop di jaringan NEAR. Mereka juga dapat membeli, menerbitkan, atau memperdagangkan NFT dan karya seni digital di NEAR atau membuat kreasi seni kolektif.
Staking 
Komunitas NEAR dapat mendukung validator melalui Staking. Validator adalah pengguna yang mengoperasikan node yang membantu menjalankan jaringan NEAR. Validator diharuskan untuk mempertahankan jumlah minimum yang distaking sehingga mereka dapat tetap berstatus sebagai validator. Pemegang token di NEAR dapat melakukan staking dengan validator pilihan mereka dan mendapatkan hadiah dari token yang dihasilkan oleh jaringan. Pengguna dapat melakukan staking menggunakan langkah-langkah berikut:

 	Pilih Staking dari tab navigasi, dan pilih validator
 	Konfirmasikan opsi yang telah anda pilih, lalu pilih “Stake with Validator”
 	Pilih jumlah token NEAR yang ingin anda staking dan klik “Kirim.”

Apa yang Dapat Kita Lakukan Di Ekosistem NEAR?
NFT
NFT sendiri telah mendapatkan banyak atensi dari masyarakat luas. Ketika Ethereum menjadi pemain utama dalam hal NFT, pergerakan mereka ke pengguna luas menjadikan fokus perhatian menjadi tertuju ke gas fee Ethereum yang tinggi sehingga membuatnya menjadi sangat tidak praktis. NEAR Protocol merupakan alternatif yang layak dan telah memiliki beberapa proyek yang sudah berjalan di atas platformnya. Skalabilitas dari protokol memastikan bahwa pengembangan dApps dilakukan dengan begitu cepat dan mudah. Saat ini, ada sekitar 19 platform terdesentralisasi untuk NFT di platform NEAR. NEAR juga secara signifikan lebih cepat daripada pemain lain di dunia NFT dan memiliki biaya transaksi yang sangat rendah.

NEAR Protocol dapat digambarkan sebagai platform yang sempurna untuk NFT dan memiliki beberapa keunggulan dibandingkan platform NFT lainnya diluaran sana dan bahkan Ethereum. NEAR Protocol dapat memproses transaksi menjadi jauh lebih cepat daripada Ethereum, dan tidak seperti Ethereum, protokol ini tidak membebani biaya gas yang tinggi atau jaringan yang lamban. Transaksi di NEAR diproses dengan seketika bahkan hampir seperti tidak dikenakan biaya sama sekali. Semua faktor ini menjadikan NEAR ideal untuk melakukan jual beli NFT dan bisa menjadi insentif bagi berbagai proyek untuk membangun NFT mereka di NEAR. Ada beberapa proyek NFT yang sudah berjalan di NEAR, seperti Mintbase dan Paras.
Ciptakan Dan Jual NFT melalui Mintbase
Pengguna NEAR Protocol dapat menggunakan beberapa proyek NFT untuk membeli, menjual, atau membuat NFT. Salah satu proyek tersebut, Mintbase yang memungkinkan pengguna untuk membuat NFT dan membuatnya tersedia untuk dijual di pasar seperti OpenSea. Pengguna dapat membuat smart contract untuk membatasi transferabilitas token, yang membantu mencegah penipuan dan transfer aset secara ilegal.

Mintbase beralih dari blockchain Ethereum ke protokol NEAR diakibatkan biaya gas yang tinggi. Awalnya, biaya gas di Ethereum rendah sehingga pengguna dapat mengadopsi dengan luas, namun dengan meningkatnya penggunaan dan kemacetan lalu lintas transaksi di Ethereum, biaya gas mulai menjadi tidak terkendali. Ada beberapa alasan lain mengapa Mintbase memilih NEAR Protocol yaitu:

 	NEAR menggunakan Rust atau AssemblyScript untuk mengkode smart contract, memungkinkan pengembang untuk menulis kode dengan mudah.
 	NEAR memiliki alamat yang dapat dibaca manusia untuk akun dan smart contract.
 	Pengembang dapat menggunakan NEAR drops dan pengguna dapat di-onboard dengan mudah dan cepat. Mereka juga dapat membayar menggunakan akun NEAR mereka dan mengirim atau menerima token NEAR.
 	Pengembang dapat menggunakan rainbow bridge ETH-NEAR dan memindahkan aset mereka dengan cepat.
 	Proyek DeFi seperti Balancer dan Aave juga ada di NEAR, membuat potensi integrasi di masa depan menjadi mudah.

Menmbuat, Memperdagangkan, dan Mengoleksi Kartu Seni Digital
Paras adalah marketplace kartu digital yang dibangun di atas protokol NEAR yang memberikan solusi kepada pengguna untuk kolektor kartu tradisional. Ini memvalidasi kepemilikan melalui blockchain melalui transaksi yang cepat dan murah. Ini juga membedakan dirinya dengan menawarkan sekumpulan koleksi alih-alih rilis mandiri satu persatu. Paras bermanfaat bagi kolektor karena secara signifikan mengurangi beban kolektor dengan memastikan bahwa koleksi mereka tidak aus dan lekang oleh waktu. Baik seniman maupun kolektor dapat dengan mudah mengakses pasar barang koleksi.

Sejak peluncuran Paras, kami telah melihat artis menghasilkan lebih dari $25.000, dengan platform yang mampu memproses 700+ transaksi yang memungkinkannya memfasilitasi volume perdagangan lebih dari $35.000. Saat ini, platform tersebut memiliki lebih dari 70 artist dan 80 kolektor. Protokol NEAR dan Paras sangat cocok karena pembuat NFT mencari alternatif untuk Ethereum yang memiliki biaya gas yang tinggi. Transaksi di NEAR hampir tidak memerlukan biaya apa pun dan dapat diselesaikan dalam hitungan detik, sedangkan Rainbow Bridge memastikan interoperabilitas antara Ethereum dan NEAR.
Jelajahi Dan Lelang Koleksi NFT
Hip-Hop Heads merupakan hasil kolaborasi antara NEAR Protocol, Ed Young, dan Universal Hip-Hop Museum. Koleksi NFT menampilkan seniman dari tahun tujuh puluhan hingga saat ini dan menampilkan 47 seniman terbesar dari genre rap. Koleksi ini menghormati para seniman dan juga menandai tahun ke-47 era Hip-Hop.

NEAR memungkinkan koleksi untuk lebih mudah diakses oleh masyarakat, dan fitur lelang menampilkan edisi baru dari semua 103 Hip-Hop Heads. Anggota komunitas dapat dengan mudah membeli NFT melalui kartu kredit tanpa sistem orientasi yang rumit.

Pengguna protokol dapat mengakses beberapa proyek NFT lain di NEAR, seperti Metamon, WebAssembly Music, Snark.Art, dll. Metamon menciptakan dunia monster yang dapat ditangkap, dikembangkan, dan dimainkan oleh pengguna. Monster diklasifikasikan sebagai makhluk edisi terbatas yang terancam punah yang dapat diadopsi oleh sekelompok kolektor NFT tertentu. Kolektor dapat menggabungkan dua jenis Metamon yang sama dan melihatnya berkembang menjadi Metamon yang lebih langka dan lebih kuat.

WebAssembly Music merupakan musik pertama yang disimpan di blockchain sebagai NFT. Musiknya dibuat oleh Peter Salomonsen dan dipublikasikan di NEAR Protocol. Karya musik tersebut adalah salah satu karya musik pertama yang dirender ke biner WebAssembly yang dapat dieksekusi. Pengguna dapat mengeksekusi file biner WASM dan mendapatkan data audio mentah melalui runtime WebAssembly.




	

	
	
		
			
				Near menggunakan kode smart contract berikut ini:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust atau AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi pada NEAR
Pertama-tama mari kita memahami DeFi terlebih dahulu. DeFi (Decentralized Finance) atau keuangan terdesentralisasi merupakan sistem keuangan terdesentralisasi yang menggunakan jaringan blockchain seperti Ethereum. Ini terdiri dari aset seperti aplikasi terdesentralisasi, protokol DeFi dan smart contract. Tujuan di balik DeFi adalah untuk menciptakan sistem keuangan yang bersifat open-source, tanpa memerlukan izin dari pihak manapun (permissionless), dan terdesentralisasi yang beroperasi secara independen dari yurisdiksi pihak ketiga atau otoritas pemerintahan pusat. DeFi memberi pengguna akses mudah ke layanan keuangan dan sangat bermanfaat bagi individu yang tidak memiliki akses ke layanan perbankan.

NEAR menghadirkan DeFi kepada masyarakat luas dengan beberapa proyek yang sudah hadir di protokol, mulai dari beberapa proyek DeFi seperti DEX, Oracle, dll. Mari kita lihat bagaimana kita dapat menggunakan beberapa proyek yang telah ada di NEAR.
Akses Hampir Semua Chain yang Kompatibel Dengan Rainbow Bridge
Rainbow Bridge bertindak sebagai jembatan antara NEAR dan Ethereum dan merupakan protokol trustless dan permissionless yang menghubungkan dua blockchain yang berbeda. Pengguna dapat dengan mudah menggunakan bridge baru atau bergabung dengan bridge yang ada tanpa perlu persetujuan dari pihak ketiga. Rainbow Bridge memungkinkan informasi apa pun yang dapat digunakan di NEAR untuk digunakan dalam smart contract Ethereum dan sebaliknya. Ini juga memungkinkan pengguna untuk memilih dengan ETH pada DAO berdasarkan NEAR tanpa melalui Ethereum.

Rainbow Bridge mudah diakses oleh pengguna, berkat desain yang intuitif, dan terpasang langsung melalui MetaMask. Rainbow Bridge juga dapat digunakan kembali dan terhubung NEAR dengan hampir semua rantai yang kompatibel dengan Ethereum. Rainbow Bridge juga ingin mendukung rantai non-EVM seperti Bitcoin.
SputnikDAO 
DAO sangat penting ketika kita berbicara mengenai strategi tata kelola protokol. SputnikDAO memberdayakan komunitas dan individu yang membentuk ekosistem NEAR, bertindak sebagai infrastruktur untuk DAO pada protokol NEAR dan memungkinkan individu dan proyek lain untuk meluncurkan DAO, meningkatkan smart contract protokol, dan mengkonfigurasi tata kelola untuk manajemen perbendaharaan dengan mudah. SputnikDAO juga memungkinkan proyek untuk diatur tata kelolanya secara multi-signature ataupun mengeluarkan token tata kelola atau menggabungkan keduanya dan menggunakannya secara bersama-sama.
Rilis Dan Mint Audio NFT Dengan DAOrecords
DAOrecords berencana untuk menjadi label Rekaman terdesentralisasi pertama di dunia dan saat ini menggunakan model hibrida. Proyek ini terus bereksperimen dengan Audio NFT, dengan proyek yang telah merilis sekitar 350 NFT dan bekerja dengan lebih dari 60 seniman sejauh ini. DAOrecords ingin mengontrol musik sepenuhnya kembali ke artis yang membuatnya dan mengubah cara mereka berinteraksi dengan penggemar mereka.

Seniman independen dapat merilis musik baru menggunakan NFT audio dan layanan streaming DAOrecord. Mereka juga dapat melakukan minting NFT audio mereka. DAOrecords telah menerbitkan NFT audio interaktif yang disebut "MintTape Vol 1."
Akses Pinjaman Melalui Aave
Aave menerapkan strategi pinjaman berbasis pool alih-alih menggunakan strategi peer-to-peer yang terdesentralisasi. Pinjaman di Aave tidak dicocokkan berdasarkan antar individu. Sebaliknya, mereka mengandalkan dana yang dikumpulkan dan pada agunan bersama dengan jumlah yang dipinjam. Aave diluncurkan pada November 2017 sebagai platform pinjaman peer-to-peer dan berganti nama menjadi Aave pada September 2018. Protokol diluncurkan di Mainnet, dan memiliki hampir $6 Miliar dana yang terkunci dalam smart contract, dan berada di 3 proyek teratas di DeFi dunia saat ini.

Aave menawarkan pinjaman kilat, yang pada dasarnya adalah pinjaman tanpa agunan yang dipinjam dan dilunasi dalam satu transaksi, yang berarti bahwa pengguna tidak memerlukan jaminan apa pun untuk pinjaman, sementara peminjam mengembalikan jumlah asli yang dipinjam dan sedikit biaya transaksi. Aave memperkenalkan pinjaman kilat, di mana siapa pun dapat meminjam likuiditas, menggunakannya dengan protokol lain, dan membayarnya kembali dalam satu transaksi. Pinjaman kilat sangat penting dalam ruang
Akses Umpan Data Dengan Chainlink
Chainlink dikembangkan sebagai jaringan oracle terdesentralisasi yang memungkinkan smart contract untuk mentransfer data antara blockchain dan sistem off-chain dengan andal dan aman. Ini menggunakan jaringan terdesentralisasi dari oracle independen untuk mengambil data dari berbagai sumber daya yang berbeda, menggabungkan data, dan kemudian mengirimkan data yang divalidasi ke smart contract, yang memicu eksekusi smart contract.

Protokol Chainlink juga menyediakan keamanan multi-layer untuk memastikan kepercayaan penuh pada jaringan oracle. Ini memungkinkan untuk membangun dan menjalankan jaringan oracle, memungkinkan pengguna untuk terhubung ke jaringan oracle yang disesuaikan tanpa harus bergantung pada jaringan oracle lain.

 	Signing Data – Data masukan oracle Chainlink ditandatangani menggunakan tanda tangan kartografi unik yang memungkinkan pengguna untuk membuktikan bahwa data berasal dari simpul oracle tertentu.
 	Data Berkualitas Tinggi – Chainlink akan menyediakan smart contract dengan data yang bersumber dari sumber eksternal seperti penyedia data eksternal.
 	Blockchain Agnostic – Chainlink dapat berjalan secara native di blockchain apa pun, mendukung blockchain publik, blockchain perusahaan, dll.




	

	
	
		
			
				DAOrecords membuat kita bisa melakukan minting:
			
		

		
					

		
			
			
			
			Karya digital
		
			
			Kartu Digital
		
			
			Audio NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora – Pengalaman Ethereum Layer-2
Aurora di NEAR Protocol memberikan pengalaman Ethereum Layer-2. Pengembang dapat menggunakan ini untuk menjangkau pasar tambahan sambil memanfaatkan fitur Protokol NEAR seperti remunerasi biaya gas dan sharding. Ini berjalan pada dua komponen penting, Aurora Bridge dan Aurora Engine. Berikut beberapa fitur yang dibawa Aurora:

 

 	Kemampuan untuk memproses ribuan transaksi per detik, peningkatan 50x dari Ethereum.
 	Waktu finalitas blok 2 detik, dibandingkan dengan waktu konfirmasi blok tunggal 13 detik di Ethereum.
 	Memungkinkan EVM untuk menskalakan secara horizontal dengan pendekatan sharding NEAR.
 	Biaya di Aurora 1000x kali lebih rendah daripada di Ethereum.
 	Aurora menawarkan kompatibilitas tanpa kompromi dengan Ethereum melalui Protokol NEAR.

PENUTUP
NEAR menciptakan ekosistem dimana pengguna dapat dengan mudah mengakses dApps, NFT, dan DeFi. Protokolnya lebih cepat dan lebih murah daripada pemain lain di dunia crypto. NEAR menawarkan solusi untuk masalah seperti kecepatan pemrosesan yang lambat, kemacetan jaringan, dan biaya gas yang tinggi dengan memanfaatkan sharding, memberikan platform sejumlah besar skalabilitas tanpa mengorbankan keamanan protokol.




	

	
	
		
			
				Protokol dibawah ini memberikan pengguna NEAR untuk mengakses Ethereum di layer-2, yaitu
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			 Aurora
		
	
		

		
		
			
				Correct!
				Wrong!

### DeFi di NEAR Protocol

NEAR Protocol merupakan platform smart contract yang berfokus pada pengembang dan keramahan pada pengguna. NEAR menyediakan platform yang dapat diskalakan untuk menjalankan aplikasi. NEAR didirikan pada musim panas di tahun 2018 oleh Alex Skidanov dan Illia Polosukhin. Pada artikel ini, kita akan melihat beberapa aplikasi DeFi pada Protokol NEAR.
Kebangkitan DeFi
DeFi atau Keuangan Terdesentralisasi adalah instrumen keuangan berbasis blockchain. Sementara instrumen keuangan terpusat terhambat oleh kurangnya interoperabilitas dan birokrasi, aplikasi DeFi mirip seperti blok Lego yang dapat digabungkan oleh pengguna untuk membuat instrumen baru. Akibatnya, ekosistem DeFi telah melesat dari $7,40 miliar pada 22 Juni 2020 menjadi $250 miliar pada 1 Desember 2021. Nilai ini meningkat sebanyak 3278% dalam waktu kurang dari satu tahun.



 

Saat ini, total dana tekunci di DeFi telah mencapai sekitar 209,42 Milyar USD.
Signifikansi Sebenarnya dari DeFi
Ketika kita berbicara tentang nilai total yang dikunci saja, ini tidaklah cukup untuk memahami arti sebenarnya dari DeFi. Ini merupakan elemen penting dalam membangun Open Web dan bertanggung jawab sendiri atas masuknya kemampuan yang telah dimiliki oleh Ethereum selama dua tahun terakhir. Jika kita memikirkannya, ini akan sangat masuk akal karena sifat DeFi yang revolusioner dan dapat dikomposisi. Kegiatan yang bisa memakan waktu berminggu-minggu di dunia keuangan tradisional sekarang hanya membutuhkan beberapa detik saja.

Namun, ada sisi lain dari penyataan ini juga. Karena lonjakan permintaan, DeFi telah menyebabkan tumpukan dan kemacetan jaringan dan kenaikan harga gas fee. Dengan demikian, hambatan masuk untuk pengguna Ethereum akan menjadi jauh lebih tinggi, khususnya bagi creator dan developer pemula.

NEAR Protocol telah menyediakan alternatif dari Ethereum yang layak, lebih cepat, dan lebih murah.
DeFi di NEAR Protocol


Sekarang kita akan melihat beberapa proyek DeFi yang paling menjanjikan di NEAR
Rainbow Bridge


Rainbow Bridge hadir sebagai perantara NEAR dan Ethereum. Semua aset yang berasal dari Ethereum sekarang sepenuhnya dapat digunakan di NEAR. Sejak diluncurkan, lebih dari 1 juta USD senilai ETH, DAI, dan token lainnya telah melewati Bridge. Infrastruktur Bridge dapat dengan mudah digunakan kembali dan memastikan koneksi antara NEAR dan semua chain yang kompatibel dengan EVM, seperti Polygon, BSC, Avalanche, Optimism, Arbitrum, dan lain-lain.. Tim saat ini telah bekerja untuk memperluas infrastruktur ini untuk mendukung chain non-EVM seperti Bitcoin, Kosmos, dll.

Berikut beberapa hal yang perlu kita ketahui tentang Rainbow Bridge:

 	Pengguna dapat diarahkan ke Rainbow Bridge secara langsung melalui MetaMask.
 	Transaksi NEAR dikonfirmasi dalam waktu kurang dari 2 detik dengan biaya <1 sen dalam biaya gas fee.

Berikut adalah ilustrasi transaksi Bridge NEAR<>Ethereum:

 	Aset dari Ethereum ke NEAR membutuhkan waktu sekitar 6 menit (sekitar 20 blok).
 	Biaya transaksi ERC20 rata-rata sekitar $10.
 	Mengirim aset dari NEAR kembali ke Ethereum membutuhkan waktu maksimum 16 jam (karena waktu finalitas Ethereum). Proses ini juga memakan biaya sekitar $60 karena biaya gas ETH.
 	Rainbow Bridge adalah inovasi penting karena merupakan langkah pertama yang penting dalam peta jalan interoperabilitas NEAR. Selain itu, karena NEAR menawarkan transaksi yang lebih cepat dan lebih murah, mungkin lebih menguntungkan bagi pengguna rantai lain untuk berinteraksi dengan aset Ethereum di NEAR daripada menjembatani langsung ke Ethereum.

Ref Finance


Ref Finance adalah platform DeFi pertama yang ada di NEAR. Versi pertama Ref memiliki beberapa kesamaan dengan Uniswap V2, bersama dengan dukungan untuk lebih banyak jenis pool, biaya yang dapat dikonfigurasi, dan sepenuhnya dimiliki oleh komunitas. Tujuan utamanya adalah untuk menyatukan komponen inti dari DeFi seperti pertukaran terdesentralisasi (DEX), protokol pinjaman, penerbit aset sintetis, dan lain sebagainya.

Ref Finance memiliki treasury sebanyak 35 juta $REF di mana 10% dialokasikan untuk dana pengembangan untuk proyek di masa mendatang dan 25% sisanya untuk kegiatan, acara, dan kemitraan terkait komunitas di masa depan.

Fitur dari Ref Finance

 	AMM DEX Ref memungkinkan perdagangan yang bersifat permissionless dan otomatis antara token NEAR atau bridge asli mana pun.
 	Penyedia likuiditas dapat memperoleh token $REF atau NEP-141 dengan melakukan staking token LP.
 	Pengguna dapat melakukan staking token $REF untuk mendapatkan lebih banyak $REF dari waktu ke waktu.

Ref adalah proyek komunitas dan dikelola oleh DAO. Ref DAO memiliki dua peran yakni Council dan Community Board.

 	Council : Council atau Dewan membuat proposal dan memberikan suara pada mereka. Sebuah proposal lolos hanya jika mayoritas Council menyetujuinya. Council akan diubah setelah DAO aktif sepenuhnya.
 	Community Board: Community Board  juga memberikan suara atau menolak proposal. Sebagian besar, Council akan tunduk pada keputusan Community Board.

Burrow


Burrow adalah platform non-kustodian, terdesentralisasi dan suku bunga berbasis pool. Ini memungkinkan pengguna untuk menyuplai aset, mendapatkan bunga, dan kemudian meminjamkannya untuk membuka likuiditas. Burrow sangat mirip dengan protokol berbasis pool lainnya seperti Aave dan Compound dan berjalan secara native di blockchain NEAR, dengan smart contract protokol yang ditulis dalam Rust. Protokol membuka likuiditas untuk aset berbunga, terutama turunan staking layer-1 seperti stNEAR (staking NEAR) dan stETH (staking ETH). Misalnya, pengguna Burrow dapat menyetor stNEAR sebagai jaminan dan kemudian meminjam NEAR, menciptakan posisi stake dengan leverage. Mereka juga dapat memposisikan diri untuk bisa melakukan pembayaran sendiri dengan meminjam stablecoin.

Ekosistem Burrow didukung oleh token BRRR, token tata kelola asli protokol. Sebagian besar pasokan token akan didistribusikan di antara anggota komunitas aktif dan pengguna Burrow. Token BRRR memiliki total pasokan 1.000.000.000 BRRR, dengan 50% dialokasikan untuk komunitas, 20% untuk DAO Treasury, 20% untuk tim inti, dan 10% sisanya untuk investor strategis dalam proyek.
Pasar Suku Bunga NEAR-native
Burrow membedakan dirinya dari platform lain yang menyuplai aset ke platform dengan memungkinkan pengguna memanfaatkan aset berbunga, yang merupakan inti dari proposisi nilai proyek. Aset berbunga staking derivatif dari aset sepadan yang disimpan dalam dana investasi. Dalam kripto, aset berbunga adalah turunan yang distaking seperti stNEAR, stETH, dan lain-lain. Burrow menggunakan aset berbunga dari lapisan dasar, memberikan hasil dari lapisan dasar. Staking langsung di lapisan dasar memberikan keamanan ekstra dari chain utama sementara juga memiliki pengembalian tertinggi dan tingkat yang paling bebas risiko.

Burrow juga memungkinkan pinjaman yang dapat dibayar sendiri secara mandiri. Pinjaman yang membayar sendiri itu unik karena mereka membayar sendiri dengan hasil yang dihasilkan dari aset berbunga. Saat pengguna memasok aset ke Burrow, mereka dapat mengunci beberapa aset mereka sebagai jaminan, dan pengguna dapat meminjam dari platform dengan aset berbunga yang bertindak sebagai jaminan. Bergantung pada aset yang disediakan dan bunga yang dihasilkan, pinjaman dapat dilunasi dari bunga yang dihasilkan dari aset berbunga.

Burrow memanfaatkan Aurora Rainbow Bridge untuk menawarkan interoperabilitas yang aman dengan rantai Layer-1 lainnya. Pengguna kemudian dapat mengakses aset mereka di chain interoperable lainnya tanpa kerumitan, dan menyuplainya ke Burrow, membuka kunci hasil atau sebagai jaminan untuk pinjaman. Saat ini, Burrow mendukung enam aset untuk pasokan dan pinjaman; ini adalah DAI, USDT, USDC, NEAR (wrapped), ETH (wrapped), stNEAR, dan stSOL. Protokol ini juga berencana untuk menambahkan bLUNA segera.

Dengan membangun di atas NEAR, Burrow mungkin dapat memanfaatkan teknologi Layer-1 paling canggih yang hanya ditemukan di NEAR, Rainbow Bridge dan Nightshade. Berkat Proof-of-Stake dan sharding di Nightshade, NEAR telah mampu memecahkan masalah skalabilitas yang telah mengganggu chain Layer-1. Ini memungkinkan Burrow untuk beroperasi dengan:

 	Latensi yang Rendah
 	Chain yang sepenuhnya terdesentralisasi
 	Chain yang dapat diskalakan tanpa batas
 	Biaya pengguna yang rendah

Aurora


Aurora di NEAR memungkinkan eksekusi kontrak Ethereum di lingkungan yang lebih berkinerja dan menunjang. Proyek ini dapat dibagi menjadi dua komponen utama: Aurora Engine, Ethereum Virtual Machine (EVM), dan Aurora Bridge, yang menyediakan transfer token ERC-20 secara trustless antara Aurora dan Ethereum. Ethereum Virtual Machine (EVM) dibangun di NEAR dan memungkinkan pengembang untuk mendistribusikan aplikasi mereka pada platform yang kompatibel dengan Ethereum, dengan throughput tinggi, skalabel, dan aman di masa depan yang juga menyajikan biaya transaksi rendah. Proyek ini mendapat dukungan signifikan dari beberapa VC teratas, termasuk Electric Capital, Dragonfly Capital, Pantera Capital, Three Arrow capital, dan Alameda Research.

Berkat Aurora, pengembang dapat menikmati tools Ethereum yang familiar saat bekerja dengan smart contract Solidity di Aurora. Aurora juga menggunakan ETH sebagai biaya dasarnya, memungkinkan pengembang untuk merasakan pengalaman yang lancar bagi pengguna dApp. Digabungkan dengan fitur unik dari NEAR Protocol, Aurora mampu mencapai tingkat skala dan kecepatan transaksi yang belum pernah terjadi sebelumnya di lingkungan yang kompatibel dengan Ethereum. Aurora 100% kompatibel dengan blockchain Ethereum dan menawarkan waktu blok 1 detik dan konfirmasi transaksi dalam 2 detik.
Peningkatan Kunci
Aurora memberi pengembang sejumlah peningkatan. Mari kita selidiki lebih dalam terkait ini.

 	Aurora menawarkan biaya hingga 1000x lebih rendah dari biaya Ethereum. Mentransfer token ERC-20 lebih rendah dari $0,01, sedangkan di Ethereum, biayanya sekitar $5,40.
 	Aurora dapat dengan mudah menampung ribuan transaksi per detik. Ini adalah peningkatan 50x dibandingkan dengan Ethereum.
 	Aurora menawarkan pertumbuhan masa depan untuk ekosistem, dengan sharding NEAR Protocol yang menawarkan penskalaan EVM horizontal dan komunikasi asinkron antara shard Aurora yang berbeda.
 	Token asli platform, $AURORA, memiliki persediaan tetap sebesar 1 miliar. Token memiliki beberapa kasus penggunaan seperti staking, voting, biaya finalisasi transfer Rainbow Bridge, biaya eksekusi kontrak Aurora, dan banyak lagi.

Bastion Protocol


Bastion Protocol adalah protokol peminjam dan pemberi pinjaman yang algoritmik dan bersifat terdesentralisasi. Proyek ini dibangun di atas lapisan Aurora, yaitu NEAR EVM-Compatible dan Gas-less. Bastion berfokus pada tokennomics, composability, UX, dan optimisasi risiko algoritmik. Berkat NEAR, proyek ini mampu mencapai efisiensi modal, kecepatan transaksi tinggi, biaya transaksi rendah, dan likuidasi yang sangat tepat.

Berkat proyek seperti Aave dan Compound, pasar uang telah menjadi DeFi primitif terbesar di Ethereum. Ada juga keberhasilan gemilang dari protokol peminjaman chain-native seperti Solend di Solana dan Benqi di Avalanche. Bastion telah menghadirkan DeFi berikutnya ke dalam NEAR, dimana ini memungkinkan pengguna untuk meningkatkan produktivitas aset mereka melalui pinjaman atau leverage tanpa meminjam.

Bastion memberi pengguna kemampuan untuk:

 	Menaruh aset sebagai jaminan
 	Suplai aset dan pendapatan dari bunga
 	Leverage Long
 	Short aset
 	Meminjam aset

Token asli protokol adalah token BSTN, dan memiliki dua kasus penggunaan utama. Token berada di pusat pengembangan Bastion Protocol. Ini memungkinkan pemegang token untuk memilih metrik proyek utama seperti likuiditas yang dimiliki protokol, model biaya, pengukur, dan staking. Ini juga merupakan kunci dalam menyelaraskan insentif antara berbagai pemangku kepentingan di Bastion.

Membangun ini di Aurora telah memungkinkan Bastion untuk menciptakan mesin suku bunga otonom yang menawarkan efisiensi modal yang jauh lebih besar, transaksi cepat yang dikombinasikan dengan kecepatan transaksi yang sangat rendah, dan likuidasi yang tepat.
OIN Finance


OIN adalah platform penerbitan stablecoin terdesentralisasi yang memungkinkan proyek untuk menerbitkan stablecoin bermerek milik mereka sendiri. Alih-alih harus memasukkan agunan mereka ke dalam daftar putih di platform lain, OIN akan meluncurkan stablecoin yang dijamin NEAR untuk membuka likuiditas tanpa menjual token NEAR mereka. Contoh kasus penggunaan OIN adalah dengan menukar stablecoin utama lainnya (swap), menambahkan leverage, melindungi nilai, pinjaman, dan sejumlah besar utilitas khusus ekosistem.

Saat ini, lini produk utama OIN adalah OINDAO. Ini memungkinkan proyek yang bergabung untuk membuat kumpulan kolateral mereka sendiri untuk mencetak stablecoin berlabel merek mereka sendiri. OIN menetapkan proses validasi cepat untuk setiap transaksi yang dimulai di blockchain melalui sistem bukti Merkle (Merkle proof system). Mereka melakukannya dengan meletakkan potongan kecil informasi yang mengarah ke "transaksi root" pada ledger dan menggunakannya untuk memvalidasi database informasi ledger yang lebih besar.

Beberapa fitur menarik dari OIN adalah sebagai berikut:

 	Sangat mudah dan cepat untuk mencetak stablecoin setelah proyek listing memutuskan parameternya.
 	Smart Contract OIN semuanya telah diaudit secara menyeluruh.
 	Dukungan teknis untuk menyiapkan parameter risiko utama untuk smart contract.
 	Dukungan teknis untuk membantu anda menukar stablecoin bermerek milik anda dengan stablecoin utama di Curve dan Balancer untuk membuka kunci likuiditas aset Anda.

Skyward Finance 


Skyward Finance adalah landasan peluncuran tanpa izin dan sumber terbuka yang dapat digunakan proyek untuk meluncurkan token mereka tanpa likuiditas apa pun. Skyward berpotensi menjadi salah satu mekanisme penemuan harga terbaik yang tahan terhadap serangan sybil dan serangan bot. Platform terlihat untuk mengaktifkan penemuan harga dan distribusi token untuk proyek yang dibangun di Protokol NEAR. Ini dilakukan dengan memanfaatkan lelang berbasis waktu streaming yang dapat diakses oleh masyarakat umum secara terdesentralisasi. Lelang ini juga akan tahan terhadap manipulasi harga, front running, dan serangan sybil. Skyward Finance akan menerbitkan token kepada komunitas, memungkinkan mereka menjadi bagian dari platform dan memperoleh pendapatan.
Apa Saja Keunggulan Skyward Finance?
Skyward Finance memiliki beberapa keunggulan, beberapa di antaranya sebagai berikut.

Proyek dapat meluncurkan token mereka tanpa likuiditas.

Mekanisme penemuan harga Skyward Finance tahan terhadap serangan bot dan sybil. Itu juga tidak bisa dimanipulasi.

Proyek dapat mengumpulkan dana dalam token apa pun dan juga dapat meluncurkan beberapa penjualan token yang terdiri dari token yang berbeda.

Karena kekekalan Skyward Finance terhadap segala jenis manipulasi harga, proyek dan pendirinya dapat memaksimalkan modal mereka berdasarkan nilai pasar.

Proyek tidak memerlukan token $SKYWARD untuk berpartisipasi atau membuat penjualan.

Skyward Finance adalah sumber terbuka dan tanpa izin, yang berarti bahwa kontrak pintar di platform sepenuhnya independen.

Karena Skyward Finance berjalan di NEAR, ia dapat memanfaatkan skalabilitas NEAR dan transaksi yang lebih murah.




	

	
	
		
			
				Manakah dari berikut ini yang merupakan platform penerbitan stablecoin?
			
		

		
					

		
			
			
			
			Ref Finance
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool adalah protokol likuiditas staking yang dibangun di atas NEAR Protocol. Individu dapat dengan mudah melakukan staking token NEAR mereka menggunakan Meta Pool dan strategi staking otomatisnya. Sebagai imbalannya, mereka menerima token “Staked NEAR atau stNEAR” yang dapat mereka gunakan di DeFi NEARverse. Token juga dapat ditukar kembali ke token NEAR asli kapan saja.

Meta Pool telah menjadi bagian penting dari ekosistem DeFi NEAR karena memperkenalkan token likuiditas staking pertama NEAR, yaitu stNEAR. Token stNEAR dapat memperoleh hadiah staking dan juga mewakili posisi staking di NEAR. Meta Pool menawarkan kepada pemegang token NEAR platform yang mudah digunakan dan menghasilkan hasil sambil membuat jaringan yang terdesentralisasi. Meta Pool akan berjalan pada DAO di Sputnik V2, platform asli NEAR untuk mengelola Organisasi Otonom Terdesentralisasi (DAO).

Ketika pemegang token melakukan staking Meta Pool, mereka mendapatkan token $META setiap epoch. Setiap epoch adalah 12 jam. Ini diterima di atas hadiah NEAR Protocol, yaitu 10,2% APY.
Cheddar 


Cheddar menciptakan jaringan loyalitas untuk NEAR dan ekosistem aplikasi terdesentralisasinya. Hal ini dicapai melalui pembentukan kemitraan strategis yang secara aktif mempromosikan penggunaan NEAR Protocol ketika memberi reward kepada pengguna. Jaringan loyalitas telah terbukti berhasil memotivasi pengguna untuk melakukan tindakan yang bermanfaat bagi bisnis. Melalui Cheddar, token komunitas dapat di-bootstrap, memungkinkan aplikasi untuk meningkatkan loyalitas pengguna dan menambah aliran pendapatan baru menggunakan mekanisme farming.

Cheddar berbeda dari Yield farm lainnya karena memberikan manfaat jangka panjang bagi HODL-ers melalui powerUP. Ini juga mempromosikan penggunaan lintas aplikasi di seluruh NEARVerse, memungkinkan pengguna untuk melakukan farming Cheddar melalui Yield Farming, Liquidity Pool, atau dApps.
Bagaimana Cheddar Memberikan Manfaat ke Protokol NEAR

 	Konektivitas dApp – Cheddar menciptakan tautan umum antara aplikasi di luar token individual, sehingga menciptakan ekosistem yang setia untuk dApps di NEAR.
 	Keterlibatan pengguna – Cheddar menciptakan keterlibatan pengguna jangka panjang melalui berbagai insentif dan membangun loyalitas melalui kemitraan strategis.
 	Cross-chain hopping – Cheddar menciptakan interkonektivitas lintas-rantai dan membuat pengguna di NEAR aktif dan terlibat, memastikan bahwa Total Locked Value (TVL) dapat dipertahankan.
 	




	

	
	
		
			
				Mana dibawah ini yang memberikan program loyalty di NEAR?
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Berry Club memungkinkan pengguna untuk membuat shared pixel art sambil juga melakukan farming untuk mendapat hadiah token. Berry Club telah dimulai sebagai bukti konsep DeFi tetapi sejak itu berkembang menjadi proyek komunitas yang sangat populer di NEAR Protocol. Berry Club memanfaatkan beberapa fitur NEAR Protocol dengan sangat baik, seperti pembayaran otomatis ke pembuat smart contract, yang tidak ditemukan di blockchain lain.

Berkat desain unik di NEAR, Berry Club dan Berry Farm dapat menguntungkan kedua pengguna, dan pembuat smart contract, yang dibayarkan dalam bentuk hadiah kontrak pintar untuk pemegang token dan pembuatnya. Manfaat tersebut muncul dari peningkatan penggunaan aplikasi (Berry Club). Jenis distribusi hadiah ini tidak mungkin dilakukan pada platform seperti Ethereum, setidaknya tidak dalam implementasinya saat ini. Ini adalah alasan lain mengapa pengguna dan pengembang harus bereksperimen dengan NEAR.




	

	
	
		
			
				Bridge anttara Ethereum dan NEAR disebut dengan :
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
Proximity Lab merupakan sebuah perusahaan penelitian dan pengembangan yang menargetkan DeFi pada ekosistem di NEAR.
Kesimpulan
NEAR Protocol saat ini sudah memiliki ekosistem DeFi yang sangat menarik dan akan terus berkembang. Saat ini, NEAR telah menyediakan alternatif yang kuat dan efisien untuk Ethereum.

### Apa itu DAO? Menelusuri tentang Sputnik DAO

Salah satu hal paling menarik yang telah mendapatkan banyak perhatian saat ini adalah konsep dari DAO (Decentralized Autonomous Organization) atau “Organisasi Otonom Terdesentralisasi.” Idenya adalah untuk menciptakan bisnis berbasis internet yang dimiliki dan dikelola secara kolektif oleh para anggotanya. Tidak ada CEO yang mengendalikan arus bisnis, tidak ada CMO, tidak ada CFO, tidak ada dewan direksi yang terpusat. Alih-alih, logika dan eksekusi bisnis dimasukkan ke dalam smart contract untuk memastikan penerapan yang efisien.

Contoh hipotetis dari DAO:

 	Charity atau Badan Amal: Siapa saja dapat menjadi anggota dan siapa pun dapat berdonasi. Kelompok memutuskan bagaimana membelanjakan atau mengalokasikan dana donasi yang terkumpul.
 	Jaringan Freelance: Jaringan kontraktor yang mengumpulkan dana mereka untuk alat terkait freelance.

Usaha dan hibah: Sebuah hedge fund terdesentralisasi di mana anggota dapat mengumpulkan dana mereka dan memberikan voting pada proposal yang berbeda.
Bagaimana DAO dapat berbeda?
DAO menjalankan aturan tertentu yang dicatat pada smart contract dan disimpan di jaringan blockchain. Smart contract dapat dianggap sebagai perjanjian otomatis antara dua pihak atau lebih. Karena sifat transparan dari blockchain, tidak mungkin untuk mengubah kode yang mengatur smart contract tanpa diketahui oleh seluruh jaringan. Inilah yang membuat DAO lebih fleksibel dan kuat daripada organisasi biasa.

 	DAO merupakan organisasi yang didemokratisasi dimana setiap anggota perlu memberikan suara untuk setiap perubahan yang harus diterapkan. DAO menggunakan tata kelola berbasis komunitas alih-alih yang berbasis eksekutif
 	DAO bersifat global dan sepenuhnya transparan.

Mengapa Organisasi Hirarki Tidak Begitu Baik
Struktur organisasi hierarkis dan vertikal merupakan cara umum untuk mengatur bisnis. Idenya sederhana, yakni setiap orang dalam organisasi (kecuali yang berada di atas) berada di bawah individu atau entitas tunggal lainnya. Dengan demikian, mereka yang memiliki kekuatan paling besar berada di puncak bagan organisasi. Pada saat yang sama, mereka yang memiliki kekuatan paling kecil akan muncul di bagian bawah. Namun, karena strukturnya yang melekat, ia memiliki beberapa kekurangan jika dibandingkan dengan DAO.




DAO
Hierarkis


Struktur
Setara dan demokratis
Hierarkial


Voting
Setiap perubahan apapun pada sistem membutuhkan voting dari para anggota
Walaupun sebuah sistem membutuhkan voting atau tidak, tergantung pada struktur dan aturan dari sistem yang berlaku


Perantara
Suara dihitung dan hasilnya diimplementasikan tanpa perantara yang terpercaya.
Jika pemungutan suara diperbolehkan, hal tersebut harus dihitung oleh perantara.


Otomasi
Isu-isu terkait tata kelola ditangani secara otomatis dengan cara yang terdesentralisasi.
Memerlukan penanganan langsung oleh manusia dan terpusat. Oleh karena itu ini sangat rentan terhadap manipulasi.


Visibilitas
Sepenuhnya bersifat publik dan transparan
Bersifat pribadi dan tidak transparan.



Model Keanggotaan Di DAO
Jadi, bagaimana tepatnya model keanggotaan dari DAO ini bekerja? Ini cukup penting mengingat untuk menjadi anggota adalah kunci model operasional dari DAO.

Saat ini terdapat dua jenis model keanggotaan:

 	Berbasis token (token-based).
 	Berbasis kepemilikan (share-based).

Token-based (Berbasis token)
Sebagian besar protokol memiliki token tata kelola (governance token) yang dapat diperjualbelikan di berbagai bursa baik terpusat maupun terdesentralisasi. Seseorang dapat memperoleh token ini melalui partisipasi dalam algoritma konsensus atau menyediakan likuiditas. Seperti namanya, dengan memiliki token ini akan memberi kita akses ke hak suara dalam protokol. Semakin banyak token yang kita pegang maka akan semakin besar kekuatan voting kita. Contohnya adalah MakerDAO dan token tata kelolanya yakni MKR. Siapa pun dapat berpartisipasi dalam tata kelola MakerDAO dengan membeli token MKR.
Share-based (Berbasis kepemilikan)
Dibandingkan dengan DAO berbasis token, DAO berbasis kepemilikan lebih bersifat permissioned atau butuh pengesahan izin . Calon anggota harus mengajukan proposal untuk bergabung dengan DAO. Proposal tersebut menyertai modal atau biaya yang bisa dalam bentuk token atau beberapa pekerjaan. Bagian atau kepemilikan dari anggota mewakili hak suara langsung mereka. Mereka dapat keluar kapan saja dengan bagian perbendaharaan yang proporsional. MolochDAO adalah protokol yang bertanggung jawab untuk mendanai proyek berbasis Ethereum yang merupakan contoh DAO berbasis kepemilikan. Kita tidak dapat membeli token tata kelola di pasar terbuka untuk mendapatkan akses ke DAO. Untuk bergabung, Kita memerlukan keahlian dan modal yang diperlukan untuk membantu mendukung proyek potensial.
Belajar Dari Kesalahan – Peretasan DAO
Tentu saja sangat penting bagi kita untuk mempelajari tentang peretasan DAO yang membagi Ethereum menjadi Ethereum dan Ethereum Classic. Kembali berkaca pada tahun 2016, Ethereum DAO diciptakan untuk menjadi game-changer dan sepenuhnya mendefinisikan kembali cara kerja dari dana ventura. Idenya adalah agar pemegang token DAO memberikan suara pada berbagai proposal proyek. Jika sebuah proposal mendapat 20% suara dari komunitas, mereka akan mendapatkan dana yang dibutuhkan untuk memulai.

DAO juga memiliki "mekanisme split." Pada dasarnya, jika anggota tidak senang dengan proyek yang masuk daftar putih (whitelist), mereka dapat memisahkan diri dari DAO untuk membuat "DAO anak/ DAO turunan" mereka sendiri. Bagaimanapun juga, DAO sukses besar dan mengumpulkan Ether senilai lebih dari $150 juta dalam penjualan massal. Sebagai perspektif, itu merupakan 14% dari jumlah semua token eter yang diterbitkan hingga saat ini.

Namun, DAO memiliki kelemahan kode yang signifikan. Pada 17 Juni 2016, seorang penyerang mengeksploitasi celah dan kelemahan ini untuk terus masuk kembali ke dalam sistem dan menyedot ETH senilai $50 juta. Sebagian besar komunitas memutuskan untuk memutar kembali insiden ini melalui hard fork. Namun, sebagian masyarakat menentang langkah tersebut. Ini pada akhirnya mengarah pada hard fork yang membagi protokol Ethereum menjadi Ethereum dan Ethereum Classic.
NEAR Protocol dan Sputnik DAO
Pendiri Near Protocol, Illia Polosukhin mengumumkan telah meluncurkan Sputnik DAO dalam artikel ini. Dia menjelaskan DAO sebagai “cara bagi komunitas dan organisasi baik yang baru maupun yang sudah ada di seluruh dunia untuk memiliki perwakilan on-chain dari grup mereka, mengelola aktivitas on-chain,, mengatur pengambilan keputusan, dan yang paling penting, berinteraksi dengan DAO lain. .”

Sputnik mengambil inspirasi berikut untuk membentuk “gelombang pertama” dari eksperimen DAO:

 	Cara komunitas mengontrol tata kelola tidak sebanding dengan jumlah orang yang terlibat. Banyak DAO yang gagal karena berbagai alasan, mulai dari masalah teknis hingga kurangnya minat untuk memberikan suara dari anggota atau kurangnya persatuan maupun faktor pendorong..
 	Tidak mungkin memiliki sistem DAO yang benar-benar menyenangkan, Minat akan luntur seiring waktu, dan pendapat orang tentang sebuah proposal mungkin berubah. Minoritas dalam grup berpotensi akan bercabang atau menyimpang dari grup untuk mengikuti sistem DAO yang baru.
 	Sebuah komunitas atau organisasi membutuhkan kepemimpinan. Komunitas yang ideal harus memiliki anggota yang berdedikasi yang bertanggung jawab untuk koordinasi dan berpotensi memoderasi.
 	Bahkan jika komunitas bersifat permissionless dan menggunakan samaran, harus ada beberapa anggota yang dikenal publik yang akan membuat inti komunitas.
 	Semakin "produk" fokus pada komunitas yang terdesentralisasi, semakin fokus kepemimpinan seharusnya dibutuhkan.
 	Pembobotan berbasis stake secara murni selalu gagal karena sebagian besar pemangku kepentingan tidak mampu atau tidak mau menjadi peserta aktif.

Tampilan Sputnik
Saat kita menuju ke beranda Sputnik, kita akan melihat layar seperti berikut.



Ketika kita menekan tombol “NEAR Forum”, kita akan melihat tampilan kategori topik pembicaraan yang tersusun dan terkategori dengan baik.



Pada homepage, jika kita mengklik “Launch App”, maka kita akan mendapatkan akses ke berbagai DAO yang terdaftar di sputnik.



Kami akan berikan contoh sesuatu yang lebih relevan dengan pembahasan kita. Mari kita periksa semua proposal di Learn NEAR DAO.



Seperti yang kita lihat, terdapat beberapa macam propsosal yang terdaftar disini berikut pembayarannya masing-masing dalam token NEAR. Jika proposal disetujui atau ditolak, itu akan ditandai demikian seperti pada gambar. Misalnya, di ID Proposal 22, seseorang berhasil menerjemahkan beranda dan footer ke Bahasa Vietnam, itulah sebabnya kita dapat melihat angka "1" di sebelah Kolok “Approve” dan tanda "Success".


Bagaimana kita menggunakan Sputnik DAO di LeanNEAR.Club
Berikut adalah dua level DAO yang digunakan:

Mother DAO dan subDAO seperti berikut:

https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near.

Lihatlah Mother DAO sebagai Klien/Pendana, subDAO sebagai Kontraktor dan anggota subDAO sebagai SubKontraktor.

Mari kita lihat cara kerjanya untuk komunitas penerjemah. Sebagai contoh artikel Panduan 3 Proyek NFT Teratas di Protokol NEAR perlu diterjemahkan dalam bahasa Vietnam.

Anggota SubDAO mengajukan proposal untuk diterjemahkan dan ditinjau.



Lalu, salah satu dari mereka mengajukan proposal konsolidasi ke Mother DAO dengan subDAO sebagai penerima dana



Ketika pekerjaan diterima dan panduan yang sudah ditranslate dipublikasi, anggota subDAO membagi dana tersebut berdasarkan proposal yang diajukan di awal sesuai dengan siapa yang berkontribusi masing-masing.
Kesimpulan
Seperti itulah kira-kira gambarannya. DAO sangatlah bersifat disruptif. Bagaimanapun juga, seseorang harus menerapkannya secara baik untuk mendapatkan manfaat dari ini semua. Sepertinya NEAR Protocol telah memecahkan permasalahan melalui Sputnik!

### Apa itu Tokenomics? Sebuah Panduan Ringkas

Salah satu prinsip inti dari jaringan terdesentralisasi adalah mekanisme tokenomics-nya. Untuk membantu memahami lebih lanjut tentang kondisi tokennya, Learn Near Club membantu merilis ruang bereksperimen untuktokenomics langsung di jaringan testnet NEAR yakni LNC|TokenHub. Namun, sebelum kita masuk ke detail lebih lanjut, mari kita ketahui apa yang dimaksud dengan tokennomics.
Apa itu Tokenomics?
Token pada mulanya merupakan istilah lain untuk "cryptocurrency" atau "cryptoasset." Namun pada akhir-akhir ini, kami telah menggunakan istilah “token” untuk menjelaskan aset kripto yang diterbitkan di atas jaringan blockchain. Istilah "tokenomics" adalah gabungan dari kata "token" dan "ekonomi," dan itu adalah istilah yang digunakan untuk menggambarkan seperti yang anda duga yakni ekonomi token.

Saat kita ingin mengukur tokenomics jaringan, kita perlu bertanya pada diri sendiri mengenai pertanyaan-pertanyaan yang ada di bawah ini:

 	Berapa total suplai dari token tersebut dan berapa banyak dari mereka yang memasuki sistem sekaligus?
 	Berapa banyak token yang akan dibuat kedepannya di masa mendatang?
 	Bagaimana mekanisme token akan didistribusikan kepada para pengguna?
 	Apa peran sebenarnya dari token dalam jaringan tersebut?
 	Apakah jaringan memerlukan token untuk berfungsi?

Secara keseluruhan, tujuannya adalah untuk membangun hubungan yang jelas antara platform dan aset.
Elemen yang Didefinisikan Dalam Tokenomics
Tokenomics secara luas dapat dibedakan antara kontrol suplai dan utilitas (kegunaan). Mari kita lihat masing-masing elemen tersebut dibawah ini:
#1 Kontrol Suplai atau Pasokan
Berapa banyak token protokol yang sebenarnya akan beredar luas. Berapa banyak suplai yang akan dikendalikan oleh kontrak dasar? Dalam aspek ini, kita harus memahami beberapa istilah-istilah tertentu.

Premining

Pada dasarnya, berapa banyak token yang sudah beredar di ekosistem pada saat rilis atau peluncuran. Biasanya, token di-mining secara berkala oleh pengguna tertentu yang disebut “penambang” atau “miners”. Namun, protokol tertentu sering kali membuat persentase tertentu dari keseluruhan suplainya yang tersedia selama peluncuran untuk distribusi token dan akses ke likuiditas. Namun, perhatikan bahwa memasukkan token dalam jumlah besar dapat menyebabkan masalah terhadap isu sentralisasi.

Alokasi Token

Bagaimana token dialokasikan ke tim pengembang proyek? Apakah mereka menghitung sejumlah besar token, yang mengarah ke permasalahan sentralisasi? Berapa banyak token yang dialokasikan ke treasury untuk pengembangan protokol di masa depan?

Token Vesting

Sebagian besar proyek menerima dana dari (Venture Capital) VC atau investor lain, yang mendapatkan alokasi token sebagai imbalan atas investasi yang mereka keluarkan. Sayangnya lebih sering terjadi kasus VC cenderung membuang alokasi yang mereka miliki segera untuk mendapatkan keuntungan cepat, yang tentunya akan merusak protokol. Kita dapat mengunci alokasi token tertentu untuk jangka waktu tertentu dengan token vesting untuk mencegah penjualan besar-besaran secara langsung.

Token vesting sangat krusial dalam menginspirasi kepercayaan investor lain karena ini dapat memberitahu pada mereka bahwa tim dan investor serius dengan proyek tersebut dan tidak mencari keuntungan yang cepat. Vesting adalah cara mudah untuk menurunkan manipulasi pasar dan menjamin nilai investasi.

Token Burning

Contoh taktik sederhana lain yang digunakan banyak proyek untuk mengontrol suplai yang beredar adalah pembakaran (burning) token. Idenya sederhana, yakni secara berkala menghapus sejumlah token dari peredaran secara permanen. Sebagian besar proyek melakukan ini dengan mengirimkan token ke dompet mati. Proyek seperti Ethereum dan Binance menggunakan token burning untuk mengontrol suplai token asli mereka.
#2 Token Utility
Apa saja macam-macam kegunaan yang dapat dilakukan oleh token milik kita? Mari kita lihat sekilas beberapa peran yang ada:

 	Token dapat digunakan untuk utilitas murni dan pembayaran di dalam atau di luar lingkungan protokol.
 	Token dapat digunakan untuk staking pada protokol dan berpartisipasi dalam tata kelola token.
 	Memegang token protokol dibutuhkan untuk mengakses berbagai aplikasi (DeFi dan NFT) di dalam sistem.

Bermain Dengan Tokenomics
Tool Tokenomics dari Learn Near memungkinkan kita untuk memetakan berbagai komponen token dan bereksperimen dengannya di jaringan testnet.

Komponen-komponen ini diantaranya adalah:

 	

 	Nama Token
 	Peluncuran awal
 	Simbol
 	Treasury atau pembendaharaan
 	Suplai Awal
 	Waktu Mulai Vesting
 	Durasi Vesting
 	Poin Desimal
 	Interval vesting



Bereksperimen dengan nilai yang berbeda ini akan membantu kita memahami kontrol suplai dari tokenomics protokol milik kita. Apakah kamu ingin bereksperimen dengan tool ini? Kunjungi langsung LNC TokenHub!

### Panduan Pengguna Step by Step Menggunakan Burrow

Panduan pengguna ini dibuat dengan berkolaborasi bersama NEAR Mates dan NEAR Insights. Silakan follow akun mereka di Twitter untuk konten NEAR yang lebih berkualitas seperti di bawah ini.

Sumber artikel terdapat pada link Medium.
Apa itu Burrow?
Burrow merupakan pasar uang otonom yang terdesentralisasi, non-kustodian, yang serupa dengan Aave dan Compound.

Burrow bertujuan untuk membuka likuiditas untuk aset berbunga, terutama untuk turunan staking layer 1 seperti stNEAR dan stETH. Pengguna Burrow akan bisa mendepositkan stNEAR sebagai jaminan (collateralI), kemudian meminjam lebih banyak NEAR untuk membuat posisi staking dengan leverage, atau meminjam stablecoin untuk membuat posisi pembayaran secara mandiri.


Cara Memulai

Masih baru di ekosistem NEAR?
Jika anda masih belum memiliki akun NEAR, ikuti panduan berikut untuk bisa membuat akun NEAR wallet milik anda terlebih dahulu.

Hubungkan ke wallet NEAR anda
Jalankan aplikasi Burrow dan hubungkan dompet NEAR anda dengan menekan tombol di sudut kanan atas.








Bagaimana Cara Meyetorkan Aset?
Pengguna dapat menyetorkan aset ke protokol dan mulai mendapatkan keuntungan berupa bunga.

Tingkat bunga akan bervariasi dan juga berfluktuasi berdasarkan tingkat pemanfaatan untuk aset yang diberikan. (Info lebih lanjut tentang model suku bunga di sini.)

Aset yang saat ini didukung setelah rilis:

 	NEAR
 	stNEAR (staked NEAR)
 	ETH
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (token asli Burrow)

1. Buka menu "Deposit" dan pilih aset yang akan disetorkan
Telusuri bagian "Setoran" dan klik aset yang ingin Anda setor.





2. Tentukan jumlah yang ingin anda setorkan dan ajukan transaksi anda tadi
3. Ketika anda sudah berhasil mendeposit aset sebelumnya, sekarang anda memiliki dua pilihan:




(1) Aktifkan "Gunakan sebagai jaminan".

Ini berarti bahwa anda sekarang dapat meminjam aset lain dengan jumlah yang telah anda setorkan ke dalam supply pool.

Ini juga mengartikan bahwa dana milik anda memiliki potensi untuk dilikuidasi. Lihat bagian “Health Factor” dan “Liquidation” di bawah ini untuk info lebih lanjut.

(2) Cukup sediakan aset, jangan “digunakan sebagai jaminan”.

Ini berarti anda hanya akan mendapatkan bunga dari jumlah yang anda berikan ke pool, tanpa meminjam aset apa pun lebih lanjut. Dalam hal ini, aset anda tidak dapat dilikuidasi.

Anda akan selalu dapat mengaktifkan "gunakan sebagai jaminan" nanti di halaman "Portofolio" anda.
4. Setujui transaksi pada NEAR Wallet prompt




Setoran anda sekarang berhasil didaftarkan, dan anda dapat mulai mendapatkan keuntungan dari bunga. Angka “APY” (persentase hasil tahunan) memberi tahu kepada anda mengenai seberapa banyak yang akan anda dapatkan dalam bentuk $BRRR untuk suplai aset yang sudah dilakukan.


Bagaimana Cara Meminjam Aset?

Sekarang setelah anda menyetorkan aset milik anda ke kumpulan likuiditas Burrow, anda juga dapat meminjam dana untuk itu.

1. Tetapkan jumlah aset anda sebagai jaminan
Untuk bisa meminjam aset, pertama-tama anda harus mengaktifkan “Use as Collateral”. Jika anda tidak bisa mengaktifkan tombol “Use as Collateral” ketika menyetorkan aset, anda dapat menyesuaikan posisi di “Portofolio” lalu menuju kolom “Adjust Collateral”.

Di Burrow, anda dapat menyortir dan memilih aset apa yang akan disetorkan untuk dijadikan jaminan, begitupun untuk menyesuaikan tingkat kolateralisasi.




2. Pada laman “Borrow”, pilih aset yang ingin dipinjam




3. Tentukan jumlah dana yang ingin anda pinjam, dan harap perhatikan tentang hasil dari Health Factor




Apa itu “Health Factor”?
Risiko suatu posisi dapat dipahami melalui Faktor Kesehatan atau “Health Factor”, yang mewakili rasio jaminan gabungan dari aset yang dipinjam.

 	Jika Health Factor lebih tinggi dari 100%, itu berarti akun dalam keadaan baik dan tidak dapat dilikuidasi.
 	Jika Health Factor kurang dari 100%, berarti akun tersebut dapat dilikuidasi sebagian dan tidak dapat meminjam lebih banyak tanpa membayar kembali sejumlah aset yang ada atau memberikan lebih banyak aset jaminan.

Untuk mempelajari lebih lanjut tentang bagaimana perhitungan Health Factor, anda dapat melihatnya lebih dalam di sini.

Apa itu “Likuidasi”?
Likuidasi adalah ketika posisi Anda ditutup secara paksa oleh protokol (yaitu agunan anda akan dijual) diakibatkan oleh perubahan kondisi pasar, nilai agunan anda tidak lagi cukup untuk mengamankan hutang anda berdasarkan Health Factor, artinya anda berisiko tidak bisa melunasi hutang anda. Kepailitan semacam ini tentunya mengancam protokol, dan oleh karena itu peristiwa likuidasi dipicu melalui bot untuk mencegahnya terlebih dahulu.

Ini mungkin terjadi ketika:

 	Nilai agunan menurun (misalnya harga wNEAR turun dari $20 menjadi $10)
 	Hutang pinjaman meningkat nilainya

Anda dapat membaca lebih lanjut tentang likuidasi di sini.

RIngkasan Singkat
When your Health Factor is…


 	Hijau :  Dana anda (umumnya) aman
 	Kuning :  Risiko sedang
 	Merah : Dana anda berisiko tinggi untuk dilikuidasi

Peringatan

 	Kami menyarankan kepada para pengguna agar JANGAN menetapkan tingkat pemanfaatan agunan pada 100%. Anda secara terang-terangan meminta untuk dilikuidasi!
 	Health Factor dapat berubah jika harga aset dasar berubah secara signifikan. Kami menyarankan pengguna untuk memantau Health Factor mereka dari waktu ke waktu, terutama jika ada perubahan cepat dalam kondisi pasar.

Ajukan dan terima transaksi







Bagaimana Cara Mengelola Aset Anda
Akses “Portofolio” di menu untuk melihat dan mengelola aset setoran dan pinjaman anda.

Net APY
"Nett APY" anda adalah APY total milik anda (berdasarkan hasil persentase tahunan) yang menghitung berapa banyak yang bisa dihasilkan dari menyetorkan aset (depost APY) dikurangi dengan berapa banyak anda berhutang pada protokol dari pinjaman (borrow APY).

Penarikan
Pilih aset yang ingin anda tarik dan klik “Tarik atau Withdraw”





Jika anda ingin menarik semua aset milik anda, pastikan untuk melunasi hutang anda terlebih dahulu. Jika penarikan pada 100% tidak berhasil, turunkan ke 99% atau lebih dan coba lagi.
Jika anda hanya menarik sebagian dari aset milik anda dan mempertahankan posisi utang anda, waspadalah terhadap ini karena hal ini akan mengubah Health Factor dan mengelola tingkat risiko likuidasi anda.





Penyesuaian Jaminan
Di Burrow, anda dapat menyesuaikan tingkat di mana aset anda dijaminkan, dan mengaturnya secara berbeda untuk setiap aset yang anda berikan. Ini berbeda dengan protokol peminjaman sebelumnya yang tingkat jaminannya ditetapkan secara default.

Anda dapat mengatur tingkat agunan yang diinginkan saat pertama kali menyetorkan aset, atau pergi ke “Portofolio” dan klik “Adjust Collateral.”




Pelunasan
Untuk melunasi hutang anda yang terutang, buka bagian "Portofolio" dan klik tombol "Repay" untuk membayar.





Menyetorkan NEAR dan Melunasi dengan wNEAR?
Karena ada perbedaan dalam standar token, Burrow (dan sebagian besar dapp DeFi lainnya di NEAR) menggunakan wNEAR ("wrapped" NEAR) dan bukan token NEAR.

Saat anda melakukan deposit, NEAR milik anda akan secara otomatis di-wrap sehingga tidak ada yang perlu anda lakukan. Namun, jika Aada meminjam $wNEAR dan ingin membayar/ melunasi kembali, anda harus melakukannya dalam bentuk wNEAR. Gunakan jasa dari Ref Finance dan menuju halaman penukaran NEAR/wNEAR di Ref Finance untuk mengubah NEAR milik anda menjadi wNEAR terlebih dahulu.

Di masa mendatang, Burrow akan mendukung wrap/unwrap secara langsung pada aplikasi Burrow itu sendiri. Selanjutnya, fungsi wrap/unwrap akan diintegrasikan ke dompet NEAR sehingga masalah ini lebih mudah untuk diselesaikan.




Untuk mempelajari perbedaan antara wNEAR dan NEAR, lihat FAQ kami lebih lanjut.




Burrow saat ini telah berjalan dan live di Mainnet! Silakan baca FAQ untuk memulai lebih lanjut.

Yang kita nantikan akhirnya telah tiba! Pasar uang pertama yang ada di jaringan NEAR akhirnya sudah live di mainnet. Ini berarti akan lebih banyak likuiditas dan aktivtas DeFI.


burrowcash.medium.com










Segera Hadir: xBRRR Staking!
Shortly, staking will go live on Burrow. Users can stake their BRRR and receive xBRRR, with which they can access boosted rewards and participate in protocol governance. Stay tuned!


Menjadi Burrow Hog

Dapp • Twitter • Discord • Docs

### Update - June 20, 2022

Brief Summary:

 	

 	
June Redeem to NEAR window opened early for (L)Earner NFT holders!




Results:

 	💸  Ⓝ756 sent to 189 (L)Earners. (L)Earner NFT holders enjoyed 2 hours early access!
 	🧪CalenD Beta Test sprint brought great feedback!
 	 New Guide: Super condensed explanation on how Data flows on NEAR protocol
 	 New Community Guide: Try web3 on NEAR testnet - safe, hands-on web3 tokenomics playground! TokenHub – DeFi playground on NEAR testnet.
 	dWork testnet token sale ended! Over 42K testnet NEAR deposited by 36 users!


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	 NEAR Certified Developer Demo day scheduled on June 22, 11 EDT

### Comment Burrow : un Guide de l'Utilisateur Étape par Étape

Ce guide de l'utilisateur a été créé en collaboration avec NEAR Mates et NEAR Insights. Suivez-les sur Twitter pour plus de contenu NEAR de qualité comme ci-dessous.

Article Source sur Medium
Qu'est-ce que Burrow ?
Burrow est un marché monétaire décentralisé, non dépositaire et autonome, de nature similaire à Aave et Compound.

Burrow vise à débloquer des liquidités pour les actifs portant intérêt, en particulier les dérivés de jalonnement de couche 1 tels que stNEAR et stETH. Les utilisateurs de Burrow pourront déposer stNEAR en garantie, puis emprunter davantage de NEAR pour créer une position de jalonnement à effet de levier, ou emprunter un stablecoin pour créer une position auto-remboursable.


Commencer

Nouveau sur NEAR ?
Si vous n'avez pas de compte NEAR, suivez simplement ce guide pour configurer d'abord votre portefeuille NEAR !

Connectez votre portefeuille NEAR
Lancez l'application Burrow et connectez votre portefeuille NEAR dans le coin supérieur droit.







Comment Fournir
Les utilisateurs peuvent fournir des actifs au protocole et commencer à gagner des intérêts.

Les taux d'intérêt sont variables et fluctueront en fonction du taux d'utilisation de l'actif donné. (Plus d'informations sur le modèle de taux d'intérêt ici.)

Actifs pris en charge au lancement :

 	NEAR
 	stNEAR (staked NEAR)
 	EPF
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (jeton natif de Burrow)

1. Allez dans "Deposit" et choisissez l'actif à fournir
Accédez à la section "Deposit" et cliquez sur l'actif que vous souhaitez déposer.






 	
 Sélectionnez le montant que vous souhaitez déposer et soumettez votre transaction.

 	
 Une fois que vous avez déposé vos avoirs, vous avez maintenant deux options :






(1) Activez "Use as Collateral” (Utiliser comme garantie).

Cela signifie que vous pourrez désormais emprunter des actifs sur le montant que vous avez déposé dans le pool d'approvisionnement.

Cela signifie également que vos fonds peuvent potentiellement être liquidés. Voir les sections «  Health Factor » et « Liquidation » ci-dessous pour plus d'informations.

(2) Fournissez simplement des actifs, pas «Use as Collateral».

Cela signifie que vous gagnerez simplement des intérêts sur le montant que vous avez fourni au pool, sans emprunter d'autres actifs. Dans ce cas, vos biens ne font pas l'objet d'une liquidation.

Vous pouvez toujours activer « Use as Collateral » plus tard dans votre page « Portfolio ».
4. Approuvez la transaction dans l'avis du portefeuille NEAR.




Votre dépôt a maintenant été enregistré avec succès et peut commencer à générer des intérêts. Le nombre "APY" (annual percentage yield - rendement annuel en pourcentage) vous indique combien vous pouvez vous attendre en récompenses $ BRRR pour la fourniture d'actifs.

Comment Borrow

Now that you have supplied your assets to Burrow’s liquidity pool, you can also borrow funds against it.

1. Désignez vos Actifs en Garantie
Pour emprunter des actifs, vous devez d'abord activer "Use as Collateral". Si vous n'avez pas activé le bouton "Use as Collateral" lors du dépôt, vous pouvez ajuster sa position dans la section "Portfolio" → "Adjust Collateral".

Chez Burrow, vous pouvez choisir les actifs déposés que vous souhaitez utiliser comme garantie, ainsi que personnaliser le taux de garantie.




2. Sur la page "Borrow", sélectionnez l'actif que vous souhaitez emprunter




3. Entrez le montant que vous souhaitez emprunter, en gardant à l'esprit le Health Factor (facteur de santé) qui en résulte




Qu'est-ce que le « Health Factor - facteur de santé » ?
Le risque d'une position peut être compris à travers le facteur de santé, qui représente les ratios de garantie combinés des actifs empruntés.

 	Si le facteur de santé est supérieur à 100 %, cela signifie que le compte est en bon état et ne peut pas être liquidé.
 	Si le facteur de santé est inférieur à 100 %, cela signifie que le compte peut être partiellement liquidé et ne peut pas emprunter davantage sans rembourser un certain montant des actifs existants ou fournir plus d'actifs en garantie.

Pour en savoir plus sur la façon dont le facteur santé est calculé, voir ici.

Qu'est-ce que "Liquidation ?
La liquidation se produit lorsque votre position est clôturée de force par le protocole (c'est-à-dire que votre garantie est vendue) car, en raison de l'évolution des conditions du marché, la valeur de votre garantie n'est plus suffisante pour garantir votre dette sur la base du facteur santé, ce qui signifie que vous risquent de ne pas être en mesure de rembourser votre dette. Ce type d'insolvabilité menace le protocole, et donc un événement de liquidation est déclenché par des bots pour l'empêcher à l'avance.

Cela peut se produire lorsque :

 	La valeur de la garantie diminue (par exemple, le prix wNEAR diminue de 20 $ à 10 $)
 	La dette empruntée prend de la valeur

Vous pouvez en savoir plus sur la liquidation ici.

TL; DR
Lorsque votre facteur de santé est…

 	Vert : vos fonds sont (généralement) en sécurité
 	Jaune : le risque est modéré
 	Rouge : vos fonds présentent un risque élevé d'être liquidés

Avertissement

 	We recommend users DO NOT set the collateral utilization rate at 100%. You are asking to be liquidated!
 	The Health Factor can change if the price of the underlying assets change to a great degree. We recommend users monitor their Health Factor from time to time, especially if there are rapid changes in market conditions.

4. Submit and approve the transaction







Comment gérer vos actifs
Accédez à « Portfolio » dans le menu pour afficher et gérer vos actifs déposés et empruntés.

APY Net
Votre « APY net » est votre APY total (rendement annuel en pourcentage) qui calcule combien vous gagnez en déposant des actifs (dépôt APY) moins combien vous devez au protocole d'emprunt (emprunter APY).

Retirer
Choisissez l'actif que vous souhaitez retirer et cliquez sur "Withdraw".





Si vous souhaitez retirer tous vos actifs, assurez-vous d'abord de rembourser votre dette. Si le retrait à 100 % ne fonctionne pas, abaissez-le à 99 % environ et réessayez.

Si vous ne retirez qu'une partie de vos actifs et maintenez votre position d'endettement, méfiez-vous de la façon dont cela modifiera le facteur santé et gérera votre risque de liquidation.




Ajuster la Garantie (Adjust Collateral)
Sur Burrow, vous pouvez personnaliser le taux auquel vos actifs sont garantis et le définir différemment pour chaque actif que vous fournissez. Ceci est différent des protocoles de prêt précédents dont les taux de garantie étaient fixés à un taux par défaut.

Vous pouvez définir le taux de collatéralisation souhaité lorsque vous déposez vos actifs pour la première fois, ou allez dans « Portfolio » et cliquez sur « Adjust Collateral ».




Rembourser
Pour rembourser votre impayé, rendez-vous dans la section « Portfolio » et cliquez sur le bouton « Repay ».





Déposez NEAR, Remboursez avec wNEAR ?
En raison de la différence dans les normes de jeton, Burrow (et la plupart des autres dapps DeFi sur NEAR) utilisent wNEAR («wrapped» NEAR), pas NEAR.

Lorsque vous déposez, votre NEAR sera automatiquement enveloppé, vous n'avez donc rien à faire. Cependant, si vous avez emprunté $wNEAR et cherchez à rembourser, vous devez le faire en tant que wNEAR. Utilisez la page Ref Finance Wrapping pour envelopper d'abord votre NEAR dans wNEAR.

À l'avenir, Burrow prendra en charge wrap/unwrap (l'emballage/déballage) direct sur l'application elle-même. De plus, la fonction wrap/unwrap sera intégrée au portefeuille NEAR afin que ce problème soit résolu plus facilement.




Pour en savoir plus sur la différence entre wNEAR et NEAR, consultez notre FAQ.




Burrow est en direct sur Mainnet ! Lisez cette FAQ pour Commencer
L'attente est terminée! Le premier marché monétaire sur NEAR native est enfin en ligne sur mainnet Cela signifie plus de liquidités et de DeFi…
burrowcash.medium.com

Prochainement : Staking xBRRR !
Bientôt, le staking ou jalonnement sera mis en ligne sur Burrow. Les utilisateurs peuvent jalonner leur BRRR et recevoir xBRRR, avec lequel ils peuvent accéder à des récompenses boostées et participer à la gouvernance du protocole. Restez à l'écoute!

Devenez un Burrow Hog
Dapp • Twitter • Discord • Documents

### TokenHub - DeFi playground on NEAR testnet

1. What is TokenHub?

 	TokenHub is a playground where you can create your own token with just a few clicks, and then freely try out every feature of the Defi world. 

2. Why TokenHub?

 	Since the Bitcoin halving in 2020, the DeFi space has continuously grown and is well developed in the diversity of products and user base. The Total Value Locked on all DeFi products once even peaked at $250 billion. This proves that the need for DeFi is increasing every day, but most people only recognize the risks of DeFi after losing actual money to it. This is the motivation for the creation of TokenHub. TokenHub team’s mission is to help DeFi users to get hands-on experience with many fields of DeFi like yield farming, and swapping of tokens, … without the cost of their actual money. By using TokenHub, users can learn a lot about DeFi without taking the risk of losing money, exclusively on NEAR testnet.

3. TokenHub Guide: How to create your own token on TokenHub
Step 1: Connect your NEAR testnet account to TokenHub
If you don’t have a NEAR testnet account, please follow the official guide.

Go to https://app.tokenhub.tk/token/create and click “Connect To Wallet”:



Once you are redirected to this site, click “Next”:


Then click “Connect”:



Your account is now connected to TokenHub:


Step 2: Go to https://app.tokenhub.tk/token/create or click the “Create Token” button on the left panel of TokenHub website:

Step 3: Fill in your desired token information 
This includes the name of your token, its symbol, its total supply, and its decimal value (from 8 to 24). In this example, I will create a token named “Bitcoin” and have the symbol “BTC”, its total supply will be 21,000,000 tokens and a decimal value of 8.



A simple explanation of decimal value is the number of digits that comes after the decimal point. For example, my Bitcoin token has a decimal value of 8, so an arbitrary account could have 1.12345678 BTC or 49.37603856 BTC, and the total supply of my BTC token will be 21,000,000.00000000. The higher the decimal value is, the more divisible your token will be.
Step 4: Configure the allocation of your token 
Step 4.1: Set up the allocation accounts
Two default accounts will receive a portion of the token total supply: TokenHub’s treasury account (treasury.tokenhub.testnet), and the account that you have connected to TokenHub. To add more accounts that can receive a portion of your total token supply, click “Add More Allocation” and then fill in the address of those accounts, note that the accounts that you add have to be NEAR testnet accounts, which are accounts that end with “.testnet”, not “.near”:



My BTC token will only allocate to the two default accounts:






	

	
	
		
			
				The default accounts that your token will be allocated to are the TokenHub’s treasury and you are connected NEAR testnet wallet.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Step 4.2: Determine the token allocation for each account 
Fill in how much of your total supply (in %) will be given to each account in the “Allocation(%)” box. The amount that the treasury account will get has three options to choose from 3, 5, or 7%. Remember that no matter how many accounts your tokens will be allocated to, the total allocation(%) of all accounts has to be 100%. My BTC token will give TokenHub’s treasury 3% (630,000 BTC), and the rest 97% will be sent to my account:


Step 4.3: Set initial release for each account
Determine how much (from 0 to 100%) of the allocation that you’ve set in Step 4.2 that will be immediately sent to each account once you have created your token. In this example, the treasury will instantly receive 10% of 3% of 21,000,000 total supply of BTC, which is 63,000 BTC. As for my account, it is 50% of 97% of 21,000,000 BTC, which is 10,185,000 BTC.

You might be wondering, “How will the rest of the token be released?”. This is where the vesting parameters come in.


Step 4.4: Configure vesting parameters
Vesting is the gradual and periodical release of tokens to the designated accounts. In this example, it means that the remaining tokens that aren't initially released will be locked after creation and will be released at selected intervals in the future. At TokenHub, you can configure 3 parameters for your token vesting: The start date, the vesting duration, and the vesting interval.

The vesting start date determines when the releasing process of your token starts. You can configure this date individually for each allocation account.



 

Next, set the vesting duration for each account. The vesting duration is how long it will take to completely release the tokens. For TokenHub’s treasury account, there are 3 options to choose from 1, 2, or 3 years. As for other accounts, you can fill in any duration (in days) that you want. In this example, the vesting for the treasury will complete its releasing of tokens in 1 year. For my account, it will be completed in 30 days.

 

Finally, set the vesting intervals (in days) for each account. The vesting interval is the period between each release. For example, a vesting duration of 30 days and an interval of 10 days would mean that the tokens will be divided into 3 equal parts, and each part will be released every 10 days. For the treasury account, there are also 3 options: 30, 90, or 180 days. For other accounts, you can choose any duration.






	

	
	
		
			
				Other than the two allocation accounts, you cannot add any other accounts that can receive your token.
			
		

		
					

		
			
			
			
			True
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Step 5: Create your token
Once you have completed all the steps above, click “Create Token”

Then you will be redirected to this site, click “Approve”

After a while, you will be redirected to the “My Token” tab which includes all your created tokens.
Guide: Launch your token sale
To launch your token sale on TokenHub, please fill out this form: https://forms.gle/vgagVRQpKrEQJ8D86

Then contact Harry - TokenHub founder via: 

 	Discord: harrynguyen#0629
 	Telegram: @harrynguyen0991

So that we can help you with setting up your token sale contract according to your sale registration. We will inform you about the contract address so you will have to send enough tokens to that contract. Finally, we will put it on the TokenHub website to begin promotion. Then all you have to do is wait and your sale will be up and running.Fundamentally, you need to decide how many tokens are allocated for sale and what is the timeline. It’s totally up to you but the sale shouldn’t last too long. The LNC token sale lasted 3 days including 2 days of the sale and 1 day of grace which can be a good reference for you. Refer to LNC Token Sale for details.

### LNC Multisender Beta Test

Follow @LearnNEAR on Twitter

Beta test sprint starts: June 16, 9 am ET
Beta Test sprint ends: June 18, 11pm ET.
Requirements:
Read "Guide and other information about LNC testnet token mulitsender"

 	Get yourself our Telegram bot LNC NEAR testnet watcher to get notified on transactions
 	If you did not participate in tesntet LNC token sale and Claim, you can get some at https://testnet.ref.finance/
 	Sign in the app LNC Multisender with NEAR testnet account
 	Send unsafe at least 3 multi-transactions to as many as you can of your NEAR friends. Try with accounts which don't contacts with LNC tokens before.
 	Send from app balance at least 2 multi-transactions to your NEAR friends.
 	Perform at least once “Withdraw all” operation
 	Perform at least once “Deposit __ LNC” operation
 	Make screenshot when you are done!
 	Tweet with your screenshot “I’ve just send testnet LNC tokens to my friends at LNC Token Multisender app, project from @LearnNEAR Barrel”

Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy Testing!

### NEAR Data Flow

Video explanation​
In the video below we have tried to give a quick overview on main concept of how the data is flowing in NEAR Protocol blockchain. You will find a text version below the video.


Text version​






NEAR Protocol blockchain data flow might be a bit tricky at a glance. But it is pretty straightforward and follows well-defined rules. In this article, we are going to have a closer look at how the data flows in NEAR Protocol blockchain.



In fact, any blockchain flow can be represented as an infinity timeline that has a start but has no end.



And a block appears on that timeline with some interval. Each of these blocks holds the information about the previous one, thus, creating a chain of blocks.

NEAR Protocol has a sharded nature, meaning that more than one parallel network, called a Shard, can be live at any moment. And each Shard produces a chunk of a block at a given interval. A Block in NEAR Blockchain is a collection of the block chunks from all shards. Block chunk is shortened to Chunk in NEAR Protocol documentation.

Returning to the data flow itself. The best we can do is to imagine tracks like we could see in audio/video editing apps. Each Shard has its own set of tracks. The top track is for Chunks. They appear no matter what at a given interval, for NEAR Blockchain the interval is about one second. Chunks are being produced even if nothing is happening on the blockchain.



But what do we mean by saying something is happening? We mean that something has triggered some changes in the blockchain. And the most well known method to trigger any changes is to send a Transaction to the blockchain with instructions of what we want to change and who has requested those changes.

A transaction needs to be constructed, signed and sent to the blockchain. Once it is executed we expect to have a result - ExecutionOutcome. Oh, that is simple. But it’s not really accurate for NEAR Blockchain.



In the beginning there is a Transaction, it contains instructions we want to be executed on the blockchain. Transaction is sent to NEAR Blockchain.

And yes, it is executed there immediately BUT the immediate result of the transaction execution is always just an acknowledgement that it will be executed on the chain; this internal execution request is known as Receipt. You can think of the Receipt as an internal transaction that exists to pass information across shards.

Let’s get back to the tracks to look at the example.

Assuming we have two accounts living on different Shards alice.near and bob.near. alice.near creates a Transaction to send a few tokens to bob.near. The Transaction is immediately executed and the ExecutionOutcome for the Transaction is always a Receipt.

But this Receipt cannot be executed here, because bob.near doesn’t live on the same Shard as alice.near, so the Receipt must be executed on the receiver’s Shard. So the Receipt is moving to the Shard where bob.near belongs to.

On the destination Shard the Receipt is executed and the process is considered as done.


THE EXPLANATION HERE IS SIMPLIFIED



Please refer to the Token transfer flow article



So the final scheme will look like:


Summary​
We have learnt the main principles of how data is flowing in NEAR Protocol. We have found out that Transactions execute and the ExecutionOutcome of the Transaction is always a Receipt.

Now we know that Receipt is a main internal asset for NEAR Protocol blockchain and it has a power of traveling between Shards. We learnt the NEAR Data flow on a simple example. Of course in real life with more complex transactions, that involve cross-contract calls, there will be more Receipts and ExecutionOutcomes.

We hope this article is useful and you will be able to build your dApps and indexers easily with the knowledge of how data if flowing in NEAR Protocol.

### Billeteras NEAR

Una guía para las billeteras NEAR
En el actual mercado crypto, Ethereum es la plataforma por excelencia para aplicaciones descentralizadas, contratos inteligentes y finanzas descentralizadas. De todas formas, Ethereum tiene varios problemas que son obstáculos, tales como altas tarifas de gas y significantes problemas relacionados con escalabilidad. Entonces mientras Ethereum puede que sea el número uno, muchos otros protocolos están surgiendo para desafiar a Ethereum en el mercado.

El Protocolo NEAR es una de las blockchains (cadenas de bloque) que ha emergido como un verdadero retador a la dominancia de Ethereum en el espacio. El equipo en NEAR ha mirado las deficiencias de Ethereum y creó un protocolo que va directo hacia los más deslumbrantes defectos, su falta de escalabilidad y las altas tarifas de gas. NEAR utiliza un proceso llamado sharding (fragmentación), permitiendo al protocolo escalar exponencialmente. NEAR también ha conseguido recaudar significativos fondos desde algunos de los más grandes capitalistas de riesgo, incluyendo a a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital y muchos más. En esta guía, vamos a mirar hacia NEAR y en particular, la billetera NEAR.
El Protocolo NEAR
Fundado en 2018, el Protocolo NEAR es una plataforma de desarrollo descentralizada diseñado para crear un ambiente sin fallas y casi perfecto para aplicaciones descentralizadas (dApps) y contratos inteligentes. NEAR fue creado luego de analizar los defectos de los protocolos existentes, particularmente Ethereum. El protocolo se enfoca en abordar estos problemas y está buscando convertirse en la plataforma de referencia para aplicaciones descentralizadas y finanzas descentralizadas. El uso del sharding en NEAR permite al protocolo escalar exponencialmente, abordando los problemas de escalabilidad prevalentes en el espacio.

La Proof of Stake (prueba de participación) de la blockchain de NEAR es extremadamente amigable hacia desarrolladores, gracias a que es de bajo costo y altamente escalable y los desarrolladores pueden de manera simple crear aplicaciones descentralizadas. El Protocolo NEAR también tiene muchas otras funciones, tales como la billetera de NEAR y otros componentes. Nuestro enfoque en este artículo va a ser la billetera de NEAR, pero ya vamos a hablar de eso luego. NEAR también utiliza Doomslug, permitiendo a los bloques alcanzar finalidad en segundos. Otras blockchains usualmente centralizan el procesamiento, limitando su usabilidad a hardware que sea de tope de gama. Mientras que este acercamiento incrementa su rendimiento, lo hace solo temporalmente. NEAR es capaz de escalar linealmente, soportando billones de transacciones de una manera descentralizada


NEAR ha sido creado por el colectivo NEAR, una comunidad de investigadores y desarrolladores. El enfoque del colectivo de NEAR es el continuo desarrollo y mejoría del protocolo. El colectivo también ha trabajado en el código inicial del Protocolo NEAR y en la implementación de la red de NEAR. Mientras el colectivo de NEAR está detrás del desarrollo del Protocolo NEAR, el último mencionado opera enteramente independiente y es totalmente descentralizado, incluso sin la posibilidad del colectivo de NEAR de poder apagarlo.
Ventajas del Protocolo NEAR

 	Los usuarios de NEAR no requieren un navegador complicado o extensiones o llaves para registrarse. Un simple email y contraseña es suficiente para el registro.
 	Los contratos inteligentes de NEAR son compatibles con la WebAssembly Virtual Machine (WASM).
 	El protocolo permite a desarrolladores desplegar aplicaciones blockchain escalables y de alto desempeño.
 	Se utiliza una fracción de las tarifas de gas comparado con otras cadenas como Ethereum.

¿Qué es una billetera cripto?
Antes de avanzar hacia la billetera de NEAR, es esencial entender que es una billetera. En términos más simples, las billeteras cripto guardan seguramente tus llaves privadas, asegurando que tus criptomonedas están seguras y accesibles. También puedes utilizar billeteras cripto para realizar transacciones, mandar y recibir criptomonedas, o incluso gastar tus criptomonedas. Cuando se elige una billetera cripto, tienes varias opciones de las cuales elegir. Estas son billeteras de papel, billeteras de hardware, y billeteras online.
Billeteras calientes
Billeteras calientes son billeteras basadas online que permiten a los usuarios transferir sus cripto rápidamente. La mayoría de los exchanges online tienen sus propias billeteras a las cuales los usuarios pueden acceder. Billeteras calientes son fáciles de acceder mediante un móvil o desde el escritorio. Mientras las billeteras calientes ofrecen fácil conectividad, también están frente a riesgos tales como hackeo. Billeteras de escritorio, billeteras online y billeteras móviles son ejemplos de billeteras calientes.
Billeteras frías
Una billetera fría o billetera de hardware son dispositivos similares a un dispositivo USB donde los usuarios pueden guardar sus llaves. La billetera es portátil y puede ser conectada a una laptop o máquina de escritorio cuando el usuario desee acceder a sus criptos. Billeteras de hardware son menos probables a tener amenazas tales como hackeo o cualquier otro tipo de ataque malicioso que pudiera ocurrir online.
Billeteras de papel
Una billetera de papel es esencialmente un pedazo de papel impreso que contiene tu llave pública y llave privada. Se puede acceder a las llaves solamente mediante un código QR. Las billeteras de papel son utilizadas para resguardar una cantidad significativa de crypto debido a que son consideradas extremadamente seguras.
La billetera NEAR
Los desarrolladores en el Protocolo NEAR han desarrollado una aplicación de billetera conveniente para los tokens NEAR. La billetera está basada en web y dentro del navegador en la cual los usuarios pueden utilizar la billetera NEAR para crear e interactuar con otras cuentas NEAR. La billetera también es requerida para interactuar con el Protocolo NEAR. La billetera es utilizada para guardar tokens NEAR y tokens estándar NEP21, los cuales son soportados dentro de la blockchain de NEAR. Esta billetera permite a los usuarios enviar o recibir tokens NEP21 y tokens NEAR e interactuar con las aplicaciones dentro del protocolo. Mientras utilizamos la billetera NEAR, es esencial recordar la siguiente información.

Un diferenciador clave para las cuentas de NEAR es que NEAR utiliza cuentas legibles por humanos, y no un hash. Entonces una cuenta de NEAR no se leería como 0x71C7656EC7ab88b098defB751B7401B5f6d8976F sino como alice.near o bob.near. Las cuentas NEAR también pueden crear sub cuentas, pero solo la cuenta raíz puede crearlas. Otro diferenciador crítico es que la mayoría de las blockchains tienen una llave pública/privada para cada cuenta. En NEAR, las cuentas pueden tener múltiples llaves asociadas a ellas. Estas son llamadas “llaves de acceso”. Las llaves de acceso son de dos tipos, una llave de acceso completa y una llave de llamada funcional. La llave de acceso completa permite al usuario completo control de su cuenta NEAR. Por otro lado, la llave de llamada funcional permite firmas de transacciones no monetarias.

Dirección de la billetera - La dirección de la billetera es esencialmente una secuencia de caracteres o números, o ambos, que son utilizados para enviar o recibir tokens utilizando la billetera NEAR.

Llave privada y frase de contraseña - La frase de contraseña y la llave de seguridad es un tipo de contraseña. La frase de seguridad está comprendida de 12 palabras, mientras que la llave privada consiste en una secuencia de letras y números. Ambos son pasos extremadamente importantes cuando se trata de la recuperación de la billetera.
Creando una billetera NEAR
La billetera NEAR permite a los usuarios enviar y recibir tokens NEAR y stakear (apostar/participar) sus tokens NEAR. De todas formas, tienes que crear una billetera en NEAR para acceder a estas funciones. Vamos a comenzar.

 	El primer paso es ir a https://wallet.near.org/. Una vez que llegas a esta página, tienes dos opciones, crear cuenta o importar cuenta existente. Vamos a ir por la primera opción.



 	Una vez que haces click en “create an ID” tienes que crear un nombre de cuenta. Creas tu nombre de cuenta y si el nombre está disponible haces click en “Reserve My Account ID” 



 	El próximo paso es elegir cómo vas a recuperar el acceso de tu cuenta. Existen tres métodos de recuperación para que tu consideres. Puedes utilizar una frase semilla, conectar un dispositivo de billetera ledger, o email. El protocolo recomienda elegir una frase semilla o conectar un dispositivo ledger, ya que estos son más seguros que asegurar tu contraseña mediante un email. Vamos a elegir “Secure Passphrase” en este ejemplo y avanzar.



 

 

 	Es altamente recomendado que utilices el Ledger Nano S o X. Utilizar el ledger asegura que tus llaves privadas estén seguramente guardadas en tu ledger. El Ledger provee el nivel más alto de seguridad mientras utilizas tu billetera NEAR. Configurar tu ledger es simple, todo lo que tienes que hacer es descargar Ledger Live, y actualizar el firmware. Para instalar la aplicación de Ledger de NEAR, abre la aplicación Ledger Live, ve a Settings y haz click en Experimental Features. Desde aquí vas a ser capaz de cambiar hacia Developer Mode. Una vez que este paso sea completado, elige Manager, busca por NEAR y haz click en Install. 
 	Una vez que haces click en Secure Passphrase, una frase semilla va a aparecer en la pantalla, conteniendo 12 palabras mnemónicas. Vas a tener que guardar con seguridad estas palabras, y la mejor manera de hacerlo es simplemente escribiendolas en un libro o un pedazo de papel y guardarlas en un lugar seguro. Por favor NO tomes un screenshot y guardes la frase o la almacenes en algún medio online. Tu frase semilla es para ti solamente.



 	Confirma y verifica que has colocado la frase semilla correctamente y completado el proceso de configuración.
 	Una vez que hayas completado la verificación de tu frase semilla, vas a ser redirigido hacia la pantalla de “Fund Your Account”. Este proceso va a requerir que tomes el ID que seleccionaste antes. Hay varias maneras de que fondees tu cuenta. Puedes realizarlo tú mismo mediante una cuenta en un exchange y enviando NEAR a la cuenta de único fondeo. También puedes fondear tu cuenta utilizando Moonpay o pidiendo a algún amigo que tenga NEAR que envíe 1 NEAR a tu cuenta temporaria. Una vez que esté completa la transacción, tu depósito inicial va a verse reflejado en la billetera.



 	Ahora que tu cuenta está fondeada exitosamente, clickea en “Continue to Account”, y vas a ser redirigido hacia el inicio de la interfaz de tu billetera.

Una vez que tu cuenta esté creada, es recomendable que actives el método 2FA. Este paso es crítico porque incrementa significativamente la seguridad de la cuenta de tu billetera NEAR.
Creación de cuenta con Ledger
Vamos a entender cómo puedes crear una cuenta utilizando un dispositivo Ledger.

 	Ve hacia wallet.testnet.near.org y elige “Create an Account”.
 	Utiliza el mismo paso mencionado en el previo método y reserva un ID de cuenta. Una vez que pongas tu ID, clickea en “Create The Account”
 	Luego, vas a tener que elegir un método de seguridad. Aquí es donde tu creación de cuenta es diferente porque vas a estar utilizando tu dispositivo Ledger. Entonces en vez de “Recovery Phrase”, selecciona “Ledger Nano S or X”.



 	Luego de elegir la opción de Ledger, aprieta “continue” y vas a ser incitado a conectar tu dispositivo ledger.



 	Una vez que hayas conectado tu dispositivo Ledger, desbloquealo. Selecciona la app de NEAR si la tienes instalada. Tu dispositivo ledger va a decir “Pending Ledger Review”. Clickea ambos botones en la parte de arriba de tu dispositivo y tu dispositivo te va a avisar a “Use Wallet To View Accounts”. Una vez que aparezca este mensaje, puedes continuar y clickear en “Continue”.
 	Una vez que aprietes continuar, la llave pública va a aparecer en la pantalla de tu Ledger. Aprueba la llave pública y confirma la operación en el Ledger.
 	Luego vas a ser incitado a agregar una llave en tu billetera ledger. Una vez que clickees en “Approve” en el ledger. Una vez que la operación ha sido aprobada, tu cuenta ha sido creada exitosamente.


Staking Utilizando La Billetera NEAR
La red de NEAR es utilizada por usuarios que operan nodos, conocidos como validadores. La comunidad de NEAR soporta validadores mediante staking. Los validadores mantienen un mínimo de cantidad stakeado, permitiéndo a ellos mantenerse como validadores. Los que poseen NEAR token pueden stakear en cualquier validador que elijan, permitiéndoles a ellos obtener recompensas de la red. La billetera NEAR tiene una interfaz de usuario de staking que está construida directamente dentro de la aplicación web.

Vamos a entender cómo hacer stake utilizando la billetera NEAR. staking usando la billetera NEAR es un proceso bastante directo y comprende los siguientes pasos.

 	Elige la opción de stake desde la barra de navegación. Si estás en el móvil, entonces vas a encontrar la opción en tu menú desplegable.
 	Elige el botón que dice “Staking Validator”.
 	Elige el validador de tu preferencia de la lista de validadores. Recuerda, como un titular de tokens NEAR; puedes stakear con cualquier validador de tu elección. 
 	Una vez que hayas confirmado tu elección, puedes seleccionar “Stake with Validator”.
 	Una vez que hagas click en “Stake with Validator”, vas a ser incitado a colocar el número de tokens NEAR con los que te gustaría hacer stake. Una vez que elijas el número de tokens, haz click en “Submit Stake”.

Para completar el proceso de staking, tienes que confirmar dos transacciones - una transacción para seleccionar el validador y otra transacción para depositar y stakear con el validador elegido.
Como hacer Unstake de tu Stake
Sacar lo que pusiste en staking es extremadamente simple. Simplemente ve hacia el panel de staking y selecciona el validador elegido previamente. Una vez seleccionado, clickea en “Unstake” y confirma. Vas a poder acceder y sacar tu stake solamente luego de que hayan pasado 36-48 horas. Para sacar tu stake, simplemente ve hacia la página del validador y clickea “Withdraw”. 
Monitorear la Información del Staking
La interfaz de la billetera de NEAR te permite elegir validadores y también te permite ver información tal como

 	El total de la cantidad stakeada - Esto te permite ver el total del número de tokens NEAR con validadores que están acumulando recompensas.
 	Recompensas sin reclamar - Estas son recompensas que han sido ganadas pero no han sido reclamadas del pool de staking.
Estas recompensas sin reclamar son automáticamente stakeadas de nuevo, incrementando el total stakeado y las recompensas compuestas.
 	Tokens para retirar - Estos son tokens que han sido stakeados y están listos para ser retirados.
 	Tokens pendientes para liberar - Estos tokens sacados del stake están todavía pendientes de liberación en una ventana de tiempo de 36 a 48 horas.

Tarifas de validador - Las tarifas de validador son pagadas a validadores para hacer stake en tu nombre. Las tarifas de validador son cargadas con las recompensas ganadas y no contra el balance de tokens stakeados hacia los validadores.
Conectar tu billetera NEAR a una dApp en NEAR
Conectar tu billetera NEAR hacia una aplicación descentralizada en NEAR es extremadamente simple. Tienes que ir hacia Awesome NEAR y elegir una de las múltiples dApps (Aplicación descentralizada) disponibles. Clickea en la aplicación deseada, y vas a ver una opción “Sign In With NEAR Wallet” en la interfaz. Una vez que clickeas, vas a obtener un mensaje en tu pantalla declarando que la dApp está pidiendo permisos para acceder a tu cuenta. Clickea en “Allow”, y la wallet va automáticamente a ser conectada con la dApp.
Otras Billeteras Respaldadas por NEAR
Trust Wallet
La Trust Wallet es una billetera no-custodial y descentralizada que permite a sus usuarios guardar sus criptomonedas. Los activos son guardados en una billetera digital accesible solamente por el usuario, convirtiéndose en una manera segura y eficiente de guardar tus activos digitales. Trust wallet se enfoca en la simplicidad y facilidad de uso. La billetera es open-source (fuente abierta/código libre), dirigida por la comunidad, de múltiple divisa, capaz de guardar casi todas las criptomonedas. La billetera provee a los usuarios con una manera conveniente de administrar sus criptomonedas y les permite controlar sus llaves privadas completamente.



La billetera fue adquirida por Binance y es la billetera oficial del exchange de Binance. Esta billetera permite a los usuarios retener el control completo de sus activos y de sus llaves privadas guardadas en el dispositivo del usuario. 

Los desarrolladores también pueden construir dApps, sin ningunas complicaciones tales como detalles de implementaciones de bajo nivel. La billetera también respalda staking dentro de la billetera, lo cual significa que los usuarios pueden ganar recompensas en cualquier token Proof of Stake o Proof of Stake Delegado que soporte la wallet. Trust Wallet permite a los usuarios ganar recompensas y continuamente agregar más stablecoins (monedas estables) y otras criptomonedas.
Creando tu Trust Wallet
Crear tu wallet utilizando Trust Wallet es un proceso simple

 	Ve a la página oficial de Trust Wallet 
 	Descarga e instala la aplicación, abre la aplicación y selecciona “Create a new wallet”



 	El paso siguiente es guardar tu frase semilla. Anota tu frase semilla de 12 palabras, y asegúrate de que hayas escrito las palabras en el orden exacto.
 	Eso es todo. Tu Trust Wallet ha sido creada

También puedes stakear NEAR con tu Trust Wallet simplemente siguiendo los pasos mencionados debajo

 	Abre tu Trust Wallet y copia la dirección NEAR
 	Inicia sesión en https://near.github.io/account-lookup/. 
 	Coloca tu dirección NEAR y obtiene los detalles de tu cuenta. Una vez que tengas los detalles, debes guardarlos.
 	Luego de completar el paso anterior, abre Staking.Dokia.Cloud. Luego de abrir el link, selecciona NEAR desde las opciones disponibles
 	Una vez que seleccionas NEAR, todos los pools de staking disponibles corriendo en los nodos NEAR van a ser presentados. Elige el pool que más se adapte para ti. 
 	Ahora vas a tener que seleccionar tu método de autorización para stakear en la pool.
 	Para hacer esto, haz click en “continue to web interface” y selecciona Mnemonic como método de autorización. Una vez esto sea seleccionado, coloca la mnemónica de tu Trust Wallet.
 	Coloca los detalles de tu cuenta que has guardado anteriormente.
 	Luego de este paso, coloca cuantos tokens NEAR te gustaría stakear.
 	Firma la transacción, y los tokens stakeados van a ser enviados al contrato inteligente del pool.
 	Si deseas remover tu stake, simplemente ve hacia https://staking.dokia.cloud/addresses y haz click en “remove.”

En Conclusión
El ecosistema de NEAR permite a los usuarios acceder a una gran cantidad de NFTs, aplicaciones descentralizadas, y soluciones DeFi. NEAR se enfoca en los defectos de blockchains tales como Ethereum, ofreciendo soluciones a problemas de larga data tales como congestiones de red, altas tarifas de gas, y tarifas de procesamiento lento. La billetera de NEAR permite a los usuarios crear e interactuar con cuentas de NEAR, permitiendo a usuarios guardar sus tokens NEAR, y stakearlos para ganar recompensas. Esperamos que ésta guía provea un poco de claridad sobre el funcionamiento de la billetera NEAR y de sus casos de uso.

### Web 3 là gì?

Near là một nền tảng phát triển phi tập trung nhằm mục đích xây dựng một hệ sinh thái Web3 lành mạnh thông qua nền tảng dễ sử dụng và có thể mở rộng. 

Hôm nay, chúng ta hãy tìm hiểu ý nghĩa của Web3 và những gì Web3 có thể làm với hệ sinh thái.
Nhu cầu cho Web3

Image Credit
Web1 được Berners-Lee tạo ra vào những năm 1990, và kể từ đó nó đã trở thành nền tảng của Internet ngày nay. Dưới đây là một số trụ cột cốt lõi của Web1:

 	HTML(HyperText Markup Language) - Ngôn ngữ đánh dấu siêu văn bản, là ngôn ngữ định dạng ra web.
 	URL(Uniform Resource Locator) - Bộ định vị tài nguyên thống nhất - một địa chỉ duy nhất để xác định một tài nguyên trên web.
 	HTTP(HyperText Transfer Protocol) - Giao thức truyền tệp siêu văn bản - cho phép bạn truy xuất các tài nguyên trên web.

Mặc dù giai đoạn này thực sự mang tính đột phá, nhưng các trang web tĩnh khá khác so với các trang web được thiết kế chuyên nghiệp mà chúng ta đang sử dụng ngày nay. Ngoài ra, trong khi các trang web 1.0 không có tính tương tác, các khái niệm mới như “email” đã trở thành một phần quan trọng trong cuộc sống của chúng ta hiện tại.

Trong vài thập kỷ qua, chúng ta đã thấy sự trỗi dậy của Web2. Các trang web hiện nay biết tương tác với người dùng. Hãy nghĩ về những công ty đã làm nên tên tuổi trong vài thập kỷ qua như Meta, TikTok, Airbnb, Uber, v.v. Điểm chung nào gắn kết họ với nhau? Họ phát triển mạnh trên nội dung hoặc tài nguyên do người dùng tạo. Về bản chất, đó là bước đột phá lớn mà chúng ta đã thấy trong thời đại này. Người ta chỉ có thể đạt được khả năng mở rộng thực sự bằng cách trao quyền cho người dùng tham gia tích cực vào hệ sinh thái.

Tuy nhiên, Web 2.0 phát triển mạnh chỉ dựa trên sự tập trung. Hãy nghĩ về số lượng các cuộc điều trần trước quốc hội mà các CEO của Google, Meta và Twitter đã phải trải qua để giải thích tất cả những gì họ làm với dữ liệu người dùng. Đặc biệt, Meta đã phạm tội chiếm đoạt dữ liệu để bán cho Cambridge Analytica, nền tảng này vận hành các chiến dịch tranh cử tổng thống Hoa Kỳ.
Web3 là gì?
Sự phát triển tiếp theo của web và internet sẽ là Web3, được xây dựng dựa trên các nguyên tắc cốt lõi nhất định. Chúng ta hãy xem xét từng cái một.

Decentralization - Phi tập trung

Có thể nói một cách an toàn rằng phi tập trung là nguyên tắc cốt lõi của cuộc cách mạng Web3. Ý tưởng là sẽ không có cơ quan quyền lực trung ương hoặc hội đồng quản trị tập trung kiểm soát sự phát triển và hướng đi của công ty. Trong thế giới ngày nay, kiểm duyệt nền tảng đã trở thành một vấn đề quan trọng. Có vẻ như trừ khi bạn theo một hệ tư tưởng chính trị cụ thể, suy nghĩ của bạn cuối cùng sẽ bị xóa khỏi nền tảng truyền thông xã hội. Các công ty cố tình làm cho hồ sơ cụ thể “khó tìm” để giảm sự lan truyền của một số hệ tư tưởng. Twitter đã công khai thừa nhận rằng họ có xu hướng kiểm duyệt hồ sơ của cánh hữu. Mục tiêu chính của Web3 sẽ là khả năng chống kiểm duyệt do tính phi tập trung hóa và phân quyền mang lại.ip resistance brought forward by decentralization.

Trustlessness - Không cần tin cậy

Đây là một phần mở rộng của điểm phân quyền. Trong Web 2.0, bạn sẽ phải tin tưởng các bên thứ ba với các thông tin nhạy cảm của mình. Thông thường, các công ty này đã lạm dụng dữ liệu theo ý của họ, dẫn đến những vụ bê bối lớn (Facebook và Cambridge Analytica). Giờ đây, với khả năng phi tập trung, sẽ không có một cơ quan nào ở trung tâm của công ty kiểm soát tất cả các dữ liệu quan trọng. Các ứng dụng Web3 sẽ chạy bằng công nghệ blockchain và mạng ngang hàng để đảm bảo khả năng không cần tin cậy vào bên thứ 3 (trustless) và khả năng phi tập trung.

Composability - Khả năng kết hợp

Một trong những khía cạnh hấp dẫn của Web3 là tính liên kết và khả năng kết hợp của nó. Chúng ta đã thấy điều này trong hệ sinh thái DeFi (Tài chính phi tập trung) và IoT (internet vạn vật). Trong DeFi, nhiều nền tảng có thể kết nối với nhau và tạo ra một hệ sinh thái liên kết chặt chẽ, trong đó bạn có thể sử dụng rất nhiều công cụ tài chính.

AI - Trí tuệ nhân tạo

Web3 sẽ sử dụng AI và Máy học (ML) để trao quyền cho hệ thống của mình nhằm tạo ra kết quả nhanh hơn và phù hợp hơn.




	

	
	
		
			
				Quiz: Đăng nhập vào website với tài khoản Facebook là ví dụ của: 
			
		

		
					

		
			
			
			
			Web1.0
		
			
			Web2.0
		
			
			Web3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Các trường hợp sử dụng của Web3
Web3 có một số trường hợp sử dụng, với tiền tệ kỹ thuật số, NFT và các thực thể khác trong không gian tiền điện tử và blockchain trở nên quan trọng đối với Web3. Các DAO (tổ chức tự trị phi tập trung) cũng là một trường hợp sử dụng quan trọng trong Web3, sử dụng các token để giúp các quyền ra quyết định trở nên công bằng và khách quan hơn.
DAO - Các tổ chức tự trị phi tập trung
Kiến thức cơ bản về các DAO và cách chúng hoạt động rất hữu ích trong việc hiểu và đóng góp cho Web3. DAO là một thực thể không yêu cầu cơ quan trung ương hoạt động. Thay vào đó, nó được thúc đẩy bởi cộng đồng của chính nó và cung cấp quyền tự chủ hoàn toàn cùng tính minh bạch. Hợp đồng thông minh chi phối tất cả các quy tắc cơ bản; các hợp đồng cũng thực hiện bất kỳ quyết định nào được cộng đồng nhất trí, với tất cả các quy trình, bao gồm cả biểu quyết hoặc đề xuất, được công bố công khai để xác minh dễ dàng. Về bản chất, một DAO được quản lý bởi những thành viên cá nhân là một phần của cộng đồng, tập thể đưa ra các quyết định quan trọng liên quan đến dự án, từ việc phân bổ tài nguyên tới việc nâng cấp.

Một nhóm thành viên cộng đồng cốt lõi thiết lập các quy tắc cho DAO thông qua các hợp đồng thông minh, đặt ra khuôn khổ của DAO. Các hợp đồng thông minh này có thể xác minh công khai, cho phép các thành viên cộng đồng hiểu từng bước liên quan đến hoạt động của DAO. Các thành viên cộng đồng có thể tạo đề xuất, sau đó toàn bộ cộng đồng bỏ phiếu cho đề xuất đó. Sau khi đề xuất đạt được mức độ đồng thuận trong cộng đồng, đề xuất đó sẽ được chấp nhận và thực thông qua hợp đồng thông minh.

Bức tranh tổng quan của DAO có thể được chia thành các nhóm khác nhau như Protocol DAO, DAO cho đầu tư, cho dịch vụ, cho xã hội, cho tài trợ, cho việc thu thập và cho việc truyền thông. Một số DAO nổi bật mà bạn có thể theo dõi là MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO (Astro DAO), DAOhaus, Opolis, MolochDAO và BanklessDAO.




	

	
	
		
			
				Quiz: Berners-Lee sáng lập ra: 
			
		

		
					

		
			
			
			
			Web1.0
		
			
			Web2.0
		
			
			Web3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tipping - Tiền boa
Nền kinh tế phi tập trung cung cấp sự hợp tác toàn cầu. Cho phép người tham gia kiểm soát cách họ làm việc, phân bổ thời gian và chuyên môn của mình thông qua một số công cụ đã tồn tại và đang phát triển giúp trao quyền và cáchlàm việc của họ.

Tipping là một trong những phương pháp giúp phát triển cộng đồng web3 bằng cách khuyến khích sự tham gia vào phát triển. Trước khi tiếp tục, điều quan trọng là phải hiểu “Tipping” là gì. Trong thế giới thực, chúng ta tip cho người cung cấp dịch vụ. Tip thường được đưa ra cho quản gia, nhân viên nhà hàng, người giao hàng và những cá nhân khác, những người giúp ta hoàn thành hoặc thực hiện một số nhiệm vụ nào đó. Trong Web3, Tipping hoạt động trên cùng một mục đích, với sự khác biệt chính là việc chuyển tiền diễn ra trên blockchain.

Trong Web3, các thành viên cộng đồng có thể được tip cho nhiều đóng góp khác nhau, chẳng hạn như đóng góp viết code cho một dự án, trả lời câu hỏi, viết một bài báo hoặc khi thành viên cộng đồng đóng góp kiến ​​thức chuyên môn của họ cho một dự án. Tipping có thể được thực hiện dưới mọi hình thức, từ airdrop NFT và token quản trị đến tip bằng ETH, USDC hoặc bất kỳ loại tiền điện tử nào khác. Tipping cho những người đóng góp giúp xây dựng lòng tin trong cộng đồng, đảm bảo rằng những người tham gia vẫn ở lại dự án và giúp thiết lập cách hoạt động ​​cho giao thức trong tương lai.

Hiện tại, bạn có thể nhận được các tip bằng NEAR token tại Twitter và Telegram của LNC
Đăng nhập với Ví của bạn
Một điều thú vị khác mà Web3 thay đổi là thủ tục đăng nhập. Quay lại những ngày của Web1, có hai cách để bạn có thể đăng nhập vào tài khoản trang web - qua email hoặc thông qua một tài khoản duy nhất được tạo riêng cho trang web đó. 

Sau đó, trong giai đoạn Web2, bạn có thể đăng nhập vào mọi thứ bằng tài khoản Google hoặc tài khoản Facebook của mình. Mặc dù điều này là thuận tiện, nhưng điều này vẫn có một thiếu sót lớn - sự chuyển đổi giá trị. Bạn vẫn phải cung cấp chi tiết các khoản thanh toán của mình một cách riêng biệt để thực hiện mua hàng.

Giờ đây, với Web3, bạn có thể chỉ cần kết nối với các trang web khác nhau bằng ví tiền điện tử của mình. Điển hình là trong OpenSea, bạn cần kết nối trực tiếp với MetaMask của mình và thực hiện mua hàng. Trên thực tế, tại LearnNEAR Club, bạn PHẢI đăng nhập bằng ví Near để tham gia vào các hoạt động (L)Earn - Học và Kiếm tiền.



 

Giao dịch với người dùng Web3 cho phép các dApp ngay lập tức truyền không chỉ dữ liệu mà còn cả giá trị tiền tệ mà không cần bất kỳ bên trung gian nào tham gia!
Vai trò của NEAR Protocol trong Web3
Với nền tảng có thể mở rộng và dễ sử dụng, NEAR Protocol cung cấp một nền tảng cho phép bạn tạo các ứng dụng DeFi và NFT.

DeFi TVL của NEAR chỉ khoảng $141,72 triệu. Đây là một hệ sinh thái rất trẻ và hiện đang phát triển với tốc độ nhanh chóng.



Ứng dụng DeFi chiếm ưu thế nhất, chiếm hơn 80% TVL tổng thể là Ref Finance.

Ref Finance có một số điểm tương đồng với Uniswap V2, ngoài ra nó hỗ trợ nhiều loại nhóm thanh khoản, phí có thể cấu hình và hoàn toàn thuộc sở hữu bởi cộng đồng. Ref cũng là nền tảng DeFi đầu tiên trên NEAR. Mục đích chính của Ref là tập hợp DEX, các giao thức cho vay, công ty phát hành tài sản tổng hợp và nhiều hơn nữa.

NEAR gần đây đã tung ra một quỹ tài trợ khổng lồ trị giá 800 triệu đô la nhằm mục đích cụ thể là tạo ra một hệ sinh thái DeFi lớn hơn và lành mạnh hơn. Quỹ có một số mục chính, bao gồm:

 	100 triệu đô la cho các công ty khởi nghiệp
 	Quỹ 100 triệu đô la cho từng khu vực (regional fund)
 	250 triệu đô la tài trợ hệ sinh thái, được phân phối trong bốn năm.

Đọc phần này để biết thêm về DeFi trên Near.

Trên mặt trận NFT, một số dự án đã được tạo trên NEAR như Mintbase, Paras, Hip Hop Heads, v.v. 

Mintbase là nền tảng NEAR NFT phổ biến nhất. Nó cho phép mọi người tạo NFT và cung cấp nó để bán trên thị trường của mình hoặc trên các thị trường NFT như OpenSea. Người tạo NFT có thể tạo(mint) một hợp đồng thông minh và giới hạn khả năng chuyển nhượng của các token được tạo, giúp ngăn chặn gian lận hoặc chuyển nhượng bất hợp pháp NFT. Mintbase tập trung vào việc tạo ra trải nghiệm tạo NFT độc đáo, đó là lý do tại sao Mintbase hỗ trợ các tài sản số khác nhau. Điều này trái ngược với các nền tảng cạnh tranh tập trung vào một mục NFT cụ thể. 
Mặt trái - Web3 bị thổi phồng quá mức?
Gần đây, meme này đang nổi tiếng trên Twitter, nhận được bình luận từ những người của công chúng như Jack Dorsey(Founder Twitter) và Elon Musk.


Image credit
Hiện tại, các ứng dụng Web3 đang nhận được rất nhiều sự chú ý đối với các nhà đầu tư mạo hiểm ở Thung lũng Silicon. Điều này dẫn đến một điểm tranh cãi chính. Với rất nhiều bên liên quan khó tính, liệu các ứng dụng Web3 sẽ phi tập trung theo ý nghĩa chân thật ban đầu? Dorsey và Musk không tin như vậy. Tuy nhiên, sẽ rất thú vị để xem điều này sẽ ra sao trong tương lai! 




	

	
	
		
			
				Quiz: Điều nào sau đây không yêu cầu tổ chức tập trung thực hiện? 
			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook
		
	
		

		
		
			
				Correct!
				Wrong!

### Dapplets × Exemplar NEAR

Dapplets × Exemplar NEAR é um Dapplet (um aplicativo de Realidade Aumentada) que pode analisar postagens do Twitter e armazená-las no contrato NEAR. Ele também pode exibir seus tweets salvos na página de sobreposição. Parte inferior do formulário.
1. Introdução
Dapplets  – aplicativos que interagem com páginas da web, aumentam-nas inserindo diferentes widgets, analisam os dados das páginas e adicionam algumas novas funcionalidades. Eles podem melhorar a experiência do usuário ao usar mídias sociais, serviços de vídeo e outras fontes.

Dapplets usam a extensão que estamos criando. Esta extensão oferece uma API simples para desenvolvedores de dapplets e grandes habilidades para a comunidade de dapplets. Nossa plataforma é descentralizada. Usamos redes NEAR e Ethereum para nossos registros e contratos. Também usamos armazenamentos descentralizados, como Swarm, IPFS e SIA para hospedagem de código de dapplets e multimídia.

Para usar nossa plataforma, primeiro você precisa instalar a  Extensão Dapplets . Atualmente está na fase alfa e não foi publicado no Google Chrome ou em qualquer outra loja. Para instalá-lo siga estes passos:

 	Abra um dos seguintes navegadores: Google Chrome, Firefox, Brave, Tor.

As etapas a seguir são descritas para o Google Chrome. As etapas podem diferir em outros navegadores.

 	Baixe a  extensão do navegador de Dapplets.
 	Abra  chrome://extensions  em uma nova guia.
 	Ative o  modo Desenvolvedor  e pressione  F5  para atualizar a página. 
 	Arraste e solte o arquivo baixado na página de extensões. A extensão será instalada automaticamente.Se você estiver usando o Ubuntu ou possivelmente outro sistema operacional Linux, a extensão Dapplets pode desaparecer das extensões do Chrome após reiniciar o PC. Para evitar isso, descompacte o arquivo e use o  Load unpacked botão para adicionar a extensão.
 	Clique no ícone da extensão Dapplets na barra de extensão. Experimente o exemplo Dapplets × NEAR.

2. Tutorial
Vamos estudar como esse dapplet funciona e por que o Dapplet é uma plataforma amigável com NEAR.

O objetivo deste exemplo é mostrar a interação entre NEAR e Dapplets. Se este é o seu primeiro encontro com os Dapplets, recomendamos que experimente primeiro a nossa  documentação. Ele contém vários exercícios que explicam como criar dapplets e adaptadores, dos mais simples aos mais complexos. Recomendamos ver os  exemplos ex01  e  ex04  que descrevem como criar os dapplets e os dapplets mais básicos com uma sobreposição. O conhecimento que você obterá facilitará a compreensão do exemplo atual.

O código inicial para este exemplo está em uma ramificação separada: exercício

Você pode clonar este repositório. Não funcionará diretamente. Tente seguir os passos para iniciá-lo.

Vejamos a estrutura. Existem três componentes: dapplet, overlay e contract.

Dapplet  é o ponto de entrada do aplicativo. Ele usa adaptadores para interação com páginas da web, definindo contextos para aumentar e widgets para inserir. Você pode encontrar as funções principais da extensão dentro de um dapplet. Usamos TypeScript em nosso projeto.

Definimos o Overlay  como um local onde um usuário pode fazer algo com os dados analisados, conectar-se às funções do dapplet principal por meio da ponte do dapplet  e gerenciar os parâmetros de aumento. É uma parte importante do aplicativo, mas é executado em outro ambiente e é publicado como um pacote separado. Na maioria dos casos usamos o React como um dos frameworks mais populares. Mas você pode usar uma estrutura de sua preferência ou JavaScript puro ou TypeScript.

O contrato não se conecta diretamente com outros módulos e pode estar localizado fora do dapplet. No entanto, este contrato NEAR simples é criado especificamente para este dapplet. É por isso que é conveniente colocá-lo na estrutura do aplicativo.

Vamos dar uma olhada em cada módulo.
2.1. Dapplet
Olhe para o  /dapplet/src/index.ts.

Inicialmente criamos uma classe injetável com decorador @Injectable e usamos @Inject para adicionar o Adaptador do Twitter como o adapter variável de classe. Crie também o  método activate. Ele é executado quando o adaptador selecionado encontra um contexto específico e está carregando. Ele conterá toda a lógica principal.



Adicione o botão a cada tweet. Coloque este código em activate:



Olhe para o código. Obtemos o widget button do adaptador. Em seguida, execute o método do adaptador attachConfig. Ele recebe um objeto com os nomes dos contextos, que serão utilizados, como chaves. Os valores são funções que recebem o contexto analisado como o único argumento e retornam um widget ou um array de widgets. Você também pode retornar  null,  false ou  undefined.

Widget é uma função que recebe um objeto que consiste em estados de widget. Os parâmetros de estado são descritos na documentação dos adaptadores. Você pode encontrar a documentação do Adaptador do Twitter aqui. No nosso caso, adicionamos uma imagem ao botão e à dica de ferramenta. exec é uma função que é executada quando clicada. Agora apenas mostramos o contexto analisado no console.

Execute o dapplet:


⚠️ Como o navegador está bloqueando páginas com certificados de segurança problemáticos, acesse  https://localhost:3001/dapplet.json  quando o aplicativo estiver em execução e concorde em executar no modo inseguro.
Abra a extensão. Vá para a guia Desenvolvedor e ative o servidor de  desenvolvimento:  https://localhost:3001/dapplet.json.



Ative a guia Dapplets. Você verá o emblema de dev perto do nosso dapplet. Ligue-o.



Agora você pode ver botões adicionais em nossos tweets. Clique no botão e abra o console. Você verá o contexto analisado do tweet.



 Você conseguiu! Parabéns!!! Volte para o código.

Queremos mostrar os dados analisados ​​não no console, mas para os usuários. Usaremos uma sobreposição para isso. Mas antes de implementar a sobreposição, adicione a lógica de interação entre o dapplet e a sobreposição ao dapplet.

Vamos alterar nosso código. Adicione a variável  _overlay de classe privada do tipo  any. No  activate adicione o seguinte código:



A função principal  Core.overlay (problemas de digitação serão corrigidos em breve) recebe um objeto com o nome da sobreposição e um título da sobreposição  e retorna o Overlay objeto que salvamos na  _overlay variável.

Vamos adicionar o método openOverlay à classe:



Neste exemplo, chamamos o método send de overlay. São necessários dois argumentos: o nome desses dados e os dados a serem enviados para a sobreposição.

Adicione  openOverlay à função exec e passe o contexto analisado para a sobreposição. Este é o código atual do dapplet:



Abra o manifesto  ./dapplet/dapplet.json.


⚠️ Como o navegador está bloqueando páginas com certificados de segurança problemáticos, acesse  https://localhost:3000  quando o aplicativo estiver em execução e concorde em executar no  modo inseguro.
Aqui vemos a URL da sobreposição nomeada  'overlay' que será usada no modo de desenvolvedor. Durante a publicação do dapplet no registro, a sobreposição será publicada no armazenamento descentralizado.

Também vemos o Adaptador do Twitter nas dependências. Estamos usando a versão 0.9.0 no exemplo.

Vamos para a sobreposição
2.2. Sobreposição
Como mencionamos anteriormente, a sobreposição pode ser criada da maneira que você quiser. Usamos  React  na maioria dos nossos projetos. Não estaremos analisando todo o código de sobreposição, mas apenas os pontos importantes para nossos aspectos de arquitetura.

Para interação com o dapplet, instale o pacote npm  @dapplets/dapplet-overlay-bridge:



Para obter os dados do dapplet, precisamos da classe Bridge  na parte de sobreposição. Veja o módulo  ./overlay/src/dappletBridge.ts. Aqui está o método onData em que assinamos o  'data' evento, que descrevemos no dapplet.



Então nós o usamos no módulo  App.tsx.



Agora salve as alterações e recarregue a página do Twitter. Ao clicar no botão, você verá a sobreposição com os dados do tweet selecionado.



Isso é legal! Mas nosso objetivo é salvar esses dados na blockchain NEAR e recuperá-los. Então vamos ver o contrato.
2.3. Contrato Inteligente NEAR
Veja o módulo  ./contract. Existe um contrato inteligente NEAR simples escrito em AssemblyScript com  create-near-app.

Em  ./contract/assembly/index.ts vemos um  PersistentUnorderedMap chamado  tweetsByNearId. Ele armazena uma matriz de dados de tweets serializados com o ID do usuário atual. Possui métodos para salvar, remover e recuperar tweets salvos.

Você pode encontrar todos os dados necessários sobre como escrever, testar e implantar contratos inteligentes NEAR na documentação oficial e nos cursos e guias do Learn NEAR .

Vamos ver como se conectar ao contrato inteligente e usar seus métodos no dapplet.

Adicione o seguinte código ao  activate método do  ./dapplet/src/index.ts módulo:



Existe um  Core.contract método que recebe 3 parâmetros: nome da rede ('near' ou 'ethereum'), nome do contrato e objeto com visualização e métodos de alteração.

Agora vamos disponibilizar os métodos de contrato na sobreposição. Para passar os métodos pela ponte de dapplets , adicione uma função listen  à chamada de sobreposição. Não tenha medo, apenas copie e cole este código 🙂



As três últimas funções assíncronas passam nossos métodos de contrato para a sobreposição. As primeiras quatro funções precisam emparelhar a carteira com o dapplet. Para obter o objeto Wallet  usamos o  método Core.wallet , com parâmetros nomeados  name ( near ou  ethereum) e  network. A carteira tem métodos  isConnected,  connect e  disconnect parâmetro  accountId.

O próximo passo é mudar  ./overlay/src/dappletBridge.ts. Temos que tornar as funções que foram descritas no dapplet, disponíveis no overlay. Copie o seguinte código para a  Bridgeclasse:



Agora podemos usar métodos de contrato nos módulos de sobreposição. Podemos autorizar o dapplet com a carteira testnet NEAR e salvar os dados dos tweets selecionados no contrato inteligente. Também podemos ver nossos dados salvos na sobreposição.

Complete todo o código confirmado no arquivo  ./overlay/src/App.tsx. Salve as alterações e recarregue a página do Twitter.



A cereja do bolo será a adição da capacidade de visualizar tweets salvos sem analisar novos. Para isso, basta adicionar o  Core.onAction método ao  activate in  ./dapplet/src/index.ts e passar a função de abrir o overlay para ele.

Core.onAction(() => this.openOverlay());

Agora você verá o ícone inicial próximo ao nome dos dapplets .



Um clique no botão abre uma sobreposição com tweets salvos.



Parabéns a todos que chegaram ao final do tutorial! Esperamos que tenha dado tudo certo.

Aqui está o resultado: dapplets -near-example

Se algo não deu certo para você, ou você ainda tem alguma dúvida, fique à vontade para nossos bate-papos no Discord e no Telegram .

Obrigado pelo seu tempo. Esperamos que esse novo conhecimento seja útil e você possa desenvolver aplicativos impressionantes e bem-sucedidos na plataforma Dapplets usando os recursos do protocolo NEAR.🚀✨

Contatos:

Web:  dapplets .org

Docs:  docs.dapplets .org

GitHub:  github.com/dapplets

Discord: discord.gg/YcxbkcyjMV

Telegrama:  t.me/dapplets

Twitter: @dapplets project

### ANÁLISE DA NEAR Live Contract -	2ª PARTE: Staking Pool Contract

Introdução:
Olá, Eu sou o Eugene e esta é a segunda parte da série de análises da live contract, e hoje vamos analisar o staking pool contract que está sendo utilizado neste exato momento para proteger o sistema de prova de participação do “NEAR Protocol”. Basicamente todos os validadores que atualmente estão em marcha na NEAR Protocol estão sendo executados em nome deste contrato. Eles não controlam por si mesmos a conta onde está retida a quantia de tokens da NEAR requeridos para prova de participação. Em vez disso, o contrato que retêm essa quantia, somente proporciona um grupo de staking e executa seus nodes. Hoje examinaremos a fundo esse contrato. Nos contratos principais temos uma staking pool contract  que é um pouco mais complicada que o contrato que analisamos previamente (Voting Contract). Assim que hoje vamos nos focar mais na lógica e menos na near_bridgen e detalhes específicos da Rust, mas isso provavelmente envolverá um pouco mais de conhecimento do protocolo NEAR. Aqui temos o staking pool contract no NEAR Github. Abaixo está o vídeo original no qual está baseado esta guia.


lib.rs
Constructor Structure


Como sempre, o contrato começa desde a estrutura principal. E neste caso é uma estrutura de staking contract. Como pode-se ver, aqui temos near_bidgen, BorshSerialize e there’s near_bindgen,BorshSerialize e BorshDeserializeand. A estrutura, tem agora, muitos mais campos que anteriormente, também tem muitos comentários sobre tais campos e provavelmente muitos deles já estejam atualizados. A lógica do contrato de staking pool, nos permite o seguinte:
Basicamente, qualquer pessoa pode depositar uma determinada quantidade de Tokens da NEAR em uma staking pool e delegá-los ao staking pool, sendo parte do staking. Isso nos permite agrupar saldos de várias pessoas (nós a chamamos contas) em uma grande stake (participação) e desta forma este grande grupo pode então se qualificar para obter a licença de validador. NEAR Protocol atualmente tem um número limitado de licenças para cada shard, sendo no máximo cem (100) licenças de validador. Você pode aspirar a essas licenças da seguinte maneira: Se ao dividir o total de tokens por cem (100) o resultado deve ser a quantia mínima requerida para uma só licença. Com a excepção de que é um pouco mais complicado de envolver a remoção dos stakes que não estão qualificados para conter essa quantia mínima, etcetera. Esse contrato é basicamente um contrato autônomo sem nenhuma chave de acesso e controlado pelo seu dono. Em tal caso o proprietário é instruído no método de iniciação.
Método de Iniciação


Então vamos ao método de inicialização. Ele tem três sub-rotinas e a primeira é o owner_id, que é o id da conta do proprietário. O proprietário tem várias permissões neste contrato que permitem que o contrato execute ações que não estão disponíveis para o restante das contas. Um desses métodos era votar em nome do staking pool para o contrato de votação que discutimos na última vez. Assim, o proprietário pode solicitar o método de votação.





Verificamos então que o predecessor (predecessor_account_id) seja igual ao dono já que este método só pode ser solicitado pelo mesmo.



Então, o que o método de votação faz é verificar se o método foi solicitado unicamente pelo proprietário e, em seguida, verificar a coerência, mas isso não é importante neste momento.



Então o contrato é o dono, e esse dono ele tem permissões extras e pode fazer certas coisas. Portanto são necessários mais alguns campos: habilitar a stake_public_key. Ao fazer staking no protocolo NEAR, você precisa fornecer uma chave pública que será usada pelo node validador para assinar mensagens em nome do node validador. Esta chave pública pode ser diferente de qualquer outra chave de acesso, e a ideia é que essa chave de acesso deva ser diferente de qualquer outra chave de acesso, pois seu node pode ser executado em um data center que possivelmente seja vulnerável a alguns ataques.  E no caso de um ataque o máximo que poderia ocorrer é algum dano na net mas não na sua conta. Seus fundos não poderão ser roubados e você pode substituir essa chave mais fácil do que você substitui uma chave de acesso inválida. Finalmente, a terceira sub-rotina que o contrato leva é o reward_fee_fraction inicial. Essa é a comissão que o proprietário do staking pool recebe para executar o node validador.



Esta é uma fração que tem um numerador e um denominador, e permite, por exemplo, que você diga basicamente “Eu pego 1% das recompensas por administrar esse pool específico”. Digamos que você tenha 1.000.000 tokens, os quais adquiriram alguma recompensa, e digamos que haja uma recompensa de 10.000 tokens, então o proprietário receberá 1% disso, que será de 100 tokens. Os floats têm um comportamento imprevisível quando você os multiplica. Por exemplo, com frações, você pode calcular com um maior número de bits. Por exemplo, a maneira como você faz a divisão, é primeiro multiplicar o valor que é u128 por um numerador (isso pode desbordar em u128),  e é por esse motivo que o fazemos em u256. Então você divide pelo denominador que deve trazê-lo abaixo de u128 novamente. Isso lhe dá uma maior precisão do que o float64 que não pode operar com a mesma precisão do u128 bits, haverá alguns erros de arredondamento ou de precisão ao fazer as contas. Portanto, você precisa de floats de maior precisão, que não são muito diferentes das contas que simulamos com u256. O Solidity originalmente não suportava floats, e ao princípio nós também não demos suporte, mas isso gerou alguns problemas em torno da formatação de strings no Rust para depuração, e portanto decidimos que não é um problema suportar floats, especialmente porque o padronizamos no lado vm. O maior problema com os floats era o comportamento indefinido em torno de certos valores de cargas. Por exemplo, quais outros bits contêm quando você tem um float infinito? Nós padronizamos isso e agora eles são independentes mas de plataforma equivalentes. Portanto, já não há nenhum problema em usar floats em nosso ambiente vm. 



A prática normal ou standard com init é que primeiro verificamos que não exista a condição, logo verificamos a entrada. A primeira coisa que faremos, é confirmar que a fração é válida e verificar que o denominador não seja zero. Em seguida, temos outra instrução que verifica se o numerador é menor ou igual ao denominador, o que significa que a fração é menor ou igual a 1. Isso é de importância para evitar alguns erros lógicos. Em seguida verificaremos que a conta é válida. Isso é de importância para evitar alguns erros lógicos. Em seguida verificaremos que a conta é válida. Por exemplo: Temos o ID de conta válido em formato JSON que faz essa verificação automaticamente durante a desserialização, se for inválido, entrará em pânico. Depois disso, puxamos o saldo da conta corrente do contrato de staking. Esse saldo geralmente é grande o suficiente porque temos que pagar pelo armazenamento deste contrato específico, e então avisamos que vamos alocar alguns tokens para o STAKE_SHARE_PRICE_GUARANTEE_FUND. O staking pool tem certas garantias que são importantes para os contratos locais. As garantias asseguram que, quando você depositar no staking pool, poderá sacar pelo menos a mesma quantidade de tokens e não poderá perder tokens nem mesmo por 1 000 000 000 000 yocto (10-24 ) NEAR  neste contrato (NEAR on this contract), O fundo STAKE_SHARE_PRICE_GUARANTEE_FUND é de cerca de 1 trilhão de yocto NEAR, enquanto normalmente consumimos cerca de 1 ou 2 trilhões de yocto NEAR para erros de arredondamento. E finalmente, temos presente qual é o saldo que vamos depositar em stake a nome deste contrato. Isso é necessário para estabelecer qualquer linha de base para limitar as diferenças de arredondamento. Em seguida, verificamos se a conta não está no stake ainda.

 Nós não queremos que isso aconteça, o que  queremos é dar início ao  contrato antes que isso aconteça. Finalmente inicializamos a estrutura, mas não a retornamos imediatamente. Acabamos de criar  aqui, a  :StakingContract structure.



Em seguida, emitimos uma transação de re-staking . Isso é importante, porque precisamos ter certeza de que essa “chave ristretto” restrita é uma chave válida, por exemplo, uma chave válida 5 119. Existem algumas chaves na curva que são chaves válidas, mas não são específicas de ristretto, e as chaves de validação só podem ser as específicas de ristretto. Isso é algo especificamente do protocolo da NEAR, e o que acontece, é que ele faz uma transação de staking com a chave fornecida.Uma vez que esta transação é criada a partir do contrato, damos validade a essa transação quando ela se executa. Se a chave for inválida, ela vai gerar um erro e toda a inicialização desse pool de staking falhará. Se você passar uma stake_public_key inválida como entrada, sua consolidação e implantação de contrato e tudo o que acontecer nessa transação em lote será revertido. Isso é importante para que o pool não tenha uma chave inválida, pois isso pode estar permitindo que você bloqueie a participação de outras pessoas. Como parte das garantias, estamos afirmando que, se você desfizer o stake, seus tokens serão devolvidos em 4 períodos. Eles serão elegíveis para retirada, e isso é importante para poder devolvê-los aos Lockups.



Penso que são demasiados detalhes para serem tomados em conta antes de explicar a visão geral de alto nível de como os contratos funcionam e como funcionam os saldos. Vamos explicar o conceito de como podemos distribuir recompensas aos proprietários de contas em tempo constante quando um período passa. Isso é importante para a maioria dos contratos inteligentes. Eles querem operar em tempo constante para cada método em vez de tempo linear para a quantidade de usuários, porque se a quantidade de usuários crescer, a quantidade de gás necessária para operar uma escala linear crescerá também, e eventualmente ficará sem gás. É por isso que todos os contratos inteligentes precisam operar em tempo constante.
Estrutura da Conta


Mantemos a estrutura chamada conta, do jeito que funciona para cada usuário. Todo usuário que transferir para este staking pool terá uma estrutura chamada account que possui os seguintes campos: unstaked é o saldo em yocto NEAR que não está em staking, portanto é apenas o saldo do usuário. Então stake_shares é na verdade um saldo, mas não em NEAR, e sim em número de ações de participação. Stake_shares é um conceito que foi adicionado especificamente a esse staking pool. A maneira como funciona é que quando você entra no stake pool, você basicamente compra novas ações ao preço atual, convertendo seu saldo fora do stake_pool em ações de participação. Um preço de participação é originalmente 1, mas com o tempo ele cresce com as recompensas e, quando a conta recebe recompensas, seu saldo total de participação aumenta, mas a quantidade total de participações não muda. Essencialmente, quando uma conta recebe recompensas de validação ou algum outro depósito direto no saldo, aumenta o valor que você pode receber por cada participação. Digamos, por exemplo, que você originalmente tinha 1 milhão NEAR que foi depositado nessa conta. Digamos que você receba 1 milhão de ações (ignorando o yocto NEAR por enquanto), se o staking pool recebeu 10.000 NEAR em recompensas, você ainda tem 1 milhão de ações, mas o 1 milhão de ações agora corresponde a 1.010.000 NEAR. Agora, se alguém quiser entrar no pool, nesse momento, eles vão comprar as ações de participação internamente dentro do contrato ao preço de 1,001 NEAR, porque cada ação agora vale isso. Quando você recebe outra recompensa, não precisa comprar mais ações apesar do saldo total, e no tempo constante todos dividem a recompensa proporcionalmente ao número de ações que possuem. Agora, quando você sai do pool, você está, na essência, vendendo essas ações ou queimando-as usando o conceito de tokens fungíveis em favor do saldo não fora do pool. Então, você vende ao preço atual, diminui o valor total da participação, bem como a quantidade total de ações, e quando você compra, aumenta o saldo total da participação e o total de ações da participação, mantendo o preço constante. Quando você entra ou sai do stake-pool, você não altera o valor, mas quando recebe as recompensas, aumenta ovalor.



Nota: Um epoch é uma unidade de tempo de aproximadamente ~12 horas ou 43,200 segundos para ser exatos.

O preço só pode subir, e isso pode ocasionar erros de arredondamento das contas quando o seu yocto NEAR não bater precisamente com o seu saldo. É por isso que temos esse fundo de garantia de 1 trilhão de yocto NEAR que colocará um yocto NEAR extra de vez em quando para bater as contas. E , a parte final está aí, pois o protocolo NEAR não para o stake e devolve o saldo imediatamente, tem que esperar três epochs até que seu saldo seja tirado do pool e devolvido à conta. Se você sair do pool (unstake), não poderá retirar esse saldo imediatamente do staking pool, precisará aguardar três epochs. Você vai ter que se lembrar em que momento você fez seu último pedido de unstake e, após três epochs, seu saldo será desbloqueado e você poderá fazer o saque do unstake. No entanto, há uma ressalva: se você fizer o unstake no último bloco do epoch, a ordem só será confirmada no seguinte epoch e a partir desse momento é que vamos contar os três epochs. A ordem chegará no primeiro bloco do próximo epoch, e isso atrasará seu saldo bloqueado a ser desbloqueado para quatro epochs em vez de três. Isso ocorre porque registramos o epoch no bloco anterior, mas a transação real só foi confirmada no bloco seguinte, no seguinte epoch. Para garantir que isso não aconteça, bloqueamos o saldo em quatro epochs em vez de três para poder contabilizar a separação de blocos. Isso é o que constitui uma conta. A ideia de ações não é tão nova, porque em  Ethereum a maioria dos provedores de liquidez e os criadores de mercado automatizados, usam esse conceito semelhante. Quando você, por exemplo, deposita no pool de liquidez, obtém algum tipo de token desse pool em vez do valor real que ali está representado. Quando você faz o saque do liquidity pool, queima esse token e obtém os tokens reais representados.  A ideia é muito parecida com chamá-las de ações, porque elas têm um preço correspondente, e poderíamos ter chamado de outra forma. Isso foi praticamente desde o início deste staking pool. Houve um estudo sobre como poder fazer isso corretamente, e uma maneira foi limitar o número de contas que podem depositar em uma determinada conta de pool para essa atualização específica. E eventualmente terminamos por chegar no tempo de complexidade constante e na verdade era um modelo bem mais simples. Então a matemática da estrutura stake_shares tornou-se um pouco mais razoável, mesmo assim existem alguns detalhes também.
Tipos de Contratos
Vamos vasculhar este contrato. Por exemplo, não está tão bem estruturado quanto um contrato de bloqueio, porque o bloqueio é ainda mais complicado. Os tipos ainda são agrupados no mesmo contrato. Existem vários modelos de tipos, por exemplo reward_fee_fraction é um modelo separado.



Conta é um tipo separado e também há uma conta legível por humanos que também é um tipo usado apenas para chamadas de exibição, portanto, não é usado para a lógica internamente.



Então, depois de terminar com todos os tipos, temos chamadas de contrato cruzado usando uma interface de alto nível.



Existem dois deles. A maneira como funciona é que você tem uma macro de near_bindgen chamada ext_contract (representando contrato externo). Você pode dar a ele um nome curto que ele mesmo gerará o qual você poderá usar. Então você tem uma descrição de característica descrevendo a interface do contrato externo que você deseja usar. Isso descreve o fato de que você pode chamar um método de votação em um contrato remoto e passar um argumento.

O argumento is_vote que é um booleano verdadeiro ou falso. Agora você poderá criar uma promessa quando precisar e passar um argumento posicional em vez de um argumento de serialização JSON. A macro se transformará em apis de promessa de baixo nível atrás dos bastidores. A segunda interface é para um retorno de chamada em nosso self, isso é bastante comum, você pode chamá-lo de ext_self. Quando você precisa fazer um retorno de chamada e fazer algo no resultado da promessa assíncrona, você pode ter esse tipo de interface. O que fazemos então é verificar se a ação de staking foi bem-sucedida. Finalmente, temos este corpo de implem
Contract File Structure (Estrutura do Arquivo do Contrato)
Este contrato é dividido em vários módulos.



Você tem o libs.rs que é a entrada principal, e ademais um módulo interno.O módulo interno tem a implementação sem a macro near_bindgen, por tanto, nenhum desses métodos ficará visível para ser chamado por um contrato por outra pessoa dessa chain. Eles só podem ser chamados dentro deste contrato internamente para que não gerem formatos JSON e não desserializem o estado. Todos eles agem como métodos regulares de Rust. Como este contrato funciona de alto nível, quando uma epoch passa, você pode adquirir certas recompensas como validador.
Important Methods of the Contract (Métodos Importantes do Contrato)


Temos um método de ping que atua no contrato. O método ping verifica se um epoch passou e então precisamos distribuir recompensas. Se o epoch mudar, o ping também será reiniciado, porque pode haver alguma mudança no valor da participação total que o contrato deve apostar. O próximo é o depósito.



O método de depósito é o Playable (pagável), o que significa que pode aceitar um depósito anexado. Isso é semelhante ao Ethereum Decorator que permite que você receba fundos somente para os respectivos métodos que os esperam. Portanto, near_bindgen, por padrão, entrará em pane se você tentar chamar um método, por exemplo, ping, e anexar um depósito a esse método. Consequentemente, o pagável nos permite anexar depósitos. Em todos os métodos há um ping interno para garantir que distribuímos as recompensas anteriores antes de alterar qualquer argumento. A estrutura comum é que, se precisarmos refazer, primeiro fazemos algo de logic e depois um restake.



O seguinte método é o deposit_and_stake. Esta é uma combinação entre dois métodos. Primeiro, você deposita o saldo no saldo da sua conta e imediatamente também faz o stake no mesmo valor, em vez de fazer duas transações. Ademais, também é pagável porque também aceita um depósito.



A próxima ação é fazer um withdraw_all (retirar tudo). Essa ordem tenta retirar todo o saldo unstake da conta chamada. Quando você interage com o staking pool, você precisa interagir com a conta que possui o saldo. Neste caso, este é o predecessor_account_id e basicamente verificamos a conta e, em seguida, retiramos o valor que não está bloqueado (unstaked amount), se é possível. Se não for retirado, vai entrar em pane. Por exemplo, se ainda estiver bloqueado devido a desmarcação há menos de 4 epochs.



Withdraw só permite um saque parcial do saldo. 



É aí que o Stake_all faz um stake de todo o saldo (stake_all) que está desbloqueado (unstaked) e é muito fora do comum usar esse método, porque você normalmente usa o stake_deposit que te dá imediatamente o saldo do stake.



Então, no stake method, você faz apenas um stake com uma quantia do stake balance. A carteira Moonlight usa um custo separado para depositar em stake, mas eles usam uma transação em lote para fazer isso.



E por último, você tem um unstake_all, que basicamente desmarca todas as suas ações, convertendo-as em um yocto NEAR. Existe um método auxiliar que diz converter meu número de ações em uma quantidade de yocto NEAR e arredondar para baixo, porque não podemos dar a você um valor extra pela sua ação multiplicada pelo preço. É assim que obtemos o valor e, em seguida, chamamos o unstake para o valor fornecido.



O argumento staked_amount_from_num_shares_rounded_down usa o u256, porque os saldos operam em u128. Para evitar desbordes, multiplicamos o total_staked_balance pelo número de ações em u256. O preço é o quociente arredondado para baixo.



A versão de arredondamento para cima staked_amount_from_num_shares_rounded_up é muito semelhante, exceto que fazemos uma verificação que nos permite arredondar para cima e não para baixo. No final de ambos nós o lançamos de volta para u128. Então temos uma ação unstake que é muito semelhante ao unstake_all, exceto que você passa o valor.


Métodos Getter/View
Depois disso, há vários métodos getter que são chamadas de visualização que retornam alguns valores. Você pode obter o saldo que não está em stake da conta, saldo em stake da conta, saldo total da conta, verificar se você pode sacar, saldo o total do stake, que é o valor total que o conjunto de stakes tem no stake ativo.



Então você pode saber quem é o proprietário do staking pool, pode obter a taxa de recompensa atual ou a comissão do staking pool, obter a chave de staking atual e há um ponto separado que verifica se o proprietário pausou o staking pool.



Digamos que o proprietário faça uma migração no staking pool dentro do node. Eles precisam desfazer completamente o staking, então, por exemplo, eles podem pausar o staking pool que enviará uma transação de estado para o protocolo NEAR e, em seguida, não serão reiniciados até que eles retomem o staking pool. No entanto, você ainda pode sacar seus saldos, mas deixará de adquirir recompensas após a aprovação.



Finalmente, você pode obter uma conta legível por humanos que fornece quantos tokens você realmente possui para o número de ações no preço atual e, finalmente, informa se você pode retirar ou não.



Em seguida, você receberá o número de contas que é o número de delegantes para esse staking pool, e  também poderá recuperar vários delegados ao mesmo tempo.

Esta é a paginação em um grande número de contas dentro do mapa não ordenado. Uma maneira de fazer isso é usar o auxiliar que chamamos de keys_as a_vector do mapa não ordenado. Ele fornece uma coleção persistente de chaves do mapa e, em seguida, você pode usar um iterador para solicitar as contas dessas chaves. Essa não é a maneira mais eficiente, mas permite implementar a paginação em mapas não ordenados. 
Owner Methods (Métodos de proprietário)


Existem vários métodos de proprietário. Um método proprietário é um método que só pode ser chamado pelo proprietário. O proprietário pode atualizar a chave de staking. Digamos que haja um node diferente e o proprietário precise usar uma chave diferente. Todos esses métodos primeiro verificam se somente o proprietário poderia chamá-lo.



Este é o método que altera a comissão do staking pool. O proprietário pode alterar a comissão que estará ativa neste epoch imediatamente a partir deste epoch, mas todas as comissões anteriores serão calculadas usando a taxa anterior.



Portanto, esse foi o método de votação que nos permitiu fazer a transição para a fase dois da rede principal.

Seguidamente estão os dois métodos, já descritos por mim, que permitem pausar o staking e reativar o staking.



O resto são apenas testes. A maior parte do processo está acontecendo internamente.
Simulation Test (Teste simulado)
Também temos basicamente testes simulados para um determinado pool. Esta simulação é como a rede realmente vai funcionar. Primeiro inicializamos o pool.



Bob é o delegante. Bob chama o método de depósito de pool que é o deposit_amount usando o deposit_method. Então Bob pode verificar se o saldo fora do stake está funcionando corretamente. Em seguida Bob introduz a quantia no stake. Então verificamos o valor atual do stake. Verificamos que seja a mesma quantia.



Bob inicia o método ping. Não há recompensas, mas nas simulações as recompensas não estão funcionando de qualquer maneira, neste caso você precisa fazer isso manualmente. Verificaremos mais uma vez que o valor de Bob ainda seja o mesmo. Em seguida o stake pool recomeça. Nós verificamos que o pool tenha recomeçado, e em seguida bloqueia a zero. Então simulamos que o pool adquiriu algumas recompensas (1 NEAR) e Bob dá um ping na piscina. Em seguida, verificamos se o valor que Bob recebeu é positivo. Esse é um caso de simulação muito simples que diz que Bob primeiro depositou no pool, que é o que verifica se a pausa e a retomada funcionam, ou simula que funciona e garante que o pool não entre no stake enquanto estiver em pausa. Então, quando retomado, o pool realmente faz o stake. E portanto, este teste verifica não apenas o mencionado, mas também se Bob adquiriu a recompensa e a distribuiu. Há outro teste que verifica algo do processo lógico, só que é algo mais complicado. Existem alguns testes de unidade na parte inferior disto, que devem verificar certas coisas. 



Alguns desses testes não são os ideais, porém verificam certos detalhes que tenham sido bons o suficiente para garantir que o cálculo fosse válido.
internal.rs
Internal Ping Method


Vamos passar para o internal_ping. Este é o método que qualquer pessoa pode chamar por meio de ping para garantir que as recompensas sejam distribuídas. Neste momento, temos pools de staking ativos e há uma conta patrocinada por uma das pessoas do NEAR que basicamente faz ping a todos os stake pools cada 15 minutos com a missão de garantir que cada um deles tenha distribuído as recompensas para serem exibidas no seu respectivo saldo. Dessa forma, a distribuição de recompensas funciona. Primeiro verificamos a altura do epoch atual, portanto, se a altura do epoch for a mesma, significa que a epoch não mudou, devolvemos false para que você não precise fazer um restake.

Agora, se o epoch mudou, lembramos que o epoch  atual (epoch height) existe, e obtemos o novo saldo total da conta. O ping pode ser chamado quando alguns tokens foram depositados por meio de cédulas de depósito, e eles já fazem parte do account_balance, e como o ping foi chamado antes, precisamos subtrair esse saldo antes de distribuir as recompensas.. Obtemos o valor total que a conta possui, incluindo ambos saldos, o bloqueado e o desbloqueado. O saldo bloqueado é um valor de stake que adquire recompensas, e o saldo desbloqueado também pode ter recompensas em certos cenários em que você diminui o seu stake, mas suas recompensas ainda serão refletidas nos próximos dois epochs. Logo após isso, eles chegarão ao valor fora do stake. Verificamos usando assert, que o saldo total é maior do que o saldo total anterior. Essa é uma variante que o staking pool requer. Houve uma grande quantidade de processos na rede de teste que falharam nessa invariável porque as pessoas ainda tinham chaves de acesso no mesmo staking pool e, quando você as tem, gasta o saldo em “gas” e pode diminuir seu saldo total sem adquirir a recompensa. Por fim, calculamos a quantidade de recompensas que o staking pool recebeu.Este é o saldo total menos o saldo total conhecido anterior, o saldo do epoch anterior. Se as recompensas forem positivas, nós as distribuímos e a primeira coisa que fazemos é calcular a recompensa que o proprietário recebe como comissão.



Multiplicamos a reward_fee_fraction pela recompensa total recebida e isso é arredondado para baixo com o numerador em u256 multiplicado pelo valor dividido pelo denominador em u256.



O owner_fee é o valor em yocto NEAR que o proprietário irá manter para si. O remaining_reward são as recompensas restantes que precisam ser restaked. Em seguida, passa a ser restaked. O proprietário recebeu as recompensas em yocto NEAR, não em shares, mas porque toda a lógica tem que estar em compartilhamentos, o proprietário do staking pool compra ações ao preço das distribuições pós-recompensa para o restante dos delegantes. Portanto, num_shares é o número de shares que o proprietário receberá como compensação pela execução do staking pool. Se for positivo, aumentamos a quantidade de ações e salvamos a conta do proprietário e também aumentamos a quantidade total de participação em ações. Se por algum motivo, durante o rounding down, esse saldo se tornasse zero, a recompensa venha ser muito pequena e o preço por ação era muito grande e o pool recebia apenas zero recompensas. Nesse caso, esse saldo será enviado apenas para o preço por ação em vez de compensar o proprietário. Em seguida, colocamos alguns totais do logging data que indicam que o epoch atual existe, que recebemos as recompensas em uma quantidade de ações ou tokens de staking, que o saldo total de staking do pool é algo e registramos o número de shares. A única maneira de expor o número de shares ao mundo externo é através dos logs. Finalmente, iremos lembrar apenas do novo saldo total e pronto. Distribuímos todas as recompensas em tempo constante e atualizamos apenas uma conta (conta do proprietário) para a comissão, e somente se a comissão fosse positiva.
Internal Stake Method (Método Interno de Stake)


O internal_stake é onde implementamos o fundo de garantia de preço. Digamos que o predecessor, a quem, neste caso chamaremos account_id, quer pôr em stake uma quantidade de tokens.

O saldo na verdade não é um tipo JSON, porque é um método interno, portanto não precisamos de JSON aqui. Calculamos quantas ações são arredondadas (para baixo) que são necessárias para o valor determinado a ser posto em stake, será quantas ações o proprietário receberá. Tem que ser positivo.

Então verificamos o valor, novamente arredondado para baixo, que o proprietário deve pagar pelas ações. Isso é para garantir que quando o proprietário comprou ações e as converteu de volta sem recompensas nunca perdeu o 1 yocto NEAR, pois poderia romper a garantia. finalmente,  confirmamos que a conta tem o suficiente para pagar o valor cobrado, e diminuímos o saldo interno que não está em stake, e aumentamos o saldo interno do número de ações da conta. Em seguida, redondeamos o staked_amount_from_num_shares_rounded_up para que o número de ações seja realmente arredondado. Este 1 centavo extra ou 1 yocto NEAR extra, virá do fundo garantia durante o arredondamento das cotas. Cobramos menos do usuário, mas contribuímos mais com o valor desse 1 trilhão de yocto NEAR que havíamos designado originalmente para isso. Essa diferença geralmente é de apenas 1 yocto NEAR que pode vir do que foi arredondado para cima ou para baixo. Depois disso, há a quantidade de total_stake_balance e total_stake_shares. Seguidamente, cunhamos novas ações com eles. E por fim, colocamos um log e retornamos o resultado.



O unstake funciona de maneira muito semelhante. Você arredonda para a quantidade de ações que precisa pagar. Em seguida, calculamos o valor que você recebe, arredondando novamente para pagar a mais por isso. Isso também vem de um fundo de garantia. Em seguida, diminuímos o valor das ações para aumentar a quantidade e indicamos quando você pode desbloquear o saldo num período de quatro epochs. O untake_amount é arredondado para baixo para que o unstake seja um pouco menos para garantir o preço dos outros participantes do pool. É basicamente assim que o staking pool funciona e como a matemática funciona. Compensamos os erros de arredondamento dos fundos que alocamos.
Conclusão
Atualizamos as chaves ristretto durante a elaboração deste contrato e foi uma surpresa que fosse necessário tomar isso em conta. No STAKE_SHARE_PRICE_GUARANTEE_FUND 1 trilhão de yocto NEAR deve ser suficiente para 500 bilhões de transações que devem ser longas o suficiente para o staking pool para que não possa ser recarregado porque as recompensas serão imediatamente redistribuídas para o total_stake_balance no próximo ping. Gastamos bastante tempo e esforço neste contrato, porque fizemos muitas análises de segurança, incluindo internas e externas, especialmente em torno desses cálculos. Foi complicado, e descobrimos algumas coisas, como, por exemplo, a tecla ristretto que apareceu durante as revisões. Nós marcamos o log de alterações deste contrato, também no readme há um monte de coisas que surgiram durante o desenvolvimento e testes no sistema ao vivo, mas a versão original tardou aproximadamente uma semana para ser escrita. Mais tarde, demos uma boa polida, testamos e implementamos várias melhorias. Então fizemos um montão de revisões. Tipo, pausar e reativar foi solicitado pelo pool, porque, caso contrário, o proprietário não teria a capacidade de desfazer o unstake se o seu node falhasse. Eles estarão atacando a rede. Essencialmente, essa participação ativa estaria solicitando a validação e não executando a rede. Antes não tínhamos essa contundência. Isso, não só era um problema para os participantes, mas também para a própria rede. Dessa forma, o proprietário pode pausar o staking se não quiser executar o pool que migra para o pool e comunicar-se o máximo possível antes disso. Em seguida, atualizamos a interface de votação para corresponder ao final da fase 2 do contrato de votação. Adicionamos métodos de visualização auxiliares para poder consultar contas de maneira legível por humanos. Por fim, houve algumas melhorias nos métodos de agrupamento em lote, então o deposit_and_stake, stake_all, untake_all e o retire_all, em vez de ter que fazer uma chamada de visualização primeiro, obter o valor e colocar o valor para chamar o stake. Aqui está a maneira como corrigimos isso.



Quando você faz o stake, não é apenas com o valor, mas também anexamos um compromisso de verificar se o stake deu certo. Isto é necessário para dois motivos: se você estiver tentando fazer o stake com uma chave inválida (não uma chave específica de ristretto), o compromisso falhará antes da execução. Ele falhará na validação antes de enviá-lo, e isso fará com que você não precise verificá-lo no contrato. Ele reverterá a última chamada e tudo ficará bem. Ademais, introduzimos o minimum stake no nível do protocolo. O mínimo stake possível é o equivalente a um décimo do valor do último preço do assento, e se o seu contrato tentar fazer o stake com menos que isso, a ação falhará e você não enviará a promessa.Digamos que você queira desfazer uma aposta e deixou cair seu saldo abaixo de um décimo do valor.A ação de staking pode falhar e você não destake, enquanto você precisa para garantir que o unstake aconteça. Nesse caso, temos esse call back que verifica se o stake tenha sido completado e bem sucedido. Esse call back basicamente verifica se funcionou, se falhar, e o saldo for positivo, precisamos desfazer o stake. Portanto, ele chamará o unstake para uma ação em que o valor dele é zero para garantir que todo o saldo seja liberado. Foi possível retirar em 4 epochs durante os testes desses contratos que fizemos na testnet beta 9 antes da manutenção. O contrato estava pronto, talvez pela volta do horário de verão, por isso o teste desta iteração levou provavelmente de 2 a 4 meses devido à complexidade que envolve a interação com o protocolo. Uma coisa que seria muito boa seria ter um stake ou depósito e fazer um stake_all em um contrato de lock-up. No momento, você precisa emitir manualmente quanto deseja pôr no stake em um contrato lock-up, mas seria ótimo se você não precisasse pensar no seu yocto NEAR e no quanto ele está bloqueado para ser guardado. Você só quer fazer o stake all do seu lock up, mas como já foi implantado, já é tarde demais para pensar nisso. Há também algum gás que é codificado e, com a diminuição habitual da taxa, esses números não podem ser alterados porque já estão na chain.



Portanto, “vote” não é importante, mas o método ON_STAKE_ACTION_GAS exige que você tenha um número grande para cada stake e não pode diminuí-lo. A tomada de ações de risco em todas as chamadas deste contrato exigirá que tenhamos uma grande quantidade de gás e o problema é que isso é um verdadeiro desperdício.  Digamos que concordamos em queimar todo o gás, esse gás será queimado sempre e logicamente desperdiçado, além de limitar o número de transações que você pode colocar em um bloco se estivermos restringindo o gás com base nesse caso. sucederam muitas iterações no teste do contrato usando a estrutura de simulação de teste que melhoramos muito. Se chegarmos aos contratos Lockup, eventualmente você poderá ver como a estrutura desses contratos melhorou em relação a este.

### NEAR Revisão de Contrato ao Vivo | Parte 3: Whitelist e Fábrica de Staking Pool

Introdução
Olá pessoal. Hoje vamos revisar 2 contratos em vez de 1. Incluiremos contratos que envolvem chamadas de contratos cruzados e falaremos sobre promessas e como elas funcionam na NEAR. Se você quiser saber mais sobre como funciona a composição, esta é uma boa sessão para ler. O primeiro contrato que veremos é chamado de contrato de lista de permissões e é usado na rede principal para colocar pools de staking na lista de permissões. Isso é importante porque a distribuição de tokens é feita por meio de contratos inteligentes. Usamos contratos de bloqueio que eventualmente revisaremos nesta série, mas a maneira como funciona é que o bloqueio é um contrato autônomo que contém tokens que devem ser liberados durante um período de tempo. Digamos que os tokens sejam lançados ao longo de 2 anos e sejam alocados linearmente a cada bloco. O que queríamos fazer é dar a capacidade de stake desses tokens, incluindo os tokens que ainda não foram lançados. Isso significa que você deve poder delegar todos os tokens que bloqueou por 2 anos, por exemplo, e começar a ganhar recompensas com eles. Isso é feito em um contrato inteligente, e um contrato de bloqueio está essencialmente chamando o contrato de staking pool que analisamos antes e transferindo tokens de um contrato para outro. Os tokens do contrato de bloqueio saem da conta e vão para a conta do staking pool. Se um staking pool não fornecer as garantias necessárias, como a capacidade de retornar esses tokens, isso significa que haverá problemas. Digamos que eu construa um staking pool personalizado que me permite não apenas fazer stake dos tokens, mas também retirá-los para qualquer conta. Esse tipo de operação permitirá que você obtenha ativos líquidos antes do término do período de liberação. Então você poderá se retirar, e esse não é o comportamento desejado.

É por isso que introduzimos a whitelist onde implementações personalizadas dos staking pools aprovados pela NEAR Foundation podem ser usadas por contratos de bloqueio. Ao mesmo tempo, queríamos dar a capacidade de criar novos staking pools que já fossem aprovados por qualquer pessoa sem passar pela aprovação da NEAR Foundation. Isso permite que qualquer pessoa crie um novo staking pool por meio de uma Staking Pool Factory (Fábrica de Staking Pool). A fábrica de staking pool é o segundo contrato que analisaremos hoje. A maneira como funciona é quando um contrato de lockup deseja delegar, antes que eles possam transferir fundos para este contrato, eles primeiro precisam selecionar um staking pool. Quando você seleciona o staking pool, o lockup emite uma transação para verificar se um determinado ID de conta está na lista de permissões em um contrato de lista de permissões e se retornar verdadeiro, o que significa que a conta está na lista de permissões, o contrato de bloqueio pode continuar com delegação. 

Ele permite que o lock-up seja realmente transferido para este contrato. Isso significa que o contrato de staking pool tem algumas garantias e APIs que o contrato local espera e não bloqueará os tokens do proprietário ou roubará tokens do contrato de bloqueio. Isso também foi importante para os cronogramas de investimento dos funcionários da NEAR. Foi em um cronograma de investimento de quatro anos, e isso permite que a Fundação emita uma transação específica para o bloqueio dessa pessoa, a fim de liberar tudo do staking pool e devolver o valor investido de volta à fundação NEAR no caso de um funcionário sair o trabalho ou for demitido. Esse é o pano de fundo sobre bloqueios e o contrato da lista de permissões.

O repositório original desses contratos pode ser encontrado no NEAR Github. Aqui está o vídeo original no qual este guia se baseia:


Contrato de lista de permissões
Estrutura principal
Vejamos o contrato da lista de permissões. Na verdade, é um contrato bastante simples, e não tem muita lógica, já sabemos a maioria das coisas. 



Ele usa uma API NEAR chamada LookupSet. É semelhante a um conjunto não ordenado. É uma coleção persistente, mas não possui iteradores, então você não pode iterar sobre as chaves dos elementos do conjunto. Você só pode verificar se um determinado elemento está presente ou não, e pode adicioná-lo ao conjunto. Você não pode verificar quais elementos estão presentes neste conjunto. Ao fazer isso, melhora a eficiência do armazenamento e o acesso de várias leituras a algumas leituras. O contrato contém alguns campos. O primeiro é o foundation_account_id. Este é o ID da conta que controla a lista de permissões. Isso significa que essa conta pode colocar staking pools na lista de permissões por 1 e também pode listar fábricas de staking pool. 

A fábrica é um contrato que pode criar uma nova instância de staking pool. A maneira como funciona é quando você emite uma transação para a fábrica de staking que está na lista de permissões por este contrato, ela cria uma nova conta como uma subconta da fábrica. No nosso caso na rede principal é chamado poolv1.near que é a fábrica de staking pool que usamos. Ele cria um contrato, por exemplo, bisontrails.poolv1.near, no qual implanta o código de pool de staking na lista de permissões que essa fábrica pode produzir. Entraremos na fábrica de staking pool mais tarde, mas, ao mesmo tempo, ela também pode colocar na whitelist esse staking pool. Aqui está como funciona. A inicialização do contrato aceita apenas um argumento foundation_account_id. Uma conta de base tem permissões mais altas neste contrato.


Getters
Há um monte de getters.



Você pode verificar se uma determinada entrada de stake está na lista de permissões. É assim que um contrato de bloqueio verifica se o pool está na lista de permissões. Basicamente, apenas verifica se um elemento está presente em um conjunto. A segunda maneira que ele também pode verificar é se a fábrica está na lista branca, então isso não é realmente necessário e ninguém a chama.
Adicionar método de staking pool


Este é um método que pode ser chamado tanto por uma fábrica quanto pela fundação. O que fazemos aqui é verificar se esse método de staking adiciona um novo staking_pool_account_id a uma lista de permissões. Ele verifica se o id da conta é válido e, se passar, verificamos se é uma fábrica. Verificamos em um conjunto que o chamador deste método está presente na lista de permissões das fábricas. Se for chamado pela fábrica de staking pool, tudo bem. Caso contrário, deve ser um ID de conta de fundação, caso contrário, o contrato falhará e esse método entrará em pânico. 

Se passarmos na verificação de permissão, apenas adicionamos esse staking pool à lista de permissões. No momento, temos apenas uma implementação para o staking pool, mas em teoria podemos modificar essa implementação quando introduzimos o slashing, por exemplo, e um staking pool precisa ter a permissão necessária. Ele precisa manter algum saldo mínimo. Há alguma outra mudança em que precisamos modificar um contrato validado durante o período de investimento de todos é de 4 anos. Muitas coisas podem acontecer na rede e precisamos ter a capacidade de alterar potencialmente os staking pools. Se a lógica do staking pool mudar, por exemplo. 

Ele permite a criação de uma nova fábrica que é uma versão melhor ou suporta algo que não era suportado antes. Ele não permite alterar uma taxa de recompensa instantaneamente, mas apenas permite que ela seja alterada após um período de espera de 7 dias, ou alguma outra ideia para uma modificação que seja um fator diferente.



O próximo remove_staking_pool só pode ser chamado pela fundação, de modo que um staking pool só pode ser eliminado pela fundação.

Além disso, add_factory também pode ser chamado apenas pela fundação. É básico, apenas adiciona a uma lista branca das contas de fábrica.



Finalmente, remove_factory também só pode ser chamado pela fundação e remove o factory_account_id. Digamos que a primeira fábrica expire, então a fundação pode basicamente remover a fábrica da lista de permissões, bem como remover todos os pools anteriores da lista de permissões. Agora, você não poderá selecionar uma das pesquisas de staking anteriores de um contrato de bloqueio e, finalmente, há uma verificação de que isso é chamado pela fundação, que é uma comparação. Este é um contrato muito simples, e ele opera apenas em conjuntos internos e o único método verdadeiro que é visível por fora é is_whitelisted. É bastante simples, é apenas um monte de setters e getters.
Imutabilidade dos Contratos Inteligentes
A maneira como os contratos inteligentes geralmente se comportam, o que é verdade no Ethereum, e em outras plataformas, é que eles são imutáveis ​​em si mesmos. No Ethereum, todo interior de contrato é imutável, mas eles usam um contrato de proxy que permite atualizar o endpoint para determinados contratos que são muito críticos para tokens. Nesse caso, nossos contratos principais são essencialmente completamente imutáveis, e pensamos neles como se fôssemos implantá-los uma vez e provavelmente não pudéssemos alterá-los, porque senão você terá que fazer um hard fork e convencer todos os validadores a fazer algum tipo de migração de código. É importante, porque o controle sobre eles deve ser feito no nível do contrato e não em algumas entidades centralizadas. Por exemplo, enquanto a fundação ainda mantém grande controle sobre os staking pools tendo a capacidade de remover staking pools aqui, ele não tem o controle para colocar uma entidade específica no mundo real na lista negra de implantar um staking pool. 

Eles ainda podem criar um staking pool com o máximo de anonimato possível e criar um staking pool sem pedir permissão para se tornar um validador na rede principal. Algumas coisas vêm da descentralização, outras vêm da limitação do controle. Embora a fundação deva dar suporte à rede, é possível que, em alguns cenários, a fundação seja forçada a fazer algo ruim para a rede. Digamos que o governo venha e tente forçá-los. Se eles tiverem menos capacidade de fazer isso, haverá maior segurança na rede. Quando desenhamos um contrato, pensamos: “Qual é a quantidade de valor neste contrato?” ou “Qual é a capacidade deste contrato de influenciar a rede em geral?”. Se for um valor pequeno, então não há problema em manter a credibilidade contanto que a comunidade confie, se for um valor grande, então não está certo. Quando chegarmos ao contrato de bloqueio, e da maneira como ele foi projetado, você pode ver como, por exemplo, a aquisição de direitos foi projetada para, por um lado, permitir que a fundação retire os fundos restantes, mas ao mesmo tempo impedem que a fundação retire os fundos investidos. 

É uma maneira legal de fazer as coisas, exceto que está escrito no código. A lista branca é um contrato muito crítico, porque antes que os fundos sejam bloqueados, a maioria dos fundos está controlando a rede por meio de contratos locais em staking pools por meio dessa lista branca específica, por isso era importante projetá-la de forma a manter a descentralização, e segurança da rede sem dar controle à fundação. Digamos que algo aconteceu, e a fundação começou a agir maliciosamente. Digamos que você conseguiu criar um novo staking pool por meio de uma fábrica e delegar para o staking pool, agora a fundação não pode realmente impedir que você delegue para esse staking pool.
Contrato Staking Pool Factory
Incluir Macro Bytes


O contrato staking_pool_factory é um contrato que possui internamente o código de um contrato de staking pool. No Rust você pode fazer isso usando a macro include_bytes. Ele basicamente pega um arquivo local e o incorpora no binário como um vetor. O que acontece é que dentro desse binário do WebAssembly podemos ter algum pedaço de memória alocado que representa um binário desse staking pool específico. Vamos voltar ao topo.
Estrutura
Mais uma vez esta é a estrutura.



Havia algumas informações sobre o gás, voltaremos a isso mais tarde.



Há uma reward_fee_fraction que acabou de ser copiado do contrato de staking pool que analisamos antes.


Contratos Externos
Existem os argumentos do staking pool, e há características, e também contratos externos, então essa é a interface de alto nível que usamos para chamar certos contratos.



Temos dois deles, o primeiro pode ser qualquer nome. Nós o chamamos de ExtSelf, porque ele representa nosso próprio contrato e contém um retorno de chamada para um método on_staking_pool_create. A segunda característica é para o contrato whitelist que acabamos de ver chamado add_staking_pool. Aqui está.



É exatamente a mesma interface, exceto que as características em Rust são como interfaces em java, por exemplo. Acabamos de definir a interface de um contrato remoto.
Inicialização


Vamos primeiro pelo cenário. Quando uma fábrica é criada, verificamos que ela não foi inicializada e verificamos o staking_pool_whitelist_account_id, o ID da conta do contrato da lista de permissões, durante a inicialização do StakingPoolFactory. Precisamos saber o staking_pool_whitelist_account_id. É aqui que o contrato de lista de permissões é implantado para colocar na lista de permissões nossas instâncias de pool de staking recém-criadas. Lembramos disso e também criamos um conjunto de contas já criadas no final deste trecho.
Método principal


Agora que a fábrica de staking pool foi criada, ela é chamada poolv1.near, por exemplo, e a fundação colocou a fábrica na lista de permissões em um contrato de lista de permissões emitindo outra transação. Agora que esta fábrica de staking pool está na lista de permissões, significa que ela tem permissão para listar os novos staking pools que ela cria. Então agora um validador entra e eles querem criar um staking pool para si mesmos. A maneira como funciona é que eles chamam create_staking_pool, e são necessários vários argumentos. O primeiro argumento é um prefixo. Digamos que seja bisontrails sem o sufixo deste id de conta atual, e isso vem dos nomes das contas NEAR. 

Uma conta só pode criar uma subconta, ou uma conta muito longa, então a fábrica de staking pool cria uma subconta sob si mesma que será bisontrails.poolv1.near. O owner_id é o id da conta do proprietário do staking pool, conforme discutimos anteriormente. Todos esses três itens são essencialmente argumentos que você passaria para um staking pool ao criá-lo pela primeira vez. É um argumento que você pode fazer proxy para o staking pool. Por exemplo, staking_pool_id pode ser bisontrails.near. O stake_public_key pode ser a chave de staking da execução de um nó validador e reward_fee_fraction pode ser 10%, por exemplo. Observe que este método também é pagável, significa que leva um depósito anexado de entrada, e a primeira coisa que pergunta é: "Você anexou depósito suficiente?" O depósito que você precisa anexar é 30 NEAR, e isso tem muitos zeros, mas isso é porque está em yocto NEAR. Você precisa anexar 30 NEAR principalmente porque precisa cobrir o estado do próprio contrato em um staking pool recém-criado. O contrato é bastante grande, são 250 kilobytes e você precisa de pelo menos 25 NEAR para isso, mas também é preciso algum dinheiro extra para cobrir o fundo de garantia de preço. 

Este é um daqueles casos em que você precisa ter um depósito anexado, porque você não pode anexar tanto gás a essa transação. Além disso, não podemos converter gás para NEAR dentro de um contrato, então, idealmente, a separação de gás permanece a mesma, é usada apenas para computação, algumas operações de leitura/gravação e chamadas de contrato cruzado. O saldo é usado para armazenamento e transferências de estado. Portanto, no nosso caso, isso criará uma nova conta, e criar uma nova conta no NEAR exige que você pague pelo armazenamento dessa conta. O armazenamento, no nosso caso, não será apenas a conta em si, mas também o contrato dessa conta. No nosso caso, este é o código do contrato de staking pool.



A próxima coisa que fazemos é verificar se o prefixo não tem um ponto, o que significa que não é uma subconta em si. Em seguida, criamos um novo staking_pool_account_id concatenando nosso ponto de identificação de conta (.) esse novo prefixo. Verificamos se o novo ID da conta do staking pool é válido. Basicamente, se qualquer uma dessas declarações falhar no protocolo NEAR devolverá os tokens. Se uma transação falhar com um depósito anexado, o depósito anexado retornará ao remetente ou predecessor, porque somente o predecessor pode anexar um saldo. É seguro fazer como um monte de afirmações aqui. Em seguida, verificamos se o owner_id do staking pool é válido. Isso é basicamente apenas um monte de ajudantes extras que também são verificados no staking pool. 

Isso é para ter certeza de que se você não passar os argumentos corretos, ou argumentos um pouco incorretos, é melhor você falhar antes que tudo seja executado para evitar queimar gás e travar os tokens que você gastou. Finalmente, verificamos usando insert que o staking pool não existe. Basicamente, insert retornará verdadeiro se for um novo elemento exclusivo e retornará falso se o elemento já existir em um conjunto. É assim que o hashset Rust funciona da mesma forma que um conjunto ordenado funciona. Portanto, se o nome do pool já existir, não adicionaremos esse staking pool ou tentaremos criar essa conta novamente. Insert faz duas coisas: adiciona esse elemento ao armazenamento, além de retornar verdadeiro se o elemento for exclusivo e não existir antes ou retornar false se o elemento já estiver presente.  Se o conjunto não tinha este valor presente verdadeiro é retornado, se este conjunto tinha este valor presente falso é retornado. 



Por fim, usamos uma API de nível médio, não usamos nossos métodos de custo bruto, mas ao mesmo tempo não usamos uma interface de alto nível. A forma como funciona é que criamos uma nova promessa, que cria uma estrutura temporária em nosso NEAR SDK e lembra o receptor dessa promessa. Você pode pensar nisso como se o contrato fosse emitir a transação para esse determinado id de conta. Chamaremos um id de conta de staking pool inexistente. Claro que não é uma transação e sim um recibo, mas é um detalhe técnico. A próxima coisa é a primeira ação em cima dessa promessa. Começamos a agrupar ações nessa promessa. A primeira ação é o create_account. Esta ação vai criar uma nova conta ou ela falhará se a conta já existir. Em seguida, depositamos o saldo em anexo. Depositamos todo o depósito que nos foi repassado, para que não fiquemos com ele nesta fábrica, e ele irá com o mesmo recibo na conta remota. 

Em seguida, implantamos um contrato. Como explicado anteriormente, include_bytes é uma macro que cria uma fatia estática que convertemos em um vetor que passará para uma ação de implantação. Isso implantará o código na conta remota. Você só pode implantar código na conta que controla, mas create_account dá a você permissão para agir como se fosse o proprietário dessa conta apenas para essa transação específica. Você pode usar o método deploy_contract, você pode fazer stake e fazer outras coisas em nome deste contrato na primeira transação que você fizer. Por fim, inicializamos o contrato do staking pool usando a API serda. Pegamos essa estrutura e serializamos isso em JSON, o método é chamado de novo. O primeiro argumento é o depósito anexado a esta chamada de função. Não precisamos dele, porque ele não espera. A próxima é a quantidade de gás que você retira da sua quantidade atual de gás e imediatamente a retira, após o que vai para a promessa. Digamos que nosso método foi chamado de 100 tera gás, tera gás é um tipo de unidade que é mais ou menos compreensível para humanos. 



Você tem 100 tera de gás quando entra e dizemos que vamos passar a base (25 tera de gás) multiplicada por 2. Passaremos imediatamente 50 tera de gás para a chamada de função deste método, então esse gás de 50 tera significa que ficamos com menos de 50 tera de gás, pois já queimamos alguns na lógica antes. Além disso, cada ação que você incluir nessa promessa também lhe custará um pouco de gas. Por exemplo, uma ação de implantação custará a você transferir os bytes de uma conta para outra. Finalmente usamos Então (then). Then é semelhante a como o javascript funciona, ele anexa a dependência da promessa anterior. Esta é a primeira promessa, e dizemos que, uma vez concluída, faça a segunda promessa. 

A maneira como funciona é você, digamos bisontrails.near ter chamado este contrato (poolv1.near) para criar bisontrails.poolv1.near. Primeiro, criamos uma promessa para bisontrails.poolv1.near e, em seguida, anexamos um retorno de chamada a essa API, o que não é ótimo em termos de usar argumentos posicionais para duas coisas diferentes. De qualquer forma, ele chama de volta o ID da conta atual. Portanto, ele chamará poolv1.near após a execução da primeira promessa. Aqui está a estrutura: bisontrails.near chama poolv1.near criando uma promessa de staking pool. Agora isso cria uma promessa para bisontrails.poolv1.near, e também cria uma promessa para si mesmo no método on_staking_pool. 



Ele precisa do resultado deste método antes que este método seja iniciado e passa três argumentos aqui. Ele passa o staking_pool_account_id, o attach_deposit e o predecessor_account_id. Então foi quem nos ligou, qual conta tentou ser criada e quantos tokens foram anexados caso precisemos fazer um reembolso. Agora, se bisontrails.poolv1.near for executado com sucesso, on_staking_pool_create receberá o resultado da execução. Digamos que houve alguma configuração incorreta de que esse método também será chamado, mas receberá um retorno de chamada dizendo que falhou. Retornamos a promessa principal depois, significa que retornamos on_staing_pool_create primeiro. É importante, porque o resultado do método create_staking_pool depende do resultado da promessa on_staking_pool_create. A transação não começa completamente em paralelo,
Chamada de Retorno
Vejamos a chamada de retorno. 



A primeira coisa que fazemos é dizer que ele só pode ser chamado pelo contrato atual usando assert_self, o que significa que ninguém mais pode chamar essa promessa.



A próxima coisa que fazemos é usar outro método auxiliar de utilitário que diz se a dependência, a criação do staking pool, foi bem-sucedida ou falhou.



Fazemos isso da seguinte maneira: primeiro usamos dois métodos end para verificar se o número de resultados é 1. Isso é uma invariante porque já sabemos que ninguém pode chamar isso duas vezes, e o segundo é se o resultado for sucesso. Se o método foi executado com sucesso, retornamos verdadeiro se a promessa falhou, então será falso. Então agora sabemos se o staking pool foi criado ou não. Novamente, também anexamos 50 tera de gás ao retorno de chamada, então agora estamos no retorno de chamada, o que significa que temos apenas 50 tera de gás.



Se formos bem-sucedidos, registraremos que o pool foi criado com êxito e, em seguida, colocaremos na lista de permissões. Em seguida, chamamos outra promessa de um retorno de chamada e anexamos 25 tera de gás. Então agora chamamos staking_pool_whitelist_account_id, o contrato da lista de permissões. Agora, podemos colocar na lista de permissões o staking pool que acabamos de criar, porque passamos esse argumento para o retorno de chamada. Retornamos essa promessa para não interromper a execução ainda, porque só queremos concluir a transação inteira quando a lista branca for concluída. Rust não tem retorno, porque se o último valor sem ponto e vírgula for fornecido, então é um valor de retorno. Se a criação falhar, ela pode falhar por apenas um motivo: se você colocar uma chave restrita inválida como discutimos brevemente antes. Se houver alguma curva estranha na qual você criou sua chave de staking, ela falhará. 

 

A razão pela qual ele falha é que significa que o depósito que você passou para o staking pool para criação será reembolsado para nós, não para o antecessor. Temos 30 NEAR neste contrato e precisamos devolvê-los ao remetente para não bloqueá-los. A primeira coisa que fazemos é removê-lo da lista de staking pools que foram criados, porque isso não foi bem-sucedido. Estamos dizendo que a criação falhou e reembolsaremos o depósito anexado. Agora não é um depósito anexado real, porque o retorno de chamada não recebe o depósito anexado. Ele passa por um recibo de reembolso separado que geralmente chega antes do retorno de chamada e também recebe o predecessor_account_id. No nosso caso, se chamarmos o predecessor_account_id, seremos nós porque este é um retorno de chamada. Nós precisamos saber para quem devemos devolver os tokens e a maneira que fazemos é devolvê-los ao remetente para não bloqueá-los. 

A primeira coisa que fazemos é removê-lo da lista de staking pools que foram criados, porque isso não foi bem-sucedido. Estamos dizendo que a criação falhou e reembolsaremos o depósito anexado. 

 

Agora não é um depósito anexado real, porque o retorno de chamada não recebe o depósito anexado. Ele passa por um recibo de reembolso separado que geralmente chega antes do retorno de chamada e também recebe o predecessor_account_id. No nosso caso, se chamarmos o predecessor_account_id, seremos nós porque este é um retorno de chamada. Nós e precisamos devolvê-los ao remetente para não bloqueá-los. A primeira coisa que fazemos é removê-lo da lista de staking pools que foram criados, porque isso não foi bem-sucedido. Estamos dizendo que a criação falhou e reembolsaremos o depósito anexado. Agora não é um depósito anexado real, porque o retorno de chamada não recebe o depósito anexado. Ele passa por um recibo de reembolso separado que geralmente chega antes do retorno de chamada e também recebe o predecessor_account_id. No nosso caso, se chamarmos o predecessor_account_id, seremos nós porque este é um retorno de chamada. Nós e reembolsaremos o depósito em anexo. 

Como você pode ver, não retornamos essa promessa, apenas dizemos que é isso, não nos importamos se ela for bem-sucedida ou falhar, o retorno básico do valor false está dizendo que o pool falhou ao ser criado. O que acontece agora a transação continua sendo executada mas o valor será devolvido ao front end. O front-end é o CLI NEAR. Você saberá imediatamente que a transação falhou. Você pode não receber seu dinheiro de volta ainda, então você ainda está esperando que esse reembolso específico seja executado no próximo bloco, mas você já sabe que o pool não foi criado para que você possa continuar. Este é um exemplo de como você pode fazer uma promessa paralela. É assim que um fator de staking pool funciona. Aqui está um getter que verifica quantos staking pools foram criados que podem ser chamados no NEAR CLI. 


Conclusão
Isto conclui a Revisão de Contrato ao Vivo da NEAR | Parte 3: Whitelist e Fábrica de Staking Pool. Obrigado por dedicar um tempo para aprender NEAR, em breve teremos mais conteúdo nesta série.

### NEAR Revisão de Contrato ao Vivo | Parte 4: Fazenda de Berry

Introdução
Aqui é Eugene, e hoje vamos falar sobre o contrato Berry Farm que é o suplemento do Berry Club que permite converter suas bananas em pepinos e cultivar NEAR. Vamos primeiro fazer uma rápida revisão da Berry Farm. O repositório pode ser encontrado no meu Github . Aqui está o vídeo original no qual este guia é baseado:


UI - Interface de Usuário


 

Berry farm é um aplicativo muito bem projetado com texto grande e muitos emojis. A maneira como funciona é que exibe seus saldos assim que você estiver logado. Ele os extrai de dois contratos diferentes, bem como de sua conta. Ele os combina de várias fontes. Abacate e banana vêm do contrato Berry Club , pepinos são locais para esse contrato e NEAR vem do saldo da sua conta. Se você farmou qualquer coisa, receberá recompensas quando as recompensas forem distribuídas. Parece que alguém fez muitas compras de abacate recentemente e as recompensas aumentaram. Ele também tem estatísticas globais, o que significa que 2.500 NEAR foram transferidos do Berry Club para Berry Farm. Ganhei 116,9 NEAR e minha recompensa será 0,014332 NEAR com base na quantidade de pepinos que tenho em comparação com o número total de pepinos. 



O número total de pepinos é 54116,4. Eu recebo 3% dessa recompensa toda vez que há uma recompensa. Então, quando clico em atualizar, basicamente atualizo as estatísticas de várias contas e posso reivindicar NEAR, que transfere do contrato para minha conta. Também posso trocar bananas por pepinos e estou fazendo um pedido para o contrato do Berry Club.





Eu vou usar transfer_with_vault que está usando o novo padrão, e requer uma pequena quantidade de NEAR, e acho que é como 1 yocto NEAR para confirmar que não estou fazendo isso através de uma chave de acesso. Não posso fazer uma transferência através de uma chave de acesso para evitar o saque automático, e isso é apenas uma proteção de segurança. Se você, por exemplo, autorizar o Berry Club de algum outro aplicativo que tenta drenar todas as suas bananas, ele falhará, porque não poderá chamar transfer_raw ou transfer_with_vault. Para esclarecer, transfer_raw é o novo nome para transferência sem contrato para que você possa apenas depositar na conta de alguém que existe, e no cofre transfer_with_vault está chamando o destinatário para retirar tokens. 



Gastei 10 bananas para conseguir mais pepinos e posso atualizar o saldo novamente para ver se alguém retirou alguma coisa. É assim que a Interface do Usuário funciona, mas há mais funcionalidades do que apenas isso. O contrato suporta pepinos como token fungível e as bananas também. Você pode criar outro aplicativo que transfere pepinos e há mais um que é o Banana Swap, que Vlad Garchina construiu.



É um Uniswap simplificado com um único pool onde você pode comprar e vender bananas. Na verdade, eu não tentei antes. Eu quero obter 1 Near em bananas que eu preciso vender por 6 bananas. Vamos ver se funciona.





Isto se chama transferências Berry Club que está mais uma vez envolvida, mas para um contrato diferente. No momento, não exibimos argumentos, mas eventualmente o faremos.



Está dizendo que me transferi e recebi 1 NEAR no qual gastei 6 bananas. Muito legal.



Você não pode adicionar liquidez e é preciso um corte de 10%. Portanto, esta é a interface do usuário.
Revisão de contrato
Berry Club
Deixe-me apresentar o contrato. Então vamos começar com o contrato Banana Farm, mas você provavelmente vai precisar dar uma olhada no token do contrato do Pixelboard, o contrato do Berry Club, bem como aquele que envia tokens. 



Berry Club tem um contrato codificado chamado farm contract id.



Quando você desenha, ele verifica se você não desenha pixels vazios, caso contrário, você pode simplesmente acionar uma recompensa sem gastar abacate. 



Em seguida, ele chama may_send_reward, que obtém a hora atual do blockchain e verifica se o next_reward_timestamp é menor que a hora atual.



A próxima recompensa é o início do tempo de cultivo, que era um carimbo de data/hora global que originalmente permitia uma contagem regressiva de 26 horas ou last_reward_timestamp quando o acionamos pela última vez, mais 60 segundos. 



Então, se é hora de enviar a próxima recompensa, ele lembra a hora atual e calcula a recompensa com base nessa lógica, então pega o saldo atual do Berry Club, pega o armazenamento atual, calcula o armazenamento pelo custo de armazenamento mais alguma margem de segurança, que é de 50 NEAR.



Ele sempre mantém 15 NEAR para os saldos futuros. Então está dizendo que se o saldo estiver disponível, se o nosso saldo for maior do que a quantidade que precisamos para armazenamento + segurança, calculamos o saldo líquido e dividimos pela parcela da recompensa que daremos toda vez, que é 24 vezes 68. 

Se você ligar a cada minuto, então você drenará a maior parte da conta, mas está sempre diminuindo por conta própria, porque o saldo diminui por conta própria, mas na maioria das vezes dá todo o saldo em um dia se você ligasse a cada minuto . 

Em primeiro lugar, você não pode produzir um bloco que está com carimbo de data/hora anterior e você não pode produzir um bloco além do seu slot. Você tem um slot dedicado quando precisa produzir um bloco. Portanto, o máximo que você pode fazer é produzir um pedaço do bloco final no milissegundo final do seu slot, que está um segundo à frente. 

Você não pode realmente avançar, caso contrário todos os outros nós quebrarão o protocolo também, então eles são limitados pela compreensão do tempo + a barra que eles usam para decidir se aceitam ou não um bloco.  Então você não pode realmente fazer um tempo correr mais rápido, a menos que todos os validadores queiram fazer isso. Isso significaria que temos os validadores que essencialmente deixarão de seguir o protocolo. Eles precisam coordenar seu tempo. 



Então, no final, ele recebeu a recompensa, dizendo que eu vou distribuir essa recompensa, e o que ele faz é chamar o contrato de Farm, e chamar take_my_near e ele simplesmente não passa nenhum argumento e passa sua recompensa e gás. Apenas uma quantidade mínima de gás é necessária para adicionar os saldos. 

Foi assim que o Berry Club foi atualizado para começar a distribuir recompensas potencialmente após cada sorteio. Leva um pouco mais. Ele usa o gás que foi gasto no desenho para distribuir a recompensa ocasionalmente, o que precisa de cerca de 10 tera de gás para isso.
Farm de Berry
Vamos para Berry Farm e começar com este contrato.  A maneira como o farm de berry funciona precisa, em tempo constante, ser capaz de distribuir recompensas com base no número total de pepinos, o que não é uma tarefa trivial, é um pouco semelhante ao staking pool e como o staking pool distribui recompensas. 

O staking pool cria um monte de ações para cada depósito que você faz e a ação tem um preço global atual que diz: “Ei, eu comprei ou cunhei mais ações e agora minhas ações podem ser resgatadas para um determinado número de tokens NEAR”. 

O preço da ação começa a partir de 1 yocto NEAR por ação e, quanto mais recompensas você acumula, mais o preço das ações sobe. Quando você usa o unstake (retira de stake), você vende ações ao preço atual e recebe NEAR de volta e arredonda para baixo. 

O desafio é quando você aposta pepinos e o preço de um pepino é zero, e quando você as aposta pela primeira vez, não pode realmente comprar ações e cunhar ações, porque o preço delas é zero. A lógica dos compartilhamentos não funciona muito bem para isso, então para isso eu precisava criar algo diferente para fazer a contabilidade. 

Vamos aos exemplos. Digamos que Mike seja a primeira pessoa que depositou 10 pepinos no contrato e, em seguida, digamos que 100 NEAR foram distribuídos. Mike receberá todas as recompensas porque ele é o único, ele controla 100% da participação na Berry Farm agora. Mike estava offline, por exemplo, e não os reivindicou, então não podemos atualizar sua conta, porque isso deve ser feito em tempo constante. Não podemos iterar por todas as contas, mas de alguma forma precisamos lembrar que Mike pegou todas as NEAR pelos seus pepinos. 

Agora vamos dizer que Josh entra e aposta outros 10 pepinos, agora a participação de Mike é de 50% e a participação de Josh é de 50%, mas Josh apostou os pepinos depois que esses 100 NEAR iniciais já foram distribuídos. Ele não tem direito a nada disso agora e Mike precisa pegar mais 50, porque ele tem 50% de participação e Josh fica com 50 NEAR. 

Quando Mike voltar a ficar online, precisamos ser capazes de exibir seu saldo em 150 NEAR que ele ganhou em tempo constante. Portanto, este é o desafio que precisávamos enfrentar com este contrato, e a maneira como ele foi resolvido foi ter uma proporção global chamada de Near por Pepino, que diz quanto NEAR é recebido por um determinado saldo de pepino quando uma conta é criada, ou tocado de qualquer maneira.. 



Então temos um saldo NEAR, então se a última fração foi menor que a fração atual, significa que podemos multiplicar pepinos da conta dada pela diferença entre 2 frações, e calcular quanto NEAR tenho direito. Quando a conta de Mike foi criada, a fração era 0 dividida por um e quando 100 NEAR foram depositados onde a contagem total de pepinos era 10, essa fração se tornou igual a 10. foram distribuídos, esta fração foi aumentada em 5, pois havia um total de 20 pepinos e 100 NEAR. Então, 100 NEAR dividido por 20 significa 5 NEAR por pepino, então isso se tornou 15. 

Agora, quando Mike volta, ele olha para seu saldo de pepino, que é 10 Near por pepino em um contrato global, é 15, seu último valor lembrado é zero, então ele apenas pega a diferença que é 15 multiplicada por 10 e reivindica esse saldo em NEAR, e isso 1 é ajustado para 15. Quando Josh volta, ele obtém esse valor que era 10, e ele tem 10 pepinos e o valor atual é 15. A diferença é 5 multiplicado pelo saldo de pepino de 10, então ele fica com 50 Near. 

É assim que gerenciamos o saldo NEAR e apropriamos as recompensas recebidas das pessoas usando tempo constante para recalcular. Então, em vez de manter uma fração inteira na memória, usamos um denominador global que é fixo e usei-o para 10 elevado a 18, que é o mesmo que a precisão de pepinos, bananas e abacates. Esse é o pano de fundo de como tudo é calculado.



Vejamos a estrutura principal do contrato, um contrato chamado farm. Ele possui um mapa de pesquisa de contas e usa hashes curtos semelhantes a tokens fungíveis com cofres. Ele tem o ID da conta do token de banana que também pode ser codificado, mas foi usado no contrato porque podemos realmente passá-lo, porque essa conta foi implantada depois e eu não queria atualizar o estado do contrato do banana Berry Club. Eu não queria modificar o estado novamente por meio da capacidade de atualização, então, em vez disso, codifiquei o valor no contrato anterior. Near por pepino, a fração que expliquei anteriormente, é o numerador e o equilíbrio total do pepino é necessário como denominador. Cofres e próximo voto são usados ​​para transferências; eles provavelmente nunca acabaram se acostumando a transferir pepinos, exceto talvez uma vez para um teste. 



Isso é o que vimos antes de ser mais uma vez um hash do ID da conta.



A estrutura da conta é o último valor antes da conta ser tocada com essa fração. O near_balance é o saldo não reivindicado. 

Sempre que você toca em uma conta depositando mais pepinos ou reivindicando NEAR, ele atualiza o último valor e move todo o NEAR não reivindicado para o seu saldo local fora da diferença, e o saldo do pepino é o seu saldo em pepinos. O near_claimed são as estatísticas, isso está apenas dizendo quanta recompensa você já reivindicou. Não é necessário para a lógica do contrato.



Há duas estruturas auxiliares apenas para o front-end. A HumanAccount retorna valores de forma mais legível e HumanStats são estatísticas globais de consumo. Vamos entrar na função take_my_near para realmente dar uma olhada em como ela funciona.



A primeira coisa que fazemos é verificar se há pepinos suficientes lá, porque o usamos como denominador. Queremos apenas 1 pepino para realmente desencadear isso, e isso é apenas uma precaução. Você não gosta de acionar esse tipo de coisa. Vamos explorar esse valor. 

O que acontece é que você obtém a quantidade de NEAR, e yocto NEAR, e você multiplica pelo denominador global. Então você está resolvendo uma fração que é Near por Pepino dividido pelo denominador mais o saldo anexado dividido pelo saldo total de pepino. Aqui está a fórmula: near_per_cucumber / denom + attach_deposit / total_cucumber_balance. Então new_near_per_cucumber é na verdade o numerador com attach_deposit e o denominador então dividido pelo denominador. Aqui está a fórmula: new_near_per_cucumber = (near_per-cucumber_numer +denom + depósito anexado) / denom. Esta é a fórmula que usamos para calcular o new_near_per_cucumber. Sempre que você toca em uma conta, ela sempre transforma seu saldo atual não reivindicado em um número fixo e, em seguida, você pode modificar qualquer um dos valores sem quebrar a lógica. Este método de toque é chamado por cada Método Getter e cada método de mudança. Antes de modificar a conta, ele sempre chama o toque na conta.



Por exemplo, em get_near_balance obtemos a conta interna. Se a conta existir, nós a tocamos localmente. Então devemos obter o near_balance.



Se você obtiver a conta, tocamos nela antes, obtenha seu saldo_próximo, saldo_pepino e reivindique o saldo. Essas são funções de visualização que estão alterando as coisas, mas não as salva, apenas altera temporariamente o valor da conta e não a salva de volta. Ele apenas faz um toque que é uma espécie de recálculo com o valor mais recente. 



Ele o salva quando você realmente faz qualquer chamada de alteração, então, por exemplo, chame para Claim_near. Obtemos sua conta e get_mut_account realmente toca a conta. Você obtém a conta que já está atualizada e near_balance é o saldo real. 

Leva o near_balance a zero, está dizendo que você reivindicou tudo isso e salva sua conta. Então, se você reivindicar um valor positivo, nós o transferiremos para você da sua conta. Ele retorna quanto NEAR você reivindicou. A beleza desse método de toque é que ele pode ser chamado em qualquer ponto. Ele não precisa ser chamado em um determinado ponto, então sempre dará o mesmo resultado, não importa se você chamou duas vezes no meio ou uma vez. Isso é apenas para retornar ao usuário com o quanto ele tem. Ele só diz o quanto NEAR você ganhou calculando a partir do estado atual. 

No Berry Club também fazemos as mesmas coisas que tocamos, e isso é necessário, porque digamos que você queira saber quantas bananas você farmou. Como sabemos a última vez que você tocou em sua conta, quando você desenhou algo pela última vez, sabemos quantos pixels você tem. Podemos calcular de um determinado momento para o anterior multiplicado pelo número de pixels que você tinha quantas bananas você deveria ter agora, e o front-end faz a mesma coisa. O front-end o simula, obtém as mesmas informações, exceto a mais recente, e depois cria um cronômetro que as calcula. 

Em teoria, o método get_near_balance não precisa retornar seu valor NEAR que está atualizado, pode apenas dizer que aqui está o total Near por Pepino e seu último NEAR total por Pepino e também seu último saldo NEAR, mas em vez disso é feito no nível do contrato. Digamos que não tivéssemos métodos de visualização pelos quais você não paga e apenas retorna e recupera um estado, então você teria que fazer essa lógica no front end ao invés de fazer aqui na memória.
Token.rs
A lógica final que precisamos fazer é como você recebe seus pepinos do Berry Club, e isso é feito usando transfer_with_vault do Berry Club. Discutimos anteriormente como o mapa 122 funciona. 



Você passa o receiver_id, valor e carga útil. Possui um cheque assert_paid que apenas verifica se o depósito é positivo. Está dizendo "você precisa de pelo menos 1 yocto NEAR para evitar chamadas de teclas de acesso à função para evitar que uma interface do usuário do Berry Club maliciosa drene todas as suas bananas". 

Ele pega o gás e então inicia uma chamada que coloca bananas em um cofre. Ele também inicia uma chamada para o receptor. Nesse caso, chamamos de contrato on-farm e ele passa ao remetente id uma quantidade de bananas, um vault id que é apenas um u64 sem JSON e uma carga útil que é uma string. No exemplo anterior, quando estávamos falando sobre o mapa 122, o payload era um binário de vec q8 em base64, porque era um payload serializado borsh. 

Durante a discussão, observei que, se você revisar esse argumento em uma carteira, não poderá ver a carga útil que deseja fazer.  É um enum com uma única opção chamada deposit_and_stake.



Agora, quando você faz uma chamada de função da interface do usuário do farm que irá para a carteira nos argumentos, a carga útil será como uma string adjacente dentro de uma string dizendo deposit and stake em vez de ser um zero codificado como base, em vez de ser um borsh versão serializada, é legível por humanos. 

Este contrato possui tipos de payload diferentes do Uniswap. Por exemplo, ele terá um payload dizendo quanto NEAR você deseja receber no máximo ou receber no mínimo. A UI maliciosa do Uniswap pode realmente substituir esse valor e, se você não o verificar no lado da carteira, poderá cair na tendência da frente.  Obtemos a conta usando get_mut_account, que obtém uma conta existente ou cria uma nova conta onde define todos os saldos como 0, mas o último numerador próximo por pepino é o global atual. Isso significa que você não cultivou nada e tem saldo zero de pepino. Ele toca de qualquer maneira, mesmo que não seja necessário, poderíamos ter evitado isso se mapeássemos e, em seguida, ele retorna o hash e a conta. 

A conta já está em dia. O que fazemos é primeiro aumentar o saldo total de pepinos e, em seguida, salvá-lo de volta ao estado da conta e também aumentar o saldo global de pepinos pela quantidade de pepinos depositados. Então, nós realmente não verificamos se o cofre continha pepinos, então confiamos que o chamador anterior, que é um contrato de banana, realmente colocou as bananas no cofre e retornamos a promessa desse método. É uma combinação estranha com uma única entrada porque a carga útil pode ser apenas um tipo agora. 

Chamamos de retirada_do_cofre, indicamos o valor que queremos retirar, que é o valor total, e então o chamamos de volta para o ID da conta do token de banana, que é um contrato do Berry Club. Mesmo assim, esse contrato ainda não recebeu bananas, mas não importa porque não usa bananas mesmo. Ele não precisa de bananas antes que possa prosseguir, já travado. Aumenta o equilíbrio total do pepino diluindo as ações. Agora, quando o take_my_near chegar, ele usará o novo saldo total de pepino. Agora vou dividir o número de compartilhamentos entre todos os participantes. 
Conclusão
Essa é a visão geral dos contratos Berry Club, Berry Farm e token.rs. Obrigado pela leitura e boa sorte em seus futuros empreendimentos com a NEAR.

### Optimizar para NEAR Storage On-Chain (Reduciendo el tamaño del contrato)

Nota: Dejamos algunas “preguntas” para que experimenten ustedes mismos cuáles son los resultados finales.

El almacenamiento en la cadena es caro. Por cada 100 kB utilizados, se bloquea 1 NEAR. Estos NEAR se pueden devolver si eliminas el almacenamiento utilizado. Hay dos causas principales del uso del almacenamiento:

 	Transacciones: Cada transacción es un recibo, que se guarda en la cadena, por lo que ocupa algo de almacenamiento. Cada recibo de transacción tiene una longitud diferente (algunos llaman a más funciones, por lo tanto, son recibos más largos; otros llaman solo a 1 función, por lo tanto, recibos más cortos), por lo tanto, la cantidad de almacenamiento utilizada es diferente. Al igual que necesitas más papel para imprimir un recibo largo, utilizas más espacio de almacenamiento para almacenar recibos más largos.
 	Despliegue de contrato inteligente: Cuando despliegas un contrato inteligente, este ocupará el tamaño del contrato inteligente (puede diferir ligeramente de lo que ve en el archivo wasm local, pero en general las diferencias son pequeñas). Para las transacciones, a menos de que reduzcas las transacciones que realizaste, realmente no puedes reducir la cantidad de espacio que se ocupa debido a las transacciones.

(Pregunta: ¿Podemos eliminar nuestra cuenta de nivel superior a través de near-cli? Si la eliminamos, ¿se libera el costo de almacenamiento? (Por ejemplo, verifica el explorador después de eliminar una subcuenta). Ciertamente, las transacciones no se eliminarán, por lo tanto: Seguirá bloqueado el costo de almacenamiento, por lo tanto, ¿Nunca se podrá liberar?)

Aquí, hablaremos sobre la optimización del tamaño de su contrato inteligente.

Nota: se dice que el desarrollo en AssemblyScript conduce a un tamaño de wasm más pequeño, para el mismo código escrito, en comparación con Rust. Yo no soy un desarrollador de AS (prefiero usar Rust), por lo que no hablaré de eso; de hecho, yo no necesito hablar de eso, es trabajo del compilador de todos modos.
Optimizar el tamaño del contrato
Almacenamiento Persistente
NEAR tiene una lista de colecciones, la lista está aquí. Estas colecciones almacenan datos en caché para reducir la tarifa de gas. Las preguntas importantes aquí son: ¿cuánta tarifa de gas deseas reducir? ¿Cuánto costo de almacenamiento estás dispuesto a pagar por la reducción de la tarifa de gas? ¿Cuántos almacenamientos persistentes únicos necesitas?

La diferencia se menciona en el enlace de arriba (las palabras exactas son las siguientes):

Es importante tener en cuenta que cuando se usa std::collections (es decir, HashMap, etc. Rust locales), cada vez que se carga el estado, todas las entradas en la estructura de datos se leerán rápidamente desde el almacenamiento y se deserializarán. Esto tendrá un alto costo para cualquier cantidad de datos no trivial, por lo que para minimizar la cantidad de gas utilizado, las colecciones SDK deben usarse en la mayoría de los casos.

Considera este ejemplo: tenemos un contrato principal que tiene un diccionario/hash/mapa para vincular un ArticleId a un artículo. El Artículo es un objeto (en Rust, también se llama Struct) con sus atributos.
use near_sdk::AccountId;
use near_sdk::collections::LookupMap;
use std::collections::HashMap;

pub struct Contract {
pub article_by_id: LookupMap<ArticleId, Article>,
}

pub struct Article {
pub owner_id: AccountId,
pub article_id: String,
pub royalty: HashMap<Account, u16>,
}
We see that Contract.article_by_id uses LookupMap and Article.royalty uses HashMap. We shall discuss why we don’t use other types.
Considera article_by_id, cuando creamos un artículo, la identificación será única y específica para ese artículo. Se almacenará para siempre. Un LookupMap almacena en caché los resultados en la memoria para que no tengamos que "calcular" (usando la tarifa de gas) cada vez que necesitamos los resultados.

Como se mencionó anteriormente, dado que todo se deserializará si se lee al usar HashMap, y LookupMap<AccountId, Article> no es una cantidad trivial de datos (cuando se crean muchos artículos), debe estar en caché en cadena.

Ahora, ¿Por qué usamos LookupMap en lugar de UnorderedMap? Este último ofrece iterar sobre la funcionalidad de la colección, que no necesitamos. Si lo necesitas, utiliza este último.

Luego, para las regalías, estamos usando HashMap. La cuestión es que tenemos muchos artículos, cada uno con su propias regalías únicas para cada Article.royalty único, necesitamos crear una nueva clave para guardar el almacenamiento.

Dato: Si aún no lo sabes, necesitas una clave única para cada objeto de las colecciones de NEAR SDK. Si dos colecciones de NEAR SDK comparten la misma clave, comparten los mismos datos (independientemente de si eso funcionaría o fallaría si tu compartes la memoria entre dos objetos diferentes, como Vector y LookupMap)

Ilustremos el mismo escenario de almacenamiento clave compartida. Digamos que creamos dos artículos, el artículo A y el artículo B. Estos son equivalentes a Article.royalty.
// Values are percentage, 100.00% == 10_000.

// Article A
{
"alice.near": 1_000,
"bob.near": 500,
}

// Article B
{
"alice.near": 1_500,
"charlie.near": 2_000,
}
For some reason, there’s a repeat royalty for alice.near. If you use the same storage key, it will lead to error, complaining that: you already have an alice.near stored in Article A, and you are repeatingly storage another value to that key, and this is not possible. We also want them to be independent of each other; and same storage key used by 2 different HashMap means they share the same values.
(Pregunta: ¿Puedes obtener los valores almacenados en Article A si inicializas con la misma clave de almacenamiento en Article B?)

 La solución es crear una clave de almacenamiento separada para cada colección.  Sin embargo, si tenemos 1 millón de artículos, necesitamos 1 millón de claves de colección diferentes para almacenarlos por separado.  ¡Esto suena estúpido!  Por lo tanto, tiene sentido almacenarlos como HashMap.  Además, son triviales.  Estas regalías están diseñadas originalmente para limitar la cantidad de datos que pueden almacenar, por lo que la obtención de datos es pequeña y la deserialización es económica.  Esto fortalece nuestra elección de usar HashMap en lugar de las colecciones SDK equivalentes, a pesar del (ligeramente) mayor uso de Gas (que es insignificante ya que la colección es tan pequeña que es insignificante).

 En conclusión, al diseñar su contrato inteligente, elija si usar colecciones NEAR SDK o colecciones Rust en función de la trivialidad y cuántas repeticiones necesita para el mismo mapa.
Reducción de código
Los primeros códigos que escribimos son malos.  De hecho, son solo un borrador.  Necesitamos una refactorización para eliminar el código innecesario.  Hay una compensación entre el código más fácil de entender y la optimización del almacenamiento.

 Por ejemplo, quizás uno tenga un PayoutObject y solo se usa en una sola función.
use near_sdk::json_types::U128;
use near_sdk::AccountId;

pub struct Payout {
pub payout: HashMap<ArticleId, U128>,
}

impl Default for Payout {
fn default() -> Self {
Self [
payout: HashMap::new(),
]
}
}
¿Por qué no solo definimos un:
HashMap::new()
en la función específica que usa esto?  Por supuesto, si haces esto último, será más difícil entender el código.  El primero hace que las cosas sean más fáciles de entender, desde una perspectiva Orientada a Objetos.  Sin embargo, (significativamente) más código conduce a más almacenamiento utilizado después de la compilación en WASM.  Entonces, es hora de hacer algunas concesiones.

En mi opinión, la legibilidad es más importante que la optimización del espacio de almacenamiento.  Si es necesario, clona el componente legible original y optimiza cada vez que realices cambios, para que las personas puedan entender lo que estás haciendo al leer tu código original.  Por supuesto, esto significa más trabajo para ti.

(Pregunta: ¿Cuánto espacio te ahorras si reemplazas el primero con el segundo? Si tienes un escenario similar en tu programa, intenta optimizarlo escribiendo menos código y ve en cuánto espacio se compila, ¿hay alguna diferencia? (A veces no la hay, a veces si la hay. Para aquellos que no, prefieran mantener el código legible para facilitar la depuración en el futuro.))
Wasm-Opt
Después de compilar la versión de lanzamiento optimizada, aún puedes reducir aún más el tamaño del contrato utilizando wasm-opt.  Para instalar, descarga el binario aquí para su sistema operativo y descomprimelo.  En el interior, hay una carpeta "bin", en la que debes copiar la ruta exacta a esa carpeta y agregarla a tu ruta de entorno.  Después de lo cual, intenta llamar a wasm-opt desde la línea de comando/terminal, ya sea que se ejecute o no.  De lo contrario, busca en Google en línea cómo resolverlo (tal vez no lo agregaste a la variable de entorno correcta, tal vez tu terminal ya está abierta y no actualiza la ruta más reciente, son los dos problemas más comunes).

 Ejecutar estos reduciría el tamaño del archivo:
#!/bin/bash
set -e

export WASM_NAME=tipping.wasm
z
mkdir res

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
cp target/wasm32-unknown-unknown/release/$WASM_NAME ./res/
wasm-opt -Os -o res/output_s.wasm res/$WASM_NAME
ls res -lh
Aquí, asumimos que el contrato original se compila en tipping.wasm (el nombre puesto en Cargo.toml es tipping).  Entonces, el nombre optimizado es output_s.wasm.  Luego ejecutamos ls (en Linux) para verificar la diferencia en el tamaño del archivo.  Debería ser más pequeño.

 Nota: también puedes usar -Oz para las banderas, pero yo lo encontré innecesario, ya que para el proyecto en el que trabajo, no conduce a un tamaño de archivo más pequeño.

 Nota importante: RUSTFLAGS debe ser "link-arg=-s", si accidentalmente lo cambias a "-z", es posible que tengas un gran problema.  Al menos para mi, genera un archivo wasm mucho más grande.  Experimenta con él y podrás comprobarlo en tu propio proyecto.

Quizás en el futuro, podrían permitir el archivo .wasm.gz para que se pueda optimizar aún más el tamaño del archivo.  Actualmente, yo lo probé y no se puede deserializar un archivo comprimido con gzip, solo se admite el archivo .wasm en la cadena.

Cargo.toml
Estas son las banderas usuales para cargo.toml.
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
También puedes elegir opt-level = "z", podría o no generar un binario más pequeño.
 Algunas otros pequeños detalles:
Evita String Formatting
format! y to_string() pueden aumentar el código; así que usa una cadena estática (&str) siempre que sea posible.

Remueve rlib si no lo requieres

Si no necesitas realizar pruebas de simulación, elimina rlib.

Usa la serialización de borsh

Prefiere no usar serde cuando sea posible.  Aquí hay una página sobre cómo sobreescribir el protocolo de serialización.

Evita las aserciones estándar de Rust y la macro panic

Estos contienen información sobre el error devuelto, que introduce una código  innecesario.  En su lugar, prueba estos métodos:
// Instead of this
assert_eq!(
contract_owner,
predecessor_account,
"ERR_NOT_OWNER"
);

// Try this (for all versions of near-sdk-rs)
if contract_owner != predecessor_account {
env::panic_str("ERR_NOT_OWNER")
}

// For near-sdk-rs v4.0 pre-release
use near_sdk::require;
require!(
contract_owner == predecessor_account,
"ERR_NOT_OWNER"
);
require! es una macro liviana introducida en near-sdk-rs v4 (y también es la macro favorita) para reemplazar a la macro assert! Funciona como assert! en su mayoría, excepto por una pequeña diferencia: no puede especificar el format! per se.
// assert! can specify format
assert!(
some_conditions,
"{}: {}"
error_type,
error_message
);

// require! cannot
require!(
some_conditions,
format!( // you need format! yourself
"{}: {}",
error_type,
error_message
)
);
Y como mencionamos antes para evitar el formato de string, es mejor hard-codear el mensaje.  Por supuesto, si realmente lo necesitas, simplemente sacrifica algunos bytes para usar el format! ocupa solo un espacio insignificante si no lo usas mucho.

No uses .expect()

En su lugar, utiliza unwrap_or_else.  Yo escribí la función de ayuda en la NEAR crate de ayuda que tal vez quieras revisar.

 De lo contrario, siempre puedes poner esto en internal.rs:
fn expect_lightweight(option: Option, message: &str) -> T {
option.unwrap_or_else(||
env::panic_str(message)
)
}

// instead of:
let owner_id = self.owner_by_id
.get(&token_id)
.expect("Token not found");

// use this:
let owner_id = expect_lightweight(
self.owner_by_id.get(&token_id),
"Token not found"
);
Evita Pánicos
Estos son algunos errores comunes de los pánicos:

 	Indexación de un segmento fuera de los límites.  my_slice[i]
 	 División de cero: dividendo / 0
 	 unwrap(): prefiera usar unwrap_or o unwrap_or_else u otros métodos más seguros para no entrar en pánico.  En near-sdk, también hay env::panic_str (env::panic está en desuso) para panic, y mencionaron aquí que podría ser preferible.  Sin embargo, también podrías usar la coincidencia antigua para lidiar con cosas y ver si funciona mejor que panic_str;  y si no funciona mejor, usa panic_str para facilitar la comprensión del código.  De lo contrario, podrías cambiar para que coincida si vale la pena.

Intenta implementar una solución alternativa para que devuelva None o impida que entre en pánico mientras se desarrolla el contrato.
Aproximaciones de nivel bajo

 	Consulta el enlace en la referencia para conocer otras formas de reducir el tamaño del contrato que no se mencionan aquí.  (Las cosas mencionadas aquí tampoco se mencionan en su mayoría el la lista). Ten en cuenta que este ejemplo ya no se actualiza, por lo que requiere que obtengas la última actualización manualmente.

 La lista está aquí:

 	Tiny Contract(obsoleto)
 	 Contrato para fuzzing rs (puedes ver la rama maestra, esta es una rama fija para evitar que se elimine en el futuro). Yo no sé lo qué hace este contrato, ni qué significa "fuzzing";  necesitarías entenderlo tú mismo.
 	 El ejemplo de Eugene para token fungible rápido, puedes ver el video de YouTube aquí.  Lo implementa sin usar near-sdk.  Experiencia de programación más difícil, pero optimizada para el tamaño.

 Aurora usa rjson como una caja de serialización JSON ligera.  Tiene una huella más pequeña que Serde actualmente empaquetado con Rust SDK.  Ve este ejemplo y tú como lector debes derivar cómo se usa.  Otro a tener en cuenta es la crate miniserde, ejemplo aquí

La herramienta Wasm-snip
Puede ser útil reemplazar funciones no utilizadas con instrucciones inalcanzables.  Por lo general, no necesitas hacer esto: solo si realmente necesitas ahorrar ese espacio, puedes continuar.

 ¡Mencionaron que la herramienta también es útil para eliminar la infraestructura de pánico!

 También puedes ejecutar wasm-opt con la bandera –dce después de recortar, para que esas funciones cortadas se eliminen.
Conclusión
Hay muchas maneras de optimizar un contrato. Algunas optimizaciones se realizan fácilmente sin ningún cambio, otras tienen compromisos y compensaciones que tu decidirás si valen la pena o no. En general, a menos que su contrato sea absolutamente grande, lo que generalmente resulta de la escritura de demasiadas líneas de código y que se recomienda que verifiques la necesidad de escribir ese código; de lo contrario, el uso simple como wasm-opt y la opción de almacenamiento persistente deberían ser suficientes.
Referencias
Near SDK documentation on reducing contract size
Reducing Wasm size for Rust

### CalenD Beta Test

Follow @LearnNEAR on Twitter

Follow dSuite on Twitter

You may find this Telegram bot useful for beta tests


https://t.me/LNC_testenet_watcher_bot

Beta test sprint starts: June 1, 9 am ET
Beta Test sprint ends: June 3, 11pm ET.

Tired of of people missing scheduled calls? Let's make them stake NEAR to help to come on time!
Requirements:
1.  Participate as Calendar Owner 

 	Go to Decentralize Form (d-form.net)
 	Login by your near account
 	Click to Calendar in the top menu
 	Click to setting icon and do some settings here
 	Click to Share your calendar, copy the link and send to your friends
 	Capture the image
 	Tweet it "Deposit NEAR to book a meeting with me at CalenD - project by  @dSuite_Official from @LearnNEAR Barrel" + screenshot + link

2. Participate as a Calendar User

 	Go to Decentralize Form (d-form.net)
 	Login by your near account
 	Paste your friend calendar link to url
 	Book a meeting
 	Capture the image
 	Tweet
 	Tweet it "I just deposited NEAR to book a meeting at CalenD - project by  @dSuite_Official from @LearnNEAR Barrel" + screenshot + link

3. Finally, submit your feedback


The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.
Happy testing!
 

### Update - May 31, 2022

Brief Summary:

 	
NCD May Demo day live session was SUPER SOLID!


Results:

 	💸  Ⓝ320 sent to 4 promising projects! Check GitHub repo to explore. View recording here.
 	🕺 (L)Earner NFT is available for minting! First benefit proposal poll "Early access to Redeem Window for (L)Earner holder" approved.

 	🧪 GlassFund Beta test sprint ended, results coming soon!
 	 New Partner Guide: NearKits — What You Need To Know

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	🎠 LNC SocialFi playground coming soon.

### GlassFund Beta Test

Follow @LearnNEAR on Twitter
Beta test sprint starts: May 26, 9 am ET
Beta Test sprint ends: May 28, 11pm ET.
Requirements:
Follow GlassFund on Twitter (https://twitter.com/glassfundisnear)

GlassFund Tutorial
I Create a project:

 	Log in with your NEAR testnet account to https://www.glassfund.tk/.
 	Go to the “My Projects” tab, click on the “Create New Project” button → Fill in the options as you wish and click Create. It will cost you 1 NEAR for creating a project.
 	View in “My Projects” tab and “Projects” tab to confirm you have it in the list.
 	Screenshot My Projects tab.
 	Make a tweet about your activity. Include the text: I’ve created a project to get funds at https://www.glassfund.tk/ - @glassfundisnear - a project from @LearnNear Barrel.

II Support other project:

 	Login with NEAR testnet account to https://www.glassfund.tk/.
 	Go to “Projects” tab, look for 5 projects you like, and support them.
 	Screenshot of 2 out of 5 projects you think are the best.

III Claim reward:

 	Login with NEAR testnet account to https://www.glassfund.tk/.
 	Go to “My Projects” tab, find your project which is in vesting time click on it to view detail. If you haven’t any projects please follow part A.
 	Check the claimable amount, if it is higher than 0 please click the claim button.
 	Check your wallet to see if your claim succeeded.
 	Make a tweet about your activity. Include the text: Build up your dream with https://www.glassfund.tk/ - @glassfundisnear - a project from @LearnNear Barrel.

IV Force stop project:

 	Login with NEAR testnet account to https://www.glassfund.tk/.
 	Go to the “Projects” tab, looking for 2 of 5 projects, you funded, which you think are the worst.
 	Click on it to view detail, and click on the “Force stop” button

V Good to have:

 	If you have one project get force-stop by the community, please take a screenshot.
 	If you have one project get to target (or more), please take a screenshot.

You have to do all those sections above and follow our twitter (https://twitter.com/glassfundisnear) to be a valid tester. The most funded project will be considered to be the first prize. Also, your feedback is important.
VI Finally, submit your feedback by filling this form:


The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.
Happy testing!
 

### NearKits — What You Need To Know

NearKits
Ok so Nearkits is a Portfolio Tracker…Or that is what it started as. We all know it as a tool we can check our NEAR NFT portfolio on, I for one have used this countless times to check throughout this red market. They also allow a NFT transfer service between wallets and then a NFT messaging service, I’ll get to those part in a moment.
As i write this today 21/05/22 they will be minting their NFT 7PM UTC a 333 collection with different tiers, Silver, Gold and Ruby and mint cost is 10N and 50% of secondary royalties will be distributed to holders...Oh and did i mention they are also under the umbrella of Antisocial Studios




The Roadmap




Phase 1
Ok so with Phase 1 complete which included a place to check your Near NFT portfolio value in USD and NEAR with a average price of all NFT’s, The ability to be able to transfer NFTs between different wallets, the ability to be able to message an NFT owner, so for example you see an NFT you want or maybe have an offer on then you can find their address and send a message directly to their wallet. You also have a very simplified NFT gallery, nothing to celebrate about though.

Phase 2
This is the minting stage, so a collection of 333 NFTs and different tiers called access cards, what else comes with this is:


 	Batch tool listing
 	Batch NFT transfer tool
 	Batch NFT bidding tool
 	Marketplace and whale tracker
 	Personalised gallery links
 	Floor sniping bots
 	NFT price tracker based on rarity

Phase 3
So after all phase 2 has been completed we go on to phase three and what we get is:


 	Sophisticated discord server bots
 	A subscription service (Non holders)
 	NEAR fair launch protocol
 	Token Analytics Tool
 	NEARKits browser extension




Sneak peak of the NearKits NFT








These remind of the portals type access type card NFT types but its the tools behind these that will make investors want to have one and with only 333 supply and a WL mint only it will be interested to see how it goes on secondary.
Here is also what they do daily on their Twitter to keep their community up to date with NEAR NFT FP prices





These are a project that came to the NEAR ecosystem with a build utilities first mentality and to provide utility that we want or need.
(Disclaimer: I am part of their team as an Advisor)

Conclusion
So depending on when you’re reading this you might be minting or grabbing one of secondary i hope i’ve gave you enough info to make an GURU informed decision, as usual always go with that gut instinct too
Links to find them on:
Twitter: https://twitter.com/NearKits_io
NearKits: https://nearkits.io/#my_nfts
Discord: https://discord.gg/wh3GrGhbfB

### Cómo Excavar: Una Guía de Usuario Paso a Paso

Esta guía del usuario se creó en colaboración con NEAR Mates y NEAR Insights. Sígalos en Twitter para obtener más contenido NEAR de calidad, como se muestra a continuación.

Artículo Fuente en Medium
 ¿Qué es Burrow?
Burrow es un mercado de dinero autónomo, descentralizado y sin custodia, de naturaleza similar a Aave y Compound.

Burrow tiene como objetivo desbloquear la liquidez para los activos que devengan intereses, en particular, los derivados de participación de capa 1 como stNEAR y stETH. Los usuarios de Burrow podrán depositar stNEAR como garantía, luego pedir prestado más NEAR para crear una posición de participación apalancada, o pedir prestada una moneda estable para hacer una posición de autopago.


Inicios

¿Nuevo en NEAR?
Si no tiene una cuenta NEAR, ¡simplemente siga esta guía para configurar su billetera NEAR primero!
Conecte su billetera NEAR
Inicie la aplicación Burrow y conecte su billetera NEAR en la esquina superior derecha.








Cómo Proporcionar
Los usuarios pueden aportar activos al protocolo y comenzar a ganar intereses.

Las tasas de interés son variables y fluctuarán dependiendo de la tasa de utilización del activo dado. (Más sobre el modelo de tasa de interés aquí.)

Activos admitidos en el lanzamiento:

 	NEAR
 	stNEAR (staked NEAR)
 	ETH
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (token nativo de Burrow)

1. Vaya a "Deposit" y elija el activo para proporcionar
Vaya a la sección "Deposit" y haga clic en el activo que desea depositar.






 	
 Seleccione la cantidad que desea depositar y envíe su transacción.

 	
 Una vez que haya depositado sus activos, ahora tiene dos opciones:






(1) Habilite "Use as Collateral" (Usar como garantía).

Esto significa que ahora podrá tomar prestados activos contra la cantidad que depositó en el grupo de suministro.

Esto también significa que sus fondos pueden potencialmente ser liquidados. Consulte las secciones "Health Factor" y "Liquidation" a continuación para obtener más información.

(2) Simplemente suministre activos, no  “Use as Collateral”.

Esto significa que simplemente ganará intereses sobre la cantidad que suministró al grupo, sin más préstamos de activos. En este caso, sus bienes no están sujetos a liquidación.

Siempre puede activar "Use as Collateral" más adelante en su página "Portfolio".
4. Aprobar la transacción en el aviso de la billetera NEAR.




Su depósito ahora se ha registrado con éxito y puede comenzar a ganar intereses. El número "APY" (annual percentage yield - rendimiento porcentual anual) le indica cuánto puede esperar en recompensas de $BRRR por suministrar activos.


Cómo Pedir Prestado

Ahora que ha suministrado sus activos al fondo de liquidez de Burrow, también puede pedir prestado fondos contra él.

1. Designe sus Activos Como Garantía
Para pedir prestados activos, primero debe habilitar "Use as Collateral". Si no ha activado el botón "Use as Collateral" al depositar, puede ajustar su posición en la sección "Portfolio" → "Adjust Collateral".

En Burrow, puede elegir qué activos depositados desea usar como garantía, así como personalizar la tasa de colateralización.




2. En la página "Borrow", seleccione el activo que desea tomar prestado




3. Ingrese el monto que desea pedir prestado, teniendo en cuenta el Health Factor (Factor de Salud) resultante




¿Qué es el “Health Factor - Factor Salud”?
El riesgo de una posición puede entenderse a través del Factor de Salud, que representa los índices de garantía combinados de los activos prestados.

 	Si el factor de salud es superior al 100%, significa que la cuenta está en buen estado y no se puede liquidar.
 	Si el factor de salud es inferior al 100 %, significa que la cuenta se puede liquidar parcialmente y no se puede pedir prestado más sin pagar una cantidad de los activos existentes o proporcionar más activos colaterales.

Para obtener más información sobre cómo se calcula el factor de salud, 

¿Qué es “Liquidation''?
La liquidación es cuando su posición se cierra a la fuerza por el protocolo (es decir, su garantía se vende) porque, debido a cambios en las condiciones del mercado, el valor de su garantía ya no es suficiente para garantizar su deuda en función del Factor de salud, lo que significa que usted corre el riesgo de no poder pagar su deuda. Este tipo de insolvencia amenaza el protocolo, por lo que se desencadena un evento de liquidación a través de bots para prevenirlo de forma anticipada.

Esto podría suceder cuando:

 	La garantía disminuye en valor (por ejemplo, el precio de wNEAR disminuye de 20 $ a 10 $)
 	La deuda prestada aumenta de valor

Puedes leer más sobre la liquidación aquí.

TL;DR
Cuando tu factor de salud es...

 	Verde: Sus fondos están (generalmente) seguros
 	Amarillo: el riesgo es moderado
 	Rojo: sus fondos corren un alto riesgo de ser liquidados

Advertencia

 	Recomendamos a los usuarios NO establecer la tasa de utilización de garantías al 100%. Usted está pidiendo ser liquidado!
 	El factor de salud puede cambiar si el precio de los activos subyacentes cambia en gran medida. Recomendamos a los usuarios monitorear su Factor de Salud de vez en cuando, especialmente si hay cambios rápidos en las condiciones del mercado.

4. Enviar y aprobar la transacción







Cómo administrar sus activos
Acceda a "Portfolio" en el menú para ver y administrar sus activos depositados y prestados.

Net APY
Su "APY neto" es su APY total (rendimiento porcentual anual) que calcula cuánto está ganando al depositar activos (APY de depósito) menos cuánto debe al protocolo de préstamos (APY prestado).

Retirar
Elija el activo que desea retirar y haga clic en "Withdraw".





Si desea retirar todos sus activos, asegúrese de pagar su deuda primero. Si el retiro del 100 % no funciona, bájelo a alrededor del 99 % e inténtelo de nuevo.

Si retira solo una parte de sus activos y mantiene su posición de deuda, tenga cuidado de cómo esto alterará el factor de salud y administrará su riesgo de liquidación.




Ajustar Garantía (Adjust Collateral)
En Burrow, puede personalizar la tasa a la que se garantizan sus activos y configurarla de manera diferente para cada activo que proporcione. Esto es diferente de los protocolos de préstamo anteriores cuyas tasas de garantía se fijaron en una tasa predeterminada.

Puede establecer la tasa de garantía deseada cuando deposite sus activos por primera vez, o vaya a "Portfolio" y haga clic en "Adjust Collateral".




Pagar
Para pagar su deuda pendiente, vaya a la sección "Portfolio" y haga clic en el botón "Repay".





¿Depositar NEAR, pagar con wNEAR?
Debido a la diferencia en los estándares de los tokens, Burrow (y la mayoría de las otras dapps de DeFi en NEAR) usan wNEAR ("wrapped" NEAR), no NEAR.

Cuando deposite, su NEAR se envolverá automáticamente, por lo que no tendrá que hacer nada. Sin embargo, si pidió prestado $ wNEAR y desea pagarlo, debe hacerlo como wNEAR. Use la página de envoltura de Ref Finance para envolver su NEAR en wNEAR primero.

En el futuro, Burrow admitirá el wrap/unwrap (envolver/desenvolver) directo en la propia aplicación. Además, la función de wrap/unwrap se integrará en la billetera NEAR para que este problema se resuelva más fácilmente.




Para leer sobre la diferencia entre wNEAR y NEAR, consulte nuestras preguntas frecuentes.




Burrow está en Vivo en Mainnet! Lea estas Preguntas Frecuentes para Comenzar

¡La espera terminó! El primer mercado monetario en NEAR native finalmente está disponible en mainnet. Esto significa más liquidez y DeFi…


burrowcash.medium.com










Próximamente: ¡Staking xBRRR!
En breve, el staking se activará en Burrow. Los usuarios pueden apostar su BRRR y recibir xBRRR, con los que pueden acceder a recompensas mejoradas y participar en la gobernanza del protocolo. ¡Manténganse al tanto!


Conviértete en un Cerdo de Madriguera

Dapp • Twitter • Discord • Docs

### Update - May 20, 2022

Brief Summary:

 	
May Redeem to NEAR window ran lightning fast!


Results:

 	💸  Ⓝ500 sent to 250 (L)Earners. LNC Community believes  there was a partially successful Sybil attack.
 	We started LNC DAO on testnet. Every LNC active member is invited to join Community group

 	🧪 MultiCall Beta Test Sprint  - This time both Mulicall and LNC sending awards to testers. Win-Win-Win at work!
 	 New Partner Guide: What is Ref Finance? A Step-by-Step Guide (L)Earn refLEARNs!
 	Learn NEAR Club is in Top 10 NEAR Dapps! Congrats!


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	(L)Earner NFT launches next week! Stay tuned!

### What is Roketo

‘So what exactly is Roketo? Why would you choose cryptocurrency as a payment method? And how are you different from the dozens of other crypto payment services out there?’ — We hear these questions a lot and collected our best answers in this article.
Below we are going to cover how Roketo works and why it will radically change your payment process.
Many companies struggle to find a fast and reliable way of payment especially if their teams are distributed across several jurisdictions. In this case cryptocurrency saves you from the hassle of the international wire transfers which can be time-consuming and require some paperwork.
Roketo is a crypto streaming service which allows you to pay people and services per second. Low commission, fast speed of transactions, and transparency make it a perfect solution for payroll delivery. Our clients use our service to pay employees, transparently send grant funds, drop their own tokens, and vest to their investors. Real time streaming is also handy when it comes to pay-per-minute services such as car parking, equipment or co-working rental.

How does it work?
Roketo links to a user wallet and transmits funds to recipients in real-time. The payer logs in with NEAR wallet, sets up a stream, its duration, and other settings, enters the recipient’s wallet address and then starts streaming the money. The funds are delivered to the stream wallet of the recipient, who can then withdraw them to convert them.





How is it different from other solutions on the market?
Low commission
Roketo is built on NEAR and this enables us to keep one of the lowest commissions on the market. While our competitors take 50$–100$ per stream, each Roketo’s stream setup costs less than 1$. On top of that, you will have to pay the gas fee for your transactions which in NEAR ecosystem is also lower than in other blockchains. Just a comparison: in Etherium cost per transaction is slightly more than $1 and in NEAR it costs just a few cents.
This means that with Roketo senders can efficiently set up hundreds of streams at the lowest possible cost and recipients can withdraw money as often as they prefer.
Fast transactions
Real-time streaming means your funds come every second at a certain speed and your recipients can withdraw them at any moment. You can forget about hours of waiting in other services, not to mention days when it comes to traditional financial instruments.
Transparency
Our clients get complete transparency of funds allocation and payroll delivery. Even when doing mass payments to their investors or community, companies still have complete control over the real time token allocation. Each stream has unique url where you can keep track of the distribution. It facilitates financial planning, tax payments, and reporting.
Intuitive interface
You need no more than one minute to set up your first stream in Roketo. Every option for stream controlling can be accessed and updated easily from both receiver and sender with no 3rd parties. Pause, resume, stop, extend streams and get the full operation history in the dApp. User interface is comfortable to use even for the team members without crypto knowledge.
Recently we have secured $900,000 in the seed round with the participation of Move Capital, MetaWeb Ventures, and A&T Capital. This investment will help us develop our product even faster so stay tuned for the new updates.


Links:


 	Join our community on Twitter
 	Chat with us on Telegram
 	Join us on Github
 	Try out Roketo Protocol
 	Visit our Website

### What is Ref Finance? A Step-by-Step Guide

NEAR Protocol is slowly gaining momentum as one of the leading DeFi protocols. As of now, the total value locked in NEAR DeFi is a little south of half a billion dollars. However, the metric to note is in the bottom left corner.



More than 50% of the TVL is dominated by Ref Finance, making it - by and large - the biggest DeFi app on NEAR. Ref Finance was the first DeFi app on NEAR, and it combines multiple functionalities like decentralized exchange (DEX), lending protocol, synthetic asset issuer, etc. 
Ref Finance – A Brief Introduction
Ref Finance was created by the co-founder of NEAR Protocol – Illia Polosukhin. The application was officially deployed in April 2021. Proximity Labs received a grant from NEAR Foundation to bootstrap and scale Ref Finance.

Ref closed a private sale in March 2022 with investments from Jump Crypto (Lead), Alameda Research, Dragonfly Capital, etc. The primary purpose of the funding was to get enough liquidity to stay afloat for 24 months starting from March 2022. Ref Finance raised $4.8m in stablecoins for 3,664,943 REF tokens. 
REF – Token Utility
The native token of Ref Finance is REF. It's a NEP-141 fungible token with a 100 million total supply. The tokens are distributed as such:



The main roles of the REF token are as follows:

 	Users can stake REF to earn protocol fees.
 	Uses can provide liquidity to token pairs with REF and earn swap fees.
 	REF LP tokens can be further farmed to earn more rewards.
 	REF stakers can participate in network governance.

Looking Into Ref Finance
Let’s take a closer look at Ref Finance and what it brings to the table. The app has the following features:

 	Swaps (including stableswaps)
 	Liquidity aggregation
 	Pools
 	Farms
 	xREF staking.

Swaps
The first feature of note is swapping. The user experience here is pretty simple. First, you connect your NEAR wallet to Ref Finance → Choose the tokens you want to swap → Complete the swap.



On the backend, the Ref swap is pretty similar to Uniswap’s. Multiple pools contain different token pairs with their corresponding liquidity. Every swap has a corresponding swap fee ($0.005), distributed to the liquidity providers.

Do you want to test out the swap feature? Go to the testnet and swap using the LNC tokens.



Oh, and don’t worry, this is a testnet, so you will not be using any real tokens.  At the core of the swapping function is the constant product formula popularized by Uniswap: x * y = k

So, what exactly does this formula mean?

Each liquidity pool in Ref has two tokens – x and y. “K” is a constant that’s determined by the governance. The formula states that trades must not change the value of x*y from k. As per the formula, large transactions usually execute at worse rates than smaller ones.
Stableswaps
There is one more cool subfeature of the swapping function. This feature lets you swap between the following stablecoins – USN, USDT, USDC, and DAI.

The underlying formula here is the one that Michael Egorov and Curve Finance popularized.



In this equation:

 	D is the invariant
 	A is a coherent factor, which is set to 240 (can be adjusted by the DAO)
 	n is the number of stable tokens

So, why do stablecoin swaps need a new formula? As per Egorov, since the slippage is so high, the returns for a stablecoin pool that uses the constant product formula will produce paltry returns.

The stableswap formula provides a better tool to swap stablecoins and reduces market friction by improving DeFi arbitrage.
Multi-chain liquidity aggregation


One of Ref Finance's main goals is to create a multi-chain future Via a liquidity aggregator. As a first step, Ref Finance will be using the EVM-compatible Aurora Liquidity Aggregator. The aggregator accumulates data across all Dexes on the Aurora chain and NEAR. The aggregator allows users to freely interact with both NEAR and EVM-friendly DeFi ecosystems.

The aggregator works like this:

 	First, it queries relevant trading data on Auror.
 	Then, it finds the optimal route across all liquidity pools on NEAR and Aurora to swap Token A for Token B.

The swapping on Aurora's liquidator aggregator works like this:

 	The tokens get transferred to a mapping address on Aurora.
 	The swap happens on Aurora via the user's NEAR account keys.
 	The tokens get transferred from Aurora's mapping address to the user's NEAR wallet.






	

	
	
		
			
				The constant product formula x*y = k is ideal for?
			
		

		
					

		
			
			
			
			Normal swaps
		
			
			Stablecoin swaps
		
			
			Cross-chain swaps
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Liquidity Pools


Up next, we have the bread-and-butter of DeFi protocols – liquidity pools. A liquidity pool has two (or more) tokens that allow users to trade without going through an intermediary. Instead, users can give liquidity by locking up tokens in the pool. In return, they earn LP tokens and trading fees. 

Ref Finance charges a fee for using their pools. The pool fee varies from 0.05% to 0.3%. Fees are accrued in real-time and can be claimed when you withdraw liquidity.

Let’s look closer at one of the more popular pools on Ref – the WBTC/ETH pool. Usually, this pair is pretty popular across DeFi.



As you can see, the WBTC/ETH pool has the following relevant metrics:

 	TVL: $28 million
 	24-hour volume: 512,000
 	Total WBTC: 424.69
 	Total EH: 5,860

If you want to create a new pool, you will simply need to enter the token pair and the accepted fees.


Farms


Up next, we have farming. The prerequisite for farming is that you must be providing liquidity to one of Ref Finance’s pools. When you provide liquidity, you get LP tokens as a receipt of your contribution. So, you can earn on top of your LP rewards by further staking your LP tokens. This process of staking your LP and earning rewards is called yield farming.

By going to the “Farm” menu, you can see both live and ended farms. Currently, the farm with the high APR is the REF-wNEAR one.



The REF-wNEAR farm has a staggering 71.1% APR with a 2X boost. In addition, this farm paid out $133,000 in rewards last week. The farming rewards are paid out in marmaj, DBIO, SKYWARD, REF, MYRIA, and PARAS tokens.
xREF Staking
Up next, we have xREF staking. Upon staking your REF, you exchange it for xREF. Over time, you will continually earn more REF by holding xREF tokens. 

Being an REF staker gives you the right to earn fees generated by the protocol. 100% of the protocol fees generated are used to buyback REF, of which:

 	75% is transferred to the xREF contract.
 	25% is allocated to the treasury. The treasury is responsible for funding grants and community initiatives.

The staking rewards are released linearly every quarter and has in built boosts for the first three years (which could be changed by the governance):

 	Year 1: 2x
 	Year 2: 1.5x
 	Year 3: 1.2x
 	Year 4: 1x

Here are some numbers for xREF staking:



Feature
Number


Staking APR
12.22%


Number of Unique Stakers
5465


Revenue Shared with xREF Holders
105,561.75 REF


Total REF Staked
3,101,195.30 REF


Total xREF Minted
2,916,845.51 xREF


Cumulative REF Buyback
132,011.31 REF



Cross-chain Interoperability
Allbridge is a cross-chain bridge launched on the NEAR Protocol that allows it to interact with other blockchains like Solana, Celo, and Terra. However, for Ethereum-NEAR interoperability, the rainbow bridge still remains the best option. Users can access these disparate blockchain ecosystems through these bridges via Ref Finance.

So, not only can you access the best of NEAR’s DeFi on Ref, but you can also jump over to access liquidity in other DeFi-rich blockchains.




	

	
	
		
			
				Ref Finance users can interact with EVM-compatible ecosystems via:
			
		

		
					

		
			
			
			
			Liquidity Pools
		
			
			Farming
		
			
			Multi-chain aggregator
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ref Finance Governance
Ref Finance governance happens via the DAO that was set up by Proximity in June 2021. The DAO currently uses SputnikDAO contract to manage its affairs. The DAO has two different types of members – Council and Community.

 	Council: The council members can create proposals and vote on them. Only council members can create proposals.
 	Community: Community members can vote on the proposals.

Conclusion
Ref Finance is the OG of the NEAR DeFi ecosystem. It has well throughout tokenomics and brings together the functionalities of Uniswap and Curve Finance under one roof. Check out the app first-hand by going to the testnet. Try swapping with the LNC tokens. The testnet allows you to trade without using any actual money.




	

	
	
		
			
				I have USN-USDT LP tokens but want to earn more yield. Which feature should I use on Ref FInance? 
			
		

		
					

		
			
			
			
			Swapping
		
			
			Farms
		
			
			Pools
		
	
		

		
		
			
				Correct!
				Wrong!

### Multicall Beta Test

Beta test sprint post mortem:
On May 10-12, we had a Beta test sprint in partnership with LNC.

I’ll start with a few stats:

 	47 Multicall instances were created by (who we think are) 40 testers.
 	There were ~36 submissions in total. 12 invalid, 24 accepted.
 	The accepted submissions were done by 14 testers. On average, each one of these submissions had 2 feedback items => Typical power-law distribution: minority of testers submitted majority of feedback. We tried to adapt rewards accordingly.
 	5 testers made a Twitter post.

It was made clear to us from the beginning that testers will find difficulties with our project, since it required familiarity with DAOs. We included instructions in our guide on how to create a DAO and pass proposals using SpuntikDAO. This confused many testers into thinking SputnikDAO is part of our project and so we got a lot of feedback about the SputnikDAO website, which we’ll forward to their team. Key learning here is that, in case multiple platforms are used, the test guide should very clearly state what platforms are the focus of the test sprint. Another key takeaway from this experience was the importance of making feedback easy. At first we used GitHub issue templates, which requires testers to have a GitHub account. What actually happened is that almost only people who already had GitHub accounts gave feedback. Others just didn’t bother. After switching to Airtable forms we got much more submissions. This was also reflected in the quality of feedback, where on the 1st day almost all submissions were valid, because people making them are somewhat technical (again, they were active on GitHub prior to this), but after the switch to Airtable, we got many invalid submissions (empty forms, mis-understanding…). Regardless, we’ll make sure our users can easily submit feedback in ways that require no extra effort from them.

All in all, the experience was very positive, and we’ll recommend other projects to do it as well. It helped us realize shortcomings about our UI/UX, as well as give us insights about what we should focus on, when writing user guides and tutorials.

 

Follow @LearnNEAR  and @multicall.near on Twitter
Beta test sprint starts: May 10, 9 am ET
Beta Test sprint ends: May 12, 11pm ET.
Requirements:
near-multicall testing guide

 	near-multicall testing guide

 	What’s a DAO?
 	What’s near-multicall?
 	Setting up near-multicall

 	(a) Create a DAO:
 	(b) Get a near-multicall instance for your DAO:


 	Create proposals with multicall



What’s a DAO?
Near-multicall is a tool that serves DAOs, so we’ll start by explaining DAOs first.
DAO stands for Decentralized Autonomous Organization, and is essentially a blockchain account governed by a group of people using rules set by a smart contract. A member can propose to do something, like “Donate 10 $NEAR to charity” or “Buy this NFT for 1 $NEAR”. Other DAO members can vote “yes” or “no”. If the proposal successfully passes voting, then this is where the true value of DAOs shines: members don’t have to trust a person to correctly execute the proposal actions. Instead the smart contract does it, which makes the process trustless.
We put emphasis on code and smart contracts, but luckily you don’t have to be a coder to make a DAO, there are projects that allow you to create your own DAO in few clicks: SputnikDAO and AstroDAO are such examples on NEAR protocol.

What’s near-multicall?
Near-multicall is a tool for DAOs to create and execute arbitrary actions in one single proposal. Example: a DAO has $USD tokens and wants to buy NFTs, which are listed for $NEAR tokens. Currently the DAO will have to make a proposal for each step:


 	Exchange $USD tokens for $wNEAR tokens
 	convert $wNEAR to $NEAR
 	Buy the NFT

The DAO members will have to agree and vote 3 times, even though all steps serve one purpose (to buy the NFT). With Near-multicall this can be done in one proposal.
With this test sprint, we’d like to know about bugs or feature suggestions to improve our UX. You can submit feedback here.
Additionally for curious developers: we have a bug bounty on our contracts of up to 100 $NEAR for each critical issue that leads to: stealing or permanent freezing of funds by non-admins, or non-admins triggering any malicious logic on behalf of the contract. Other critical issues can be eligible and will be reviewed on case-by-case basis.

Setting up near-multicall
Step 1 - Create a DAO:
For the purpose of this guide, we’ll be using SputnikDAO on testnet:


 	
Get a NEAR testnet wallet: https://wallet.testnet.near.org/

 	
Go to: https://testnet-v2.sputnik.fund/#/

 	
Sign in with the wallet you created: 

 	
Click “create new DAO”: 

 	
Fill out DAO info: 
In the above picture:


 	Name: This also determines the DAO address. If we choose “my-test-dao” as DAO name, then DAO address will be “my-test-dao.sputnikv2.testnet”. This address works like a normal NEAR account: you can send funds to the DAO from your wallet, the DAO can interact with platforms on NEAR such as Paras or Ref-finance and it can hold several tokens as well as NFTs.
 	Purpose: any text works here, it does not affect how the DAO will work.
 	Council member: Your testnet wallet address goes here. This makes you the first member in the DAO.
 	Amount to tranfer: This is the aomunt of $NEAR tokens you’ll be giving to the DAO upon its creation. We suggest 20.


 	
Click submit and confirm the transaction:
Upon success you’ll find your DAO page by modifying the following link to have its address:
https://testnet-v2.sputnik.fund/#/DAO_ADDRESS
for example:
https://testnet-v2.sputnik.fund/#/my-test-dao.sputnikv2.testnet
we’ll use the DAO page to create and vote on proposals, so leave it open on a separate browser tab to use it later.

 	
Done! 



Note: If you need assistance with this step, please reach out in LNC Telegram or near-multicall discord


Step 2 - Get a near-multicall instance for your DAO:

 	Go to https://multicall.app/ and login with your wallet.
 	Enter the full DAO address in the DAO selector field: 
Always make sure your DAO address is there during all tests.
 	Create a multicall instance for your DAO: 
 	go to DAO page (section (a) step 6): you should find a proposal that says: “create multicall instance for this DAO at …”. Vote “yes” on this proposal.
 	go back to https://multicall.app/#/dao and enter DAO address in DAO selector again (like step 2). If you see the following then setup was successful  

 Seen any bugs? report HERE
 Got a suggestion? please use this FORM

Step 3 - Create proposals with multicall

 	First proposal will mint 2 tokens
In this test we’re going to mint some $USDC and $DAI. If successful, the tokens will appear on your testnet wallet. Let’s start:


 	
go to: https://multicall.app/#/app

 	
enter the DAO address: 

 	
Let’s use our first card: 

 	
fill card information with the following:
Contract address: nusdc.ft-fin.testnet
Function name: mint
Function arguments (!!! replace YOUR_WALLET_ADDRESS):

  {
      "account_id": "YOUR_WALLET_ADDRESS",
      "amount": "123456789"
  }

Allocated gas: choose a number between 7 and 10. (i.e. 7.5 Tgas)
Attached deposit: 0 yocto


 	
Second card:
So the previous card was for minting tokens, the second card is just a trick for the wallet to display our token balances
Contract address: nusdc.ft-fin.testnet
Function name: ft_transfer
Function arguments (!!! replace YOUR_WALLET_ADDRESS):

{
    "receiver_id": "YOUR_WALLET_ADDRESS",
    "amount": "123456789"
}

Allocated gas: choose a number between 7 and 10. (i.e. 7.5 Tgas)
Attached deposit: 0 yocto


 	
Mint a second token:
In steps 4 & 5 we worked on cards that will mint $USDC, so now let’s do the same for a second token $USDT. The UI has a “clone” feature so we don’t repeat the work all over again. On the new cards we just change the address from nusdc.ft-fin.testnet to nusdt.ft-fin.testnet


 	
Almost done! we just have to propose our multicall to the DAO


 	
go to DAO page and vote yes on the proposal:


 	
Done! Can you see the tokens on your wallet? If you do, congrats, you did it! 

 	Take a screenshot of the proposal and tweet it:
"I just made a @multicall.near proposal during Beta Test Sprint at @LearnNEAR"+screenshot

 Seen any bugs? report HERE
 Got a suggestion? please use this FORM



If you made it this far, thank you! We appreciate you taking the time to test our project.

Please use this FORM to share your experience, and any general thoughts with us!



The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.
Happy testing!
 

### Update - May 5, 2022

Brief Summary:

 	
NCD April Demo day brought super interesting projects!


Results:

 	💸  Ⓝ200 sent to 6 promising projects! Check GitHub repo to explore.
 	🧪 dWork Beta Test Sprint STARTED! This time we will be using the dApp to test itself!
 	🧪 LNC Barrel is FULL STEAM! 3 graduated projects, 10 is brewing! You may get a chance to have your projects there as well, just (L)Earn! 
 	
 New Community Guide: Simulation Testing (Rust)


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	refLEARNs are going to be the first (L)Earning partners opportunities

### dWork Beta Test Phase 2

Follow @LearnNEAR on Twitter
Beta test sprint starts: May 5, 9 am ET
Beta Test sprint ends: May 7, 11pm ET.

This time we will be using the dApp to test itself! Let's have some fun with dWork!
Requirements:
What’s new?
- Modern UI
- Better UX
- Filter tasks based on categories
- Search
- Fully decentralized

Notes: To complete the beta test, you have to create two accounts and participate as a requester and a worker to understand what we are developing.

Follow dWork on Twitter https://twitter.com/dworkisnear
1.  Participate as a worker:
- Complete this task: https://www.dwork.tk/task/root-dwork.testnet_89094474
2. Participate as a requester:
- https://www.dwork.tk/task/root-dwork.testnet_89094706
- Submit your work in this task https://www.dwork.tk/task/root-dwork.testnet_89094574
3. Finally, submit your feedback about the new dWork here:
https://www.dwork.tk/task/root-dwork.testnet_89094384
Testnet account used at this step will be used as matching for mainnet one for award payouts.

 

The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.
Happy testing!
 

### Multiverse Fighters - P2E Game on NEAR

In this article, we will take a look at some aspects of Multiverse Fighters, thanks to which our project can become the flagship of P2E in Near Protocol.
Gameplay
Clans
This is already a familiar mechanic for MMORPGs. People with common gaming goals unite to spread their influence. In general, nothing new, but you can't do without them.
DAO and orders
We decided to combine these 2 items, because they are closely related. The orders represent an important social component of the project. Moderators, artists, writers and journalists are all representatives of the community and develop together with the project, and their work is rewarded from the ecosystem pool. More about the order system here - blog/Order-System

DAO in the project is a vote for key innovations, for example, choosing a suitable description for an item, the name of a character or adding a new weapon developed by one of the players to the game. The direct participation of the community in the work and development of the project distinguishes Multiverse Fighters from competitors!

The project is built on the cutting-edge NEAR blockchain, giving us the ability to transparently reward players and community members through NFT and a token.
Arenas and tournaments
Arenas, like regular fights, can be both single and group, as well as with different conditions of fights, for example, only fist fights, or without equipment and only with a knife. Lots of options ;) The players in a duel in the arena themselves set a bet for the victory, which can be either a token or any NFT, it adds excitement to ordinary fights.

The conditions of some arenas can also be offered by the community and put for voting in DAO. At the end of each month, the most unpopular arena is removed and a new vote is held. Tournaments are held every day and are divided into daily, weekly and monthly. They differ in the prize pool and take place in one of the arenas, the conditions of the fights will depend on it.
Moving and interacting
An interactive map and interaction with interesting NPCs will not let you get bored even when you get tired of fighting, nothing prevents you from getting aesthetic pleasure from the world around you in the multiverse.

Even choosing a path when moving between locations can create an interesting adventure for you, which can end with both an attack by robbers (other players) and a meeting with unique NPCs that even many elves have not met, dwarves tell legends about them.
Diverse gameplay
Beautiful visual component and unique situations created by the Multiverse are great for streams and video content, which allows you not only to play Multiverse Fighters, but also to watch other players with interest.
Utility of token
Thanks to the extensive application and deflationary model, the value of the MF token will only grow.

Trade and rent of NFT, upgrade and repair of some NFT, staking, selection and reset of attributes, more details can be seen on the attached diagram.
Ecosystem pool
Thanks to the ecosystem pool, our economic model differs from the usual pyramid, in which the first investors earn on newcomers. With the help of gaming activities, we return to the player most of his investment in the first month of the game. And from the second month he can already start making a profit. But since not all players devote all their time to the game, the rewards remain in the ecosystem pool to make it possible for active players to earn.

Thanks to the constantly replenished ecosystem pool - Multiverse Fighters is an excellent game project with a sustainable economy.



Web3
Web3 is an idea for a new iteration of the World Wide Web based on blockchain technology, which incorporates concepts such as decentralization and token-based economics. Some technologists and journalists have contrasted it with Web 2.0, wherein they say data and content are centralized in a small group of companies sometimes referred to as "Big Tech"....

Yes, Web3 has not been formed at all yet, which allows us to take a direct part in it ourselves. Thanks to our principles of community building and the introduction of DAO system, we ourselves become part of Web3, where the content in the Multiverse Fighters is decentralized between the community and the players themselves.

### Simulation Testing (Rust)

Before we Start

This article do not show the possibilities a simulation testing framework can do; it discusses about how to create an MVP simulation testing framework for your project. For more advanced changes, do your own research (DYOR) and check out some links one included in this article.


NOTE: Simulation tests will go deprecated as Sandbox comes up. Check out workspaces-rs and workspaces-js.

Brief Introduction
The difference between unit testing and simulation testing is; the former is restricted to testing within the library; while the latter simulate a call from the outside in. Unit testing mostly test internal frameworks for correct logic; while simulation testing tries to simulate user actions and check whether things goes as the developer expects. Treat each function as a simulation.


If you’re fantasized with one test one assertion, please don’t. Even for unit test, one do not agree with one assertion per test function framework; what says simulation tests requires more than one assertions within a single function/simulation.

As usual, the simplest example is the Greeting App; so we’ll use that and write a simulation test for it.

Greeting Simulation test
You don’t need to write your own greeting app: just run this command:

npx create-near-app --contract=rust <your_project_name>
Violà! You now have a greeting app example with a simple frontend. Follow the instruction to deploy the contract and test around with it until you’re familiar before moving on. Checking out the last few lines of the output.
We suggest that you begin by typing: 
cd <your_project_name>
yarn dev
Copy the command and test out how the app works until you’re familiar with it. After testing, stop the deployment temporarily: it’s quite annoying to redeploy everytime you make a small change(s) from one’s point of view if we don’t need the frontend.

Create Simulation Test Folder
Without consider NEAR, simulation testing is also called integration testing in (pure) Rust. If you want to know more, please refer to The Rust Book or Rust By Example to check how to perform integration testing.
In short, you require a folder entirely outside of src called tests. So we’ll do that now. Assuming you already cd into your project directory, run this:

cd contract
mkdir tests 
mkdir tests/sim
touch tests/sim/main.rs
Navigate and open up <your_project_name>/contract/tests/sim/main.rs and open it up in the editor of your choice.
Now, you can either dump everything into one file, or you could split it. Generally, you have a utils.rs to make non-test functions that are reused. You can have another .rs file for multiple short tests. If you have longer tests, like the simulation tests from the lockup contract, one suggests one file per test; and name your file accordingly. You wouldn’t want your readers to see a file with 1000+ lines of code.
Now, even though the Greeting wouldn’t have long simulation tests, one will show you what one means by one test per file by deliberately separating them. You don’t have to do it, though.

Include Dependencies
We need a library called near-sdk-sim. This example uses near-sdk v3.1.0, so we’ll use the corresponding near-sdk-sim v3.2.0 (one don’t know why they don’t match, though). Bear in mind, however, if the version don’t match, simulation tests won’t run, because it says Import near_sdk::some_fn is not equal to near_sdk::some_fn, which is confusing (but actually near_sdk::some_fn is indeed different from near_sdk::some_fn: they have different versions!)


One actually likes writing with near-sdk v4.0.0-pre.4, but that requires some changes to the contract for it to run. The changes aren’t complicated, mostly about AccountId is no longer String and some other smaller stuffs; but that’s not the point of this article, so we’ll stick with 3.1.0 and perhaps update this article in the future if it updates. (Plus there’s some bug with v4 simulation which we’ll talk about later).

Let’s go to Cargo.toml: it should now look like this: (see new section dev-dependencies). It’s important to ensure rlib is present too!

[package]
name = "greeter"
version = "0.1.0"
authors = ["Near Inc <hello@near.org>"]
edition = "2018"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "3.1.0"

[dev-dependencies]
near-sdk-sim = "3.2.0"

[profile.release]
codegen-units = 1
# Tell `rustc` to optimize for small code size.
opt-level = "z"
lto = true
debug = false
panic = "abort"
# Opt into extra safety checks on arithmetic operations https://stackoverflow.com/a/64136471/249801
overflow-checks = true

[workspace]
members = []

Previously one wrote a guide on reducing contract size; including removing “rlib”. To use simulation tests, though, it requires “rlib”, so it’s a trade-off between contract size and doing simulation tests.

If you have stopped yarn dev, now compile the contract once to download the library. In contract, run:

cargo build

Make sure you have lots of disk space (recommended 20GB free space) as this takes up quite a lot of space!


For smooth experience during first-time compilation, try compiling on a machine that has 16 vCPU and 8 GB RAM. Especially librocksdb-sys will take a loooooooooooooooong time to compile. It isn’t clear whether compilation is transferable (certainly not across OS, but unsure within the same OS). Since one rented a VM on Azure, one could easily change the size temporarily and change it back to a smaller (and cheaper) size after compilation, hence no conflict.

Let’s move back to write the simulation tests in main.rs.

Prepare the wasm file
Please be aware: everytime you make changes to your contract, you need to rebuild the wasm. We made a script here to build your wasm file and move it to the top directory res folder.
So run this: (from the contract directory)

mkdir res 
touch build.sh
Then, include the content below inside contract/build.sh so you can run bash build.sh (inside contract folder) instead of typing the command out every time.
#!/bin/bash 
set -e 

export WASM=greeter.wasm 

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release 
cp target/wasm32-unknown-unknown/release/$WASM res/
Imports
This is easy: we treat the library as a library. Remember, those that are pub(crate) originally in the library cannot be used in simulation tests (since this is outside). It’s just like you compile it and someone is using your code. Ensure to import those functions that you need.
If we check the src.lib.rs, we see there’s (only) a Welcome struct. When you import it, you add the Contract keyword behind. For example:

use greeter::{
    WelcomeContract 
};
For the lockup contract, their main struct is called LockupContract, so when they import, it’s LockupContractContract. One do not know why they made it this way, perhaps for non-conflict; just add it!

Include contract files
The next thing before we test it works, is to include the wasm file. This is a must. Also, if you have a utils.rs, this should NOT be put there; otherwise you need to think hard how to make it discoverable from other files. To not think hard, we put it in main.rs:

// Directories are relative to top-level Cargo directory. 
near_sdk_sim::lazy_static_include_bytes! {
      GREETER_WASM_BYTES => "res/greeter.wasm" 
      // other wasm bytes.  
}
What one means by “top-level Cargo directory” means the contract directory. Certainly you can discover stuffs outside it with ../../some_file if you ever need it. For example, if you don’t use the res but the yarn dev, the out/main.wasm is outside the contract directory. To import that, we do:
near_sdk_sim::lazy_static_include_bytes! {
     GREETER_WASM_BYTES => "../out/main.wasm" 
}

Since this is a macro, ensure that you don’t accidentally put a “comma” (“,”) after the last item; otherwise you might get weird error messages and Rust refuses to compile.

Unfortunately, we couldn’t really test this function while it goes until we created the helper function (a complete MVP) and an MVP test.

Initialization Function
To not repeat the setup function, we include them inside basic_setup(). Check the basic_setup() of the lockup contract for another example (which includes deployment of other contracts than their main testing contract). Here, we’ll also do the same, but we don’t have other contract to setup so we’ll skip that and just include the necessary functions in basic_setup().
Make a utils.rs:

touch tests/sim/utils.rs
Inside utils.rs, we insert the content:
use crate::*; 

/// 300 TGas 
pub const MAX_GAS: u64 = 300_000_000_000_000; 

/// 1 NEAR (just a random number) 
pub const MIN_BALANCE_FOR_STORAGE: u128 = 1_000_000_000_000_000_000_000_000; 

pub const GREETER_ACCOUNT_ID: &str = "greeter"; 

pub(crate) fn basic_setup() -> (UserAccount, UserAccount) { 
  let mut genesis_config = GenesisConfig::default(); 
  genesis_config.block_prod_time = 0; 
  let root = init_simulator(Some(genesis_config)); 

  let alice = root.create_user( 
    "alice".to_string(), to_yocto("200") 
  ); 

  (root, alice) 
}
There are some important things to note here. The first is this block of code:
let mut genesis_config = GenesisConfig::default(); 
genesis_config.block_prod_time = 0; 
let root = init_simulator(Some(genesis_config));
The Genesis is the first block of the blockchain. However, genesis and genesis time isn’t really the same. For example, the root represents the blockchain itself. It’s not the near or testnet top-level account: it’s the blockchain. However, if you check out the explorer on testnet, we see that it’s created during the Genesis. So, the root comes first, then it’s packaged with some of the accounts during Genesis time. We create a simulator of the Genesis called root.
Here, what we mean by Genesis is not genesis time, but the “ultimate root”. It’s the “parent account” of all top-level accounts.
Usually, we don’t need to modify the GenesisConfig; and if you need, this is one example.
If you ever need to make changes to the genesis, check out the docs for values you can change. Then, you can modify it line 2 in the code block above by assigning each field a value. Finally, you need to initialize the simulator with init_simulator.
If you don’t need modification, you can initialize a simulator with no configuration (which will use the default) like this:

let root = init_simulator(None);
Next, we have the root creating an account called “alice” for us. The first argument is the account name, the second is how many NEAR to give to the account.


Because root is the Genesis, it can only create top-level accounts like near, testnet, alice. It cannot create sub-accounts like alice.near: only the parent account near can create alice.near, not the Genesis.

One thing we don’t have here is deployment with root. For our contract, we use the deploy! macro which we’ll do in the test function instead of here. But if you have other wasm file, like the lockup contract does, they can’t use the deploy! macro, so this is how they did it.
For example on the whitelist contract; it’s deployed on root like this:

let _whitelist = root.deploy_and_init( 
  &WHITELIST_WASM_BYTES, 
  STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(), 
  "new", &json!({
    "foundation_account_id": foundation.valid_account_id(), 
  }).to_string().into_bytes(), 
  to_yocto("30"), 
  MAX_GAS, 
);
Because the requirement for an init function to be called once during deployment is so common, there’s a function deploy_and_init. If the contract does not have a deploy function (assuming whitelist doesn’t have one here), we can do this.
let _whitelist = root.deploy(
 &WHITELIST_WASM_BYTES,
 STAKING_POOL_WHITELIST_ACCOUNT_ID.parse().unwrap(),
 to_yocto("30") 
);
and in reality there’s no deploy_and_init function, so we call it manually. To do this, we need an account to call it who have the ability to do so. For the lockup, it’s the foundation
let foundation = root.create_user("foundation".to_string(), to_yocto("10000"));
 foundation.call(
   STAKING_POOL_WHITELIST_ACCOUNT_ID.to_string(),
   "new", 
   &json!({
      "foundation_account_id": foundation.valid_account_id()
   }).to_string().into_bytes(),
   MAX_GAS,
   NO_DEPOSIT, 
).assert_success();

We note that reality and simulation have some differences.

Lastly, don’t forget to import it to main.rs and import the required functions:

use near_sdk::Balance;
 use near_sdk_sim::runtime::GenesisConfig;
 use near_sdk_sim::{init_simulator, to_yocto, UserAccount};
 pub(crate) mod utils;
 use utils::*;
Building first test function
We’re ready to build first test function. First, import the required functions in main.rs:

use near_sdk_sim::{deploy};
This is the deploy macro.
Create a file for the test:

touch tests/sim/test_set_and_get_greeting.rs
As one comes from a Python background, one like to name functions starting with test. You don’t have to. Here, one adopt naming the file name starting with test_; while the action testing function inside without. Example, we’ll have a set_and_get_greeting() function inside test_set_and_get_greeting.rs (file).
Import the file into main.rs before we forget:

mod test_set_and_get_greeting;
We don’t need pub(crate) like utils does as it doesn’t need to share anything with other files.
The first thing we need in the set_and_get_greeting function is to deploy the contract.

 let greeter_amount = to_yocto("1000");
 let (root, alice) = basic_setup();

 let greeter = deploy!(
   contract: WelcomeContract, 
   contract_id: GREETER_ACCOUNT_ID.to_string(),
   bytes: &GREETER_WASM_BYTES,
   signer_account: root,
   deposit: MIN_BALANCE_FOR_STORAGE + greeter_amount 
);
If we have a custom #[init] method, we include these after deposit arguments:
gas: MAX_GAS,
 init_method: <method_name>(method_args)
However, if we don’t have, we remove them. For a bunch of traits that match the macro, check the docs. You need to match at least one of them; otherwise Rust refuses to compile.
(Question: Does the order matters? Or just the bunch of kwargs needs to match one of the traits?)
Note that unlike reality, the deployment is done by root again (you can see from signer_account). In reality, it’s done by some account responsible for it.
Next, let’s set a greeting and get the greeting and assert they’re as expected.
It seems like people like to assign to a variable call res which is reused over and over again. It’s not the clearest way; but we surely can do that to not cram our head and think of variable names. res just means “results” returned from a particular function call.


It’s a good practice to assign your res with a type, (irregardless of whether Rust can infer the type or not), so you know what type is returned.

Remember we have view_method and change_method in smart contract. For the contract deployed with deploy! (which is the smart contract you can import and the one you’re mainly testing), we can use view_method_call and function_call respectively. We’ll speak in a while if we have external wasm how to call.
Our set_greeting is a change_method, so we’ll use a function_call. A function_call takes in a PendingContractTx, Gas and Deposit.
The PendingContractTx is just the function, and other arguments are easy to interpret what it is. Let’s see our set_greeting:

let greeting: String = "Hello, NEAR!".to_owned();
alice.function_call(
  greeter.contract.set_greeting(greeting),
  MAX_GAS, 0 
).assert_success();
Ensure you pass in the respective arguments in the function. We also call assert_success() at the end to make sure the Promise is fulfilled. The above is imitating the near-cli:
near call $GREETER_CONTRACT set_greeting '{
  "message": "Hello, NEAR!"
 }' --gas=$MAX_GAS --amount=0 --accountId=$ALICE_ACCOUNT_ID
Then, we can have the view function call. If you check the function, get_greeting takes an Account Id of type String and returns a String.
let res: String = alice.view_method_call( 
  greeter.contract.get_greeting(alice.account_id().to_string())
 ).unwrap_json();

One suspects you don’t need .account_id().to_string(), just .account_id() is sufficient. Here, we’re just making it explicit because it takes in a String. If it takes in AccountId, we could just call .account_id() without any confusion. (Especially when AccountId no longer equals to String starting near-sdk-rs v4.)

As the result returned is a JSON, we unwrap it with unwrap_json().
Then, we could make assertions on the result.

assert_eq!(res, greeting);
Recall greeting is a variable we assigned earlier on, which is “Hello, NEAR!”.

Running the integration test
If you just want to run the integration test, run
cargo test --tests sim (because it’s in the tests/sim folder). If you want to run every test, including unit tests, run cargo test.
Note, for some reason it takes like 30 seconds or more (irregardless of how many CPU cores you have); you have to wait before the test even starts.
A reminder again: if you make changes to the contract, you need to rebuild it; otherwise you’ll wonder why it doesn’t run and you believe it will run now so…

Complete Code
You can find the complete code here: https://github.com/Wabinab/NEAR_greeter_integration_tests

Conclusion
Now, you can repeat other tests (if you have any) by creating new file, link it using mod to main.rs, write the tests inside. It’s a fun exercise: the more you write, the more you understand.

A note on upgrading to v4.0.0-pre.4
The whitelist contract deploy_and_init function needs changes on these:
AccountId is no longer String


 	So replace all "alice".to_string() with "alice".parse().unwrap(). If the replacement is inside a function which it cannot parse, you need to create a variable. (This is especially true in the deploy! macro, which has no type inference).

let alice_account: AccountId = "alice".parse().unwrap(); 

// pass it to the function. 

 	

 	
valid_account_id is deprecated. Use account_id() instead. This occurs in json!.

 	
Any integer passed to json! requires specification. Example: v3.2.0 allows 10, but v4.0.0-pre.4 don’t allow: you must say 10u64 or any other types.

 	
The #[quickcheck] macro has a bug and fails the test with v4. One file an error on Github; as of writing, the Dev team doesn’t reply yet.


Feel free to check out the lockup contract simulation test on one’s book (currently in pre-Alpha as of writing) for perhaps more tips and tricks not listed here. (This is MVP, anyways).

References

 	https://www.near-sdk.io/
 	https://www.near-sdk.io/testing/simulation-tests
 	https://wabinab.github.io/NEAR-book/simulation/sim_01.html
 	Lockup contract: https://github.com/near/core-contracts/tree/master/lockup/tests

### Update - April 22, 2022

Brief Summary:

 	
It's been busy weeks at LNC!


Results:

 	💸  Ⓝ500 sent to 500 (L)Earners during April Redeem to NEAR Winodw!
 	🧪 Ⓝ30 sent to NMS - NEAR Message System  Beta Test winners! Congrats!
 	🧪 Ⓝ50 sent DeepGreen Beta Test winners with Gachip_1010.near won award of Ⓝ50! Congrats!
 	LNC tokens crowd sale on testnet was a blast! 1M LNC tokens were sold for $NEAR 167,682.


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	We are launching MASSIVE DeFi/SocialFi testnet playground initiative at LNC! Stay tuned!

### Os 7 principais projetos de NFT  na NEAR

O crescimento do DeFi trouxe os NFTs para o foco principal, e o crescimento dos NFTs também trouxe vários problemas ainda mais à vista. Ethereum tem o monopólio deste setor, com muitos NFTs criados em sua blockchain. Então, qual é o problema de criar NFTs em uma das plataformas mais populares do mundo? A questão das altas taxas de gás. O Ethereum tem um grande problema quando se trata de taxas que podem ultrapassar centenas de dólares, o que o torna muito impraticável.

Então, quais são as opções quando se trata de NFTs e projetos NFT? Que outras opções eles têm? O protocolo NEAR tem vários projetos importantes em sua plataforma e é frequentemente apontado como o assassino do Ethereum. O protocolo NEAR é um blockchain escalável que simplifica e acelera o desenvolvimento de dApps. No momento, existem 19 plataformas descentralizadas e NEAR NFT Marketplaces para cunhar e negociar NFTs no em sua blockchain. O protocolo NEAR tem uma vantagem significativa sobre o Ethereum, pois é significativamente mais rápido e as transações custam quase nada, tornando-o uma plataforma ideal para negociação em NFTs.
Protocolo NEAR e NFTs
O protocolo NEAR é a plataforma perfeita para NFTs pois possui muitas vantagens sobre o Ethereum. O protocolo é significativamente mais rápido. O Ethereum também tem taxas de gás substancialmente mais altas, enquanto o NEAR permite que as transações sejam processadas por uma taxa insignificante. Esses fatores tornam o NEAR ideal para comprar e vender NFTs.

Como mencionado anteriormente, já existem vários projetos NFT que foram criados no blockchain NEAR. No entanto, antes de dar uma olhada nos projetos, vamos entender brevemente o conceito de NFTs.
O significado de Não Fungível
Um ativo fungível é um ativo que pode ser trocado por outro ativo idêntico. Bitcoin é um excelente exemplo de ativo fungível, o que significa que você pode trocar um Bitcoin por outro Bitcoin sem problemas. Os ativos não fungíveis, por outro lado, são ativos únicos que não podem ser negociados. Um exemplo de ativo não fungível pode ser uma pintura exclusiva ou colecionáveis ​​de edição limitada.
Um ativo não fungível tem uma propriedade ou propriedades distintas que o diferenciam de outros ativos. Os tokens não fungíveis são baseados em ativos não fungíveis e são ativos digitais exclusivos que usam a tecnologia blockchain.
O que é um NFT?
NFTs são ativos digitais exclusivos que têm suas informações de identificação registradas em um contrato inteligente. A informação no contrato inteligente é o que torna um NFT único. Ativos fungíveis como Bitcoin podem ser trocados, o que significa que você pode enviar ou receber Bitcoin sem problemas. Os ativos fungíveis também são divisíveis, permitindo que você envie quantias menores. Já os ativos não fungíveis não são divisíveis. Por exemplo, você não pode enviar a alguém uma parte de uma pintura ou um ingresso.

NFTs são certificados digitais de propriedade para ativos digitais. Um NFT é um contrato inteligente utilizado para proteger um ativo digital. Uma vez escrito, é publicado em um token (ERC-721) no blockchain. Qualquer coisa pode ser transformada em um NFT, sendo os mais populares vídeos, GIFs ou JPEGs.




	

	
	
		
			
				Which of the following is an NFT? 
			
		

		
					

		
			
			
			
			Bitcoin 
		
			
			Fiat currency
		
			
			A digital collectible
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Projetos NFT no Protocolo NEAR
Atualmente, existem várias plataformas NFT no NEAR, então vejamos alguns dos projetos mais populares na plataforma.
Mintbase
A Mintbase começou em 2018 e foi criada por Nate Geier e Calorine Wend. Nate Geier é o CEO da empresa, enquanto Caroline é a COO, utilizando sua experiência em gerenciamento e desenvolvimento de negócios. A Mintbase conseguiu levantar US$ 1 milhão em uma rodada de financiamento inicial em 2020. A Sino Global liderou a rodada e também consistiu em outros Fundos de Capital de Risco, como Block Oracle Capital, D1 Ventures e outros investidores-anjo.

Mulher Peixe por From My Dream

A plataforma Mintbase permite que os usuários criem e vendam NEAR NFTs. Os usuários podem cunhar diferentes ativos digitais como NFTs. Esses ativos podem variar de ingressos para eventos à arte criptográfica e tudo mais.

A Mintbase permite que praticamente qualquer pessoa com acesso à Internet faça um NFT e o disponibilize para venda em seu mercado NEAR NFT ou em mercados NFT como o OpenSea. Os mineradores podem criar um contrato inteligente e limitar a transferibilidade dos tokens cunhados, ajudando a evitar fraudes ou a transferência ilegal de itens exclusivos. A Mintbase está focada em criar uma experiência de criação de NFT única, e é por isso que, como mencionado anteriormente, ele suporta diferentes ativos digitais. Isso é contrário às plataformas concorrentes que se concentram em uma categoria NFT específica.
Por que a Mintbase mudou para NEAR?
Então, por que a mudança do Ethereum para o NEAR? A resposta é taxas de gás. As taxas de gás do Ethereum começaram a se tornar ridiculamente caras. Para cunhar NFTs na Mintbase, o usuário precisa criar uma loja digital. Isso envolve o usuário criar um contrato inteligente e pagar ao Ethereum uma taxa de gás. Inicialmente, a taxa era baixa e os usuários conseguiram implantar a loja rapidamente. No entanto, com o aumento do congestionamento na rede Ethereum, as taxas começaram a ficar cada vez mais altas, com a criação de lojas custando centenas de dólares. O custo tornou-se tão alto que a Mintbase teve que dizer a seus usuários para esperar que os preços do gás caíssem antes de implantar uma loja. O Ethereum rapidamente se tornou insustentável para comprar, vender ou criar NFTs.

A Mintbase viu a NEAR como uma plataforma melhor em comparação com o Ethereum, com taxas de gás significativamente mais baixas graças a um modelo de execução de contrato mais eficiente. Ele também usa Nightshade, uma abordagem dinâmica para Sharding. No entanto, existem várias outras razões pelas quais a Mintbase mudou para NEAR.

 	O uso de Rust ou AssemblyScript para contratos inteligentes na plataforma NEAR facilita para os desenvolvedores escreverem código
 	NEAR apresenta endereços legíveis por humanos para contratos e contas
 	Os desenvolvedores podem integrar usuários rapidamente, graças ao NEAR Drops. Eles podem pagar por suas contas NEAR e enviar tokens NEAR
 	Desenvolvedores e usuários podem mover ativos rapidamente graças à ponte ETH-NEAR Rainbow
 	Outras plataformas DeFi, como Aave e Balancer, também estão no NEAR, o que facilitará qualquer integração futura.




	

	
	
		
			
				Why did Mintbase switch to NEAR? 
			
		

		
					

		
			
			
			
			High Gas fees
		
			
			NEAR is a better platform 
		
			
			Developers can move assets faster
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras foi criado com a visão de fornecer a solução para o envelhecimento dos cartões colecionáveis ​​tradicionais. A plataforma valida a propriedade por meio do blockchain com transações rápidas e baratas. Ela se concentra na criação de coleções nativas de criptografia que podem ser diversificadas em mídias mais proeminentes.

PunkyPoN#0006 por monztre.near

Paras é um mercado de cartões de arte digital tudo-em-um construído na NEAR. A plataforma pode validar a propriedade e dar acesso a cada compra e cunhagem aos usuários. Oferece transações rápidas e baratas e se diferencia de outros marketplaces por oferecer coleções em vez de lançamentos únicos. A plataforma se diferencia da seguinte maneira.

 	Reduz a carga de manutenção dos colecionadores, garantindo que seus colecionáveis ​​não se desgastem com o tempo. A plataforma remove barreiras e oferece aos artistas e colecionadores acesso fácil ao mercado de colecionáveis ​​digitais. Graças ao Protocolo NEAR, Paras pode reduzir os custos incorridos pelos artistas para vender seus cartões.
 	Está desenvolvendo a vertical do Digital Art Card para futuros artistas, jogadores e criativos e permitindo que os artistas criem uma coleção vinculada a um tema ou tradição. Através deste método, os cartões de arte digital em Paras são ricos em histórias e cenários.

Paras é capaz de adotar uma abordagem com curadoria e criar uma comunidade e experiência em NFTs. Também garante consistência e qualidade ao selecionar artistas e formatos. Artistas podem criar novos cartões no Paras somente após serem aprovados, e o número de novos artistas aprovados é limitado a 30 artistas por semana. Os artistas também precisam estar em conformidade com a proporção padrão de 64:89.




	

	
	
		
			
				What is Paras? 
			
		

		
					

		
			
			
			
			An all-in-one digital art card marketplace
		
			
			A smart contract platform 
		
			
			A programming language 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Desde o lançamento da plataforma, os artistas do Paras já faturaram mais de US$ 25.000, com a plataforma capaz de facilitar um volume de negociação de mais de US$ 35.000 em mais de 700 transações. A plataforma conta com mais de 80 colecionadores ativos e mais de 70 artistas. A baixa taxa de cunhagem mantém a barreira de entrada para artistas digitais bastante baixa, e os artistas podem cunhar cartões sem se preocupar com o custo de cunhagem.
Por que NEAR é uma ótima combinação para Paras?
Como a demanda por espaço no Ethereum está elevando os custos da plataforma, os novos criadores de NFT estão procurando alternativas e soluções. A NEAR está trabalhando com o Ethereum em uma solução interoperável. As transações na NEAR custam apenas alguns centavos e, às vezes, até menos. A carteira NEAR é altamente eficiente e as transações são concluídas quase instantaneamente. A ponte Rainbow garante que o NEAR será interoperável com ativos baseados no Ethereum.
(L)Earner NFT
O Learn NEAR Club também está emitindo nossos próprios PFP NEAR NFTs – (L)Earner, Genesis Edition. Lançaremos este projeto em meados de fevereiro e já começamos a colaborar com um dos designers gráficos mais premiados do mundo para torná-lo um grande sucesso. Acreditamos que este projeto vai evoluir o espaço NEAR NFT de forma massiva. Mais detalhes sobre as (L)Earner NFTs, incluindo o custo de cunhagem, serão anunciados em breve.
Você pode se inscrever aqui para obter acesso antecipado ao mint. E, claro, você precisará ser um membro do LNC e estar pronto para gastar alguns nLEARNs para participar.
Hip Hop Heads
Hip Hop Heads marca a entrada de um pilar da cultura americana no espaço criptográfico. A série de arte colaborativa apresenta o trabalho de Andre LeRoy Davis, o criador do icônico The Last Word da Source Magazine, e também apresenta a animação de fundo de um dos co-proprietários da The Source Magazine, Ed Young.

Hip Hop Heads nasceu de uma colaboração entre o Museu Universal Hip Hop, o Protocolo NEAR e Ed Young. Juntos, eles decidiram criar uma coleção NFT que apresentava artistas dos anos 70 até hoje. A coleção, chamada NFT.HipHop Heads, contará com 47 dos maiores artistas de rap e homenageará não apenas os artistas, mas também marcará o 47º ano da era Hip Hop. O projeto se reconecta com as raízes do rap utilizando os mais recentes avanços tecnológicos.

HipHopHead 10.292.22166

Cada ilustração existirá como uma coleção de 47, significando 47 anos da era Hip Hop. A primeira edição de cada Hip Hop Head é nomeada dependendo do lugar do artista na história do Hip Hop. O significado de cada artista é demonstrado através de uma ilustração criada por Andre LeRoy Davis. O código de animação de fundo é resultado dos números mais significativos da história do Hip Hop que demonstram a passagem da era Hip Hop ao longo de 47 anos. A coleção NFT será leiloada todos os dias em seu site até o dia 24 de julho.
Por que Hip-Hop Heads escolheu NEAR?
O protocolo NEAR permite que a coleção Hip Hop Heads seja mais acessível à população em geral. Conforme mencionado anteriormente, a coleção será leiloada diariamente até o dia 24 de agosto e poderá ser adquirida com cartão de crédito. Isso permite que a NEAR torne o projeto mais viável. O mercado de leilões também destaca os recursos do Protocolo NEAR, como uma interface familiar e amigável semelhante à web-2, cunhagem de NFT fácil e relativamente barata e acessibilidade ao usuário final.

Como os usuários podem comprar NFTs usando um cartão de crédito, o mercado oferece uma maneira simples de compra sem etapas complicadas que fazem os usuários pularem obstáculos. Os royalties da NFT no protocolo NEAR são gravados no código NFT, permitindo que os criadores ganhem royalties de vendas secundárias, mesmo que a NFT mude para outro mercado. Isso é possível graças ao padrão NFT em nível de contrato da NEAR. NEAR dá aos artistas e criadores o controle de seu NFT, permitindo que eles se beneficiem de seu trabalho.
NPunks
Após o tremendo sucesso de Cryptopunks, Solpunks e Tpunks, a NEAR finalmente terá sua própria versão do projeto, chamada Npunks. Assim como no projeto Punks original, haverá 10.000 NPunks únicos com suas próprias características de raridade. A coleção terá 9 alienígenas, 24 macacos, 88 zumbis e 111 bots.



Para evitar o acúmulo e garantir uma participação justa, todos têm a chance de comprar um (ou mais Npunks). As compras são feitas aleatoriamente e a identidade é mantida em mistério até que a transação seja considerada completa. Os usuários são livres para vender seu Npunk no mercado secundário após o lançamento.
NEAR Misfits
NEAR Misfists é a primeira coleção NFT criptograficamente completa da NEAR. Os Misfits consistem em 1.600 Normie, 150 Zombies, 101 Skellies, 50 Meerkats e 22 Glitch Misfits.



Em novembro de 2021, 1.923 NFTs Misfit foram vendidos em menos de 36 horas. A partir de agora, você pode comprar esses NFTs em mercados NEAR NFT como Paras e Mintbase.
NEARNauts
O NEARNauts é um NFT gerado aleatoriamente e orientado pela comunidade que visa desenvolver uma comunidade orgânica e leal em torno do projeto. Um conjunto de características raras garante exclusividade verificável. Esta função aleatória verificável (VRF) inclui três algoritmos – gerado, prova e verificação.

 	         Generated: Isso produz dois pares de chaves – uma chave secreta (SK) e uma chave pública (pk).
 	         Prova: Toma o SK e a mensagem (x) para fornecer uma saída aleatória (y) e uma prova.

·         Verificação: O algoritmo de verificação pega pk, x e y e usa a prova para verificar a validade da saída.



O DAO da comunidade NEARNauts será lançado no primeiro trimestre de 2022.
Conclusão
A NEAR está tornando a construção e implantação de dApps mais fácil, rápida e barata do que qualquer outro protocolo blockchain e é um dos projetos mais promissores no espaço criptográfico. Ela aborda vários problemas enfrentados por projetos no Ethereum, como altas taxas de gás e baixas velocidades de processamento. Ele também tem várias vantagens sobre o blockchain Ethereum graças à sua solução fragmentada.

O Protocolo NEAR mostrou uma promessa significativa, utilizando Sharding para resolver problemas enfrentados por outras blockchains. Graças a essa abordagem, a NEAR pode aumentar a taxa de transferência sem comprometer a segurança. O NEAR Collective garante que engenheiros e desenvolvedores trabalhem constantemente no protocolo.

### Protocolo NEAR e Polygon

Polygon ganhou muita força nos últimos meses. Com a escalabilidade sendo a última moda na comunidade Ethereum, faz sentido porque as soluções de camada 2, como a Polygon, ganharam tantos seguidores. No entanto, o Protocolo NEAR  não apenas oferece uma plataforma altamente escalável na camada base, mas também oferece uma experiência de camada 2 compatível com EVM. Hoje, vamos comparar esses dois projetos.
O que é Polygon?
Então, para entender Polygon , vamos primeiro olhar para a camada 2. Na rede Ethereum, o blockchain Ethereum base é conhecido como “layer-1”. As redes descentralizadas priorizam a segurança e as sondagens de atividade, o que inevitavelmente compromete a velocidade. A solução aqui é construir uma rede adicional acima da blockchain central chamada camada 2. O blockchain delega cálculos complexos para a camada 2, o que acelera exponencialmente o rendimento geral. Polygon é um exemplo de uma solução de camada 2.

O token nativo do ecossistema Polygon é MATIC. Os principais utilitários da MATIC são:

 	         Finalidades de pagamento e liquidação entre os participantes.
 	         Staking e governança. Quanto mais MATIC você “aposta”, maior é o seu poder de voto.
 	         Pagar as taxas de transação.
 	         Recompensar os usuários por fornecer recursos e serviços computacionais.

MATIC tem um fornecimento total de 10 bilhões de tokens.
Mecânica de Polygon
Polygon possui um ecossistema multinível que utiliza sidechains ou cadeias laterais compatíveis com EVM. O objetivo dessas cadeias laterais é desobstruir a cadeia principal. Sidechains são blockchains laterais que estão ligados à cadeia principal por meio de um pino bidirecional. A sidechain pode ter suas próprias regras e ecossistemas exclusivos. Periodicamente, as cadeias laterais devem enviar dados para o blockchain principal para garantir operações contínuas.

Os desenvolvedores criam suas próprias cadeias laterais para escalar seus aplicativos utilizando a pilha do Polygon SDK. Polygon ganhou popularidade principalmente porque é muito mais barato de usar do que a rede principal Ethereum e é muito mais rápido.

Polygon usa um mecanismo de Prova de Participação (PoS) e qualquer pessoa pode se tornar um validador fazendo staking de seus tokens MATIC. Os validadores têm as seguintes funções no ecossistema:

 	         Validação de transações aprovando e confirmando trocas nas sidechains.
 	         Os validadores de rede podem cuidar da governança votando em várias atualizações.
 	         Responsável por selecionar produtores de blocos para cada checkpoint (mais sobre isso daqui a pouco).

As sidechains em Polygon são uma seção do ecossistema Ethereum em que os usuários podem executar rapidamente seus projetos sem se preocupar com os preços inflacionados do gás e o rendimento lento.

Como Polygon garante velocidade e descentralização

O PoS da Polygon é usado principalmente para “checkpoints”. Isso significa que uma equipe de produtores de blocos é nomeada para cada ponto de verificação, e esses produtores são responsáveis ​​por manter e garantir o consenso. Ter um número limitado de produtores permite que Polygon forme blocos muito mais rápido que o Ethereum (taxa de bloco de 1 segundo em vez de 20 segundos).

Além disso, Polygon garante a descentralização delegando pontos de verificação PoS periodicamente à cadeia principal do Ethereum. Cada bloco criado pelo produtor do bloco deve ser validado por meio de uma prova de bloco comprometida com a cadeia Ethereum.

Como interagir com Polygon?

Isto é o que você precisa fazer para interagir com um projeto baseado na cadeia lateral da Polygon:

 	         Identifique o contrato na rede Ethereum e declare o número de tokens que você deseja enviar para a cadeia lateral da Polygon.
 	         Um contrato inteligente especial chamado “RootChainManager” ativa outro contrato chamado “ChildChainManager”. Esses dois contratos funcionam em conjunto para garantir que o número de tokens bloqueados na rede Ethereum seja transferido sem problemas para a rede principal.
 	         Agora o usuário pode passar para a rede Polygon e aceitar seus tokens.

Certo, e que tal o contrário? E se você quiser sair do ecossistema Polygon e voltar para o Ethereum? Estas são as etapas que você precisará seguir:

 	         Você deve queimar seus tokens em Polygon.
 	         A verificação desta queima precisa ser enviada para a cadeia principal Ethereum.
 	         Uma vez verificados, seus recursos serão realocados para você em sua carteira.

O que é o Protocolo NEAR?
No verão de 2018, Illia Polosukhin e Alexander Skidanov criaram o Protocolo NEAR como a plataforma de desenvolvimento ideal para aplicativos descentralizados. A maioria das outras plataformas sofre de baixas velocidades, baixa taxa de transferência e baixa compatibilidade com outras cadeias.

O Protocolo NEAR foi desenvolvido do zero e possui os seguintes recursos para permitir uma boa escalabilidade e segurança:

 	         NEAR usa um mecanismo de geração de blocos chamado “Doomslug”. O Doomslug permite que os blocos recebam a finalização em segundos.

·         NEAR é um sistema fragmentado que permite escalabilidade infinita. É preciso uma abordagem única para escalar até bilhões de transações de maneira completamente descentralizada, em vez de depender de processos centralizados como outros protocolos.

O que é “Sharding” ou Fragmentação?

Continuando do último ponto, vamos entender o que é sharding. Sharding é uma técnica usada em bancos de dados para lidar com dados volumosos. O sharding divide todo o banco de dados em pedaços gerenciáveis ​​chamados “shards”. Esses fragmentos podem ser processados ​​em paralelo para computação rápida.

Agora, o que exatamente acontece em uma blockchain durante o sharding? Vamos dar uma olhada:

 	         Todo o estado do blockchain é dividido em fragmentos menores.
 	         Cada conta pertence a um único fragmento e eles podem interagir apenas com as contas pertencentes ao mesmo fragmento.

O problema com o sharding normal é que ele exige que os nós sejam executados em hardware cada vez mais complexo, reduzindo as chances de entrada. A fragmentação da NEAR permite que pequenos nós sejam executados em instâncias simples hospedadas na nuvem.

O que é Aurora?

Aurora fornece uma experiência de camada 2 compatível com Ethereum em cima da NEAR e consiste no Aurora Bridge e no Aurora Engine. Os desenvolvedores de Ethereum podem executar seus aplicativos em Aurora para aproveitar os vários recursos positivos da NEAR, como taxas de gás e sharding. No geral, estas são as melhorias que Aurora está trazendo:

 	         Os aplicativos podem processar vários milhares de transações por segundo. Esta é uma melhoria exponencial em relação ao Ethereum.
 	         Aurora é extremamente rápida, pois tem um tempo de bloqueio de 2 segundos em comparação com os 15 segundos do Ethereum.
 	         O sharding do NEAR permite que o ecossistema seja dimensionado horizontalmente.
 	         As taxas em Aurora são 1000x mais baixas do que as do Ethereum.
 	         Completamente compatível com Ethereum sobre o protocolo NEAR.

DeFi em NEAR e Polygon
DeFi em Polygon
Polygon permite que você use a maioria dos aplicativos DeFi populares predominantes no Ethereum, como Curve Finance, 1inch Exchange e Beefy Finance. De acordo com o DappRadar, os 5 principais aplicativos dos usuários nas últimas 24 horas são os seguintes:



Sushi como podemos ver, o aplicativo mais popular.

O ecossistema DeFi cada vez mais radical da Polygon tem sido um espetáculo à parte. A imagem a seguir mostra o Valor Total Bloqueado (TVL) em Polygon, que atualmente é de cerca de US$ 5,19 bilhões.



O TVL atingiu um pico de US$ 10,54 bilhões em 15 de junho de 2021. Além disso, quando se trata do valor real bloqueado, o Aave é – de longe – o maior protocolo, representando impressionantes 40% do total de TVL.
DeFi em NEAR
Comparado ao Polygon, o DeFi em NEAR ainda tem um ecossistema muito jovem que vem crescendo constantemente nos últimos três meses. Até o momento, o TVL é apenas cerca de US $ 141,72 milhões.



O aplicativo DeFi mais dominante que representa mais de 80% do TVL geral é o Ref Finance.

O Ref Finance tem algumas semelhanças com o Uniswap V2, além de suportar mais tipos de pool, taxas configuráveis ​​e é totalmente de propriedade da comunidade. Ref também é a primeira plataforma DeFi na NEAR. O principal objetivo do Ref é reunir DEX, protocolos de empréstimo, emissor de ativos sintéticos e muito mais sob um guarda-chuva.

A NEAR lançou recentemente um enorme fundo de doação de US$ 800 milhões que visa especificamente a criação de um ecossistema DeFi maior e mais saudável. O fundo tem alguns requisitos importantes, que incluem o seguinte:

 	US$ 100 milhões para startups
 	Fundo regional de US$ 100 milhões
 	Doações de US$ 250 milhões para ecossistemas a serem distribuídos ao longo de quatro anos.

NFT em NEAR e Polygon
NFT em Polygon
Polygon é uma das três blockchains atualmente disponíveis na Opensea (uma das maiores plataformas de comércio de NFT do mundo), juntamente com Ethereum e Klaytn. De acordo com as classificações do site, aqui estão as 5 principais NFTs em Polygon:



Parece que ZED RUN é o líder na corrida quando se trata de NFTs da Polygon. 

Então, o que é ZED? É um jogo de corrida digital de cavalos comprovadamente justo construído na blockchain. A ideia é que você colete o maior número possível de cavalos de corrida para criar um estábulo de alta qualidade.


NFT em NEAR
Atualmente, existem várias plataformas NFT em NEAR como a Mintbase. Mintbase foi iniciada em 2018 por Nate Geier e Calorine Wend e arrecadou US$ 1 milhão em uma rodada de financiamento inicial em 2020. A plataforma permite que os usuários criem e vendam ativos apoiados por NFTs. Além disso, os usuários podem cunhar diferentes ativos digitais como NFTs. Esses ativos podem variar de ingressos para eventos a arte criptográfica e tudo mais.



Curiosamente, Mintabase deveria ser lançada no Ethereum. No entanto, as altas taxas de gás e o congestionamento crescente os impediram de fazê-lo. Então, em vez disso, a Mintbase viu a NEAR como uma plataforma melhor que a Ethereum, com taxas de gás significativamente mais baixas graças a um modelo de execução de contrato mais eficiente.
Conclusão
Polygon ganhou muita tração no ano passado, com a camada 2 ficando mais popular do que nunca. Além disso, devido ao seu relacionamento próximo com a comunidade Ethereum, experimentou uma rápida taxa de adoção.

Por outro lado, NEAR se mostrou muito promissora ao resolver problemas de escalabilidade com sharding. Além disso, a concessão de US$ 800 milhões para desenvolvedores trará uma quantidade significativa de utilidade para a rede. Ambos os protocolos – Polygon e NEAR – fornecem uma plataforma perfeita para os desenvolvedores construírem uma economia descentralizada escalável e eficiente.

### O que é Tokenomics ou Tokenomia? Guia expresso

Um dos princípios centrais de uma rede descentralizada é sua Token Economia ou Tokenomia. Para ajudar os projetos a entender melhor as nuances de seus tokens, o Learn Near Club ajudou a lançar um novo playground de tokenomics prático na Rede de Test da NEAR – LNC|TokenHub . No entanto, antes de entrarmos em detalhes, vamos saber o que significa tokenomics.
O que é Tokenomics ou Tokenomia?
Token era inicialmente apenas outro termo para uma “criptomoeda” ou “criptoativo”. No entanto, ultimamente, usamos o termo “token” para explicar um ativo criptográfico que é emitido em cima de uma blockchain. O termo “tokenomics” é uma junção de “token” e “economia”, e é um termo usado para descrever, você adivinhou, a economia de um token.

Quando você deseja avaliar a tokenomics da rede, você precisa se fazer estas perguntas:

 	         Qual é a oferta total de tokens e quantos deles estão entrando no sistema de uma só vez?
 	         Quantos tokens serão criados no futuro?
 	         Como os tokens estão sendo distribuídos entre os usuários?
 	         Qual é o papel exato do token na rede?
 	         A rede precisa de um token para funcionar?

No geral, o objetivo é estabelecer um vínculo claro entre a plataforma e o ativo.
Elementos Definidos em Tokenomics
A Tokenomia pode ser amplamente diferenciada entre controle de suprimento e utilidade. Vejamos cada um desses elementos.
#1 Controle de Fornecimento
Quantos tokens de protocolo realmente estarão em circulação. Quanto desse fornecimento está sendo controlado pelo contrato base? Nesse aspecto, devemos entender certos termos.

Pré-mineração

Basicamente, quantos tokens já estão sendo negociadas livremente no ecossistema no momento do lançamento. Normalmente, os tokens são minerados periodicamente por usuários especializados chamados “mineradores”. No entanto, protocolos específicos geralmente disponibilizam uma certa % de sua oferta geral durante o lançamento para distribuição de tokens e acesso à liquidez. No entanto, observe que a pré-mineração de um grande número de tokens pode levar a problemas de centralização.

 

Alocação de token

Como os tokens são alocados para a equipe do projeto? Eles calculam uma grande quantidade de tokens, levando a problemas de centralização? Quantos tokens são alocados ao tesouro para o desenvolvimento futuro do protocolo?

 

Aquisição Progressiva de token

A maioria dos projetos recebe financiamento de VCs - Ventures Capital (Fundos de Capital de Risco) ou outros investidores, que recebem uma alocação de token em troca de seu investimento. Infelizmente, na maioria das vezes, os VCs tendem a vender sua alocação imediatamente para obter um lucro rápido, o que inevitavelmente prejudica o protocolo. Você pode bloquear uma alocação de token específica por um período de tempo especificado com aquisição de token para evitar uma venda maciça.

A Aquisição Progressiva de tokens é crucial para inspirar a confiança dos investidores, pois diz a eles que a equipe e os investidores levam o projeto a sério e não procuram um retorno rápido. A Aquisição Progressiva é uma maneira fácil de reduzir as manipulações de mercado e garantir o valor do investimento.

Queima de token

Outra tática simples que muitos projetos utilizam para controlar o fornecimento circulante é a queima de tokens. A ideia é simples – remova periodicamente uma certa quantidade de tokens de circulação permanentemente. A maioria dos projetos faz isso enviando os tokens para uma carteira morta. Projetos como Ethereum e Binance usam a queima de tokens para controlar o fornecimento (quantidade) de seus tokens nativos.
#2 Utilidade do token
Quais são as diferentes funções que seus tokens podem assumir? Vamos dar uma olhada rápida em alguns dos diferentes papéis.

 	         Os tokens podem ser usados ​​para pura utilidade e pagamento dentro ou fora do ambiente do protocolo.
 	         Os tokens podem ser usados ​​para participar do protocolo e participar da governança.

·         Manter o token de protocolo é necessário para acessar os diferentes aplicativos (DeFi e NFT) dentro do sistema.
Brincando com a Tokenomia
A ferramenta de tokenomics do Learn Near permite mapear os diferentes componentes do seu token e brincar com eles na rede de teste.

Esses componentes são:

 	         Nome do token
 	         Lançamento inicial
 	         Símbolo
 	         Tesouraria
 	         Fornecimento inicial
 	         Horário de início de aquisição
 	         Duração da aquisição
 	         Pontos decimais
 	         Intervalo de Aquisição

Brincar com esses diferentes valores ajudará você a entender o controle de fornecimento da tokenomia do seu protocolo. Quer experimentar esta ferramenta? Confira o LNC TokenHub !

### DeFi no protocolo NEAR

A NEAR Protocol é uma plataforma de contrato inteligente, que se concentra no desenvolvedor e na facilidade de uso. Ele fornece uma plataforma escalável para a execução de aplicativos. A NEAR foi fundada no verão de 2018 por Alex Skidanov e Illia Polosukhin. Hoje, neste artigo, veremos os aplicativos DeFi no protocolo NEAR .
A ascensão do DeFi
DeFi ou Finanças Descentralizadas são instrumentos financeiros baseados em blockchain. Enquanto os instrumentos financeiros centralizados são prejudicados pela falta de interoperabilidade e burocracia, os aplicativos DeFi são como blocos de Lego que os usuários podem juntar para criar novos instrumentos. Como resultado, o ecossistema DeFi saltou de US$ 7,40 bilhões em 22 de junho de 2020 para US$ 97,7 bilhões em 7 de setembro de 2021. Isso representa um aumento de valor de ~ 1220% em pouco mais de um ano! 



Atualmente, o valor total bloqueado em DeFi é de cerca de US$ 83,86 bilhões. 
O verdadeiro significado do DeFi
Apenas falar sobre o valor total bloqueado não é suficiente para entender o verdadeiro significado do DeFi. É um elemento crucial na construção da Web Aberta e foi o único responsável pelo influxo de talentos que o Ethereum experimentou nos últimos dois anos. Se você pensar bem, isso faz todo o sentido devido à natureza revolucionária e combinável do DeFi. Ações que poderiam levar semanas no mundo financeiro tradicional agora levam apenas alguns segundos.

No entanto, há um outro lado dessa equação também. Devido ao aumento da demanda, o DeFi foi responsável por causar congestionamento na rede e aumento dos preços do gas. Como tal, a barreira de entrada para o Ethereum tornou-se significativamente maior para desenvolvedores e criadores iniciantes.

O protocolo NEAR fornece uma alternativa viável, rápida e barata ao Ethereum.
Protocolos DeFi na NEAR


Vamos passar por alguns dos projetos DeFi mais promissores no NEAR.
Rainbow Bridge


A Rainbow Bridge existe entre NEAR e Ethereum . Todos os ativos originários do Ethereum agora são completamente utilizáveis ​​na NEAR. Desde o seu lançamento, mais de US$ 1 milhão em ETH, DAI e outros tokens cruzaram a ponte. A infraestrutura de ponte pode ser facilmente reaproveitada e garantir conexões entre NEAR e todas as cadeias compatíveis com EVM, como Polygon, BSC, Avalanche, Optimism, Arbitrum, etc. A equipe está trabalhando atualmente para estender essa infraestrutura para suportar cadeias não EVM como Bitcoin, Cosmos, etc

Aqui estão algumas coisas que você precisa saber sobre a Rainbow Bridge 

 	Os usuários podem interagir com a Rainbow Bridge diretamente através da MetaMask.
 	As transações NEAR são confirmadas em menos de 2 segundos e custam menos de 1 centavo em taxas de gás.

Uma transação de ponte NEAR<>Ethereum acontece da seguinte forma:

 	Os ativos que vão do Ethereum para o NEAR levam cerca de 6 minutos (cerca de 20 quarteirões).
 	As transações ERC20 custam cerca de US$ 10 em média.
 	O envio de ativos do NEAR de volta para o Ethereum leva no máximo 16 horas (devido aos tempos de finalização do Ethereum). Esse processo também custa cerca de US$ 60 devido aos custos do gas ETH.

A Rainbow Bridge é uma inovação importante, pois é um primeiro passo essencial no roteiro de interoperabilidade da NEAR. Além disso, como a NEAR oferece transações mais rápidas e baratas, pode ser favorável para os usuários de outras cadeias interagirem com os ativos do Ethereum no NEAR, em vez de se conectarem diretamente ao Ethereum.
Ref Finance


Ref Finance foi a primeira plataforma DeFi na NEAR. A primeira versão do Ref tinha algumas semelhanças com o Uniswap V2, além de suporte para mais tipos de pool, taxas configuráveis ​​e totalmente de propriedade da comunidade. Seu principal objetivo é reunir os principais componentes do DeFi, como uma exchange descentralizada (DEX), protocolo de empréstimo, emissor de ativos sintéticos, etc.

A Ref Finance tem um tesouro de 35 milhões de $ REF, dos quais 10% são alocados para um fundo de desenvolvimento para projetos futuros e 25% para atividades, eventos e parcerias relacionadas à comunidade.

Recursos do Ref Finance

 	O AMM DEX da Ref permite negociação automatizada e sem restrições entre qualquer token nativo NEAR ou em ponte.
 	 Os provedores de liquidez podem ganhar tokens $REF ou NEP-141 fazendo stake de tokens LP.
 	Os usuários podem fazer stake de tokens $REF para ganhar mais $REF ao longo do tempo.

Ref é um projeto comunitário e é mantido por uma DAO. A Ref DAO tem dois papéis – conselho e conselho comunitário. 

 	Conselho: O Conselho cria propostas e as vota. Uma proposta é aprovada somente se a maioria do conselho as confirmar. O Conselho será alterado assim que o DAO estiver totalmente ativo.
 	Community Board: O Community Board também vota ou rejeita uma proposta. Principalmente, o conselho vai adiar a decisão do conselho da comunidade.

OIN Finance


OIN é uma plataforma descentralizada de emissão de stablecoin que permite que projetos emitam sua própria stablecoin. Em vez de ter que colocar suas garantias na lista de permissões em outras plataformas, a OIN lançará uma stablecoin com garantia NEAR para desbloquear liquidez sem vender seus tokens NEAR. Os casos de uso da OIN são – trocar por outras stablecoins convencionais, adicionar alavancagem, hedging, empréstimos e uma infinidade de utilitários específicos do ecossistema.

Atualmente, a principal linha de produtos da OIN é a OINDAO. Ela permite que os projetos que se unem criem seu próprio pool de garantias para cunhar suas próprias stablecoins rotuladas. OIN estabelece um processo de validação rápida para cada transação iniciada no blockchain por meio do sistema de prova Merkle. Eles fazem isso colocando pequenos pedaços de informações que levam a uma “transação raiz” no livro-razão e os usam para validar um banco de dados maior de informações.

Algumas características interessantes da OIN são as seguintes:

 	É fácil e rápido cunhar stablecoins uma vez que o projeto de listagem decide os parâmetros.
 	Todos os contratos inteligentes da OIN foram completamente auditados.
 	Suporte técnico para configurar os principais parâmetros de risco para os contratos inteligentes.
 	Suporte técnico para ajudá-lo a trocar sua stablecoin própria por stablecoins convencionais no Curve e no Balancer para desbloquear a liquidez do seu ativo.

Skyward Finance 


O Skyward Finance é uma plataforma de lançamento sem restrições e de código aberto que os projetos podem utilizar para lançar seus tokens sem qualquer liquidez. Skyward tem potencialmente um dos melhores mecanismos de descoberta de preços resistentes a ataques sybil e ataques de bot. A plataforma procura habilitar a descoberta de preços e a distribuição de tokens para projetos construídos na NEAR Protocol. Ele faz isso utilizando leilões baseados em tempo de streaming que podem ser acessados ​​pela comunidade em geral de maneira descentralizada. Esses leilões também serão resistentes à manipulação de preços, front running e ataques de sybil. A Skyward Finance emitirá tokens para a comunidade, permitindo que eles se tornem parte da plataforma e obtenham receita. 
Quais são algumas das vantagens do Skyward Finance?
O Skyward Finance tem várias vantagens, algumas das quais são as seguintes.

 	Os projetos podem lançar seus tokens sem liquidez. 
 	O mecanismo de descoberta de preços da Skyward Finance é resistente a ataques de bot e sybil. Também não pode ser manipulado. 
 	Os projetos podem arrecadar fundos em qualquer token e também podem lançar várias vendas de tokens compostas por diferentes tokens. 
 	Devido à imutabilidade da Skyward Finance a qualquer tipo de manipulação de preços, os projetos e seus fundadores podem maximizar seu capital com base no valor de mercado. 
 	Os projetos não exigem o token $SKYWARD para participar ou criar uma venda. 
 	O Skyward Finance é de código aberto e sem restrições, o que significa que os contratos inteligentes na plataforma são totalmente independentes. 
 	Como o Skyward Finance é executado na NEAR, ele pode aproveitar a escalabilidade do NEAR e as transações mais baratas. 




	

	
	
		
			
				Qual das opções a seguir é uma plataforma de emissão de stablecoin?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool é um protocolo de staking de líquidos que é construído no protocolo NEAR. Os indivíduos podem facilmente fazer stake de seus tokens NEAR usando o Meta Pool e suas estratégias de staking automáticas. Em troca, eles recebem tokens “Staked NEAR” que podem utilizar no DeFi NEARverse. Os tokens também podem ser trocados pelos tokens NEAR originais a qualquer momento. 

O Meta Pool se tornou uma parte essencial do ecossistema DeFi da NEAR, pois apresenta o primeiro token de staking líquido da NEAR, o stNEAR. O token stNEAR pode acumular recompensas de staking e também representar posições de staking no NEAR. O Meta Pool oferece aos detentores de tokens NEAR uma plataforma fácil de usar e que gera rendimentos ao criar uma rede descentralizada. O Meta Pool será executado em um DAO no Sputnik V2, plataforma nativa da NEAR para gerenciar organizações autônomas descentralizadas. 

Quando os detentores de tokens fazem stake no Meta Pool, eles recebem tokens $META a cada época. Cada época é de 12 horas. Eles são recebidos além das recompensas do Protocolo NEAR, que são 10,2% APY. 
Cheddar 


A Cheddar está criando uma rede de fidelidade para a NEAR e seu ecossistema de aplicativos descentralizados. Está conseguindo isso através do estabelecimento de parcerias estratégicas que promovem ativamente o uso do protocolo NEAR ao recompensar os usuários. As redes de fidelidade provaram que motivam com sucesso os usuários a realizar ações que são benéficas para as empresas. Por meio do Cheddar, os tokens da comunidade podem ser inicializados, permitindo que os aplicativos aumentem a fidelidade do usuário e adicionem novos fluxos de receita usando mecanismos de farming. 

O Cheddar é diferente de outras fazendas de rendimento (Yield farms), pois fornece benefícios de longo prazo aos detentores (holders)  por meio de powerUPs. Ele também promove o uso de aplicativos cruzados em todo o NEARVerse, permitindo que os usuários cultivem Cheddar por meio de agricultura de rendimento, pools de liquidez ou dApps. 
Como o Cheddar se beneficia do protocolo NEAR

 	Conectividade dApp – Cheddar cria um link comum entre aplicativos além de apenas tokens individuais, criando assim um ecossistema fiel para dApps no NEAR. 
 	Engajamento do usuário – Cheddar cria engajamento de longo prazo do usuário por meio de vários incentivos e fidelização por meio de parcerias estratégicas. 
 	Cross-chain hopping – O Cheddar cria interconectividade entre cadeias e mantém os usuários em NEAR ativos e engajados, garantindo que o Valor Total Locked seja preservado. 




	

	
	
		
			
				Qual das opções a seguir está criando um programa de fidelidade no NEAR?

			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


O Berry Club permite que os usuários criem pixel art compartilhado enquanto também cultivam recompensas de token. O Berry Club começou como uma prova de conceito DeFi, mas desde então se tornou um projeto comunitário extremamente popular no Protocolo NEAR. O Berry Club faz excelente uso de vários recursos do NEAR Protocol, como pagamentos automáticos para criadores de contratos inteligentes, que não são encontrados em nenhum outro blockchain. 

Graças ao design exclusivo do NEAR, o Berry Club e o Berry Farm podem beneficiar tanto os usuários quanto os criadores de contratos inteligentes, que são pagos na forma de recompensas de contratos inteligentes para detentores e criadores de tokens. Esses benefícios decorrem do aumento do uso do aplicativo (Berry Club). Esse tipo de distribuição de recompensas não é possível em plataformas como Ethereum, pelo menos não em sua implementação atual. Essa é outra razão pela qual usuários e desenvolvedores devem experimentar o NEAR .




	

	
	
		
			
				A ponte entre Ethereum e NEAR é chamada:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
Uma empresa de pesquisa e desenvolvimento visando DeFi no ecossistema NEAR.
Conclusão
A NEAR Protocol já possui um ecossistema DeFi muito empolgante e só vai crescer ainda mais. Do jeito que as coisas estão, o NEAR fornece uma alternativa poderosa e eficiente ao Ethereum.

### Os 5 melhores jogos em NEAR

A NEAR Protocol é uma plataforma de contrato inteligente que se concentra no desenvolvedor e na facilidade de uso. Com os jogos GameFi e blockchain se tornando a próxima grande tendência, vamos dar uma olhada em alguns dos protocolos de jogos que estão atualmente disponíveis no NEAR. Especificamente, veremos:

 	Chain Typing (Digitação em cadeia)
 	Pixel DApps: Pixelparty, Pixelpets e Cryptoheroes.
 	Lands (Terrenos)

Chain Typing (Digitação em cadeia)
Chain Typing é um jogo play-to-earn (jogue para ganhar) que ajuda você a melhorar a eficiência na digitação. Você precisará possuir um personagem para jogar o jogo, conforme representado na Tabela de Líderes. Inicialmente, haverá apenas 30 personagens disponíveis para jogar o jogo. À medida que o jogo aumenta, haverá mais personagens jogáveis ​​disponíveis. Os caracteres podem ser usados ​​como um espaço de anúncio para conter descrições.



As doações irão para os fundos do jogo para ajudar ainda mais o jogo. As taxas de cunhagem de personagens em cadeia também são doadas para os fundos do jogo e não são reembolsáveis.
Pixel DApps


Pixel DApps criou três jogos para o ecossistema NEAR, a saber:

 	Pixelparty
 	Pixelpets
 	Cripto-heróis

#1 Pixelparty


PixelParty é um dos jogos Pixel Dapps. É uma vitrine NFT Frame com uma oferta total de 600 tokens. Junto com isso, você deve observar o seguinte:

 	Cada token que você possui permite desenhar em um quadro (frame) de 20x20px.
 	Os usuários podem comprar diferentes quadros conectados para desenhar um quadro maior.
 	Todos os detentores de quadros recebem recompensas do ecossistema pixeltoken.
 	Frameholders ativos com uma quantidade mínima de frames podem participar do DAO.

Veja como participar do PixelParty:

 	Conecte-se com sua carteira NEAR.
 	Escolha e compre um dos quadros disponíveis.
 	Seus quadros estarão localizados na barra lateral.
 	Você é livre para desenhar, editar ou listá-los no mercado.

#2 Pixelpets


PixelPets é um jogo criado por Pixel DApps para trocar e lutar com seus animais de estimação. É um jogo NFT em que cada token representa um dos 60 tipos diferentes de animais de estimação. Além disso, cada mascote tem uma das quatro características de raridade – comum, rara, épica e lendária. A característica afeta os diferentes atributos do animal de estimação, como força, qualidade e nível. No PixelPets, você pode:

 	Chocar: Colete ovos de animais de estimação e choque-os. Você só pode chocar um ovo de cada vez. Quanto maior a raridade do animal de estimação, mais tempo leva para chocar o ovo. 
 	Treinar: Ao treinar seu animal de estimação, você pode aumentar a classificação de qualidade. Você pode treinar seu animal de estimação enviando-os para a academia.
 	Evoluir: Depois de ganhar pontos de experiência suficientes e obter o nível de qualidade desejado, seu animal de estimação pode evoluir para o próximo nível na câmara de evolução.
 	Lutar: Experiência de fazenda duelando com outros petmasters. Você também pode lutar no coliseu e ganhar prêmios e honras.
 	Marketplace: compre e venda seus animais de estimação com pixeltoken.

#3 Cryptoheroes


O terceiro jogo criado pela Pixel DApps é o Cryptoheroes – um jogo baseado em blockchain PvE focado em saques, troca e forjamento de itens e luta contra chefes com amigos para ganhar PXT. Entre em masmorras, derrote lacaios e colete itens. 

Como você ganha PXT:

 	Junte-se a seus aliados para participar de ataques, derrotar chefes malignos e competir por recompensas semanais do PXT.
 	Colete itens poderosos e venda-os no mercado.
 	Você também pode reforjar seus itens para melhorar seu equipamento existente.

Como você participa de raids?

 	Cada raid tem 8 jogadores. 
 	As invasões acontecem semanalmente.
 	Os 20 melhores ataques são recompensados ​​a cada semana.

NEAR Lands


NEAR Lands é um jogo multijogador 2D descentralizado baseado em blockchain. Você, como jogador, pode andar por aí ou construir um jogo de mundo aberto pixelizado baseado em terras. Os jogadores podem:

 	Crie seus próprios personagens e itens.
 	Falar com amigos.
 	Envolva-se com outros participantes do universo online.
 	Os jogadores podem explorar a paisagem e criar um reino online imersivo e interativo.

Conclusão
O ecossistema de jogos NEAR ainda é jovem, mas já está se mostrando muito promissor. Portanto, fique atento e fique de olho nos projetos mais recentes que estão sendo construídos no NEAR.

### NFT Marketplaces na Near

Com o crescimento da tecnologia blockchain, vimos vários novos casos de uso que estão impulsionando a adoção do blockchain, ajudando-o a se popularizar. Em 2021, vimos o surgimento de NFTs como um novo caso de uso da tecnologia blockchain. Os NFTs chamaram a atenção do espaço blockchain, resultando em sua crescente popularidade à medida que os usuários lutavam para colocar as mãos neles. Uma medida de sua popularidade pode ser medida pela venda de uma coleção de arte NFT por Beeple que foi vendida por impressionantes US$ 69 milhões. 

Com o sucesso impressionante dos NFTs, vimos vários artistas, músicos e outros criadores mergulharem nos NFTs. Vimos artistas como Grimes e bandas como The Rolling Stones e Kings of Leon entrarem no movimento NFT vendendo versões tokenizadas de suas músicas, arte do álbum e mercadorias digitais e virtuais. Com tanta atenção sobre eles, os NFTs são um tema quente, e é essencial entendê-los e como você pode comprá-los ou vendê-los através de um mercado NFT, como o mercado NEAR NFT. Mas primeiro, devemos entender a definição de um NFT.
O que é um NFT?
Um NFT pode ser descrito como ativos digitais exclusivos que têm suas informações de identificação armazenadas em contratos inteligentes. Esta é a informação que torna cada NFT único. Como cada NFT é único, eles não podem ser trocados entre si como itens fungíveis, como moeda fiduciária ou mesmo BTC. As NFTs também são indivisíveis, diferentemente dos itens fungíveis, que podem ser divididos em bens ou valores menores e depois enviados para outros. Por exemplo, você não pode vender metade de uma pintura ou metade de uma passagem de trem para ninguém. A mesma lógica se aplica a uma NFT, com cada NFT única contendo um conjunto único de dados que não podem ser divididos ou negociados. 

Os NFTs são baseados em dois tipos de padrões de token na blockchain Ethereum, o padrão de token ERC-721 e o padrão de token ERC-1155. Ambos os padrões de token garantem que o ativo em questão funcione de uma determinada maneira, permitindo que os desenvolvedores implantem facilmente seus NFTs usando esses padrões de token, além de garantir a compatibilidade com serviços e o ecossistema de criptografia. No entanto, várias outras blockchains, como EOS, NEAR e Tron, já lançaram seus próprios padrões de token para atrair desenvolvedores e criar NFTs em suas plataformas. 
História de NFTs
Já discutimos o que é um NFT acima. No entanto, de onde os NFTs se originaram? O primeiro NFT cunhado pode ser rastreado até 2014, quando Kevin McCoy cunhou o primeiro NFT intitulado “Quantum” em 3 de maio de 2014, muito antes da explosão dos NFTs e do espaço de arte cripto. O Quantum NFT pode ser descrito como uma imagem pixelizada, consistindo em um octógono preenchido com círculos, arcos e outras formas. Todas as formas compartilham o mesmo centro, com as formas maiores cercando as menores.

Indo mais fundo na história, os NFTs foram alimentados por fenômenos culturais como CryptoPunks e CryptoKitties. No entanto, a história vai muito mais longe do que apenas estes. Em 2012, vimos o surgimento de “moedas coloridas”, que podem ser creditadas com a ideia das NFTs. Essas moedas coloridas foram inicialmente emitidas na blockchain do Bitcoin. Então, em 2014, surgiu a Counterparty, criada na blockchain do Bitcoin e permitindo a criação de ativos. Em 2016, vimos o surgimento de Rare Pepes e, logo depois, CryptoPunks, que levaram ao boom do NFT, empurrando os NFTs para o mainstream e capturando a imaginação do público em geral.




	

	
	
		
			
				Qual das seguintes afirmações é verdadeira sobre NFTs?
			
		

		
					

		
			
			
			
			Um NFT é um ativo digital exclusivo que tem suas informações de identificação armazenadas em contratos inteligentes
		
			
			Um NFT é um ativo que é divisível e pode ser dividido e compartilhado ou distribuído a outros indivíduos
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O que é um Marketplace NFT?
Assim como você precisa de um mercado para comprar a maioria dos itens, tanto no mundo real quanto no digital, um mercado NFT (marketplace) permite que os usuários comprem, vendam, troquem, exibam ou criem seus próprios NFTs. Pense em um mercado NFT como um eBay ou Amazon, mas exclusivamente para NFTs. Praticamente qualquer pessoa pode usar um mercado NFT, mas para acessar esses mercados, o usuário precisa do seguinte: 

 	Uma conta de usuário no mercado NFT que permitirá que você compre o NFT de uma plataforma específica.
 	Uma carteira criptográfica compatível com a blockchain na qual você pretende comprar as NFTs. Por exemplo, se você planeja usar o blockchain Ethereum para comprar ou vender seus NFTs, precisará de uma carteira compatível, como MetaMask. Se você planeja usar Solana , você precisa de uma carteira compatível com Solana, como Sollet. 

Os marketplaces de NFT são cruciais porque conectam compradores e vendedores e oferecem aos usuários uma série de ferramentas que permitem que eles criem seus próprios NFTs em poucos minutos. Os artistas podem usar o mercado para colocar suas NFTs à venda, e os compradores podem navegar no mercado, comprando o item por meio de um processo de licitação. 
Mercados NFT populares
Existem vários mercados NFT que você pode escolher, dependendo de suas necessidades. Os mercados de NFT universais são extremamente populares, enquanto outros mercados de nicho existem para NFTs específicos que podem consistir em cartões colecionáveis, terras virtuais em mundos digitais, como Decentraland, ou mesmo certos itens e colecionáveis ​​​​no jogo. Alguns dos mercados NFT mais populares são:

 	OpenSea
 	SuperRare
 	Rarible
 	Mintable
 	Nifty Gateway

Como a ascensão da OpenSea alimentou os NFTs 
A OpenSea se estabeleceu como líder e é o maior mercado NFT, hospedando e fornecendo suporte para todos os tipos de ativos digitais. O mercado foi inicialmente usado como um mercado para o jogo popular, CryptoKitties. No entanto, desde então, ele se expandiu muito além de apenas colecionáveis ​​e é um mercado para vários ativos, como música, ativos no jogo e colecionáveis, colecionáveis ​​digitais, arte etc. A OpenSea é responsável por impulsionar o crescimento de NFTs e projetos NFT como CryptoKitties, CryptoPunks, Ethermon e outros, todos lançados em 2017, mesmo ano do OpenSea, que levou o mercado a liderar a adoção de NFTs no mainstream. 




	

	
	
		
			
				Quais são os padrões de token usados ​​para NFTs?
			
		

		
					

		
			
			
			
			ERC-721 e ERC-1155
		
			
			ERC-20
		
			
			ERC-725
		
			
			Tudo acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O protocolo NEAR
O NEAR Protocol foi fundado em 2018 e é uma plataforma de desenvolvimento descentralizada que cria um ambiente perfeito para contratos inteligentes e aplicativos descentralizados. O NEAR se concentra nas deficiências de outros protocolos no mesmo espaço, como o Ethereum, rivalizando facilmente com os recursos da plataforma número um para finanças descentralizadas e aplicativos descentralizados. NEAR aborda uma das deficiências mais gritantes do Ethereum, a escalabilidade. Ele faz isso por meio de um processo chamado “sharding”. O sharding, ou fragmentação permite que o protocolo NEAR aumente exponencialmente. 

A NEAR usa uma blockchain Proof-of-Stake que usa sharding e é amigável ao desenvolvedor. A NEAR é de baixo custo e altamente escalável, permitindo que os desenvolvedores criem aplicativos descentralizados com facilidade. A NEAR também apresenta o Doomslug, que permite que os blocos atinjam a finalidade em poucos segundos. O protocolo usa a mesma tecnologia do Bitcoin, combinando-o com outros recursos, como sharding. O protocolo NEAR é dimensionado linearmente, permitindo suportar bilhões de transações de maneira descentralizada. 

A NEAR também consiste em várias plataformas NFT exclusivas à medida que mais e mais projetos escolhem o protocolo NEAR para lançar seus projetos. A colaboração da NEAR com Ed Young viu a plataforma lançar retratos de figuras icônicas da história do hip-hop. A plataforma Arterra da NEAR permite o envolvimento de fãs com influenciadores, equipes esportivas e streamers, permitindo que os fãs coletem NFTs de seus criadores favoritos. Outro projeto no NEAR é o Pixelparty, composto por 600 tokens, sendo cada token uma representação de um subframe de um Pixelparty Frame. Outro projeto no NEAR é o Metamon, que permite aos usuários coletar monstros baseados em NFT. Os usuários também podem combinar dois monstros, evoluindo-os para NFTs mais poderosos e mais raros. 

A NEAR permite que os usuários acessem vários protocolos que vão desde DAOs, DeFi e NFTs, com um ecossistema vibrante que possui vários projetos em execução. Como nosso foco está nos mercados NFT, analisaremos os projetos NFT no protocolo NEAR, ou seja, Paras, Mintbase e TenK. 
Mintbase 


Fonte: NEAR

Criado por Nate Geier e Caroline Wend em 2018, o Mintbase permite que os usuários criem e vendam NEAR NFTs . Esses NFTs podem ser qualquer coisa, desde cripto arte até ativos digitais e tudo mais. Qualquer pessoa com acesso à Internet pode criar um NFT no Mintbase e vendê-lo no mercado NEAR NFT ou vendê-lo em outros mercados, como OpenSea. O Mintbase permite que os criadores façam contratos inteligentes , limitando a transferibilidade dos tokens cunhados. Isso ajuda a reduzir significativamente a fraude ou a transferência ilegal de NFTs. 

A Mintbase fez a mudança do Ethereum para a NEAR graças às altas taxas de gás no primeiro. As taxas de gas ficaram tão altas que a Mintbase teve que pedir aos usuários que esperassem que os preços do gás caíssem antes de implantar uma loja. Com taxas de gas significativamente mais baixas, o NEAR foi e continua sendo a plataforma perfeita para o Mintbase. O protocolo é capaz de obter taxas de gas mais baixas devido a um modelo eficiente de execução de contratos. O NEAR também usa uma abordagem dinâmica para sharding chamada Nightshade, dando-lhe uma vantagem considerável sobre outras plataformas, como Ethereum. 
Paras

Fonte: NEAR

Paras é um mercado de arte digital criado no protocolo NEAR. O protocolo é diferente de outros marketplaces porque oferece exclusivamente coleções em vez de lançamentos únicos. Paras se inspira nos cartões comerciais do mundo real, com seus NFTs semelhantes aos das coleções de cartões esportivos e outros cartões comerciais de franquias populares, como Pokémon. Ao contrário de outros mercados, especialmente aqueles no Ethereum que permitem que os usuários carreguem praticamente qualquer coisa, o Paras adota uma abordagem mais comedida aos NFTs. 

Para criar no Paras, os artistas precisam se inscrever, com apenas 30 artistas aprovados toda semana. As obras de arte criadas pelos artistas devem estar em conformidade com a proporção de 64:89 do Paras, além de conter informações específicas relacionadas à obra de arte. A Paras escolheu o NEAR porque oferecia velocidades de transação rápidas e baixas taxas de transação. Outro fator importante pelo qual a Paras escolheu a NEAR foi por causa da Rainbow Bridge, que permite a transferência de ETH para a NEAR, permitindo a compra perfeita de NFTs. 

Recentemente, a Paras lançou Boom Boom, uma minissérie de quadrinhos criada exclusivamente para o ecossistema NEAR. O protocolo também lançou seu primeiro quadrinho, Paradigm, com as três primeiras edições disponíveis gratuitamente, enquanto os lançamentos subsequentes custarão US$ 0,3 NEAR por edição. 
TenK 


Fonte: Twitter

 

Mintbase e Paras são consideradas as plataformas NFT mais proeminentes disponíveis no protocolo NEAR. No entanto, há um terceiro projeto disponível na NEAR, chamado TenK. TenK pode ser descrito como uma plataforma de arte generativa de código aberto que traz uma série de obras de arte NFT para o protocolo NEAR. O protocolo já está lançando vários projetos de destaque no NEAR. TenK é o protocolo por trás do NEAR Misfits, lançado em 2021. O NEAR Misfits é a primeira coleção de fotos de perfil criptograficamente completa com base no protocolo NEAR. 
Considerações finais
O protocolo NEAR tornou a cunhagem de NFTs e mercados NFT muito mais fácil do que o Ethereum, permitindo que ele se tornasse um dos protocolos mais promissores e procurados no espaço cripto. A NEAR leva o Ethereum de frente, fornecendo soluções para problemas de longa data, como falta de escalabilidade, transações lentas e velocidades de processamento e taxas de gás extremamente altas. O NEAR se tornou uma alternativa bem-sucedida ao Ethereum, com novos projetos migrando para o protocolo e outros mudando do Ethereum para a NEAR. Outros projetos como Paras e TenK já operam na NEAR.




	

	
	
		
			
				Quais deficiências do Ethereum a NEAR aborda?
			
		

		
					

		
			
			
			
			Altas taxas de gas
		
			
			Escalabilidade
		
			
			Baixa velocidade nas transações
		
			
			Todas acima
		
	
		

		
		
			
				Correct!
				Wrong!

### Uma rápida introdução à rede DeBio

A Solução Biomédica Descentralizada na Rede Octopus
O atual sistema biomédico está quebrado. O Status Quo impede que os pacientes possam acessar seus dados livremente, e os profissionais de saúde não podem garantir a segurança dos dados de seus pacientes. A Rede DeBio pretende mudar isso.
O que é a Rede DeBio?
A DeBio Network é uma plataforma anônima descentralizada para medicina e bioinformática especializada em testes genéticos. A DeBio visa revolucionar a atual indústria biomédica, dando aos pacientes total soberania sobre seus dados usando as tecnologias blockchain mais avançadas.

A introdução do blockchain no atual ecossistema de tecnologia desempenha um grande papel na busca de finanças globais descentralizadas, mas os casos de uso oferecidos pela blockchain excedem mais do que apenas finanças. A DeBio acredita que o futuro dos dados médicos depende em parte do uso de blockchain, especialmente na especialização de casos de uso de tecnologia, bem como na interoperabilidade.
O teste genético centralizado é um risco de privacidade
Nos últimos anos, os testes genéticos explodiram em popularidade. Como resultado, plataformas de testes genéticos diretos ao consumidor, como 23andMe e AncestryDNA, tiveram um aumento no número de consumidores. Mas o que muitas pessoas não percebem é o risco implícito de privacidade de usar essas plataformas. 

As principais plataformas de testes genéticos diretos ao consumidor são centralizadas, tornando-as um alvo fácil para violações de dados. Em 2020, houve 1.001 violações de dados apenas nos Estados Unidos; com o setor de saúde recebendo o peso disso, informou a Govtech.

Ainda mais preocupante é que os dados genéticos não são exclusivos de um indivíduo, mas exclusivos da árvore genealógica do indivíduo. Ao usar um serviço de bioinformática centralizado, você coloca em risco não apenas sua privacidade, mas também a privacidade de seus parentes distantes. 

O dano disso é inequívoco porque existe a possibilidade de seus parentes distantes, por exemplo, um primo em segundo grau, serem afetados por sua decisão. Preocupante é o pensamento de um parente distante que você nem sabe que existe, fazendo um teste genético e tendo seus dados genéticos rastreados até você.

Os dados genéticos podem ser rastreados até você mesmo com uma pequena quantidade de informações demográficas, como idade e estado. Esse tipo de informação pode ser usado contra você pelas seguradoras, para aproveitar ao máximo seus clientes.
O Conceito de Rede DeBio
O principal conceito por trás do DeBio é baseado na noção de querer aumentar os testes biomédicos e genéticos para os consumidores sem perder sua privacidade. Mas a DeBio também quer incentivar a pesquisa genética oferecendo colaborações entre laboratórios soberanos.
Uma ponte física-digital para testes anônimos
Os consumidores podem selecionar uma ampla gama de produtos e recomendações laboratoriais do mercado de testes genéticos da DeBio. Depois que o consumidor decidir sobre um produto, ele só precisará coletar duas amostras de DNA pelo método de swab bucal ou coletar amostras de células orais com cotonetes.

O consumidor então envia a amostra de DNA para o laboratório dentro de um envelope em que a única informação identificável escrita no envelope é o ID de rastreamento genético da amostra. Os laboratórios não podem identificar amostras sem um ID de rastreamento porque, para fins de anonimato, a DeBio não coletará informações de identificação pessoal de qualquer tipo, tornando as amostras de DNA não rastreáveis ​​até o consumidor.

Os resultados (por exemplo, teste e genoma) são então criptografados com a chave pública do consumidor recuperada do blockchain DeBio e armazenados e depois carregados em armazenamento descentralizado. Isso permite que os consumidores mantenham total soberania sobre seus dados criptografados – os consumidores devem possuir suas chaves privadas para descriptografar os resultados.

A equipe da DeBio Network está expandindo esse conceito de “ponte física para digital” para usar casos fora do mercado de testes genéticos – que podem incluir testes de laboratório para doenças e outros dados de registros médicos eletrônicos ou informações pessoais de saúde.
Colaboração do Sovereign Lab para oferecer produtos conjuntos que integram serviços de vários laboratórios
Após o consumidor enviar a amostra de DNA para o laboratório, o laboratório será notificado. Quando a amostra chegar, o laboratório começará a sequenciar as amostras físicas ou iniciará qualquer teste de biomarcador. Depois de concluir os testes subsequentes o laboratório criptografará os resultados usando a chave pública do consumidor e os carregará no armazenamento descentralizado.

Os resultados não podem ser descriptografados sem o uso da chave privada do consumidor, portanto, a soberania do consumidor sobre os resultados de seus testes biomédicos é segura. No entanto, para incentivar ainda mais os testes genéticos, os consumidores optam por fazer staking de seus dados de testes genéticos para serem usados ​​por outros laboratórios.

O objetivo de ter laboratórios soberanos é aumentar a disponibilidade de produtos e possibilitar produtos conjuntos por meio da integração de serviços de vários laboratórios. Isso também permite que o DeBio escale porque os laboratórios não precisam ser centralizados, permitindo a participação de várias instalações de genética independentes.




	

	
	
		
			
				Qual problema a Rede DeBio pretende resolver?
			
		

		
					

		
			
			
			
			Preocupações de privacidade entre plataformas de testes genéticos online
		
			
			 Obstáculos em laboratórios soberanos para fazer seu trabalho
		
			
			A falta de pesquisas em genética
		
			
			Cuidados de saúde caros 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





O Techstack da Rede DeBio
A bioinformática e os ecossistemas biomédicos têm demandas únicas em como ambos precisam ser acessíveis aos profissionais que conduzem os estudos, mas também seguros o suficiente para proteger a privacidade e a soberania do paciente. Assim, para garantir a soberania do paciente sobre seus dados, toda a pilha de tecnologia consiste em soluções descentralizadas que vão desde autenticação descentralizada até armazenamento descentralizado de arquivos.



A imagem foi retirada do DeBio Deck

A DeBio incorporou uma série de tecnologias de ponta na solução, incluindo, mas não se limitando a:

 	Substrate
 	KILT Protocol
 	The Octopus Network
 	The InterPlanetary File System (IPFS)
 	Ocean Protocol

Substrate
A primeira tecnologia notável incorporada é o Substrate. É a estrutura por trás do token Polkadot, permitindo que os desenvolvedores construam blockchains propositais. Os serviços principais serão construídos usando o Substrate, tornando-os os principais blocos de construção da solução. A DeBio escolheu o Substrate por dois motivos:

 	       Interoperabilidade Blockchain (essencialmente ser capaz de se comunicar entre diferentes blockchains).
 	       Segurança da cadeia de retransmissão (aplicando padrões de segurança mais rígidos da cadeia de retransmissão do host).

Além de permitir que os blockchains se comuniquem entre si, o recurso de interoperabilidade também impõe um padrão de segurança que será herdado por cadeia paralela conectada à cadeia de retransmissão principal. Como resultado, a segurança do blockchain DeBio é aprimorada seguindo os padrões da cadeia de retransmissão correspondente.
KILT Protocol
A próxima menção notável seria o Protocolo KILT. KILT é um protocolo para criar, atestar e verificar identidades anonimamente na Web3. Para se autenticar cada usuário precisa criar uma declaração, que seria enviada a um atestador confiável.

Um atestador tem a responsabilidade de certificar a declaração de um usuário, que se transformará em um hash a ser salvo no blockchain KILT. A reivindicação de um usuário às vezes contém dados confidenciais sobre o usuário, mas como o hash não pode ser transformado novamente em uma reivindicação do usuário, a privacidade do usuário é garantida.

Depois de receber o certificado do atestador confiável, o usuário agora pode usar suas declarações em aplicativos que usam KILT e confia no atestador mencionado. KILT é privacidade por design. Os aplicativos que verificarão a reclamação não precisam passar pelo atestador e compararão diretamente a reclamação com a armazenada na blockchain KILT, cortando o atestador do processo de verificação e tornando-o totalmente descentralizado.

O protocolo KILT fornece uma solução que impede que os dados sejam concentrados em uma entidade. Ele permite a soberania de dados para os que se preocupam com a privacidade. A DeBio fez uma parceria com a KILT para implementar um sistema de autenticação descentralizado porque se encaixa perfeitamente no caso de uso anônimo da DeBio .
The Octopus Network
Octopus é uma rede de criptografia para lançar e executar blockchains específicos de aplicativos Web3 por uma fração do custo. Uma das considerações de usar o Octopus é que, comparado ao Polkadot, eles oferecem uma concessão de segurança significativamente mais barata e recursos de cadeia cruzada comparáveis. Octopus é apoiado pelo NEAR Protocol. NEAR é uma blockchain de alto desempenho destinada a resolver o problema de escalabilidade e aumentar a produtividade do desenvolvedor simplificando o processo de desenvolvimento e criando um ambiente amigável ao desenvolvedor.

A DeBio já é parceira da Octopus e será uma das cinco primeiras blockchains específicas de aplicativos (cadeias de aplicativos) lançadas na Octopus Network. A DeBio também já faz parte da Octopus Guild, uma comunidade de desenvolvedores e redes de aplicativos da Octopus Network.
O Sistema de Arquivos Interplanetários (IPFS)
O InterPlanetary File System (IPFS) é um protocolo feito para armazenamento e compartilhamento de dados ponto a ponto totalmente descentralizado. O IPFS foi criado como uma solução para projetos descentralizados que desejam armazenar uma quantidade de dados grande demais para ser armazenada no próprio blockchain. O IPFS cria endereços de conteúdo exclusivos por meio do hash do próprio conteúdo. Cada conteúdo exclusivo terá um endereço diferente apontando para sua localização. A DeBio adiciona IPFS para armazenar dados biomédicos, como genomas humanos criptografados e registros médicos eletrônicos criptografados.
Ocean Protocol
O Protocolo do Oceano ou Ocean Protocol foi desenvolvido para o consumo de ativos de dados de forma segura e com preservação da privacidade. Ele faz isso com o recurso de computação para dados e permite a monetização de dados sem precisar sair das instalações do proprietário. O mercado de dados de código aberto do Ocean Protocol chamado Ocean Market é bifurcado; a equipe da DeBio Network usará o Ocean para staking de dados biomédicos.
Privacy Computing
Para staking dos dados biomédicos, a DeBio hospedará dados biomédicos anônimos em seu armazenamento de dados privado. Este processo não envolve o IPFS mencionado acima porque o armazenamento de dados será completamente separado do IPFS. Os usuários que desejam fazer staking de seus dados precisarão descriptografar e fazer upload de seus dados biomédicos em seu armazenamento de dados privado. Embora a transferência de dados biomédicos descriptografados para um armazenamento de dados privado pareça assustadora, a DeBio implementará conceitos de computação de privacidade dentro do armazenamento de dados para proteger sua privacidade.



Imagem recuperada do DeBio Whitepaper

Somente após o consentimento do usuário os conjuntos de dados são agregados por meio do proxy de computação para dados da Ocean, e o terceiro poderá criar análises e processar os dados enquanto permanecerem no local.

Ao incentivar os usuários a fazer staking de seus dados geneticos/biomédicos e esperar que isso incentive ainda mais a pesquisa no campo. Além disso, o armazenamento de dados de propriedade privada não coletará informações de identificação pessoal, portanto, não há necessidade de se preocupar com o rastreamento de suas amostras até você.

Pandu Sastrowardoyo, CEO da DeBio, afirmou que uma das razões pelas quais ela criou a DeBio é ajudar a pesquisa genética a florescer criando um mercado de dados genéticos totalmente anônimo. “O DeBio é um sistema econômico totalmente novo para a genética – permitindo a soberania genética, garantindo a participação de laboratórios menores enquanto sobrecarrega a pesquisa genética. Tudo feito em cima de um modelo semelhante ao DeFi que é totalmente descentralizado”, disse Pandu.




	

	
	
		
			
				Onde o DeBio armazena os dados em stake?
			
		

		
					

		
			
			
			
			Dentro da blockchain da DeBio
		
			
			Dentro dos tokens de dados
		
			
			Em um armazenamento de dados privado
		
			
			Em IFPS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Camadas de Arquitetura Técnica
Nossa arquitetura técnica consiste em quatro camadas, a principal infraestrutura de blockchain, a camada de lógica de negócios genérica e de transporte e, por último, a camada de lógica de negócios de nível superior.



Arquitetura técnica proposta pela DeBio, imagem recuperada do whitepaper da DeBio
Camada 1: A Infraestrutura Blockchain
A primeira camada conterá os serviços principais. Os serviços principais são construídos sobre Substrato, Octopus e IPFS. O substrato é o bloco de construção principal para o serviço blockchain. Para salvar arquivos grandes, o DeBio usará IPFS e salvará o endereço do conteúdo dentro do Substrato. Por fim, toda a cadeia de aplicativos será conectada à cadeia de retransmissão Octopus.
Camadas 2 e 3: a camada de lógica de negócios genérica e de transporte
A segunda e a terceira camadas contêm o transporte e a lógica de negócios genérica. Essas camadas são responsáveis ​​por servir os dados diretamente aos usuários. Cada palete contém a lógica de negócios básica para interações com o blockchain e servirá como uma camada de abstração da quarta camada para se comunicar com os serviços Substrato na primeira camada.
Camada 4: A Camada Lógica de Negócios de Nível Superior
A quarta camada consistiria na interface do usuário do DeBio e na Metamask. Toda interação entre os usuários e o blockchain será feita a partir da quarta camada. Todas as consultas também serão definidas a partir do nível superior e serão processadas em todas as camadas mencionadas anteriormente. Para financiar cada transação, os usuários podem usar a Metamask para pagar usando uma moeda estável ERC20. Nesse caso, o DeBio usará o DAI como a moeda estável de escolha.
O modelo de token


Imagem recuperada do DeBio Whitepaper

A equipe da DeBio Network pretende liberar seis tokens:

 	         Recompensas de transações da Mainnet e token de validação ($DBIO)
 	         O token de governança ($GBIO)
 	         O Token de Dados Genomics ($GENE, via Ocean Protocol)
 	         O Token de Dados Biomédicos ($MED, via Ocean Protocol)
 	·       O Token de Dados de Registros Médicos Eletrônicos ($EMR, via Protocolo Ocean)

Mainnet Coin (moeda estável, etc)
A moeda da rede principal será apoiada por uma moeda estável. A DeBio decidiu usar uma moeda estável porque ela precisa ser usada como uma troca estável para transações e taxas relacionadas ao trabalho realizado pelos laboratórios correspondentes. A DeBio utilizará $DAI como nosso token estável.
Token de governança ($GBIO)
Os tokens de governança serão usados ​​principalmente para votação pelos laboratórios registrados. A DeBio Network é uma organização descentralizada, portanto, é necessário haver um esquema de governança para votar no mercado DAOGenics. Como alternativa, o token de governança também pode servir como um método de integração do laboratório.
Os Tokens de Dados ($GENE, $MED e $EMR)
Esses tokens são usados ​​como um método de transação no mercado de dados. Ao fazer staking dos dados biomédicos no mercado Ocean, os consumidores serão recompensados ​​com tokens de dados que podem ser convertidos em $OCEAN.
Validador e recompensas de transações ($DBIO)
O token validador é usado para incentivar os proprietários do nó a validar transações e proteger o dApp de usuários não autorizados. Os incentivos previstos para validadores são recompensas de LP e tokens de governança.
Transações do consumidor na rede DeBio
$DAI é a moeda estável da rede principal usada para transações na plataforma DeBio. Os consumidores podem usar a moeda da rede principal para pagar por produtos e taxas de serviço. Os produtos que estarão disponíveis no mercado incluem produtos de testes geneticos, produtos de testes biomédicos e um serviço soberano de armazenamento de registros médicos eletrônicos (EMR).



Imagem recuperada do DeBio Whitepaper
Recompensas Transacionais
Cada transação confirmada pelo consumidor será recompensada por um token validador, mais especificamente um token $DBIO. O preço de um único token $DBIO é determinado pelo mercado de dados DeBio Network que hospeda os dados genéticos do consumidor disponíveis para staking.
Staking de dados na rede DeBio
Depois de comprar um produto no marketplace, o consumidor pode optar por fazer staking de seus resultados no Ocean Marketplace. Os dados em stake pelos consumidores serão categorizados como tokens de dados, chamados $GENE, $MED e $EMR para dados genéticos, dados biomédicos e registros médicos eletrônicos (EMR), respectivamente. Os tokens de dados serão mantidos na Rede DeBio e agregados ao mercado de dados via Ocean Protocol como um token ERC20. Como os dados genéticos, dados biomédicos ou o próprio EMR são muito grandes para serem salvos dentro dos tokens de dados ERC20, os tokens de dados servirão principalmente como um ponteiro/link para os dados correspondentes.

Os consumidores que fizerem staking de seus tokens de dados terão uma função de “provedor de dados” no mercado de dados. Todas as transações no mercado de dados Ocean usarão tokens $OCEAN. Assim, se a transação for bem-sucedida, o comprador estará trocando tokens $OCEAN pelos tokens de dados ($GENE ou $EMR ou $MED). Considerando que o “provedor de dados” receberá os tokens $OCEAN subsequentes.



Imagem recuperada do DeBio Whitepaper

Se o comprador de dados quiser acessar os dados vinculados no token de dados, ele precisará enviar o token de dados ao provedor de dados com antecedência. Como resultado, o provedor de dados terá o token $OCEAN e os tokens de dados, enquanto o comprador de dados receberá os dados vinculados pelo token de dados.



Imagem recuperada do DeBio Whitepaper

Por outro lado, os tokens de dados ($GENE ou $MED ou $EMR) recebidos pela DAOGenics Foundation serão convertidos em tokens $OCEAN. Após um determinado período, o token $OCEAN recebido pela DAOGenics Foundation será convertido em um token $DBIO por meio de um contrato inteligente sem permissão.

Como resultado, a DAOGenics Foundation sempre comprará de volta o token $DBIO por meio de um contrato inteligente sem permissão com base no volume de transações realizado no mercado de dados. Mais transações no mercado de dados aumentarão a demanda pelo token $DBIO.




	

	
	
		
			
				Quando você aposta dados no mercado de dados da DeBio Network, o que você ganha?
			
		

		
					

		
			
			
			
			A moeda da rede principal ($DAI)
		
			
			Tokens de Governança ($GBIO)
		
			
			Tokens de Recompensa de Transação ($DBIO)
		
			
			Token Ocean ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusão
Há muitos benefícios de fazer testes genéticos. Pela primeira vez na história da humanidade, as pessoas foram capazes de determinar seus estilos de vida para buscar a longevidade; a vantagem de tal conhecimento é surpreendente. Mas, embora os testes genéticos tenham seus maravilhosos benefícios sem regulamentações e padrões adequados, também têm suas deficiências. Sem a garantia de ter seus dados genéticos privados e seguros, isso pode causar problemas no futuro.

DeBio visa resolver o problema antes que seja tarde demais. A DeBio está construindo uma plataforma descentralizada para suas necessidades médicas pessoais, começando pela genética. Nosso conceito permite sinergia entre laboratórios de todas as escalas, garantindo o anonimato e a soberania do usuário em todas as etapas do fluxo de trabalho da ciência de dados genéticos - desde a coleta de amostras, armazenamento de dados até a geração de relatórios.

Algumas pessoas podem dizer que nosso DNA é a coisa mais privada que temos, e levamos isso muito a sério. O primeiro teste genético do anonimato deve ser o foco número um para todas as empresas.

O futuro está aqui, a DeBio está criando soluções para revolucionar o setor de saúde e testes genéticos. Você está pronto para mudar o mundo com a gente?

Adaptado do artigo original no Medium .  

### O que é Octopus Network?

Resultado esperado: uma compreensão geral da Rede Octopus na perspectiva do usuário final

Um polvo é muito diferente de um humano. Em vez de ter um sistema nervoso centralizado como os humanos, dois terços dos neurônios de um polvo estão espalhados por todo o corpo e distribuídos entre seus braços. Esses neurônios podem tomar decisões por conta própria sem a entrada do cérebro – essencialmente tornando o polvo uma forma de vida inteligente descentralizada.

A Rede Octopus é uma rede criptográfica interoperável multicadeia que emula um polvo. Como os braços de um polvo, cada blockchain específico de aplicativo conectado (appchain) é capacitado com sua própria inteligência e mecanismos de tomada de decisão para se adaptar a ambientes em constante mudança. Quando conectados como um todo, todos os membros se beneficiam de efeitos de rede significativos e economias de escala - criando uma Internet de Blockchains.



Octopus Network é uma rede criptográfica multicadeia para lançar e executar blockchains específicos de aplicativos Web3.0 — appchains.

Appchains na Octopus Network se beneficiam de segurança alugada (LPoS) flexível e econômica, interoperabilidade multicadeia pronta para uso, infraestrutura completa e uma comunidade pronta para ser engajada.

A Octopus Network diminui o custo para lançar uma cadeia de aplicativos de vários milhões de dólares para menos de cem mil dólares – desencadeando a 3ª Onda de Inovação de redes criptográficas.
A evolução dos aplicativos Web3.0
Web3.0 ainda não aconteceu. Mas, com base nos primeiros princípios, temos certeza de que isso acontecerá.

A negociação sempre flui para o mercado com custos de transação mais baixos, assim como a água sempre flui para baixo.

As plataformas Web2.0 são administradas e de propriedade de empresas cujos objetivos estão diretamente alinhados com a maximização do valor para o acionista. Eles extraem o máximo de lucro possível das atividades econômicas que coordenam. Redes criptográficas são mercados de serviços digitais com custos de transação minimizados. Assim, as plataformas Web2.0 simplesmente não têm defesa contra a eventual substituição por redes criptográficas.

Web3 refere-se a aplicativos descentralizados executados em blockchains pertencentes à comunidade de usuários, em vez de corporações que extraem lucros. A Web3.0 aspira devolver valor aos verdadeiros criadores.

Mas as plataformas Web2.0 são fantásticas para usuários da Internet. Para que um aplicativo Web3.0 suplante um aplicativo Web2.0, ele precisa ser um ótimo aplicativo Web e fornecer uma experiência de usuário que seja pelo menos tão boa quanto sua contraparte Web2.0.

O desenvolvimento de aplicativos Web3.0 normalmente precisa sacrificar a experiência do usuário porque a tecnologia de contabilidade distribuída envolve mais complexidades e custos maiores do que a Web2.0 — o que resulta em UX de menor qualidade.

Mas uma 3ª Onda de Inovação em redes criptográficas está chegando e trazendo soluções promissoras de aplicativos Web3.0 com a maré.
A 3ª Onda de Inovação em Redes Criptográficas
Bitcoin é um blockchain específico da aplicação (appchain) - o primeiro e o mais bem-sucedido.


Inspirado no Bitcoin, uma variedade de appchains foi desenvolvida de 2011 a 2015. Alguns tentaram se tornar um Bitcoin melhor, enquanto outros visavam uma variedade de casos de uso além da moeda – deixando-nos com uma infinidade de moedas mortas. A razão comumente aceita para isso é que o blockchain do Bitcoin foi construído especificamente e inadequado para abordar outros casos de uso ao ser bifurcado ou estendido. Podemos chamar esse período de “1ª Onda de inovação cripto”.


A 2ª onda nasceu com o Ethereum. Ethereum é um blockchain público de uso geral equipado com uma máquina virtual Turing-Complete (que teoricamente poderia executar qualquer computação, desde que permaneça dentro da limitação de complexidade, também conhecida como limite de gas). A principal linguagem de programação EVM, Solidity, com sua sintaxe semelhante a Javascript, é fácil de aprender e muito bom no controle de ativos on-chain.


O Ethereum permitiu que milhares de desenvolvedores construíssem aplicativos descentralizados (dApps). Infelizmente, muito poucos conseguiram reter muitos usuários por um longo período de tempo até a explosão do DeFi de 2020.


Mas o principal desafio enfrentado pelo Ethereum é a escalabilidade – e as taxas de gás para executar contratos inteligentes tornaram certos casos de uso proibitivamente caros. Enquanto o Ethereum 2.0 visa direcionar esses problemas com um protocolo de blockchain fragmentado, o Ethereum 2.0 é um roteiro de vários anos com riscos de execução desconhecidos.


No entanto, uma 3ª onda de inovação cripto está chegando. Estruturas de blockchain, como Substrate e Cosmos SDK, podem fornecer um espaço de design colossal sem precedentes para desenvolvedores de aplicativos Web3.0.


Os desenvolvedores agora podem fornecer um aplicativo Web3.0 totalmente otimizado criando uma cadeia de aplicativos.


O que é uma Appchain?
Um aplicativo descentralizado ou dApp é um aplicativo da Web com pelo menos uma parte de seu back-end residindo em um blockchain. O back-end de um dApp pode ser implementado de duas maneiras – contratos inteligentes podem ser hospedados em uma plataforma blockchain ou um aplicativo descentralizado pode viver em seu próprio blockchain dedicado.

Quando um dApp tem seu próprio blockchain, ele é chamado de blockchain específico do aplicativo ou appchain. Ao contrário dos dApps, os appchains permitem que os desenvolvedores personalizem seus aplicativos em termos de estrutura de governança, design econômico e até mesmo seu algoritmo de consenso subjacente.

Appchains também oferecem aos desenvolvedores capacidade de processamento de transações dedicada, o que significa que um aplicativo em um appchain não precisa competir com outros aplicativos pela capacidade de processamento de transações em uma rede.

Para ilustrar, enquanto milhares de aplicativos diferentes podem compartilhar um conjunto padrão de configurações em uma plataforma genérica de contrato inteligente, cada cadeia de aplicativos em uma configuração de PoS pode facilmente atingir mais de 1.000 TPS e finalização rápida - e toda essa capacidade de processamento de transações seria dedicada a apenas uma aplicação.

Ao contrário dos contratos inteligentes, as cadeias de aplicativos podem evoluir rapidamente com legitimidade. Cada appchain é uma economia autogovernada com processos explícitos definidos por código para chegar a acordos sobre atualizações de protocolo. E, graças ao Substrate, a função principal da governança on-chain está pronta para uso. Qualquer rede criptográfica pode espelhar o processo de governança de outra por meio de código copiado e colado. A própria governança Blockchain pode evoluir como software de código aberto.

Ainda assim, ninguém pode ignorar que os contratos inteligentes são ótimos para casos de uso de negociação de ativos, por exemplo, DeFi. Como os contratos inteligentes são executados com base nas mesmas suposições de segurança, a composição entre eles é a receita essencial para a explosão do DeFi.

No entanto, embora a experiência do usuário do DeFi não seja tão ruim quanto o banco on-line, ele ainda tem muito espaço para melhorias, especialmente quando se considera um blockchain de camada 1 mais capaz do que o Ethereum – como o NEAR Protocol.
Por que a Octopus escolheu NEAR?
Embora o SDK do Substrate e do Cosmos tenha diminuído o custo de desenvolvimento de cadeias de aplicativos para um nível pelo menos comparável aos contratos inteligentes, a inicialização de cadeias de aplicativos ainda é um trabalho tecnicamente complexo e de capital intensivo para os desenvolvedores.

A NEAR Protocol é uma blockchain de prova de participação (PoS) fragmentado que enfatiza a escalabilidade e a usabilidade.A NEAR é frequentemente referida como uma solução de escalabilidade pronta para dApps Ethereum existentes, mas é igualmente capaz de lidar com um conjunto de outros tipos de soluções descentralizadas - como appchains.

Em comparação com outras plataformas de Camada 1 que também podem acomodar cadeias de aplicativos, como Polkadot ou Cosmos, a NEAR tem algumas vantagens técnicas e econômicas importantes.

Comparado ao Cosmos, iniciar um appchain na NEAR é mais fácil porque os validadores não precisam ser inicializados para cada appchain individual.

Por exemplo, no Cosmos, cada appchain deve se proteger com um conjunto de validadores descentralizado e com quantidade suficiente de tokens em stake. Portanto, os desenvolvedores de um appchain precisam primeiro obter o reconhecimento de valor do token nativo do appchain nos mercados de ativos criptográficos e, em seguida, inicializar uma comunidade validadora ativa desde o início.

Comparado a Polkadot, a NEAR oferece às cadeias de aplicativos uma concessão de segurança significativamente mais barata e não tem limite no número de cadeias de aplicativos que podem ser lançadas.

Uma parachain da Polkadot deve ser capaz de arcar com o custo de consenso de um fragmento da rede – o que pode equivaler a dezenas de milhões de dólares por ano.

Em um sistema de computação, maior segurança não significa necessariamente melhor segurança, porque um maior nível de segurança sempre vem com um maior nível de custo. Então, o que um sistema computacional precisa é de segurança apropriada e adequada.

Na Polkadot, os desenvolvedores não decidem um nível de segurança apropriado e adequado para sua parachain. Eles só têm uma escolha - ganhar uma vaga no leilão. Mas mesmo que uma parachain vença o leilão, geralmente paga a mais pela segurança, porque uma rede criptográfica em suas fases de lançamento não precisa de um nível de segurança de vários bilhões de dólares.

Além disso, uma carga de custos de segurança de alto nível desde o início pode levar uma parachain à hiperinflação porque ela deve prometer emitir uma grande quantidade de tokens nativos para os credores do Crowdloan. No mínimo, esse ônus econômico deixa muito pouco espaço para uma cadeia para incentivar os verdadeiros criadores de valor de seu protocolo – os participantes que ajudam a construir os efeitos de rede da criptorede.

Para simplificar, a NEAR foi escolhido pela Octopus sobre Polkadot e Cosmos porque é simplesmente mais econômico, escalável, fácil de usar e interoperável com redes como Ethereum do que qualquer outra solução L1 existente.

Acreditamos que os appchains serão a 3ª onda de inovação de redes criptográficas  que nos conduzirá à Web3.0 – e que a Octopus Network tornará os appchains acessíveis a inúmeros projetos com todos os tipos de orçamentos.




	

	
	
		
			
				O que é uma cadeia de aplicativos?
			
		

		
					

		
			
			
			
			Um aplicativo descentralizado
		
			
			Uma blockchain de uso geral
		
			
			Um blockchain específico do aplicativo
		
			
			Um contrato inteligente
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





As vantagens do PoS alugado (LPoS)
O que é segurança no contexto do blockchain?

Simplificando, a segurança é o nível de certeza de que os protocolos predefinidos serão aplicados como a maioria das partes interessadas espera — seja na camada base ou na camada de aplicação.

A segurança do Blockchain é geralmente considerada uma propriedade quantificável. Não pode haver segurança absoluta ou ilimitada. Se um blockchain tivesse segurança absoluta, deveria ser inutilizável e inacessível.

Comparado ao modelo de segurança compartilhado de uma parachain da Polkadot, o Appchain Leased PoS (LPoS) da Octopus Network é muito mais escalável e flexível. Como o leasing de títulos é essencialmente um leasing de capital ou leasing de garantias, ele pode ser dimensionado sem limitações físicas.

Na Polkadot, cada parachain acomodará um certo número de validadores no pool exclusivamente em qualquer época. O algoritmo de consenso limita o tamanho total da pool. (É por isso que se espera que o número total de parachains seja inferior a 100, com menos de 10 slots de parachains disponíveis este ano.)

O PoS alugado da Octopus é muito mais econômico do que o da Polkadot. Como o Octopus não possui seu próprio blockchain e o token $OCT é emitido e gerenciado por um contrato inteligente, o Octopus não precisa pagar diretamente pelos custos de consenso. Assim, a taxa de inflação $OCT pode ser definida como zero, o que significa que a taxa básica de juros do sistema econômico Octopus é zero.

Quando a taxa de juros básica é zero, um APY de 3% a 5% é um retorno anual decente (que é o intervalo que esperamos que uma cadeia de aplicativos pague por sua segurança alugada). Mas em contraste, a parachain na polkadot precisa pagar um APY (retorno anual de juros) de 20% ou mais para se tornar atraente para os credores de Crowdloan $DOT, porque fazer stake no Polkadot Relay, a blockchain principal Polkadot, já dará aos investidores um retorno anual livre de risco de 14%.

Como o LPoS é uma segurança baseada em necessidades e oferece às cadeias de aplicativos a alavancagem econômica para escalar organicamente, acreditamos que o LPoS é mais propício ao desenvolvimento de cadeias de aplicativos a longo prazo do que o PoS independente. No entanto, também acreditamos que o direito de escolha sempre pertence a qualquer comunidade de appchain.

Se qualquer appchain na Octopus Network optar por parar de usar o LPoS para se transformar em um blockchain PoS independente, o Octopus fornecerá as ferramentas para apoiar sua transformação - Sua conexão com a Octopus Network seria então rebaixada para a de uma ponte IBC padrão e os ativos de cadeia cruzada existentes não seriam afetados.
Visão geral da Rede Octopus


Legenda: D-Delegante; S– Staking; V– Validador; RT – Tempo de execução; N- Nó

O Octopus Relay está situado no núcleo da Octopus Network. O Octopus Relay é um conjunto de contratos inteligentes executados no blockchain NEAR (também conhecido como mainchain) que implementa o mercado de aluguel de segurança.

As cadeias de aplicativos Octopus ficam situadas no lado onde há demanda do mercado. As cadeias de aplicativos Octopus alugam segurança de detentores de $OCT pagando aluguel em seus tokens nativos. Cada appchain pode escolher seu próprio modelo econômico, incluindo quantos tokens nativos está disposto a pagar aos validadores por segurança.

Os validadores e delegadores da Octopus estão situados no lado da oferta do mercado de aluguel de títulos.

Os validadores Octopus fazem staking em tokens $OCT para validar um determinado appchain e configurar um nó para executar o protocolo desse appchain. Em troca, os validadores são elegíveis para receber o respectivo token nativo da cadeia de aplicativos que estão validando.

Os Delegadores Octopus podem delegar seus $OCT aos Validadores para uma participação nas recompensas de staking do token nativo de um appchain. As recompensas de apostas são distribuídas aos Delegadores diretamente após os Validadores coletarem uma comissão unificada.

Se os validadores se comportarem mal (por exemplo, ficarem offline, atacarem a rede ou executarem software modificado), eles (e seus Delegadores) serão reduzidos ao perder uma porcentagem de seus $OCT apostados. Todas as punições são aplicadas aos Delegadores proporcionalmente quando seus Validadores são cortados. Dessa forma, o staking funciona como um desincentivo ao comportamento malicioso.

Como os detentores de $OCT são responsáveis ​​por decidir em qual cadeia de aplicativos gostariam de apostar, a Octopus Network funciona como um mercado livre, onde as cadeias de aplicativos podem alugar o nível de segurança de que precisam a preço de mercado a qualquer momento.

A Octopus Network também possui uma série de ferramentas para provedores de segurança, como ferramentas de gerenciamento e implantação automática de nó validador de appchain, visualizações econômicas de rede e ferramentas de análise estatística.

O mercado Octopus Network LPoS permite que qualquer desenvolvedor, projeto ou empreendedor crie de forma rápida, eficiente e acessível sua própria cadeia de aplicativos no NEAR.

Mas a Octopus Network também oferece suporte a cadeias de aplicativos de muitas outras maneiras, incluindo o fornecimento de interoperabilidade entre cadeias, infraestrutura integrada e uma comunidade pronta para ser engajada.




	

	
	
		
			
				Quais são as vantagens do LPoS?
			
		

		
					

		
			
			
			
			LPoS é econômico
		
			
			LPoS é flexível
		
			
			LPoS é escalável
		
			
			Todas acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interoperabilidade
É menos controverso agora afirmar que todos os blockchains públicos e redes multichain acabarão sendo interconectados – formando a Internet dos Blockchains. A Octopus Network foi projetada especificamente para fazer parte disso.

A equipe Octopus (anteriormente conhecida como Cdot) vem trabalhando no protocolo de interoperabilidade de blockchain universal IBC e integração de cadeia cruzada há mais de dois anos.

O Octopus Relay permite a interoperabilidade das cadeias de aplicativos com o protocolo NEAR e Ethereum via Rainbow Bridge. Além disso, as cadeias de aplicativos podem utilizar um palete IBC pronto para uso para se conectar diretamente a qualquer blockchain habilitado para IBC.

Qualquer ativo emitido no Ethereum, NEAR ou qualquer blockchain habilitado para IBC pode ser transferido e utilizado por appchains Octopus sem confiança. Por outro lado, quaisquer ativos emitidos em appchains podem ser transferidos sem confiança para Ethereum, NEAR e qualquer blockchain habilitado para IBC.

Com base na interoperabilidade perfeita entre a Octopus Network e a NEAR, a variedade de ativos criptográficos emitidos nas cadeias de aplicativos Octopus também contribuirá para a prosperidade do ecossistema DeFi da NEAR.
A infraestrutura
A Octopus Network fornece um conjunto completo de infraestrutura para appchains — incluindo API Gateway, Blockchain Explorer, Archive Gateway, etc.

O Octopus Bridge implantará um contrato envelopado NEP-141 no NEAR para cada token nativo do appchain. Em seguida, carteiras e trocas podem integrar tokens evelopados padrão em vez de ter que se integrar a cada appchain individualmente.

Assim, as equipes de appchain só precisam se concentrar no tempo de execução do Substrate e no desenvolvimento de front-end, enquanto a Octopus Network lida com todas as outras necessidades técnicas.
Comunidade
Uma rede criptográfica é de propriedade de sua comunidade. Essa é a essência da descentralização e a diferença fundamental das plataformas Web2.0.

A Octopus Network atua como uma meta-comunidade para nutrir centenas de comunidades de aplicativos Web3.0. Desenvolvedores de aplicativos Web3.0 e fundadores de cadeias de aplicativos podem exibir os méritos de sua criptorede para atrair uma variedade de apoiadores – como investidores, validadores, delegadores e participantes de protocolos.

Os usuários interessados ​​em diferentes aplicativos Web3.0 estarão atentos aos seus aplicativos favoritos por meio de eventos como os lançamentos da cadeia de aplicativos Octopus. Dessa forma, o Octopus é uma base comunitária para as cadeias de aplicativos apoiarem sua própria jornada de construção de comunidades ativas ao seu redor.

A Octopus Network também oferece grande capacidade de bifurcação para todas as suas cadeias de aplicativos, tornando sem sentido para qualquer tipo de magnata ou tirano assumir uma cadeia de aplicativos sem o acordo da comunidade – mantendo-a descentralizada. A Octopus atenderá a todas as suas cadeias de aplicativos com bifurcação, arquivando o histórico do bloco de cadeias de aplicativos no Arweave - um protocolo de armazenamento permanente descentralizado.

Com base no histórico de blocos arquivados, cada appchain pode ser bifurcada em qualquer altura para se tornar uma nova appchain se sua comunidade suportar a bifurcação. E qualquer equipe principal do appchain é substituível se perder a confiança de sua comunidade. É assim que a conscientização do usuário garante a descentralização.
O que é o Programa Octopus Accelerator?
 



A equipe do Octopus está bem ciente de que o espaço blockchain ainda é apenas uma fatia de toda a indústria da Internet. E dentro do espaço blockchain, os desenvolvedores de contratos inteligentes do Solidity são muito mais prolíficos do que os desenvolvedores do Substrate.

Para encontrar e atrair projetos de appchain excepcionais, a primeira tarefa é transformar desenvolvedores Web e Solidity em desenvolvedores Substrate. Nesse sentido, a equipe Octopus é muito experiente.

A Equipe Octopus construiu com sucesso o IBC para Substrate e também ofereceu cursos de treinamento online de Substrate na China com outros entusiastas de Substrate. Esses cursos treinaram o primeiro grupo de desenvolvedores do Substrate na China, inicializando a gênese da Chinese Substrate Community. Os desenvolvedores do Octopus também são organizadores da comunidade Rust na China (incluindo RustCon).

Até o momento, muitos membros da equipe Octopus serviram como assistentes de ensino para o curso, que agora é um curso oficial financiado pela Parity, Inc. Com base nessas experiências, estamos negociando com parceiros em todo o mundo, incluindo a equipe educacional NEAR, para fornecer cursos de treinamento semelhantes em todo o mundo.

Mas a Octopus reconhece que desenvolvedores de Substrate qualificados não são tudo o que os projetos de aplicativos Web 3.0 bem-sucedidos exigem. É por isso que estamos lançando o Octopus Accelerator Program — uma coleção de cursos e seminários abertos e combináveis ​​disponíveis para desenvolvedores de substrato e equipes Web3.0 em todo o mundo.

A cada trimestre, o Programa Octopus Accelerator realizará um lote de cursos com duração de dez semanas. Durante cada período do curso, os assuntos oferecidos incluirão tópicos como Economia de Tokens, Design de Produto Web 3.0, Construção de Comunidades, Governança Blockchain, Regulamentação de Criptografia e Captação de Recursos para Projetos de Cripto. Especialistas convidados participarão de seminários, fornecerão vídeos sobre tópicos específicos e estarão disponíveis como mentores.

No final de cada lote de cursos, a Octopus Foundation realizará um evento Demo Day para selecionar os cinco principais projetos da cadeia de aplicativos e fornecer a eles até US$ 250 mil em recompensas totais por trimestre.

Dessa forma, a Octopus Foundation financiará diretamente 20 projetos de appchain por meio do Programa Octopus Accelerator a cada ano, concedendo a eles mais US$ 1 milhão no total.




	

	
	
		
			
				O que é verdade sobre a equipe de desenvolvimento do Octopus?
			
		

		
					

		
			
			
			
			A equipe de desenvolvimento Octopus construiu o IBC para substrato
		
			
			A equipe de desenvolvimento da Octopus ajudou a treinar os primeiros desenvolvedores de substrato na China
		
			
			A equipe de desenvolvimento Octopus era anteriormente conhecida como Cdot
		
			
			Todas acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Como as Appchains vão ao ar no Octopus


O design arquitetônico da Octopus Network - juntamente com o poder de processamento do NEAR Protocol - facilita a hospedagem de centenas de cadeias de aplicativos. O processo de seleção de appchain faz parte do protocolo Octopus e o poder de decisão pertence à Comunidade Octopus.

Além de ser validadores e delegadores de appchain, os detentores de token $OCT têm o direito de selecionar os melhores projetos de appchain votando ou rejeitando em uma fila de candidatos na cadeia.

As cadeias baseadas em substrato podem se tornar cadeias de aplicativos Octopus concluindo com sucesso as seguintes etapas:

 	Cadastro
 	Auditoria
 	Votação
 	Encenação
 	Inicializando

Fase de registro
Qualquer cadeia baseada em Substrate pode se inscrever para se tornar uma cadeia de aplicativos Octopus. O registro requer um white paper ou especificação e uma versão de tempo de execução que foi testada e auditada internamente. Para evitar abusos, o registro exige um pequeno depósito de $OCT.
Estágio de Auditoria
Depois que o appchain for registrado, os membros da força-tarefa da comunidade irão auditá-lo. O objetivo da auditoria é garantir que o appchain não tenha vulnerabilidades de segurança conhecidas e que sua lógica de aplicativo seja consistente com seu white paper ou especificação.

A própria auditoria do Appchain é atualmente uma necessidade não atendida no espaço blockchain. Apenas algumas empresas do setor têm experiência relevante e os serviços que prestam são caros.

A auditoria realizada pela Octopus Network não apenas reduz muito o custo de lançamento de um appchain para seus fundadores, mas também contribui para o acúmulo de conhecimento relevante e capacidades profissionais.
Fase de votação
Depois que um appchain passa pela fase de auditoria, ele entra na fila de candidatos onde será votado ou rejeitado pelos detentores de $OCT.

Em um período contínuo que dura de uma a duas semanas, o appchain que ocupa o primeiro lugar com o maior número de votos positivos, menos, votos negativos, na fila entrará no estado de teste como o appchain mais suportado pela Comunidade Octopus.
Estágio de preparação
Na fase de preparação, os detentores de $OCT podem apostar ou delegar na appchain.

Quando o período de teste terminar, se o appchain tiver atraído staking suficiente além da linha de fundo de segurança, ele entrará no estado de inicialização.
Estágio de inicialização
No estágio de inicialização, os membros da força-tarefa executarão 4 nós de bootstrap para iniciar o appchain. Em seguida, os validadores devem executar seus nós para ingressar no consenso da cadeia de aplicativos.

A Octopus Network também executará um cluster de nó completo para cada appchain e fornecerá serviços de acesso à API para o front-end do appchain. Os desenvolvedores do Appchain só precisam atualizar a configuração do front-end e o appchain está pronto para os usuários finais.
Recompensas da Appchain
A Octopus reconhece que os projetos da appchain são os criadores de valor da rede. Enquanto outras redes multichain cobram entrada para appchains, a Octopus considera as equipes de appchain a parte mais crítica da comunidade e está muito feliz em compartilhar os benefícios da expansão do efeito de rede com eles.

Portanto, as primeiras 100 cadeias de aplicativos Octopus lançadas serão recompensadas diretamente com 100k $ OCT.

Além disso, a fundação decidiu fornecer 1 milhão de recompensas adicionais de $OCT para as dez primeiras cadeias de aplicativos para reconhecê-las como cadeias de aplicativos fundadoras.
O que é o token $OCT?
$OCT, o token nativo da Octopus Network, é um token fungível e não inflacionário com três utilidades principais:

 	Garantia para garantir a segurança do appchain
 	Governança
 	Aprovando candidatos da cadeia de aplicativos votando-os na fila de candidatos

Garantia de segurança
O $OCT desempenha um papel fundamental na Octopus Network por meio de staking de appchain. Os detentores apostam seu $OCT para fornecer segurança às cadeias de aplicativos em que acreditam para ganhar recompensas nos tokens nativos das respectivas cadeias de aplicativos.

O Staking de $OCT também atua como um desincentivo para participantes mal-intencionados que seriam penalizados por ter seu $OCT reduzido, que é a fonte de segurança alugada para as cadeias de aplicativos Octopus.

Quando o Octopus for executado em sua capacidade total, 30 a 50 cadeias de aplicativos serão lançadas na rede anualmente.

Se a taxa de retorno de equilíbrio de longo prazo do staking da cadeia de aplicativos for de 5% ao ano, apenas as cadeias de aplicativos recém-lançadas trariam cerca de US$ 400 milhões em demandas de garantia a cada ano.
Governança
A segunda função do $OCT é dar aos titulares o direito de controlar a governança da rede (mais especificamente, o Octopus Relay, onde todas as regras econômicas se aplicam), formando o Octopus DAO.

O Octopus DAO Council tem no máximo 100 membros, mas é mais provável que cresça de alguns membros no início para algumas dezenas quando estiver estável.

O poder de governança de cada membro do Conselho é valioso, mas ainda disperso o suficiente para evitar conluio.

Em nossa opinião, na maioria dos casos, o valor de governança de um token não pode ser dissociado de seu valor de utilidade. Uma governança sólida e amplamente participada dará aos detentores de token expectativas de valor mais estáveis ​​e suprimirá flutuações extremas no preço do token, reduzindo assim o custo implícito da opção de staking de appchain.
Votação da Appchain
A terceira função de $OCT por meio de detentores de $OCT é a seleção de quais cadeias de aplicativos continuarão a viver na rede, votando ou rejeitando candidatos a cadeias de aplicativos.

As equipes da Appchain precisarão convencer a comunidade Octopus de que seu aplicativo Web3.0 é significativo e criará fluxos de valor contínuos para investidores que apostam $OCT em suas appchains.

Os detentores de $OCT selecionarão cuidadosamente quais cadeias de aplicativos eles suportam, pois há um custo de oportunidade de perder aquelas que poderiam ser mais valiosas.
Conclusão
Nomeamos a Rede Octopus em homenagem à criatura bêntica marinha mais ferozmente inteligente. De uma perspectiva evolutiva, o polvo, que consiste em cerca de 300 espécies, é um organismo incrivelmente bem-sucedido. Existe há 155 milhões de anos, vive em todos os oceanos e suas muitas espécies se adaptaram com sucesso a uma ampla gama de diversos habitats marinhos.

Esperamos totalmente que a Octopus Network forneça aplicativos descentralizados para todos os setores on-line que o intermediário tradicional da Web 2.0 controlou até agora - e devolva valor aos criadores reais.

Na Octopus Network, podemos construir aplicativos Web3.0 com ótima experiência do usuário, aproveitando a tecnologia appchain - seja em jogos, NFTs, DAOs, publicidade, economia dos criadores (vídeo, áudio, gráficos, texto), mercados de previsão, token registro com curadoria (TCR) e muito mais.

A 3ª Onda de Inovação de Redes Criptográficas está sendo introduzida na parte de trás do versátil Octopus, trazendo consigo o potencial para um tsunami de inovação descentralizada da Web3.0 – limitada apenas pela imaginação.

### Integração com o protocolo NEAR

Uma descrição da nossa jornada de integração NEAR




Vamos começar com o que são os 3 pilares do Protocolo NEAR:

 	Prova de Participação (Proof-of-Stake)
 	Fragmentado (Shards)
 	Contratos inteligentes WASM

Como uma prova de participação, o consenso da blockchain é alcançado fazendo stake e não pela mineração, Near tem blocos rápidos de 1 segundo com finalização curta.

O blockchain é fragmentado, o que significa que as chamadas entre contratos são assíncronas (não confundir com síncronas como no Ethereum ou Solana). Codificando Contratos em NEAR você precisa ter a mentalidade de trabalhar com modelo de ator (ou microsserviços, mas eu odeio esse termo). O requisito de assincronia é necessário para que os fragmentos possam ser processados ​​em paralelo, levando a uma taxa de transferência de transações muito maior. Blockchains em que os contratos inteligentes não são fragmentados simplesmente atingirão um teto de escalabilidade, descarregando para GPU ou ASIC (enquanto ainda síncrono) só pode atrasar horizontalmente esse teto, mas não levará a uma escala exponencial.

Contratos em NEAR são código WASM, você pode então codificar em qualquer linguagem que possa compilar para WASM. Atualmente AssemblyScript (subconjunto de TypeScript) e RUST são mais suportados com cadeias de ferramentas adequadas.

ISENÇÃO DE RESPONSABILIDADE: Isso levará menos de 30 minutos se você puder programar em TypeScript.

Construir um WebApp no ​​protocolo NEAR (que é exatamente o que o Near proporciona) é muito fácil em comparação com outras blockchains.

Vamos clonar o exemplo do contador aqui https://github.com/near-examples/counter.






git clone https://github.com/near-examples/counter
yarn












Nós só apenas nos importamos com essas 2 pastas e 1 arquivo assembly/ é onde está nosso contrato inteligente (que será compilado para WASM).

src/ é para onde vai nosso código frontend que interage com o contrato.

package.json é para onde vão nossas dependências JavaScript extras.


















O núcleo do nosso contrato inclui armazenamento em cadeia, registro de controle para o recebimento gerado e funções públicas exportadas. As funções que definem o armazenamento devem ser chamadas, caso contrário podem ser visualizadas (mesmo sem uma conta NEAR).

Near suporta vários tipos de coleções (que se auto-descrevem) no near-sdk-as.












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collectionsOs principais que você vai precisar:

 	storage.getPrimitive — get/set
 	persistenteMap — definir/obter
 	persistenteUnorderedMap — set/get/query/length

Eu não incluo persistenteVector porque você deve evitar usá-lo, é muito fácil queimar toneladas de vetores de iteração de gás, tente usar conjuntos sempre que possível.

Os valores padrão para coleções de visibleMap precisam ser sufixados com !


let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log imprimirá a saída do log em seu recibo ao chamar uma função, isso é útil para controlar o fluxo do que aconteceu, especialmente à medida que os contratos se tornam mais complexos. Exemplo de um contrato de cunhagem legível por humanos pode ter uma mensagem de log de “alice.near cunhou 5.0 ZOD de zod.near”.

Vamos implantar nosso contrato, para isso precisamos de near-cli.






npm install near-cli -g
E para implantar podemos criar uma conta testnet fictícia. Contas são contratos e você só pode ter 1 contrato por conta. Para criar vários contratos, você precisa usar subcontas, contract1.me.near, contract2.me.near.

Vamos implantar e chamar a função getCounter.
yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
Saída é

View call: dev-1623290109414-64922580028342.getCounter({})
0
Vamos incrementar o contador

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Vamos ver esta chamada no explorador de blocos https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342

Maravilha.

Para visualizar uma função, podemos usar curl, mas precisamos analisar alguma saída de linha de comando, é mais simples escrever um script de nó rápido. Nós nem precisamos de uma conta próxima.






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
O snippet a seguir usa a API RPC https://docs.near.org/docs/api/rpc para consultar o estado do contrato zodtv.near mint.

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
NEAR denomina-se ao 24, o yocto.

3_000_000_000_000__000_000_000_000

é 3,0

Isso termina a primeira série aqui, a próxima seria trabalhar com um frontend da Web e obter corretamente o equilíbrio, o estado e muito mais.

### Crypto Hero, jogo na NEAR

O que é o Crypto Hero?

Crypto Hero é um jogo baseado em blockchain, focado principalmente em PvE (Jogador contra o Jogo) – onde você pode moer masmorras e trocar itens com outros jogadores, além de jogar com amigos em um sistema de invasões onde você pode ganhar prêmios de Pixel Token semanalmente. A ideia é inspirada em RPGs tradicionais, assim como em RPGs de ação como Diablo.



Ele tenta implementar a mecânica desses jogos de maneira simples, permitindo uma experiência simplificada onde os jogadores podem desenvolver seus personagens, competir com outros e, o mais importante, ganhar.

O jogo contém 5 elementos principais, que vou listar abaixo.

Por que você deve jogar Crypto Hero?

Crypto Hero é o segundo jogo da PixelDapps  e não será o último – uma equipe que vem produzindo com sucesso jogos blockchain onde os jogadores encontram oportunidades de ganhar prêmios enquanto se divertem. O token atual é estável e crescente, que é o momento perfeito para investimento em estagio inicial. Fora isso, o Crypto Hero é divertido. Ele cria um sistema de progressão de RPGs para um nível totalmente novo com itens NFT que são coletados e negociados em uma comunidade que está principalmente conectada com ideias e aspirações no ecossistema.

Como você joga o Crypto Hero?

Regras do Crypto Hero

Quando posso jogar o Crypto Hero? 

O lançamento da MainNet foi em 22 de janeiro

Onde posso jogar o Crypto Hero?

Jogue Crypto Hero

1 - A casa de leilões

Os itens podem ser trocados na casa de leilões com Pixel Tokens. Você pode filtrar itens por categorias, bem como diferentes tipos de equipamentos para facilitar a pesquisa.



 	Os itensSeu herói pode equipar até 6 itens diferentes: uma arma, armadura, botas, um colar, um anel e um capacete.

Os itens são definidos por raridade: comum, raro, épico e lendário.

Itens podem ser dropados em masmorras, quanto mais profundo o nível da masmorra, melhor o drop do item.

Os itens tornarão seu herói mais forte.



 	O heróiSeu herói tem HP, Nível e Experiência.

Seu herói pode subir de nível quando ganha experiência suficiente. 

Quanto maior o nível do seu herói, mais forte ele fica.



 	A masmorraVocê pode enviar seu herói para explorar a masmorra, onde ele enfrentará uma horda de criaturas.

Você pode escolher o quão profundo você quer ir em uma masmorra, níveis mais profundos dão melhores itens e experiência, mas se tornam exponencialmente mais difíceis. 

Depois de vencer a masmorra, você é recompensado com itens e experiência e precisa esperar para entrar na masmorra novamente.



 	A escada de classificaçãoA escala de classificação exibe os níveis mais altos + os níveis de itens no jogo, criando um cenário competitivo entre os jogadores.



 	As InvasõesO sistema de invasões é um impulso social para os jogadores se conectarem, além de ser a principal parte de ganhos do jogo. Você pode se agrupar com outros 7 jogadores para lutar contra chefes que têm diferentes dificuldades de classificação e recompensas diferentes.

### Melhores práticas de criptografia: dicas para uma experiência de criptografia perfeita

O espaço de criptomoedas pode ser um pouco arriscado, mesmo para os mais experientes. À medida que a criptomoeda ganha mais popularidade, os riscos para seus ativos também aumentam exponencialmente. Os investidores em criptomoedas estão cada vez mais preocupados com a segurança de seus investimentos e ativos. Embora os ativos criptográficos e as criptomoedas sejam protegidos pelas plataformas nas quais são negociados, os investidores e usuários dessas trocas precisam ser mais proativos ao proteger seus ativos digitais.

É imperativo que os usuários tenham uma ideia completa do espaço das criptomoedas antes de investir em criptomoedas. Também é essencial ter uma ideia do cenário regulatório em seu país para que você conheça o status legal das criptomoedas e como você pode investir. Seguir um conjunto de práticas recomendadas é ideal para proteger seus investimentos em criptografia e ter uma experiência de criptografia perfeita.
Riscos potenciais para consumidores de criptomoedas
A volatilidade é um risco considerado parte integrante do espaço criptográfico. Qualquer indivíduo que investe em criptomoedas está bem ciente dos aspectos de volatilidade da criptomoeda. No entanto, vários outros riscos podem representar uma ameaça significativa para os investidores em criptomoedas e seus investimentos. Alguns desses riscos são:

 	Lavagem de dinheiro
 	Golpes de investimento falsos por meio de ICOs.
 	Golpes de aumento de preço e despejo de criptomoedas
 	Corretoras falsas de criptomoedas
 	Golpes de phishing

Além dos riscos mencionados acima, há sempre a ameaça iminente de hackers. Os investidores devem estar sempre atentos à possibilidade de fraude, roubo, perda de ativos. Vejamos algumas das maneiras pelas quais os investidores podem proteger suas criptomoedas e garantir que tenham uma experiência criptográfica tranquila.




	

	
	
		
			
				Qual das opções a seguir não é considerada uma estratégia sólida ao investir em criptomoedas?
			
		

		
					

		
			
			
			
			Estudar e entender o cenário regulatório em sua jurisdição antes de investir
		
			
			Comparar cuidadosamente as corretoras e ver qual melhor atende às suas necessidades
		
			
			Procurar pelo próximo Bitcoin e Ethereum
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Melhores práticas de criptografia para garantir uma experiência de criptografia perfeita
Sua criptografia pode ser comprometida por vários caminhos, como carteiras de criptomoedas, uma corretora comprometida ou uma frase semente comprometida. Aqui estão algumas etapas simples que podem ajudar muito a garantir que você tenha uma experiência de criptografia perfeita.
Sempre use uma senha forte
Ao usar uma bolsa para negociar criptomoedas, você precisará criar uma conta. É imperativo que você proteja esta conta de negociação com uma senha forte composta por números e caracteres especiais. Uma senha forte é sua primeira linha de defesa contra qualquer hacker ou agente malicioso. O uso de um gerenciador de senhas também ajuda, permitindo que você crie e lembre-se de senhas complexas. Você pode usar gerenciadores de senhas, como o Dashlane, para ajudá-lo a criar uma senha segura. Também é imperativo alterar sua senha regularmente e usar um gerenciador de senhas, conforme mencionado acima, juntamente com a autenticação de dois fatores.




	

	
	
		
			
				O que pode ser considerado um potencial risco para os investidores de criptomoedas?
			
		

		
					

		
			
			
			
			Falsos investimentos em ICOs
		
			
			Esquemas fraudulentos de aumento de preços e despejo de criptomoedas
		
			
			Lavagem de dinheiro
		
			
			Todos acima
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Use 2FA (autenticação de dois fatores)
Além de manter uma senha forte, implemente 2FA ao usar trocas de criptomoedas. Em vez de usar a autenticação por SMS, você pode usar aplicativos como Google Authenticator ou Authy. Idealmente, ajudaria se você usasse o 2FA mais forte permitido pela plataforma. Chaves de segurança de hardware como Yubikey são ideais, juntamente com aplicativos como Google Authenticator e Authy, que já foram mencionados acima. Se você não tiver escolha e 2FA baseado em SMS, você deve habilitar um código único para ser enviado para seu dispositivo móvel toda vez que você fizer login em sua conta de negociação de criptomoedas.
Proteja suas chaves privadas
Para armazenar suas criptomoedas, você precisará de uma carteira que conterá suas chaves públicas e privadas para enviar, receber e armazenar criptomoedas. Embora seu endereço público precise ser compartilhado com outros usuários, você não deve compartilhar suas chaves privadas com nenhum indivíduo ou entidade. Se alguém obtiver acesso à sua chave privada, você poderá perder todos os fundos presentes em sua carteira. O mesmo se aplica às suas chaves privadas quando se trata de sua blockchain ou conta de negociação. Você pode proteger suas chaves seguindo algumas etapas simples:

 	Usando uma chave aleatória ou senha
 	Mantendo o controle de suas chaves e não entregando-as a uma troca centralizada.
 	Usando uma carteira de hardware

Use uma carteira fria
Como sabemos, as carteiras de criptomoedas se dividem em duas categorias, carteiras quentes e carteiras frias. As carteiras quentes oferecem facilidade e simplicidade, mas também vulnerabilidade significativa. Enquanto você obtém acesso fácil à sua criptomoeda, eles também são vulneráveis ​​a ameaças de segurança, como hackers. Uma carteira fria é o que a maioria dos especialistas no espaço criptográfico recomendam, especialmente se você pretende manter suas criptomoedas por um período significativo de tempo. Uma carteira fria é essencialmente uma carteira offline, o que significa que seus ativos são armazenados offline, protegendo seus ativos de quaisquer tentativas de hackers. As carteiras frias garantem total segurança contra ameaças com as quais você normalmente teria que lidar ao usar uma carteira quente. Exemplos de carteiras frias são carteiras de hardware e carteiras de papel.
Adote uma abordagem híbrida
Adotar uma abordagem híbrida envolve o uso de carteiras quentes e carteiras frias. Ao usar essa abordagem, você pode armazenar suas criptomoedas offline quando não forem negociadas. No entanto, ao executar uma negociação, você pode simplesmente transferir os ativos que pretende vender para sua carteira quente, concluir a negociação e transferir seus ativos de volta para a carteira fria.
Usar uma VPN
É extremamente importante usar uma conexão de internet segura ao acessar sua conta de negociação de criptomoedas e fazer transações de criptomoedas. Nunca tente realizar uma negociação em uma rede Wi-Fi pública e, mesmo ao usar sua rede doméstica, o uso de uma VPN é recomendado para segurança adicional. O uso de uma VPN ajudará a manter sua atividade de navegação segura contra possíveis hackers ou entidades maliciosas. Também é importante proteger seu dispositivo pessoal, que você usaria para realizar transações. Mantenha sempre seu dispositivo atualizado e certifique-se de não clicar em nenhum link malicioso ou visitar qualquer site malicioso.
Não coloque todos os ovos na mesma cesta
Assim como no mercado de ações tradicional, a diversificação é fundamental no mercado de criptomoedas. Como investidor, a diversificação é sempre saudável para seu portfólio de criptomoedas. Em vez de colocar todo o seu dinheiro, digamos BTC, investir em uma combinação de BTC, ETH e um punhado de outras criptomoedas pode ajudar a protegê-lo da potencial volatilidade do mercado, além de permitir que você se beneficie de várias fontes quando o mercado estiver em alta. corre.
A devida diligência é fundamental
Antes de investir em uma criptomoeda, é importante entender o ativo subjacente, seus usos e como ele funciona. Quase todas as moedas têm whitepapers disponíveis on-line, que podem ajudá-lo a entender melhor a moeda e aprimorar seu conhecimento sobre o potencial da moeda. Se não houver um whitepaper disponível ou se o whitepaper não mencionar ou descrever o funcionamento da moeda, é melhor evitar essa moeda.
O tempo também é fundamental
Assim como a due diligence, o timing também é considerado um fator chave quando se trata de investir no mercado de criptomoedas. Pense que você sabe o que há para saber sobre criptomoedas, então você deve ser capaz de cronometrar seu investimento perfeitamente. O mercado de criptomoedas é volátil e as oscilações de preços são comuns. Não saia por aí investindo em novas moedas procurando o próximo Bitcoin ou o próximo Ethereum. Sempre seja minucioso sobre o projeto antes de investir, siga os padrões de preços e acompanhe as notícias para ficar à frente de eventos que possam afetar negativamente o valor do seu investimento (hack de corretora, manipulação de preços). As criptomoedas são altamente especulativas, portanto, sempre faça sua lição de casa antes de entrar no espaço.
Verifique novamente todos os detalhes da transação
Lembre-se, as transações de blockchain são imutáveis, ou seja, uma vez executadas, elas não podem ser revertidas. Isso torna extremamente importante verificar todos os detalhes da transação antes de prosseguir com a transação. Seus fundos só podem ser revertidos para você se a parte oposta concordar em fazê-lo.
Não invista mais do que você pode perder
Este é um dos pontos mais críticos que você deve ter em mente como investidor. Embora as criptomoedas possam ser consideradas um porto seguro, e sim, elas são para países que são para cidadãos de locais como a Venezuela, que está sofrendo com a hiperinflação. Mas as criptomoedas são um investimento de alto risco com volatilidade significativa. O que é lucrativo de manhã pode ser vermelho à tarde. Se você é iniciante, é sempre aconselhável começar investindo quantias menores de dinheiro.
Conclusão
As criptomoedas são um investimento um tanto arriscado para iniciantes e para cabeças experientes. Como regra geral, os investimentos de alto risco devem constituir apenas uma pequena parte do seu portfólio. No caso de criptomoedas, é sempre bom diversificar seus investimentos em várias moedas para que seus investimentos possam se valorizar ou desvalorizar em graus variados, isolando-o até certo ponto.

Os pontos mencionados acima são geralmente considerados as táticas mais básicas que você pode empregar para garantir uma experiência de criptografia perfeita. O espaço está em constante mudança e você deve ser proativo para garantir a segurança de seus investimentos e fundos, protegendo completamente suas contas e carteiras. Mantenha-se sempre atualizado com as últimas notícias e desenvolvimentos no espaço criptográfico.




	

	
	
		
			
				Usar uma senha forte, 2FA, carteira fria e uma VPN ao realizar transações é considerado parte das melhores práticas de criptografia?
			
		

		
					

		
			
			
			
			Verdadeiro
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!

### Como construir um jogo Play To Earn no NEAR Protocol

Revisão detalhada do protótipo atual — BerryClub




Este guia te faz entender a dinâmica básica que permitirá que você crie um jogo Play to Earn no Near Protocol.

Não queremos deixar você ou seus jogadores ricos, mas a mecânica do Near funciona de forma que pequenas transações sejam muito úteis em uma interface HTML5 simples e criem um jogo de farming simples e divertido. Farming cultivo do inglês,seria no sentido de fazer uma atividade no jogo para receber ganhos em criptomoedas.

Analisaremos um contrato inteligente e os arquivos js/rust por trás de um jogo de farming existente,  berryclub. Se você aplicar a mesma lógica às suas ideias de jogo, poderá obter resultados ainda mais divertidos!
Para seguir o lado técnico deste tutorial, recomendamos verificar o figment Near Pathway para  construir uma transação  e  construir seu primeiro contrato inteligente em Near. Os conceitos presentes nesses guias não estão incluídos neste tutorial. Será muito mais fácil seguir este tutorial se você mantiver uma guia aberta no arquivo de origem vinculado enquanto lê a explicação, porque grande parte do código mencionado é referenciado com números de linha, mas não reproduzido aqui. O repositório original do BerryClub foi bifurcado (fork) para este tutorial a fim de manter esse esforço válido desde que o código ainda funcione no blockchain; como você verá na próxima seção, o jogo em si evoluiu ao longo do tempo e estará evoluindo novamente, queríamos enfatizar seu estado agora.

A interface do Berryclub
Berryclub é construído com React, então a primeira coisa que vamos fazer é entrar no  arquivo app.js  localizado na pasta src do repositório do github, isso nos poupará tempo na análise do contrato, permitindo que nos concentremos no que precisamos extrapolar a lógica fora do jogo real (que é divertido e jogado por uma grande comunidade).

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
Depois de importar o react a primeira biblioteca necessária é o bn.js  um utilitário simples para gerenciar números inteiros ou não decimais, muitos recursos podem chegar à sua interface com esta biblioteca, antes de tudo isto aqui é usado para gerenciar as transações:

const PixelPrice = new BN(“10000000000000000000000”);
O jogo Berryclub é baseado na economia imobiliária, existe um tabuleiro administrado por uma parte do contrato chamado board.rs, ele é subdividido em pixels, e cada pixel tem um preço que deve ser pago para poder sacar nele. As mecânicas da ação de “empate” são o núcleo das habilidades de farming e autossustentação do jogo e serão analisadas em profundidade quando chegarmos ao contrato inteligente.
Como você pode ver aqui, o preço de um pixel é declarado como uma constante no início de nosso aplicativo e pode ser modificado usando as ferramentas de frontend e a biblioteca bn.j. A segunda importação é o sdk near, que nos permite interagir com o blockchain Near, conforme explicado no caminho do NEAR Figment. O primeiro uso da API Near é declarar as variáveis ​​de contrato usadas e garantir que a rede principal seja usada quando o código for executado a partir da url do Berryclub:

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Em seguida, importamos os utilitários react UI para construir nossa interface e permitir que as pessoas desenhem,  react-color,  react-switch  e  react-compound-timer. O primeiro desses utilitários que é usado é o timer, ele é usado para definir um tempo limite para atualizar a tabuleiro na linha 62.

A “atualização” do tabuleiro é feita pelo frontend para exibir o estado atualizado do tabuleiro usando uma chamada RPC para o contrato inteligente.
const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
O que vemos aqui são duas const a mais do que as necessárias para atualizar, as duas últimas na verdade são usadas para o farming dos pixels depois de desenhá-los e definir um intervalo de tempo de um dia para calcular as recompensas. Outras consts também são declaradas para gerenciar a tabuleiro de acordo com o contrato inteligente, e aqui, pela primeira vez, cruzamos o conceito de linhas, que será muito importante para entender a gestão do tabuleiro e é o item mais reutilizável de toda a interface:

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
Como você pode ver, depois de subdividir a tabuleiro 50×50, informamos nossa interface para buscar apenas as linhas seguindo a instrução RefreshBoardTimeout e considerar o comprimento de cada linha como Boardwidth multiplicado por 12, o tamanho de uma única célula.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Os pixels são considerados em lote, não de forma independente, tanto quando a ação de desenho é chamada quanto quando a interface é atualizada.
Por último, mas não menos importante, nossas importações incluem um componente de interface do usuário personalizado, chamado Weapons,js: este componente foi desenvolvido posteriormente na história da comunidade berryclub, para que cada usuário possa fazer upload e desenhar uma imagem inteira no quadro, e cunhar no mercado de NFT berrycards.

Mecânica DeFi
As linhas entre 27 e 51 são uma referência útil de como este Dapp constrói suas habilidades de farming sobre algumas mecânicas básicas de DeFi que serão analisadas nas últimas partes deste tutorial. Até agora, apenas mencionamos brevemente que, para desenhar/comprar um pixel, o berryclub canaliza você através de algumas operações DeFi no ref.finance usando seus próprios Tokens específicos, abacates para comprar pixels e bananas obtidas com os pixels que você comprou.







Existe um clone uniswap simples criado para trocar por bananas/abacates que funcionou no mesmo contrato inteligente construído para os outros tokens deste jogo/protótipo. Há também um token de farming criado para o jogo, chamado pepino, ele permite que as pessoas ganhem uma parte dos tokens que toda a comunidade que joga o jogo paga pelo gás para sacar no tabuleiro.







A Conta ou como os usuários ganham dinheiro
Este é o primeiro passo que damos no código Rust do contrato inteligente, mas senti a necessidade de lembrá-lo que a mecânica DeFi não é a única maneira que o Berryclub permite que você ganhe tokens. A conta tem um arquivo específico no contrato inteligente do Berryclub, não precisamos entrar nisso imediatamente, o que precisamos saber é que algumas informações são coletadas no objeto da conta que são cruciais para a mecânica de farm e ganhos:

 	         ID da conta
 	         accountIndex para a lista (vetor) de contas que tocaram o pixel board pela última vez
 	         balance (vetor para vários tokens de propriedade)
 	         número de pixels
 	         timestamp reivindicado (nanossegundos, quando a conta em questão reivindicou recompensas pela última vez)
 	         preferências de farming (bananas ou pepinos)

As duas últimas informações são para calcular as recompensas em um determinado momento, por exemplo, se você possui 5 pixels por um dia, adquire 5 bananas. Se você comprar de outra pessoa, seus ganhos diminuem porque o número de pixels que eles possuem diminui, de modo que a quantidade de ganhos é calculada e o carimbo de data/hora renovado relacionando a nova quantidade de pixels de propriedade. Como veremos, as recompensas são calculadas com base nessas duas variáveis. A operação aplicada à conta do proprietário anterior quando um pixel é desenhado é chamado de “toque” e você pode encontrá-lo no arquivo Rust account.rs . A propriedade da unidade de pixel único é a base para ganhar no berryclub e, dessa forma, essa mecânica é praticamente a mesma que uma interface de staking NFT poderia usar, recompensando a propriedade NFT.
pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
Para tirar qualquer dúvida o dono inicial do tabuleiro é 0, o próprio contrato, e se não for possível encontrar um dono anterior, o contrato é usado como dono anterior. Finalmente para iniciar o jogo alguns tokens foram armazenados na conta do contrato e são sempre aumentados usando o preço do gás estabelecido para as pessoas comprarem abacates e bananas, para que o “cofre” do jogo seja sempre preenchido com alguns tokens para os usuários ganharem. Agora vamos voltar à nossa interface.

Números para Cores e Vice-Versa






As linhas entre 67 e 82 em app.js  são usadas para decodificar números em cores e vice-versa, para que os elementos da interface do usuário interajam com a tabuleiro, são definidas duas variáveis ​​constantes, intToColor e rgbaToInt. O que podemos notar aqui é que para transformar um número inteiro em uma string de cor, métodos são usados ​​para dividir os 3 números para vermelho verde e azul:

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
Para reverter a string de cor em inteiro, simplesmente aplicamos uma função math.round() e usamos o inteiro resultante.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
As linhas abaixo são sobre upload e impressão de imagens no tabuleiro usando  o componente de arma  e não vamos falar delas em profundidade: imgColorToInt e int2hsv transformam números em dois tipos diferentes de escalas de cores, então transparenteColor é definido e um gamma para a imagem a ser impressa com generateGamma. Em decodeLine transformamos o buffer em um array de pixels a ser impresso no tabuleiro usando as cores acima, iterando entre elas.

Primeiro construtor React
Nas próximas linhas do  app.js  , definimos um construtor que definirá os estados que usaremos posteriormente em nossa interface do usuário para interagir com o blockchain.

class App extends React.Component {
  constructor(props) {
    super(props);
Usando construtor e super nos manterá aptos a usar isso no construtor. Os estados definidos aqui são a cor selecionada padrão e a paleta de cores:













const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
E para o timer que atualiza a tabuleiro:

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Em seguida, os estados da conta de usuário em uso são definidos, mais importante se o usuário fez login, se houver alguma transação pendente (definida como pendentePixels), o estado boardLoaded carregará o quadro de tela para desenhar o alfa selectedCell e os estados pickerColor definem o estados dos componentes interativos para adicionar cores ao quadro, junto com pickingColor para escolher a cor do quadro e gammaColors é útil para impressão de imagens no quadro juntamente com os estados armasOn e armasCodePosition.

Esses outros estados são úteis para a conta ganhar no jogo, baseado em pixel e baseado em DeFi:
owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
Enquanto os últimos três estados configuram o cronômetro para uso posterior:

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
A lista a seguir (linhas 203-215) define objetos e ações que irão interagir com os estados, referenciando pela primeira vez um elemento DOM, o tabuleiro canvas.

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Por fim, definimos alguns dos estados após o login ser feito:

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Interações básicas
Agora começamos a descrever as interações no quadro/tela conectando-as aos estados previamente definidos. Para essas interações, usamos funções. O primeiro usará nossa referência anterior ao elemento canvas para criá-lo e instruí-lo com detalhes sobre o tipo de movimento do mouse que permitimos aos nossos usuários. No primeiro clique, ativamos o watchmode para que nosso timer inicie:

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
E modo de renderização de imagem se o usuário quiser imprimir uma imagem no quadro:

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
A próxima é a parte importante, definimos como a interface lê o movimento do mouse e do toque sobre o tabuleiro:

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
O código utilizado leva em consideração tanto os usuários mobile, construindo uma função ad-hoc para calcular a posição e adicionando um listener ao canvas/tabuleiro para eventos de toque: canvas.addEventListener(“touchmove”, mouseMove); Em seguida, essas interações são usadas para definir o estado selectedCell e rastrear o início e o fim da ação do mouse/toque na tela junto com seu movimento em cada célula:

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
A interação aqui funciona nos estados previamente definidos, como por exemplo, o seletor de cores nos permite escolher as cores do quadro e usá-las para desenhar. A chave usada pelo seletor de cores é a tecla alt e podemos fazer upload e imprimir imagens no quadro somente se o seletor de cores estiver desabilitado, pois então acionaremos a função generategamma. Desta forma, a função pickcolor(), referenciada à célula, poderá ser usada para definir um único pixel ou, em vez disso, todo o quadro para renderizar uma imagem:

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
Agora, pessoal, chegamos ao núcleo, então esteja pronto para começar a mergulhar no contrato inteligente. Sabemos como desenhar o pixel na interface, mas precisamos anexar as transações a eles para que nossa interface seja um Play to Earn real. Portanto, preste muita atenção ao que estou prestes a dizer, porque mesmo que seu jogo pareça completamente diferente disso em termos de interface do usuário, a mecânica de ganho pode muito bem ser adequada para qualquer outro tipo de jogo e será explicada aqui da maneira mais simples que eu posso.






O contrato inteligente Berryclub
Linhas
Encontramos linhas pela primeira vez no início deste artigo, considerando as definições de UI dos estados. As linhas são um conceito importante da interface do Berryclub, são as linhas pelas quais o quadro/tela é subdividido e cada pixel nelas é um pedaço de metadados. Eles fazem parte da interface do usuário que interage com o contrato inteligente e são o objeto mais reutilizável do jogo (por exemplo, para criar níveis em um jogo mais articulado), então vamos gastar um pouco de tempo analisando como eles são usados para armazenar dados do tabuleiro e avaliados enquanto os usuários jogam o jogo.
Em primeiro lugar, no  arquivo board.rs  , encontramos uma definição de PixelLine logo após a definição de Pixel:

pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
Um vetor (array) de dados de string subdivididos pela largura da tabuleiro.

E então definimos no PixelBoard como um vetor do PixelLines desta forma:
pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
Assim, cada linha é armazenada no quadro como um único registro com um campo de metadados chamado line_versions incrementando cada vez que você modifica uma linha. Então cada vez que nossa interface busca o tabuleiro você recebe 50 linhas mas também um metadado para cada linha que representa quantas vezes a linha foi atualizada, e ao buscar esses metadados a interface sabe qual é o número de vezes que a linha foi alterada. Se a linha foi alterada da busca anterior, então você busca os dados para cada pixel, caso contrário, simplesmente não o faz.

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
Esta é uma maneira inteligente de armazenar e buscar dados da interface que podem ser úteis para usar em seu próximo jogo Play to Earn em Near.







Transações
Vamos voltar para nossa interface do usuário em  app.js  por um momento para ter certeza de que entendemos como as transações são gerenciadas no front-end. Primeiro precisamos de uma função para verificar a conta se algo der errado e é isso:

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Então você se lembra dos arrays _queue e _pendingPixels que definimos em nosso construtor? Definitivamente, é hora de usá-los, pois as transações são gerenciadas dependendo de quais pixels você desenhou no quadro:

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Espere, eu não estava pronto para esse monte de código... Sim, você está! Mas vamos olhar com atenção, criamos um objeto de pixels (vetor), modificamos nosso objeto _queue para caber em pixels e atribuímos seu valor ao objeto _pendingPixel em uma  função assíncrona .
E depois? Nós apenas desenhamos em um objeto de contrato que é chamado do SDK próximo, e a ação para desenhar (uma parte das ações que definimos para o usuário) é definida no  arquivo lib.rs  rust.

pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
Para os pixels de contrato inteligente são uma cor e um id de conta (o proprietário místico), e é um jogo baseado em imóveis: então temos um antigo proprietário que desenhou o pixel antes e um novo proprietário que deseja desenhá-lo agora. Com a ação de sorteio, obtemos o old_owner e o substituímos pela conta do novo proprietário alterando o valor da cor de todos os pixels dentro do vetor PixelRequest, então enviamos recompensas para o antigo proprietário enquanto cobramos o novo. 

Os carimbos de data e hora para recompensas são redefinidos e a contagem começa novamente do zero com um pixel a menos para o antigo proprietário e um a mais para o novo. A ação setPixelRequest é definida no  arquivo board.rs  do nosso contrato, mas voltemos ao nosso  libs.rs .

Como é a função Maybe_send_rewards()? Aqui está em toda a sua glória:
impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
Por favor, não seja preguiçoso, se você não puder se ajudar, pode chegar a isso mais tarde com  este vídeo do autor do jogo . As explicações que vou usar são tiradas desse vídeo também!

A função verifica a hora no blockchain (não estamos usando o timer na interface aqui, porque queremos ter certeza!) e usa os recursos de farm do contrato em um timestamp global com a função get_next_reward_timestamp() e last_reward_timestamp() então finalmente chama get_expected_reward() para calcular as recompensas devidas à conta.
pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
Então, pegamos o saldo atual da conta berryclub (lembra que temos um campo de saldo na conta?), o uso e custos atuais de armazenamento e um limite de segurança de 50 abacates. Se o saldo for seguro para uso fora do custo de armazenamento, dividimos em 24 (horas) * 60 (minutos) de recompensa, o que significa que você basicamente obtém exatamente o mesmo saldo que possui uma vez, se ligar a cada minuto, poderá encontrá-lo definido no início do  arquivo lib.rs :

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
Aposto que vocês acham que o processo de recompensa acabou. Errado.

Na verdade, precisamos voltar à nossa função Maybe_send_reward() para ver que ela chama o novo contrato de farm Berryclub para distribuir as recompensas de staking, que são… pepinos, o token de staking no Berryclub 🙂
const FARM_CONTRACT_ID_PREFIX: &str = "farm";
Na verdade, essa não é a única fonte de receita de distribuição com essa função, ela também aproveita os custos de gás pagos pelas pessoas para comprar abacates e trocar bananas para recompensar toda a comunidade!

Como isso é possível? Primeiramente, o GAS_BASE_COMPUTE é definido no  arquivo token.rs  onde a quantidade de gás para o contrato inteligente é definida. Sim, você está certo! O preço do gás é baixo e pode ser usado para recompensar os usuários que interagem com seu videogame!!!

Para entender melhor como as taxas de GAS funcionam no Near, consulte esta documentação detalhada!
Este tutorial é trazido a você por jilt.near e seu  projeto NFT Gaming. Apoie-o na compra de NFTs!

### Optimiser pour NEAR Storage On-Chain (Réduction de la Taille du Contrat)

Avis : Nous vous laissons quelques « questions » pour que vous puissiez expérimenter vous-mêmes les résultats finaux.

Le stockage sur chaîne coûte cher. Pour chaque 100 kB utilisés, 1 NEAR est verrouillé. Ces NEAR peuvent être retournés si vous supprimez le stockage utilisé. Il existe deux principales causes d'utilisation du stockage :

 	Transactions : chaque transaction est un reçu, qui est enregistré en chaîne, ce qui occupe un peu de stockage. Chaque reçu de transaction a une longueur différente (certains appellent plus de fonctions, donc une réception plus longue ; d'autres n'appellent qu'une seule fonction, donc une réception plus courte), d'où la quantité de stockage utilisée est différente. Tout comme vous avez besoin de plus de papier pour imprimer un long reçu, vous utilisez plus d'espace de stockage pour stocker un reçu plus long.
 	Déploiement de contrat intelligent : lorsque vous déployez un contrat intelligent, il prendra la taille du contrat intelligent (il peut différer légèrement de ce que vous voyez dans le fichier wasm local, mais dans l'ensemble, les différences sont minimes).

Pour les transactions, à moins de réduire les transactions que vous avez effectuées, vous ne pouvez pas vraiment réduire l'espace occupé en raison des transactions.

(Question : Pouvons-nous supprimer notre compte de niveau supérieur via near-cli ? Si nous le supprimons, cela libère-t-il des coûts de stockage ? (P. -S. vérifier l'explorateur après la suppression d'un sous-compte.) Certes, les transactions ne seront pas supprimées, d'où verrouillera-t-il toujours le coût de stockage, donc ne pourra jamais être libéré ?)

Ici, nous parlerons de l'optimisation de la taille de votre contrat contract (Smart Contrat)

Remarque : on dit que le développement en AssemblyScript conduit à une taille de wasm plus petite, pour le même code écrit, par rapport à Rust. On n'est pas un développeur AS (préfère utiliser Rust), donc on n'en parlera pas ; en fait, on n'a pas besoin d'en parler, c'est de toute façon le boulot du compilateur.
Optimiser la taille du contrat
Stockage Persistant
Near a une liste de collections, la liste est ici. Ces collections mettent en cache les données pour réduire les frais de gaz. Le compromis est le suivant : combien de frais de gaz souhaitez-vous réduire ? Combien de frais de stockage êtes-vous prêt à payer pour la réduction des frais de gaz ? De combien de stockage persistant unique avez-vous besoin ?

La différence est mentionnée dans le lien ci-dessus (les mots exacts sont comme ci-dessous):

Il est important de garder à l'esprit que lors de l'utilisation de std :: collections (c'est-à-dire HashMap, etc. Rust locals), chaque fois que l'état est chargé, toutes les entrées de la structure de données seront lues à partir du stockage et désérialisées. Cela aura un coût élevé pour toute quantité de données non négligeable, donc pour minimiser la quantité de gaz utilisée, les collections SDK doivent être utilisées dans la plupart des cas.

Considérez cet exemple : nous avons un contrat principal qui a un dictionnaire/hash/map pour lier un ArticleId à un Article. L'article est un objet (dans Rust, on l'appelle aussi un Struct) avec ses attributs.
use near_sdk::AccountId;
use near_sdk::collections::LookupMap;
use std::collections::HashMap;

pub struct Contract {
pub article_by_id: LookupMap<ArticleId, Article>,
}

pub struct Article {
pub owner_id: AccountId,
pub article_id: String,
pub royalty: HashMap<Account, u16>,
}
We see that Contract.article_by_id uses LookupMap and Article.royalty uses HashMap. We shall discuss why we don’t use other types.
Considérez article_by_id, lorsque nous créons un article, l'identifiant id sera unique et spécifique à cet article. Il sera stocké pour toujours. Une LookupMap cache les résultats en mémoire afin que nous n'ayons pas à "calculer" (en utilisant les frais de gaz) chaque fois que nous avons besoin des résultats.

 

Comme mentionné précédemment, étant donné que tout sera désérialisé s'il est lu lors de l'utilisation de HashMap, et que LookupMap<AccountId, Article> n'est pas une quantité insignifiante de données (lorsqu'il y a beaucoup d'articles en cours de création), il doit être mis en cache sur la chaîne.

 

Maintenant, pourquoi utilisons-nous LookupMap au lieu de UnorderedMap ? Le latter offre une itération sur la fonctionnalité de collection, dont nous n'avons pas besoin. Si vous en avez besoin, utilisez le latter.

 

Ensuite, pour la royalty, nous utilisons HashMap. Le fait est que nous avons beaucoup d'articles, chacun avec son propre Article.royalty unique. Pour chaque Article.royalty unique, nous devons créer une nouvelle clé pour enregistrer le stockage.

P.-S. Si vous ne le savez pas encore, vous avez besoin d'une clé unique pour chaque objet des collections NEAR SDK. Si deux collections NEAR SDK partagent la même clé, elles partagent les mêmes données (indépendamment du fait que cela fonctionnera ou échouera si vous partagez de la mémoire entre deux objets différents, comme Vector et LookupMap)

Illustrons le même scénario de clé stockage partagé. Supposons que nous créons deux articles, l'article A et l'article B. Ce sont leurs équivalents Article.royalty.
// Values are percentage, 100.00% == 10_000.

// Article A
{
"alice.near": 1_000,
"bob.near": 500,
}

// Article B
{
"alice.near": 1_500,
"charlie.near": 2_000,
}
For some reason, there’s a repeat royalty for alice.near. If you use the same storage key, it will lead to error, complaining that: you already have an alice.near stored in Article A, and you are repeatingly storage another value to that key, and this is not possible. We also want them to be independent of each other; and same storage key used by 2 different HashMap means they share the same values.
(Question : pouvez-vous récupérer les valeurs stockées dans l'article A si vous initialisez avec la même clé de stockage dans l'article B ?)

La solution consiste à créer une clé de stockage distincte pour chaque collection. Cependant, si nous avons 1 million d'articles, nous avons besoin de 1 million de clés de collecte différentes pour les stocker séparément. Cela semble stupide ! Par conséquent, il est logique de les stocker plutôt sous forme de HashMap. De plus, ils sont triviaux. Ces royalty ou redevances sont conçues à l'origine pour limiter la quantité de données qu'elles peuvent stocker, de sorte que la récupération des données est petite et que leur désérialisation est bon marché. Cela renforce notre choix d'utiliser HashMap plutôt que les collections SDK équivalentes, malgré une consommation de gaz (légèrement) plus élevée (ce qui est négligeable puisque la collection est si petite qu'elle est négligeable).

En conclusion, lors de la conception de votre contrat intelligent, choisissez d'utiliser les collections NEAR SDK ou les collections Rust en fonction de la trivialité et du nombre de répétitions dont vous avez besoin pour le même Map.
Réduction de codes
Les premiers codes que nous écrivons, ils sont mauvais. En fait, ce ne sont qu'un brouillon. Nous avons besoin d'une refactorisation pour supprimer le code inutile. Il existe un compromis entre un code plus facile à comprendre et l'optimisation du stockage.

Par exemple, on a peut-être un PayoutObject, et il n'est utilisé que dans une seule fonction.
use near_sdk::json_types::U128;
use near_sdk::AccountId;

pub struct Payout {
pub payout: HashMap<ArticleId, U128>,
}

impl Default for Payout {
fn default() -> Self {
Self [
payout: HashMap::new(),
]
}
}
Pourquoi ne pouvons-nous pas simplement définir un
HashMap::new()
dans la fonction spécifique qui l'utilise? Bien sûr, si vous faites le latter, il serait plus difficile de comprendre le code. Le former rend les choses plus faciles à comprendre, d'un point de vue d’Objet Orienté. Cependant, (significativement) plus de code conduit à plus de stockage utilisé après la compilation vers WASM. Alors, il est temps de faire quelques compromis.

À l'avis, la lisibilité est plus importante que l'optimisation de l'espace de stockage. Si nécessaire, clonez le composant lisible d'origine et effectuez une optimisation à chaque fois que vous apportez des modifications, afin que les gens puissent comprendre ce que vous faites en lisant votre code d'origine. Bien sûr, cela signifie plus de travail pour vous.

(Question : Combien d'espace est économisé si vous remplacez le former par le latter ? Si vous avez un scénario similaire dans votre programme, essayez de l'optimiser en écrivant moins de code et voyez combien d'espace il a compilé, y a-t-il des différences ? (Parfois il n'y en a pas, parfois il y en a. Pour ceux qui n'en ont pas, préférez garder le code lisible pour faciliter le débogage à l'avenir. ))
Wasm-Opt
Après avoir compilé la version optimisée, vous pouvez encore réduire davantage la taille du contrat en utilisant wasm-opt. Pour l'installer, téléchargez le binaire ici pour votre système d'exploitation OS et décompressez-le (unzip). À l'intérieur, il y a un dossier "bin", dont vous devez copier le chemin exact vers ce dossier et l'ajouter à votre chemin d'Environnement. Après quoi, essayez d'appeler wasm-opt depuis la ligne de command line/terminal, qu'il s'exécute ou non. Sinon, google en ligne comment le résoudre (peut-être que vous ne l'avez pas ajouté à la bonne variable d'environnement, peut-être que votre terminal est déjà ouvert et qu'il n'actualise pas le dernier chemin, sont les deux problèmes les plus courants).

L'exécution de ceux-ci réduirait la taille du fichier :
#!/bin/bash
set -e

export WASM_NAME=tipping.wasm
z
mkdir res

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
cp target/wasm32-unknown-unknown/release/$WASM_NAME ./res/
wasm-opt -Os -o res/output_s.wasm res/$WASM_NAME
ls res -lh
Ici, nous supposons que le contrat d'origine est compilé dans tipping.wasm (le nom Cargo.toml est tipping). Ensuite, le nom optimisé est output_s.wasm. Nous exécutons ensuite ls (sous Linux) pour vérifier leur différence de taille de fichier. Il devrait être plus petit.

Remarque : vous pouvez également utiliser -Oz pour les drapeaux, mais on a trouvé cela inutile, comme pour le projet sur lequel on travaille, cela ne conduit pas à une taille de fichier plus petite.

Remarque importante : Le RUSTFLAGS doit être "link-arg=-s", si vous le changez accidentellement en "-z", vous pourriez avoir un gros problème. Au moins pour un, il génère un fichier wasm beaucoup plus volumineux. Vous devrez l'expérimenter et vérifier votre propre projet.

Peut-être qu'à l'avenir, ils pourraient autoriser le fichier .wasm.gz afin que vous puissiez optimiser davantage la taille du fichier. Actuellement, on l'a essayé et il ne peut pas désérialiser un fichier gzippé, ne prenant en charge que le fichier .wasm en chaîne.

Cargo.toml

Ce sont les drapeaux habituels pour le cargo toml.
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
Vous pouvez également choisir opt-level = "z", cela peut ou non générer un binaire plus petit.
Quelques autres petites victoires
Éviter le Formatage de Chaîne

format! et to_string() peut apporter un gonflement du code ; utilisez donc une chaîne statique (&str) chaque fois que possible.

Suppression de rlib si non requis

Si vous n'avez pas besoin de faire des tests de simulation, supprimez rlib.

Utiliser la sérialisation Borsh

Préférez ne pas utiliser serde lorsque cela est possible. Voici une page sur la façon de remplacer le protocole de sérialisation.

Évitez les assertions standard de Rust et les macros de panique

Ceux-ci contiennent des informations sur l'erreur renvoyée, ce qui introduit un gonflement inutile. Essayez plutôt ces méthodes :
// Instead of this
assert_eq!(
contract_owner,
predecessor_account,
"ERR_NOT_OWNER"
);

// Try this (for all versions of near-sdk-rs)
if contract_owner != predecessor_account {
env::panic_str("ERR_NOT_OWNER")
}

// For near-sdk-rs v4.0 pre-release
use near_sdk::require;
require!(
contract_owner == predecessor_account,
"ERR_NOT_OWNER"
);
require! est une macro légère introduite dans near-sdk-rs v4 (et c'est aussi sa macro préférée) pour remplacer assert! macro. Cela fonctionne comme assert! la plupart du temps, à une petite différence près : il ne peut pas spécifier de format ! per se.
// assert! can specify format
assert!(
some_conditions,
"{}: {}"
error_type,
error_message
);

// require! cannot
require!(
some_conditions,
format!( // you need format! yourself
"{}: {}",
error_type,
error_message
)
);
Et comme nous l'avons mentionné précédemment pour éviter le formatage des chaînes, il est préférable de coder le message en dur. Bien sûr, si vous en avez vraiment besoin, sacrifiez simplement quelques octets pour utiliser le format ! est ok: il ne prend qu'un espace négligeable si vous ne l'utilisez pas de manière intensive.

N'utilisez pas .expect()

Utilisez plutôt unwrap_or_else. L'un a écrit la fonction d'assistance dans la caisse d'assistance NEAR helper crate que vous voudrez peut-être consulter.

Sinon, vous pouvez toujours mettre ceci dans internal.rs :
fn expect_lightweight(option: Option, message: &str) -> T {
option.unwrap_or_else(||
env::panic_str(message)
)
}

// instead of:
let owner_id = self.owner_by_id
.get(&token_id)
.expect("Token not found");

// use this:
let owner_id = expect_lightweight(
self.owner_by_id.get(&token_id),
"Token not found"
);
Évitez Panicking
Voici quelques erreurs courantes dans les paniques :

 	Indexation d'une tranche hors limites. my_slice[i]
 	Division de zéro : dividend / 0
 	unwrap() : préférez utiliser unwrap_or ou unwrap_or_else ou d'autres méthodes plus sûres pour ne pas paniquer. Dans le near-sdk, il y a aussi env::panic_str (env::panic est obsolète) pour panic, et ils ont mentionné ici que cela pourrait être préféré. Cependant, vous pouvez également utiliser la correspondance à l'ancienne pour gérer les choses et voir si cela fonctionne mieux que panic_str ; sinon, utilisez panic_str pour une compréhension plus facile du code. Sinon, vous pouvez passer à match si cela en vaut la peine.

Essayez d'implémenter une solution de contournement pour qu'elle renvoie None ou n'imposez aucune panicking lors du développement du contrat.
Approches de niveau inférieur
Consultez le lien dans la référence pour d'autres moyens de réduire la taille du contrat non mentionnés ici. (Les éléments mentionnés ici ne sont également pour la plupart pas mentionnés ici).

Gardez à l'esprit que cet exemple n'est plus mis à jour, il vous oblige donc à dériver manuellement la dernière mise à jour.

La liste est ici :

 	Tiny Contract (obsolète)
 	Contrat de fuzzing rs (vous pouvez visualiser la branche master, il s'agit d'une branche fixe pour éviter qu'elle ne soit supprimée à l'avenir). On ne sait pas ce que fait ce contrat, ni ce que signifie « fuzzing » ; vous auriez besoin de vous comprendre.
 	L'exemple d'Eugene pour un jeton fongible rapide, et vous pouvez regarder la vidéo youtube ici. Il l'implémente sans utiliser le near-sdk. Une expérience de programmation plus malheureuse, mais qui optimise la taille.

Aurora utilise rjson comme crate de sérialisation JSON légère. Il a une empreinte plus petite que serde actuellement fourni avec Rust SDK. Voir cet exemple et le lecteur a besoin de déduire comment il s'utilise lui-même. Ajouter à considérer est miniserde crate, exemple ici
L'outil Wasm-snip
Il peut être utile de remplacer les fonctions non utilisées par des instructions inaccessibles. Habituellement, vous n'avez pas besoin de le faire : seulement si vous avez vraiment vraiment besoin d'économiser cet espace, vous pouvez continuer.

Ils ont mentionné que l'outil est également utile pour supprimer l'infrastructure en panicking !

Vous pouvez également exécuter wasm-opt avec l'indicateur –dce après la capture, afin que ces fonctions coupées soient supprimées.
Conclusion
Il existe de nombreuses façons d'optimiser un contrat. Certaines optimisations se font facilement sans aucun changement, d'autres ont des compromis et des trade-offs que vous déciderez si cela en vaut la peine ou non. En général, à moins que votre contrat ne soit extrêmement volumineux, ce qui résulte généralement de l'écriture d'un trop grand nombre de lignes de code et pour lesquelles vous êtes encouragé à vérifier la nécessité d'écrire du code ; sinon, une utilisation simple comme wasm-opt et un choix de stockage persistant devrait suffire.
Les références
Near SDK documentation on reducing contract size
Reducing Wasm size for Rust

### Las Mejores Prácticas Cripto: Consejos Para Una Experiencia Cripto Perfecta

El espacio de criptomonedas puede ser un tanto abrumador, incluso para las mentes más experimentadas. Mientras la cripto gana una popularidad más convencional, los riesgos hacia tus activos también incrementan exponencialmente. Los inversores en cripto están constantemente preocupados respecto a la seguridad de sus inversiones y sus activos. Mientras los cripto activos y criptomonedas están seguras por plataformas en las que son intercambiadas, inversores y usuarios de estos exchanges (plataforma de intercambio) necesitan ser más proactivos cuando aseguran sus activos digitales.

Es imperativo que los usuarios tengan una idea exhaustiva del espacio de criptomonedas antes de invertir en criptomonedas. Además es esencial tener una idea del panorama regulatorio en tu país para que sepas el estatus legal de las criptomonedas y cómo puedes de esa manera invertir. Siguiendo un conjunto de mejores prácticas es ideal para salvaguardar tus inversiones en criptomonedas y tengas una experiencia cripto perfecta.
Riesgos Potenciales Para Consumidores Cripto
La volatilidad es un riesgo que es considerado una parte integral del espacio cripto. Cualquier individuo que invierte en cripto está al tanto de la volatilidad en aspectos de criptomonedas. De todas formas, otros riesgos pueden significar una amenaza hacia los inversores en criptomonedas y sus inversiones. Algunos de estos riesgos son: 

 	Lavado de dinero
 	Estafas de inversiones mediante ICOs (Oferta Inicial de Moneda)
 	Estafas cripto Pump and Dump (Aumentar y Tirar abajo el precio)
 	Falsos exchanges cripto
 	Estafa Phishing (Suplantación de Identidad)

Aparte de los riesgos mencionados arriba, siempre está la amenaza latente de hackers. Los inversores siempre deberían estar alertas hacia la posibilidad de fraude, robo, pérdida de activos. Echemos un vistazo hacia algunas de las formas en las que los inversores pueden salvaguardar sus criptomonedas y asegurarse de que tengan una tranquila experiencia cripto.




	

	
	
		
			
				¿Cuál de las siguientes no es considerada una buena estrategia cuando se invierte en cripto?
			
		

		
					

		
			
			
			
			Estudiar y entender el panorama regulatorio en tu jurisdicción antes de invertir
		
			
			Comparar cuidadosamente exchanges de criptomonedas y controlar cual de ellos funciona mejor para ti
		
			
			Buscar el próximo Bitcoin o Ethereum
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Las Mejores Prácticas Para Asegurarse Una Experiencia Cripto Perfecta
Tus criptos pueden ser comprometidas mediante diferentes vías, como por ejemplo una billetera de criptomoneda comprometida, un exchange comprometido, o una seed phrase (frase de semilla) comprometida. Aquí tenemos unos simples pasos que te pueden ayudar en gran medida, asegurando que tengas una perfecta experiencia cripto. 
Siempre Utiliza Una Contraseña Fuerte
Cuando utilizas un exchange para intercambiar criptos, vas a requerir crear una cuenta. Es imperativo que asegures esta cuenta en la que intercambias cripto con una contraseña fuerte que consista de números y caracteres especiales. Una contraseña fuerte es la primera línea de defensa contra un grupo malicioso o hackers. Utilizar un administrador de contraseñas también ayuda, permitiéndote crear y recordar contraseñas complejas. Puedes utilizar administradores de contraseña tales como Dashlane para ayudarte a crear una contraseña segura. Además es imperativo cambiar tu  contraseña regularmente y utilizar un administrador de contraseña como mencionamos anteriormente, junto con un Two Factor Authentication (Authenticator de dos factores)




	

	
	
		
			
				¿Qué puede ser considerado un riesgo potencial hacia inversores cripto?
			
		

		
					

		
			
			
			
			Estafas de inversión mediante ICOs
		
			
			Estafas Pump and Dump
		
			
			Lavado de dinero
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Uso del 2FA (Two factor authentication)
Sumado a mantener una contraseña fuerte se debe implementar 2FA cuando se utilizan exchanges de criptomonedas. En vez de usar la autenticación mediante SMS, puedes utilizar aplicaciones tales como Google Authenticator o Authy. Idealmente, ayudaría si utilizas el 2FA más fuerte permitido por la plataforma. Hardware de llaves de seguridad tales como Yubikey son ideales, junto con aplicaciones como Google authenticator y Authy, las cuales han sido mencionadas anteriormente. Si no tienes opción y debes utilizar un 2FA basado en SMS, debes establecer un código de única vez que sea enviado hacia tu móvil cada vez que ingresas a tu cuenta de cripto trading (intercambio).
Salvaguarda Tus Llaves Privadas
Para guardar tus criptomonedas, vas a requerir de una billetera que sostenga tus llaves públicas y privadas para enviar, recibir y guardar criptomonedas. Mientras tu dirección pública tiene que ser compartida con otros usuarios, no debes compartir tus llaves privadas con ningún individuo o entidad. Si alguien gana acceso a tu llave privada, entonces podrías terminar perdiendo todos los fondos presentes en tu billetera. Lo mismo aplica a tus llaves privadas cuando se trata de tu blockchain (cadena de bloques) o cuenta de trading. Puedes asegurar tus llaves siguiendo unos pocos y simples pasos.

 	Utilizar una llave aleatoria o frase de contraseña
 	Mantener el control de tus llaves y no entregarlas a un exchange centralizado
 	Utilizar una hardware wallet (billetera hardware)

Utilizar Una Cold Wallet
Como nosotros sabemos, las billeteras de criptomonedas caen dentro de dos categorías, hot wallets (billeteras calientes) y cold wallets (billeteras frías). Las hot wallets ofrecen facilidad y simplicidad pero también vulnerabilidad significativa. Mientras tienes fácil acceso hacia tus criptomonedas, también son vulnerables a amenazas de seguridad tales como hackeo. Una cold wallet es lo que la mayor cantidad de expertos en cripto recomiendan, especialmente si intentas mantener tus criptomonedas por una cantidad significativa de tiempo. Una cold wallet es esencialmente una wallet fuera de línea, lo que significa que tus activos que tus activos están siendo guardados fuera de línea, asegurando tus activos de intentos de hackeo. Cold wallets aseguran completa seguridad de amenazas con las que usualmente tendrías que lidiar cuando utilizas una hot wallet. Ejemplos de cold wallets son hardware wallets y paper wallets (billeteras de papel).
Adopta Un Acercamiento Híbrido
Adoptar un acercamiento híbrido implica utilizar ambas, hot wallets y cold wallets. Cuanto se utiliza este acercamiento, puedes guardar criptomonedas fuera de línea cuando no son intercambiadas. De todas formas, cuando ejecutas un intercambio, puedes simplemente transferir los activos que intentas vender hacia tu hot wallet, completar el intercambio, y luego transferir los activos de nuevo hacia tu cold wallet.
Utilizar Un VPN
Es extremadamente importante utilizar una conexión de internet segura cuando accedes a tu cuenta de trading de criptomonedas y realizas transacciones cripto. Nunca intentes llevar a cabo un intercambio en una red de WiFi pública, e incluso cuando utilizas la red de tu hogar, el uso de VPN es recomendado para seguridad adicional. Utilizar un VPN va a ayudar a mantener a salvo tu actividad de navegación de potenciales hackers o agentes maliciosos. Además es importante asegurar tu dispositivo personal, el cual vas a estar utilizando para realizar transacciones. Siempre mantén tu dispositivo al día, y asegúrate de no terminar clickeando en algún link malicioso o visitar algún sitio web malicioso.
No Pongas Todos Tus Huevos En Una Sola Canasta
Justo como el mercado de acciones tradicional, la diversificación es clave en el mercado cripto. Como inversor, diversificar es siempre saludable para tu portafolio cripto. En vez de poner todo tu dinero en, digamos BTC, invertir en una combinación de BTC, ETH, y un puñado de otras criptomonedas podría ayudar a protegerte de una potencial volatilidad de mercado mientras también te permite beneficiarte de múltiples fuentes cuando el mercado está en un bull run (mercado alcista).
La Debida Diligencia Es Clave
Antes de invertir en una criptomoneda, es importante entender el activo subyacente, sus usos, y cómo funciona. Casi toda moneda tiene sus whitepapers (información de proyecto) disponibles en línea, lo cual puede ayudar a que entiendas mejor la moneda y mejores tu conocimiento sobre el potencial de dicha moneda. Si no hay whitepaper disponible o si el whitepaper no menciona o describe el funcionamiento de la moneda, entonces es mejor evadir la moneda en cuestión.
La Sincronización También Es Clave
Justo como la debida diligencia, la sincronización también es considerada un factor clave cuando se trata de invertir en el mercado cripto. Si piensas que sabes lo que se necesita saber respecto a cripto, entonces también debes ser capaz de sincronizar tu inversión perfectamente. El mercado de las criptomonedas es volátil y las oscilaciones de precios son comunes. No vayas por ahí invirtiendo en nuevas monedas buscando el próximo Bitcoin o el siguiente Ethereum. Siempre sé detallista sobre el proyecto antes de invertir, sigue los patrones de precio, y mantente al tanto de las noticias para seguir por delante de los eventos que puedan impactar negativamente el valor de tu inversión (hackeo en exchange, manipulación de precio). Las criptomonedas son altamente especulativas, entonces siempre haz tu tarea antes de saltar hacia el espacio.
Chequea Doblemente Todos Los Detalles de Transacción
Recuerda, las transacciones blockchain son inmutables, lo que significa que una vez que son ejecutadas, no pueden ser revertidas. Esto hace que sea extremadamente importante chequear el doble todos los detalles de la transacción antes de proseguir con la transacción. Tus fondos solamente pueden ser revertidos si la contraparte accede a ello.
No Inviertas Más De Lo Que No Puedes Afrontar Perder
Este es uno de los puntos más críticos que debes tener en mente como inversor. Mientras las criptomonedas pueden ser consideradas un resguardo de valor, y si, lo son para países con ciudadanos tales como Venezuela, que están tambaleándose con hiperinflación. Pero las criptomonedas son una inversión de alto riesgo con una volatilidad significativa. Lo que era rentable a la mañana puede convertirse en rojo hacia la tarde. Si eres un principiante, siempre es recomendable empezar invirtiendo bajas cantidades de dinero.
En Conclusión
Las criptomonedas son de cierta forma una inversión riesgosa para principiantes y también para personas experimentadas. Como regla de oro, inversiones de alto riesgo deberían conformar solamente una pequeña porción de tu portafolio. En el caso de las criptomonedas, siempre está bien diversificar tus inversiones en diferentes monedas para que tus inversiones puedan apreciarse o depreciarse en diversos grados, aislandote hasta cierto punto.

Los puntos mencionados anteriormente son generalmente considerados como las técnicas más básicas que puedes emplear para asegurarte una experiencia cripto perfecta. El espacio está en constante fluidez, y debes ser proactivo en asegurar la seguridad de tus inversiones y fondos mediante asegurar tus cuentas y billeteras detalladamente. Siempre debes mantenerte actualizado con las últimas noticias y desarrollos en el espacio cripto.




	

	
	
		
			
				Utilizar una contraseña fuerte, 2FA, cold wallet y un VPN cuando se realizan transacciones son consideradas partes de las mejores prácticas en cripto
			
		

		
					

		
			
			
			
			Verdadero
		
			
			Falso
		
	
		

		
		
			
				Correct!
				Wrong!

### Mercados NFT en NEAR

Con el crecimiento de la tecnología blockchain, hemos visto varios casos de uso nuevos que están impulsando la adopción de blockchain, ayudándola a pasar a la corriente principal. En 2021, vimos el auge de las NFT como un nuevo caso de uso de la tecnología blockchain. Los NFT llamaron la atención del espacio blockchain, lo que resultó en su creciente popularidad a medida que los usuarios se apresuraban a tenerlos en sus manos. Podemos medir su popularidad con la venta de una colección de arte NFT de Beeple que se vendió por la asombrosa cantidad de $69 millones.

Con el asombroso éxito de los NFT, hemos visto a varios artistas, músicos y otros creadores sumergirse en los NFT. Hemos visto a artistas como Grimes y bandas como The Rolling Stones y Kings of Leon subirse al carro de NFT vendiendo versiones tokenizadas de sus canciones, carátulas de álbumes y productos digitales y virtuales. Con tanta atención en ellos, los NFT son un tema muy popular, y es esencial comprenderlos y cómo puede comprarlos o venderlos a través de un mercado NFT como el mercado NFT de NEAR. Pero primero, debemos entender la definición de un NFT.
¿Qué es un NFT?
Un NFT se puede describir como un activo digital único que tiene su información de identificación almacenada en contratos inteligentes. Esta es la información que hace que cada NFT sea único. Debido a que cada NFT es único, no se pueden intercambiar entre sí como elementos fungibles como moneda fiduciaria o incluso BTC. Los NFT también son indivisibles, a diferencia de los artículos fungibles, que pueden dividirse en activos o cantidades más pequeñas y luego enviarse a otros. Por ejemplo, no puedes vender la mitad de un cuadro o la mitad de un billete de tren a nadie. La misma lógica se aplica a un NFT, con cada NFT único que contiene un conjunto único de datos que no se pueden dividir ni intercambiar.

Los NFT se basan en dos tipos de estándares de token en la cadena de bloques de Ethereum, el estándar de token ERC-721 y el estándar de token ERC-1155. Ambos estándares de token garantizan que el activo en cuestión actuará de cierta manera, lo que permite a los desarrolladores implementar fácilmente sus NFT utilizando estos estándares de token y, al mismo tiempo, garantizar la compatibilidad con los servicios y el ecosistema criptográfico. Sin embargo, varias otras cadenas de bloques, como EOS, NEAR y Tron, ahora han lanzado sus propios estándares de token para atraer a los desarrolladores a crear NFTs en sus plataformas.
Historia de los NFTs
Ya hemos discutido lo que es un NFT arriba. Sin embargo, ¿de dónde se originaron los NFT? El primer NFT minteado (acuñado) se remonta a 2014, cuando Kevin McCoy minteó el primer NFT titulado "Quantum" el 3 de mayo de 2014, mucho antes de la explosión de los NFT y el espacio del criptoarte. El Quantum NFT se puede describir como una imagen pixelada, que consiste en un octágono lleno de círculos, arcos y otras formas. Todas las formas comparten el mismo centro, con las formas más grandes rodeando a las más pequeñas.

Profundizando en la historia, los NFT fueron impulsados por fenómenos culturales como CryptoPunks y CryptoKitties. Sin embargo, la historia va mucho más allá de estos. En 2012, vimos el surgimiento de "monedas de colores", a las que se les puede atribuir la idea de los NFT. Estas monedas de colores se emitieron inicialmente en la cadena de bloques de Bitcoin. Luego, en 2014, surgió Counterparty, creada en la cadena de bloques de Bitcoin y que permite la creación de activos. En 2016 vimos el surgimiento de Rare Pepes y, poco después, CryptoPunks, lo que condujo al boom de los NFT, impulsando a los NFTs a la corriente principal y capturando la imaginación del público en general.




	

	
	
		
			
				¿Cúal de las siguientes afirmaciones acerca de los NFTs es verdadera?
			
		

		
					

		
			
			
			
			Un NFT es un activo digital único que tiene su información de identificación almacenada en contratos inteligentes
		
			
			Un NFT es un activo que es divisible y se puede dividir y compartir o distribuir a otras personas
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Qué es un Mercado NFT?
Así como necesitas un mercado para comprar la mayoría de los artículos, tanto en el mundo real como en el digital, un mercado de NFT permite a los usuarios comprar, vender, intercambiar, exhibir o mintear (acuñar - crear) sus propios NFT. Piensa en un mercado de NFT como un eBay o un Amazon, pero exclusivamente para NFTs. Prácticamente cualquiera puede usar un mercado NFT, pero para acceder a estos mercados, un usuario requiere lo siguiente

 	Una cuenta de usuario en el mercado de NFT que le permitirá comprar el NFT desde una plataforma en particular.
 	Una billetera cripto que sea compatible con la cadena de bloques en la que pretende comprar los NFT. Por ejemplo, si planea usar la cadena de bloques Ethereum para comprar o vender sus NFT, necesitará una billetera compatible como MetaMask. Si planea usar Solana, necesitará una billetera compatible con Solana, como Sollet.

Los mercados de NFTs son cruciales porque unen a compradores y vendedores y ofrecen a los usuarios una serie de herramientas que les permiten crear sus propios NFT en cuestión de minutos. Los artistas pueden usar el mercado para poner a la venta sus NFT, y los compradores pueden navegar por el mercado y comprar el artículo a través de un proceso de subasta.
Mercados NFT Populares
Hay varios mercados de NFT entre los que puede elegir según lo que tú requieras. Los mercados universales de NFT son extremadamente populares, mientras que existen otros mercados de nicho para NFT específicos que podrían consistir en tarjetas coleccionables, mundos digitales terrestres virtuales como Decentraland, o incluso ciertos artículos y coleccionables del juego. Algunos de los mercados NFT más populares son:

 	OpenSea
 	SuperRare
 	Rarible 
 	Mintable
 	Nifty Gateway 

Cómo el ascenso de OpenSea impulsó los NFTs 
OpenSea se ha establecido como líder y es el mercado de NFT más grande, que aloja y brinda soporte para todo tipo de activos digitales. El mercado se utilizó inicialmente como mercado para el popular juego CryptoKitties. Sin embargo, desde entonces se ha expandido mucho más allá de los coleccionables y es un mercado para varios activos como música, activos en juegos y coleccionables, coleccionables digitales, arte, etc. OpenSea es responsable de impulsar el crecimiento de los NFTs y de los proyectos NFT como CryptoKitties, CryptoPunks, Ethermon y otros, todos los cuales se lanzaron en 2017, el mismo año que OpenSea, lo que llevó al mercado a liderar la carga de NFT en la corriente principal.




	

	
	
		
			
				¿Cuáles son los estándares de tokens usados por los NFTs?
			
		

		
					

		
			
			
			
			ERC-721 y ERC-1155
		
			
			ERC-20
		
			
			ERC-725
		
			
			Todos los anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El Protocolo NEAR
El Protocolo NEAR se fundó en 2018 y es una plataforma de desarrollo descentralizada que crea un entorno perfecto para contratos inteligentes y aplicaciones descentralizadas. NEAR se enfoca en las deficiencias de otros protocolos en el mismo espacio, como Ethereum, NEAR rivaliza fácilmente con las capacidades de la plataforma número uno para finanzas descentralizadas y aplicaciones descentralizadas. NEAR aborda una de las deficiencias más evidentes de Ethereum, la escalabilidad. Lo hace a través de un proceso llamado "sharding" (Fragmentación). La fragmentación permite que el protocolo NEAR se amplíe exponencialmente.

NEAR utiliza una cadena de bloques de prueba de participación que usa fragmentación y es fácil de usar para desarrolladores. NEAR es de bajo costo y altamente escalable, lo que permite a los desarrolladores crear fácilmente aplicaciones descentralizadas. NEAR también presenta Doomslug, que permite que los bloques alcancen la finalidad en cuestión de segundos. El protocolo utiliza la misma tecnología que Bitcoin, combinándola con otras funciones como la fragmentación. El protocolo NEAR se escala linealmente, lo que le permite admitir miles de millones de transacciones de manera descentralizada.

 

NEAR también consta de varias plataformas NFT únicas mientras que más y más proyectos eligen el protocolo NEAR para lanzar sus proyectos. La colaboración de NEAR con Ed Young hizo que la plataforma lanzará retratos de figuras icónicas de la historia del hip-hop. La plataforma Arterra de NEAR permite la participación de los fanáticos para personas influyentes, equipos deportivos y transmisores, lo que les permite recopilar NFT de sus creadores favoritos. Otro proyecto en NEAR es Pixelparty, que consta de 600 fichas, cada una de las cuales representa una subtrama de una trama de Pixelparty. Otro proyecto de NEAR es Metamon, que permite a los usuarios coleccionar monstruos basados en NFT. Los usuarios también pueden combinar dos monstruos, convirtiéndolos en NFT más poderosos y raros.

NEAR permite a los usuarios acceder a varios protocolos que van desde DAO, DeFi y NFT, con un ecosistema vibrante que tiene varios proyectos en funcionamiento. Debido a que nuestro enfoque está en los mercados de NFT, analizaremos los proyectos de NFT en el protocolo NEAR, llamados Paras, Mintbase y TenK.
Mintbase 


Fuente: NEAR

Creado por Nate Geier y Caroline Wend en 2018, Mintbase permite a los usuarios crear y vender NFTs en NEAR. Estos NFT pueden ser cualquier cosa, desde arte criptográfico hasta activos digitales y todo lo demás. Cualquier persona con acceso a Internet puede crear un NFT en Mintbase y venderlo en el mercado NFT de NEAR o venderlo en otros mercados como OpenSea u otros mercados. Mintbase permite a los creadores realizar contratos inteligentes, lo que limita la transferibilidad de los tokens acuñados. Esto ayuda a reducir significativamente el fraude o la transferencia ilegal de NFT.

Mintbase hizo el cambio de Ethereum a NEAR gracias a las altas tarifas de gas en el primero. Las tarifas de gas se volvieron tan altas que Mintbase tuvo que pedirles a los usuarios que esperaran a que los precios de la gas bajaran antes de abrir una tienda. Con tarifas de gas significativamente más bajas, NEAR fue y sigue siendo la plataforma perfecta para Mintbase. El protocolo puede lograr tarifas de gas más bajas debido a un modelo eficiente de ejecución de contratos. NEAR también utiliza un enfoque dinámico para la fragmentación llamado Nightshade, lo que le otorga una ventaja considerable sobre otras plataformas como Ethereum.
Paras

Fuente: NEAR

Paras es un mercado de tarjetas de arte digital creado en el protocolo NEAR. Este mercado es diferente de otros mercados porque ofrece exclusivamente colecciones en lugar de lanzamientos individuales. Paras se inspira en los cromos del mundo real, con sus NFT similares a los de las colecciones de cromos deportivos y otros cromos de franquicias populares como Pokémon. A diferencia de otros mercados, especialmente aquellos en Ethereum que permiten a los usuarios cargar prácticamente cualquier cosa, Paras adopta un enfoque más medido con respecto a los NFT.

Para crear en Paras, los artistas deben presentar una solicitud, con solo 30 artistas aprobados cada semana. Las obras de arte creadas por los artistas deben cumplir con la relación de aspecto de Paras de 64:89 y, al mismo tiempo, contener información específica relacionada con la obra de arte. Paras eligió NEAR porque ofrecía velocidades de transacción rápidas y tarifas de transacción bajas. Otro factor importante por el que Paras eligió NEAR fue por el Rainbow Bridge, que permite la transferencia de ETH a NEAR, lo que permite la compra sin problemas de NFT.

Recientemente, Paras lanzó Boom Boom, una serie de mini-cómics creada exclusivamente para el ecosistema NEAR. El protocolo también lanzó su primer cómic, Paradigm, con los primeros tres números disponibles de forma gratuita, mientras que los lanzamientos posteriores tendrán un precio de $0.3 NEAR por número.
TenK 


Fuente: Twitter

Mintbase y Paras se consideran las plataformas NFT más destacadas disponibles en el protocolo NEAR. Sin embargo, hay un tercer proyecto disponible en NEAR, llamado TenK. TenK se puede describir como una plataforma de arte generativo de código abierto que trae una gran cantidad de obras de arte NFT al protocolo NEAR. El protocolo ya está lanzando varios proyectos destacados en NEAR. TenK es el protocolo detrás de NEAR Misfits, que se lanzó en 2021. NEAR Misfits es la primera colección de imágenes de perfil criptográficamente completa basada en el protocolo NEAR.
Pensamientos finales
El Protocolo NEAR ha hecho que la acuñación de NFTs y los mercados de NFTs sean mucho más fáciles que Ethereum, lo que le permite convertirse en uno de los protocolos más prometedores y buscados en el espacio cripto. NEAR se enfrenta a Ethereum de frente, brindando soluciones para problemas muy grandes como la falta de escalabilidad, transacciones lentas y velocidades de procesamiento, y tarifas de gas extremadamente altas. NEAR se ha convertido en una alternativa exitosa a Ethereum, con nuevos proyectos que acuden en masa al protocolo y otros que cambian de Ethereum a NEAR. Otros proyectos como Paras y TenK ya operan en NEAR.




	

	
	
		
			
				¿Qué deficiencias de Ethereum aborda NEAR?
			
		

		
					

		
			
			
			
			Altas comisiones
		
			
			Escalabilidad
		
			
			Transacciones lentas
		
			
			Todas las de arriba
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Live Обзор контрактов | Часть 2: Контракт пула ставок

Введение
Это вторая часть серии обзоров контрактов и сегодня мы собираемся рассмотреть контракт пула ставок. Он используется для защиты системы подтверждения NEAR Protocol. В основном все валидаторы, которые в настоящее время работают на протоколе NEAR, работают от имени этого контракта. Они сами не контролируют учетную запись, которая размещает количество токенов NEAR, необходимое для доказательства доли, но вместо этого контракт ставит эту сумму, и они просто предоставляют пул ставок и запускают свои ноды. Сегодня мы будем разбирать этот  контракт. В основных контрактах у нас есть: контракт на пул ставок, и он немного сложнее, чем предыдущий контракт, который мы рассмотрели (контракт на голосование). Мы больше сосредоточимся на логике, а не на close_bindgen и специфичных для Rust материалах, но, вероятно, потребуется немного больше знаний о протоколе NEAR. Вот контракт пула ставок на NEAR Github. Ниже представлено оригинальное видео, на котором основано это руководство.


lib.rs
Структура


Как и прежде, контракт начинается с основной структуры. В данном случае это контракт структуры ставок. Как видите, есть Near_bindgen, BorshSerialize и BorshDeserialize. В структуре теперь намного больше полей, чем в прошлой, и к ним есть некоторые комментарии. Большинство из них, вероятно, уже обновлены. Логика контракта пула ставок позволяет нам сделать следующее: практически любой может внести некоторое количество токенов NEAR в пул ставок разместив их в пуле. Это позволяет нам объединять балансы нескольких людей (здесь мы называем их учетными записями) в одну крупную долю.  Таким образом это большое количество может претендовать на места валидатора. NEAR Protocol сейчас имеет ограниченное количество мест для одного шарда, максимум 100 мест для валидаторов. Вы можете рассмотреть места следующим образом: если вы возьмете общее количество поставленных токенов и разделите его на 100, результатом будет минимальное количество токенов, необходимое для одного места, за исключением того, что удаление немного сложнее. Ставки, которые не соответствуют этой минимальной сумме, и т. д. Этот контракт в основном является автономным контрактом без какого-либо ключа доступа, который контролируется владельцем. В этом случае владелец указывается в методе инициализации.
Метод инициализации


Итак, давайте перейдем к методу инициализации. Он имеет три аргумента,  первый — это owner_id, который является идентификатором учетной записи владельца. У владельца есть множество разрешений на этот контракт, которые позволяют контракту выполнять действия, недоступные для остальных учетных записей. Одним из таких методов было голосование от имени пула ставок по контракту на голосование, который мы обсуждали в прошлый раз. Таким образом, владелец может вызвать метод голосования.





Затем мы проверяем, что предшественник равен владельцу, поскольку этот метод может быть вызван только владельцем.



Итак, что делает метод голосования, он проверяет, что метод был вызван только владельцем, а затем проверяет некоторую логику, но сейчас логика нас не интересует.



Итак, контракт является владельцем, и этот владелец может делать определенные вещи, у него есть дополнительные разрешения. Затем он занимает еще несколько полей: он принимает stake_public_key. Когда вы делаете ставку на протокол NEAR, вам необходимо предоставить открытый ключ, который будет использоваться вашим узлом валидатора для подписи сообщений от имени узла валидатора. Этот открытый ключ может отличаться от любого ключа доступа, и в идеале он должен отличаться от любого ключа доступа, потому что ваш узел может работать в центре обработки данных, который может быть уязвим для некоторых атак. В этом случае максимум, что могут сделать злоумышленники, это навредить сети, но не вашей учетной записи. Они не могут украсть ваши средства, и вы можете легко заменить этот ключ на другой ключ доступа. Наконец, третий аргумент, который принимает контракт, — это reward_fee_fraction. Это комиссия, которую берет владелец стейкинг-пула за запуск узла валидатора.



Это дробь, у которой есть числитель и знаменатель, и она позволяет вам сказать: «Я получаю 1% вознаграждения за управление этим конкретным пулом». Допустим, у вас есть 1 000 000 токенов, они получили какое-то вознаграждение, есть вознаграждение в 10 000 токенов, тогда владелец возьмет 1% из этого, что составляет 100 токенов. Плавающие запятые ведут себя непредсказуемо, когда вы их умножаете. Например, с дробями вы можете использовать математику с большим количеством битов. Например, вы выполняете деление, сначала умножаете сумму, которая равна u128, на числитель (это уже может переполниться в u128), поэтому мы делаем это в u256. Затем вы делите его на знаменатель, который снова должен стать ниже u128. Это дает вам более высокую точность, чем float64, который не может работать с точностью до 128 бит, поэтому у него будут ошибки округления или ошибки точности при выполнении операций. Это означает, что  вам нужны более точные числа с плавающей запятой, которые на самом деле не отличаются от математики, где мы моделируем это с помощью u256. Изначально Solidity не поддерживала числа с плавающей запятой, и мы тоже изначально не поддерживали, но это создавало некоторые проблемы с форматированием строк в Rust для отладки, поэтому мы решили, что нет ничего плохого в поддержке чисел с плавающей запятой, тем более что мы сделали это на стороне виртуальной машины. Самой большой проблемой с плавающей запятой было неопределенное поведение при определенных значениях нагрузки. Например, какие другие биты содержат ее, когда у вас есть бесконечное число с плавающей запятой. Мы стандартизировали это, и теперь они эквивалентны независимым платформам. Итак, теперь можно использовать float в нашей виртуальной среде.



Стандартная практика с init заключается в том, что мы сначала проверяем, что состояние не существует. Затем мы проверяем ввод. Первое, что мы делаем, это проверяем правильность дроби и проверяем, что знаменатель не равен нулю. Далее у нас есть оператор else, который проверяет, что числитель меньше или равен знаменателю, что означает, что дробь меньше или равна 1. Это важно, чтобы избежать некоторых логических ошибок. Следующее, что мы делаем, это проверяем, что учетная запись действительна. Этот контракт был написан до появления некоторых вспомогательных метрик, которые существуют сейчас. Например, у нас есть действительный идентификатор учетной записи в типах JSON, который делает эту проверку автоматически во время десериализации, если он недействителен, он просто паникует. После этого подтягиваем текущий баланс счета стейкинг-контракта. Этот баланс обычно достаточно велик, потому что он должен платить за хранение этого конкретного контракта, и тогда мы говорим, что собираемся выделить несколько токенов для STAKE_SHARE_PRICE_GUARANTEE_FUND. Пул ставок имеет определенные гарантии, которые важны для локальных контрактов. Это  гарантирует, что когда вы вносите депозит в пул ставок, вы должны иметь возможность вывести по крайней мере такое же количество токенов, и вы не можете потерять токены даже на 1 000 000 000 000 лет до NEAR по этому контракту, внося и выводя из пулы ставок. Фонд STAKE_SHARE_PRICE_GUARANTEE_FUND составляет около 1 триллиона NEAR в год, в то время как мы обычно потребляем около 1 или 2 триллиона NEAR в год на ошибки округления. Наконец, мы помним, каков баланс, который мы собираемся поставить от имени этого контракта. Это необходимо для установления некоторого базового уровня, чтобы ограничить разницу в округлении. Затем мы проверяем, что учетная запись еще не застейкана. Это может нарушить некоторую логику. Мы не хотим, чтобы это произошло, поэтому мы хотим инициализировать контракт до того, как он что-либо поставит. Наконец, мы инициализируем структуру, но не возвращаем ее сразу. Мы только что создали здесь структуру :StakingContract.



Затем мы оформляем транзакцию рестейкинга. Это важно, потому что нам нужно убедиться, что предоставленный ключ для ставок является действительным ключом с ограниченным доступом для ристретто, например, действительным ключом 5 119. На кривой есть некоторые ключи, которые являются действительными ключами, но не специфичны для ристретто, а ключи валидатора могут быть специфичны только для ристретто. Это специфика протокола NEAR, и происходит то, что он выполняет транзакцию стейкинга с заданным ключом. Как только эта транзакция создана из контракта, мы проверяем эту транзакцию, когда она уходит. Если ключ недействителен, то он выдаст ошибку, и вся инициализация этого пула ставок завершится ошибкой. Если вы передадите недействительный стейк_публичный_ключ в качестве входных данных, ваша консолидация и развертывание контракта, а также все, что происходит в этой одной пакетной транзакции, будет отменено. Это важно, чтобы у пула не было недействительного ключа, потому что это может позволить вам заблокировать долю других людей. В качестве гарантии мы говорим, что если вы отмените ставку, ваши токены будут возвращены через 4 эпохи. Они будут иметь право на вывод, и это важно, чтобы иметь возможность вернуть их в изоляцию.



Я думаю, что это слишком много моментов, прежде чем я объясню общий обзор того, как работают контракты и как работают балансы. Давайте объясним концепцию того, как мы на самом деле можем распределять вознаграждения между владельцами учетных записей в постоянное время. Это важно для большинства смарт-контрактов. Они хотят действовать за постоянное время для каждого метода, а не за линейное время для количества пользователей, потому что, если количество пользователей будет расти, то количество газа, необходимое для работы линейной шкалы, также будет расти, и в конечном итоге оно иссякнет.  Вот почему все смарт-контракты должны действовать в постоянное  время.
Структура аккаунта


Как это работает для каждого пользователя, мы сохраняем структуру, называемую учетной записью. Каждый пользователь, делегированный в этот пул ставок, будет иметь структуру, называемую учетной записью, со следующими полями: unstaked — это баланс в yocto NEAR, который не поставлен, поэтому это просто баланс пользователя. Тогда доля_количества на самом деле является балансом, но не в ПОЧТИ, а в количестве долей доли. Stake_shares — это концепция, которая была добавлена ​​к этому конкретному пулу ставок. Это работает следующим образом: когда вы делаете ставку, вы, по сути, покупаете новые акции по текущей цене, конвертируя свой баланс без ставки в доли доли. Цена доли ставки изначально равна 1, но со временем она растет вместе с вознаграждениями, и когда учетная запись получает вознаграждения, ее общий баланс ставки увеличивается, но количество общих долей ставки не меняется. По сути, когда учетная запись получает вознаграждение за проверку или какие-либо другие депозиты прямо на баланс, это увеличивает сумму, которую вы можете получить за каждую долю ставки. Предположим, например, что у вас изначально был 1 миллион NEAR, который был внесен на этот счет. Допустим, вы получаете 1 миллион акций (пока игнорируя yocto NEAR), если пул ставок получил 10 000 NEAR в качестве вознаграждения, у вас все еще есть 1 миллион акций, но теперь 1 миллион акций соответствует 1 010 000 NEAR. Теперь, если кто-то еще захочет сделать ставку в это время, он купит акции внутри компании в рамках контракта по цене 1,001 NEAR, потому что сейчас каждая акция стоит этого. Когда вы получаете очередное вознаграждение, вам не нужно покупать больше акций, несмотря на общий баланс, и в постоянное время каждый делится вознаграждением пропорционально количеству имеющихся у него акций. Теперь, когда вы отменяете стейкинг, вы, по сути, продаете эти акции или сжигаете их, используя концепцию взаимозаменяемых токенов в пользу незанятого баланса. Таким образом, вы продаете по текущей цене, вы уменьшаете общую сумму ставки, а также общее количество акций, а при покупке вы увеличиваете общий баланс ставки и общее количество акций, сохраняя при этом цену неизменной. Когда вы делаете ставку или снимаете ставку, вы не меняете цену, когда вы получаете вознаграждение, вы увеличиваете цену.



Цена может только расти, и это может привести к ошибкам округления, когда ваш yocto NEAR и ваш баланс не могут точно совпадать. Вот почему у нас есть этот гарантийный фонд в размере 1 триллиона NEAR, который несколько раз добавит один дополнительный Yocta NEAR. Наконец, заключительная часть, потому что протокол NEAR не отменяет ставку и не возвращает баланс немедленно, он должен ждать три эпохи, пока ваш баланс не будет разблокирован и возвращен на счет. Если вы отмените ставку, вы не сможете немедленно вывести этот баланс из пула ставок, вам нужно подождать три эпохи. Затем вы помните, на какой высоте эпохи вы вызывали последнее действие отмены ставок, и через три эпохи ваш баланс станет разблокированным, и вы сможете выйти из неразмещенных ставок. Однако есть одно предостережение: если вы вызываете отмену ставок в последнем блоке эпохи, фактическое обещание, которое делает отмену ставок, будет получено для следующей эпохи. Он прибудет в первый блок следующей эпохи, и это задержит разблокировку вашего заблокированного баланса до четырех эпох вместо трех. Это потому, что мы записали эпоху в предыдущем блоке, но фактическая транзакция произошла в следующем блоке, в следующей эпохе. Чтобы этого не произошло, мы фиксируем баланс на четыре эпохи вместо трех, чтобы учесть этот пограничный случай. Вот что представляет собой учетная запись. Идея акций не нова, потому что в Ethereum большинство поставщиков ликвидности и автоматизированных маркет-мейкеров используют аналогичную концепцию. Когда вы, например, вносите депозит в пул ликвидности, вы получаете какой-то токен из этого пула вместо фактической суммы, которая там представлена. Когда вы выходите из пула ликвидности, вы сжигаете этот токен и получаете фактически представленные токены. Идея очень похожа на то, чтобы называть их акциями, потому что они имеют соответствующую цену, и мы могли бы назвать их по-другому. Это было почти с самого начала этого контракта с пулом ставок. Мы исследовали, как мы можем сделать это должным образом, и один из способов заключался в том, чтобы ограничить количество учетных записей, которые могут вносить депозиты в определенную учетную запись пула для этого конкретного обновления. В конце концов мы остановились на постоянном времени сложности, и на самом деле это была более простая модель. Затем математика структуры доли_долей стала более или менее разумной, даже несмотря на то, что здесь тоже есть некоторые моменты.
Типы контрактов
Давайте пройдемся по этому контракту. Например, он не так хорошо структурирован, как договор блокировки, потому что блокировка еще сложнее. Типы по-прежнему связаны в одном контракте. Есть большое количество  типов типов, например,  вознаграждение_платы_фракция — это отдельный тип.



Учетная запись — это отдельный тип, а также существует удобочитаемая учетная запись, которая также является типом, который используется только для вызовов просмотра, поэтому он не используется для внутренней логики.



Затем, после того как мы закончим со всеми типами, у нас будут межконтрактные вызовы с использованием высокоуровневого интерфейса.



Это работает следующим образом: у вас есть макрос из near_bindgen, который называется ext_contract (внешний контракт). Вы можете дать ему короткое имя, которое он сгенерирует, и которое вы сможете использовать. Затем у вас есть описание признака, описывающее интерфейс внешнего контракта, который вы хотите использовать. Это описывает тот факт, что вы можете вызвать метод голосования на удаленном контракте и передать один аргумент. Аргумент is_vote, который является истинным или ложным логическим значением. Теперь вы сможете создать промис, когда вам это нужно, и передать позиционный аргумент вместо сериализованного аргумента JSON. Макрос превратит его в низкоуровневый API обещаний за кулисами. Второй интерфейс предназначен для обратного вызова самого себя, это довольно распространено, вы можете назвать его ext_self. Когда вам нужно сделать обратный вызов и что-то сделать с результатом асинхронного обещания, вы можете использовать этот тип интерфейса. Что мы делаем, так это проверяем, удалось ли стейкинг. Наконец, у нас есть тело реализации основной структуры реализации пула ставок. 
Структура файла контракта
Этот контракт разделен на несколько модулей.



У вас есть libs.rs, который является основным входом, и у вас также есть внутренний модуль. Внутренний модуль имеет реализацию без макроса near_bindgen, поэтому ни один из этих методов не будет виден для вызова по контракту кем-то еще в цепочке. Их можно вызывать только внутри этого контракта, чтобы они не генерировали форматы JSON и не десериализовали состояние. Все они действуют как обычные методы борьбы с ржавчиной. Как этот контракт работает на высоком уровне, так это то, что по прошествии эпохи вы можете получить определенные награды в качестве валидатора.
Важные методы в контракте


У нас есть метод ping, который пингует контракт. Метод ping проверяет, прошла ли эпоха, а затем нам нужно распределить награды. Если эпоха изменилась, то она также будет изменена, потому что может быть некоторое изменение в сумме общей ставки, которую должен поставить контракт. Далее депозит.



Метод депозита является платным, что означает, что он может принимать прикрепленный депозит. Это похоже на декоратор Ethereum, который позволяет получать средства только теми способами, которые их ожидают. Так Near_bindgen по умолчанию будет паниковать, если вы попытаетесь вызвать метод, например ping, и привязать к этому методу депозит. Следовательно, кредиторская задолженность позволяет нам прикреплять депозиты. В каждом методе есть внутренний пинг, чтобы убедиться, что мы распределили предыдущие награды, прежде чем менять какую-либо логику. Общая структура такова, что если нам нужно перестейкать, то мы сначала делаем какую-то логику, а потом перестейкаем.



Следующий метод — deposit_and_stake. Это комбинация двух методов. Во-первых, вы вносите остаток на баланс своей учетной записи, и вы также хотите поставить ту же сумму сразу, а не совершать две транзакции. Это также платно, потому что он также принимает депозит.



Следующий — remove_all. Он пытается вывести весь незанятый баланс со счета, который его вызвал. Когда вы взаимодействуете с пулом ставок, вам необходимо взаимодействовать с учетной записью, которой принадлежит баланс. В данном случае это предшественник_аккаунт_ид, и мы в основном проверяем учетную запись, а затем, если можем, снимаем не поставленную сумму. Если не отозвать, то паникует. Например, если он все еще заблокирован из-за отмены ставок менее 4 эпох назад.



Вывод позволяет вывести только часть баланса.



Затем все незанятые балансы ставятся на стейк_колл, и этот метод используется довольно редко, потому что вы обычно используете депозитную ставку, а в ней уже есть весь баланс ставки.



Затем в методе ставки вы просто ставите некоторую сумму баланса ставки. Кошелек Moonlight использует отдельную плату для внесения ставки, но для этого они используют пакетную транзакцию.



Наконец, у вас есть unstake_all, который в основном снимает все ваши доли, конвертируя их в yocto NEAR. Существует вспомогательный метод, который предлагает преобразовать количество моих акций в сумму yocto NEAR и округлить в меньшую сторону, потому что мы не можем дать вам дополнительную сумму за вашу акцию, умноженную на цену. Вот как мы получаем сумму, а затем вызываем отмену ставки на указанную сумму.



 

Логика Staking_amount_from_num_shares_rounded_down использует u256, потому что балансы работают на u128. Чтобы избежать переполнения, мы умножаем total_staked_balance на количество долей в u256. Цена округлена в меньшую сторону.



Вариант с округлением Staded_amount_from_num_shares_rounded_up очень похож, за исключением того, что мы делаем проверку, которая позволяет нам округлить. В конце обоих мы возвращаем его к u128.

Затем выполняем действие отмены ставки, которое очень похоже на unstake_all, за исключением того, что вы передаете сумму.


Методы получения/просмотра
После этого есть куча методов-геттеров, которые являются вызовами просмотра, которые возвращают вам некоторые суммы. Вы можете получить незанятый баланс учетной записи, баланс учетной записи, общий баланс учетной записи, проверить, можете ли вы вывести средства, общий баланс ставки, который представляет собой общую сумму активной ставки в пуле ставок.



Затем вы можете узнать, кто является владельцем пула ставок, вы можете получить текущую плату за вознаграждение или комиссию пула ставок, получить текущий ключ ставок, и есть отдельная вещь, которая проверяет, приостановил ли владелец пул ставок.



Допустим, владелец выполняет миграцию пула ставок на узле. Им необходимо полностью отказаться от ставок, поэтому, например, они могут приостановить пул ставок, который отправит транзакцию состояния в протокол NEAR, а затем не будет повторно делать ставки, пока они не возобновят пул ставок. Тем не менее, вы все еще можете вывести свои балансы, но вы перестанете получать вознаграждения после его прохождения.



Наконец, вы можете получить удобочитаемую учетную запись, в которой указано, сколько у вас на самом деле токенов для количества акций по текущей цене, и, наконец, указано, можете ли вы вывести средства или нет.



Затем он дает вам количество учетных записей, которое является количеством делегаторов в этом пуле ставок, и вы также можете получить несколько делегаторов одновременно. Это пагинация на большом количестве аккаунтов в пределах неупорядоченной карты. Один из способов сделать это — использовать помощник, который мы называем keys_as a_vector из неупорядоченной карты. Это дает вам постоянную коллекцию ключей из карты, а затем вы можете использовать итератор для запроса учетных записей из этих ключей. Это не самый эффективный способ, но он позволяет реализовать нумерацию страниц на неупорядоченных картах.
Методы владельца


Есть куча методов владельца. Метод владельца — это метод, который может быть вызван только владельцем. Владелец может обновить ключ стейкинга. Допустим, у них другой узел, и владельцу нужно использовать другой ключ. Все эти методы сначала проверяют, что их мог вызвать только владелец.



Это метод, который изменяет комиссию в пуле ставок. Владелец может немедленно изменить комиссию, которая будет действовать в эту эпоху, начиная с этой эпохи, но все предыдущие комиссии будут рассчитываться с использованием предыдущей комиссии.



Тогда это был метод голосования, который позволил нам перейти ко второй фазе основной сети.

Далее следуют два метода, которые я уже описал, которые позволяют приостановить ставку и возобновить ставку.



Остальное только тесты. Большая часть логики происходит внутри.
Тест
У нас также в основном есть симуляционные тесты для конкретного пула. Этот симуляционный тест показывает, как на самом деле будет работать сеть. Сначала мы инициализировали пул.



Боб делегирует. Боб вызвал метод депозита пула, который представляет собой deposit_amount, используя метод депозита. Затем Боб может убедиться, что незанятый баланс работает правильно. Затем Боб ставит сумму. Затем мы проверяем сумму ставки сейчас. Мы убедились, что Боб поставил такую ​​же сумму.



Боб вызывает метод ping. Наград нет, но в симуляциях награды все равно не работают, поэтому вам нужно сделать это вручную. Мы еще раз убедимся, что сумма Боба осталась прежней. Затем бассейн возобновляется. Мы проверяем, что пул возобновил работу, затем блокируем его до нуля. Затем мы моделируем, что пул получил некоторое вознаграждение (1 NEAR), и боб пингует пул. Затем мы проверяем, что сумма, которую получил Боб, положительна. Это очень простой случай моделирования, в котором говорится, что Боб сначала внес депозит в пул, который проверяет, что пауза и возобновление работают, или имитирует, что это работает, и гарантирует, что пул не делает ставки во время паузы. Затем при возобновлении пул фактически делает ставки. Таким образом, этот тест проверяет не только это, но и то, что Боб получил награду и получил ее. Есть еще один тест, который проверяет некоторую логику, но он более сложный. Внизу есть несколько модульных тестов, которые должны проверять определенные вещи.



Некоторые из этих тестов не идеальны, но они проверяют определенные вещи, которые были достаточно хороши, чтобы убедиться, что математика складывается.
internal.rs
Internal Ping Method


Давайте перейдем к internal_ping. Это метод, который любой может вызвать с помощью ping, чтобы убедиться, что награды распределены. Прямо сейчас у нас есть активные пулы ставок, и есть учетная запись, спонсируемая одним из сотрудников NEAR, который в основном пингует каждую ставку в пуле каждые 15 минут, чтобы убедиться, что они распределили вознаграждения для отображения на балансе. Так работает распределение вознаграждения. Сначала мы проверяем текущую высоту эпохи, поэтому, если высота эпохи такая же, значит, эпоха не изменилась, мы возвращаем false, поэтому вам не нужно повторно делать ставку. Если эпоха изменилась, то мы запоминаем, что текущая эпоха (высота эпохи) существует, получаем новый общий баланс счета. Пинг может быть вызван, когда какие-то токены были депонированы через депозитные бюллетени, и они уже являются частью account_balance, и, поскольку пинг был вызван до того, как нам нужно вычесть этот баланс, прежде чем мы распределим вознаграждения. Мы получаем общую сумму, которая есть на счете, включая заблокированный и разблокированный баланс. Заблокированный баланс — это поставленная сумма, которая дает вознаграждение, а разблокированный баланс также может иметь вознаграждение в определенных сценариях, когда вы уменьшаете свою ставку, но ваши вознаграждения все равно будут отражаться в течение следующих двух эпох. После этого они придут к неразыгранной сумме. Проверяем с помощью assert! что общий баланс больше, чем предыдущий общий баланс. Это инвариант, которого требует пул ставок. В тестовой сети было много вещей, которые не сработали с этим инвариантом, потому что у людей все еще были ключи доступа к тому же пулу ставок, и когда он у вас есть, вы тратите баланс на газ, и вы можете уменьшить свой общий баланс без получения вознаграждения. Наконец, мы вычисляем сумму вознаграждения, полученного пулом ставок. Это общий баланс минус предыдущий известный общий баланс, баланс предыдущей эпохи. Если вознаграждение положительное, мы распределяем его. Первое, что мы делаем, это рассчитываем вознаграждение, которое владелец берет себе в качестве комиссии.



Мы умножаем вознаграждение_fee_fraction на общее полученное вознаграждение, и оно аналогичным образом округляется в меньшую сторону: числитель в u256 умножается на значение, деленное на знаменатель в u256.



Owners_fee — это сумма в yocto NEAR, которую владелец оставит себе. Оставшаяся_награда — это оставшиеся вознаграждения, которые необходимо повторно застейкать. Затем происходит повторная ставка. Владелец получил вознаграждение в yocta NEAR, а не в долях, но поскольку вся логика должна быть в долях, владелец пула ставок покупает доли по цене распределения вознаграждения за пост для остальных делегаторов. Таким образом, num_shares — это количество акций, которые владелец получит в качестве компенсации за управление пулом ставок. Если он положительный, мы увеличиваем количество акций и сохраняем учетную запись владельца обратно, а также увеличиваем общую сумму доли в акциях. Если по какой-то причине при округлении в меньшую сторону этот баланс становился равным нулю, вознаграждение было очень маленьким, а цена за акцию очень большой, и пул получал только нулевое вознаграждение. В этом случае этот баланс просто пойдет на цену за акцию, а не на компенсацию владельцу. Затем мы помещаем некоторые общие данные журнала, которые говорят, что текущая эпоха существует, что мы получили вознаграждение в виде количества акций или токенов, что общий баланс ставок в пуле что-то, и мы регистрируем количество акций. Единственный способ показать количество общих ресурсов внешнему миру — через журналы. Далее, если владелец получил вознаграждение, это говорит о том, что общее вознаграждение составило столько-то акций. Наконец, мы просто запоминаем новый общий баланс и все. Мы распределяли все вознаграждения в постоянное время и обновляли только один аккаунт (аккаунт владельца) для комиссии, и только если комиссия была положительной.
Internal Stake Method


Internal_stake — это место, где мы реализуем фонд гарантии цены. Допустим, предшественник, в данном случае мы назовем его account_id, хочет поставить определенное количество токенов. Balance на самом деле не является типом JSON, потому что это внутренний метод, поэтому здесь нам не нужен JSON. Мы рассчитываем, сколько акций нужно округлить в меньшую сторону, чтобы поставить заданную сумму, поэтому именно столько акций получит владелец. Он должен быть положительным. Затем мы проверяем сумму, которую владелец должен заплатить за акции, снова округляя в меньшую сторону. Это делается для того, чтобы гарантировать, что когда владелец купил акции и конвертировал их обратно без вознаграждения, он никогда не потерял NEAR за 1 год, потому что это может нарушить гарантию. Наконец, мы утверждаем, что на счету достаточно средств для оплаты взимаемой суммы, и мы уменьшаем внутренний неразмещенный баланс и увеличиваем внутренний баланс количества акций на счете. Затем мы округляем ставку_количества_из_количества_долей_раундед_в большую сторону, чтобы количество долей фактически округлялось в большую сторону. Эти 1 дополнительный пенни или 1 дополнительный год NEAR будут поступать из гарантированного фонда во время округления акций. Мы взимали с пользователя меньшую плату, но мы внесли больший вклад в сумму из этого 1 триллиона лет NEAR, которую мы изначально выделили для этого. Эта разница обычно составляет всего 1 год от NEAR, которая может быть получена в результате округления в большую или меньшую сторону. После этого идет сумма total_staked_balance и total_stake_shares. Далее мы выпускаем с ними новые акции. Наконец мы ставим лог и возвращаем результат.



Анстейкинг работает очень похоже. Вы округляете до суммы акций, которую вам нужно заплатить. Затем мы вычисляем сумму, которую вы получаете, снова округляя до переплаты вам за это. Это также происходит из гарантийного фонда. Затем мы уменьшаем доли, чтобы увеличить сумму, и сообщаем, когда вы сможете разблокировать баланс между четырьмя эпохами. Unstake_amount округляется в меньшую сторону, чтобы мы откладывали немного меньше, чтобы гарантировать цену других участников пула. Примерно так работает пул ставок и как работает математика. Мы компенсируем ошибки округления из средств, которые мы выделили.
Вывод
Мы обновили ключи для ристретто во время разработки этого контракта, и было удивительно, что нам нужно было это учитывать. В STAKE_SHARE_PRICE_GUARANTEE_FUND 1 триллион yocto NEAR должно быть достаточно для 500 миллиардов транзакций, что должно быть достаточно долго для пула ставок, чтобы его нельзя было пополнить, потому что вознаграждения будут немедленно перераспределены на total_stake_balance при следующем пинге. Мы потратили довольно много времени и усилий на этот контракт, потому что мы провели множество проверок безопасности, в том числе внутренних и внешних, особенно в отношении этой математики. Это было сложно, и некоторые вещи были обнаружены, например, ключ от ристретто, который всплывал во время обзоров. Мы отметили журнал изменений этого контракта, так же в ридми есть куча всего, что всплыло во время разработки, и тестирования на живой системе, но на написание оригинальной версии ушло около недели. Позже мы его почистили, протестировали и улучшили. Потом мы сделали кучу доработок. Приостановка и возобновление были запрошены пулом, потому что в противном случае владелец не имел бы возможности отменить ставку, если его узел выйдет из строя. Они будут атаковать сеть. По сути, эта активная доля будет запрашивать проверку, а не запускать сеть. Раньше у нас не было рубки. Это не было проблемой для участников, но это было проблемой для самой сети. Таким образом, владелец может приостановить стейкинг, если он не хочет запускать пул, который они мигрируют в пул, и общаться как можно больше до этого. Затем мы обновили интерфейс голосования, чтобы он соответствовал заключительному контракту на голосование на втором этапе. Мы добавили вспомогательные методы просмотра, чтобы иметь возможность запрашивать учетные записи в удобном для человека виде. Наконец, были внесены некоторые улучшения в методы пакетной обработки, поэтому Deposit_and_stake, Stak_all, unstake_all и remove_all вместо того, чтобы сначала делать вызов просмотра, получать сумму и помещать сумму для вызова ставки. Вот как мы это исправили.



Когда вы делаете ставку, вы не только ставите сумму, мы также прилагаем обещание проверить, была ли ставка успешной. Это необходимо для двух вещей: если вы пытаетесь сделать ставку с недопустимым ключом (не ключом, специфичным для ристретто), то обещание не будет выполнено до выполнения. Он не пройдет проверку перед отправкой, и поэтому вам не нужно проверять его в контракте. Он вернет последний звонок, и все будет хорошо. Также мы ввели минимальную ставку на уровне протокола. Минимальная ставка составляет одну десятую от суммы цены последнего места, и если ваш контракт попытается сделать ставку меньше этой, то действие не будет выполнено, и вы не отправите обещание. Допустим, вы хотите отменить ставку, но ваш баланс упал ниже одной десятой суммы ставки. Действие стейкинга может завершиться неудачей, и вы не сможете отменить стейкинг, в то время как вам это нужно, чтобы гарантировать, что анстейкинг произойдет. В этом случае у нас есть этот обратный вызов, который проверяет, успешно ли завершено действие стейкинга. Этот обратный вызов в основном проверяет, что в случае сбоя и положительного баланса нам нужно отменить ставку. Таким образом, он вызовет отмену ставки для действия, когда сумма ставки равна нулю, чтобы убедиться, что весь баланс освобожден. Вы можете вывести средства в 4 эпохи во время тестирования этих контрактов, которые мы проводили в тестовой сети бета-версии 9 перед техническим обслуживанием. Контракт был готов примерно летом, поэтому тестирование этой итерации заняло, вероятно, около 2-4 месяцев из-за сложности, связанные с взаимодействием с протоколом. Было довольно много обучения от разбивки на страницы до вспомогательных методов и объединения некоторых вещей. Одна вещь, которая была бы действительно хороша, иметь ставку или депозит и ставить все на контракт блокировки. Прямо сейчас вам нужно вручную указать, сколько вы хотите поставить на контракт блокировки, но было бы здорово, если бы вам не нужно было думать о вашем yocto NEAR и о том, сколько он заблокирован для хранения. Вы просто хотите поставить все из своего локапа, но, поскольку он уже был развернут, было слишком поздно думать об этом. Есть также некоторый газ, который жестко запрограммирован, и с общим снижением комиссии эти номера нельзя изменить, потому что они уже в цепочке.



Таким образом, голосование не важно, но метод ON_STAKE_ACTION_GAS требует, чтобы у вас было большое количество для каждой ставки, и вы не можете его уменьшить. Рискованные действия при каждом вызове по этому контракту потребуют от нас большого количества газа, и проблема в том, что это расточительно. Допустим, мы договорились сжечь весь газ, этот газ всегда будет сожжен и потрачен впустую, плюс он ограничивает количество транзакций, которые вы можете поместить в один блок, если мы ограничиваем газ на основании этого случая. Было много итераций по тестированию контракта с использованием среды имитационного тестирования, которую мы значительно улучшили. Если мы в конце концов доберемся до контрактов блокировки, вы увидите, насколько структура контрактов блокировки улучшилась по сравнению с этой.

### NEAR Live Обзор контрактов | Часть 3: Белый список и стейкинг-пул

Введение
Всем привет. Сегодня мы рассмотрим 2 контракта. Мы включим в обзор контракты, включающие кросс-контрактные вызовы, и поговорим  и о том, как они работают на NEAR. Если вы хотите узнать больше о том, как работает компонуемость, это хорошая статья для чтения. Первый контракт, который мы собираемся рассмотреть, называется контрактом белого списка,  он используется в основной сети для внесения в белый список пулов ставок. Это важно, потому что распределение токенов осуществляется через смарт-контракты. Мы используем контракты блокировки,  принцип работы заключается в том, что блокировка — это автономный контракт, который содержит токены, которые должны быть выпущены в течение определенного периода времени. Допустим, токены выпускаются в течение 2 лет и линейно распределяются в каждом блоке. Что мы хотели сделать, так это дать возможность делать ставки на эти токены, включая токены, которые еще не выпущены. Вы должны иметь возможность делегировать все токены, которые вы заблокировали, например, на 2 года, и начать зарабатывать вознаграждение.  Делается это в смарт-контракте, а контракт блокировки, по сути, вызывает контракт пула ставок, который мы рассматривали ранее, и передает токены из одного контракта в другой. Токены из контракта блокировки списываются с аккаунта и переходят на счет пула ставок. Если пул ставок не предоставляет необходимых гарантий, таких как возможность возврата этих токенов, то это означает, что будут проблемы. Допустим, я создаю собственный пул ставок, который позволяет мне не только держать токены, но и выводить их на любой счет. Этот тип операции позволит вам получить ликвидные активы до окончания периода выпуска. 

Вот почему мы ввели белый список, в котором пользовательские реализации пулов ставок, одобренные NEAR Foundation, могут использоваться в контрактах блокировки. В то же время мы хотели дать возможность создавать новые пулы ставок, которые уже одобрены кем-либо, без одобрения со стороны NEAR Foundation. Это позволяет любому создать новый пул ставок через стэйкинг-пул. Стэйкинг-пул — это второй контракт, который мы сегодня рассмотрим. Работает это так: когда контракт блокировки хочет делегировать средства, прежде чем это можно будет сделать, им сначала нужно выбрать стэйкинг-пул. Когда вы выбираете стэйкинг-пул, блокировка запускает транзакцию, чтобы проверить, включен ли данный идентификатор учетной записи в белый список в контракте белого списка, и если он возвращает true, что означает, что учетная запись внесена в белый список, тогда контракт блокировки может быть продолжен с делегированием. Это позволяет блокировке фактически перейти к этому контракту. Контракт стэйкинг-пула имеет некоторые гарантии и API, которые ожидает локальный контракт, и он не собирается блокировать токены владельца или забирать токены из контракта блокировки. Также это важно для графиков инвестирования сотрудников NEAR. Четырехлетний график инвестирования позволяет фонду выпустить конкретную транзакцию для блокировки этого человека, чтобы вывести все из пула ставок и вернуть инвестируемую сумму обратно в фонд NEAR в случае ухода сотрудника (например увольнение). Это была предыстория блокировки и контракта белого списка.

Оригинальный репозиторий этих контрактов можно найти на NEAR Github. Вот оригинальное видео, на котором основано это руководство:


Контракт белого списка
Основная структура
Давайте посмотрим на контракт белого списка. На самом деле это довольно простой контракт и мы уже знаем большую часть вещей.



Он использует NEAR API, который называется LookupSet она похожа на неупорядоченный набор. Это персистентная коллекция, но в ней нет итераторов, поэтому вы не можете перебирать ключи элементов набора. Вы можете только проверить, присутствует данный элемент или нет, и вы можете добавить его в набор. Делая это, он повышает эффективность хранения и доступа от нескольких чтений до нескольких чтений. Контракт содержит несколько полей. Первый — это Foundation_account_id. Это идентификатор учетной записи, которая управляет белым списком. Это означает, что эта учетная запись может внести в белый список пулы ставок на 1, а также может внести в белый список фабрики пулов ставок. Фабрика — это контракт, который может создать новый экземпляр пула ставок. Работает это следующим образом: когда вы выполняете транзакцию в отношении фабрики ставок, внесенной в белый список этого контракта, создается новая учетная запись в качестве дополнительной учетной записи стэйкинг-пула. В нашем случае в основной сети он называется poolv1.near, который является используемой нами фабрикой стейкинг-пулов. Он создает контракт, например bisontrails.poolv1.near, на котором он развертывает код стейкинг-пула из белого списка, который может производить эта фабрика. Позже мы перейдем к фабрике пулов ставок, но в то же время она также может внести этот пул ставок в белый список. Вот как это работает. Инициализация контракта принимает только аргумент Foundation_account_id. Учетная запись фонда имеет более высокие права доступа к этому контракту.


Добытчики
Есть много добытчиков.



Вы можете проверить, включен ли данный ввод ставок в белый список. Вот как контракт блокировки проверяет, находится ли пул в белом списке. По сути, он просто проверяет, присутствует ли элемент в наборе. Второй способ, которым он также может проверить, состоит в том, что стэйкинг-пул находится в белом списке, так что это на самом деле не нужно, и никто его не вызывает.
Добавление метода стэйкинг-пула


Это метод, который может быть вызван как пулом, так и фондом. Здесь мы проверяем, добавляет ли этот метод стейкинга новый staking_pool_account_id в белый список. Он проверяет, действителен ли идентификатор учетной записи, затем, если он действителен, мы проверяем, является ли это пулом. Проверяем в наборе, что вызывающий этот метод присутствует в белом списке фабрик. Если это вызвано фабрикой стейкинг-пула, то все в порядке. Если нет, то это должен быть идентификатор базовой учетной записи, иначе контракт не будет выполнен, и этот метод вызовет панику. Если мы проходим проверку разрешений, мы просто добавляем этот стейкинг-пул в белый список. Прямо сейчас у нас есть только одна реализация для пула ставок, но теоретически мы можем изменить эту реализацию, например, когда мы вводим слэшинг, и пул ставок должен иметь необходимое разрешение. Он должен поддерживать некоторый минимальный баланс. Есть еще одно изменение, когда нам нужно изменить подтвержденный контракт на период инвестирования каждого, равный 4 годам. В сети может происходить множество вещей и нам нужна возможность потенциально изменять пулы ставок. Например, если изменится логика стейкинг пула. Это позволяет создать новую фабрику, которая является лучшей версией или поддерживает что-то, что не поддерживалось ранее. Это не позволяет мгновенно изменить комиссию за вознаграждение, а позволяет изменить ее только после 7-дневного периода ожидания или какой-либо другой идеи для модификации, которая будет другим фактором.



Следующий remove_staking_pool может быть вызван только фондом, поэтому пул ставок может быть уничтожен только фондом.

Кроме того, add_factory также может вызываться только фондом. Это просто, просто добавляется в белый список заводских учетных записей.



Наконец, remove_factory также может вызываться только фондом и удаляет factory_account_id. Допустим, срок действия первой стэйкинг-пула истекает, тогда фонд может удалить его из белого списка, а также удалить все предыдущие стэйкинг-пулы из белого списка. Теперь вы не сможете выбрать один из предыдущих опросов ставок из контракта блокировки, так же есть проверка, что это вызвано фондом, который является сравнением. Это очень простой контракт,  он работает с внутренними наборами,  единственный верный метод видимый извне — это is_whitelisted. 
Неизменяемость смарт-контрактов
Особенность того, как обычно ведут себя смарт-контракты, как в Ethereum так и в других платформах, заключается в том, что они неизменны сами по себе. В Ethereum внутренняя часть каждого контракта является неизменной, но они используют прокси-контракт, который позволяет им обновлять конечную точку для определенных контрактов, которые очень важны для токенов. В этом случае наши основные контракты, по сути, полностью неизменны, и мы думаем о них так, как будто мы развернем их один раз и, вероятно, не можем их изменить, потому что в противном случае вам придется делать хардфорк и убеждать всех валидаторов сделать некоторый тип миграции кода. Это важно, потому что контроль над ними должен осуществляться на уровне контракта, а не на каких-то централизованных объектах. Например, хотя фонд по-прежнему сохраняет большой контроль над пулами ставок, имея возможность удалять пулы ставок здесь, у него нет возможности занести в черный список конкретную организацию в реальном мире от развертывания пула ставок. Они по-прежнему могут создать пул ставок с максимально возможной анонимностью и создать пул ставок, не спрашивая разрешения стать валидатором в основной сети. Что-то происходит из-за децентрализации, что-то из-за ограничения контроля. Хотя предполагается, что фонд должен поддерживать сеть, возможно, что в некоторых сценариях фонд может быть вынужден сделать что-то плохое для сети. Допустим, приходит правительство и пытается заставить их. Если у них меньше возможностей для этого, то безопасность в сети выше. Когда мы разрабатываем контракт, мы думаем: «Какова сумма стоимости в этом контракте?» или «Какова способность этого контракта влиять на сеть в целом?». Если это маленькое значение, то можно сохранять доверие до тех пор, пока доверяет сообщество, если это большое значение, то это не нормально. Когда мы на самом деле перейдем к контракту на блокировку и к тому, как он разработан, вы можете увидеть, как, например, наделение правами было разработано, чтобы с одной стороны позволить фонду вывести оставшиеся средства, но в то же время помешать фонду от вывода вложенных средств. Это законный способ ведения дел, за исключением того, что он прописан в коде. Белый список является очень важным контрактом, потому что до того, как средства будут заблокированы, большинство фондов как бы контролируют сеть через локальные контракты в пулах ставок через этот конкретный белый список, поэтому было важно разработать его таким образом, чтобы он сохранял децентрализацию. и безопасность сети без передачи контроля фонду. Допустим, что-то случилось, и фонд начал действовать злонамеренно. Допустим, вы смогли создать новый пул ставок через фабрику и делегировать в пул ставок, теперь фонд не может помешать вам делегировать в этот пул ставок.
Контракт на создание пула ставок
Include Bytes Macro


Контракт staking_pool_factory — это контракт, который имеет внутренний код контракта пула ставок. В Rust это можно сделать с помощью макроса include_bytes. По сути, он берет локальный файл и встраивает его в двоичный файл в виде вектора. Что происходит, так это то, что в этом бинарном файле WebAssembly у нас может быть выделен некоторый фрагмент памяти, который представляет бинарный файл этого конкретного пула ставок. Вернемся к началу.
Структура
Это структура.



Там была некоторая информация о газе, мы вернемся к этому позже.



Существует вознаграждение_fee_fraction, которое просто скопировано из контракта пула ставок, который мы рассмотрели ранее.


Внешние контракты
Есть аргументы стейкинг-пула, которые он принимает, есть черты и внешние контракты, так что это высокоуровневый интерфейс, который мы используем для вызова определенных контрактов.



У нас их два, у первого может быть любое имя. Мы называем его ExtSelf, поскольку он представляет собой наш собственный контракт и содержит обратный вызов метода on_staking_pool_create. Вторая черта предназначена для контракта с белым списком, который мы только что видели, под названием add_staking_pool. Вот. 



Это точно такой же интерфейс, за исключением того, что трейты в Rust похожи, например, на интерфейсы в java. Мы просто определяем интерфейс удаленного контракта.
Инициализация


Давайте сначала пройдемся по сценарию. Когда создается фабрика, мы проверяем, что она не была инициализирована, и проверяем staking_pool_whitelist_account_id, идентификатор учетной записи контракта белого списка, во время инициализации StakingPoolFactory. Нам нужно знать staking_pool_whitelist_account_id. Именно здесь развертывается контракт белого списка, чтобы внести в белый список наши недавно созданные экземпляры пула ставок. Мы это помним, а также создаем набор уже созданных аккаунтов в конце этого фрагмента.
Основной метод


Теперь, когда создана фабрика стейкинг-пула, например, она называется poolv1.near, и фонд внес фабрику в белый список в контракте белого списка, выполнив еще одну транзакцию. Теперь, когда эта фабрика пулов ставок занесена в белый список, это означает, что у нее есть разрешение на внесение в белый список новых пулов ставок, которые она создает. Итак, теперь приходит валидатор, и они хотят создать для себя пул ставок. Как это работает, они вызывают create_staking_pool, и он принимает кучу аргументов. Первый аргумент — это префикс. Допустим, это bisontrails без суффикса текущего идентификатора учетной записи, и это происходит от имен учетных записей NEAR. Учетная запись может создать только дополнительную учетную запись или очень длинную учетную запись, поэтому фабрика стейкинг-пула создает под собой дополнительную учетную запись, которая будет называться bisontrails.poolv1.near. Как мы обсуждали ранее, owner_id — это идентификатор учетной записи владельца пула ставок. Все эти три элемента, по сути, являются аргументами, которые вы должны передать пулу ставок при его первом создании. Это аргумент, который вы можете проксировать в пул ставок. Например, staking_pool_id может быть bisontrails.near. Staking_public_key может быть ключом стейкинга от запуска узла валидатора, а вознаграждение_fee_fraction может быть, например, 10%. Обратите внимание, что этот метод также является платным, это означает, что он принимает входящий прикрепленный депозит, и первое, что он спрашивает, это: «Вы вложили достаточно депозита?» Депозит, который вам нужно прикрепить, составляет 30 NEAR, и в нем много нулей, но это потому, что он в yocto NEAR. Вам нужно прикрепить 30 NEAR в основном потому, что вам нужно покрыть состояние самого контракта во вновь созданном пуле ставок. Контракт довольно большой, это 250 килобайт, и для этого вам нужно как минимум 25 NEAR, но также потребуются дополнительные деньги для покрытия гарантийного фонда цены. Это один из тех случаев, когда у вас должен быть прикрепленный депозит, потому что вы не можете привязать к этой транзакции столько газа. Также мы не можем конвертировать газ в NEAR в рамках контракта, поэтому в идеале разделение газа остается прежним, оно используется только для вычислений, некоторых операций чтения/записи и межконтрактных вызовов. Баланс используется для хранения состояния и переводов. Так что в нашем случае это создаст новую учетную запись, а создание новой учетной записи на NEAR потребует от вас оплаты хранения этой учетной записи. Хранилищем в нашем случае будет не только сама учетная запись, но и контракт этой учетной записи. В нашем случае это код контракта стейкинг-пула.



Следующее, что мы делаем, это проверяем, что в префиксе нет точки, что означает, что это не сама дополнительная учетная запись. Затем мы создаем новый staking_pool_account_id, объединяя точку идентификатора нашей учетной записи (.) с этим новым префиксом. Мы проверяем, что новый идентификатор учетной записи пула ставок действителен. По сути, если какое-либо из этих утверждений не удастся, протокол NEAR вернет токены. Если транзакция с прикрепленным депозитом завершится неудачно, прикрепленный депозит вернется к отправителю или предшественнику, потому что только предшественник может прикрепить баланс. Здесь безопасно делать кучу утверждений. Затем мы проверяем, что owner_id пула ставок действителен. По сути, это просто набор дополнительных помощников, которые также проверены в пуле ставок. Это сделано для того, чтобы убедиться, что если вы не передаете правильные аргументы или слегка неправильные аргументы, вам лучше потерпеть неудачу раньше, чем все будет выполнено, чтобы избежать сжигания газа и блокировки потраченных токенов. Наконец, с помощью вставки мы проверяем, что пул ставок не существует. По сути, вставка вернет true, если это новый уникальный элемент, и вернет false, если элемент уже существует в наборе. Вот как работает хеш-набор Rust точно так же, как работает упорядоченный набор. Поэтому, если имя пула уже существует, мы не будем добавлять этот пул ставок или пытаться создать эту учетную запись снова. Insert делает две вещи: добавляет этот элемент в хранилище, а также возвращает true, если элемент уникален и ранее не существовал, или возвращает false, если элемент уже присутствует. Если в наборе не было этого значения, возвращается true, если в этом наборе это значение было, возвращается false.



Наконец, мы используем API среднего уровня, мы не используем наши методы необработанных затрат, но в то же время мы не используем интерфейс высокого уровня. Это работает следующим образом: мы создаем новое обещание, которое создает временную структуру в нашем NEAR SDK и запоминает получателя этого обещания. Вы можете думать об этом так, как если бы контракт выдавал транзакцию для данного идентификатора учетной записи. Мы назовем идентификатор несуществующей учетной записи пула ставок. Конечно, это не транзакция, а квитанция, но это техническая деталь. Следующее — это первое действие поверх этого обещания. Мы начинаем объединять действия в это обещание. Первое действие — create_account. Это действие создаст новую учетную запись или завершится ошибкой, если учетная запись уже существует. Затем мы вносим прикрепленный баланс. Мы вносим весь залог, который нам передали, чтобы мы не хранили его на этой фабрике, и он уйдет с той же распиской на удаленный счет. Далее мы разворачиваем контракт. Как пояснялось ранее, include_bytes — это макрос, создающий статический срез, который мы преобразуем в вектор, который будет передан действию развертывания. Это развернет код в удаленной учетной записи. Вы можете развернуть код только в той учетной записи, которой управляете, но create_account дает вам разрешение действовать так, как будто вы являетесь владельцем этой учетной записи, только для этой конкретной транзакции. Вы можете использовать метод deploy_contract, вы можете делать ставки и делать некоторые другие вещи от имени этого контракта в первой транзакции, которую вы делаете. Наконец, мы инициализируем контракт пула ставок, используя API serda. Мы берем эту структуру и сериализуем ее в JSON, метод называется new. Первый аргумент — это прикрепленный депозит к этому вызову функции. Нам это не нужно, потому что оно этого не ожидает. Следующее - это количество газа, которое вы берете из своего текущего количества газа, и сразу забираете, после чего оно переходит на обещание. Допустим, наш метод назывался 100 терагаз, терагаз — это некая единица, которая примерно понятна человеку.



Когда вы входите, у вас есть 100 терагаза, и мы говорим, что собираемся пройти базу (25 терагаза), умноженную на 2. Мы немедленно передаем 50 терагаза в вызов функции этого метода, поэтому эти 50 терагаза означают, что мы только осталось менее 50 тера газа, потому что мы уже сожгли кое-что по логике раньше. Кроме того, каждое действие, которое вы включаете в это обещание, также будет стоить вам немного газа. Например, действие развертывания будет стоить вам, чтобы передать байты из одной учетной записи в другую. Наконец, мы используем then. Затем аналогично тому, как работает javascript, он прикрепляет зависимость от предыдущего обещания. Это первое обещание, и мы говорим, что после его завершения выполните второе обещание. Это работает следующим образом: вы вызываете, скажем, bisontrails.near, вызывая этот контракт (poolv1.near), чтобы создать bisontrails.poolv1.near. Сначала мы создаем обещание для bisontrails.poolv1.near, а затем прикрепляем обратный вызов к этому API, что не очень удобно с точки зрения использования позиционных аргументов для двух разных вещей. В любом случае он вызывает текущий идентификатор учетной записи. Таким образом, он вызовет poolv1.near после выполнения первого промиса. Вот структура: bisontrails.near вызывает poolv1.near, создавая обещание пула ставок. Теперь это создает обещание для bisontrails.poolv1.near, а также создает обещание для самого себя в методе on_staking_pool.



Ему нужен результат этого метода до того, как этот метод запустится, и здесь он передает три аргумента. Он передает идентификатор staking_pool_account_id, прикрепленный_депозит и предшествующий_account_id. Итак, кто нам звонил, какую учетную запись пытались создать и сколько токенов было привязано на случай, если нам нужно будет сделать возврат. Теперь, если isontrails.poolv1.near успешно выполнен, то on_staking_pool_create получит результат выполнения. Допустим, была некоторая неправильная конфигурация, что этот метод также будет вызываться, но получит обратный вызов, говорящий о том, что он не удался. Мы вернули основной промис после, тогда это означает, что мы сначала вернули on_staing_pool_create. Это важно, потому что результат метода create_staking_pool зависит от результата промиса on_staking_pool_create. Транзакция не запускается полностью параллельно, теперь она зависит от выполнения этого конкретного метода.
Обратная связь


Первое, что мы делаем, это говорим, что это может быть вызвано только текущим контрактом с использованием assert_self, что означает, что никто другой не может вызвать это обещание.



Следующее, что мы делаем, это используем другой вспомогательный метод утилиты, который говорит, была ли зависимость, создание пула ставок успешной или неудачной.



Мы делаем это следующим образом: сначала мы используем два конечных метода, чтобы проверить, что количество результатов равно 1. Это инвариант, потому что мы уже знаем, что никто не может вызвать его дважды, а второй — если результат будет успешным. Если метод выполнен успешно, то мы возвращаем true, если обещание не удалось, то оно будет ложным. Итак, теперь мы знаем, был ли создан пул ставок или нет. Опять же, мы также добавили 50 тера газа к обратному вызову, так что теперь мы находимся в обратном вызове, что означает, что у нас есть только 50 тера газа.



Если нам это удастся, мы зарегистрируем, что пул был успешно создан, а затем внесем его в белый список. Затем мы вызываем другой промис из обратного вызова и присоединяем газ 25 тера. Итак, теперь мы вызываем staking_pool_whitelist_account_id, контракт белого списка. Теперь мы можем внести в белый список только что созданный пул ставок, потому что мы передали этот аргумент обратному вызову. Мы возвращаем это обещание, чтобы пока не останавливать выполнение, потому что мы хотим завершить всю транзакцию только после завершения белого списка. В Rust нет возврата, потому что если указано последнее значение без точки с запятой, то это возвращаемое значение. Если создание завершится ошибкой, это может произойти только по одной причине: если вы введете неверный ключ ристретто, как мы кратко обсуждали ранее. Если есть какая-то странная кривая, в которой вы создали свой ключ для ставок, то он потерпит неудачу. Причина, по которой это не удается, заключается в том, что депозит, который вы передали в пул ставок для создания, будет возвращен нам, а не предшественнику. У нас по этому контракту 30 РЯЗ, и нам нужно вернуть их обратно отправителю, чтобы мы их не запирали. Первое, что мы делаем, это удаляем его из списка созданных пулов ставок, потому что это не увенчалось успехом. Итак, мы говорим, что создание не удалось, и мы собираемся вернуть вам прикрепленный депозит. Теперь это не реальный прикрепленный депозит, потому что callback не получает прикрепленный депозит. Он проходит через отдельную квитанцию ​​о возмещении, которая обычно приходит перед обратным вызовом, и также принимает id-предыдущего_аккаунта. В нашем случае, если мы вызовем предшествующий_аккаунт_ид, это будет наш, потому что это обратный вызов. Нам нужно знать, кому мы должны вернуть токены, и способ, которым мы это делаем, заключается в создании промиса с использованием нового предшественника_account_id, и мы возвращаем токены, которые были прикреплены ранее. Как вы можете видеть, мы не возвращаем это обещание, мы просто говорим, что все, нас не волнует, успешно это или нет, основной возврат значения false говорит о том, что пул не удалось создать. Что происходит сейчас: транзакция продолжает выполняться, но значение будет возвращено во внешний интерфейс. Внешний интерфейс — это NEAR CLI. Вы сразу узнаете, что транзакция не удалась. Возможно, вы еще не вернете свои деньги, поэтому вы все еще ждете, пока этот конкретный возврат будет выполнен в следующем блоке, но вы уже знаете, что пул не был создан, чтобы вы могли продолжить. Это пример того, как вы можете сделать параллельное обещание. Вот как работает фактор пула ставок. Вот геттер, который проверяет, сколько было создано стейкинг-пулов, которые можно вызвать в NEAR CLI.


Заключение
На этом  мы завершаем обзор текущих контрактов NEAR. | Часть 3: Фабрика белого списка и стейкинг-пула. Спасибо, что нашли время изучить NEAR. Скоро в этой серии появится больше материалов.

### Оптимизация для NEAR Storage On-Chain (уменьшение размера контракта)

Примечание: мы оставляем вам несколько «вопросов», чтобы вы сами могли поэкспериментировать, и оценить каковы будут конечные результаты. 

Хранение в цепочке стоит дорого. На каждые 100 КБ блокируется 1 NEAR. Эти NEAR можно вернуть, если убрать используемое хранилище. Существует две основные причины использования хранилища:

 	Транзакции: каждая транзакция представляет собой квитанцию, которая сохраняется в цепочке и, следовательно, занимает некоторое хранилище. Каждая квитанция транзакции имеет разную длину (некоторые вызывают больше функций, следовательно, квитанция длиннее; другие вызывают только 1 функцию, поэтому квитанция короче), поэтому объем используемого хранилища различен. Точно так же, как вам нужно больше бумаги для печати длинной квитанции, вы используете больше места для хранения более длинной квитанции.
 	Развертывание смарт-контракта: Когда вы разворачиваете  смарт-контракт, он занимает размер смарт-контракта (он может немного отличаться от того, что вы видите в локальном файле wasm, но в целом различия невелики). Для транзакций, если вы не уменьшите количество транзакций, которые вы сделали, вы не сможете реально уменьшить объем пространства, занимаемый транзакциями.

(Вопрос: Можем ли мы удалить нашу учетную запись верхнего уровня через Near-Cli? Если мы удалим, освободит ли это стоимость хранения? (ps проверьте проводник после удаления дополнительной учетной записи.) Конечно, транзакции не будут удалены, следовательно будет ли он по-прежнему блокировать стоимость хранения, следовательно, никогда не может быть выпущен?)

Далее мы поговорим об оптимизации размера вашего смарт-контракта.
Оптимизация размера контракта
Постоянное хранение
У NEAR есть список коллекций, список находится здесь. Эти коллекции кэшируют данные, чтобы уменьшить плату за газ. Компромисс заключается в следующем: какую плату за газ вы хотите уменьшить? Какую стоимость хранения вы готовы заплатить за снижение платы за газ? Сколько уникальных постоянных хранилищ вам нужно?

Разница указана в приведенной выше ссылке (точные данные приведены ниже):

Важно иметь в виду, что при использовании std::collections (т. е. HashMap и т. д.) при каждой загрузке состояния все записи в структуре данных будут поочередно считываться из хранилища и десериализоваться. Это будет стоить дорого за любой нетривиальный объем данных, поэтому, чтобы свести к минимуму количество используемого газа, в большинстве случаев следует использовать коллекции SDK.

Рассмотрим этот пример: у нас есть основной контракт, в котором есть словарь/хеш/карта для связи ArticleId со статьей. Статья — это объект (в Rust он также называется Struct) со своими атрибутами.
use near_sdk::AccountId;
use near_sdk::collections::LookupMap;
use std::collections::HashMap;

pub struct Contract {
pub article_by_id: LookupMap<ArticleId, Article>,
}

pub struct Article {
pub owner_id: AccountId,
pub article_id: String,
pub royalty: HashMap<Account, u16>,
}
We see that Contract.article_by_id uses LookupMap and Article.royalty uses HashMap. We shall discuss why we don’t use other types.
Рассмотрим article_by_id, когда мы создаем статью, идентификатор будет уникальным и специфичным для этой статьи. Он будет храниться вечно. LookupMap кэширует результаты в памяти, поэтому нам не нужно «вычислять» (используя плату за газ) каждый раз, когда нам нужны результаты.

Как упоминалось ранее, поскольку все будет десериализовано при чтении при использовании HashMap, а LookupMap<AccountId, Article> не является тривиальным объемом данных (когда создается много статей), он должен кэшироваться в цепочке.

Итак, почему мы используем Lookup Map вместо Unordered_Map? Последний предлагает итерацию функциональности коллекции, которая нам не нужна. Если вам это нужно, используйте последний.

Затем для роялти мы используем HashMap. Дело в том, что у нас много статей, каждая со своей уникальной статьей.роялти. Для каждого уникального Article.royalty нам нужно создать новый ключ для сохранения хранилища.

Давайте проиллюстрируем тот же сценарий общего хранилища ключей. Скажем, мы создаем две статьи, Article A и Article B. Это их эквивалент Article.royalty.
// Values are percentage, 100.00% == 10_000.

// Article A
{
"alice.near": 1_000,
"bob.near": 500,
}

// Article B
{
"alice.near": 1_500,
"charlie.near": 2_000,
}
For some reason, there’s a repeat royalty for alice.near. If you use the same storage key, it will lead to error, complaining that: you already have an alice.near stored in Article A, and you are repeatingly storage another value to that key, and this is not possible. We also want them to be independent of each other; and same storage key used by 2 different HashMap means they share the same values.
(Вопрос: можете ли вы получить значения, хранящиеся в статье A, если вы инициализируете тот же ключ хранилища в статье B?)

Решение состоит в том, чтобы создать отдельный ключ хранилища для каждой коллекции. Однако, если у нас есть 1 миллион статей, нам потребуется 1 миллион различных ключей коллекции, чтобы хранить их отдельно. Это звучит глупо! Следовательно, имеет смысл хранить их скорее как HashMap. Кроме того, они тривиальны. Эти лицензионные платежи изначально предназначены для ограничения объема данных, которые они могут хранить, поэтому выборка данных невелика, а их десериализация обходится дешево. Это укрепляет наш выбор в пользу использования HashMap, а не эквивалентных коллекций SDK, несмотря на (немного) более высокое использование газа (что незначительно, поскольку коллекция настолько мала, что ею можно пренебречь).

В заключение, при разработке смарт-контракта выберите, использовать ли коллекции NEAR SDK или коллекции Rust, основываясь на тривиальности и количестве повторов, необходимых для одной и той же карты.
Сокращение кода
Первый код, который мы пишем, плохой. На самом деле они всего лишь наброски. Нам нужен рефакторинг, чтобы удалить ненужный код. Существует компромисс между более простым для понимания кодом и оптимизацией хранилища.

Например, возможно, у кого-то есть PayoutObject, и он используется только в одной функции.
use near_sdk::json_types::U128;
use near_sdk::AccountId;

pub struct Payout {
pub payout: HashMap<ArticleId, U128>,
}

impl Default for Payout {
fn default() -> Self {
Self [
payout: HashMap::new(),
]
}
}
Почему бы нам просто не определить
HashMap::new()
в конкретной функции, которая использует это? Конечно, если вы сделаете последнее, будет сложнее понять код. Первый упрощает понимание с точки зрения объектно-ориентированного подхода. Однако (значительно) больший объем кода приводит к увеличению объема памяти, используемой после компиляции в WASM. Итак, пришло время сделать некоторые компромиссы.

(Вопрос: сколько места вы сэкономите, если замените первое на второе? Если у вас есть подобный сценарий в вашей программе, попробуйте оптимизировать ее, написав меньше кода, и посмотрите, сколько места она скомпилировала, есть ли разница? (Иногда нет, иногда есть.Для тех, у кого нет, предпочтите сохранить читаемый код для более легкой отладки в будущем).
Wasm-Opt
После того, как вы скомпилировали оптимизированную версию выпуска, вы можете еще больше уменьшить размер контракта, используя wasm-opt. Для установки загрузите бинарный файл для вашей ОС здесь и разархивируйте его. Внутри есть папка «bin», из которой вы должны скопировать точный путь к этой папке и добавить его в свой путь к среде. После этого попробуйте вызвать wasm-opt из командной строки/терминала независимо от того, работает он или нет. Если нет, погуглите в интернете, как это решить (возможно, вы не добавили его в правильную переменную среды, возможно, ваш терминал уже открыт, и он не обновляет последний путь, это две самые распространенные проблемы).

Их запуск уменьшит размер файла:
#!/bin/bash
set -e

export WASM_NAME=tipping.wasm
z
mkdir res

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
cp target/wasm32-unknown-unknown/release/$WASM_NAME ./res/
wasm-opt -Os -o res/output_s.wasm res/$WASM_NAME
ls res -lh
Здесь мы предполагаем, что исходный контракт скомпилирован в tipping.wasm (название Cargo.toml — tipping). Тогда оптимизированное имя — output_s.wasm. Затем мы запускаем ls (в Linux), чтобы проверить разницу в размере файла. Он должен быть меньше.

Примечание: вы также можете использовать -Oz для флагов, но оказалось, что это необязательно, поскольку для проекта, над которым вы работаете, это не приводит к уменьшению размера файла.

Важное примечание: RUSTFLAGS должен быть «link-arg=-s», если вы случайно измените его на «-z», у вас могут возникнуть большие проблемы. По крайней мере, для одного он генерирует wasm-файл гораздо большего размера. Вы должны поэкспериментировать с ним и проверить свой собственный проект.

Cargo.toml
Это обычные флаги
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
Вы также можете выбрать opt-level = «z», это может сгенерировать или не сгенерировать двоичный файл меньшего размера.
Другие маленькие хитрости
Избегайте форматирования строк формат! а to_string() может привести к раздуванию кода; поэтому используйте статическую строку (&str), когда это возможно. 

Удаление rlib, если не требуется 

Если вам не нужно проводить моделирование, удалите rlib.

Используйте сериализацию Borsh 

По возможности не используйте serde. Вот страница о том, как переопределить протокол сериализации. 

Избегайте стандартных утверждений Rust и макроса паники Они содержат информацию о возвращенной ошибке, что приводит к ненужному раздуванию. Вместо этого попробуйте следующие методы:
// Instead of this
assert_eq!(
contract_owner,
predecessor_account,
"ERR_NOT_OWNER"
);

// Try this (for all versions of near-sdk-rs)
if contract_owner != predecessor_account {
env::panic_str("ERR_NOT_OWNER")
}

// For near-sdk-rs v4.0 pre-release
use near_sdk::require;
require!(
contract_owner == predecessor_account,
"ERR_NOT_OWNER"
);
require! это легкий макрос, представленный в почти SDK-RS v4 (и это также один из любимых макросов), чтобы заменить assert! макрос. Это работает как утверждение! в основном, за исключением одного небольшого отличия: он не может указывать формат! как таковой.
// assert! can specify format
assert!(
some_conditions,
"{}: {}"
error_type,
error_message
);

// require! cannot
require!(
some_conditions,
format!( // you need format! yourself
"{}: {}",
error_type,
error_message
)
);
И, как мы упоминали ранее, чтобы избежать форматирования строк, лучше всего жестко закодировать сообщение. Конечно, если вам это действительно нужно, просто пожертвуйте несколькими байтами, чтобы использовать формат! все в порядке: он занимает незначительное место, если вы не используете его широко.

Не используйте .expect() 

Вместо этого используйте unwrap_or_else. Один написал вспомогательную функцию в ближайшем вспомогательном ящике, который вы, возможно, захотите проверить.

В противном случае вы всегда можете поместить это во internal.rs:
fn expect_lightweight(option: Option, message: &str) -> T {
option.unwrap_or_else(||
env::panic_str(message)
)
}

// instead of:
let owner_id = self.owner_by_id
.get(&token_id)
.expect("Token not found");

// use this:
let owner_id = expect_lightweight(
self.owner_by_id.get(&token_id),
"Token not found"
);
Избегайте паники
Вот некоторые распространенные ошибки при панике:

 	Индексирование фрагмента за пределами границ. мой_срез[я]
 	Деление нуля: делимое / 0
 	unwrap(): предпочитайте использовать unwrap_or или unwrap_or_else или другие более безопасные методы, чтобы не паниковать. В Near-sdk также есть env::panic_str (env::panic устарела) для паники, и они упомянули здесь, что это может быть предпочтительнее. Тем не менее, вы также можете использовать старомодное сопоставление для работы с вещами и посмотреть, работает ли оно лучше, чем panic_str; если нет, то используйте panic_str для облегчения понимания кода. В противном случае вы можете переключиться на матч, если оно того стоит.

Попробуйте реализовать обходной путь, чтобы он возвращал None или принудительно не паниковал при разработке контракта.
Подходы нижнего уровня
Перейдите по ссылке в справочнике, чтобы узнать о других способах уменьшения размера контракта, не упомянутых здесь. (Материалы, упомянутые здесь, также в основном здесь не упоминаются).

Имейте в виду, что этот пример больше не обновляется, поэтому вам нужно вручную получить последнее обновление.

Список здесь:

 	Крошечный контракт (устаревший)
 	Контракт на фаззинг rs (вы можете просмотреть основную ветку, это фиксированная ветка, чтобы предотвратить ее удаление в будущем). Никто не знает, что делает этот контракт и что означает «фаззинг»; вам нужно понять себя.
 	Пример Евгения для быстрого взаимозаменяемого токена, и вы можете посмотреть видео на YouTube. Он реализует это без использования Near-SDK. Более неудачный опыт программирования, но оптимизация по размеру.

Aurora использует rjson в качестве облегченного контейнера для сериализации JSON. Он занимает меньше места, чем serde, в настоящее время упакованный с Rust SDK. Посмотрите этот пример,  читатель должен сам понять, как его использовать. Еще один вариант — ящик для мини-серий, пример здесь.
Инструмент Wasm-snip
Может быть полезно заменить функции, которые не используются, недоступной инструкцией. Обычно вам не нужно этого делать: только если вам действительно нужно сэкономить это пространство, вы можете пойти дальше.

Они упомянули, что этот инструмент также полезен для удаления инфраструктуры, вызывающей панику! 

Вы также можете запустить wasm-opt с флагом –dce после обрезки, чтобы эти отрезанные функции были удалены.
Заключение
Существует множество способов оптимизации контракта. Некоторые оптимизации выполняются легко без каких-либо изменений, другие имеют компромиссы, которые вы должны решить, стоит ли идти на компромиссы. В общем, если ваш контракт не слишком велик, что обычно является результатом написания слишком большого количества строк кода и который вам рекомендуется проверять на предмет необходимости написания кода; в противном случае должно быть достаточно простого использования, такого как wasm-opt и выбор постоянного хранилища.

NEAR SDK документация по уменьшению размера контракта

Уменьшение размера Wasm для Rust

### Burrow: пошаговое руководство пользователя

Это руководство было создано в сотрудничестве с NEAR Mates и NEAR Insights. Следите за ними в Твиттере, чтобы получать больше качественного контента о NEAR.
Что такое Burrow ?
Burrow — это децентрализованный автономный денежный рынок, не связанный с хранением, схож по своей природе с Aave и Compound.

Burrow стремится разблокировать ликвидность для процентных активов, в частности для производных инструментов первого уровня, таких как stNEAR и stETH. Пользователи Burrow смогут вносить stNEAR в качестве залога, а затем занимать больше NEAR для создания позиции с кредитным плечом или занимать стабильную монету для создания самоокупаемой позиции.


Как начать?

Начинаете впервые с NEAR?
Если у вас нет учетной записи NEAR, просто следуйте этому руководству, чтобы сначала настроить кошелек NEAR!

Подключите свой кошелек NEAR
Запустите приложение Burrow и подключите свой кошелек NEAR в правом верхнем углу.








Какой Supply
Пользователи могут вносить активы в протокол и получать проценты. 

Процентные ставки являются переменными и будут колебаться в зависимости от коэффициента использования данного актива. (Подробнее о модели процентной ставки здесь.)

Поддерживаемые активы при запуске:

 	NEAR
 	stNEAR (staked NEAR)
 	ETH
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (Burrow’s native token)

1. Перейдите в «Депозит» и выберите актив для взноса
Перейдите в раздел «Депозит» и нажмите на актив, который хотите внести.





2. Выберите сумму, которую хотите внести, и отправьте транзакцию.
3. После того, как вы внесли свои активы, у вас есть два варианта:




(1) Включите «Использовать в качестве залога». Это означает, что теперь вы сможете занимать активы на сумму, которую вы вложили в пул ресурсов.

Это также означает, что ваши средства потенциально могут быть ликвидированы. См. разделы «Фактор риска» и «Ликвидация» ниже для получения дополнительной информации.

(2) Просто поставляйте активы, а не «используйте в качестве залога». Это означает, что вы просто будете получать проценты от суммы, которую вы внесли в пул, без дальнейшего заимствования каких-либо активов. В этом случае ваши активы не подлежат ликвидации.

Вы всегда можете включить «использовать в качестве залога» позже на странице «Портфолио».
4. Подтвердите транзакцию в окне кошелька NEAR.




Теперь ваш депозит успешно зарегистрирован, и вы можете начать получать проценты. Число «APY» (годовой доход в процентах) говорит вам, сколько вы можете ожидать в вознаграждении в валюте BRRR за поставку активов.


Как взять взаймы


Теперь, когда вы внесли свои активы в пул ликвидности Burrow, вы также можете занять средства под него.
1. Назначьте свои активы в качестве залога
Чтобы заимствовать активы, вы должны сначала включить «Использовать в качестве залога». Если вы не включили кнопку «Использовать в качестве обеспечения» при внесении депозита, вы можете настроить свою позицию в разделе «Портфель» → «Настроить обеспечение». В Burrow вы можете выбрать, какие депонированные активы вы хотите использовать в качестве залога, а также настроить скорость обеспечения.





2. На странице «Занять» выберите актив, который хотите взять взаймы.




3. Введите сумму, которую вы хотите занять, учитывая полученный коэффициент здоровья.




Что такое «Фактор здоровья»?
Риск позиции можно понять с помощью фактора здоровья, который представляет собой комбинированные коэффициенты обеспечения заемных активов. 

 	Если фактор здоровья выше 100%, это означает, что счет находится в хорошем состоянии и не может быть ликвидирован. 
 	Если фактор здоровья меньше 100%, это означает, что счет может быть частично ликвидирован и не может занимать больше без погашения некоторой суммы существующих активов или предоставления дополнительных залоговых активов.

Более подробно узнать о том, как рассчитывается коэффициент здоровья можно здесь.

Что такое «Ликвидация?
Ликвидация — это когда ваша позиция принудительно закрывается протоколом (т. е. ваше обеспечение продается), потому что из-за изменений рыночных условий стоимость вашего обеспечения больше не является достаточной для обеспечения вашего долга на основе фактора здоровья, что означает, что вы рискуете оказаться не в состоянии погасить свой долг. Такой вид неплатежеспособности угрожает протоколу, и поэтому событие ликвидации запускается с помощью ботов, чтобы предотвратить это заранее.

Это может произойти, когда: 

 	Залог уменьшается в стоимости (например, цена wNEAR снижается с 20 до 10 долларов США)
 	Заемный долг растет в цене 

Подробнее о ликвидации можно прочитать здесь.

TL;DR
Когда ваш фактор здоровья:

 	Зеленый: ваши средства (как правило) безопасны.
 	Желтый: риск умеренный
 	Красный: ваши средства подвержены высокому риску ликвидации.

Предупреждение

 	Мы рекомендуем пользователям НЕ устанавливать коэффициент использования обеспечения на уровне 100%.
 	Фактор здоровья может измениться, если цена базовых активов изменится в значительной степени. Мы рекомендуем пользователям время от времени контролировать свой фактор здоровья, особенно в случае быстрых изменений рыночной конъюнктуры.

4. Отправьте и подтвердите транзакцию







Как управлять своими активами
Доступ к «Портфолио» в меню для просмотра и управления вашими депонированными и заемными активами.

Net APY
Ваш «чистый APY» — это ваш общий APY (годовой доход в процентах), который рассчитывает, сколько вы зарабатываете от депонирования активов (депозит APY) за вычетом суммы, которую вы должны протоколу от заимствования (заимствование APY).

Вывод средств
Выберите актив, который хотите вывести, и нажмите «Вывести».





Если вы хотите вывести все свои активы, сначала обязательно погасите свой долг. Если вывод на 100% не работает, уменьшите до 99% или около того и повторите попытку.

Если вы снимаете только часть своих активов и сохраняете свою долговую позицию, помните о том, как это изменит Фактор здоровья и уменьшит риск ликвидации.




Скорректировать обеспечение
В Burrow вы можете настроить ставку, по которой ваши активы обеспечиваются, и установить ее по-разному для каждого актива, который вы предоставляете. Это отличается от предыдущих протоколов кредитования, в которых залоговые ставки были установлены по умолчанию.

Вы можете установить желаемую ставку обеспечения при первом внесении своих активов или перейти в «Портфель» и нажать «Настроить обеспечение».




Погашение
Чтобы погасить непогашенную задолженность, перейдите в раздел «Портфель» и нажмите кнопку «Погасить».





Депозит NEAR, погашение с помощью wNEAR?
Из-за разницы в стандартах токенов Burrow (и большинство других децентрализованных приложений DeFi на NEAR) используют wNEAR («обернутый» NEAR), а не NEAR.

Когда вы вносите депозит, ваш NEAR будет автоматически обернут, поэтому вам не нужно ничего делать. Однако, если вы одолжили $wNEAR и хотите погасить его, вы должны сделать это как wNEAR. Используйте страницу обертывания Ref Finance, чтобы сначала обернуть NEAR в wNEAR.

В будущем Burrow будет поддерживать прямую перенос/развертку в самом приложении. Кроме того, функция переноса/распаковки будет интегрирована в кошелек NEAR, чтобы упростить решение этой проблемы.




Чтобы узнать о разнице между wNEAR и NEAR, см. наш FAQ.
Burrow работает в основной сети! Прочтите этот гайд, чтобы начать! 
Ожидание окончено! Первый денежный рынок NEAR наконец-то заработал в основной сети. Это означает больше ликвидности и DeFi…
https://burrowcash.medium.com/









Скоро: стейкинг xBRRR!
Вскоре стейкинг будет запущен на Burrow. Пользователи могут ставить свои BRRR и получать xBRRR, с помощью которых они могут получить доступ к повышенным вознаграждениям и участвовать в управлении протоколом. Следите за обновлениями!


Become a Burrow Hog

Dapp • Twitter • Discord • Docs

### NEAR Carteira

Guia para carteiras NEAR
No mercado de criptomoedas atual, o Ethereum é a plataforma de escolha para aplicativos descentralizados, contratos inteligentes e finanças descentralizadas. No entanto, o Ethereum tem vários problemas que são  obstáculos como altas taxas de gas e problemas significativos relacionados à escalabilidade. Portanto, embora o Ethereum possa ser o Numero Um, vários outros protocolos estão surgindo para desafiá-lo. 

O protocolo NEAR é um dos blockchains que emergiu como um verdadeiro desafiante ao domínio do Ethereum no espaço. A equipe da NEAR analisou as deficiências do Ethereum e criou um protocolo que vai direto para sua falha mais gritante, sua falta de escalabilidade e altas taxas de gás. A NEAR usa um processo chamado sharding, permitindo que o protocolo seja dimensionado exponencialmente. A NEAR também conseguiu arrecadar fundos significativos de alguns dos maiores capitalistas de risco, incluindo a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital e vários outros. Neste guia, veremos a NEAR e, em particular, a carteira NEAR. 
O protocolo NEAR
Fundado em 2018, o NEAR Protocol é uma plataforma de desenvolvimento descentralizada projetada para criar um ambiente perfeito para aplicativos descentralizados (dApps) e contratos inteligentes. O NEAR foi criado após analisar as deficiências dos protocolos existentes, principalmente o Ethereum. O protocolo se concentra em abordar esses problemas e procura se tornar a plataforma principal para aplicativos descentralizados e finanças descentralizadas. O uso de sharding da NEAR permite que o protocolo aumente exponencialmente, abordando os problemas de escalabilidade predominantes no espaço. 

O blockchain Proof-of-Stake da NEAR é extremamente amigável ao desenvolvedor, graças ao baixo custo e altamente escalável, e os desenvolvedores podem criar aplicativos descentralizados perfeitamente. O protocolo NEAR também possui vários outros recursos, como a carteira NEAR e outros componentes. Nosso foco neste artigo será na carteira NEAR, mas falaremos mais sobre isso um pouco mais tarde. A NEAR também utiliza o Doomslug, permitindo que os blocos atinjam a finalidade em segundos. Outras blockchains geralmente centralizam o processamento, limitando sua usabilidade a hardwares de ponta. Embora essa abordagem aumente a taxa de transferência, ela o faz apenas temporariamente. O NEAR é capaz de escalar linearmente, suportando bilhões de transações de forma descentralizada. 

NEAR foi criado pelo NEAR Collective, uma comunidade de pesquisadores e desenvolvedores. O foco do coletivo NEAR é o desenvolvimento e aprimoramento contínuos do protocolo. O coletivo também trabalhou no código inicial do Protocolo NEAR e na implementação da Rede NEAR. Enquanto o NEAR Collective está por trás do desenvolvimento do NEAR Protocol, este último opera de forma totalmente independente e é totalmente descentralizado, com o NEAR Collective incapaz de desligá-lo. 
Vantagens do protocolo NEAR

 	Os usuários do NEAR não precisam de extensões ou chaves complicadas do navegador para se registrar. Um simples e-mail e senha são suficientes para se registrar. 
 	Os contratos inteligentes NEAR são compatíveis com o WebAssembly Virtual Machine (WASM). 
 	O protocolo permite que os desenvolvedores implantem aplicativos blockchain escaláveis ​​e de alto desempenho. 
 	Uma fração das taxas de gás em comparação com outros, como o Ethereum. 

O que é uma carteira cripto
Antes de passar para a carteira NEAR, é essencial entender o que é uma carteira. Nos termos mais simples, as carteiras criptográficas armazenam com segurança suas chaves privadas, garantindo que sua criptomoeda seja segura e acessível. Você também pode usar carteiras de criptomoedas para realizar transações, enviar e receber criptomoedas ou até mesmo gastar suas criptomoedas. Ao selecionar uma carteira de criptomoedas, você tem várias opções para escolher. São carteiras de papel, carteiras de hardware e carteiras online. 
Carteiras quentes
As carteiras quentes são carteiras online que permitem que os usuários transfiram suas criptomoedas rapidamente. A maioria das trocas online tem suas próprias carteiras que os usuários podem acessar. As carteiras quentes são fáceis de acessar por meio de um celular ou desktop. Embora as carteiras quentes ofereçam conectividade fácil, elas também correm o risco de ameaças como hackers. Carteiras de desktop, carteiras online e carteiras móveis são exemplos de carteiras quentes. 
Carteiras frias
Uma carteira fria ou carteira de hardware é um dispositivo semelhante a um dispositivo USB onde os usuários podem armazenar suas chaves. A carteira é portátil e pode ser conectada a um laptop/desktop sempre que o usuário desejar acessar sua criptomoeda. As carteiras de hardware são muito menos propensas a ameaças como hackers ou qualquer outro ataque malicioso que possa ocorrer online. 
Carteiras de papel
Uma carteira de papel é essencialmente um pedaço de papel impresso contendo sua chave pública e chave privada. As chaves só podem ser acessadas através de um código QR. As carteiras de papel são usadas para armazenar uma quantidade significativa de criptomoedas, pois são consideradas extremamente seguras. 
A carteira NEAR
Os desenvolvedores do NEAR Protocol desenvolveram um aplicativo de carteira conveniente para tokens NEAR. A carteira é uma carteira no navegador e baseada na web que os usuários podem usar a carteira NEAR para criar e interagir com outras contas NEAR. A carteira também é necessária para interagir com o protocolo NEAR. A carteira é usada para armazenar os tokens NEAR e os padrões de token NEP21, que são suportados no blockchain NEAR. A carteira permite que os usuários enviem ou recebam tokens NEP21 e NEAR e interajam com aplicativos no protocolo. Ao usar a carteira NEAR, é essencial lembrar as seguintes informações. 

Um diferencial importante para contas NEAR é que NEAR usa contas legíveis por humanos e não um hash. Portanto, uma conta em NEAR não seria lida como 0x71C7656EC7ab88b098defB751B7401B5f6d8976F, mas como alice.near ou bob.near. As contas NEAR também podem criar subcontas, mas apenas a conta root pode criá-las. Outro diferencial crítico é que a maioria das blockchains tem um par de chaves pública/privada para cada conta. No NEAR, as contas podem ter vários pares de chaves associados a elas. Elas são chamadas de “chaves de acesso”. As chaves de acesso são de dois tipos, uma chave de acesso completo e uma chamada funcional. Uma chave de acesso total concede ao usuário controle total de sua conta NEAR . Por outro lado, a chamada funcional permite a assinatura de transações não monetárias. 

Endereço da carteira – O endereço da carteira é essencialmente uma sequência de caracteres ou números ou ambos usados ​​para enviar ou receber tokens usando a carteira NEAR. 

Chave privada e senha – A senha e a chave de segurança são um tipo de senha. A senha é composta por 12 palavras, enquanto a chave privada consiste em uma sequência de letras e números. Ambos são passos extremamente importantes quando se trata de recuperação de carteira. 
Criando uma carteira NEAR
A carteira NEAR permite que os usuários enviem e recebam tokens NEAR e apostem seus tokens NEAR. No entanto, você precisa criar uma carteira na NEAR para acessar esses recursos. Vamos começar.

O primeiro passo é acessar https://wallet.near.org/ . Assim que chegar a esta página, você terá duas opções, Criar Conta ou Importar Conta Existente. Vamos com a primeira opção.



 	Depois de clicar em “criar um ID”, você deve criar um nome de conta. Crie o nome da sua conta e, se o nome estiver disponível, clique em “Reservar ID da minha conta”.



 	O próximo passo é escolher como restaurar o acesso à sua conta. Existem três métodos de recuperação para você considerar. Você pode usar uma frase de semente, conectar uma carteira de hardware Ledger ou e-mail. O protocolo recomenda escolher uma frase inicial ou conectar uma carteira de hardware de contabilidade, pois são mais seguros do que proteger sua conta por e-mail. Vamos selecionar “Secure Passphrase” neste exemplo e seguir em frente.



 

 

 	É altamente recomendável que você use o Ledger Nano S ou X. O uso do ledger garante que suas chaves privadas sejam armazenadas com segurança em seu ledger. O Ledger fornece o mais alto nível de segurança ao usar a carteira NEAR. A configuração do seu ledger é simples, tudo o que você precisa fazer é baixar o Ledger Live e atualizar o firmware. Para instalar o aplicativo NEAR Ledger, abra o aplicativo Ledger Live, vá para Configurações e clique em Recursos experimentais. A partir daqui, você poderá ativar o modo de desenvolvedor. Concluída esta etapa, selecione Manager, Search for NEAR e clique em Install.
 	Depois de clicar em Secure Passphrase”, uma frase inicial aparecerá na tela, contendo 12 palavras mnemônicas. Você precisa guardar essas palavras com segurança, e a melhor maneira de fazer isso é simplesmente anotá-las em um livro ou papel e guardá-las em um local seguro. Por favor, NÃO faça uma captura de tela e salve a frase ou armazene-a em qualquer meio online. Sua frase-semente é só para você.



 	Confirme e verifique se você inseriu a frase inicial corretamente e concluiu o processo de configuração.
 	Depois de concluir a verificação de sua frase inicial, você será redirecionado para a tela "Acrescente saldo a sua conta". Este processo é necessário para obter o ID que você selecionou anteriormente. Existem várias maneiras de financiar sua conta. Você pode fazer isso sozinho acessando outra conta com saldo e enviando NEAR para o endereço de novo. Você também pode financiar sua conta usando Moonpay ou pedir a um amigo que tenha NEAR para enviar 1 NEAR para seu endereço temporário. Assim que a transação for confirmada, seu depósito inicial será refletido na carteira.
 	



 	Agora que sua conta foi criada com sucesso, clique em “Continuar para a conta” e você será redirecionado para a interface inicial da sua carteira.

Depois que sua conta for criada, é recomendável ativar o 2FA. Esta etapa é crítica, pois aumenta significativamente a segurança da sua conta de carteira NEAR. 
Criação de conta com Ledger
Vamos entender como você pode criar uma conta usando um dispositivo Ledger. 

 	Acesse wallet.testnet.near.org e selecione “Criar uma conta”.
 	Use a mesma etapa descrita no método anterior e reserve um ID de conta. Depois de inserir seu ID, clique em "Criar a conta". 
 	Em seguida, você terá que escolher seu método de segurança. É aqui que a criação da conta é diferente porque você usará seu dispositivo Ledger. Então, em vez de “Frase de recuperação”, selecione o “Ledger Nano S ou X”.



 	Depois de selecionar a opção Ledger, clique em "continuar" e você será solicitado a conectar seu dispositivo Ledger. 



 	Depois de conectar seu dispositivo Ledger, desbloqueie-o. Se você tiver o aplicativo NEAR instalado, selecione-o. Seu dispositivo Ledger dirá "Pending Ledger Review". Clique nos dois botões na parte superior do dispositivo e seu dispositivo solicitará "Usar carteira para visualizar contas". Quando esta mensagem aparecer, você pode ir em frente e clicar em “Continuar”. 
 	Depois de clicar em continuar, a chave pública aparecerá na tela do Ledger. Aprove a chave pública e confirme a operação no Ledger. 
 	Em seguida, você será solicitado a adicionar uma chave à sua carteira Ledger. Depois de clicar em "Aprovar" no Ledger. Assim que a operação for aprovada, sua conta foi criada com sucesso. 


Staking usando a carteira NEAR
A rede NEAR é executada por usuários que operam nós, conhecidos como validadores. A comunidade NEAR oferece suporte aos validadores por meio de staking. Os validadores mantêm um valor mínimo em stake, permitindo que permaneçam como validadores. Os detentores de token NEAR podem apostar com qualquer validador que escolherem, permitindo que ganhem recompensas da rede. A carteira NEAR possui uma interface de usuário de staking que é construída diretamente no aplicativo da web. 

Vamos entender como apostar usando a carteira NEAR. Staking usando a carteira NEAR é um processo bastante simples e compreende as seguintes etapas. 

 	Selecione a opção para fazer Stake na barra de navegação. Se você estiver no celular, encontrará a opção no menu suspenso. 
 	Selecione o botão que diz “Staking Validator”.
 	Selecione o validador de sua escolha na lista de validadores. Lembre-se, como um detentor de token NEAR; você pode apostar com qualquer validador de sua escolha. 
 	Depois de confirmar sua escolha, você pode selecionar “Stake with Validator”.
 	Depois de clicar em “Stake with Validator”, você será solicitado a inserir o número de tokens NEAR que deseja apostar. Depois de inserir o número de tokens, clique em "Enviar aposta".

Para concluir o processo de staking, você precisa confirmar duas transações - uma transação para selecionar o validador e outra para depositar e apostar com o validador selecionado. 
Unstaking da sua participação
Desfazer seu stake é extremamente simples. Basta ir ao painel de staking e selecionar o validador escolhido. Uma vez selecionado, clique em “Unstake” e confirme. Você poderá acessar e retirar sua aposta somente após 36-48 horas. Para retirar sua aposta, basta acessar a página do validador e clicar em “Retirar”.
Monitorar Informações de Staking
A interface da carteira NEAR permite que você escolha validadores e também permite visualizar informações como 

 	O valor total apostado – Isso permite que você visualize o número total de tokens NEAR com validadores que estão acumulando recompensas. 
 	Recompensas não reivindicadas – Estas são recompensas que foram ganhas, mas não foram retiradas do staking pool. Essas recompensas não reivindicadas são apostadas automaticamente novamente, aumentando o valor total apostado e as recompensas compostas. 
 	Tokens para retirada – Estes são tokens que foram retirados e estão prontos para serem retirados. 
 	Tokens pendentes de liberação – Esses tokens não apostados ainda aguardam a expiração da janela de 36 a 48 horas. 

Taxas do validador – As taxas do validador são pagas aos validadores para apostar em seu nome. As taxas do validador são cobradas nas recompensas obtidas e não no saldo do token em staking. 
Conectando sua carteira NEAR a um dApp no ​​NEAR
Conectar sua carteira NEAR a um aplicativo descentralizado no NEAR é extremamente simples. Você tem que ir ao Awesome NEAR e escolher um dos muitos dApps disponíveis. Clique no aplicativo desejado e você verá uma opção para “Entrar com a carteira NEAR” na interface. Depois de clicar, você receberá uma mensagem na tela informando que o dApp está solicitando permissão para acessar sua conta. Clique em “Permitir” e o dApp será automaticamente conectado ao dApp. 
Outras carteiras suportadas por NEAR 
Trust Wallet
A Trust Wallet é uma carteira não custodial e descentralizada que permite aos usuários armazenar suas criptomoedas. Os ativos são armazenados em um endereço digital acessível apenas pelo usuário, tornando-se uma forma segura e eficiente de armazenar ativos digitais. A carteira se concentra na simplicidade e facilidade de uso. É uma carteira de várias moedas de código aberto, orientada para a comunidade, capaz de armazenar quase todas as criptomoedas. Ele fornece aos usuários uma maneira conveniente de gerenciar suas criptomoedas e permite que eles controlem completamente suas chaves privadas.



A carteira foi adquirida pela Binance e é a carteira oficial da exchange Binance. A carteira permite que os usuários mantenham o controle total de seus ativos e chaves privadas armazenadas no dispositivo do usuário. Os desenvolvedores também podem criar dApps, sem complicações, como detalhes de implementação de baixo nível. A carteira também suporta staking na carteira, o que significa que os usuários podem ganhar recompensas em qualquer token Proof-of-Stake ou Delegated Proof-of-Stake suportado. A Trust Wallet permite que os usuários ganhem recompensas e adiciona continuamente mais stablecoins e criptomoedas.
Criando sua Trust Wallet
Criar sua carteira usando a Trust Wallet é um processo simples.

 	Acesse o site oficial da Trust Wallet.
 	Baixe e instale o aplicativo, abra o aplicativo e selecione “Criar uma nova carteira”.



 	O próximo passo é salvar sua frase inicial. Anote sua frase inicial de 12 palavras e certifique-se de anotar as palavras na ordem exata.
 	E é isso. Sua carteira de confiança foi criada.

Você também fazer Stakeing de NEAR com sua Trust Wallet simplesmente seguindo as etapas abaixo

 	Abra sua Trust Wallet e copie o endereço NEAR.
 	Faça login em https://near.github.io/account-lookup/ .
 	Digite seu endereço NEAR e obtenha os detalhes da sua conta.
 	Depois de obter os detalhes, você deve salvá-los.
 	Após concluir a etapa acima, abra Staking.Dokia.Cloud . Após abrir o link, selecione NEAR entre as opções disponíveis.
 	Depois de selecionar NEAR, todos os pools de staking disponíveis executando nós NEAR serão exibidos. Selecione a pool mais adequada para você.
 	Agora você terá que selecionar seu método para autorizar sua aposta no pool.
 	Para isso, clique em “continuar na interface web” e selecione Mnemonic como método de autorização. Uma vez selecionado, insira o Mnemônico da sua carteira de confiança.
 	Insira os detalhes da sua conta que você salvou anteriormente.
Após esta etapa, insira quantos tokens NEAR você gostaria de apostar.
 	Assine a transação e os tokens apostados serão enviados para o contrato inteligente do pool.
 	Se você deseja remover seu staking, basta acessar https://staking.dokia.cloud/addresses e clicar em “remover”.

Considerações finais
O ecossistema da NEAR permite que os usuários acessem uma série de NFTs, aplicativos descentralizados e soluções DeFi . O NEAR aborda as deficiências de blockchains como o Ethereum, oferecendo soluções para problemas de longa data, como congestionamento de rede, altas taxas de gás e taxas de processamento lentas. A carteira NEAR permite que os usuários criem e interajam com contas NEAR, permitindo que os usuários armazenem seus tokens NEAR e façam staking para ganhar recompensas. Esperamos que este guia forneça alguma clareza sobre o funcionamento da carteira NEAR e seus casos de uso.

### NEAR кошельки

Гайд по NEAR кошельку
На современном крипторынке Ethereum является предпочтительной платформой для децентрализованных приложений, смарт-контрактов и децентрализованных финансов. Однако у Ethereum есть несколько проблем, которые мешают, например, высокая плата за газ и серьезные проблемы связанные с масштабируемостью. Хотя Ethereum может быть номер один, на рынке появляется другие протоколы, которые бросают вызов Ethereum.

Протокол NEAR — это один из блокчейнов, который стал настоящим соперником Ethereum. Команда NEAR рассмотрела недостатки Ethereum и создала протокол, который устраняет его самый вопиющий недостаток — отсутствие масштабируемости и высокую плату за газ. NEAR использует процесс, называемый сегментированием, что позволяет протоколу экспоненциально масштабироваться. NEAR также удалось привлечь значительное финансирование от некоторых крупнейших венчурных капиталистов, включая a16z, Coinbase Ventures, Scalar Capital, Dragonfly Capital и некоторых других. В этом руководстве мы рассмотрим NEAR и, в частности, кошелек NEAR.
NEAR протокол
Протокол NEAR, основанный в 2018 году, представляет собой децентрализованную платформу разработки, предназначенную для создания цельной и почти идеальной среды для децентрализованных приложений (dApps) и смарт-контрактов. NEAR был создан после анализа недостатков существующих протоколов, в частности Ethereum. Протокол фокусируется на решении этих проблем и стремится стать основной платформой для децентрализованных приложений и децентрализованных финансов. Использование NEAR сегментации позволяет протоколу расширяться в геометрической прогрессии, решая проблемы масштабируемости.

Блокчейн NEAR Proof-of-Stake чрезвычайно удобен для разработчиков благодаря своей низкой стоимости и высокой масштабируемости, а разработчики могут легко создавать децентрализованные приложения. Протокол NEAR также имеет несколько других функций, таких как кошелек NEAR и другие компоненты. В этой статье мы сосредоточимся на кошельке NEAR, но об этом немного позже. NEAR также использует Doomslug (механизм консенсуса), позволяя блокам достигать завершенности за секунды. Другие блокчейны обычно централизуют обработку, ограничивая ее использование очень высокопроизводительным оборудованием. Хотя этот подход увеличивает пропускную способность, он делает это только временно. NEAR способен линейно масштабироваться, поддерживая миллиарды транзакций децентрализованным образом.

NEAR был создан NEAR Collective, сообществом исследователей и разработчиков. В центре внимания коллектива NEAR находится постоянное развитие и совершенствование протокола. Коллектив также работал над исходным кодом протокола NEAR и реализацией сети NEAR. Хотя за разработкой протокола NEAR стоит Коллектив NEAR, последний работает полностью независимо и полностью децентрализован, и даже Коллектив NEAR не может его закрыть.
Преимущества протокола NEAR

 	Пользователям NEAR не требуется никаких сложных расширений браузера или ключей для регистрации. Для регистрации достаточно простого адреса электронной почты и пароля.
 	Смарт-контракты NEAR совместимы с виртуальной машиной WebAssembly (WASM).
 	Протокол позволяет разработчикам развертывать масштабируемые и высокопроизводительные блокчейн-приложения.
 	низкая плата за газ по сравнению с другими, такими как Ethereum.

Что такое крипто-кошелек
Прежде чем перейти к кошельку NEAR, важно понять, что такое кошелек. Проще говоря, крипто-кошельки надежно хранят ваши личные ключи, гарантируя безопасность и доступность вашей криптовалюты. Вы также можете использовать криптовалютные кошельки для проведения транзакций, отправки и получения криптовалюты или даже для ее расходования. При выборе крипто-кошелька у вас есть несколько вариантов на выбор. Это бумажные кошельки, аппаратные кошельки и онлайн-кошельки.
Горячие кошельки
Горячие кошельки — это онлайн-кошельки, которые позволяют пользователям быстро переводить свою криптовалюту. У большинства онлайн-бирж есть собственные кошельки к которым могут получить доступ пользователи. Горячие кошельки легко доступны через мобильный или настольный компьютер. Хотя горячие кошельки предлагают простое подключение, они подвержены взлому. Настольные кошельки, онлайн-кошельки и мобильные кошельки являются примерами горячих кошельков.
Холодные кошельки
Холодный кошелек или аппаратный кошелек — это устройство, похожее на USB-устройство, на котором пользователи могут хранить свои ключи. Кошелек портативный и может быть подключен к ноутбуку/рабочему столу всякий раз, когда пользователь хочет получить доступ к своей криптовалюте. Аппаратные кошельки гораздо менее подвержены таким угрозам, как взлом или любая другая злонамеренная атака, которая может произойти в Интернете.
Бумажные кошельки
Бумажный кошелек — это, по сути, распечатанный лист бумаги, содержащий ваш открытый ключ и закрытый ключ. Доступ к ключам возможен только через QR-код. Бумажные кошельки используются для хранения значительного количества криптовалюты, поскольку они считаются чрезвычайно безопасными.
NEAR кошелек
Разработчики NEAR Protocol разработали удобное приложение-кошелек для токенов NEAR. Кошелек представляет собой встроенный в браузер и веб-кошелек, который пользователи могут использовать для создания кошелька NEAR и взаимодействия с другими учетными записями NEAR. Кошелек также необходим для взаимодействия с протоколом NEAR. Кошелек используется для хранения токенов NEAR и стандартов токенов NEP21, которые поддерживаются в блокчейне NEAR. Кошелек позволяет пользователям отправлять или получать токены NEP21 и NEAR и взаимодействовать с приложениями по протоколу. При использовании кошелька NEAR важно помнить следующую информацию.

Ключевым отличием учетных записей NEAR является то, что NEAR использует удобочитаемые учетные записи, а не хэш. Таким образом, учетная запись в NEAR будет читаться не как 0x71C7656EC7ab88b098defB751B7401B5f6d8976F, а как alice.near или bob.near. Учетные записи NEAR также могут создавать дочерние учетные записи, но их может создавать только учетная запись root. Еще одним важным отличием является то, что большинство блокчейнов имеют одну пару открытого/закрытого ключа для каждой учетной записи. В NEAR с учетными записями может быть связано несколько пар ключей. Они называются «ключи доступа». Ключи доступа бывают двух типов: ключ полного доступа и функциональный вызов. Ключ полного доступа предоставляет пользователю полный контроль над своей учетной записью NEAR. С другой стороны, функциональный вызов позволяет подписывать неденежные транзакции.

Адрес кошелька - по сути, представляет собой последовательность символов или цифр, или и то, и другое, которые используются для отправки или получения токенов с использованием кошелька NEAR.Закрытый ключ и парольная фраза - парольная фраза и ключ безопасности являются типом пароля. Парольная фраза состоит из 12 слов, а закрытый ключ состоит из последовательности букв и цифр. Оба являются чрезвычайно важными шагами, когда речь идет о восстановлении кошелька.
Создание кошелька NEAR
Кошелек NEAR позволяет пользователям отправлять и получать токены NEAR и размещать свои токены NEAR. Однако для доступа к этим функциям вам необходимо создать кошелек на NEAR. Давайте начнем.

 	Первый шаг — перейти на https://wallet.near.org/. Как только вы перейдете на эту страницу, у вас будет два варианта: «Создать учетную запись» или «Импортировать существующую учетную запись». Мы пойдем с первым вариантом.



 	После того, как вы нажмете «создать идентификатор», вы должны создать имя учетной записи. Создайте имя своей учетной записи и, если имя доступно, нажмите «Зарезервировать идентификатор моей учетной записи».



 	Следующим шагом является выбор способа восстановления доступа к вашей учетной записи. Вам следует рассмотреть три метода восстановления. Вы можете использовать seed-фразу, подключить аппаратный кошелек или электронную почту. Протокол рекомендует выбрать исходную фразу или подключить аппаратный кошелек, так как это более безопасно, чем защита вашей учетной записи по электронной почте. В этом примере мы выберем «Безопасную парольную фразу» и двинемся дальше.



 	Настоятельно рекомендуется использовать Ledger Nano S или X. Использование реестра гарантирует, что ваши личные ключи будут надежно храниться в вашем реестре. Ledger обеспечивает высочайший уровень безопасности при использовании кошелька NEAR. Настроить свою бухгалтерскую книгу очень просто, все, что вам нужно сделать, это загрузить Ledger Live и обновить прошивку. Чтобы установить приложение NEAR Ledger, откройте приложение Ledger Live, перейдите в «Настройки» и нажмите «Экспериментальные функции». Отсюда вы сможете включить режим разработчика. После завершения этого шага выберите «Менеджер», «Найдите NEAR» и нажмите «Установить».

 

 	После того, как вы нажмете «Безопасная парольная фраза», на экране появится исходная фраза, содержащая 12 мнемонических слов. Вы должны безопасно хранить эти слова, и лучший способ сделать это — просто записать их в книгу или на лист бумаги и хранить в надежном месте. Пожалуйста, НЕ делайте снимок экрана и не сохраняйте фразу и не храните ее на каком-либо онлайн-носителе. Ваша seed-фраза предназначена только для вас.



 	Подтвердите и убедитесь, что вы правильно ввели исходную фразу и завершили процесс установки.
 	После того, как вы завершите проверку своей сид-фразы, вы будете перенаправлены на экран «Пополнить счет». Этот процесс необходим для получения идентификатора, который вы выбрали ранее. Есть несколько способов, которыми вы можете пополнить свой счет. Вы можете сделать это самостоятельно, зайдя в свою учетную запись на бирже и отправив NEAR на одноразовый адрес для финансирования. Вы также можете пополнить свой счет с помощью Moonpay или попросить друга, у которого есть NEAR, отправить 1 NEAR на ваш временный адрес. Как только транзакция будет подтверждена, ваш первоначальный депозит будет отражен в кошельке.



 	Теперь, когда ваша учетная запись успешно пополнена, нажмите «Перейти к учетной записи», и вы будете перенаправлены на домашний интерфейс вашего кошелька.

После создания учетной записи рекомендуется включить 2FA. Этот шаг имеет решающее значение, поскольку он значительно повышает безопасность вашей учетной записи кошелька NEAR.
Создание учетной записи с помощью Ledger
Давайте разберемся, как вы можете создать учетную запись с помощью устройства Ledger.

 	Перейдите на wallet.testnet.near.org и выберите «Создать учетную запись».
 	Используйте тот же шаг, что и в предыдущем методе, и зарезервируйте идентификатор учетной записи. После того, как вы введете свой идентификатор, нажмите «Создать учетную запись».
 	Далее вам нужно будет выбрать метод безопасности. Здесь создание учетной записи отличается, потому что вы будете использовать свое устройство Ledger. Поэтому вместо «Фраза восстановления» выберите «Ledger Nano S или X».



 	После выбора опции Ledger нажмите «Продолжить», и вам будет предложено подключить устройство Ledger.



 	После подключения устройства Ledger разблокируйте его. Если у вас установлено приложение NEAR, выберите его. На вашем устройстве Ledger появится сообщение «Ожидает проверки Ledger». Нажмите обе кнопки в верхней части устройства, и ваше устройство предложит вам «Использовать кошелек для просмотра учетных записей». Как только появится это сообщение, вы можете продолжить и нажать «Продолжить».
 	Как только вы нажмете «Продолжить», открытый ключ появится на вашем экране Ledger. Подтвердите открытый ключ и подтвердите операцию в реестре.
 	Далее вам будет предложено добавить ключ в свой кошелек Ledger. После того, как вы нажмете «Подтвердить» в книге. Как только операция будет одобрена, ваша учетная запись будет успешно создана.


Стейкинг с использованием кошелька NEAR
Сеть NEAR управляется пользователями, управляющими узлами, известными как валидаторы. Сообщество NEAR поддерживает валидаторов посредством стейкинга. Валидаторы сохраняют минимальную сумму ставок, что позволяет им оставаться в качестве валидаторов. Владельцы токенов NEAR могут делать ставки с любым валидатором по своему выбору, что позволяет им получать вознаграждение в сети. Кошелек NEAR имеет пользовательский интерфейс для ставок, встроенный непосредственно в веб-приложение.

Давайте разберемся, как делать ставки с помощью кошелька NEAR. Стейкинг с использованием кошелька NEAR — довольно простой процесс, состоящий из следующих шагов.

 	Выберите вариант разбивки на панели навигации. Если вы используете мобильный телефон, вы найдете эту опцию в раскрывающемся меню.
 	Нажмите кнопку с надписью «Валидатор ставок».
 	Выберите нужный валидатор из списка валидаторов. Помните, как держатель токена NEAR; вы можете делать ставки с любым валидатором по вашему выбору.
 	После того, как вы подтвердите свой выбор, вы можете выбрать «Ставка с валидатором».
 	После того, как вы нажмете «Стейкинг с валидатором», вам будет предложено ввести количество токенов NEAR, которое вы хотите поставить. После того, как вы введете количество токенов, нажмите «Отправить ставку».

Чтобы завершить процесс стейкинга, вам необходимо подтвердить две транзакции: одну транзакцию для выбора валидатора, а другую — для внесения депозита и стейкинга с выбранным валидатором.
Отмена стэйкинга
Отменить ставку очень просто. Просто перейдите на панель управления стейкингом и выберите выбранный вами валидатор. После выбора нажмите «Отменить ставку» и подтвердите. Вы сможете получить доступ и снять свою ставку только по прошествии 36-48 часов. Чтобы вывести свою ставку, просто перейдите на страницу валидатора и нажмите «Снять».
Мониторинг информации о стэйкинге
Интерфейс кошелька NEAR позволяет выбирать валидаторов, а также позволяет просматривать такую информацию, как

 	Общая сумма стэйкинга — позволяет просмотреть общее количество токенов NEAR с валидаторами, которые накапливают вознаграждения.
 	Невостребованные вознаграждения — это вознаграждения, которые были заработаны, но не были выведены из пула ставок. Эти невостребованные вознаграждения автоматически ставятся снова, увеличивая общую сумму ставок и увеличивая вознаграждения.
 	Токены для вывода — это токены, которые не были размещены и готовы к выводу.
 	Токены, ожидающие выпуска. Эти неразмещенные токены все еще ожидают истечения 36-48-часового окна.
 	Сборы валидаторов — сборы валидаторов выплачиваются валидаторам, которые делают ставки от вашего имени. Комиссия валидаторов взимается с заработанных вознаграждений, а не с баланса токенов, поставленных валидаторам.

Подключение вашего кошелька NEAR к децентрализованному приложению на NEAR
Подключить ваш кошелек NEAR к децентрализованному приложению на NEAR очень просто. Вам нужно зайти на Awesome NEAR и выбрать одно из множества доступных приложений dApp. Нажмите на нужное приложение, и вы увидите опцию «Войти с NEAR Wallet» в интерфейсе. Как только вы нажмете, вы получите сообщение на экране о том, что dApp запрашивает разрешение на доступ к вашей учетной записи. Нажмите «Разрешить», и dApp будет автоматически подключен к dApp.
Другие кошельки, поддерживаемые NEAR
Trust кошелек
Trust Wallet — это децентрализованный кошелек, не связанный с хранением, который позволяет пользователям хранить свои криптовалюты. Активы хранятся по цифровому адресу, доступному только пользователю, что делает его безопасным и эффективным способом хранения цифровых активов. Кошелек Trust ориентирован на простоту и удобство использования. Кошелек представляет собой управляемый сообществом мультивалютный кошелек с открытым исходным кодом, способный хранить практически все криптовалюты. Он предоставляет пользователям удобный способ управления своими криптовалютами и позволяет им полностью контролировать свои закрытые ключи.



Кошелек был приобретен Binance и является официальным кошельком биржи Binance. Кошелек позволяет пользователям сохранять полный контроль над своими активами и закрытыми ключами, хранящимися на устройстве пользователя. Разработчики также могут создавать dApps без каких-либо сложностей, таких как низкоуровневые детали реализации. Кошелек также поддерживает стейкинг на кошельке, что означает, что пользователи могут получать вознаграждение за любые поддерживаемые токены Proof-of-Stake или Delegated Proof-of-Stake. Trust Wallet позволяет пользователям получать вознаграждения и постоянно пополняется новыми стейблкоинами и криптовалютами.
Создание вашего кошелька Trust
Создание кошелька Trust Wallet — простой процесс.

 	Перейдите на официальный сайт Trust Wallet.
 	Загрузите и установите приложение, откройте приложение и выберите «Создать новый кошелек».



 	Следующим шагом будет сохранение исходной фразы. Запишите исходную фразу из 12 слов и убедитесь, что вы записываете слова в точном порядке.
 	И это все. Ваш Trust Wallet создан.

Вы также можете стэйкать NEAR с помощью своего кошелька Trust, просто выполнив следующие действия.

 	Откройте свой кошелек Trust и скопируйте адрес NEAR.
Войдите на https://near.github.io/account-lookup/.
Введите свой адрес NEAR и получите данные своей учетной записи. Как только вы получите детали, вы должны сохранить их.
 	После выполнения вышеуказанного шага откройте Staking.Dokia.Cloud. После открытия ссылки выберите NEAR из доступных вариантов.
 	Как только вы выберете NEAR, отобразятся все доступные пулы ставок, на которых запущены узлы NEAR. Выберите бассейн, наиболее подходящий для вас.
Теперь вам нужно будет выбрать способ авторизации вашей доли в пуле.
 	Для этого нажмите «перейти в веб-интерфейс» и в качестве метода авторизации выберите Мнемоника. Как только это будет выбрано, введите мнемонику вашего Trust Wallet.
 	Введите данные своей учетной записи, которые вы сохранили ранее.
 	После этого шага введите, сколько токенов NEAR вы хотите поставить.
 	Подпишите транзакцию, и поставленные токены будут отправлены на смарт-контракт пула.
 	Если вы хотите удалить свою ставку, просто перейдите на https://staking.dokia.cloud/addresses и нажмите «Удалить».

Заключительные мысли
Экосистема NEAR позволяет пользователям получать доступ к множеству NFT, децентрализованных приложений и решений DeFi. NEAR устраняет недостатки блокчейнов, таких как Ethereum, предлагая решения давних проблем, таких как перегрузка сети, высокая плата за газ и медленная плата за обработку. Кошелек NEAR позволяет пользователям создавать учетные записи NEAR и взаимодействовать с ними, позволяя пользователям хранить свои токены NEAR и делать ставки для получения вознаграждения. Мы надеемся, что это руководство внесет определенную  ясность в работу кошелька NEAR и возможные варианты его использования.

### DeepGreen Beta Testers Feedback

Follow @LearnNEAR on Twitter

Beta test sprint starts: April 14, 9 am ET
Beta Test sprint ends: April 17, 11pm ET.
Introduction
Welcome to the field acceptance test of our web application and NEAR Protocol integration.

Carbon Emissions can be offset by purchasing private CO2 certificates. Unfortunately this market suffers from fraud and untransparent processes. We are here to help and we have NEAR Protocol to help us do it! We offer CO2 Certificates originating from Construction and Infrastructure projects where environmentally-friendly processes and materials were incentivised.

The central smart contract during testing will be report.deepgreencc.near. The goal of this test is to learn how intuitive our app is and to understand if something is not clear or even not working.

Our Application enables businesses to purchase CO2 Compensation Certificates and use these certificates in their report which is mandatory in Germany since this year. During testing, all requests will be accepted within 10 seconds automatically.
Requirements:


 	Visit our Landing Page https://en.deepgreen.cc/  and navigate to our web App

 	Create an Account by making up credentials and an imaginary company


 	Request the purchase of CO2 Certificates

 	Request the usage of certificates by creating a new CO2 report

 	View the report you created by going back to the dashboard where there is a table for transactions. Above the table there is a toggle switch to view usages and purchases. When selecting usages all created reports are being shown the the name being a link to the specific report page.


 	Now inspect the NEAR blockchain to verify the data being written is correct regarding the report name, company name and certificate quantity
 	Verify the projects whose certificates were used to create the reports compensation by clicking on the links to the projects pages in the report window

 	Take a screenshot
 	Tweet about this with a screenshot "I just verified Carbon Credit Certificate issued by DeepGreen, project from @LearnNEAR LNC Barrel" +link to transaction
 	Congratulations!
You have just purchased CO2 Compensation for your company and used them in your report. This transaction is saved on the NEAR blockchain and you can show it to your customers anytime, increasing transparency! Furthermore, you have used one of the most environmentally friendly blockchains around to do so.
Please share with us how the process has worked out for you. Tell us if at any step you did not quite understand what was happening and why, or if anything outright didn't work.Thank you for participation, please submit the NEAR explorer URL and your company name so we can verify your completion.

Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy testing!



 
Post Beta Tests Notes:
We are a Startup combining the trustless nature of blockchain in the form of the environmentally friendly NEAR Protocol with Carbon Offsetting.

For this we have developed a webapp and applied for the LNC Barrel Program, where we get support, contacts and access to funding for our development.

But its not only funding and good ideas that are required, but it's also Beta Testing. During development its important to get feedback from outsiders as often as possible in order to understand whether the development goes in the right direction, the UI is intuitive and any bugs have sneaked their way into the main branch.

For this we got help from LNC, where compensation was offered to constructive feedback for using our app. Within 3 days we received numerous valuable feedback statements which helped us greatly understand how our customers would feel and react to our platform. 

We can strongly encourage everyone building with NEAR Protocol to apply for this support whilst leveraging one of the most advanced blockchains around.

### O que você pode fazer com a Near Protocol

No mundo das criptos, o Ethereum domina como a plataforma principal quando se trata de contratos inteligentes, aplicativos descentralizados e finanças descentralizadas. No entanto, o Ethereum não é o único protocolo no espaço de contratos inteligentes e aplicativos descentralizados, como vários outros protocolos na imagem. Embora o Ethereum seja a plataforma número um no espaço, ele possui algumas deficiências, como taxas de gás extremamente altas e problemas significativos de escalabilidade.

A NEAR Protocol é uma das blockchains que podem rivalizar com o Ethereum, indo direto para a falha mais gritante do protocolo, sua falta de escalabilidade, usando algo conhecido como sharding. Isso permite que a NEAR aumente sua escalabilidade exponencialmente. O protocolo também levantou fundos significativos e conta com o fundo a16z da Andreessen Horowitz como um de seus patrocinadores.
Um olhar mais atento ao protocolo NEAR
O protocolo NEAR é uma plataforma de desenvolvimento descentralizada que foi fundada em 2018. A NEAR cria o ambiente perfeito para aplicativos descentralizados e contratos inteligentes, concentrando-se nas deficiências de outros protocolos no mesmo espaço. Já mencionamos as deficiências anteriormente. A NEAR utiliza o protocolo NEAR, uma blockchain Proof-of-Stake que é conhecida por ser pública, amigável ao desenvolvedor e fragmentada (shards). O protocolo é uma plataforma de baixo custo e altamente escalável que os desenvolvedores podem utilizar para criar aplicativos descentralizados (dApps). Outros recursos que os desenvolvedores podem usar incluem aplicativos de carteira e componentes de interoperabilidade que permitem que os desenvolvedores utilizem facilmente o ecossistema NEAR e criem aplicativos. 

A NEAR apresenta o Doomslug, mecanismo de geração de blocos proposto em 2019. Permite uma finalidade prática; significando que os blocos podem atingir a finalidade em segundos. O NEAR funciona na mesma tecnologia que alimenta tecnologias como o Bitcoin e o combina com recursos como fragmentação de banco de dados, ou  sharding. Outros blockchains centralizam o processamento, o que significa que é limitado a hardware de ponta. Essa abordagem fornece apenas um impulso temporário para a taxa de transferência. Por outro lado, a NEAR é dimensionada linearmente e pode suportar até bilhões de transações de maneira completamente descentralizada.
Características importantes da NEAR
O protocolo NEAR é desenvolvido pela NEAR Collective. Algumas das características do protocolo são as seguintes.               

 	NEAR como protocolo é simples de usar, e os desenvolvedores podem criar aplicativos com facilidade e rapidez nele


 	NEAR permite escalabilidade quase infinita graças ao uso de sharding


 	Near é um protocolo de camada 1. 

Entendendo a NEAR Collective
O NEAR Collective, uma comunidade de pesquisadores e desenvolvedores, está por trás do desenvolvimento do protocolo NEAR. O coletivo trabalha continuamente para desenvolver e melhorar o protocolo NEAR e também trabalhou em projetos como a escrita do código inicial do protocolo e a implementação da rede NEAR. O protocolo NEAR opera de forma totalmente independente e descentralizado, e mesmo os desenvolvedores e pesquisadores que o construíram não podem desligá-lo.                                                

O Coletivo NEAR consiste na Fundação NEAR, que é uma organização sem fins lucrativos que cria um ecossistema em torno do protocolo NEAR. O Coletivo NEAR auxilia nas atividades de desenvolvimento e governança do protocolo. O Protocolo NEAR é apenas um dos vários projetos do coletivo.
O que você pode fazer no protocolo NEAR
A Near Protocol permite que os usuários acessem diversos projetos e protocolos que vão desde NFTs até DAOs e DeFi. A NEAR desenvolveu um ecossistema nativo vibrante com vários projetos que já estão em execução no protocolo, enquanto mais projetos estão em andamento.
Introdução ao NEAR
Para começar a usar a NEAR, a primeira coisa que você precisa é de uma conta NEAR . Você pode aprender como configurar uma conta NEAR aqui. Depois de criar sua conta NEAR, você pode conectá-la à sua carteira NEAR, que permite fazer chamadas de contrato para o blockchain, enviar ou receber fundos e configurar os nós locais. Para criar uma conta NEAR, você precisa ter pelo menos 0,2 NEAR para poder manter seu lugar na rede NEAR.
O token NEAR
Existem duas maneiras de obter tokens NEAR; você pode ganhá-los ou comprá-los diretamente. Os tokens NEAR podem ser obtidos participando da rede, participando de contratos de desenvolvimento ou executando nós da comunidade que podem permitir que as pessoas da comunidade construam no NEAR. Você também pode comprar tokens NEAR que estão disponíveis em todas as principais exchanges de criptomoedas.
O que você pode fazer com tokens NEAR
O token NEAR permite que você execute várias tarefas; você pode transferir tokens NEAR entre contas e acompanhar as transações no Block Explorer. As taxas de transação na NEAR são extremamente baixas, permitindo que você mova tokens facilmente. Você também pode enviar NEAR para qualquer pessoa que precise criar uma conta NEAR usando o NEAR Drops. Os tokens NEAR também permitem que você acesse um número crescente de aplicativos que estão sendo criados na NEAR. Eles também podem comprar, publicar ou comercializar NFTs e arte digital em NEAR ou criar criações de arte coletiva. 
Fazendo o Staking
A comunidade NEAR pode apoiar validadores por meio de Staking. Validadores são aqueles usuários que operam os nós, que ajudam a rodar a rede NEAR. Os validadores são obrigados a manter um valor mínimo de tokens NEAR em staking, bloqueados, para que possam permanecer como validadores. Os detentores de tokens no NEAR podem fazer o staking com um validador de sua escolha e ganhar uma recompensa dos tokens gerados pela rede. Os usuários podem participar do staking pelas seguintes etapas:

 	Selecione Staking na barra de navegação e escolha um validador
 	Confirme as opções que você selecionou e, em seguida, selecione “Stake with Validator” 
 	Escolha o número de tokens NEAR que você deseja apostar e clique em “Enviar”.

O que você pode fazer no ecossistema NEAR
NFTs 
NFTs vêm ganhando uma atenção significativa. Embora o Ethereum seja a principal rede quando se trata de NFTs, sua mudança para o mainstream também colocou em foco as altas taxas de gas do Ethereum, tornando-o bastante impraticável. A NEAR Protocol é uma alternativa viável e já possui diversos projetos em execução em sua plataforma. A escalabilidade do protocolo garante que o desenvolvimento de dApps seja rápido e fácil. Atualmente, existem 19 plataformas descentralizadas para NFTs na rede NEAR . A NEAR também é significativamente mais rápida do que outros concorrentes no espaço NFT e tem custos de transação extremamente baixos.  

O protocolo NEAR pode ser descrito como a plataforma perfeita para NFTs e tem várias vantagens sobre outras plataformas NFT e até mesmo Ethereum. O protocolo NEAR pode processar transações muito mais rápido que o Ethereum e, ao contrário do Ethereum, não sofre com altas taxas de gas ou congestionamento de rede. As transações no NEAR são processadas quase instantaneamente com um custo insignificante associado. Todos esses fatores tornam o NEAR ideal para compra e venda de NFTs e atuam como um incentivo para que diferentes projetos construam seus NFTs na NEAR. Existem vários projetos NFT já rodando na NEAR, como Mintbase e Paras .
Crie e venda NFTs através do Mintbase
Os usuários do protocolo NEAR podem usar vários marketplaces NFT para comprar, vender ou criar NFTs. Um desses projetos, o Mintbase, permite aos usuários criar um NFT e disponibilizá-lo para venda em marketplaces como o OpenSea. Os usuários podem criar contratos inteligentes para limitar a transferibilidade dos tokens, o que ajuda a evitar fraudes e a transferência ilegal de ativos. 

A Mintbase mudou do blockchain Ethereum para o protocolo NEAR devido às altas taxas de gas do primeiro. Inicialmente, as taxas de gas no Ethereum eram baixas e os usuários podiam implantar rapidamente, no entanto, com o aumento do uso e congestionamento no Ethereum, os custos do gas começaram a ficar fora de controle. Existem várias outras razões pelas quais o Mintbase escolheu o NEAR Protocol. 

 	A NEAR usa Rust ou AssemblyScript para codificar contratos inteligentes, permitindo que os desenvolvedores escrevam o código facilmente. 
 	A NEAR possui endereços legíveis por humanos para contratos e contas inteligentes. 
 	Os desenvolvedores podem usar NEAR Drops e usuários integrados com facilidade e rapidez. Eles também podem pagar por suas contas NEAR e enviar ou receber tokens NEAR. 
 	Os desenvolvedores podem usar a ponte ETH-NEAR Rainbow Bridge e mover seus ativos rapidamente. 
 	Projetos DeFi, como Balancer e Aave, também estão na NEAR, facilitando qualquer potencial integração futura. 

Crie, troque e colete cartões de arte digital
Paras é um marketplace de itens digitais construído no protocolo NEAR que fornece aos usuários uma solução para itens colecionáveis ​​tradicionais antigos. Ele valida a propriedade através do blockchain por meio de transações rápidas e baratas. Também se diferencia por oferecer coleções em vez de lançamentos independentes. Paras é benéfico para os colecionadores, pois reduz significativamente a carga dos colecionadores, garantindo que seus colecionáveis ​​não se desgastem. Artistas e colecionadores podem acessar facilmente o mercado de colecionáveis. 

Desde o lançamento do Paras, vimos artistas ganharem mais de US$ 25.000, com a plataforma sendo capaz de processar mais de 700 transações que permitiram facilitar um volume de negociação de mais de US$ 35.000. Atualmente, a plataforma conta com mais de 70 artistas e 80 colecionadores. O protocolo NEAR e o Paras são uma ótima opção porque os criadores de NFT estão procurando alternativas ao Ethereum com suas altas taxas de gás. As transações na NEAR custam quase nada e podem ser concluídas em segundos, enquanto o Rainbow Bridge garante a interoperabilidade entre Ethereum e NEAR. 
Explorar e leiloar coleções de NFT
Hip-Hop Heads resulta de uma colaboração entre o NEAR Protocol, Ed Young e o Universal Hip-Hop Museum. A coleção NFT apresenta artistas dos anos 70 até o presente e apresenta 47 dos maiores artistas do gênero rap. A coleção homenageia os dois artistas mencionados e também marca o 47º ano da era Hip-Hop. 

NEAR permite que a coleção seja mais acessível à comunidade, e o leilão apresenta novas edições de todos os 103 Hip-Hop Heads. Os membros da comunidade podem comprar facilmente os NFTs por meio de um cartão de crédito sem nenhum sistema de integração complicado.

Os usuários do protocolo podem acessar vários outros projetos NFT na NEAR, como Metamon, WebAssembly Music, Snark.Art etc. O Metamon cria um universo de monstros que os usuários podem capturar, evoluir e brincar. Os monstros são classificados como criaturas de edição limitada em extinção que um seleto grupo de colecionadores de NFT pode adotar. Os colecionadores podem combinar dois do mesmo tipo de Metamon e vê-lo evoluir para um Metamon mais raro e poderoso. 

WebAssembly Music é a primeira música que foi armazenada no blockchain como um NFT. A música foi criada por Peter Salomonsen e publicada no protocolo NEAR. A música estava entre as primeiras que foram renderizadas para um binário executável do WebAssembly. Os usuários podem executar o arquivo binário WASM e obter os dados brutos de áudio por meio de um 




	

	
	
		
			
				NEAR usa o seguinte para codificar contratos inteligentes:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust ou AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi na NEAR 
Vamos primeiro entender que é DeFi. DeFi ou Finanças Descentralizadas se referem a um sistema financeiro completamente descentralizado que utiliza blockchains como o Ethereum. Ele consiste em ativos como aplicativos descentralizados, protocolos DeFi e contratos inteligentes. O objetivo por trás do DeFi é criar um sistema financeiro de código aberto, totalmente sem limitações e descentralizado que opere independentemente da jurisdição de qualquer autoridade governamental central ou terceirizada. O DeFi oferece aos usuários acesso fácil a serviços financeiros e é especialmente benéfico para indivíduos que não têm acesso a serviços bancários.

NEAR está trazendo DeFi para as massas com vários projetos ao vivo no protocolo, com projetos que vão desde projetos DeFi, DEXs, Oracles, etc. Vejamos como você pode usar alguns dos projetos no NEAR. 
Acesse quase todas redes compatíveis com a Rainbow Bridge
A Rainbow Bridge atua como uma ponte entre NEAR e Ethereum e é um protocolo sem limitações e de confiança mútua (permissionless e trustless) que conecta duas blockchains diferentes. Os usuários podem implantar facilmente uma nova ponte ou ingressar em uma ponte existente sem precisar de aprovação de terceiros. A Rainbow Bridge permite que qualquer informação que possa ser usada na NEAR seja utilizada em contratos inteligentes Ethereum e vice-versa. Isso também permite que os usuários votem com ETH em uma DAO baseada em NEAR sem passar pelo Ethereum. 

O Rainbow Bridge é facilmente acessível para os usuários, graças a um design intuitivo e integrado diretamente através da MetaMask. A Rainbow Bridge também pode ser reaproveitada e conectar NEAR com quase todas as cadeias compatíveis com Ethereum. A Rainbow Bridge também está procurando oferecer suporte a cadeias não EVM, como Bitcoin. 
SputnikDAO 
As DAOs são extremamente importantes quando se trata da estratégia de governança de um protocolo. A SputnikDAO capacita comunidades e indivíduos que compõem o ecossistema NEAR, atuando como a infraestrutura para DAOs no protocolo NEAR e permite que indivíduos e outros projetos lancem DAOs, atualizem contratos inteligentes de protocolo e configurem governança para gerenciamento de tesouraria com facilidade. A SputnikDAO também permite que os projetos configurem governança de várias assinaturas ou emitam tokens de governança ou combinem os dois e os usem juntos. 
Crie e lance NFTs de áudio com DAOrecords
A DAOrecords planeja se tornar a primeira gravadora descentralizada do mundo e atualmente emprega um modelo híbrido. O projeto tem experimentado continuamente com NFTs de áudio, com o projeto tendo lançado 350 NFTs e trabalhado com mais de 60 artistas até agora. A DAOrecords quer controlar a música de volta para os artistas que as criaram e mudar a maneira como eles interagem com seus fãs. 

Artistas independentes podem lançar novas músicas usando NFTs de áudio e serviços de streaming da DAOrecords. Eles também podem cunhar seus NFTs de áudio. A DAOrecords já publicou um NFT de áudio interativo chamado “MintTape Vol 1”.
Acessar Empréstimos Através da Aave
A Aave implementa uma estratégia de empréstimo baseada em pool de liquidez em vez de uma estratégia descentralizada ponto a ponto. Empréstimos na Aave não são correspondidos individualmente. Em vez disso, eles contam com fundos agrupados e garantias junto com os valores emprestados. A Aave foi lançada em novembro de 2017 como uma plataforma de empréstimo peer-to-peer e renomeado Aave em setembro de 2018. O protocolo foi lançado na Mainnet e tem quase US$ 6 bilhões bloqueados em contratos inteligentes e está entre os 3 principais projetos no ecossistema DeFi.

A Aave oferece flash loans, que são basicamente empréstimos sem garantia que são emprestados e pagos em uma única transação, o que significa que os usuários não exigem nenhuma garantia para o empréstimo, enquanto o mutuário devolve o valor original emprestado e uma pequena taxa. Aave introduziu flash loans, onde qualquer pessoa pode emprestar liquidez, usá-la com outros protocolos e reembolsá-la em uma única transação.Flash loans são essenciais no espaço DeFi, pois dão aos indivíduos acesso à liquidez sem a necessidade de garantias. 
Acesse feeds de dados com o Chainlink
A Chainlink foi desenvolvida como uma rede de oráculos descentralizados que permite que contratos inteligentes transfiram dados entre blockchains e sistemas off-chain de forma confiável e segura. Ele utiliza uma rede descentralizada de oráculos independentes para recuperar dados de vários recursos diferentes, agregar os dados e, em seguida, entregar os dados validados ao contrato inteligente, que aciona a execução do contrato. 

O protocolo Chainlink também fornece segurança multicamada para garantir total confiança na rede de oráculos, permitindo a construção e execução dessas redes, onde os usuários podem se conectar a elas sem precisar depender de outras redes de oráculos. 

 	Assinatura de Dados – Os dados de entrada dos oráculos Chainlink são assinados usando uma assinatura cartográfica exclusiva que permite aos usuários provar que os dados se originaram de um nó oracle específico. 
 	Dados de alta qualidade - Chainlink fornecerá contratos inteligentes com dados provenientes de fontes externas, como provedores de dados externos. 
 	Blockchain Agnostic – Chainlink é capaz de rodar nativamente em qualquer blockchain, suportando blockchains públicos, blockchains corporativos, etc. 




	

	
	
		
			
				DAOrecords permite cunhar:
			
		

		
					

		
			
			
			
			Arte digital
		
			
			Gatos digitais
		
			
			NFTs de áudio
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora – Uma experiência Ethereum de segunda camda
A Aurora no protocolo NEAR fornece uma experiência de segunda camada Ethereum. Os desenvolvedores podem usar isso para utilizar ferramentas em redes adicionais enquanto aproveitam os recursos da NEAR Protocol, como taxa de gas baratas e o sharding. É executado em dois componentes críticos, a Aurora Bridge e a Aurora Engine. Aqui estão alguns recursos que a Aurora traz:

 	A capacidade de processar milhares de transações por segundo, um aumento de 50 vezes em relação ao Ethereum. 
 	Um tempo de finalização de bloco de 2 segundos, em comparação com o tempo de confirmação de bloco único de 13 segundos no Ethereum. 
 	Permite que o EVM seja acessado horizontalmente com a abordagem de sharding da NEAR.
 	As taxas na Aurora são 1000x mais baixas do que as do Ethereum. 
 	O Aurora oferece compatibilidade intransigente com o Ethereum no protocolo NEAR. 

Considerações finais 
A NEAR está criando um ecossistema onde os usuários podem acessar facilmente dApps, NFTs e DeFi. O protocolo é mais rápido e mais barato que outros players no espaço criptográfico. A NEAR oferece soluções para problemas como velocidades de processamento lentas, congestionamento de rede e altas taxas de gas utilizando sharding, dando à plataforma uma escalabilidade significativa sem comprometer a segurança do protocolo.




	

	
	
		
			
				Este protocolo permite que usuários da NEAR acessem qual protocolo de segunda camada do Ethereum:
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			Plasma
		
	
		

		
		
			
				Correct!
				Wrong!

### Conta na NEAR - Guia rápido

Introdução a sua conta na NEAR

 	

 	A NEAR usa nomes, ou identificadores de conta que podem ser lidos por humanos no formato “nome.near”. Por exemplo, maria.near ou jane.near.
 	O sistema de contas NEAR é semelhante ao sistema de domínio do site no sentido de que uma conta pode criar quantas subcontas forem necessárias. Por exemplo, uma conta com o nome maria.near pode criar uma conta como sub.maria.near e, por sua vez, pode criar as contas first.sub.maria.near, second.sub.maria.near e assim por diante.
 	NEAR Wallet ( https://wallet.near.org/ ) ( NEAR Protocol wallet), NEAR Faucet ( https://faucet.paras.id/ ) (uma faucet para usuários de Ethereum e Metamask) ou near-cli ( https: //github.com/near/near-cli ) (interface de linha de comando que oferece funcionalidade para integração NEAR) podem ser usados ​​para criar uma conta.
 	Na NEAR você pode criar uma conta e enviá-la para um amigo ou assinante com com a ajuda do serviço https://nearnames.com .
 	Você pode verificar as informações da conta no NEAR Explorer ( https://explorer.near.org/ ), bem como na NEAR Wallet
 	Além de contas visíveis (nome.near), o ecossistema NEAR também suporta a criação de contas invisíveis com a ajuda de near-cli (elas se parecem com endereços Bitcoin e Ethereum). Você pode encontrar um guia detalhado em inglês aqui
 	Cada conta no sistema pode ter apenas 1 contrato inteligente. Para aplicativos que exigem uso de várias contratos inteligentes, contas filhas podem ser usadas. Por exemplo, contract_1.maria.near, contract_2.maria.near, etc.

Existem contas de desenvolvedor ( https://docs.near.org/docs/concepts/account#dev-accounts ) no ecossistema NEAR. Sua especialidade reside no fato de que eles são feitos para testar e depurar contratos inteligentes.

Conta NEAR - Chaves

 	

 	NEAR como a maioria das outras blockchains é baseado em criptografia com uma chave aberta. Ele se baseia em pares de chaves, cada uma das quais consiste em uma chave aberta (chave pública ) combinada com uma chave fechada (chave privada ).
 	NEAR usa a chave aberta para identificação e a chave fechada para assinar transações (confirmação de titularidade da conta durante a criação da transação).
 	Na NEAR existem 3 tipos de chaves. Chaves de acesso são para assinar transações da conta, chaves validadoras permitem operações relacionadas à validação de rede, chaves de nó (nó de rede) permitem comunicação de baixo nível entre nós na rede.
 	As chaves podem ser armazenadas em 3 armazenamentos diferentes. InMemoryKeyStore – armazenamento de memória, usado para cenários temporários. BrowserLocalStorageKeyStore – armazenamento de navegador local não criptografado, usado para trabalhar com aplicativos no navegador. UnencryptedFileSystemKeyStore – armazenamento não criptografado no sistema de arquivos, usado ao trabalhar com near-cli.
 	Uma conta pode ter várias chaves de acesso ou nenhuma.
 	As chaves podem ter diferentes níveis de acesso – FullAccess (acesso total) ou FunctionCall (apenas a capacidade de chamar métodos de contrato).
 	Todas as chaves são únicas dentro de uma conta, mas a chave pública pode ser atribuída a diferentes contas com diferentes níveis de acesso. O nível de acesso determina quais ações na conta podem ser executadas com essa chave.
 	Para o nível de acesso FullAccess , todos os 8 tipos de ações estão disponíveis: CreateAccountAction (criar uma conta), DeployContractAction (implantar um contrato), FunctionCallAction (chamar métodos de contrato), TransferAction (enviar tokens para outra conta), StakeAction (staking tokens), AddKeyAction (adicionar uma chave a uma conta), DeleteKeyAction (excluir uma chave de conta), DeleteAccountAction (excluir uma conta).
 	Para o nível de acesso FunctionCall , apenas FunctionCallAction está disponível (chamando métodos de contrato). Além disso, para essa chave, você pode especificar quais métodos de contrato ela pode chamar.

### O que é Web3?

O NEAR Protocol é uma plataforma descentralizada de desenvolvimento que visa construir um ecossistema Web3 saudável por meio de sua plataforma escalável e fácil de usar. Hoje, vamos entender as implicações da Web3 e o que ela pode fazer com o ecossistema.
A Necessidade da Web3

Crédito da Imagem
A Web 1.0 foi lançada por Berners-Lee em 1990 e desde então se tornou a base da internet como a conhecemos hoje. Aqui estão alguns dos principais pilares da Web 1.0:

 	         HTML ou HyperText Markup Language, que é a linguagem de formatação da web.
 	         URL ou Uniform Resource Locator – um endereço exclusivo para identificar um recurso na web.
 	         HTTP ou HyperText Transfer Protocol permite que você recupere recursos na web.

Embora esse estágio tenha sido realmente inovador, as páginas da web eram muito estáticas e bem diferentes dos sites projetados profissionalmente que estamos acostumados hoje. Além disso, embora as páginas da web estivessem longe de ser interativas, novos conceitos como “e-mail” se tornariam uma parte significativa de nossas vidas no futuro.

Nas últimas duas décadas, vimos a ascensão da Web 2.0. Os sites estão agora mais interativos do que nunca. No entanto, isso é apenas uma parte do todo. Pense nas empresas que se tornaram grandes nas últimas duas décadas. Meta, TikTok, Airbnb, Uber, etc. Qual é a única coisa comum que os une? Eles prosperam em conteúdo ou recursos gerados pelo usuário. Em essência, esse foi o grande avanço que vimos durante essa época. Só se pode alcançar a verdadeira escalabilidade capacitando seus usuários a participar ativamente de seu ecossistema.

No entanto, a Web 2.0 prosperou apenas na centralização. Não acredita em nós? Pense no número de audiências no Congresso que os CEOs do Google, Meta e Twitter tiveram que passar para explicar o que eles fazem com os dados dos usuários. Meta, em particular, foi culpado de apropriação indevida de dados de usuários. Na verdade, os dados de usuários que eles venderam para a Cambridge Analytica foram a base sobre a qual as campanhas presidenciais dos EUA foram realizadas.

However, Web 2.0 thrived solely on centralization. Don’t believe us? Think about the number of congressional hearings that the CEOs of Google, Meta, and Twitter had to go through to explain what all they do with user data. Meta, in particular, was guilty of misappropriating user data. In fact, the user data that they sold off to Cambridge Analytica were the very foundation upon which the US presidential campaigns were run.
O que é Web3?
A próxima iteração da web e da internet será a web3, que será construída sobre certos princípios fundamentais. Vamos passar por eles um a um.

Descentralização

Pode-se dizer com segurança que a descentralização é o princípio central da revolução da Web3. A ideia é que não haverá mais autoridade central ou conselho de administração centralizado que esteja controlando o crescimento e a narrativa da empresa. No mundo de hoje, a censura de plataforma tornou-se um problema significativo. Parece que, a menos que você esteja seguindo uma ideologia política específica, seus pensamentos acabarão sendo excluídos da plataforma de mídia social. As empresas tornam deliberadamente perfis específicos “difíceis de encontrar” para reduzir a disseminação de certas ideologias. O Twitter admitiu abertamente que eles tendem a censurar perfis de direita. O principal bloco de construção da Web3 será a resistência à censura trazida pela descentralização.

Falta de confiança

Isso é praticamente uma extensão do ponto de descentralização. Na Web 2.0, você teria que confiar suas informações confidenciais a terceiros. Na maioria das vezes, essas empresas usaram mal os dados à sua disposição, levando a enormes escândalos (Facebook e Cambridge Analytica). Agora, de acordo com a descentralização, não haverá um órgão único no centro da empresa com controle de todos os dados cruciais. Os aplicativos Web3 serão executados usando a tecnologia blockchain e a rede ponto a ponto para garantir a falta de confiança e a descentralização.

Componibilidade

Um dos aspectos fascinantes da Web3 será sua interconectividade e composição. Já vimos isso no ecossistema DeFi (Finanças Descentralizadas) e IoT (internet das coisas). No DeFi, várias plataformas podem se conectar e criar um ecossistema unido onde você pode tirar proveito de vários instrumentos financeiros.

Inteligência artificial

A Web3 usará IA e Machine Learning (ML) para capacitar seus sistemas a produzir resultados mais rápidos e relevantes.




	

	
	
		
			
				Fazer login em um site com sua conta do Facebook é um exemplo de:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de uso da Web3
A Web3 tem vários casos de uso, com moedas digitais, NFTs e outras entidades no espaço de criptografia e blockchain se tornando cruciais para a Web3. Organizações Autônomas Descentralizadas ou DAOs também são um caso de uso significativo para Web3, utilizando tokens para tornar os poderes de tomada de decisão mais justos e imparciais.
Organizações Autônomas Descentralizadas
O conhecimento básico de DAOs e como eles funcionam é muito útil para entender e contribuir para a Web3. Uma DAO é uma entidade que não requer uma autoridade central para funcionar. Em vez disso, é impulsionado por sua comunidade e oferece total autonomia e transparência. Contratos inteligentes regem todas as regras fundamentais; os contratos também executam qualquer decisão acordada pela comunidade, com todos os processos, incluindo votação ou propostas, publicamente disponíveis para verificação. Em essência, um DAO é governado por membros individuais que fazem parte da comunidade, tomando coletivamente decisões críticas em relação ao projeto, desde alocações até atualizações.

Uma equipe central de membros da comunidade estabelece regras para o DAO por meio de contratos inteligentes, estabelecendo a estrutura do DAO. Esses contratos inteligentes são publicamente verificáveis, permitindo que os membros da comunidade entendam cada etapa relacionada ao funcionamento do DAO. Os membros da comunidade podem criar propostas, e após isso toda a comunidade vota na proposta. Quando uma proposta atinge um nível de consenso na comunidade, ela é aceita e aplicada pelo contrato inteligente.

O cenário DAO pode ser dividido em diferentes grupos, como DAOs de Protocolo, DAOs de Investimento, DAOs de Serviços, DAOs Sociais, DAOs de Subsídios, DAOs de Colecionadores e DAOs de Meios de Comunicação. Alguns dos DAOs proeminentes que você pode acompanhar são MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO, DAOhaus, Opolis, MolochDAO e BanklessDAO.




	

	
	
		
			
				Berners-Lee foi pioneiro:
			
		

		
					

		
			
			
			
			Web 1.0

		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Gorjetas
A economia descentralizada oferece colaboração global que permite aos participantes controlar como trabalham, alocar seu tempo e experiência, com várias ferramentas já existentes e emergentes que os capacitam e seu estilo de trabalho. A gorjeta é um desses métodos que ajuda o crescimento das comunidades da web3, incentivando a participação. Antes de prosseguirmos, é importante entender a “gorjeta”. No mundo real, damos gorjeta a uma pessoa que presta um serviço. Muitas vezes, são dadas gorjetas a empregadas domésticas, funcionários de restaurantes, entregadores e outros indivíduos que nos ajudam a concluir ou executar determinadas tarefas para nós. Na Web3, as gorjetas funcionam com a mesma premissa, com a principal diferença de que a transferência de fundos ocorre através do blockchain.

Na Web3, os membros da comunidade podem receber gorjetas para uma variedade de contribuições, como contribuir com código para um projeto, responder perguntas, escrever um artigo ou quando um membro da comunidade empresta sua experiência a um projeto. As gorjetas podem ser realizadas de qualquer forma, desde airdrops de NFTs e tokens de governança até gorjetas em ETH, USDC ou qualquer outra criptomoeda. Dar gorjetas aos contribuidores ajuda a construir confiança na comunidade, garantir que os participantes permaneçam envolvidos no projeto e também ajuda a estabelecer um tom para participação futura.

Atualmente, os usuários da web3 estão recebendo gorjetas em tokens NEAR no Twitter e no Telegram.
Fazendo login com sua carteira
Outra coisa interessante que a Web3 muda são os procedimentos de login. Nos dias da Web 1.0, havia duas maneiras de fazer login em uma conta de site – por e-mail ou por meio de uma conta exclusiva criada exclusivamente para esse site.

Então, durante a fase Web 2.0, você pode fazer login em tudo com sua conta do Google ou sua conta do Facebook. Embora isso fosse conveniente, ainda tinha uma grande falha – a transferência de valor. Você ainda tinha que fornecer seus detalhes de pagamento separadamente para fazer compras.

Agora, com a web 3.0, você pode simplesmente se conectar a diferentes sites com sua carteira de criptomoedas. Por exemplo, no OpenSea, você pode se conectar diretamente ao seu MetaMask e fazer compras.

Lidar com usuários da web3 permite que os dapps transmitam instantaneamente não apenas dados, mas também valor monetário, sem nenhum intermediário envolvido!



 
O papel do protocolo NEAR na Web3
Com sua plataforma escalável e fácil de usar, o NEAR Protocol fornece uma plataforma que permite criar aplicativos DeFi e NFTs sem gastar muito.

O TVL DeFi (Total Value Locked ou Valor Total Bloqueado) para NEAR é de apenas US$ 141,72 milhões. É um ecossistema muito jovem e atualmente está crescendo rapidamente.



O aplicativo DeFi mais dominante que representa mais de 80% do TVL geral é o Ref Finance.

O Ref Finance tem algumas semelhanças com o Uniswap V2, além de suportar mais tipos de pool, taxas configuráveis ​​e é totalmente de propriedade da comunidade. Ref também é a primeira plataforma DeFi no NEAR. O principal objetivo do Ref é reunir DEX, protocolos de empréstimo, emissor de ativos sintéticos e muito mais sob um só lugar.

A NEAR lançou recentemente um enorme fundo de doação de US$ 800 milhões que visa especificamente a criação de um ecossistema DeFi maior e mais saudável. O fundo tem alguns requisitos importantes, que incluem o seguinte:

 	         US$ 100 milhões para startups
 	         Fundo regional de US$ 100 milhões
 	         Doações de US$ 250 milhões para ecossistemas a serem distribuídos ao longo de quatro anos.

Leia isto para saber mais sobre DeFi em NEAR.

No lado dos NFTs, vários projetos foram criados no blockchain NEAR como Mintbase, Paras, Hip Hop Heads, etc.

Mintbase é a plataforma NEAR NFT mais popular, pois permite que qualquer pessoa faça uma NFT e a disponibilize para venda em seu mercado ou em mercados NFT como o OpenSea. Os mineradores podem criar um contrato inteligente e limitar a transferibilidade dos tokens cunhados, ajudando a evitar fraudes ou a transferência ilegal de itens exclusivos. O Mintbase está focado em criar uma experiência de criação de NFT única, e é por isso que, como mencionado anteriormente, ele suporta diferentes ativos digitais. Isso é contrário às plataformas concorrentes que se concentram em uma categoria NFT específica.
O outro lado - Há muito Hype?
Recentemente, esse meme está circulando no Twitter, recebendo comentários de nomes como Jack Dorsey e Elon Musk.


Crédito da imagem
A partir de agora, os aplicativos Web3 estão recebendo uma enorme atenção para os VCs (Venture Capital ou Capitais de Risco) do Vale do Silício. Isso traz um grande ponto de discórdia. Com tantas partes de peso interessadas, os aplicativos Web3 serão descentralizados no sentido mais verdadeiro? Dorsey e Musk não acreditam nisso. No entanto, será interessante ver como isso se desenrola no futuro.




	

	
	
		
			
				Qual dos seguintes não requer uma autoridade central para funcionar:
			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Торговые площадки NFT

С ростом технологии блокчейна мы увидели много новых вариантов его использования, они стимулируют внедрение блокчейна, помогая ему стать массовым явлением. В 2021 году мы наблюдали рост NFT. NFT - один из вариантов использования технологии блокчейн. NFT привлекли внимание пространства блокчейнов, что привело к их стремительному росту популярности, поскольку пользователи изо всех сил пытались заполучить их. Об их популярности можно судить по продаже коллекции произведений искусства NFT компанией Beeple, которая была продана за ошеломляющую сумму в 69 миллионов долларов.

С грандиозным  успехом NFT мы наблюдаем, как художники, музыканты и другие создатели погрузились в NFT. Мы видели, как артисты, как Граймс, и такие группы, как The Rolling Stones и Kings of Leon, запрыгивали на подножку NFT, продавая токенизированные версии своих песен, обложки альбомов, а также цифровые и виртуальные товары. С таким большим вниманием к ним, NFT являются горячей темой, и важно понимать как вы можете покупать или продавать их через торговые площадки NFT. На NEAR тоже есть торговые площадки NFT. Но сначала мы должны понять определение NFT. 
Что такое NFT?
NFT можно описать как уникальные цифровые активы, идентифицирующая информация которых хранится в смарт-контрактах. Это информация, которая делает каждый NFT уникальным. Поскольку каждый NFT уникален, их нельзя обменивать друг на друга, как взаимозаменяемые предметы, такие как фиатная валюта или даже BTC. NFT также неделимы, в отличие от взаимозаменяемых элементов, которые можно разделить на более мелкие активы или суммы, а затем отправить другим. Например, вы не можете никому продать половину картины или половину билета на поезд. Та же логика применима к NFT, где каждый уникальный NFT содержит уникальный набор данных, которые нельзя разделить или продать. 

NFT основаны на двух типах стандартов токенов в блокчейне Ethereum: стандарте токенов ERC-721 и стандарте токенов ERC-1155. Оба стандарта токенов гарантируют, что рассматриваемый актив будет действовать определенным образом, позволяя разработчикам легко развертывать свои NFT с использованием этих стандартов токенов, а также обеспечивая совместимость с сервисами и криптоэкосистемой. Однако,  несколько других блокчейнов, таких как EOS, NEAR и Tron, выпустили свои собственные стандарты токенов, чтобы привлечь разработчиков и создать NFT на своих платформах. 
История NFT
Мы уже обсуждали, что такое NFT выше. Однако откуда взялись NFT? Первый выпущенный NFT можно проследить до 2014 года, когда Кевин Маккой выпустил первый NFT под названием «Quantum» 3 мая 2014 года, задолго до взрыва NFT и пространства криптоискусства. Quantum NFT можно описать как пикселизированное изображение, состоящее из восьмиугольника, заполненного кругами, дугами и другими формами. Все фигуры имеют один и тот же центр, причем большие фигуры окружают меньшие. 

Углубляясь в историю, NFT подпитывались такими культурными феноменами, как CryptoPunks и CryptoKitties. Однако история идет гораздо дальше, чем только это. В 2012 году мы стали свидетелями появления «цветных монет», которым можно приписать идею NFT. Эти цветные монеты изначально были выпущены на блокчейне Биткойна. Затем в 2014 году появился Counterparty, созданный на блокчейне Биткойн и позволяющий создавать активы. В 2016 году мы увидели появление Rare Pepes, а вскоре после этого и CryptoPunks, что привело к буму NFT, вытолкнув NFT в мейнстрим и захватив воображение широкой публики. 




	

	
	
		
			
				Что из нижеперечисленного верно в отношении NFT? 
			
		

		
					

		
			
			
			
			
NFT — это уникальный цифровой актив, идентифицирующая информация которого хранится в смарт-контрактах.
		
			
			NFT — это делимый актив, который можно разделить и разделить или передать другим лицам.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Что такое торговая площадка NFT?
Точно так же, как вам нужен рынок для покупки большинства товаров, как в реальном, так и в цифровом мире, рынок NFT позволяет пользователям покупать, продавать, обменивать, отображать или чеканить (создавать) свои собственные NFT. Думайте о рынке NFT как о eBay или Amazon, но исключительно для NFT. Практически любой может использовать рынок NFT, но для доступа к этим рынкам пользователю требуется следующее: 

 	Учетная запись пользователя на торговой площадке NFT, которая позволит вам приобретать NFT на определенной платформе. 
 	Крипто-кошелек, совместимый с блокчейном, на котором вы собираетесь покупать NFT. Например, если вы планируете использовать блокчейн Ethereum для покупки или продажи ваших NFT, вам потребуется совместимый кошелек, такой как MetaMask. Если вы планируете использовать Solana, вам потребуется кошелек, совместимый с Solana, например Sollet. 

Торговые площадки NFT имеют решающее значение, поскольку они объединяют покупателей и продавцов и предлагают пользователям множество инструментов, позволяющих им создавать свои собственные NFT за считанные минуты. Художники могут использовать торговую площадку для выставления своих NFT на продажу, а покупатели могут просматривать торговую площадку, покупая предмет в процессе торгов. 
Популярные торговые площадки NFT
Существует несколько торговых площадок NFT, которые вы можете выбрать в зависимости от ваших требований. Универсальные рынки NFT чрезвычайно популярны, в то время как существуют другие нишевые рынки для конкретных NFT, которые могут состоять из коллекционных карт, виртуальных наземных цифровых миров, таких как Decentraland, или даже некоторых внутриигровых предметов и предметов коллекционирования. Некоторые из самых популярных торговых площадок NFT: 

 	OpenSea
 	SuperRare
 	Rarible 
 	Mintable
 	Nifty Gateway

Как популярность OpenSea  подпитывает NFT
OpenSea зарекомендовала себя как лидер и крупнейший рынок NFT, предоставляющий хостинг и поддержку для всех видов цифровых активов. Торговая площадка изначально использовалась как торговая площадка для популярной игры CryptoKitties. Однако с тех пор он вышел далеко за рамки только предметов коллекционирования и представляет собой рынок для различных активов, таких как музыка, внутриигровые активы и предметы коллекционирования, цифровые предметы коллекционирования, искусство и т. д. OpenSea отвечает за рост NFT в NFT и NFT-проектах. такие как CryptoKitties, CryptoPunks, Ethermon и другие, все из которых были запущены в 2017 году, в том же году, что и OpenSea, что привело к тому, что рынок стал мейнстримом.




	

	
	
		
			
				Какие стандарты токенов используются для NFT? 
			
		

		
					

		
			
			
			
			ERC-721 и ERC-1155
		
			
			ERC-20
		
			
			ERC-725
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Протокол NEAR
Протокол NEAR был основан в 2018 году и представляет собой децентрализованную платформу разработки, которая создает идеальную среду для смарт-контрактов и децентрализованных приложений. NEAR фокусируется на недостатках других протоколов в том же пространстве, таких как Ethereum, легко конкурируя с возможностями платформы номер один для децентрализованных финансов и децентрализованных приложений. NEAR устраняет один из самых явных недостатков Ethereum — масштабируемость. Он делает это с помощью процесса, называемого «шардинг». Разделение позволяет протоколу NEAR расширяться в геометрической прогрессии. 

NEAR использует блокчейн Proof-of-Stake, который использует сегментирование и удобен для разработчиков. NEAR является недорогим и легко масштабируемым, что позволяет разработчикам легко создавать децентрализованные приложения. NEAR также представляет Doomslug, который позволяет блокам достигать окончательности за считанные секунды. Протокол использует ту же технологию, что и Биткойн, сочетая ее с другими функциями, такими как сегментирование. Протокол NEAR масштабируется линейно, что позволяет ему поддерживать миллиарды транзакций децентрализованным образом. 

NEAR также состоит из нескольких уникальных платформ NFT, так как все больше и больше проектов выбирают протокол NEAR для запуска своих проектов. Благодаря сотрудничеству NEAR с Эдом Янгом платформа запустила портреты знаковых фигур из истории хип-хопа. Платформа NEAR Arterra позволяет фанатам взаимодействовать с влиятельными лицами, киберспортивными командами и стримерами, позволяя фанатам собирать NFT от своих любимых создателей. Еще один проект NEAR — Pixelparty, состоящий из 600 токенов, каждый из которых представляет подкадр кадра Pixelparty. Еще один проект NEAR — Metamon, который позволяет пользователям собирать монстров на основе NFT. Пользователи также могут комбинировать двух монстров, превращая их в более мощные и редкие NFT. 

NEAR позволяет пользователям получить доступ к нескольким протоколам, начиная от DAO, DeFi и NFT, с динамичной экосистемой, в которой есть несколько запущенных проектов. Поскольку мы сосредоточены на торговых площадках NFT, мы рассмотрим проекты NFT на протоколе NEAR, а именно Paras, Mintbase и TenK. 
Mintbase 


Source: NEAR

Mintbase, созданная Нейтом Гейером и Калорином Венд в 2018 году, позволяет пользователям создавать и продавать NEAR NFT. Эти NFT могут быть чем угодно, от криптоискусства до цифровых активов и всего, что между ними. Любой, у кого есть доступ к Интернету, может создать NFT на Mintbase и продать его на торговой площадке NEAR NFT или на других торговых площадках, таких как OpenSea или других торговых площадках. Mintbase позволяет создателям заключать смарт-контракты, ограничивая возможность передачи отчеканенных токенов. Это помогает значительно сократить мошенничество или незаконную передачу NFT. 

Mintbase перешла с Ethereum на NEAR благодаря высокой плате за газ в первом случае. Плата за газ стала настолько высокой, что Mintbase пришлось просить пользователей подождать, пока цены на газ не упадут, прежде чем открывать магазин. Благодаря значительно более низкой плате за газ NEAR был и остается идеальной платформой для Mintbase. Протокол позволяет снизить плату за газ благодаря эффективной модели исполнения контракта. NEAR также использует динамический подход к сегментированию под названием Nightshade, что дает ему значительное преимущество перед другими платформами, такими как Ethereum. 
Paras

Source: NEAR

Paras — это рынок цифровых арт-карт, созданный по протоколу NEAR. Протокол отличается от других торговых площадок тем, что предлагает исключительно коллекции, а не отдельные релизы. Paras черпает вдохновение из коллекционных карточек в реальном мире, а его NFT аналогичны коллекциям спортивных карточек других коллекционных карточек популярных франшиз, таких как Pokemon. В отличие от других торговых площадок, особенно на Ethereum, которые позволяют пользователям загружать практически все, что угодно, Paras использует более взвешенный подход к NFT. 

Чтобы создавать на Paras, художники должны подать заявку, и каждую неделю утверждается только 30 художников. Произведения, созданные художниками, должны соответствовать соотношению сторон Параса 64:89, а также содержать конкретную информацию, связанную с произведением искусства. Парас выбрал NEAR, потому что он предлагает быструю скорость транзакций и низкую комиссию за транзакцию. Еще одним важным фактором, почему Paras выбрал NEAR, был Rainbow Bridge, который позволяет переводить ETH в NEAR, что позволяет беспрепятственно покупать NFT. 

Недавно Парас запустил Boom Boom, серию мини-комиксов, созданную исключительно для экосистемы NEAR. Протокол также выпустил свой первый комикс Paradigm, первые три выпуска которого доступны бесплатно, а последующие выпуски будут стоить около 0,3 доллара США за выпуск. 
TenK 


Source: Twitter

 

Mintbase и Paras считаются наиболее известными платформами NFT, доступными в протоколе NEAR. Тем не менее, на NEAR доступен третий проект под названием TenK. TenK можно охарактеризовать как платформу для генеративного искусства с открытым исходным кодом, которая переносит множество иллюстраций NFT в протокол NEAR. Протокол уже запускает несколько известных проектов на NEAR. TenK — это протокол, лежащий в основе NEAR Misfits, который был запущен в 2021 году. NEAR Misfits — это первая криптографически полная коллекция изображений профилей, основанная на протоколе NEAR. 
Заключительные мысли
Протокол NEAR значительно упростил выпуск NFT и торговых площадок NFT, чем Ethereum, что позволило ему стать одним из самых многообещающих и востребованных протоколов в криптопространстве. NEAR берет Ethereum в лоб, предлагая решения давних проблем, таких как отсутствие масштабируемости, низкая скорость транзакций и обработки, а также чрезвычайно высокая плата за газ. NEAR стал успешной альтернативой Ethereum: новые проекты стекаются к протоколу, а другие переходят с Ethereum на NEAR. Другие проекты, такие как Парас и ТенК, уже работают на NEAR. 




	

	
	
		
			
				Какие недостатки Ethereum устраняет NEAR? 
			
		

		
					

		
			
			
			
			Высокие цены на gas
		
			
			Масштабируемость
		
			
			Низкая скорость транзакций
		
			
			Все вышеперечисленное
		
	
		

		
		
			
				Correct!
				Wrong!

### Лучшие практики криптографии: советы по использованию криптографии

Пространство криптовалюты может быть пугающим даже для самых опытных инвесторов. По мере того, как криптовалюта становится все более популярной, риски для ваших активов также увеличиваются в геометрической прогрессии. Инвесторы в криптовалюту все больше беспокоятся о безопасности своих инвестиций и активов. В то время, как крипто активы и криптовалюты, защищены платформами, на которых они торгуются, инвесторы и пользователи этих бирж должны быть более активными при защите своих цифровых активов. 

Крайне важно, чтобы пользователи имели полное представление о криптовалютном пространстве, прежде чем инвестировать в криптовалюты. Также важно иметь представление о нормативно-правовой базе в вашей стране, чтобы знать правовой статус криптовалют и способы инвестирования. Следование набору передовых практик идеально подходит для защиты ваших инвестиций в криптовалюту и беспрепятственного использования криптовалюты. 
Потенциальные риски для владельцев криптовалюты
Волатильность — это риск, который считается неотъемлемой частью крипто пространства. Любой человек, инвестирующий в криптовалюту, хорошо осведомлен об волатильности. Однако, существуют и другие риски для инвесторов в криптовалюту и их инвестиций. 

Некоторые из этих рисков:

 	Отмывание денег
 	Инвестиционные аферы через ICO 
 	Мошенничество с пампом и дампом 
 	Поддельные биржи криптовалют
 	Фишинговые мошенничества

Помимо рисков, упомянутых выше, всегда существует угроза со стороны хакеров. Инвесторы всегда должны быть на страже в отношении возможности мошенничества, кражи, потери активов. Давайте рассмотрим некоторые способы, с помощью которых инвесторы могут защитить свои криптовалюты и обеспечить бесперебойную работу с криптовалютами. 




	

	
	
		
			
				Что из следующего считается неправильной стратегией при инвестировании в криптовалюту? 
			
		

		
					

		
			
			
			
			Изучение и понимание нормативно-правовой базы перед инвестированием 
		
			
			Тщательное изучение и проверка криптобирж, какая из них лучше подходит для вас
		
			
			Поиск следуеюшего Биткоина или Эфира
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Передовые методы работы с криптографией для обеспечения беспрепятственного ее использования
Ваша криптовалюта может быть скомпрометирована несколькими способами: взлом крипто валютного кошелька или биржи, скомпрометированная СИД фраза. Вот несколько простых шагов, которые могут иметь большое значение для обеспечения безопасности при работе с криптовалютой. 
Всегда используйте надежный пароль
При использовании биржи для торговли криптовалютой вам потребуется создать учетную запись. Крайне важно защитить этот торговый счет надежным паролем, состоящим из цифр и специальных символов. Надежный пароль — это ваша первая линия защиты от любого злонамеренного хакера или группы. Также помогает использование менеджера паролей, позволяющего создавать и запоминать сложные пароли. Вы можете использовать менеджеры паролей, такие как Dashlane, чтобы помочь вам создать безопасный пароль. Также крайне важно регулярно менять свой пароль и использовать диспетчер паролей, как упоминалось выше, наряду с двухфакторной аутентификацией.




	

	
	
		
			
				Что можно считать потенциальными рисками для крипто инвесторов? 
			
		

		
					

		
			
			
			
			Инвестиционные мошенничества через ICO 
		
			
			Мошенничество с пампом и дампом
		
			
			Отмывание денег
		
			
			Все вместе взятое
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Используйте 2FA (двухфакторная аутентификация)
Наряду с надежным паролем подключите двухфакторную аутентификацию при использовании бирж криптовалют. Вместо аутентификации по SMS вы можете использовать такие приложения, как Google Authenticator или Authy. В идеале было бы лучше, если бы вы использовали самую мощную двухфакторную аутентификацию, разрешенную платформой. Аппаратные ключи безопасности, такие как Yubikey вместе с такими приложениями, как Google Authenticator и Authy, о которых уже упоминалось выше, дадут хорошую защиту. Если у вас нет выбора кроме 2FA на основе SMS, вам следует включить отправку одноразового кода на ваше мобильное устройство каждый раз, когда вы входите в свою торговую учетную запись криптовалюты.
Защитите свои личные ключи
Для хранения ваших криптовалют вам потребуется кошелек, в котором будут храниться ваши открытые и закрытые ключи для отправки, получения и хранения криптовалют. Хотя ваш публичный адрес должен быть доступен другим пользователям, вы не должны передавать свои личные ключи какому-либо физическому или юридическому лицу. Если кто-то получит доступ к вашему закрытому ключу, вы можете потерять все средства, находящиеся в вашем кошельке. То же самое относится и к вашим закрытым ключам, когда речь идет о вашем блокчейне или торговом счете. 

Вы можете защитить свои ключи, выполнив несколько простых шагов:

 	Использование случайного ключа или парольной фразы 
 	Сохранение контроля над своими ключами и не передача их на централизованный обмен. 
 	Использование аппаратного кошелька 

Используйте “холодный” кошелек
Как мы знаем, криптовалютные кошельки делятся на две категории: “горячие” кошельки и “холодные”  кошельки. “Горячие”  кошельки предлагают легкость и простоту, но также и значительную уязвимость. Хотя вы и  получаете легкий доступ к своей криптовалюте, они также уязвимы для угроз безопасности, таких как взлом. “Холодный” кошелек — это то, что рекомендуют большинство экспертов в области криптовалют, особенно если вы намерены хранить свои криптовалюты в течение значительного периода времени. “Холодный” кошелек — это, по сути, автономный кошелек, то есть ваши активы хранятся в автономном режиме, защищая ваши активы от любых попыток взлома. “Холодные” кошельки обеспечивают полную защиту от угроз, с которыми вы обычно сталкиваетесь при использовании горячего кошелька. Примерами “холодных” кошельков являются аппаратные кошельки и бумажные кошельки. 
Используйте гибридный подход
Принятие гибридного подхода влечет за собой использование как  “горячих”, так и “холодных” кошельков. При использовании этого подхода вы можете хранить свои криптовалюты в автономном режиме, когда они не торгуются. Однако,  при совершении сделки вы можете просто перевести активы, которые собираетесь продать, в свой “горячий” кошелек, завершить сделку, а затем перевести свои активы обратно в “холодный”  кошелек. 
Используйте VPN
Чрезвычайно важно использовать безопасное подключение к Интернету при доступе к вашему торговому счету криптовалюты и совершении крипто валютных транзакций. Никогда не пытайтесь торговать в общедоступной сети Wi-Fi, и даже при использовании домашней сети для дополнительной безопасности рекомендуется использовать VPN. Использование VPN поможет защитить вашу активность в Интернете от потенциальных хакеров и злоумышленников. Также важно защитить ваше личное устройство, которое вы будете использовать для проведения транзакций. Всегда обновляйте свое устройство и следите за тем, чтобы вы не нажимали на какие-либо вредоносные ссылки и не посещали вредоносные веб-сайты. 
Не кладите все яйца в одну корзину
Как и в случае с традиционным фондовым рынком, на рынке криптовалют ключевое значение имеет диверсификация. Инвесторы знают, что  диверсификация всегда полезна для вашего крипто-портфеля. Вместо того, чтобы вкладывать все свои деньги, скажем, в BTC, инвестирование в комбинацию BTC, ETH и нескольких других криптовалют, может помочь защитить вас от потенциальной волатильности рынка, а также позволит вам извлечь выгоду из нескольких источников, когда рынок находится на подъеме. 
Ключевой момент - осмотрительность
Прежде чем инвестировать в криптовалюту, важно понять базовый актив, его использование и то, как он функционирует. Почти для каждой монеты есть технические описания, доступные в Интернете, которые могут помочь вам лучше понять монету и расширить свои знания о потенциале монеты. Если технический документ недоступен или если в техническом документе не упоминается или не описывается функционирование монеты, то этой  монеты лучше избегать. 
Ключевой момент - время
Точно так же, как и комплексная проверка, время также считается ключевым фактором, когда речь идет об инвестировании в криптовалютный рынок. Если вы думаете, что знаете, что нужно знать о криптовалюте, тогда вы должны быть в состоянии идеально рассчитать время для своих инвестиций. Криптовалютный рынок нестабилен, и колебания цен являются обычным явлением. Не инвестируйте в новые монеты в поисках следующего Биткойна или следующего Эфириума. Всегда тщательно изучайте проект, прежде чем инвестировать, следите за ценовыми моделями и следите за новостями, чтобы быть в курсе событий, которые могут негативно повлиять на стоимость ваших инвестиций (взлом биржи, манипулирование ценами). Криптовалюты очень спекулятивны, поэтому всегда подходите взвешенно к принятию таких решений, прежде чем прыгать в космос. 
Дважды проверяйте все детали транзакции
Помните, транзакции блокчейна неизменяемы, то есть после выполнения их нельзя отменить. Это делает чрезвычайно важным перепроверить все детали транзакции, прежде чем продолжить транзакцию. Ваши средства могут быть возвращены вам только в том случае, если противоположная сторона согласится на это. 
Не вкладывайте больше, чем вы можете позволить себе потерять
Это один из самых важных моментов, который вы должны иметь в виду как инвестор. В то время, как криптовалюты можно рассматривать как безопасное убежище, и да, они предназначены для стран, которые предназначены для граждан таких стран, как Венесуэла, которая шатается в условиях гиперинфляции. Но криптовалюты — это инвестиции с высоким риском и значительной волатильностью. То, что было прибыльным утром, днем может быть убыточным. Если вы новичок, всегда рекомендуется начинать с вложения меньших сумм денег. 
Заключение
Криптовалюты — несколько рискованное вложение как для новичков, так и для опытных инвесторов. Как правило, высокорисковые инвестиции должны составлять лишь небольшую часть вашего портфеля. В случае с криптовалютами,  всегда полезно диверсифицировать свои инвестиции в несколько монет, чтобы ваши инвестиции могли повышаться или обесцениваться в разной степени, в некотором смысле  защищая  вас. Упомянутые выше моменты,  обычно считаются самой базовой тактикой, которую вы можете использовать для обеспечения бесперебойной работы с криптовалютой. Мир динамичен и  постоянно меняется, и вы должны проявлять инициативу в обеспечении безопасности своих инвестиций и средств, тщательно защищая свои счета и кошельки. Всегда будьте в курсе последних новостей и событий в крипто пространстве. 




	

	
	
		
			
				Использование надежного пароля, двухфакторной аутентификации, холодного кошелька и VPN при проведении транзакций считается частью передовой практики криптографии. 
			
		

		
					

		
			
			
			
			Правда 
		
			
			Ложь
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Live Contract Review - Teil 4: Berry Farm

Einleitung
Mein Name ist Eugene, und heute werden wir über den Berry Farm Contract sprechen, der die Ergänzung des Berry Clubs ist, die es Ihnen ermöglicht, Deine Bananen in Gurken umzuwandeln und NEAR zu farmen. Lasst mich euch zunächst einen kurzen Überblick über die Berry Farm geben. Das Repository kann auf meinem Github gefunden werden. Hier ist das ursprüngliche Video, auf dem dieser Leitfaden basiert:


UI


Berry Farm ist eine sehr gut gestaltete App mit großem Text und vielen Emojis. Die App zeigt den Kontostand nach dem Login an und bezieht diesen dabei aus verschiedenen Quellen. Avocados und Bananen, eine Zwischenwährung in der App, stammen aus dem Berry Club Contract, Gurken aus dem lokalen Contract und NEAR aus deinem Kontostand. Die Grundlage des Spiels ist, dass man einen Raum auf dem Screen reservieren kann, und auf Basis dieser Nutzung eine wiederkehrende Belohnung ausgeteilt wird. Wenn ein Spieler einen Raum für sich vereinnahmt hat und dabei nicht von einem anderen Spieler verdrängt wurde, wird ein Teil der gesamten Belohnung an diesen Spieler ausgegeben. Es scheint, dass jemand in letzter Zeit viele Avocados gekauft hat da die Belohnungen zum Zeitpunkt der Erstellung diesen Artikels relativ zur Vergangenheit gestiegen sind. Es gibt auch globale Statistiken, die besagen, dass 2500 NEAR von Berry Club zu Berry Farm übertragen wurden. Ich habe 116,9 NEAR verdient und meine Belohnung wird 0,014332 NEAR betragen, basierend auf der Anzahl der Gurken, die ich im Vergleich zur Gesamtzahl der Gurken habe.



Die Gesamtzahl der Gurken beträgt 54116,4. Ich bekomme jedes Mal, wenn es eine Belohnung gibt, einen Anteil von 3 % von dieser Belohnung. Wenn ich also auf Aktualisieren klicke, aktualisiere ich im Grunde die Statistiken von mehreren Konten, und ich kann NEAR beanspruchen, das vom Contract auf mein Konto übertragen wird. Ich kann auch Bananen gegen Gurken tauschen oder den Berry Club Contract aufrufen.





Ich werde transfer_with_vault zur Übertragung von Assets nutzen. Dabei wird ein neuer, sichererer Standard verwendet. Als Sicherheitsmaßnahme gegen automatische Abbuchungen muss das Abheben von Assets manuell bestätigt werden wodurch verhindert wird, dass ein Zugangsschlüssel verwendet wird. Dieser Prozess kostet 1 yocto NEAR. Wenn du z.B. Berry Club von einer anderen App autorisieren würdest, die versucht, alle deine Bananen abzuziehen, würde das scheitern, weil sie nicht in der Lage ist, transfer_raw oder transfer_with_vault aufzurufen. Zur Klarstellung: transfer_raw ist der neue Name für Überweisungen ohne Contract, bei dem man einfach auf ein bestehendes Konto einzahlen kann, und transfer_with_vault nennt den Empfänger, um Token abzuheben. 



Um mehr Gurken zu bekommen habe ich 10 Bananen ausgegeben. Bei der Aktualisierung des Kontostands kann ich sehen, ob jemand etwas abgehoben hat. So funktioniert die Benutzeroberfläche, aber es gibt mehr Funktionen als nur diese. Der Contract unterstützt Gurken und Bananen als fungible Token. Man kann in Zukunft möglicherweise eine weitere App entwickeln, die Gurken überträgt, und es gibt noch weitere Möglichkeiten, wie z.B. Banana Swap, die Vlad Garchina entwickelt hat.



Es ist ein vereinfachter Uniswap mit einem einzigen Pool, in dem man Bananen kaufen und verkaufen kann. Ich habe es tatsächlich noch nicht ausprobiert. Ich möchte Bananen im Wert von 1 NEAR verkaufen, was zum Zeitpunkt des Erstellens diesen Artikels etwa 6 Bananen entspricht. Mal sehen, ob es klappt.





Berry Club Transfers wird aufgerufen, der wieder einmal beteiligt ist, aber dieses mal mit einem anderen Contract. Wir zeigen derzeit keine Argumente an, aber bald werden wir das tun.



Es wird angezeigt dass die Summe überwiesen wurde, und ich habe 1 NEAR bekommen, für das ich 6 Bananen ausgegeben habe. Ziemlich cool.



Die Liquidität kann nicht aufgestockt werden, und sie wird um 10 % gekürzt. Das ist also das User Interface.
Überprüfung des Contracts
Berry Club
Lasst mich nun den Contract vorstellen. Wir beginnen mit dem Banana Farm Contract, aber Du musst Dir wahrscheinlich auch den Token Contract von pixelboard, den Contract von Berry Club und den Contract, der Token verschickt, ansehen. 



Berry Club hat einen hard-coded Contract, der Farm Contract id genannt wird.



Wenn du zeichnest, wird überprüft, dass du keine leeren Pixel zeichnest, sonst könntest du einfach eine Belohnung auslösen, ohne Avocados auszugeben. 



Dann wird maybe_send_reward aufgerufen, das die aktuelle Zeit aus der Blockchain abruft und überprüft, ob der next_reward_timestamp kleiner als die aktuelle Zeit ist.



Die nächste Belohnung wird entweder am Beginn der Farming-Zeit ausgelöst, die ein global timestamp ist, welcher ursprünglich einen 26-Stunden-Countdown ermöglichte, oder beim Zeitstempel last_reward_timestamp, als wir ihn zuletzt ausgelöst haben, plus 60 Sekunden. 



Wenn es also an der Zeit ist, den nächsten Reward zu senden, wird sich die aktuelle Zeit gemerkt und der Reward auf der Grundlage dieser Logik berechnet. D.h. der aktuelle Kontostand von Berry Club und der aktuelle Speicherplatz wird genommen, es wird der Speicherplatz berechnet um die Speicherkosten plus eine Sicherheitsspanne, die 50 NEAR beträgt, zu decken. 



Es werden immer 15 NEAR für die zukünftigen Guthaben gehalten. Wenn unser Guthaben höher ist als der Betrag, den wir für die Lagerung plus Sicherheit benötigen, dann berechnen wir das verfügbare Guthaben und teilen es durch den Anteil der Belohnung, den wir jedes Mal auszahlen werden, was 24 mal 68 ist. Wenn man es jede Minute aufrufen würde, dann würde man den größten Teil des Guthabens auf dem Konto aufbrauchen. Aber die Belohnungen nehmen von selbst ab, weil das Guthaben an sich von selbst abnimmt. Aber es ergibt meistens alles Guthaben innerhalb eines Tages, wenn man es jede Minute aufrufen würde. Erstens kann man keinen Block produzieren, der einen früheren Zeitstempel hat und zweitens kann man keinen Block produzieren, der über den eigenen Slot hinausgeht. Man hat einen bestimmten Slot, wenn man einen Chunk produzieren muss. Man kann also höchstens einen Teil des letzten Blocks in der letzten Millisekunde des Slots produzieren, also eine Sekunde früher. Man kann es nicht wirklich weit nach vorne verschieben, da sonst alle anderen Nodes das Protokoll ebenfalls brechen würden. Das Protokoll ist also dahingehend begrenzt, dass die Entscheidung ob ein Block angenommen wird oder nicht begrenzt ist. Das würde bedeuten, dass die Prüfer im Grunde aufhören, das Protokoll zu befolgen. Sie müssen ihre Zeit koordinieren. 



Bei Ablauf der Zeit ist also die auszuschüttende Belohnung ermittelt und der Farm Contract ruft take_my_near auf. Dabei übergibt er keine Argumente sondern nur die auszuzahlende Belohnung und GAS für die Netzwerkgebühren. Es wird nur eine minimale Menge an GAS benötigt, um die Guthaben zu addieren. So wurde der Berry Club aktualisiert, um nach jeder Zeichnung potenziell Belohnungen zu verteilen. Aber es braucht etwas mehr. Es wird GAS verwendet, das für die Zeichnung ausgegeben wurde, um die Belohnung von Zeit zu Zeit zu verteilen, wofür etwa 10 TERA GAS benötigt werden.
Berry Farm
Gehen wir zur Berry Farm und beginnen wir mit diesem Contract.  So wie die Berry Farm funktioniert, muss sie in der Lage sein, in konstanten Zeitabständen Belohnungen zu verteilen, die auf der Gesamtzahl der Gurken basieren, was keine triviale Aufgabe ist. Sie ähnelt ein wenig dem Staking Pool, und wie ein typischer Staking Pool Belohnungen verteilt. Der Staking-Pool erstellt eine Reihe von Anteilen für jede durchgeführte Einzahlung. Dabei hat der Anteil einen aktuellen globalen Preis, der sagt: "Hey, ich habe mehr Anteile gekauft oder geprägt, und jetzt können meine Anteile gegen eine bestimmte Anzahl von NEAR Token eingelöst werden." Der Aktienpreis beginnt bei 1 yocto NEAR pro Aktie, und je mehr Rewards man ansammelt, desto mehr steigt der Preis der Anteile. Wenn Du unstake verwendest, verkaufst Du Anteile zum aktuellen Preis, und Du erhältst NEAR zurück, welches unstaked und abgerundet ist. Das Problem dabei ist, dass der Preis einer Gurke gleich Null ist, wenn man sie zum ersten Mal stakest, und dass man nicht wirklich Anteile kaufen und prägen kann, weil der Preis von Anteilen gleich Null ist. Die Logik von Anteilen funktioniert in diesem Fall nicht sehr gut, also musste ich für diese Sache etwas anderes entwickeln, um die Buchführung zu erledigen. Kommen wir zu den Beispielen. Nehmen wir an, Mike ist die erste Person, die 10 Gurken in den Contract eingezahlt hat, und dann werden 100 NEAR verteilt. Mike bekommt alle Belohnungen, weil er der Einzige ist, der jetzt 100% der Anteile an der Berry Farm kontrolliert. Mike war z.B. offline und hat sie nicht beansprucht, also können wir sein Konto nicht wirklich aktualisieren, da dies in konstanten Zeitabständen geschehen muss. Wir können nicht durch alle Konten gehen, aber wir müssen uns irgendwie merken, dass Mike alle NEAR für seine Gurken bekommen hat. Nehmen wir nun an, Josh kommt hinzu und setzt weitere 10 Gurken ein. Jetzt beträgt Mikes Anteil 50 % und Joshs Anteil 50 %, aber Josh hat die Gurken eingesetzt, nachdem die ursprünglichen 100 NEAR bereits verteilt wurden. Er hat kein Anrecht auf die 100 NEAR, die Mike jetzt bekommt, weil er 50% Anteil hat und Josh 50 NEAR bekommt. Wenn Mike wieder online geht, müssen wir in der Lage sein, seinen Kontostand mit 150 NEAR anzuzeigen, die er in dem konstanten Zeitabstand verdient hat. Das ist also die Herausforderung, die wir mit diesem Contract angehen mussten, und die Art und Weise, wie wir sie gelöst haben, ist, dass wir ein globales Größenverhältnis haben, das near per cucumber genannt wird und das angibt, wie viel NEAR ein bestimmtes Gurkenguthaben erhält, wenn ein Konto erstellt oder in irgendeiner Weise berührt wird. Wir merken uns den letzten Wert dieses Bruchteils. 



Dann haben wir einen NEAR Guthaben, d.h. wenn der letzte Bruchteil niedriger war als der aktuelle Bruchteil, können wir die Gurken des betreffenden Kontos mit der Differenz zwischen zwei Brüchen multiplizieren und berechnen, wie viel NEAR diesem Konto zusteht. Als Mikes Konto angelegt wurde, war der Bruchteil 0 geteilt durch eins, und als 100 NEAR eingezahlt wurden und die Gesamtzahl der Gurken 10 betrug, wurde dieser Bruchteil gleich 10. Als dann Josh hinzu kam und weitere 10 Gurken zur Gesamtzahl hinzufügte und weitere 100 NEAR verteilt wurden, wurde dieser Bruch um 5 erhöht, weil es insgesamt 20 Gurken und 100 NEAR gab. 100 NEAR geteilt durch 20 bedeutet also 5 NEAR pro Gurke, also wurden es 15. Wenn Mike nun zurückkommt, sieht er sich seinen Gurken Guthaben an, der 10 Near pro Gurke beträgt, bei einem globalen Contract von 15. Sein zuletzt erinnerter Wert ist Null, also nimmt er einfach die Differenz, die 15 multipliziert mit 10 beträgt, und setzt diesen Bestand in NEAR um, und diese 1 wird wieder auf 15 gesetzt. Wenn Josh zurückkommt, erhält er diesen Wert, der bei 10 lag, und er hat 10 Gurken und der aktuelle Wert ist 15. Die Differenz ist 5 multipliziert mit dem Gurken Guthaben von 10, also bekommt er 50 NEAR. Auf diese Weise verwalten wir das NEAR-Guthaben und eignen uns die Belohnungen an, die wir von Leuten erhalten und verwenden dabei konstante Zeitabstände für die Neuberechnung. Anstatt also einen ganzen Bruchteil im Speicher zu halten, verwenden wir einen globalen Nenner, der feststeht, und ich habe ihn auf 10 hoch 18 gesetzt, was der Genauigkeit von Gurken, Bananen und Avocados entspricht. Das ist der Hintergrund, wie das alles berechnet wird.



Schauen wir uns die Hauptstruktur des Contracts an, einen Contract, der Farm genannt wird. Er hat eine Lookup-Map von Konten und verwendet Short Hashes, ähnlich wie fungible Token mit Vaults. Er enthält die Account-ID des Bananen-Tokens, die auch hardcodiert werden kann, aber wir haben sie aus dem Contract übernommen, weil wir sie tatsächlich weitergeben können, denn dieser Account wurde erst nach dem Deployment eingerichtet und ich wollte den Zustand des Banana Berry Club Contracts nicht aktualisieren. Ich wollte den Zustand nicht noch einmal durch die Aktualisierbarkeit ändern, also habe ich stattdessen den Wert im vorherigen Contract hartcodiert. NEAR pro Gurke, der Bruch, den ich vorhin erklärt habe, ist der Zähler und das Gesamt Gurken Guthaben wird als Nenner benötigt. Vaults und Next Vote werden für Transfers verwendet; sie wurden wahrscheinlich nie dazu benutzt, Gurken zu transferieren, außer vielleicht einmal für einen Test. 



Dies ist das, was wir zuvor gesehen haben. Auch hier handelt es sich um einen Hash der Account-ID.



Die Account-Struktur ist der letzte Wert, bevor der Account mit diesem Teilwert in Berührung gekommen ist. Die near_balance ist das nicht beanspruchte Guthaben. Jedes Mal, wenn du ein Konto veränderst, indem du entweder mehr Gurken einzahlst oder NEAR beanspruchst, wird der letzte Wert aktualisiert und alle nicht beanspruchten NEAR aus der Differenz in dein lokales Guthaben verschoben, und cucumber balance ist dein Guthaben in Gurken. Der Wert near_claimed ist die Statistik, die nur angibt, wie viel Belohnung du bereits beansprucht hast. Es wird nicht für die eigentliche Contract-Logik benötigt. 



Es gibt zwei Hilfskonstruktionen nur für das Frontend. HumanAccount gibt Werte in einer besser lesbaren Form zurück und HumanStats ist eine globale Statistik für den Verbrauch. Schauen wir uns die Funktion take_my_near an, um zu sehen, wie sie funktioniert.



Als erstes überprüfen wir, ob genügend Gurken vorhanden sind, da wir sie als Nenner verwenden. Wir wollen nur eine Gurke, um dies tatsächlich auszulösen, was nur eine Vorsichtsmaßnahme ist. Man möchte diese Art von Dingen nicht auslösen. Lasst uns diesen Wert untersuchen. Was passiert, ist, dass man den Betrag von NEAR und yocto NEAR erhält und ihn mit dem Nenner global multipliziert. Man löst also einen Bruch, der NEAR pro Gurke geteilt durch den Nenner plus angehängte Bilanz geteilt durch die Gesamtbilanz der Gurken ist. Hier ist die Formel: near_per_cucumber / Nenner + beigefügtes Guthaben / Gesamt Gurken Guthaben. Also ist new_near_per_cucumber eigentlich der Zähler mit attached_deposit und dem Nenner, der dann durch den Nenner geteilt wird. Hier ist die Formel: new_near_per_cucumber = (near_per-cucumber_numer + denom + attached deposit) / denom. Dies ist die Formel, mit der wir die new_near_per_cucumber berechnen. Immer wenn Du einen Kontostand veränderst, wird Dein aktuelles Guthaben in eine feste Zahl umgewandelt und Du kannst dann jeden der Werte ändern, ohne die Logik zu unterbrechen. Diese Touch-Methode wird every Getter und every Change-Method genannt. Bevor Du das Konto änderst, wird immer die Touch Funktion für das Konto angewandt.



In get_near_balance wird beispielsweise das interne Konto abgefragt. Wenn das Konto existiert, ändern wir es lokal. Dann sollten wir den near_balance erhalten.



Wenn Du das Konto erhältst, das wir vorher verändert haben, erhältst Du die near_balance, cucumber_balance und claim balance. Das sind Funktionen zur Veranschaulichung, die etwas verändern, aber es wird nicht gespeichert, so dass der Kontowert nur vorübergehend verändert wird und nicht zurückgespeichert wird. Es wird lediglich eine Veränderung vorgenommen, die eine Art Neuberechnung mit dem neuesten Wert darstellt. 



Es wird gespeichert, wenn Du einen Änderungsaufruf tätigst, also zum Beispiel claim_near aufrufst. Wir erhalten Dein Konto und get_mut_account verändert das Konto tatsächlich. Du erhältst das Konto, das bereits aktualisiert wurde und dein Guthaben wird dir als near_balance angezeigt. Es setzt die near_balance auf Null und sagt, dass du das alles beansprucht hast, und es speichert diese Informationen in deinemKonto. Wenn Du dann einen positiven Wert beanspruchst, wird dieser von Deinem Konto an Dich überwiesen. Die Funktion gibt dabei zurück, wie viel NEAR Du beansprucht hast. Das Schöne an dieser Touch Method ist, dass sie an jedem beliebigen Punkt aufgerufen werden kann. Sie muss nicht an einem bestimmten Punkt aufgerufen werden, so dass sie immer das gleiche Ergebnis liefert, egal ob Du sie zweimal in der Mitte oder einmal mittendrin aufgerufen hast. Dies ist nur dazu da, dem Benutzer mitzuteilen, wie viel Guthaben er hat. Es sagt dir nur, wie viel NEAR du verdient hast, indem es den aktuellen Stand berechnet. Im Berry Club machen wir das Gleiche wie bei der Touch Funktion, und das ist auch nötig, denn sagen wir mal, du willst wissen, wie viele Bananen du gezüchtet hast. Da wir wissen, wann du dein Konto das letzte Mal verändert hast, beziehungsweise wann du zuletzt etwas gezüchtet hast, wissen wir, wie viele Pixel du hast. Wir können von einem bestimmten Zeitpunkt bis zum vorherigen Zeitpunkt multipliziert mit der Anzahl der Pixel, die Du hattest, berechnen, wie viele Bananen Du jetzt haben solltest, und das Frontend macht genau das Gleiche. Das Frontend simuliert es, es erhält dieselben Informationen, außer dem letzten Zeitpunkt, und erstellt dann einfach einen Timer, der vorwärts läuft und dies berechnet. Theoretisch muss die get_near_balance-Methode nicht den aktuellen NEAR-Wert zurückgeben, sondern kann einfach sagen: Hier sind die gesamten NEAR pro Gurke und die letzten gesamten NEAR pro Gurke und auch das letzte NEAR-Guthaben, aber stattdessen wird es auf der Ebene des Contracts gemacht. Angenommen, wir hätten keine Ansichtsmethoden, für die man nicht zahlt und nur einen Status zurückgibt und abruft, dann müsste man diese Logik am Frontend ausführen, anstatt sie hier im Speicher zu machen.
Token.rs
Die letzte Logik, die wir brauchen, ist die Art und Weise, wie Du deine Gurken aus dem Berry Club erhalten kannst. Dies geschieht durch die Verwendung von transfer_with_vault aus dem Berry Club. Wir haben bereits besprochen, wie die Map 122 funktioniert. 



Du übergibst die receiver_id, den Betrag und die Payload. Es gibt einen assert_paid Check, der nur überprüft, ob die Einzahlung positiv ist. Es sagt, oh, du brauchst mindestens 1 yocto NEAR, um Aufrufe mit einem Funktionsschlüssel zu verhindern, damit eine bösartige Berry Club UI nicht all deine Bananen abzapft. Es erhält GAS und initiiert dann einen Aufruf, der Bananen in einen Vault legt. Es wird auch ein Anruf an den Empfänger getätigt. In diesem Fall nennen wir es einen On-Farm Contract und übergeben der Absender-ID eine Menge Bananen, eine Vault-ID, die nur eine u64 ohne JSON ist, und einen Payload, der ein String ist. Im vorangegangenen Beispiel, als wir über map 122 sprachen, war die Payload eine Binärdatei von vec q8 in base64, weil es eine borsh serialisierte Payload war. Während der Diskussion habe ich bemerkt, dass, wenn Du dieses Argument in einer Wallet überprüfen würdest, Du nicht in der Lage sein würdest, die Payload zu sehen, die Du staken willst, so dass wir in dieser Contract Implementierung tatsächlich JSON für den Payload verwenden, so dass wir die JSON aus der String-Payload einfügen.  Es ist ein Enum mit einer einzigen Option namens deposit_and_stake.



Wenn man nun eine Funktion von dem Farm User Interface aus aufruft, die an die Wallet in den Argumenten geht, wird die Nutzlast wie ein angrenzender String innerhalb eines Strings sein, der Einzahlung und Einsatz angibt, anstatt eine Null zu sein, die als Basis kodiert ist, anstatt eine borsh serialisierte Version zu sein, ist es eine menschlich lesbare. Dieser Contract hat andere Payload-Typen als Uniswap, z.B. hat er einen Payload, der angibt, wie viel NEAR man maximal oder mindestens erhalten möchte. Die bösartige Uniswap-Benutzeroberfläche kann diesen Wert einfach ersetzen, und wenn Du ihn nicht auf der Wallet-Seite verifiziert hast, kann es sein, dass deine Transaktion tatsächlich unter das beste Angebot fällt. Wir haben das Konto mithilfe von get_mut_account erhalten. Diesen kann entweder ein bestehendes Konto erhalten oder ein neues Konto erstellen, bei dem alle Guthaben auf 0 gesetzt werden, wobei der letzte Zähler für den Preis von NEAR zu Gurken der aktuelle globale ist. Das bedeutet, dass du nichts gefarmt hast und dein Guthaben für Gurken gleich Null ist. Es verändert sich trotzdem, auch wenn es nicht nötig ist, wir hätten es vermeiden können, wenn wir die Map gemacht hätten, und dann gibt es den Hash und das Konto zurück. Das Konto ist bereits auf dem neuesten Stand. Was wir tun, ist, dass wir zuerst das gesamte Gurken Guthaben erhöhen und es dann in den Zustand des Kontos zurückspeichern, und wir erhöhen auch das globale Gurken Guthaben um die Menge der eingezahlten Gurken. Dann überprüfen wir nicht wirklich, ob der Vault Gurken enthält, also vertrauen wir darauf, dass der vorherige Aufrufer, der ein Bananen-Contract ist, die Bananen tatsächlich in den Vault gelegt hat, und wir geben das Versprechen aus dieser Methode zurück. Es ist eine seltsame Übereinstimmung mit einem einzigen Eintrag, weil die Payload im Moment nur einen Typ haben kann. Wir rufen withdraw_from_vault auf und wir geben den Betrag an, den wir abheben wollen, nämlich den vollen Betrag, und dann rufen wir die Account-ID des Bananen-Tokens zurück, die ein Berry Club Contract ist. Dieser Contract hat zwar noch keine Bananen erhalten, aber das ist ihm egal, weil er sowieso keine Bananen braucht. Er braucht keine Bananen, um fortzufahren, also ist es egal, wie lange er dort Gurken staken wird, und der Vault ist bereits verschlossen. Es erhöht das Guthaben der Gurken insgesamt, indem es die Anteile verteilt. Wenn take_my_near nun durchgeführt wird, kann es das neue gesamte Gurken Guthaben verwenden. Jetzt werde ich die Anzahl der Anteile auf alle Teilnehmer aufteilen. 
Fazit
Das ist der Überblick über die Verträge von Berry Club, Berry Farm und token.rs. Vielen Dank für das Durchlesen diesen Artikels und viel Glück bei Deinen zukünftigen Unternehmungen mit NEAR.

### NEAR Live-Contract Review | Teil 2: Der Staking-Pool-Contract

Einführung
Hey, ich bin Eugene und dies ist der zweite Teil der Serie zum Live Contract Review. Heute werden wir den Staking Pool Contract besprechen, der im Moment verwendet wird, um das NEAR Protocol Proof of Stake System zu sichern. Im Grunde genommen operieren alle Validatoren, die derzeit auf dem NEAR Protocol laufen, im Namen dieses Contracts. Sie kontrollieren nicht selbst den Account, welcher die für den Proof of Stake erforderliche Menge an NEAR-Token staked, sondern der Contract staked diese Menge an Tokens, und die Validatoren stellen lediglich einen Staking-Pool bereit und betreiben ihre Nodes. Heute werden wir diesen Contract genauer unter die Lupe nehmen. In den Kern Contracten haben wir einen Staking-Pool-Contract, der etwas komplizierter ist als der vorherige Contract, den wir reviewed haben (der Voting-Contract). Daher werden wir uns heute mehr auf die Logik und weniger auf die near_bindgen und Rust spezifischen Dinge konzentrieren, aber es wird wahrscheinlich ein wenig mehr Wissen über das NEAR-Protokoll erfordern. Hier ist der Contract für den Staking Pool auf dem NEAR Github Account. Unten ist das Originalvideo, auf welchem diese Anleitung basiert.


lib.rs
Constructor Structure


As before, the contract starts from the main structure. In this case it's a staking contract structure. As you can see there's near_bindgen, and BorshSerialize and BorshDeserialize. The structure now has way more fields than the past one, and there are some comments on them, most of them are probably up to date. The logic of the staking pool contract allows us to do the following: basically anyone can deposit some amount of NEAR tokens to the staking pool, and delegate them to the staking pool by staking them in the pool. That allows us to bundle together balances from multiple people (we call them accounts here) into one large stake, and this way this large state may actually qualify for validator seats. NEAR Protocol has a limited amount of seats for a single shard right now, there's at most 100 validator seats. You can think about the seats in the following way: if you take the total amount of token staked and divide it by 100 the result will be the minimum amount of tokens required for a single seat, except it's a little bit more complicated to involve removing the stakes that are not qualified to contain this minimum amount, etc. This contract basically is a standalone contract without any access key on it that is controlled by the owner. In this case the owner is provided in the initialization method. 
Initialization Method


Gehen wir also zur Initialisierungsmethode. Sie hat drei Parameter. Der erste ist owner_id, die Konto-ID des Besitzerkontos. Der Eigentümer verfügt über eine Reihe von Berechtigungen für diesen Contract, die es dem Contract erlauben, Aktionen auszuführen, die für den Rest der Accounts nicht verfügbar sind. Eine dieser Methoden besteht darin, im Namen des staking pools für den Voting-Contract abzustimmen, den wir beim letzten Mal besprochen haben. Der Eigentümer kann also die Abstimmungsmethode aufrufen.





Wir überprüfen dann, ob der Vorgänger gleich dem Besitzer ist, da diese Methode nur vom Besitzer aufgerufen werden kann.



Die Vote-Methode prüft also, ob die Methode nur vom Eigentümer aufgerufen wurde, und überprüft dann eine gewisse Logik, aber das ist im Moment nicht wichtig.



Der Contract ist also der Eigentümer welcher durch seine erweiterten Berechtigungen mehr Dinge tun kann, als alle anderen Accounts im Netzwerk. Dann werden noch ein paar weitere Felder abgefragt: der stake_public_key. Wenn Sie sich am NEAR-Protokoll beteiligen, müssen Sie einen öffentlichen Schlüssel angeben, der von Ihrem Validator-nodes verwendet wird, um Nachrichten im Namen des Validator-nodes zu signieren. Dieser öffentliche Schlüssel sollte einzigartig sein da Ihr Knoten möglicherweise in einem Rechenzentrum betrieben wird, das für einige Angriffe anfällig ist. In diesem Fall können die Angreifer höchstens dem Netzwerk schaden, aber nicht Ihrem Konto. Sie können Ihr Guthaben nicht stehlen, und Sie können diesen Schlüssel leicht ersetzen, verglichen mit dem, was Sie für den Ersatz des mangelhaften Zugangsschlüssels benötigen. Das dritte Argument des Vertrags ist die anfängliche Reward_fee_fraction. Dies ist die Provision, die der Eigentümer des Staking Pools für den Betrieb des Validierungs Knotens erhält. 



Dies ist ein Bruch, der einen Zähler und einen Nenner hat, und es erlaubt Ihnen im Grunde zu sagen "Ich nehme 1% der Belohnungen für den Betrieb dieses bestimmten Pools", zum Beispiel. Sagen wir, Sie haben 1 000 000 Token, die eine Belohnung erhalten haben, sagen wir, es gibt eine Belohnung von 10 000 Token, dann wird der Besitzer 1% davon nehmen, was 100 Token sind. Floats verhalten sich unvorhersehbar, wenn man sie multipliziert. Bei Brüchen kann man zum Beispiel mit einer größeren Anzahl von Bits rechnen. Bei der Division multipliziert man zum Beispiel zuerst den Betrag, der u128 ist, mit einem Zähler (dieser kann schon bei u128 überschreiten), aber deshalb machen wir das ja in u256. Dann dividiert man ihn durch den Nenner, was ihn wieder unter u128 bringen sollte. Dadurch erhält man eine höhere Genauigkeit als bei float64, das nicht mit u128-Bit-Präzision arbeiten kann, so dass es bei der Berechnung zu Rundungs- oder Präzisionsfehlern kommen kann. Sie benötigen also entweder eine höhere Genauigkeit von Floats, die sich nicht wirklich von der Mathematik unterscheiden, bei der wir dies mit u256 simulieren. Ursprünglich unterstützte Solidity keine Floats, und auch wir taten das ursprünglich nicht, aber das warf einige Probleme bei der String-Formatierung in Rust für das Debugging auf, so dass wir beschlossen, dass es nicht schadet, Floats zu unterstützen, besonders da wir dies auf der vm-Seite standardisieren. Das größte Problem mit Floats war das undefinierte Verhalten bei bestimmten Werten von Lasten. Zum Beispiel, was andere Bits enthalten, wenn man einen unendlichen Float hat. Wir haben dies standardisiert, und jetzt sind sie plattformunabhängig gleichwertig. Es ist also kein Problem, Floats jetzt in unserer VM-Umgebung zu verwenden. 



Die Standardpraxis bei init ist, dass wir zuerst prüfen, ob der Wert nicht vorhanden ist. Dann überprüfen wir die Eingabe. Als Erstes wird überprüft, ob der Bruch gültig ist und ob der Nenner nicht Null ist. Anschließend wird mit einer else-Anweisung überprüft, ob der Zähler kleiner oder gleich dem Nenner ist, d. h. ob der Bruch kleiner oder gleich 1 ist. Das ist wichtig, um einige logische Fehler zu vermeiden. Als Nächstes überprüfen wir, ob das Konto gültig ist. Dieser Contract wurde geschrieben, bevor es einige der Hilfsmetriken gab, die heute existieren. Zum Beispiel haben wir die gültige Konto-ID in JSON-Types, die diese Prüfung automatisch während der Deserialisierung durchführt, wenn sie ungültig ist, wird sie einfach in einen Panic-Modus versetzt. Danach ziehen wir den aktuellen Kontostand des Staking Contracts. Dieser Kontostand ist in der Regel groß genug, weil er für die Speicherung dieses speziellen Contracts bezahlt werden muss, und dann sagen wir, dass wir einige Token für den STAKE_SHARE_PRICE_GUARANTEE_FUND zuteilen werden. Der Staking Pool hat bestimmte Garantien, die für lokale Contracts wichtig sind. Garantien stellen sicher, dass Sie, wenn Sie in den Staking Pool einzahlen, in der Lage sein sollten, mindestens die gleiche Menge an Token abzuheben, und Sie können keine Token verlieren, auch nicht für so viel wie 1 000 000 000 000 yocto NEAR auf diesen Vertrag, indem Sie in den Staking Pool einzahlen und abheben. Der STAKE_SHARE_PRICE_GUARANTEE_FUND-Fonds beläuft sich auf etwa 1 Billion Yocto NEAR, während wir normalerweise etwa 1 oder 2 Billionen Yocto NEAR für Rundungsfehler verbrauchen. Schließlich erinnern wir uns daran, wie hoch der Saldo ist, den wir im Namen dieses Vertrags einsetzen werden. Dies ist erforderlich, um eine Ausgangsbasis für die Begrenzung der Rundungsdifferenzen zu schaffen. Als Nächstes überprüfen wir, ob das Konto nicht bereits einen Stack eingesetzt hat. Dies könnte eine gewisse Logik durchbrechen. Das soll nicht passieren, also initialisieren wir den Contract, bevor er etwas staked. Schließlich initialisieren wir die Struktur, aber wir geben sie nicht sofort zurück. Wir haben hier gerade die Struktur :StakingContract erstellt.



Dann führen wir eine Wiederherstellungs-Transaktion durch. Dies ist wichtig, denn wir müssen sicherstellen, dass der bereitgestellte Staking-Schlüssel ein gültiger, auf Ristretto beschränkter Schlüssel ist, z. B. ein 5 119 gültiger Schlüssel. Es gibt einige Schlüssel auf der Kurve, die zwar gültig, aber nicht ristretto-spezifisch sind, und Validierungsschlüssel können nur ristretto-spezifisch sein. Dies ist eine NEAR-Protokoll-spezifische Sache, und was passiert, ist, dass es eine Staking-Transaktion mit dem gegebenen Schlüssel macht. Sobald diese Transaktion aus dem Contract erstellt wurde, validieren wir diese Transaktion, wenn sie den Contract verlässt. Wenn der Schlüssel ungültig ist, wird ein Fehler ausgegeben und die gesamte Initialisierung des Staking Pools schlägt fehl. Wenn Sie einen ungültigen stake_public_key als Eingabe übermitteln, wird Ihre Vertragskonsolidierung und -bereitstellung sowie alles, was in dieser einen Batch-Transaktion geschieht, rückgängig gemacht. Dies ist wichtig, damit der Pool keinen ungültigen Schlüssel hat, denn dadurch könnten Sie den Stake anderer Leute blockieren. Als Teil der Garantien sagen wir, dass Ihre Token in 4 Epochen zurückgegeben werden, wenn Sie Ihren Einsatz zurücknehmen. Sie können dann abgehoben werden, und das ist wichtig, um sie an die Lockups zurückgeben zu können.



Ich denke, das sind zu viele Details, bevor ich den allgemeinen Überblick darüber erkläre, wie Contracts und Guthaben funktionieren. Lassen Sie uns das Konzept erklären, wie wir tatsächlich Belohnungen an Kontoinhaber in konstanten Zeitabschnitten verteilen können, wenn eine Epoche vergeht. Dies ist für die meisten Smart Contracts wichtig. Sie wollen in konstanten Zeitabschnitten für jede Methode agieren, anstatt in linearer Zeit für die Anzahl der Nutzer, denn wenn die Anzahl der Nutzer wächst, dann wächst auch die Menge an Gas, die für den Betrieb einer linearen Skala erforderlich ist, und irgendwann geht das Gas aus. Deshalb müssen alle Smart Contracts in konstanter Zeit agieren. 
Account Struktur


Die Art und Weise, wie es funktioniert, ist, dass wir für jeden Benutzer eine Struktur namens Account haben. Jeder Benutzer, der an diesen Staking-Pool delegiert hat, hat eine Struktur namens account, die die folgenden Felder enthält: unstaked ist der Saldo in yocto NEAR, der nicht gestaked ist, also nur der Saldo des Benutzers. Stake_shares ist der Saldo, aber nicht in NEAR, sondern in der Anzahl der Stake-Shares. Stake_shares ist ein Konzept, das zu diesem speziellen Stake-Pool hinzugefügt wurde. Wenn Sie einen Stake tätigen, kaufen Sie im Grunde neue Anteile zum aktuellen Preis, indem Sie Ihr Guthaben in Stake-Anteile umwandeln. Der Preis eines Anteils ist ursprünglich 1, aber mit der Zeit wächst er mit den Belohnungen, und wenn das Konto Belohnungen erhält, erhöht sich sein Gesamtguthaben, aber die Anzahl der Anteile ändert sich nicht. Wenn ein Konto Validierungsprämien oder andere Einzahlungen direkt auf das Guthaben erhält, erhöht sich der Betrag, den Sie für jeden stake share erhalten können. Nehmen wir zum Beispiel an, Sie hatten ursprünglich 1 Million NEAR, die auf dieses Konto eingezahlt wurde. Sagen wir, Sie erhalten 1 Million Anteile (ignorieren Sie die yocto NEAR für jetzt), wenn der Staking-Pool 10 000 NEAR an Belohnungen erhalten hat, haben Sie immer noch 1 Million Anteile, aber die 1 Million Anteile entsprechen jetzt 1 010 000 NEAR. Wenn nun jemand anderes zu diesem Zeitpunkt einen Einsatz tätigen möchte, wird er intern innerhalb des Contracts Anteile zum Preis von 1,001 NEAR kaufen, da jeder Anteil nun so viel wert ist. Wenn Sie eine weitere Belohnung erhalten, brauchen Sie trotz des Gesamtguthabens keine weiteren Anteile zu kaufen, und in der konstanten Zeit teilt jeder die Belohnung proportional zur Anzahl der Anteile, die er hat. Wenn Sie nun den Einsatz aufheben, verkaufen Sie im Wesentlichen diese Anteile oder verbrauchen sie unter Verwendung des Konzepts der fungiblen Token zugunsten des nicht gesetzten Guthabens. Wenn Sie also zum aktuellen Preis verkaufen, verringern Sie sowohl den Gesamtbetrag des Einsatzes als auch die Gesamtzahl der Anteile, und wenn Sie kaufen, erhöhen Sie den Gesamtbetrag des Einsatzes und die Gesamtzahl der Anteile, während der Preis konstant bleibt. Wenn Sie Ihren Einsatz erhöhen oder verringern, ändert sich der Preis nicht, wenn Sie die Belohnungen erhalten, erhöht sich der Preis. 



Der Preis kann nur steigen, und das kann zu Rundungsfehlern führen, wenn Ihr yocto NEAR und Ihr Saldo nicht genau übereinstimmen. Deshalb haben wir diesen Garantiefonds von 1 Billion Yocto NEAR, der ein paar Mal einen zusätzlichen Yocta NEAR in den Mix werfen wird. Und schließlich ist da noch der letzte Teil, denn das NEAR-Protokoll hebt den Einsatz nicht sofort auf und gibt das Guthaben zurück, sondern muss drei Epochen warten, bis Ihr Guthaben freigegeben und auf das Konto zurückgeführt wird. Wenn Sie die Einsätze aufheben, können Sie das Guthaben nicht sofort aus dem Einsatzpool abheben, sondern müssen drei Epochen lang warten. Erinnern Sie sich dann daran, in welcher Epoche Sie die letzte Aktion zum Aufheben des Einsatzes aufgerufen haben, und nach drei Epochen wird Ihr Guthaben wieder freigegeben, und Sie sollten es aus dem Einsatzpool abheben können. Es gibt jedoch eine Einschränkung: Wenn Sie die Freigabe im letzten Block der Epoche aufrufen, kommt das eigentliche Versprechen, das die Freigabe vornimmt, erst in der nächsten Epoche. Es kommt im ersten Block der nächsten Epoche an, und das verzögert die Freigabe des gesperrten Saldos auf vier statt drei Epochen. Das liegt daran, dass wir die Epoche im vorherigen Block aufgezeichnet haben, die eigentliche Transaktion aber im nächsten Block, in der nächsten Epoche, stattfand. Damit das nicht passiert, sperren wir den Saldo um vier Epochen statt um drei Epochen, um diesen Ausnahmefall zu berücksichtigen. Das ist es, was ein Konto ausmacht. Die Idee der Anteile ist nicht so neu, denn auf Ethereum verwenden die meisten Liquiditätsanbieter und automatisierten Market Maker dieses ähnliche Konzept. Wenn Sie zum Beispiel in den Liquiditätspool einzahlen, erhalten Sie eine Art Token aus diesem Pool anstelle des tatsächlichen Betrags, der dort vertreten ist. Wenn Sie aus dem Liquiditätspool abheben, verbrennen Sie diesen Token und erhalten die tatsächlich repräsentierten Token. Die Idee ist sehr ähnlich wie die, sie als Aktien zu bezeichnen, weil sie einen zugehörigen Preis haben, wir hätten sie auch anders nennen können. Das war fast von Anfang an der Fall bei diesem Staking-Pool-Contract. Es wurde erforscht, wie wir das richtig machen können, und eine Möglichkeit war, dass wir die Anzahl der Konten begrenzen, die auf ein bestimmtes Pool-Konto für diese spezielle Aktualisierung einzahlen können. Schließlich haben wir uns für die konstante Komplexitätszeit entschieden, und das war tatsächlich ein einfacheres Modell. Dann wurde die Berechnung der stake_shares-Struktur einigermaßen vernünftig, obwohl auch hier einiges zu berücksichtigen ist.
Contracts-Arten
Gehen wir diesen Contract einmal durch. Er ist nicht so gut strukturiert wie z. B. ein Lockup-Vertrag, denn ein Lockup ist noch komplizierter. Die Typen sind immer noch im selben Vertrag gebündelt. Es gibt eine Reihe von Arten von Typen, zum Beispiel ist reward_fee_fraction ein eigener Typ.



Account ist ein separater Typ, und es gibt auch ein für den Menschen lesbares Konto, das ebenfalls ein Typ ist, der nur für Aufrufe der Ansicht verwendet wird, also intern nicht für Logik verwendet wird.



Wenn wir dann mit allen Typen fertig sind, haben wir cross contract calls, die ein High-Level-Interface verwenden.



Es gibt zwei davon. Die Art und Weise, wie es funktioniert, ist, dass Sie ein Makro von near_bindgen namens ext_contract (steht für externen Contract) haben. Sie können ihm einen kurzen Namen geben, den er generiert und den Sie verwenden können. Dann haben Sie eine Trait-Beschreibung, die die Schnittstelle des externen Contracs beschreibt, den Sie verwenden wollen. Hier wird beschrieben, dass Sie eine Vote-Methode auf einem externen Vertrag aufrufen und ein Attribut übergeben können. Das Attribut is_vote ist ein boolescher Wert, der true oder false ist. Jetzt können Sie ein Versprechen erstellen, wenn Sie es brauchen, und ein Positionsargument anstelle eines serialisierten JSON-Arguments übergeben. Das Makro wird hinter den Kulissen in Low-Level-Promise-Apis eingebaut. Die zweite Schnittstelle ist für einen Callback auf unser Selbst, das ist ziemlich häufig, können Sie es ext_self nennen. Wenn Sie einen Callback benötigen und etwas mit dem Ergebnis des asynchronen Versprechens machen wollen, können Sie diese Art von Interface verwenden. Wir prüfen, ob die Staking-Aktion erfolgreich war. Schließlich haben wir diesen Hauptimplementierungsstruktur-Implementierungskörper des Staking-Pools.
Contract Dateistruktur
Dieser Contract ist in mehrere Module aufgeteilt.



Sie haben libs.rs, welche die Hauptdatei ist, und Sie haben auch ein internes Modul. Das interne Modul hat die Implementierung ohne das near_bindgen-Makro, so dass keine dieser Methoden sichtbar ist, um durch einen Contract von jemand anderem in der Blockchain aufgerufen zu werden. Sie können nur innerhalb dieses Contracts intern aufgerufen werden, womit sie keine JSON-Formate erzeugen und keinen Zustand deserialisieren. Sie verhalten sich alle wie normale Rust-Methoden. Wie dieser Vertrag auf hohem Niveau funktioniert ist, dass, wenn eine Epoche vergeht Sie bestimmte Belohnungen als Validator erwerben können.
Wichtige Methoden des Contracts


Wir haben eine ping-Methode, die den Contract anpingt. Die Ping-Methode prüft, ob eine Epoche vergangen ist, und dann müssen wir die Belohnungen verteilen. Wenn sich die Epoche geändert hat, wird sie auch neu gestartet, da sich die Höhe des Gesamteinsatzes, den der Contract zu leisten hat, ändern könnte. Der nächste Schritt ist die Einzahlung.



Die Deposit-Methode ist eine payable, was bedeutet, dass sie eine angehängte Einzahlung akzeptieren kann. Dies ähnelt dem Ethereum-Dekorator, der es Ihnen ermöglicht, Geld nur für die Methoden zu erhalten, die es erwarten. Daher wird near_bindgen standardmäßig in einen Panikzustand geraten, wenn Sie versuchen, eine Methode aufzurufen, z. B. ping, und eine Einzahlung an diese Methode anhängen. Folglich erlaubt uns payable, Einzahlungen anzuhängen. In jeder Methode gibt es einen internen Ping, um sicherzustellen, dass wir vorherige Belohnungen verteilt haben, bevor wir irgendeine Logik ändern. Die gemeinsame Struktur besteht darin, dass wir, wenn wir neu einzahlen müssen, zuerst die Logik ändern und dann neu einzahlen.



Die nächste Methode ist deposit_and_stake.  Dies ist eine Kombination aus zwei Methoden. Zum einen zahlen Sie das Saldo auf den Einsatzsaldo Ihres Accounts ein, und zum anderen wollen Sie den gleichen Betrag sofort einsetzen, anstatt zwei Transaktionen durchzuführen. Sie ist auch payable, weil sie auch eine Einzahlung akzeptiert.



Die nächste Methode ist withdraw_all. Sie versucht, das gesamte nicht eingesetzte Guthaben von dem Account abzuheben, der ihn aufgerufen hat. Wenn Sie mit dem Stake-Pool interagieren, müssen Sie mit dem Account interagieren, dem das Guthaben gehört. In diesem Fall ist dies die predecessor_account_id, und wir überprüfen das Konto und ziehen dann den nicht gesetzten Betrag ab, wenn wir können. Wenn er nicht abgehoben wird, kommt es zur Alarmierung. Zum Beispiel, wenn es immer noch gesperrt ist, weil es vor weniger als 4 Epochen freigegeben wurde.



Abheben ermöglicht es Ihnen, nur einen Teil des Guthabens abzuheben.



Dann setzt stake_all das gesamte nicht eingesetzte Guthaben ein, und es ist ziemlich selten, diese Methode zu verwenden, weil man normalerweise den deposit stake verwendet, welcher bereits das gesamte Guthaben hat.



In der Stake Methode wird nur eine spezifische Menge des Guthabens gestaked. Beispielsweise das Moonlight Wallet verwendet separate Kosten für die Einzahlung in den Stake, aber eine gebündelte Transaktion um dies zu tun.



Schließlich gibt es noch die Methode unstake_all, welche im Grunde alle Anteile aufhebt, indem die Anteile in yocto NEAR umwandelt werden. Es gibt eine Hilfsmethode, die sagt: "Konvertiere meine Anzahl von Anteilen in einen Betrag von yocto NEAR und runde ab, denn wir können dir nicht mehr geben für deinen Anteil multipliziert mit dem Preis. So erhalten wir den Betrag, und dann rufen wir unstake für den angegebenen Betrag auf.



Die Logik staked_amount_from_num_shares_ rounded_down verwendet u256, weil balances auf u128 arbeiten. Um einen Überlauf zu vermeiden, wird der Gesamtbetrag der Einsätze mit der Anzahl der Anteile in u256 multipliziert. Der Preis ist der abgerundete Quotient.



Die Aufrundungsversion staked_amount_from_num_shares_rounded_up ist sehr ähnlich, mit dem Unterschied, dass wir eine Prüfung durchführen, die es uns erlaubt, aufzurunden. Am Ende beider Varianten wird der Betrag auf u128 zurückgesetzt.

Dann haben wir eine unstake-Aktion, die der unstake_all-Aktion sehr ähnlich ist, außer dass man den Betrag übergibt.


Getter/View-Methoden
Danach gibt es eine Reihe von Getter-Methoden, die View-Calls sind, die Ihnen einige Beträge zurückgeben. Sie können den Kontostand ohne Einsätze, den Kontostand mit Einsätzen, den Gesamtsaldo des Kontos abfragen, prüfen, ob Sie sich auszahlen lassen können, und den Gesamteinsatz abfragen, also den Gesamtbetrag der aktiven Einsätze.



Dann können Sie herausfinden, wer der Eigentümer des Staking Pools ist, Sie können die aktuelle Belohnungsgebühr oder Provision des Staking Pools abrufen, den aktuellen Staking Key abrufen und es gibt eine separate Funktion, die überprüft, ob der Eigentümer den Staking Pool pausiert hat.



Angenommen, der Eigentümer führt eine Migration des Staking-Pools auf dem Node durch. Dafür muss der Staking Pool vollständig aufgehoben werden. Erst danach kann der Staking Pool beispielsweise pausiert werden. Diese Aufhebung sendet eine Status Transaktion an das NEAR-Protokoll. Erst danach kann kann der Staking Pool erst wieder in Betrieb genommen werden. Sie können jedoch immer noch Ihr Guthaben abheben, aber Sie werden keine Rewards mehr erhalten, bis die Migration vorüber ist.



Schließlich können Sie eine menschenlesbare Abrechnung erhalten, die Ihnen anzeigt, wie viele Token Sie für die Anzahl der Anteile zum aktuellen Preis tatsächlich haben, und schließlich steht dort, ob Sie Geld abheben können oder nicht.



Sie erhalten dann die Anzahl der Accounts, d.h. die Anzahl der Delegatoren für diesen Staking Pool, und Sie können auch mehrere Delegatoren auf einmal abrufen. Dies ist eine Paginierung für eine große Anzahl von Accounts innerhalb der Unordered Map. Eine Möglichkeit, dies zu tun, ist die Verwendung der Hilfsfunktion keys_as a_vector aus der unordered map. Damit erhält man eine dauerhafte Sammlung von Keys aus der Map, und dann kann man einen Iterator verwenden, um Konten aus diesen Keys abzufragen. Das ist nicht die effizienteste Methode, aber sie ermöglicht die Implementierung einer Paginierung für Unordered Maps.
Owner Methoden


Es gibt eine Reihe von Owner Methoden. Eine Owner-Methode ist eine Methode, die nur vom Owner aufgerufen werden kann. Der Owner kann den Staking Key aktualisieren. Nehmen wir an, sie haben einen anderen node, und der Owner muss einen anderen Schlüssel verwenden. Alle diese Methoden prüfen zunächst, ob nur der Owner sie aufrufen kann.



Dies ist die Methode, mit der die Provision für den Staking-Pool geändert wird. Der Owner kann die Provision, die ab dieser Epoche aktiv ist, sofort ändern, aber alle vorherigen Provisionen werden mit der vorherigen Gebühr berechnet.



Dies war dann die Voting Methode, die uns den Übergang zu Phase zwei des Mainnets ermöglichte.

Als Nächstes folgen die beiden Methoden, die ich bereits beschrieben habe und die es ermöglichen, das Staking zu pausieren und wieder aufzunehmen.



Der Rest sind nur Tests. Der größte Teil der Logik findet in den Interna statt.
Simulationstest
Wir haben auch Simulationstests für einen bestimmten Pool. Diese Simulationstests zeigen, wie das Netzwerk tatsächlich funktionieren wird. Zunächst haben wir den Pool initialisiert.



Bob ist der Delegator. Bob ruft die Deposit Methode des Pools auf, bei der es sich um den deposit_amount handelt. Dann kann Bob überprüfen, ob das nicht eingesetzte Guthaben korrekt funktioniert. Wenn Bob den Betrag einsetzt wird dessen höhe zunächst überprüft.



Bob ruft die Ping-Methode auf. Es gibt keine Belohnungen, aber in Simulationen funktionieren die Belohnungen sowieso nicht, also muss man das manuell machen. Wir überprüfen noch einmal, ob Bobs Betrag immer noch derselbe ist. Dann wird der Pool wieder aufgenommen. Wir verifizieren, dass der Pool wieder aufgenommen wurde, und sperren dann auf Null. Dann simulieren wir, dass der Pool einige Belohnungen erworben hat (1 NEAR) und Bob pingt den Pool an. Dann überprüfen wir, ob der Betrag, den Bob erhalten hat, positiv ist. Das ist ein sehr einfacher Simulationsfall, der besagt, dass Bob zuerst in den Pool eingezahlt hat, was verifiziert, dass das Anhalten und Wiederaufnehmen funktioniert, oder simuliert, dass es funktioniert, und sicherstellt, dass der Pool während des Pausierens nicht sperrt. Bei der Wiederaufnahme des Vorgangs wird der Pool dann tatsächlich eingesetzt. Mit diesem Test wird also nicht nur dies überprüft, sondern auch, ob Bob die Belohnung erhalten hat und ob die Belohnung verteilt wurde. Es gibt noch einen weiteren Test, der eine gewisse Logik überprüft, aber der ist komplizierter. Es gibt einige Unit-Tests, die bestimmte Dinge überprüfen sollen.



Einige dieser Tests sind nicht ideal, aber sie überprüfen bestimmte Dinge, die gut genug waren, um sicherzustellen, dass die Berechnung aufgeht.
internal.rs
Internal Ping Method


Kommen wir nun zu internal_ping. Das ist die Methode, die jeder über ping aufrufen kann, um sicherzustellen, dass die Belohnungen verteilt werden. Im Moment haben wir aktive Stake-Pools und es gibt einen Account, der von einem der NEAR-Leute gesponsert wird, der im Grunde genommen jeden Stake im Pool alle 15 Minuten anpingt, um sicherzustellen, dass die Rewards verteilt wurden und auf dem Kontostand angezeigt werden. Auf diese Weise funktioniert die Reward-Verteilung. Wir überprüfen zunächst die aktuelle Epochenhöhe. Wenn die Epochenhöhe gleich ist, hat sich die Epoche nicht geändert, wir geben false zurück, so dass Sie nicht neu starten müssen. Wenn sich die Epoche geändert hat, erinnern wir uns daran, dass die aktuelle Epoche (Epochenhöhe) existiert, und wir erhalten den neuen Gesamtsaldo des Accounts. Ping kann aufgerufen werden, wenn einige Token durch Depotabstimmungen eingezahlt wurden, und sie sind bereits Teil des account_balance sind. Da ping vorher aufgerufen wurde, müssen wir diesen Saldo abziehen, bevor wir die Belohnungen verteilen. Wir erhalten den Gesamtbetrag, den das Konto hat, einschließlich des gesperrten und des nicht gesperrten Guthabens. Der gesperrte Kontostand ist ein Einsatz, der Belohnungen erhält Dieser kann in bestimmten Szenarien, in denen Sie Ihren Einsatz verringern, ebenfalls Belohnungen erhalten, aber Ihre Belohnungen werden noch für die nächsten zwei Epochen berücksichtigt. Danach werden sie auf den nicht eingesetzten Betrag zurückgesetzt. Wir überprüfen mit assert!, dass der Gesamtsaldo höher ist als der vorherige Gesamtsaldo. Dies ist eine Invariante, die der Staking-Pool benötigt. Im Testnetz gab es eine Reihe von Fällen, in denen diese Invariante nicht erfüllt wurde, weil die Leute immer noch Zugriffsschlüssel auf denselben Staking-Pool hatten, und wenn man diesen hat, gibt man das Guthaben für Gas aus, und man kann sein Gesamtguthaben verringern, ohne die Belohnung zu erhalten. Schließlich berechnen wir den Betrag der Rewards, die der Staking-Pool erhalten hat. Dies ist das Gesamtguthaben abzüglich des vorher bekannten Gesamtguthabens, des Guthabens aus der vorherigen Epoche. Wenn die Rewards positiv sind, verteilen wir sie. Als erstes berechnen wir den Reward, den der Besitzer für sich selbst als Provision nimmt.



Wir multiplizieren die Reward_fee_fraction mit dem Gesamtbetrag der erhaltenen Rewards und runden diesen ebenfalls ab, indem wir den Zähler in u256 mit dem Wert multiplizieren und durch den Nenner in u256 dividieren.



Die owner_fee ist der Betrag in yocto NEAR, den der Eigentümer für sich selbst behält. Die remaining_reward ist die verbleibende Reward, die zurückgegeben werden muss. Dann geht es weiter zum Restaked. Der Eigentümer hat die Rewards in yocta NEAR erhalten, nicht in Anteilen, aber da die gesamte Logik in Anteilen sein muss, kauft der Eigentümer des Staking-Pools Anteile zum Preis der Post-Reward-Ausschüttungen an den Rest der Delegierten. num_shares ist also die Anzahl der Anteile, die der Owner als Entschädigung für den Betrieb des Staking Pools erhält. Wenn sie positiv ist, erhöhen wir die Anzahl der Anteile, schonen den Account des Owners und erhöhen auch den Gesamtbetrag des Einsatzes in Anteilen. Wenn aus irgendeinem Grund während der Abrundung dieser Saldo Null wurde, war die Belohnung sehr klein, und der Preis pro Anteil war sehr groß, und der Pool erhielt nur Null Belohnungen. In diesem Fall wird dieser Saldo einfach auf den Preis pro Anteil aufgeschlagen, anstatt den Eigentümer zu entschädigen. Als Nächstes fügen wir einige Gesamtprotokollierungsdaten ein, die besagen, dass die aktuelle Epoche existiert, dass wir die Belohnungen in Form von Anteilen oder Token erhalten haben und dass das Gesamtguthaben des Pools positiv ist. Anschließend wird die Anzahl der Anteile protokolliert.

Die einzige Möglichkeit, die Anzahl der Anteile nach außen zu tragen, sind die Protokolle. Wenn der Owner dann Belohnungen erhalten hat, heißt es, dass die Gesamtbelohnung so viele Anteile waren. Zum Schluss merken wir uns nur noch den neuen Gesamtsaldo und das war's. Wir haben alle Rewards in konstanter Zeit verteilt und nur ein Account (das Account des Owners) für die Provision aktualisiert, und das auch nur, wenn die Provision positiv war.
Interne Stake-Methode


Der internal_stake ist der Ort, an dem wir den Preisgarantiefonds implementieren. Nehmen wir an, der Vorgänger, in diesem Fall nennen wir ihn account_id, möchte eine bestimmte Menge an Token einsetzen. Der Saldo ist eigentlich kein JSON-Typ, da es sich um eine interne Methode handelt und wir hier kein JSON benötigen. Wir berechnen, wie viele Anteile abgerundet werden müssen, um den gegebenen Betrag zu setzen, also wie viele Anteile der Owner erhalten wird. Der Wert muss positiv sein. Dann prüfen wir den Betrag, den der Owner für die Anteile zahlen muss, ebenfalls abgerundet. Damit soll sichergestellt werden, dass der Owner beim Kauf von Anteilen und deren Rücktausch ohne Belohnung niemals die 1 yocto NEAR verliert, da dies die Garantie brechen könnte. Schließlich stellen wir fest, dass der Account über genug Geld verfügt, um den belasteten Betrag zu bezahlen, und wir verringern den internen unbesetzten Saldo und erhöhen den internen Anteilssaldo des Accounts. Als Nächstes runden wir den Einsatzbetrag für die Anzahl der Anteile auf, so dass die Anzahl der Anteile tatsächlich aufgerundet wird. Dieser 1 zusätzliche Penny oder 1 zusätzlicher Yocto NEAR wird aus dem Garantiefonds während der Aufrundung der Anteile kommen. Wir haben dem Nutzer weniger berechnet, aber wir haben mehr zu dem Betrag dieser 1 Billion Yocto NEAR beigetragen, den wir ursprünglich dafür vorgesehen hatten. Diese Differenz beträgt in der Regel nur 1 Yocto NEAR, die durch Auf- oder Abrundung entstehen kann. Danach gibt es den Betrag von total_staked_balance und total_stake_shares. Als nächstes geben wir neue Anteile dazu. Schließlich erstellen wir ein Protokoll und geben das Ergebnis zurück.



Unstaking funktioniert ganz ähnlich. Sie runden auf die Anzahl der Anteile auf, die Sie bezahlen müssen. Dann berechnen wir den Betrag, den Sie erhalten, wobei wir wiederum aufrunden, um Ihnen eine Überzahlung zu ermöglichen. Auch dieser Betrag stammt aus einem Garantiefonds. Dann verringern wir die Anteile, um den Betrag zu erhöhen und geben an, wann Sie das Guthaben zwischen vier Epochen freischalten können. Der unstake_amount wird abgerundet, so dass wir etwas weniger freigeben, um den Preis der anderen Teilnehmer des Pools zu garantieren. Das ist so ziemlich das, wie der Stake-Pool funktioniert und wie die Mathematik funktioniert. Wir kompensieren Rundungsfehler aus den Mitteln, die wir zugeteilt haben.
Fazit
Wir haben die Ristretto-Schlüssel während des Entwurfs dieses Contracts aktualisiert und es war überraschend, dass wir dies einkalkulieren mussten. Im STAKE_SHARE_PRICE_GUARANTEE_FUND sollte 1 Billion yocto NEAR für 500 Milliarden Transaktionen ausreichen, was für den Staking-Pool lang genug sein sollte, damit er nicht wieder aufgefüllt werden kann, da die Belohnungen beim nächsten Ping sofort wieder auf den total_stake_balance verteilt werden.  Wir haben ziemlich viel Zeit und Mühe auf diesen Contract verwendet, weil wir tonnenweise Sicherheitsüberprüfungen durchgeführt haben, sowohl intern als auch extern, vor allem im Hinblick auf die Mathematik. Das war kompliziert und es wurden einige Dinge entdeckt, wie der Ristretto-Schlüssel, welcher erst bei den Überprüfungen auftauchte. Wir haben das Änderungsprotokoll dieses Contracts markiert, und auch in der Readme gibt es einen Haufen Dinge, die während der Entwicklung und des Testens auf dem Live-System aufgetaucht sind, aber die ursprüngliche Version benötigte etwa eine Woche zum Schreiben. Später haben wir sie bereinigt, getestet und verbessert. Dann haben wir eine Reihe von Überarbeitungen vorgenommen. Das Pausieren und Wiederaufnehmen wurde vom Pool gefordert, weil der Owner sonst nicht in der Lage wäre, den Stake aufzuheben, wenn sein Node ausfällt. Sie würden das Netzwerk angreifen. Im Wesentlichen würde dieser aktive Einsatz die Validierung fordern und nicht das Netzwerk betreiben. Früher hatten wir kein Slashing. Das war zwar kein Problem für die Teilnehmer, aber ein Problem für das Netzwerk selbst. Auf diese Weise kann der Eigentümer das Staking pausieren, wenn er den Pool nicht betreiben will, wenn er in den Pool migriert, und vorher so viel wie möglich kommunizieren. Als Nächstes haben wir das Vote-Interface aktualisiert, um sie an den endgültigen Voting-Contract der zweiten Phase anzupassen. Wir fügten helper view-Methoden hinzu, um Konten in einer für Menschen lesbaren Weise abfragen zu können. Schließlich gab es einige Verbesserungen bei der Zusammenführung von Methoden, so deposit_and_stake, stake_all, unstake_all und withdraw_all. Anstelle eines initialen View-Calls, welcher den Betrag zu erhält und den Betrag setzt um den Einsatz aufzurufen, wurde der folgende Weg implementiert:



Wenn Sie einen Einsatz tätigen, setzen Sie nicht nur den Betrag ein, sondern wir fügen auch ein Versprechen hinzu, um zu prüfen, ob der Einsatz erfolgreich war. Das Versprechen wird für zwei Dinge benötigt: Wenn Sie versuchen, mit einem ungültigen Schlüssel (nicht ristretto-spezifischen Schlüssel) zu setzen, wird das Versprechen vor der Ausführung fehlschlagen. Es scheitert bei der Validierung, bevor es gesendet wird. Dies wird erreicht, ohne dass eine Prüfung im Contract notwendig ist. Dadurch ist es möglich den letzten Call rückgängig zu machen, und alles wird gut sein. Wir haben auch den Mindesteinsatz auf Protokollebene eingeführt. Der Mindesteinsatz beträgt ein Zehntel des letzten Platzierungspreises, und wenn Ihr Contract versucht, einen geringeren Einsatz zu leisten, wird die Aktion fehlschlagen, und Sie werden das Versprechen nicht senden. Angenommen, Sie möchten einen bestimmten Betrag abheben und Ihr Guthaben ist unter ein Zehntel des Einsatzes gefallen. Die Aktion kann fehlschlagen, und Sie werden den Stake nicht aufheben, obwohl Sie ihn brauchen, um zu garantieren, dass der Unstake stattfindet. In diesem Fall haben wir diesen Callback, der prüft, ob die Staking-Aktion erfolgreich abgeschlossen wurde. Dieser Callback prüft im Grunde, dass wir die Absteckung aufheben müssen, wenn sie fehlschlägt und der Saldo positiv ist. Es wird also unstake für eine Aktion aufgerufen, bei der der Einsatz null ist, um sicherzustellen, dass das gesamte Guthaben freigegeben wird. Während der Tests dieser Contracte, die wir im Beta-9-Testnetz vor der Wartung durchgeführt haben, kann man sich um 4 Epochen in der Zeit zurückversetzen lassen. Der Contract war etwa im Sommer fertig, so dass die Tests dieser Iteration aufgrund der Komplexität, die die Interaktion mit dem Protokoll mit sich bringt, wahrscheinlich 2-4 Monate dauerten. Es gab eine ganze Menge zu lernen, von der Paginierung bis zu den Hilfsmethoden und der Zusammenstellung einiger Dinge. Eine Sache, die wirklich schön wäre, wäre die Möglichkeit, Einsätze oder Einzahlungen und Einsätze in einem lock-up-Contract zusammenzufassen. Im Moment muss man manuell angeben, wie viel man auf einen Lockup Contract setzen will, aber es wäre toll, wenn man nicht über sein Yocto NEAR nachdenken müsste und wie viel es für die Lagerung gesperrt ist. Sie wollen einfach alles von deinem Lockup staken, aber da es bereits eingesetzt wurde, war es zu spät, darüber nachzudenken. Es gibt auch Gas, das fest kodiert ist, und mit der allgemeinen Gebührensenkung können diese Zahlen nicht geändert werden, weil sie bereits in der Chain ist.



Die Vote ist also nicht wichtig, aber die ON_STAKE_ACTION_GAS-Methode erfordert, dass man eine große Zahl für jeden Einsatz hat, und man kann sie nicht verringern. Das Risiko, bei jedem Call in diesem Contract Aktionen durchzuführen, erfordert eine große Menge an Gas, und das Problem ist, dass das verschwenderisch ist. Angenommen, wir einigen uns darauf, das gesamte Gas zu verbrauchen, dann wird dieses Gas immer verbraucht und verschwendet, und außerdem wird die Anzahl der Transaktionen, die man in einen Block packen kann, eingeschränkt, wenn wir das Gas in diesem Fall beschränken. Es gab viele Iterationen beim Testen des Contracts unter Verwendung des Simulationstest-Frameworks, welche wir stark verbessert haben. Wenn wir später zu den Lockup Contracts kommen, können Sie sehen, wie sich die Struktur der Lockup Contracts gegenüber diesem verbessert hat.

### O que são DAOs? Aprendendo sobre a Sputnik DAO.

Uma das coisas mais empolgantes que ganhou muita força nos últimos tempos é o conceito de DAO ou “Organização Autônoma Descentralizada”. A ideia é criar um negócio nativo da Internet que seja de propriedade coletiva e gerenciado por seus membros. Não há CEO controlando o fluxo do negócio, nem CMO, nem CFO, nem conselho de administração centralizado. Em vez disso, a lógica de negócios e a execução são incorporadas aos contratos inteligentes para garantir uma implantação simplificada.

Exemplos hipotéticos de DAOs:

 	Caridade: Qualquer um pode se tornar um membro e qualquer um pode doar. O grupo decide como gastar as doações.
 	Rede Freelance: Rede de empreiteiros que juntam seus fundos para ferramentas relacionadas a freelancers.
 	Empreendimentos e doações: Um fundo de hedge descentralizado onde os membros podem reunir seus fundos e votar em diferentes propostas.

Como as DAOs são diferentes?
As DAOs executam certas regras que são registradas no contrato inteligente e mantidas na blockchain. Um contrato inteligente pode ser pensado como um acordo automatizado entre duas ou mais partes. Devido à natureza transparente do blockchain, é impossível alterar o código que rege o contrato inteligente sem que toda a rede conheça. Isso é o que torna a DAO mais flexível e robusta do que as organizações típicas.

 	DAOs são uma organização democratizada em que cada membro precisa votar em quaisquer mudanças que precisem ser implementadas. A DAO usa governança baseada na comunidade em vez de uma governança baseada em executivos.
 	DAOs são globais e completamente transparentes.

Por que as organizações hierárquicas não são boas o suficiente
Uma estrutura organizacional hierárquica e vertical é uma maneira comum de organizar um negócio. A ideia é simples – cada pessoa dentro da organização (exceto a que está no topo) está subordinada a outro indivíduo ou entidade. Assim, aqueles com mais poder estão no topo do gráfico. Ao mesmo tempo, aqueles com menos poder apareceriam na parte inferior. No entanto, devido à sua estrutura inerente, apresenta várias deficiências quando comparado aos DAOs.
 




DAOs
Hierárquico


Estrutura
Plano e democratizado
Hierárquico


Votação
Cada mudança no sistema requer votação pelos membros.
Se um sistema requer ou não votação depende da estrutura e das regras definidas pelo sistema.


Intermediário
Os votos são computados e o resultado implementado sem um intermediário confiável.
Se a votação for permitida, eles precisam ser computados por um intermediário.


Automação
As questões relacionadas à governança são tratadas automaticamente de forma descentralizada.
Requer manuseio humano e centralizado. Portanto, eles são vulneráveis ​​à manipulação.


Visibilidade
Totalmente público e transparente.
Privado e principalmente opaco.



Modelos de associação em DAOs
Então, como exatamente funciona um modelo de associação DAO? Isso é muito importante, pois se tornar um membro é fundamental para o modelo operacional de um DAO.

Ok, então existem dois modelos de associação:

 	Baseado em token.
 	Baseado em ações.

Baseado em token
A maioria dos protocolos possui um token de governança que pode ser negociado em várias exchanges centralizadas e descentralizadas. Pode-se ganhar esses tokens participando de um algoritmo de consenso ou fornecendo liquidez. Como o nome sugere, possuir esses tokens dá acesso a direitos de voto dentro do protocolo. Quanto mais tokens você possuir, maior será o seu poder de voto. Um exemplo disso é o MakerDAO e seus tokens de governança – MKR. Qualquer pessoa pode participar da governança do MakerDAO comprando os tokens MKR.
Baseado em compartilhamento
Comparado aos DAOs baseados em token, as DAOs baseados em compartilhamento são mais restritas. Os membros potenciais devem apresentar uma proposta para ingressar na DAO. A proposta acompanha uma homenagem em forma de fichas ou algum trabalho. A parte de um participante representa seu poder de voto direto. Eles podem sair a qualquer momento com uma parte proporcional da tesouraria. MolochDAO – um protocolo responsável por financiar projetos baseados em Ethereum – é um exemplo de DAO baseado em ações. Você não pode comprar tokens de governança no mercado aberto para obter acesso ao DAO. Para participar, você precisa do conhecimento e do capital necessários para ajudar a apoiar projetos em potencial.
Aprendendo com os erros - O hack da “The DAO”
É fundamental aprender sobre o hack da “The DAO” que dividiu o Ethereum em Ethereum e Ethereum Classic. Em 2016, o Ethereum DAO foi criado para mudar o jogo e repensar completamente a maneira como os fundos de risco, ou Venture Funds, funcionam. A ideia era que os detentores de tokens DAO votassem em várias propostas de projetos. Se uma proposta obtiver 20% de votos da comunidade, eles receberão os fundos necessários para começar.

O DAO também tinha um “mecanismo de divisão”. Basicamente, se os membros não estiverem satisfeitos com os projetos da lista de permissões, eles podem se separar da DAO para criar seu próprio “DAO filho”. De qualquer forma, a DAO foi um grande sucesso e acumulou mais de US$ 150 milhões em ETH em uma venda coletiva. Por uma questão de perspectiva, isso foi 14% de todos os tokens de ether emitidos até aquele momento.

No entanto, “The DAO” tinha uma vulnerabilidade de código significativa. Em 17 de junho de 2016, um invasor explorou essa vulnerabilidade para reentrar continuamente no sistema e desviar US$ 50 milhões em ETH. A maioria da comunidade decidiu reverter esse incidente por meio de um hard fork. No entanto, parte da comunidade foi contra esse movimento. Isso acabou levando a um hard fork que dividiu o protocolo Ethereum em Ethereum e Ethereum Classic.
Near Protocol e Sputnik DAO
Co-fundador do Near Protocol, Illia Polosukhin anunciou o Sputnik DAO neste artigo . Ele explicou a DAO como “uma maneira para comunidades e organizações novas e existentes em todo o mundo terem representação on-chain de seu grupo, gerenciar suas atividades on-chain, governar sua tomada de decisões e (importante!) interagir com outras DAOs .”

O Sputnik tomou as seguintes inspirações para formar a “primeira onda” de experimentação de DAOs:

 	A forma como a comunidade controla a governança não se adapta ao número de pessoas envolvidas. Muitas DAOs falharam por vários motivos, desde questões técnicas até a falta de interesse em votar dos membros, ou a falta de um fator unificador e motivador.
 	É impossível ter um sistema DAO completamente com 100% de consenso, os interesses vão flutuar e as opiniões das pessoas sobre uma proposta podem mudar. A minoria no grupo poderia bifurcar ou divergir do grupo para seguir um novo sistema DAO.
 	Uma comunidade ou organização precisa de liderança. Uma comunidade ideal deve ter membros dedicados que sejam responsáveis ​​pela coordenação, potencialmente pela moderação.
 	Mesmo que a comunidade tenha permissão ilimitada e seja pseudônima, deve haver alguns membros conhecidos publicamente que criarão o núcleo da comunidade.
 	Quanto mais focada no “produto” for uma comunidade descentralizada, mais focada deve ser a liderança.
 	A ponderação puramente baseada em participação sempre falha porque a maioria das partes interessadas não pode ou não quer ser participante ativa.

A interface do Sputnik
No momento em que você for para a página inicial do Sputnik , você verá a seguinte tela.



Ao clicar em “NEAR Forum” você verá os diferentes tópicos de conversação de forma organizada e apropriada.



Na página inicial, se você clicar em “Launch App”, terá acesso às diferentes DAOs listadas no sputnik. 



Vamos dar um exemplo de algo mais próximo a nós. Vamos conferir todas as propostas no Learn NEAR DAO.



Então, como podemos ver há várias propostas listadas aqui, junto com seus respectivos pagamentos (em NEAR). Se uma proposta for aprovada ou rejeitada, ela será marcada assim. Por exemplo, na ID da proposta 22, alguém traduziu com sucesso a página inicial e o rodapé para “vietnamita”, e é por isso que você pode ver o “1” ao lado de “Approve” e o selo “Success”.


Como usamos o Sputnik DAO no LeanNEAR.Club
Existem dois níveis de DAO em uso:

Mother DAO e as seguintes subDAOs:

 	https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near 

Veja a Mother DAO como “Cliente/Fundadora”, as subDAOs como “Contratada” e membros das subDAOs como “Subcontratada”.

Vamos dar uma olhada em como funciona para a tradução da comunidade. Um guia dos 3 principais projetos NFT sobre o protocolo NEAR precisa ser traduzido em vietnamita. Os membros da SubDAO enviam propostas para tradução e revisão.



Em seguida, um deles apresentou uma proposta consolidada ao Mother DAO com subDAO como receptor de fundos



Uma vez que o trabalho é aceito e o Guia traduzido é publicado, os membros do subDAO dividem os fundos recebidos de acordo com as propostas apresentadas anteriormente.

Para possíveis resoluções de conflitos, o membro Mother DAO atua também como Membro Votante em todas as subDAOs.
Conclusão
Então, aí está. DAOs são incrivelmente disruptivas. No entanto, é preciso implementá-las corretamente para realmente colher os frutos. Parece que a Near Protocol realmente decifrou o código com o Sputnik!

### NEAR Message System Beta test Phase 2

Follow @LearnNEAR on Twitter

Beta test sprint starts: April 8, 0:01 am ET
Beta Test sprint ends: April 11, 11:59 pm ET
Requirements 

 	Get yourself our Telegram bot LNC NEAR testnet watcher  to get notified on transactions
 	Login the app NMS with NEAR account
 	Send at least 3 public messages to 3 of your NEAR friends. And ask them to Reply to your messages in 1 day
 	Send at least 2 private messages to 2 of your NEAR friends. And ask them to Reply to your messages in 1 hour
 	Perform at least 1 "Claim Back" operation
 	Make screenshot when you are done!
 	Tweet with your screenshot "I've just NMSed  my friend at NEAR Message System, project from @LearnNEAR  Barrel"
 	Fill the Feedback form

The top 20 beta testers will get 1 NEAR, the best feedback submitter will get 10 NEAR. Please make sure that your testnet and main account MATCH exactly - eg. john.testnet and john.near.

Happy Testing!

### O que é a NEAR Protocol?

Resultado esperado: entendimento básico de como o NEAR funciona na perspectiva do usuário final
NEAR é uma plataforma de aplicações descentralizada que roda sobre a blockchain NEAR Protocol. Esta blockchain, que funciona em centenas de máquinas em todo o mundo, é desenvolvida para ser irestrita e aberta a todos, com alto desempenho e segura o suficiente para criar uma camada de dados forte e descentralizada para a nova web. A principal missão da NEAR é apresentar uma plataforma ideal para executar aplicativos que podem ter acesso a uma pool compartilhada e segura de: dinheiro, identidade e dados de propriedade de seus usuários. Ela combina os recursos de rede resistente a partições, computação sem servidor e armazenamento distribuído em um novo tipo de plataforma. 

Portanto, antes de prosseguirmos, vamos aprender um pouco da história e ver como as plataformas blockchain evoluíram ao longo do tempo.
A evolução da tecnologia Blockchain
Desde que Satoshi Nakamoto lançou o whitepaper do Bitcoin em outubro de 2008, o mundo se familiarizou com a tecnologia blockchain revolucionária. Na última década, o blockchain passou por três estágios de evoluções.

Geração 1: Bitcoin

Bitcoin é o exemplo perfeito da blockchain de primeira geração. O objetivo desta blockchain é ser um sistema de pagamento simples e direto. Começando como a “moeda da internet”, o Bitcoin se tornou uma das classes de ativos mais procuradas. No entanto, há um grande problema quando se trata de BTC. É inviável realizar transações complicadas por ela, já que podem conter várias camadas de metadados e lógica anexadas a elas.

Geração 2: Ethereum e plataformas de contratos inteligentes

Ethereum inaugurou as plataformas blockchain de segunda geração com contratos inteligentes. Por fim, os desenvolvedores conseguiram programar transações sofisticadas por meio desses contratos inteligentes e criar aplicativos descentralizados (dApps). Por meio desses dApps, os casos de uso do blockchain aumentaram consideravelmente.

No entanto, este ecossistema vem enfrentando problemas devido ao seu crescimento. O principal é que esses blockchains estão sofrendo de graves problemas de escalabilidade. Por exemplo, o Bitcoin tem uma taxa de transferência de 7 transações por segundo, enquanto o Ethereum pode gerenciar apenas 25. Quando você compara isso com o PayPal (115 tps) e Visa (1.700 tps), é muito ruim.

Para ser justo, Ethereum e Bitcoin recentemente tentaram corrigir esses problemas de escalabilidade com várias soluções de camada dois, como lightning network, raiden, plasma protocol etc. A ideia aqui é criar uma camada adicional sobre a blockchain subjacente onde o protocolo principal pode delegar tarefas repetitivas e complicadas.

No entanto, existem dois problemas com essa abordagem. Em primeiro lugar, essas soluções de camada 2 ainda não alcançaram a aceitação das massas. Em segundo lugar, elas arruínam a arquitetura original do protocolo, o que pode ter implicações duradouras.

É aí que entra a terceira geração.

Geração 3: Near Protocol

O NEAR é um exemplo das blockchains de terceira geração, que visam resolver os problemas de escalabilidade e permitir que usuários finais e desenvolvedores aproveitem todo o potencial dos contratos inteligentes e da tecnologia blockchain. Em vez de depender da tecnologia da camada 2, o NEAR se liberta da ideia de que cada nó que participa da rede precisa executar todo o código porque isso cria essencialmente um grande gargalo e retarda todas as outras abordagens.

Para corrigir esse problema, o NEAR usa uma técnica que já é predominante no mundo dos bancos de dados, o sharding. Se executado corretamente, permite que a capacidade da rede aumente à medida que o número de nós na rede aumenta, de modo que não haja um limite teórico na capacidade da rede. A melhor parte? Sharding é uma técnica de escalabilidade de camada 1.
O que é Sharding?
Em um banco de dados, às vezes você precisa lidar com dados grandes e volumosos. Isso prejudica drasticamente o desempenho e o rendimento e torna todo o processo extremamente ineficiente. É aqui que entra o sharding ou fragmentação. 

O sharding faz uma partição horizontal do seu banco de dados e se transforma em tabelas menores e mais gerenciáveis.

Então, por que uma partição horizontal e não uma partição vertical?

Considere esta tabela:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Agora, se fôssemos particionar esta tabela verticalmente:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Vê isso?

Por causa da partição, a tabela se transforma em duas tabelas completamente diferentes. 

Ao contrário disso, o que acontece quando a tabela é particionada horizontalmente:

Você vê o que acontece? Quando você particiona verticalmente uma tabela, elas tendem a se tornar duas tabelas completamente diferentes.

No entanto, se fôssemos particioná-los horizontalmente:



A
B
A*B
A/B


3
3
9
1


4
4
16
1



Vê isso?
Uma partição horizontal transforma o banco de dados em tabelas menores do mesmo banco de dados. Esses bancos de dados menores são chamados de shards ou fragmentos.

Como o sharding ajuda o Blockchain?
Como vimos até agora, à medida que mais e mais nós entram no ecossistema Ethereum e Bitcoin, todo o processo de consenso e verificação leva ainda mais tempo. Agora, o que o sharding fará para ajudar nisso?

A fragmentação vai quebrar o estado global do blockchain em fragmentos menores e mais gerenciáveis.

O que acontece na ativação do sharding?

 	O estado é dividido em shards
 	Cada conta única está em um shard, e as contas nesse shards só farão transações com as outras contas no mesmo shards.

Em termos simplistas, imagine esse cenário. Existe uma rede hipotética com três nós (A, B e C) e eles precisam verificar os dados T. Os dados T são divididos em três fragmentos T1, T2 e T3. Em vez de todos esses nós trabalharem em T como um todo, eles podem trabalhar individualmente em um shard ao mesmo tempo. Como podemos ver, a quantidade de tempo que  economizamos é exponencial.

Ao contrário de muitas outras abordagens de fragmentação, que ainda exigem que os nós sejam executados em hardware cada vez mais complexos (reduzindo a capacidade de mais pessoas participarem da rede), a técnica da NEAR permite que os nós permaneçam pequenos o suficiente para serem executados em instâncias simples hospedadas na nuvem.
Por que blockchains escaláveis ​​como NEAR são necessárias?
Dica: nem tudo é velocidade!

Quando se trata de blockchains de segunda e terceira geração, o que realmente determina seu valor inato é o ecossistema de  dApps que prospera nelas. Como tal, a maioria dessas plataformas blockchain está em uma competição perpétua para atrair o maior número possível de desenvolvedores. 

No entanto, o problema com as plataformas atuais é que elas não possuem a sofisticação necessária para hospedar aplicativos de alta qualidade. O problema aqui é que temos desenvolvedores tentando criar jogos de PS4 em uma plataforma equivalente ao Windows 98. Como tal, eles precisam comprometer fortemente a funcionalidade geral de seus dApps.

Além disso, há outro fator que deve ser considerado aqui. A velocidade é um fator vital quando se trata de usabilidade do aplicativo. Afinal, por que os usuários usarão um aplicativo se ele não for utilizável? Os desenvolvedores exigem que um número definido de usuários use continuamente seus aplicativos antes que eles atinjam a massa crítica.

É por isso que uma plataforma blockchain escalável como a NEAR é importante para a adoção generalizada de blockchain e contratos inteligentes.

A NEAR permite que os desenvolvedores apenas implantem seu aplicativo sem pensar muito em como a infraestrutura em torno dele opera ou escala, que é mais parecida com as nuvens modernas como Amazon AWS ou GCP ou Azure que abrigam quase todos os aplicativos da web atuais.
NEAR: Uma breve história
A NEAR começou no verão de 2018, quando Alex Skidanov e Illia Polosukhin decidiram se afastar de sua aventura empreendedora anterior, se você estiver curioso, pode ler mais sobre isso aqui . Muito rapidamente, quando Misha saiu do MemSQL, a equipe expandiu para 9 pessoas em 3 dias. A equipe inicial era composta por 7 engenheiros, Erik fazendo operações comerciais e Sasha conversando com o mercado.

Hoje, a NEAR Collective é um grupo de equipes distribuído globalmente, composto por muitas organizações e colaboradores individuais, que se auto-organizam para dar vida a essa tecnologia. Não é um negócio ou algo tão formal. Pense nisso como os grupos de pessoas que executam grandes projetos de software de código aberto.

Um dos projetos do NEAR Collective é escrever o código inicial e a implementação de referência para a rede open source NEAR, como construir os propulsores de foguetes no ônibus espacial. Seu trabalho é fazer o trabalho de P&D necessário para ajudar a blockchain a entrar em órbita. O código para essa cadeia é de código aberto, portanto, literalmente, qualquer pessoa pode contribuir ou executá-lo.
É importante ressaltar que redes como NEAR são projetadas para serem totalmente descentralizadas. Isso significa que eles operam completamente por conta própria e não podem ser censuradas, desligadas ou manipuladas por terceiros... nem mesmo pelas equipes que os construíram inicialmente! Assim, enquanto os membros desse coletivo estão aqui para dar o pontapé inicial na construção da implementação de referência, eles rapidamente se tornam não essenciais para a operação da rede assim que ela começa a funcionar. Na verdade, uma vez pronto para o lançamento, qualquer pessoa pode modificar e executar o código da NEAR Protocol para iniciar seu próprio blockchain porque é tudo de código aberto e quaisquer alterações teriam que ser aceitas democraticamente pelos validadores independentes que o executam.

Como a Blockchain NEAR funciona
Blockchain é a tecnologia que sustenta a criptomoeda, é uma tecnologia que pode armazenar com segurança registros de transações em uma rede ponto a ponto, em vez de armazená-los em um único local. Servidores independentes em todo o mundo, chamados de nós, compõem a rede que opera o blockchain.

Um dos aspectos mais definidores da tecnologia blockchain é a descentralização. Então, por que a descentralização é útil? Vamos olhar para isso da perspectiva de desenvolvedores e usuários finais.

 	Desenvolvedores: no mundo centralizado, os desenvolvedores geralmente ficam à mercê de plataformas em nuvem ou mesmo do governo para garantir que possam continuar executando os aplicativos. No mundo descentralizado, não há intermediários dominadores.
 	Usuários finais: a transparência dos aplicativos descentralizados pode permitir que os usuários vejam o código de back-end e saibam exatamente como os aplicativos usarão suas informações pessoais.

O que é o algoritmo de consenso NEAR?

Os protocolos de consenso são usados ​​para chegar a um acordo sobre um único valor entre vários participantes de um sistema. Se todos os participantes da rede colaborarem de acordo com o protocolo de consenso, novos valores poderão ser anexados ao ledger e verificados pelos nós. No entanto, no caso de disputas, a rede pode se concentrar na segurança ou na vivacidade.

O mecanismo de consenso implementado na NEAR é chamado Nightshade. O Nightshade modela o sistema como um único blockchain. A lista de todas as transações em cada bloco é dividida em pedaços físicos (chunks), um chunk por shade, ou um pedaço por fragmento. Todos os pedaços se acumulam em um bloco. Observe que os shards só podem ser validados por nós que mantêm o estado desse shard.

Falando em validação, um componente chave do NEAR são os validadores. Esses validadores são responsáveis ​​por manter o consenso dentro do protocolo. Os validadores são nós especializados que precisam manter seus servidores online 100% do tempo, mantendo seus sistemas continuamente atualizados. 

Aqui estão alguns pontos que você deve ter em mente sobre validadores de rede.

 	A NEAR determina seus validadores de rede a cada nova época (aprox. 12 horas), elegendo-os com base em sua participação (staking).
 	Os validadores já eleitos são re-inscritos automaticamente fazendo o re-staking dos seus tokens mais as recompensas acumuladas.
 	Os validadores em potencial precisam ter sua participação no staking acima de um nível determinado dinamicamente.
 	Existem dois métodos que um validador pode usar para fortalecer sua participação – comprar os próprios tokens ou pedir emprestado por delegação de participação.
 	A recompensa que você recebe é diretamente proporcional à quantidade de tokens em stake. Quanto maior a quantidade de tokens em stake, maior a recompensa.

O consenso é baseado no consenso da cadeia mais pesada. Ou seja, uma vez que um produtor de bloco publica um bloco, ele coleta as assinaturas dos nós validadores. O peso de um bloco é então a participação cumulativa de todos os signatários cujas assinaturas estão incluídas no bloco. O peso de uma rede é a soma dos pesos dos blocos. Além disso, o consenso utiliza um gadget de finalidade que introduz condições de corte adicionais para maior segurança da cadeia.



	

	
	
		
			
				Quiz rápido: O peso de um bloco é:
			
		

		
					

		
			
			
			
			A aposta máxima dos signatários cujas assinaturas estão incluídas no bloco.
		
			
			A participação cumulativa de todos os signatários cujas assinaturas estão incluídas no bloco.
		
			
			A participação média de toda a rede pelo número de assinantes no bloco.

		
			
			Nenhuma das alternativas acima.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR: Tempo de execução
A camada de tempo de execução é usada para executar contratos inteligentes e outras ações criadas pelos usuários e preservar o estado entre as execuções. Ele pode ser descrito de três ângulos diferentes: passando passo-a-passo por vários cenários; descrevendo os componentes do tempo de execução; e descrevendo as funções que o tempo de execução executa.

O que é o token NEAR?
O token NEAR é o ativo nativo e fundamental do ecossistema NEAR e sua funcionalidade está habilitada para todas as contas. Cada token é um ativo digital exclusivo semelhante ao Ether que pode ser usado para:

 	Pagar para processar transações e armazenar dados.
 	Executar um nó de validação como parte da rede participando do processo de staking.
 	Ajudar a determinar como os recursos de rede são alocados e para onde sua futura direção técnica irá, participando de processos de governança.

O token NEAR permite a coordenação econômica de todos os participantes que operam a rede, além de possibilitar novos comportamentos entre os aplicativos que são construídos sobre essa rede.
Como começar na NEAR?
Conta/Carteira
Antes de começar a usar o NEAR, a primeira coisa que você deseja fazer é configurar uma conta NEAR.

Assista a este vídeo sobre contas NEAR:



A carteira permite interagir com contratos inteligentes na blockchain, configurar seu nó local e enviar e receber fundos de outros usuários. Ao registrar sua ID de conta, você deve fornecer um nome exclusivo. Embora cada carteira tenha que ter um nome único, cada usuário pode configurar várias carteiras.

Você pode imaginar isso semelhante a uma conta do Facebook ou do Google. Depois de se registrar em qualquer um dos serviços, você pode usar a mesma conta para fazer login em serviços de terceiros. A diferença entre os IDs de conta NEAR e as contas do Google é que os dados, armazenados em um ID de conta, só podem ser acessados ​​e gerenciados pelo proprietário da carteira. Além disso, todas as informações são armazenadas em uma rede distribuída de nós em vez de um único servidor.

Crie uma conta NEAR agora mesmo: https://wallet.near.org/create
Informações mais detalhadas sobre contas NEAR em DOCS.NEAR.

NEAR Explorer
O NEAR Explorer permite visualizar as criações de blocos em tempo real! Essa ferramenta útil permite pesquisar transações e contas, permitindo visualizar todas as interações entre usuários e contratos inteligentes.


Como obter tokens NEAR?
Existem 4 maneiras de obter $NEAR

NEAR grátis para usuários do Ethereum
Comece configurando uma carteira com um pouco de NEAR grátis via faucet para usuários do Ethereum: https://faucet.paras.id

Ganhe
Você pode ganhar $NEAR participando de recompensas de desenvolvimento, administrando uma comunidade onde ajuda as pessoas a construir no NEAR, vencendo um hackathon da NEAR ou sendo uma parte ativa da comunidade. Se você conseguir atrair outras pessoas para emprestar tokens para staking, também poderá ganhar $ NEAR sendo um validador.

Compre
$NEAR está disponível em várias exchanges importantes (veja abaixo), onde você pode se cadastrar e comprar o token usando moeda fiduciária ou criptomoeda.

Exchanges que listam $ NEAR

Você pode ter uma visão geral dos preços e pares em coinmarketcap e coingecko .

https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR
A partir de um amigo
Você não precisa ter uma conta NEAR para receber tokens NEAR! A  “ NEAR Drop ” permite que seu amigo pré-financie uma nova conta e envie um link para recuperar os tokens.

O que posso fazer com os tokens NEAR?
Transferir NEAR
Envie $NEAR entre contas suas e de um amigo e confira as transações no Block Explorer. Como as taxas de transação são muito baixas, você pode mover de forma rápida e fácil quantias muito pequenas de $NEAR para testar e aprender a utilizar a rede.
Envie-os como um presente em http://redpacket.near.org/

Experimente um NEAR Drop (convide um amigo)
Envie ao seu amigo um NEAR Drop se ele precisar criar uma conta.

Usar aplicativos NEAR
Para ver a lista crescente de aplicativos desenvolvidos em NEAR, clique aqui .

Comece fácil com NFT - compre/publique/negocie arte em https://paras.id/
Jogue no BerryClub para participar da criação de arte coletiva: https://berryclub.io/

Quanto custa usar NEAR (gas)?
Quando você interage com a blockchain NEAR para atualizar ou alterar dados, as pessoas que executam a infraestrutura do blockchain incorrem em algum custo. No final do dia, alguns computadores em algum lugar processam sua solicitação e os validadores que executam esses computadores gastam um capital significativo para mantê-los funcionando.

Como outras blockchains programáveis, a NEAR compensa essas pessoas cobrando taxas de transação, também chamadas de taxas de gas.

Se você estiver familiarizado com provedores de serviços de nuvem web2 (Amazon Web Services, Google Cloud, etc), uma grande diferença com blockchains é que os usuários são cobrados imediatamente quando fazem uma chamada para um aplicativo, em vez de os desenvolvedores arcarem com o custo de usar todos aquela infraestrutura. Isso cria novas possibilidades, como aplicativos que não correm o risco de desaparecer a longo prazo devido ao fim dos fundos do desenvolvedor/empresa. No entanto, ele também vem com algumas lombadas de usabilidade. Para ajudar com isso, a NEAR também oferece aos desenvolvedores a capacidade de cobrir os custos de gás para os usuários, para criar uma experiência mais familiar para aqueles que vêm da web2.

Ao pensar em gas, tenha em mente dois conceitos:

 	Unidades de gas: internamente, as taxas de transação não são calculadas diretamente em tokens NEAR, mas passam por uma fase intermediária de “unidades de gás”. O benefício das unidades de gás é que elas são determinísticas – a mesma transação sempre custará o mesmo número de unidades de gás.
 	Preço do gas: as unidades de gas são então multiplicadas pelo preço do gas para determinar quanto cobrar dos usuários. Este preço é recalculado automaticamente a cada bloco, dependendo da demanda da rede (se o bloco anterior estiver mais da metade cheio, o preço sobe, caso contrário, diminui e não muda mais de 1% a cada bloco), e atinge o fundo em um preço que é configurado pela rede, atualmente 100 milhões yoctoNEAR.

Observe que o preço do gas pode diferir entre a rede principal e a rede de teste da NEAR. Verifique o preço do gas antes de confiar nos números abaixo.

Pensando em gas

NEAR tem um tempo de bloqueio de mais ou menos um segundo, isto é possível limitando a quantidade de gas por bloco. As unidades de gás foram cuidadosamente calculadas para chegar a alguns números fáceis de pensar:

10¹² unidades de gas, ou 1 TGas (TeraGas)…

≈ 1 milissegundo de tempo de “computação”

...que, a um preço mínimo de gas de 100 milhões de yoctoNEAR, equivale a uma cobrança de 0,1 milliNEAR

Este 1ms é uma aproximação, mas útil, e é o objetivo atual de como as unidades de gas são definidas dentro do NEAR. As unidades de gas encapsulam não apenas o tempo de computação/CPU, mas também o tempo de largura de banda/rede e o tempo de armazenamento/IO. Por meio de um mecanismo de governança, os parâmetros do sistema podem ser ajustados, mudando o mapeamento entre TGas e milissegundos no futuro, mas o acima ainda é um bom ponto de partida para pensar sobre o que as unidades de gás significam e de onde elas vêm.



	

	
	
		
			
				Quiz rápido: 1 TeraGas ou TGas é igual a:
			
		

		
					

		
			
			
			
			1 micro segundo de tempo de computação
		
			
			10 segundos de tempo de computação
		
			
			1 milisegundo de tempo de computação
		
			
			1 nanosegundo de tempo de computação
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






O custo das ações comuns
Para lhe dar um ponto de partida sobre o que esperar dos custos na NEAR, a tabela abaixo lista algumas ações comuns e quanto TGas eles exigem atualmente, e qual seria a taxa, em milliNEAR, ao preço mínimo do gás de 100 milhões de yN.




Operação
TGas
taxa (mN)
taxa (Ⓝ)


Criar uma conta
0.42
0.042
4.2⨉10⁻⁵


Enviar fundos
0.45
0.045
4.5⨉10⁻⁵


Estaca
0.50
0.050
5.0⨉10⁻⁵


Adicionar chave de acesso total
0.42
0.042
4.2⨉10⁻⁵


Excluir chave
0.41
0.041
4.1⨉10⁻⁵



Como posso ter lucros com NEAR?
Faça stake de suas $NEAR
A chave para o modelo Proof-of-Stake é como os validadores são apoiados pela comunidade por meio de staking. Os validadores ganham recompensas de token NEAR por operar os nós que executam a rede na forma de uma taxa de inflação estática de 5% a cada ano, criando novos tokens para validadores a cada época (~ 12 horas) como recompensas.

Os validadores devem manter uma quantidade mínima de participação para manter sua vaga de validador. Os detentores de tokens podem fazer o staking com um validador específico que acreditam estar fazendo um bom trabalho como validador ajudando a rede  e então ganhar uma parte das recompensas de token geradas pela rede também. Isso incentiva os detentores de tokens a se envolverem com a comunidade!

A NEAR Wallet agora tem uma interface de usuário de staking integrada diretamente no aplicativo da web.

Para fazer o staking:

 	Selecione “Staking” na barra de navegação (ou menu suspenso no celular)
 	Clique no botão “Selecionar Validador”
 	Escolha um validador
 	Confirme sua escolha e selecione “Efetuar stake com validador”
 	Insira o valor de NEAR que você gostaria de apostar e clique em "Enviar stake"

Você precisará confirmar duas transações, uma para selecionar o validador e outra para depositar e apostar com o validador.

Para o unstake, ou encerrar o staking:

 	No painel de staking (/staking), selecione seu validador atual
 	Clique em “Unstake” e confirme a transação

Após 36 a 48 horas (4 épocas completas), você poderá retirar sua aposta. Para isso, retorne à página do validador e clique em “Retirar”.



	

	
	
		
			
				Quiz rápido: Novos tokens são criados como recompensas após a época, que é aproximadamente a cada:
			
		

		
					

		
			
			
			
			12 minutos
		
			
			12 segundos
		
			
			12 dias
		
			
			12 horas
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Construindo DeFi em NEAR
O ecossistema DeFi (Finanças Descentralizadas) está pegando fogo. Atualmente, a Ethereum detém uma rede DeFi no valor de mais de US$ 100 bilhões. O ecossistema DeFi na NEAR ainda é jovem e crescente. 



De acordo com a DeFiLlama, o Valor Total Locked (TVL) do ecossistema NEAR é inferior a US$ 100 milhões, sendo a Ref Finance a líder de mercado. O próprio fato de que o ecossistema DeFi da Ethereum é 1000X o da NEAR mostra que estamos muito adiantados quando se trata de NEAR DeFi. De fato, em 2021, o Protocolo NEAR anunciou uma iniciativa de financiamento de US$ 800 milhões. A maior parte do fundo está destinada a aumentar o setor DeFi do protocolo.

Se você quiser saber mais sobre o ecossistema DeFi da NEAR, leia este.
Ecossistema NFT em Crescimento da NEAR
Um ativo não fungível tem uma propriedade ou propriedades distintas que o diferenciam de outros ativos. Os tokens não fungíveis são baseados em ativos não fungíveis e são ativos digitais exclusivos que usam a tecnologia blockchain. Ultimamente, este setor tem crescido muito e explodiu em popularidade.

O protocolo NEAR é a plataforma perfeita para NFTs, pois possui duas grandes vantagens sobre o Ethereum:

 	NEAR é significativamente mais rápido.
 	Ethereum também tem taxas de gas substancialmente mais altas.

Esses fatores tornam o NEAR ideal para comprar e vender NFTs. Leia este artigo para saber mais sobre os 3 principais projetos NFT no NEAR.
E agora? Como posso interagir com o NEAR?
Ok, então o que acontece a seguir? Se você leu até aqui, provavelmente gostaria de se aprofundar no protocolo NEAR . Então, a próxima coisa que você deve fazer é ler o whitepaper da NEAR . Se você é novo no blockchain e quer aprender mais sobre a tecnologia em si, você pode conferir este vídeo sobre como desconstruir o ecossistema blockchain .

Junte -se ao servidor NEAR Discord e verifique o Fórum NEAR.

 

### NEAR Wallets

The NEAR Protocol, a scalable layer-1 blockchain designed for usability and decentralization, has gained traction for its developer-friendly environment and low-cost transactions. 

These are NEAR fundamentals:

 	Human readable accounts - (e.g. alice.near) making contract interactions easy to verify and understand
 	Performance, scalability and affordability enabled by Proof of Stake consensus and sharding
 	Developer and user friendly experience

Central to interacting with this ecosystem is the NEAR wallet—a tool that allows users to store, manage, and transact with NEAR tokens and other assets on the blockchain. This article explores what NEAR wallets are, how they work, and some popular options available.
What Is A Crypto Wallet 
Before moving on to the NEAR wallet, it is essential to understand what a wallet is. In the simplest of terms, crypto wallets safely store your private keys, ensuring that your cryptocurrency is safe and accessible. You can also use crypto wallets to conduct transactions, send and receive cryptocurrency, swap tokens, and interact with Dapps. When selecting a crypto wallet, you have several options to choose from. These are paper wallets, hardware wallets, and online wallets.
Hot Wallets 
Hot wallets are online-based wallets that allow users to transfer their crypto quickly. Most online exchanges have their own wallets which users can access. Hot wallets are easy to access through a mobile or desktop. While hot wallets offer easy connectivity, they are also at risk from threats such as hacking. Desktop wallets, online wallets, and mobile wallets are examples of hot wallets. 
Cold Wallets 
A cold wallet or hardware wallet is a device similar to a USB device where users can store their keys. The wallet is portable and can be connected to a laptop/desktop whenever the user wishes to access their crypto. Hardware wallets are much less prone to threats such as hacking or any other malicious attack that could occur online. 
Paper Wallets 
A paper wallet is essentially a printed piece of paper containing your public key and private key. The keys can be accessed only through a QR code. Paper wallets are used to store a significant amount of cryptocurrency since they are considered extremely safe. 
The Best Cold Wallet for NEAR
Ledger Nano S Plus


The best cold wallet for NEAR is any ledger device, with the most popular being the Ledger Nano S Plus. Ledger devices are the industry standard when it comes to cold wallet storage of crypto, and they are compatible with over 5,500 coins and tokens. They come with a companion app called Ledger Live that has many handy features such as buying, selling, swapping and staking crypto, along with compatibility for virtually any NFT. On top of that, ledger is compatible with many hot wallets discussed in this article.

 
Top Hot Wallets for NEAR
According to (L)Earner the My NEAR Wallet, Meteor Wallet, Here wallet, Bitte Wallet are the most popular at NEAR Ecosystem.
MyNearWallet

Launching in 2022, MyNearWallet is the official successor of the NEAR ecosystem. Meteor Wallet maintains and works on improving old features, adding many new ones, security improvements,  bug-fixes and a holistic interface overhaul. During its early days, MyNearWallet looked almost identical to the legacy wallet, but with hard work and dedication, the development team was able to overhaul the interface, fix bugs, address security issues and add many new features as was promised.




	

	
	
		
			
				What is the most secure type of crypto wallet
			
		

		
					

		
			
			
			
			Hot Wallet
		
			
			Cold Wallet
		
			
			Paper Wallet
		
			
			Custodial Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Product Overview
MyNearWallet allows users to securely store, swap, trade and stake NEAR tokens and compatible assets such as NFTs. It supports all of the latest NEAR token standards such as the NEP-141 (FT), NEP-148 (FT) , NEP-171 (NFT) and NEP-177 (NFT) standards. MyNearWallet is the official successor of the legacy NEAR Wallet. On top of that this wallet also has wNEAR and USN swaps available, as well as ways to purchase NEAR. Another way to earn money using MyNearWallet is by staking NEAR to help the blockchain validate transactions, which grants a return of ~10% APY.

MyNearWallet is more than just another wallet; it also serves as a portal into the vast ecosystem of NEAR dApps. Some of the best dApps built on NEAR include Ref.finance (go-to DeFi platform on NEAR), Rainbow Bridge (transfer tokens between Ethereum and NEAR), Mintbase (premier NFT platform on NEAR) and Sweatcoin (stay active to earn crypto) just to name a few.



A key differentiator for NEAR accounts is that NEAR uses human readable accounts, and not a hash. So an account on NEAR would not read as 0x71C7656EC7ab88b098defB751B7401B5f6d8976F but as alice.near or bob.near. NEAR accounts can also create sub-accounts, but only the root account can create them. Another critical differentiator is that most blockchains have one public/private key pair for each account. On NEAR, accounts can have multiple key pairs associated with them. These are called “access keys.” Access keys are of two types, a full access key, and a functional call. A full access key grants the user complete control of their NEAR account while a functional call allows for non-monetary transaction signing.

Wallet Address – The wallet address is essentially a sequence of characters or numbers or both that are used to send or receive tokens using the NEAR wallet. 

Private Key And Passphrase – The passphrase and security key is a type of password. The passphrase comprises 12 words, while the private key consists of a sequence of letters and numbers. Both are extremely important steps when it comes to wallet recovery.
Creating An Account Using MyNearWallet 
MyNearWallet allows you to create a NEAR account to access all of the features that were previously discussed. 

 	To create an account go to www.mynearwallet.com. Once you reach this page you will see two options: Create Account or Import Existing Account. If you already have an existing NEAR account and would like to transfer it to MyNearWallet choose Import Existing Account and follow the instructions. We will focus on the creation of a new account in this guide. Select the “Create Account” option.


2. Type the desired name for your account into the “Account ID” box, then click “Reserve My Account ID”.

3. Enter the password for your NEAR account, make sure it is a strong password, as it will grant access to your account and crypto. Checkmark the two boxes.

4. Click “Get Started”

5. You will be able to choose from 2 options: “Secure Passphrase” or “Ledger Hardware Wallet”. Select “Secure Passphrase” (we will show you how to set it up with a Ledger device later in this guide).

6. MyNearWallet will generate you a passphrase consisting of 12 random words. You can generate a new one if you don’t like yours. Make sure to write your passphrase down, or store it in a password manager like LastPass, as you will need it to access your account. Click continue once you’re ready.

7. You will then be prompted to enter one of the words from your passphrase. Enter the word in the box provided.
8.The last step to set up your account is to purchase some NEAR tokens, or have a friend transfer them into your account. 
a. You can click this button to access payment methods for purchasing NEAR.

b. Ask a friend to send you some NEAR.
i. Click your wallet address at the top right of the screen.

ii. Copy your address and send it to your friend.

iii. Once the NEAR is sent to your  address the setup will be complete.

Account Creation With Ledger 

 	Repeat steps 1-4 from the previous section of this guide.
 	Select the “Ledger Hardware Wallet” option.


3. Refer to the guide on Ledger’s Customer Support Website for further instructions.



	

	
	
		
			
				What cold/hardware wallet brand is recommended for storing NEAR?
			
		

		
					

		
			
			
			
			Trezor
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Ledger
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Here Wallet


HERE Wallet is a non-custodial mobile wallet for the NEAR Protocol. With the use of this wallet, users can easily transfer, receive, stake and swap NEAR along with fungible and non-fungible tokens based on NEAR. It features a liquid stacking protocol meaning users have the ability to withdraw their NEAR from staking at any moment. The staking yields are ~9% APY. The wallet also has customer support documentation for users to reference if they get stuck.

HERE Wallet has a variety of security features such on-device password storage, biometrics, and pin access making it one of the most phone-friendly wallets on the market. The seed phrase is stored locally on the device, yet the wallet also features integration with Ledger and HITO hardware wallets for those who want extra security. The wallet will also periodically send security alerts out to the user when it spots suspicious activity and has been independently audited by OtterSec.
HOT Wallet

HOT Labs provides two secure, non-custodial solutions—HOT Wallet and the HOT Wallet Extension—built on its decentralized HOT Protocol. The HOT Wallet is integrated directly into Telegram, allowing users to manage multiple blockchains (e.g., TON, Solana, TRON, NEAR, EVM-compatible) from within the chat. It features self-custody of private keys, Multi-Party Computation (MPC) for enhanced security, and optional two-factor authentication and password protection. It also supports in-chat trading, asset swapping, bridging, staking, and analytics, transforming Telegram into a crypto command center.
Complementing this, the HOT Wallet Extension is a browser-based tool that connects MPC-secured wallets to web dApps, extending secure access beyond Telegram. Both solutions leverage the HOT Protocol—a decentralized MPC system—that distributes key data across validators, enabling features like seed-phrase rotation, transfer of wallet ownership, flexible 2FA (via SMS/email), and cross-chain gas payments through HOT Relay. These combined capabilities offer users a secure, user-friendly ecosystem for managing crypto assets across Telegram and browser environments.

Intear Wallet


Intear Wallet is a next-generation web-based wallet designed specifically for the NEAR ecosystem. Built with speed and user experience at its core, Intear positions itself as “the fastest NEAR wallet” while offering advanced smart wallet capabilities that go beyond traditional crypto storage.

Intear Wallet stands out in the crowded wallet space through its innovative approach to user onboarding and recovery. Unlike traditional wallets that rely solely on seed phrases, Intear implements a smart wallet architecture that allows users to recover their accounts through multiple methods including Google authentication, biometric verification, passkeys, and even connections to EVM and Solana wallets. This flexibility makes crypto more accessible to mainstream users while maintaining the security standards expected by experienced users.
Meteor Wallet


Meteor Wallet is a browser extension, and web wallet built for the NEAR ecosystem. Launching on the NEAR protocol in Q3 2022, this new wallet has an intuitive interface, and many exciting features such as simple onboarding, easy recovery, advanced NFT features, and many more. Everything on the wallet is encrypted, and nothing is logged, so that you can have peace of mind that your crypto assets are safe. The wallet has a great customer support team with extensive guides written for new users and advanced users alike.

Meteor Wallet is one of the simplest and most user-friendly NEAR wallets. It's a web wallet that can also be used as a Chrome extension. It currently only works with the NEAR protocol as it was specifically designed for that purpose. Some of Meteor’s features include staking, transferring, purchasing and swapping NEAR, along with other fungible and non-fungible tokens built on NEAR. This wallet also opens up the doors to the rest of the NEAR ecosystem, and gives access to dApps built on NEAR.
Creating an Account with Meteor Wallet
To create a wallet, open the Meteor Wallet website and enter your username:

Yes, as simple as that.
Next Steps
Now you can move some NEAR in your wallet (Receiving NEAR) or continue exploring other Meteor Wallet's features.



In the example above, our address is simpleisland-slime.near.
Sending NEAR
To send NEAR to someone, you need to know the recipient's account ID (username). When you have it, you can send NEAR to them:

You can send other tokens when you click at them, the same menu will open for the selected token:
NFTs
Meteor Wallet has a built-in NFT viewer, where you can see your NFTs in the wallet, view their traits, floor prices, transfer NFTs, and more.




Transaction history
Under the "lightning bolt" sign, you can see your transaction history:


Settings
Settings in Meteor Wallet are located here:



 	Connected Apps: Here you can see all the apps that you have connected your wallet to (or technically, created a Function Call key). You can also revoke access to these apps by clicking "Deauthorize".


2. Security and Recovery: This part of the wallet contains your account's seed phrase. You can view or export your seeds & private key from this page. It also gives you an option to manage Full Access Keys and Function Call Access Keys of your account.

3. You can also provide feedback, share your issue with technical support, set a password, remove the account from meteor wallet, and other things from this page.
Dive deeper at NEAR Docs
Trust Wallet
The Trust Wallet is a non-custodial and decentralized wallet that allows users to store their cryptocurrencies. The assets are stored in a digital address accessible only by the user, making it a secure and efficient way to store digital assets. Trust wallet focuses on simplicity and ease of use. The wallet is an open-source, community-driven, multi-currency wallet capable of storing almost all cryptocurrencies. It provides users with a convenient way to manage their cryptocurrencies and allows them to control their private keys completely.



The wallet was acquired by Binance and is the official wallet of the Binance exchange. The wallet allows users to retain complete control of their assets and private keys stored on the user’s device. Developers can also build dApps, without any complications such as low-level implementation details. The wallet also supports on-wallet staking, which means users can earn rewards on any supported Proof-of-Stake or Delegated Proof-of-Stake tokens. Trust Wallet allows users to earn rewards and continually adds more stablecoins and cryptocurrencies.
Sender Wallet


Sender Wallet is a browser extension wallet built for NEAR protocol, which is also available as an app. It launched in February 2022, and is gaining popularity among NEAR users for its wide variety of features such as a blacklist of malicious addresses, Ledger support, NFT collectibles, token exchange, and staking. 

If you’re worried about security, Sender has got you covered. It has been audited by SlowMist, a leading cybersecurity firm, and it also regularly gives out bug bounties to ensure that security is up to date. With investors like Binance Labs, and Crypto.com Capital, Sender Wallet has received a lot of industry backing, and is sure to be a mainstay in the NEAR ecosystem.
Bitte Wallet
Bitte Wallet is not actively developed anymore.
Mintbase Wallet rebranded in Bitte Wallet.

Bitte wallet makes using blockchain technology easier than ever, all thanks to some clever features from the NEAR blockchain.
Key Features:
User-Friendly Onboarding: With passkeys and account abstraction, Bitte Wallet offers a seamless onboarding experience, often faster than traditional Web2 platforms.

Secure Custody of Assets: Utilizing biometric features such as Face ID or fingerprints, Bitte Wallet securely stores wallet keys in your chosen password manager, ensuring you have full control over your assets.

No Gas Fees: Leveraging account abstraction and meta-transaction technologies unique to the NEAR blockchain, Bitte Wallet facilitates transactions covering gas fees.

So, Bitte wallet users can now enjoy a smoother, more familiar experience, similar to using regular apps, without the usual blockchain hassles.
Coinbase Wallet
Coinbase Wallet is a flexible non-custodial wallet with a wide range of functionalities. It has broad NFT and DeFi functionality making it ideal for traders or investors . The wallet is compatible with Android, iOS, and most popular web browsers as an extension, providing a convenient experience and seamless transition across multiple devices.



The main factor that differentiates this wallet from others is direct access to the Coinbase platform. The wallet has great integration with NEAR dApps including, but not limited to DeFi, gaming, NFT marketplaces and more. This is a great wallet for users coming from Coinbase, as it will facilitate an easy and fluid transition into the NEAR ecosystem.




	

	
	
		
			
				Which wallet is the official successor to NEAR Wallet?
			
		

		
					

		
			
			
			
			HERE Wallet
		
			
			MyNearWallet
		
			
			Guarda Wallet
		
			
			Meteor Wallet
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Closing Thoughts 
NEAR’s ecosystem allows users to access a host of NFTs, decentralized applications, and DeFi solutions. NEAR addresses the shortcomings of blockchains such as Ethereum, offering solutions to long-standing problems such as network congestion, high gas fees, and slow processing fees. The NEAR wallet allows users to create and interact with NEAR accounts, allowing users to store their NEAR tokens, and stake them to earn rewards. We hope this guide provides some clarity about the functioning of the NEAR wallet and its use cases.


                 
 
                        What is the best NEAR wallet?(Required)
			
					
					HOT wallet
			
			
					
					INTEAR wallet
			
			
					
					Meteor wallet
			
			
					
					My NEAR Wallet
			
			
					
					HERE Wallet
			
			
					
					Ethereum wallet
			
			
					
					Bitte wallet
			Quadratic vote with nLEARNs(Required)
			
					
					1 nLEARN (ONE vote)
			
			
					
					4 nLEARNs (TWO votes)
			
			
					
					9 nLEARNs (THREE votes)

### Обзор игры Farm Me

15 марта Farm Me официально запустили игру на Aurora Network.

Farm Me | Announcement Teaser Trailer OFFICIAL

Farm Me — это многопользовательская строительная игра, работающая на платформе Near Blockchain. Farm Me была создана как фермерская игра с элементами борьбы за выживание, чтобы помочь вам окунуться в привлекательную фэнтезийную Метавселенную. 

У команды разработчиков более 10 лет опыта в производстве игр в том числе и на блокчейне. Разработчики имеют опыт работы с криптовалютой/блокчейном и являются популярными экспертами в своем сообществе. Используя свои уникальные функции и стратегию, Farm Me стремится в будущем стать одной из ведущих метавселенных 3D GameFi и создать долгосрочную прибыль для инвесторов по мере устойчивого роста.

Геймплей



иллюстрация позаимствована из официальной документации

Впечатляющий игровой процесс выделяют Farm Me среди других игр NFT. FARM Me — это фэнтезийная метавселенная с элементами битвы за выживание. 

Which view do you prefer? | Farm Me Official

Что нужно игрокам, чтобы начать играть в мире Farm Me?

 	Каждому игроку необходимо купить хотя бы одного Героя и одну Землю на Рынке, чтобы начать основные операции, которые составляют основу для новой деятельности по строительству фермы. У каждого Героя будет от 0 до 2 пассивных навыков, поддерживающих игровой процесс. Кроме того, игрокам также будет предоставлен базовый сундук, который включает в себя сельскохозяйственные инструменты: деревянную кирку, деревянный топор,  деревянную лейку, деревянный серп и упаковку из 10 семян картофеля, чтобы начать заниматься сельским хозяйством.
 	По прошествии определенного периода времени игроки могут увеличить количество земли, которую они могут купить для поддержки сельскохозяйственной деятельности, в соответствии со своими потребностями.
 	Максимальное количество блоков, которое Farm Me позволяет игрокам открыть, составляет 8000 блоков, в зависимости от развития игры и потребностей игроков мир метавселенной Farm Me будет продолжать расширяться.
 	На карте Farm Me есть ферма, город, лес, шахта и пляж, соответствующие разнообразным и интересным занятиям, которые игроки могут исследовать.

Земли



иллюстрация позаимствована из официальной документации

Игрок получает количество земель случайным образом после первой покупки фермы. После этого игрок может расширять свою ферму с помощью игровых материалов.



иллюстрация позаимствована из официальной документации

Карта фермы разделена на блоки, которые игрок может разблокировать. A0 — это место, где начинается ваша ферма. Игрок может расширить свою ферму, подойдя к забору участка, который он хочет расширить. Когда вы решите открыть участок, потребуются различные материалы, чтобы разблокировать землю. Ниже приведены материалы, необходимые для открытия каждого блока:



иллюстрация позаимствована из официальной документации

В игре игрок столкнется с новой областью, которую нельзя пересечь. Игроку нужно собрать дерево и камень, чтобы построить мост, по которому можно пройти. Дерево и камень в основном используются для строительства мостов, эти два материала можно получить, рубя деревья и разбивая камни. После сбора материала вам придется подождать определенное время, пока мост будет построен.

Ниже приведен список материалов необходимый для строительства:



иллюстрация позаимствована из официальной документации

Герои



иллюстрация позаимствована из официальной документации

Герой — это персонаж, которым управляет игрок, чтобы исследовать город Нексум. Игрокам нужно будет выбрать Героя, чтобы начать играть, так же есть возможность вызывать новых героев с помощью $FAME или собирать определенное количество осколков призыва героя. У героя  5 редкостей: Обычный, Редкий, Супер-редкий, Легендарный, Эпический, Мифический.

У каждого Героя будут разные базовые характеристики, основанные на уникальных характеристиках Героя. Герой имеет следующие девять характеристик: HP, SP, DEF, Luck, Speed ​​Move, Speed ​​Attack, Critical Rate, Critical Damage. Когда игрок вызывает или объединяет осколки нового Героя, эти характеристики будут выбраны случайным образом в пределах определенного диапазона. В настоящее время существует два типа Героев, которых можно призвать или объединить в осколки. Распределение характеристик Героя подробно описано в следующей таблице:



иллюстрация позаимствована из официальной документации

Инструменты

Инструменты помогают игрокам выполнять такие действия, как возделывание земли, рубка деревьев и разрушение камней. Каждое действие потребляет определенное количество очков выносливости.

Инструменты имеют несколько уровней:

 	деревянный
 	медный
 	серебряный
 	золотой
 	алмазный

Инструменты более высокого уровня используются для разрушения камня и руды более высокого уровня в игре. Эти инструменты будут открываться постепенно, когда игрок выполняет определенные условия в игре.

Топор — это инструмент, используемый в основном для сбора древесины. Этот инструмент используется для вырубки деревьев и удаления пней. В начале игры игрок получает деревянный топор. Если игрок хочет срубить большое дерево и большой пень, ему нужен лучший топор.

Мотыга - это основной инструмент, используемый для обработки земли, чтобы игрок мог возделывать землю. Деревянная мотыга будет предоставлена ​​игроку бесплатно в начале игры. Мотыга имеет много уровней и имеет различное использование.

Лейку - используется для полива растений. Игроку необходимо постоянно поливать растения, чтобы они росли. Деревянная лейка будет выдана игроку бесплатно в начале игры. Полив может иметь многоуровневый и различный эффект.

Кирка — необходимый инструмент для сбора камней, минеральных руд и редких драгоценных камней. Деревянная кирка будет дана игроку бесплатно в начале игры. Она также используется для разрыхления почвы, обработанной мотыгой.

Магазин

Магазин — это место, где игрок может покупать и продавать предметы. В каждом магазине есть один  NPC.

- Каждый день игрок может зарабатывать только 5000 МЕ в каждом магазине.

- Если игрок покупает предмет в магазине, заработанный лимит ME будет суммироваться. Когда игрок продает предмет, чтобы получить ME, заработанный лимит ME будет вычтен из цены продажи.

- ME заработанный лимит для одного Магазина сбрасывается каждый день.

- Если предел заработанных ME уменьшится до 0 --> любой другой проданный предмет не даст игроку ME.

Токеномика



иллюстрация позаимствована из официальной документации

Для обеспечения устойчивости и расширения экосистемы Farm Me имеет 2 типа токенов:

 	 Токен (FAME): Токен является фундаментальным фактором игровой платформы и игровой валютой, используемой для транзакций.
 	 Токен (ME): вторичный токен, используемый в экосистеме игры, бесконечно зарабатываемый в результате взаимодействия с игроком.

Играйте чтобы зарабатывать

Играйте чтобы зарабатывать деньги (P2E), помогайте игрокам строить свои миры и получайте финансовые выгоды за счет сбора, торговли на рынке и другими способами. В Farm Me вы можете зарабатывать разными способами:

 	Как инвестор/владелец NFT: вы можете сначала покупать предметы NFT, а затем сдавать в аренду NFT за $FAME. Вы также можете продавать предметы NFT или $FAME на торговой площадке.
 	Выполнять все ежедневные задания, чтобы заработать токен $ME и собрать элементы осколков, которые задействованы в создании нового NFT.
 	Участвуйте во внутриигровых событиях и турнирах (ежедневных/еженедельных/ежемесячных) и получайте награды.

В дальнейшем виды заработка будут увеличиваться.

Вывод

FARM Me — это фэнтезийная метавселенная с элементами битвы за выживание. Впечатляющая 3D-графика, привлекательный сюжет, разнообразный игровой процесс. Farm Me — это не только площадка для заработка, но и отличная игра, в которую стоит поиграть самым заядлым геймерам. Игра обещает удовлетворить даже самых требовательных игроков.

Материал подготовлен игровым сообществом:

https://t.me/play_on_near

https://twitter.com/Play_on_Near

https://medium.com/@NEARGaming

### Update - April 5, 2022

Brief Summary:

 	
 We are launching MASSIVE DeFi/SocialFi testnet playground initiative at LNC!


Results:

 	💸  Ⓝ191 sent to 6 projects NEAR Certified Developer Demo Day March 2022 winners
 	🧪 Ⓝ48  have been just sent to LNC NFT Certificates Beta Test winners! Congrats!
 	It was a BLAST! Have you ever heard about new super-duper p2p web3(14) "Laugh-to-Earn" concept cooked by one of LNC Barrel projects?

 	


📚(L)Earn how to Optimize for NEAR Storage On-Chain (Community Guide)




Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Starting with crowd sale of 1M of LNC testnet tokens tomorrow!

### Optimize for NEAR Storage On-Chain (Reducing Contract Size)

Note: We leave some “questions” for you to experiment yourselves what the end results are.

Storage on chain is expensive. For every 100kB used, 1 NEAR is locked. These NEAR can be returned if you remove the storage used. There are two main causes of storage usage:

 	Transactions: Each transaction is a receipt, which is saved on-chain, hence taking up some storage. Each transaction receipt have different length (some calls more functions, hence longer receipt; others call only 1 function hence shorter receipt), hence the amount of storage used is different. Just like you need more paper to print a long receipt, you use up more storage space for storing longer receipt.
 	Smart contract deployment: When you deploy a smart contract, it will take up the size of the smart contract (it may differ slightly from what you see from the local wasm file, but overall the differences are small).
For transactions, unless you reduce the transactions you did, you can’t really reduce how much space is taken due to transactions.

(Question: Can we delete our top-level account via near-cli? If we delete, does it freed up storage cost? (p.s. check explorer after deleting a sub-account.) Certainly, the transactions won’t be deleted, hence will it still lock the storage cost, hence can never be released?)

Here, we shall talk about optimizing your smart contract size.
Note: it is said that development in AssemblyScript leads to smaller wasm size, for the same code written, compared to Rust. One isn’t an AS developer (prefer to use Rust), so one won’t speak about that; in fact, one don’t need to speak about that, it’s the compiler’s job anyways.
Optimize Contract Size
Persistent Storage
Near have a list of collections, the list is here. These collections cache data to reduce Gas fee. The tradeoff is: how much Gas fee you want to reduce? How much storage cost you’re willing to pay for the Gas fee reduction? How many unique persistent storage do you need?

The difference is mentioned in the link above (the exact words are as below):

It’s important to keep in mind that when using std::collections (i.e. HashMap, etc Rust locals), that each time state is loaded, all entries in the data structure will be read eagarly from storage and deserialize. This will come at a large cost for any non-trivial amount of data, so to minimize the amount of gas used the SDK collections should be used in most cases.

Consider this example: We have a main contract that have a dictionary/hash/map to link an ArticleId to an Article. The Article is an object (in Rust, it’s also called a Struct) with its attributes.
use near_sdk::AccountId;
use near_sdk::collections::LookupMap;
use std::collections::HashMap;

pub struct Contract {
pub article_by_id: LookupMap<ArticleId, Article>,
}

pub struct Article {
pub owner_id: AccountId,
pub article_id: String,
pub royalty: HashMap<Account, u16>,
}
We see that Contract.article_by_id uses LookupMap and Article.royalty uses HashMap. We shall discuss why we don’t use other types.
Consider article_by_id, when we create an article, the id will be unique and specific to that article. It will be stored forever. A LookupMap cache the results in memory so we don’t have to “calculate” (using Gas fee) every time we need the results.

As mentioned before, since everything will be deserialize if read when using HashMap, and LookupMap<AccountId, Article> is not trivial amount of data (when there are lots of Article being created), it should be cache on-chain.

Now, why are we using LookupMap instead of UnorderedMap? The latter offers iterating over the collection functionality, which we don’t need. If you need it, use the latter.

Then for royalty, we’re using HashMap. Thing is, we have lots of Article, each with it’s own unique Article.royalty. For each unique Article.royalty, we need to create a new key to save the storage.
P.S. If you haven’t know yet, you need a unique key for each object from NEAR SDK collections. If two NEAR SDK collections share the same key, they share the same data (irregardless of whether it’ll work or fail if you share memory between two different objects, like Vector and LookupMap)
Let’s illustrate the same key shared storage scenario. Say we create two article, Article A and Article B. These are their Article.royalty equivalent.
// Values are percentage, 100.00% == 10_000.

// Article A
{
"alice.near": 1_000,
"bob.near": 500,
}

// Article B
{
"alice.near": 1_500,
"charlie.near": 2_000,
}
For some reason, there’s a repeat royalty for alice.near. If you use the same storage key, it will lead to error, complaining that: you already have an alice.near stored in Article A, and you are repeatingly storage another value to that key, and this is not possible. We also want them to be independent of each other; and same storage key used by 2 different HashMap means they share the same values.
(Question: can you fetch the values stored in Article A if you initialize with the same storage key in ArticleB?)

The solution is to create separate storage key for each collections. However, if we have 1 million articles, we need 1 million different collection keys to store them separately. This sounds stupid! Hence, it makes sense to store them rather as HashMap instead. Furthermore, they’re trivial. These royalty are originally designed to limit how much data they can store so fetching of data is small and deserializing them is cheap. This strengthen our choice to use HashMap than the equivalent SDK collections, despite (slightly) higher Gas usage (which is negligible since the collection is so small it’s negligible).

In conclusion, when designing your smart contract, choose whether to use NEAR SDK collections or Rust collections based on triviality and how many repeats you need for the same Map.
Code reduction
The first code we write, they’re bad. In fact, they’re just a draft. We need some refactoring to delete unnecessary code. There’s a tradeoffs between easier-understanding code and storage optimization.

For example, perhaps one have a PayoutObject, and it’s only used in a single function.
use near_sdk::json_types::U128;
use near_sdk::AccountId;

pub struct Payout {
pub payout: HashMap<ArticleId, U128>,
}

impl Default for Payout {
fn default() -> Self {
Self [
payout: HashMap::new(),
]
}
}
Why can’t we just define a
HashMap::new()
in the specific function that uses this? Of course, if you do the latter, it would be more difficult to understand the code. The former makes things easier to understand, from an Object Oriented perspective. However, (significantly) more code leads to more storage used after compilation to WASM. So, time to do some trade-offs.
In one’s opinion, readability is more important than storage space optimization. If required, clone the original readable component and do some optimization each time you make changes, so people can understand what you’re doing by reading your original code. Of course, this means more work for you.
(Question: How much space is saved if you replace the former with the latter? If you have a similar scenario in your program, try optimizing it by writing less code and see how much space it compiled to, is there a differences? (Sometimes there isn’t, sometimes there are. For those that doesn’t, prefer to keep the readable code for easier debugging in the future. ))
Wasm-Opt
After you compiled the optimized release version, you can still further reduce the contract size by using wasm-opt. To install, download the binary here for your OS and unzip it. Inside, there’s a “bin” folder, which you should copy the exact path to that folder and add it to your Environment path. After which, try to call wasm-opt from the command line/terminal whether it runs or not. If not, google online how to solve it (perhaps you didn’t add it to the correct environment variable, perhaps your terminal is already open which it doesn’t refresh the latest path, are the two most common problems).

Running these would reduce the file size:
#!/bin/bash
set -e

export WASM_NAME=tipping.wasm
z
mkdir res

RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
cp target/wasm32-unknown-unknown/release/$WASM_NAME ./res/
wasm-opt -Os -o res/output_s.wasm res/$WASM_NAME
ls res -lh
Here, we assume that the original contract is compiled to tipping.wasm, (Cargo.toml name is tipping). Then, the optimized name is output_s.wasm. We then run ls (on Linux) to check for their difference in file size. It should be smaller.

Note: you can also use -Oz for the flags, but one found that unnecessary, as for the project one works on, it doesn’t lead to smaller file size.

Important Note: The RUSTFLAGS should be “link-arg=-s”, if you accidentally change it to “-z”, you might have big problem. At least for one, it generates a far bigger wasm file. You shall experiment with it and check for your own project.
Perhaps in the future, they might allow .wasm.gz file so you can further optimize file size. Currently, one tried it and it cannot deserialize a gzipped file, only supporting .wasm file on-chain.
Cargo.toml
These are the usual flags for cargo toml.
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
You could choose opt-level = "z" too, it might or might not generate a smaller binary.
Some other small wins
Avoid String Formatting
format! and to_string() can bring code bloat; so use static string (&str) whenever possible.

Removing rlib if not required
If you don’t need to do simulation testing, remove rlib.

Use Borsh serialization
Prefer to not use serde when possible. Here is a page on how to override the serialization protocol.

Avoid Rust standard assertions and panic macro
These contains information on the the error returned, which introduces unnecessary bloat. Instead, try these methods:
// Instead of this
assert_eq!(
contract_owner,
predecessor_account,
"ERR_NOT_OWNER"
);

// Try this (for all versions of near-sdk-rs)
if contract_owner != predecessor_account {
env::panic_str("ERR_NOT_OWNER")
}

// For near-sdk-rs v4.0 pre-release
use near_sdk::require;
require!(
contract_owner == predecessor_account,
"ERR_NOT_OWNER"
);
require! is a lightweight macro introduced in near-sdk-rs v4 (and it’s also one’s favorite macro) to replace assert! macro. It works like assert! mostly, except for one small difference: it cannot specify format! per se.
// assert! can specify format
assert!(
some_conditions,
"{}: {}"
error_type,
error_message
);

// require! cannot
require!(
some_conditions,
format!( // you need format! yourself
"{}: {}",
error_type,
error_message
)
);
And as we mentioned to avoid string formatting before, it’s best if you hard-code the message. Of course, if your really need it, just sacrifice some bytes to use format! is ok: it take up only negligible space if you don’t use it extensively.

Don’t use .expect()
Instead, use unwrap_or_else. One wrote the helper function in the near helper crate which you might wanna check out.

Otherwise, you could always put this in internal.rs:
fn expect_lightweight(option: Option, message: &str) -> T {
option.unwrap_or_else(||
env::panic_str(message)
)
}

// instead of:
let owner_id = self.owner_by_id
.get(&token_id)
.expect("Token not found");

// use this:
let owner_id = expect_lightweight(
self.owner_by_id.get(&token_id),
"Token not found"
);
Avoid Panicking
These are some common errors to panics:

 	Indexing a slice out of bounds. my_slice[i]
 	Division of zero: dividend / 0
 	unwrap(): prefer to use unwrap_or or unwrap_or_else or other safer methods to not panic. In near-sdk, there’s also env::panic_str (env::panic is deprecated) to panic, and they mentioned here that it could be preferred. However, you could also use the old-fashioned match to deal with stuffs and see if it works better than panic_str; if not, then use panic_str for easier code understanding. Otherwise, you could switch to match if it worth it.

Try to implement workaround so it returns None or enforce no panicking while developing contract.
Lower level approaches
Check out the link in the reference for other ways to reduce contract size not mentioned here. (The stuffs mentioned here are also mostly not mentioned here).

Do bear in mind, this example is not updated anymore, so it requires you to derive to the latest update manually.

The list is here:

 	Tiny Contract(deprecated)
 	Contract for fuzzing rs (you can view the master branch, this is a fixed branch to prevent it removed in the future). One don’t know what this contract does, nor what “fuzzing” means; you would require understanding yourself.
 	Eugene’s example for fast fungible token, and you can watch the youtube video here. He implement it without using near-sdk. More unhappy programming experience, but optimize for size.
 	Aurora uses rjson as a lightweight JSON serialization crate. It has a smaller footprint than serde currently packaged with Rust SDK. See this example and reader requires deriving how it’s use themselves. Anoter to consider is miniserde crate, example here

The Wasm-snip tool
It might be useful to replace functions not used with unreachable instruction. Usually you don’t need to do this: only if you really really need to save that space you could go forward.

They mentioned the tool is useful for removing the panicking infrastructure too!

You could also run wasm-opt with --dce flag after snipping, so those snipped functions get removed.
Conclusion
There are lots of ways to optimize a contract. Some optimization are done easily without any changes, others have compromises and trade-offs that you shall decide whether or not it’s worth the trade-offs. In general, unless your contract is utterly big, which usually result from too many lines of code being written and which you are encouraged to check for necessity of code written; otherwise simple usage like wasm-opt and persistent storage choice should be sufficient.
References
Near SDK documentation on reducing contract size
Reducing Wasm size for Rust

### How to Burrow: A Step-by-Step User Guide

This user guide was created in collaboration with NEAR Mates and NEAR Insights. Follow them on Twitter for more quality NEAR content like below.
Source article at Medium

What is Burrow?
Burrow is a decentralized, non-custodial, autonomous money market similar in nature to Aave and Compound.
Burrow aims to unlock liquidity for interest-bearing assets, particularly layer 1 staking derivatives such as stNEAR and stETH. Users of Burrow will be able to deposit stNEAR as collateral, then borrow more NEAR to create a leveraged staking position, or borrow a stablecoin to make a self-repaying position.


Getting Started

New to NEAR?
If you don’t have a NEAR account, just follow this guide to set up your NEAR wallet first!

Connect Your NEAR Wallet
Launch the Burrow app and connect your NEAR wallet at the top right corner.








How to Supply
Users can supply assets to the protocol and begin earning interest.
The interest rates are variable and will fluctuate based on the utilization rate for the given asset. (More info on the interest rate model here.)
Supported assets at launch:


 	NEAR
 	stNEAR (staked NEAR)
 	ETH
 	wBTC
 	USDT
 	USDC
 	DAI
 	BRRR (Burrow’s native token)

1. Go to “Deposit” and choose the asset to supply
Browse to the “Deposit” section and click on the asset you want to deposit.





2. Select the amount you’d like to deposit and submit your transaction.
3. Once you have deposited your assets, you now have two options:




(1) Enable “Use as collateral.”
This means that you will now be able to borrow assets against the amount you deposited into the supply pool.
This also means that your funds can potentially be liquidated. See “Health Factor” and “Liquidation” sections below for more info.
(2) Simply supply assets, don’t “use as collateral.”
This means that you will simply earn interest on the amount you supplied to the pool, without further borrowing any assets. In this case, your assets are not subject to liquidation.
You can always turn on “use as collateral” later in your “Portfolio” page.

4. Approve the transaction in the NEAR wallet prompt.




Your deposit is now successfully registered, and you can begin earning interest. The “APY” (annual percentage yield) number tells you how much you can expect in $BRRR rewards for supplying assets.


How to Borrow

Now that you have supplied your assets to Burrow’s liquidity pool, you can also borrow funds against it.

1. Designate your assets as collateral
In order to borrow assets, you must first enable “Use as Collateral.” If you haven’t turned on the “Use as collateral” button while depositing, you can adjust your position in the “Portfolio” → “Adjust Collateral” section.
On Burrow, you can pick and choose which deposited assets you want to use as collateral, as well as customize the rate of colleteralization.





2. On the “Borrow” page, select the asset you want to borrow




3. Enter the amount you want to borrow, keeping in mind the resulting Health Factor




What is the “Health Factor?”
The risk of a position can be understood through the Health Factor, which represents the combined collateral ratios of the borrowed assets.


 	If the health factor is higher than 100%, it means the account is in a good state and can’t be liquidated.
 	If the health factor is less than 100%, it means the account can be partially liquidated and can’t borrow more without repaying some amount of the existing assets or providing more collateral assets.

To learn more about how the health factor is calculated, see here.

What is “Liquidation?
Liquidation is when your position is forcefully closed by the protocol (i.e. your collateral is sold off) because, due to changes in market conditions, the value of your collateral is no longer enough to secure your debt based on the Health Factor, meaning that you are at risk of not being able to pay off your debt. This kind of insolvency threatens the protocol, and therefore a liquidation event is triggered through bots to prevent it in advance.
This might happen when:


 	The collateral decreases in value (e.g. wNEAR price decreases from 20$ to 10$)
 	The borrowed debt increases in value

You can read more about liquidation here.

TL;DR
When your Health Factor is…


 	Green: Your funds are (generally) safu
 	Yellow: Risk is moderate
 	Red: Your funds are at a high risk of being liquidated

Warning

 	We recommend users DO NOT set the collateral utilization rate at 100%. You are asking to be liquidated!
 	The Health Factor can change if the price of the underlying assets change to a great degree. We recommend users monitor their Health Factor from time to time, especially if there are rapid changes in market conditions.

4. Submit and approve the transaction







How to Manage Your Assets
Access “Portfolio” in the menu to view and manage your Deposited and Borrowed assets.

Net APY
Your “Net APY” is your total APY (annual percentage yield) which calculates how much you are earning from depositing assets (deposit APY) minus how much you owe the protocol from borrowing (borrow APY).

Withdraw
Choose the asset you want to withdraw and click “Withdraw.”





If you want to withdraw all your assets, make sure to repay your debt first. If withdrawing at 100% doesn’t work, lower to 99% or so and try again.
If you are withdrawing only a portion of your assets and maintaining your debt position, beware of how this will change the Health Factor and manage your liquidation risk.





Adjust Collateral
On Burrow, you can customize the rate at which your assets are collateralized, and set it differently for each asset you supply. This is different from previous lending protocols whose collateral rates were set at a default rate.
You can set the desired collateralization rate when you first deposit your assets, or go to “Portfolio” and click “Adjust Collateral.”





Repay
To pay off your outstanding debt, go to the “Portfolio” section and click the “Repay” button.





Deposit NEAR, Repay with wNEAR?
Due to the difference in token standards, Burrow (and most other DeFi dapps on NEAR) use wNEAR (“wrapped” NEAR), not NEAR.
When you deposit, your NEAR will be automatically wrapped, so there is nothing you need to do. However, if you borrowed $wNEAR and are looking to repay, you have to do it as wNEAR. Use the Ref Finance Wrapping Page to wrap your NEAR into wNEAR first.
In the future, Burrow will support direct wrap/unwrap on the app itself. Furthermore, the wrap/unwrap function will be integrated to the NEAR wallet so that this issue is more easily resolved.





To read on the difference between wNEAR and NEAR, see our FAQ.




Burrow is Live on Mainnet! Read this FAQ to Get Started

The wait is over! The first money market on NEAR native is finally live on mainnet. This means more liquidity and DeFi…


burrowcash.medium.com










Coming Soon: xBRRR Staking!
Shortly, staking will go live on Burrow. Users can stake their BRRR and receive xBRRR, with which they can access boosted rewards and participate in protocol governance. Stay tuned!


Become a Burrow Hog

Dapp • Twitter • Discord • Docs

### Haher Beta Testers Feedback

Requirements:
Follow @LearnNEAR on Twitter

Beta test sprint starts: April 1, 0:01 am ET
Beta Test sprint ends: April 4, 11:59 pm ET
Haher: https://haher.live/
Requirements:

 	Smile!
 	Login to Haher
 	Record your personal laugh NFT
 	Put your NFT on Sale
 	Listen several NFTs on main page (report if voice spam or abusive content found)
 	Try to listen all laugh records together by clicking special button on the top

 	Buy 1 NFT
 	Go to your account, open minted NFT, copy link. Then tweet: "I've minted my laugh as NFT! at Haher, project from @LearnNEAR  Barrel + *link to your haher*"
 	Smile!

Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy testing!

### Crypto Hero, ein NEAR Spiel

Was ist Crypto Hero?

Crypto Hero ist ein Blockchain-basiertes Spiel, welches sich hauptsächlich auf PvE konzentriert - wo Du in Dungeons grinden und Gegenstände mit anderen Spielern tauschen kannst, sowie mit Freunden in einem Raid-System spielen kannst und wo Du wöchentlich Preise in Pixel-Token verdienen kannst.

Die Idee ist inspiriert von traditionellen RPGs und Action-RPGs wie Diablo.



ier haben wir versucht, die Mechanismen dieser Spiele auf einfache Art und Weise zu implementieren, so dass ein optimiertes Erlebnis entsteht, bei dem die Spieler ihre Charaktere entwickeln, mit anderen konkurrieren und, was am wichtigsten ist, Geld verdienen können.

Das Spiel enthält 5 Hauptelemente, die im Folgenden aufgelistet werden. 

Warum solltest Du Crypto Hero spielen?

Crypto Hero ist das zweite Spiel von PixelDapps und wird nicht das letzte sein - ein Team, das erfolgreich Blockchain-Spiele produziert hat, in denen Spieler die Möglichkeit haben, Preise zu verdienen und gleichzeitig Spaß zu haben. Der aktuelle Token ist stabil und steigend, was der perfekte Zeitpunkt für eine frühe Investition ist.

Abgesehen davon, macht Crypto Hero Spaß. Es schafft ein Aufstiegssystem aus RPGs in eine ganz neue Ebene mit NFT-Items, die in einer Community gesammelt und gehandelt werden, die in erster Linie mit Ideen und Ambitionen im Ökosystem verbunden sind.

Wie spielt man Crypto Hero?

Crypto Hero Regeln

Wann kann ich Crypto Hero spielen?

Die MainNet Veröffentlichung ist am 22. Januar.

Wo kann ich Crypto Hero spielen?

Crypto Hero Spielen

 	Das Auktionshaus

Im Auktionshaus können Gegenstände gegen Pixel-Token getauscht werden.

Du kannst die Gegenstände nach Kategorien und verschiedenen Ausrüstungsarten filtern, um die Suche zu erleichtern.



 	Die Gegenstände

Dein Held kann bis zu 6 verschiedene Gegenstände ausrüsten: eine Waffe, eine Rüstung, Stiefel, eine Halskette, einen Ring und einen Helm.

Die Gegenstände sind nach Seltenheit definiert: gewöhnlich, selten, episch und legendär.

Gegenstände können in Dungeon-Runs gedroppt werden, je höher der Dungeon-Level, desto besser die Gegenstände. Gegenstände können außerdem deinen Helden stärker machen.



 	Der Held

Dein Held hat HP, Level und Erfahrung.

Dein Held kann aufsteigen, wenn er genug Erfahrung gesammelt hat.

Je höher Dein Heldenlevel ist, desto stärker wird er.



 	Der Dungeon

Du kannst Deinen Helden auf eine Dungeon-Tour schicken, bei der er es mit einer Horde von Kreaturen zu tun bekommt.

Du kannst wählen, wie tief Du in einen Dungeon eindringen willst, tiefere Ebenen geben bessere Beute und Erfahrung, werden aber exponentiell schwieriger. 

Wenn Du den Dungeon geschafft hast, wirst Du mit Beute und Erfahrung belohnt und musst warten, bis Du den Dungeon erneut betreten kannst.



 	Die Rangliste

Die Rangliste zeigt die höchsten Stufen und Gegenstandsstufen im Spiel an und schafft so ein Wettbewerbsszenario zwischen den Spielern.



 	 Die Raids

Das Raid-System ist ein sozialer Anreiz für die Spieler, miteinander in Kontakt zu treten, und gleichzeitig der wichtigste Teil des Spiels, um Geld zu verdienen. Du kannst dich mit anderen 7 Spielern zusammenschließen, um gegen Bosse zu kämpfen, die unterschiedliche Schwierigkeitsgrade und Belohnungen haben.

### Integration mit dem NEAR-Protokoll

Ein Erfahrungsbericht über die Integration von NEAR




Beginnen wir mit den 3 Säulen des NEAR-Protokolls:

 	Proof of Stake
 	Sharding
 	WASM Smart Contracts

Bei der Proof of Stake-Blockchain wird der Konsens durch Staking und nicht durch Mining erzeugt. Near hat schnelle 1-Sekunden-Blöcke mit kurzer Finality.

Die Blockchain ist sharded, d.h. die Aufrufe zwischen Contracts sind asynchron (nicht zu verwechseln mit synchron wie bei Ethereum oder Solana). Um Near Contracts zu programmieren, muss man die Denkweise eines Akteurs Modells (auch Microservices genannt, aber ich hasse diesen Begriff) übernehmen. Die Asynchronität ist notwendig, damit Shards parallel verarbeitet werden können, was zu einem viel größeren Transaktionen Durchsatz führt. Blockchains, bei denen Smart Contracts nicht gesplittet sind, werden an eine Grenze der Skalierbarkeit stoßen. Das Auslagern auf GPU oder ASIC (obwohl immer noch synchron) kann diese Grenze nur horizontal verschieben, aber es wird nicht zu einer exponentiellen Skalierung führen.

Near Contracts werden als WASM-Code ausgeführt, d.h. Du kannst in jeder Sprache programmieren, die zu WASM kompiliert werden kann. Gegenwärtig werden AssemblyScript (Gruppe von TypeScript) und RUST mit den entsprechenden Toolchains am besten unterstützt.

HINWEIS: Wenn Du in TypeScript programmieren kannst, benötigst Du dafür WENIGER als 30 Minuten.

Eine WebApp auf dem NEAR-Protokoll zu erstellen (was genau das ist, worauf Near zugreift) ist im Vergleich zu anderen Blockchains sehr einfach.

Lasst uns das Counter Example hier klonen https://github.com/near-examples/counter.
git clone https://github.com/near-examples/counter

yarn

















Wir interessieren uns nur für diese 2 Ordner und 1 Datei.assembly/ ist der Ort, an dem sich unser Smart Contract befindet (der zu WASM kompiliert wird).

src/ ist der Ort, an dem sich unser Frontend-Code befindet, der mit dem Contract interagiert.

package.json ist der Ort, an dem sich unsere zusätzlichen JavaScript-Dependencies befinden.


















Der Kern unseres Contracts umfasst die Speicherung in der Blockchain, die Kontrollprotokollierung für das erzeugte Receipt und exportierte öffentliche Funktionen. Funktionen, die die Speicherung festlegen, müssen benannt werden, da sie sonst (auch ohne NEAR-Konto) eingesehen werden können.

Near unterstützt mehrere Arten von Collections (die sich selbst beschreiben) unter dem near-sdk-as.












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections
Die Hauptelemente, die Du benötigst:

 	storage.getPrimitive - get/set
 	persistentMap - set/get
 	persistentUnorderedMap - set/get/query/length

Ich schließe persistentVector nicht mit ein, weil man es vermeiden sollte, ihn zu benutzen. Es ist sehr einfach, Tonnen von GAS zu verbrennen, indem man Vektoren iteriert, versuche, Sets zu benutzen, wann immer es möglich ist.
let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log gibt beim Aufrufen einer Funktion eine Log-Ausgabe auf dem Receipt aus. Dies ist nützlich für den Kontrollfluss, insbesondere wenn die Contracts komplexer werden. Ein Beispiel für einen menschenlesbaren Contract kann eine Log-Meldung wie "alice.near has minted 5.0 ZOD from zod.near" sein.

Lasst uns unseren Contract deployen, dafür brauchen wir near-cli.






npm install near-cli -g
Und für die Bereitstellung können wir ein Dummy-Testnet-Account erstellen. Accounts sind Contracts und Du kannst nur einen Contract pro Account haben. Um mehrere Contracts zu erstellen, musst Du Sub Accounts verwenden: contract1.me.near, contract2.me.near.

Wir setzen die Funktion getCounter ein und rufen sie auf.
yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
Die Ausgabe ist

View call: dev-1623290109414-64922580028342.getCounter({})
0
Lasst uns den Counter erhöhen

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Lasst Uns diesen Teil auf dem Block Explorer aufrufen.

https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342 

Großartig.

Um eine Funktion anzuzeigen, können wir curl verwenden, müssen aber einige Befehlszeilen Ausgaben parsen, es ist einfacher, ein schnelles Node-Skript zu schreiben. Wir brauchen nicht einmal ein near-Konto.






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
Der folgende Ausschnitt verwendet die RPC-API https://docs.near.org/docs/api/rpc, um den Zustand des Contracts zodtv.near mint abzufragen.

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
NEAR benennt die 24, den Yocto.

3_000_000_000_000__000_000_000_000

ist 3.0

Damit endet die erste Serie, die nächste wäre die Arbeit mit einem Web-Frontend und die korrekte Ermittlung von Kontostand, Status und mehr.

### Was bedeutet Tokenomics? Schnellanleitung

Einer der Grundpfeiler eines dezentralen Netzwerks ist die Tokenomic, oder auch Token-Ökonomie. Um Projekte dabei zu unterstützen, die Nuancen ihrer Token besser zu verstehen, hat der Learn Near Club einen neuen Playground für Tokenomics im NEAR Testnet eingerichtet - LNC|TokenHub. Bevor wir jedoch ins Detail gehen, sollten wir wissen, was Tokenomics bedeutet.
Was bedeutet Tokenomics?
Token war ursprünglich nur ein anderer Begriff für eine "Kryptowährung" oder ein "Krypto-Asset". In letzter Zeit haben wir jedoch den Begriff "Token" verwendet, um ein Krypto-Asset zu beschreiben, das auf einer Blockchain ausgegeben wird, allerdings nicht die Native Währung auf der Blockchain ist. Der Begriff "Tokenomics" setzt sich aus den Begriffen "Token" und "Economics" zusammen und beschreibt - Du ahnst es schon - die wirtschaftlichen Aspekte eines Tokens.

Wenn Du die Tokenomics des Netzwerks beurteilen willst, solltest Du dir folgende Fragen stellen:

 	Wie groß ist das Gesamtangebot an Token, und wie viele von ihnen gelangen gleichzeitig in das System?
 	Wie viele Token werden in Zukunft ausgegeben werden?
 	Wie werden die Token unter den Nutzern verteilt?
 	Welche genaue Rolle spielt der Token im Netzwerk?
 	Braucht das Netzwerk diesen Token, um zu funktionieren?

Insgesamt geht es darum, eine klare Verbindung zwischen der Plattform und dem Vermögenswert herzustellen.
In Tokenomics definierte Elemente
Bei der Tokenomic kann grob zwischen Supply Control und Utility unterschieden werden. Schauen wir uns jedes dieser Elemente an.
#1 Supply Control
Wie viele der Protokoll-Token werden tatsächlich im Umlauf sein? Wie viel des Angebots wird durch den Basis-Contract kontrolliert? Unter diesem Aspekt müssen wir bestimmte Begriffe verstehen.

Premining

Im Wesentlichen geht es darum, wie viele Token zum Zeitpunkt der Einführung bereits im Ökosystem im Umlauf sind. Normalerweise werden Token in regelmäßigen Abständen von spezialisierten Nutzern, die "Miner" genannt werden, hergestellt. Bestimmte Protokolle stellen jedoch oft einen bestimmten Prozentsatz ihres Gesamtangebots beim Start für die Token Verteilung und den Zugang zu Liquidität zur Verfügung. Beachten jedoch, dass das Pre-Mining einer großen Anzahl von Token zu Problemen mit Zentralisierung führen könnte. 

Token Allocation

Wie werden die Token dem Projektteam zugeteilt? Wird eine große Menge an Token zugeteilt, was zu Problemen mit Zentralisierung führen kann? Wie viele Token wird der Treasury für die künftige Entwicklung des Protokolls zugewiesen?

Token Vesting

Die meisten Projekte werden von Risikokapitalgebern oder anderen Investoren finanziert, die im Gegenzug für ihre Investition eine Zuteilung von Token erhalten. Leider neigen die Risikokapitalgeber in den meisten Fällen dazu, ihre Zuweisung an Token sofort loszuwerden, um einen schnellen Gewinn zu erzielen, was dem Protokoll unweigerlich schadet. Mit Token Vesting kannst Du eine bestimmte Token-Zuteilung für einen bestimmten Zeitraum festschreiben, um einen massiven Ausverkauf zu verhindern.

Das Token-Vesting ist wichtig, um das Vertrauen der Investoren zu gewinnen, da es ihnen zeigt, dass das Team und die Investoren das Projekt ernst nehmen und nicht auf einen schnellen Gewinn aus sind.  Vesting ist ein einfacher Weg, um Marktmanipulationen zu verringern und den Wert der Investition zu garantieren.

Token Burning

Eine weitere einfache Taktik, die viele Projekte anwenden, um den Token-Umlauf zu kontrollieren, ist das verbrennen von Token oder auch Token Burning genannt. Die Idee ist einfach: In regelmäßigen Abständen wird eine bestimmte Menge an Token dauerhaft aus dem Verkehr gezogen. Die meisten Projekte tun dies, indem sie die Token an eine Dead Wallet senden. Dies ist eine Adresse, zu der niemand den Schlüssel hat. Projekte wie Ethereum und Binance verwenden Token Burning, um das Angebot ihrer eigenen Token zu kontrollieren.
#2 Token Utility
Welche verschiedenen Rollen können Ihre Token einnehmen? Werfen wir einen kurzen Blick auf einige der verschiedenen Rollen.

 	Token können für reine Nutzungs- und Zahlungszwecke innerhalb oder außerhalb der Protokolle Umgebung verwendet werden.
 	Token können verwendet werden, um sich an dem Protokoll zu beteiligen und an der Governance teilzunehmen.
 	Der Besitz des Protokoll-Tokens ist Voraussetzung für den Zugriff auf die verschiedenen Anwendungen (DeFi und NFT) innerhalb des Systems.

Spielen mit Tokenomics
Mit dem Tokenomics-Tool von Learn Near kannst Du die verschiedenen Komponenten Deines Tokens abbilden und mit ihnen im Testnet spielen.

Diese Komponenten sind:

 	Token Name
 	Erstveröffentlichung
 	Symbol
 	Treasury
 	Initial Supply
 	Vesting-Startzeit
 	Vesting-Dauer
 	Decimal Points
 	Vesting-Intervall

Das Spiel mit diesen verschiedenen Werten wird Dir helfen, die Supply Control der Tokenomics Deines Protokolls zu verstehen. Möchtest Du mit diesem Tool experimentieren? Probiere LNC TokenHub aus!

### DeFi auf dem NEAR-Protocol

NEAR Protocol ist eine Smart Contract Plattform, die sich auf Entwickler- und Benutzerfreundlichkeit konzentriert. Sie schafft eine skalierbare Plattform für die Ausführung von Anwendungen. NEAR wurde im Sommer 2018 von Alex Skidanov und Illia Polosukhin gegründet. In diesem Artikel werden wir uns heute mit DeFi-Anwendungen auf dem NEAR-Protocol beschäftigen.
Der Aufstieg von DeFi
DeFi oder Decentralized Finance sind blockchain basierte Finanzinstrumente. Während zentralisierte Finanzinstrumente durch mangelnde Interoperabilität und Bürokratie behindert werden, sind DeFi-Apps wie Legosteine, welche die Nutzer zusammenführen können, um neue Instrumente zu schaffen. Infolgedessen ist das DeFi-Ökosystem von 7,40 Milliarden Dollar am 22. Juni 2020 auf 97,7 Milliarden Dollar am 7. September 2021 angewachsen. Das ist ein Wertzuwachs von ~1220 % in etwas mehr als einem Jahr! 



Derzeit beläuft sich der Gesamtwert der DeFi auf rund 83,86 Milliarden Dollar. 
Die wahre Bedeutung von DeFi
Es reicht nicht aus, nur über den Gesamtwert zu sprechen, um die wahre Bedeutung von DeFi zu verstehen. Es ist ein entscheidendes Element beim Aufbau des Open Web und war allein verantwortlich für den Zulauf an Talenten, den Ethereum in den letzten zwei Jahren erfahren hat. Wenn man darüber nachdenkt, macht dies aufgrund der revolutionären und zusammensteckbaren Natur von DeFi absolut Sinn. Handlungen, die in der traditionellen Finanzwelt Wochen dauern würden, brauchen jetzt nur noch Sekunden.

Es gibt jedoch auch eine Kehrseite dieser Medaille. Aufgrund des sprunghaften Anstiegs der Nachfrage ist DeFi für die Überlastung der Netze und die steigenden GAS-preise verantwortlich. Dadurch ist die Einstiegshürde in Ethereum für neue Entwickler und Gründer deutlich höher geworden.

Das NEAR-Protocol bietet eine praktikable, schnellere und billigere Alternative zu Ethereum.
DeFi auf dem NEAR-Protocol


Schauen wir uns einige der vielversprechendsten DeFi-Projekte auf NEAR an.
Rainbow Bridge


Die Rainbow Bridge existiert zwischen NEAR und Ethereum. Alle Vermögenswerte, die aus Ethereum stammen, sind nun vollständig in NEAR verwendbar. Seit dem Start haben ETH, DAI und andere Token im Wert von über 1 Million Dollar die Brücke überquert. Die Bridge-Infrastruktur kann leicht wiederverwendet werden und gewährleistet Verbindungen zwischen NEAR und allen EVM-kompatiblen Chains wie Polygon, BSC, Avalanche, Optimism, Arbitrum usw. Das Team arbeitet derzeit an der Erweiterung dieser Infrastruktur zur Unterstützung von Nicht-EVM-Blockchains wie Bitcoin, Cosmos usw.

Hier sind einige Dinge, die Du über die Rainbow Bridge wissen solltest:

 	Benutzer können direkt über MetaMask in die Rainbow Bridge eingebunden werden.
 	NEAR-Transaktionen werden in weniger als 2 Sekunden bestätigt und kosten <1 Cent an GAS-Gebühren.

Hier sieht man, wie eine NEAR<>Ethereum-Bridge-Transaktion aussieht:

 	Assets, die von Ethereum zu NEAR gehen, brauchen etwa 6 Minuten (etwa 20 Blöcke).
 	ERC20-Transaktionen kosten im Durchschnitt etwa 10 Dollar.
 	Das Senden von Vermögenswerten von NEAR zurück nach Ethereum dauert maximal 16 Stunden (aufgrund der Ethereum-Finalitätszeiten). Dieser Vorgang kostet aufgrund der ETH-GAS-Kosten ebenfalls etwa 60 $.

Die Rainbow Bridge ist eine wichtige Innovation, da sie ein wesentlicher erster Schritt in der Interoperabilitäts-Roadmap von NEAR ist. Da NEAR außerdem schnellere und billigere Transaktionen bietet, könnte es für Nutzer anderer Chains vorteilhaft sein, mit Ethereum-Assets auf NEAR zu interagieren, anstatt direkt zu Ethereum zu wechseln.
Ref Finance


 

Ref Finance war die erste DeFi-Plattform auf NEAR. Die erste Version von Ref hatte einige Ähnlichkeiten mit Uniswap V2, zusammen mit der Unterstützung für mehr Pool-Typen, konfigurierbare Gebühren, und es ist vollständig im Besitz der Community. Sein Hauptziel ist es, Kernkomponenten von DeFi wie decentralized exchange (DEX), lending protocol, synthetic asset issuer usw. zusammenzuführen.

Ref Finance verfügt über ein Vermögen von 35 Millionen $REF, von denen 10 % für die Entwicklung neuer Projekte und 25 % für künftige gemeinschaftsbezogene Aktivitäten, Veranstaltungen und Partnerschaften bestimmt sind.

Merkmale von Ref Finance

 	Ref's AMM DEX ermöglicht einen genehmigungsfreien und automatisierten Handel zwischen jedem nativen NEAR oder Bridged Token.
 	 Liquidity Provider können $REF- oder NEP-141-Token durch den Einsatz von LP-Token verdienen.
 	Benutzer können $REF-Token staken, um mit der Zeit mehr $REF zu verdienen.

Ref ist ein Gemeinschaftsprojekt und wird von einer DAO verwaltet. Die Ref DAO hat zwei Rollen - den Council und das Community Board. 

 	Council: Der Council erstellt Vorschläge und stimmt über sie ab. Ein Vorschlag wird nur angenommen, wenn die Mehrheit des Councils ihn bestätigt. Der Council wird geändert, sobald die DAO voll aktiv ist.
 	Community Board: Das Community Board stimmt ebenfalls über einen Vorschlag ab oder lehnt ihn ab. In den meisten Fällen wird der Council die Entscheidung des Community Board befolgen.

OIN Finance


OIN ist eine dezentrale Stablecoin-Emissions Plattform, die es Projekten ermöglicht, ihre eigene Stablecoin-Marke zu emittieren. Anstatt ihre Sicherheiten auf anderen Plattformen whitelisten zu müssen, wird OIN einen mit NEAR besicherten Stablecoin herausgeben, um Liquidität freizusetzen, ohne ihre NEAR-Tokens zu verkaufen. Die Anwendungsfälle von OIN sind - Swapping für andere Mainstream-Stablecoins, Hinzufügen von Leverage, Hedging, Lending und eine Fülle von Ökosystem-spezifischen Dienstprogrammen.

Derzeit ist die Haupt Produktlinie von OIN der OINDAO. Er ermöglicht ihm sich anschließenden Projekten, ihren eigenen Besicherungspool zu erstellen, um ihre eigenen Stablecoins mit Markenzeichen zu prägen. OIN etabliert einen schnellen Validierungsprozess für jede auf der Blockchain initiierte Transaktion durch das Merkle-Proof-System. Dazu werden kleine Information Brocken, die zu einer "Root-Transaktion" führen, in den Ledger aufgenommen und zur Validierung einer größeren Informationsdatenbank verwendet.

Einige interessante Merkmale von OIN sind die folgenden:

 	Es ist einfach und schnell, Stablecoins zu prägen, sobald das Listing-Projekt die Parameter festlegt.
 	Die Smart Contracts von OIN sind alle gründlich geprüft worden.
 	Es gibt Technische Unterstützung bei der Festlegung der wichtigsten Risikoparameter für die Smart Contracts.
 	Es gibt Technischen Support für den Tausch der eigenen Stablecoin mit anderenMainstream-Stablecoins auf Curve und Balancer zu tauschen, um die Liquidität des Assets freizusetzen.

Skyward Finance 


Skyward Finance ist ein permissionless und open-source Launchpad welches Projekte nutzen können, um ihre Token ohne jegliche Liquidität zu lancieren. Skyward verfügt über einen der besten Preisfindungsmechanismen, der resistent gegen Sybil- und Bot-Attacken ist. Die Plattform soll die Preisermittlung und Token Verteilung für Projekte ermöglichen, die auf dem NEAR-Protokoll basieren. Dies geschieht durch die Verwendung von zeitbasierten Streaming-Auktionen, auf die die allgemeine Gemeinschaft dezentral zugreifen kann. Diese Auktionen werden auch resistent gegen Preismanipulationen, Front Running und Sybil-Attacken sein. Skyward Finance wird Token an die Community ausgeben, die es ihr ermöglichen, Teil der Plattform zu werden und Einnahmen zu erzielen. 
Was sind einige der Vorteile von Skyward Finance?
Skyward Finance hat mehrere Vorteile, von denen einige im Folgenden aufgeführt sind.

 	Projekte können ihre Token ohne Liquidität auf den Markt bringen. 
 	Der Preisfindungsmechanismus von Skyward Finance ist resistent gegen Bot- und Sybil-Angriffe. Er kann auch nicht manipuliert werden. 
 	Projekte können Mittel in jedem Token aufbringen und auch mehrere Token-Verkäufe mit verschiedenen Token starten. 
 	Da Skyward Finance gegen jede Art von Preismanipulation unempfindlich ist, können Projekte und ihre Gründer ihr Kapital auf Basis des Marktwertes maximieren.
 	Projekte benötigen den $SKYWARD-Token nicht, um an einem Verkauf teilzunehmen oder einen zu erstellen. 
 	Skyward Finance ist open-source und permissionless, was bedeutet, dass die Smart Contracts auf der Plattform völlig unabhängig sind. 
 	Da Skyward Finance auf NEAR läuft, kann es die Vorteile von NEARs Skalierbarkeit und günstigeren Transaktionen nutzen. 




	

	
	
		
			
				Which of the following is a stablecoin issuance platform?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool ist ein liquid Staking-Protocol, das auf dem NEAR-Protocol basiert. Einzelpersonen können ihre NEAR-Token mithilfe von Meta Pool und seinen automatischen Einsatzstrategien problemlos staken. Im Gegenzug erhältst Du "Staked NEAR"-Token, die Du im DeFi NEARverse verwenden kannst. Die Token können auch jederzeit in die ursprünglichen NEAR Token zurückgetauscht werden. 

Meta Pool ist ein wesentlicher Bestandteil des NEAR DeFi Ökosystems geworden, da er NEARs ersten liquiden Staking Token, den stNEAR, einführt. Mit dem stNEAR-Token können Staking-Belohnungen angesammelt werden und auch Staking-Positionen auf NEAR dargestellt werden. Meta Pool bietet NEAR-Token-Inhabern eine einfach zu bedienende Plattform, die Renditen generiert und gleichzeitig ein dezentrales Netzwerk schafft. Meta Pools Governance wird auf einem DAO auf Sputnik V2 laufen, NEARs nativer Plattform zur Verwaltung von dezentralen autonomen Organisationen. 

Wenn Token-Inhaber sich an Meta Pool beteiligen, erhalten sie jede Epoche $META-Tokens. Jede Epoche beträgt 12 Stunden. Diese erhalten sie zusätzlich zu den Belohnungen des NEAR-Protocol, die 10,2% APY betragen. 
Cheddar 


Cheddar schafft ein Treuenetzwerk für NEAR und sein Ökosystem dezentraler Anwendungen. Dies geschieht durch den Aufbau strategischer Partnerschaften, die die Verwendung des NEAR-Protokolls bei der Belohnung der Nutzer aktiv fördern. Loyalitätsnetzwerke haben sich als erfolgreich erwiesen, um Nutzer zu Handlungen zu motivieren, die für Unternehmen von Vorteil sind. Durch Cheddar können Community-Tokens gebootstrappt werden, was es Anwendungen ermöglicht, die Nutzerbindung zu erhöhen und neue Einnahmequellen durch Farming-Mechanismen zu erschließen. 

Cheddar unterscheidet sich von anderen Yield-Farmen, da es HODL-Benutzern durch PowerUPs langfristige Vorteile bietet. Außerdem fördert es die anwendungsübergreifende Nutzung im gesamten NEARVerse, indem es den Nutzern ermöglicht, Cheddar durch Yield Farming, Liquiditätspools oder dApps zu farmen. 
How Does Cheddar Benefit The NEAR Protocol 

 	dApp-Konnektivität - Cheddar schafft eine gemeinsame Verbindung zwischen Apps, die über einzelne Token hinausgeht, und schafft so ein loyales Ökosystem für dApps auf NEAR. 
 	Nutzerbindung - Cheddar schafft langfristige Nutzerbindung durch verschiedene Anreize und baut Loyalität durch strategische Partnerschaften auf. 
 	Cross-Chain-Hopping - Cheddar schafft Cross-Chain-Interkonnektivität und hält die Nutzer auf NEAR aktiv und engagiert, wodurch sichergestellt wird, dass der Total Locked Value (TVL) erhalten bleibt. 




	

	
	
		
			
				Which of the following is creating a loyalty program on NEAR?
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Der Berry Club ermöglicht es den Nutzern, gemeinsam Pixelkunst zu erstellen und gleichzeitig Token-Belohnungen zu sammeln. Der Berry Club begann als DeFi-Proof-of-Concept, hat sich aber inzwischen zu einem äußerst beliebten Community-Projekt auf dem NEAR-Protokoll entwickelt. Der Berry Club nutzt mehrere Funktionen des NEAR-Protokolls, wie z. B. automatische Zahlungen an die Ersteller von Smart Contracts, die auf keiner anderen Blockchain zu finden sind, auf hervorragende Weise. 

Dank des einzigartigen Designs von NEAR können Berry Club und Berry Farm sowohl den Nutzern als auch den Herstellern von Smart Contracts zugute kommen, die in Form von Smart Contract-Belohnungen sowohl an Token-Inhaber als auch an Ersteller ausgezahlt werden. Diese Vorteile ergeben sich aus der erhöhten Nutzung der Anwendung (Berry Club). Diese Art der Verteilung von Belohnungen ist auf Plattformen wie Ethereum nicht möglich, zumindest nicht in der derzeitigen Implementierung. Dies ist ein weiterer Grund, warum Nutzer und Entwickler mit NEAR experimentieren sollten.




	

	
	
		
			
				The bridge between Ethereum and NEAR is called:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
Ein Forschungs- und Entwicklungsunternehmen, das DeFi auf das NEAR-Ökosystem ausrichtet.
Fazit
Das NEAR-Protokoll verfügt bereits über ein sehr aufregendes DeFi-Ökosystem, und es wird nur noch weiter wachsen. So wie es aussieht, bietet NEAR eine leistungsstarke und effiziente Alternative zu Ethereum.

### NEAR Sputnik DAO: Memberdayakan Komunitas

Open Web dan Web3 bermula dari gagasan bahwa internet generasi berikutnya akan dibangun untuk masyarakat dan juga diatur oleh masyarakat itu sendiri. Bahkan NEAR telah mengkodifikasikan ini dalam misi utamanya: memberdayakan semua orang untuk bisa mengontrol sendiri uang, data, dan kekuatan tata kelola mereka.



	

	
	
		
			
				What according to you should be the core purpose of a DAO?
			
		

		
					

		
			
			
			
			Coordinating community activities
		
			
			Facilitate the Governance Mechanism
		
			
			 Replicate the corporate structure
		
			
			Facilitate tokenomics
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berdasarkan postingan blog yang lama pada tahun 2014 oleh pendiri Ethereum, Vitalik Buterin melukiskan cara berpikir baru tentang tindakan kolektif, alih-alih dimana perusahaan dengan pemegang saham, eksekutif, dan karyawan, mungkin saja ada organisasi otonom terdesentralisasi, atau DAO, di mana anggota memiliki bagian dari organisasi, menyumbangkan apa yang mereka bisa untuk keberhasilannya, dan dihargai secara proporsional untuk kontribusi mereka. Tidak ada bos, tidak ada hierarki, dan para peserta disatukan oleh tujuan yang sama.

Saya ingat merasa terinspirasi ketika saya pertama kali membaca posting dari Vitalik, membayangkan masa depan yang benar-benar milik komunitas di mana siapa saja, di mana saja dapat meresmikan grup dan tindakannya terlepas dari batas-batas perbatasan, hukum, atau bank seperti halnya Web3 yang didukung blockchain untuk individu, yang dapat dilakukan DAO untuk komunitas. Pada akhirnya perusahaan akan digantikan oleh DAO, yang masih memiliki banyak fitur seperti perusahaan, tetapi dengan fleksibilitas yang lebih besar baik pada saat pendiriannya maupun seiring waktu karena tuntutan dan prioritas orang-orang yang terlibat berubah.

Visi ini bahkan mendahului minat saya pada Web3 dan blockchain. Saya meninggalkan Ukraina karena saya tidak pernah merasa aman untuk memulai sebuah perusahaan di sana. Saya tidak percaya dengan bank Ukraina mana pun yang dapat dipercaya untuk menyimpan uang saya dengan aman. Pemerintah telah mengubah aturan tentang memegang mata uang AS beberapa kali selama sepuluh tahun terakhir (seperti kebutuhan untuk menjual setengahnya pada penerimaan untuk mata uang lokal). Ada banyak korupsi dan struktur yang kaku seputar bagaimana agar perusahaan dapat beroperasi di Ukraina. Di beberapa negara, untuk membentuk perusahaan tentunya akan ada biaya tambahan karena korupsi pemerintah, kurangnya supremasi hukum, dan bank yang tidak dapat diandalkan yang bisa hilang sewaktu-waktu.

Ini berlaku di mana-mana, sampai batas tertentu: sebelum blockchain, jika orang ingin ikut berorganisasi ke dalam kelompok formal, mereka perlu meminta izin dari pemerintah (misalnya membuat perusahaan), terutama jika mereka membutuhkan rekening bank dan ingin berpartisipasi dalam perekonomian sebagai sebuah kelompok. Proses ini memakan waktu, mahal, kompleks, dan menghasilkan organisasi yang tunduk pada aturan yang membatasi mereka setelah terbentuk.

Bahkan koordinasi komunitas yang sifatnya informal tetap membutuhkan aturan dan moderasi. Bayangkan sebuah kelompok mahasiswa anime yang ingin mengoordinasikan acara fans internasional, atau sekelompok seniman sukses di seluruh dunia ingin bergabung bersama untuk mendukung seniman pemula lain. Koordinasi komunitas dapat mencakup segala hal mulai dari cara memposting ke arah mana anggota bersandar pada beberapa pertanyaan, membuat karya seni atau produk secara bersama-sama, meluncurkan aplikasi, berinvestasi dalam beberapa aset digital, atau bahkan memiliki channel sosial bersama seperti akun Twitter. Semua ini adalah contoh nyata dari koordinasi yang membutuhkan semacam tata kelola.

Untuk waktu yang lama, saya percaya pada banyak tim kecil yang bekerja bersama, bukan perusahaan besar yang menciptakan monopoli dan kemudian berjuang untuk mempertahankannya. Sebenarnya, sekitar sepuluh tahun yang lalu, beberapa teman dan saya membuat ProstoKSI yang bukanlah perusahaan, yang terdiri dari pengembang yang bekerja sama dalam poyek open-source.

Web3 membuat visi ini memungkinkan dimana hal ini tidak bisa dilakukan oleh Web2, karena jaminan bersumber dari kripto. Bayangkan membangun di atas penyedia cloud atau menggunakan bank yang hanya dijalankan oleh kelompok yang terdiri dari 20 orang tanpa afiliasi formal dan tidak ada jaminan bahwa organisasi akan tetap berfungsi dalam setahun kedepan dan juga ada batasan untuk apa yang dapat dibangun di atasnya . Namun dalam kripto, infrastruktur dan aplikasi terdesentralisasi dapat diandalkan karena bersifat open source, open state, dan dilengkapi dengan jaminan yang dapat diandalkan. Aplikasi yang dibuat dengan cara ini menyediakan protokol umum untuk berinteraksi satu sama lain, yang dapat diandalkan oleh pengembang, bisnis, dan pengguna lain.

DAO merupakan bagian dari protokol umum seperti itu di dunia baru. Dalam tujuh tahun sejak Vitalik menulis postingan tingkat tinggi ini, ribuan anggota telah bereksperimen dengan DAO di Ethereum dan jaringan lain — beberapa yang paling terkenal termasuk Maker, Moloch DAO, MetaCartel, The LAO, dan Flamingo DAO. Saya telah mengambil beberapa pelajaran penting dari gelombang pertama eksperimen DAO yang menginformasikan visi DAO di NEAR:

 	Secara umum jelas bahwa cara sederhana bagi komunitas untuk mengontrol tata kelola tidak sesuai dengan jumlah orang yang terlibat. Ribuan orang tidak dapat secara efektif mengembangkan atau mengendalikan apa pun tanpa pengenalan aturan, undang-undang, atau hierarki. Kami juga telah melihat sejumlah eksperimen di ruang blockchain seputar tata kelola protokol dan dana investasi. Banyak di antaranya yang gagal karena berbagai alasan, mulai dari masalah teknis hingga kurangnya minat untuk memberikan suara dari anggota atau kurangnya faktor pendorong yang menyatukan.
 	Seseorang tidak dapat berharap bahwa setiap anggota akan selalu bahagia. Kepentingan dapat melayang dan pendapat orang dapat berkembang; mayoritas dan minoritas pada akhirnya akan muncul di sekitar beberapa masalah. Meskipun dalam banyak kasus setiap orang akan mencapai konsensus melalui tata kelola dasar seperti pemungutan suara, minoritas komunitas harus dapat bercabang, atau menyimpang dari kelompok asli untuk mengikuti seperangkat aturan baru, kapan saja jika mereka tidak setuju dengan mayoritas dan memiliki cukup keinginan mereka sendiri.
 	Setiap komunitas atau organisasi membutuhkan kepemimpinan. Bahkan jika itu adalah sekelompok orang yang sangat berdedikasi — jika mereka tidak bekerja penuh waktu untuk tujuan bersama, mereka mungkin terlalu sibuk untuk aktif sepanjang waktu dan berpartisipasi dalam setiap diskusi atau keputusan. Komunitas biasanya memiliki anggota yang berdedikasi yang bertanggung jawab untuk koordinasi, berpotensi untuk memoderasi.
 	Jika sebuah komunitas bersifat permissionless (tanpa perlu bergantung ke pihak tertentu) dan semi anonim, tetaplah bernilai jika memiliki anggota yang diketahui oleh publik terlibat dan menciptakan "inti" dari komunitas. Komunitas akan mendengarkan perspektif dan pendapat anggota ini di atas yang lain karena mereka dikenal sebagai yang paling berdedikasi dan berpengetahuan.
 	Semakin "produk" terfokus seperti komunitas yang terdesentralisasi, semakin fokus pula kepemimpinannya, karena pengembangan produk biasanya membutuhkan lebih banyak konteks daripada yang dimiliki oleh peserta komunitas mana pun. Misalnya, komunitas yang mencoba membangun blockchain atau pertukaran terdesentralisasi bersama.
 	Pembobotan murni berbasis saham selalu gagal, baik karena mayoritas pemangku kepentingan tidak mampu atau tidak mau menjadi peserta aktif, atau karena dapat membuatnya lebih mudah untuk menyerang proses tata kelola.




	

	
	
		
			
				Is the Sputnik DAO created specifically for technical communities?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





So a DAO is a community united around some common purpose, requiring some rules for coordination and governance, with the flexibility to evolve over time as the interests and goals of the community shift, and the ability to transact and make money as a unit with minimal overhead. With all of these learnings in mind, we set out to create a DAO protocol on NEAR that would empower all kinds of communities — not just technical ones run by engineers — with a flexible, robust framework for working and evolving together.



	

	
	
		
			
				Which of the following is/are true about community leadership?
			
		

		
					

		
			
			
			
			True leadership ensures that every single community member is always happy
		
			
			Community leaders are not required to work full-time for the community
		
			
			Even in a permission-less community, it is important to have core members/leaders
		
			
			Leaders of the community govern the community by creating rules
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Protokol yang diciptakan yakni Sputnik DAO, menawarkan cara bagi komunitas dan organisasi baru dan yang sudah ada di seluruh dunia untuk memiliki perwakilan on-chain dari grup mereka, mengelola aktivitas on-chain mereka, mengatur pengambilan keputusan mereka sendiri, dan (yang penting!) berinteraksi dengan DAO lainnya. Saat ini ada sekitar 100 DAO Sputnik sejak peluncuran awal pada Februari 2021, dengan ~$500rb dialokasikan dan ~$500rb terdapat dalam perbendaharaan kolektif (lihat statistiknya di sini).

Lihat sputnik.fund dan beri tahu kami pendapat anda. Minggu depan kami akan membagikan V2 beta dengan UX yang fresh, fitur baru, dan artikel lain dengan detail tentang bagaimana Sputnik secara unik memecahkan tantangan utama dalam mengorganisir komunitas. Pastikan untuk mengikuti Medium kami untuk mendapatkan notifikasi tentang V2.

Terima kasih kepada semua komunitas grup Sputnik untuk ide terhadap v2, NEAR Team,

Tara Tan, Julia Lipton untuk masukan dan saran

Mally Anderson  untuk editorial
Artikel asli dapat dilihat di Medium.

### 5 Game Teratas di NEAR

NEAR Protocol merupakan platform smart contract yang berfokus pada pengembangan dan kenyamanan pengguna. Dengan GameFi dan game berbasis blockchain yang menjadi sesuatu yang besar kedepannya, mari kita lihat beberapa protokol game yang saat ini hadir di NEAR. Secara khusus, kita akan mengulas tentang:

 	Chain Typing
 	Pixel DApps : Pixelparty, Pixelpets. Dan Cryptoheroes
 	Lands

Chain Typing
Chain Typing adalah game play-to-earn yang membantu kamu meningkatkan efisiensi saat mengetik. Kamu harus memiliki karakter untuk memainkan game, seperti yang ditunjukkan di Papan Peringkat. Awalnya, hanya akan ada 30 karakter yang tersedia untuk bermain game. Seiring skala permainan, akan ada lebih banyak karakter yang dapat dimainkan yang tersedia. Karakter dapat digunakan sebagai ruang iklan untuk menampung deskripsi.



Donasi akan masuk ke dana permainan untuk membantu pengembangan game lebih lanjut. 

Biaya minting karakter chain juga didonasikan ke dana permainan dan sifatnya tidak bisa dikembalikan.
Pixel DApps


Pixel DApps telah membuat tiga jenis game untuk ekosistem NEAR, yaitu:

 	Pixelparty
 	Pixelpets
 	Cryptoheroes

#1 Pixelparty


PixelParty adalah salah satu game Pixel Dapps. Game ini merupakan etalase Bingkai NFT dengan total suplai 600 token. Bersamaan dengan itu, kamu harus memperhatikan hal-hal berikut ini:

 	Setiap token yang kamu miliki memungkinkan Anda menggambar pada bingkai 20x20px.
 	Pengguna dapat membeli bingkai terhubung yang berbeda untuk menggambar bingkai yang lebih besar.
 	Semua pemegang bingkai menerima hadiah dari ekosistem pixeltoken.
 	Frameholder aktif dengan jumlah frame minimum dapat berpartisipasi dalam DAO.

Berikut ini adalah cara untuk berpartisipasi dalam PixelParty:

 	Hubungkan aplikasi dengan wallet NEAR milikmu
 	Pilih dan beli salah satu bingkai yang tersedia.
 	Bingkai milikmu akan ditempatkan di sidebar.
 	Kamu bebas menggambar, mengedit, atau mencantumkannya di pasar.

#2 Pixelpets


PixelPets adalah game yang dibuat oleh Pixel DApps untuk berdagang dan bertarung dengan hewan peliharaan milikmu. Ini merupakan permainan NFT di mana setiap token mewakili salah satu dari 60 jenis hewan peliharaan yang berbeda-beda. Selain itu, setiap hewan peliharaan memiliki salah satu dari empat sifat kelangkaan yaitu common, rare, epic, dan legendary. Sifat tersebut memengaruhi berbagai atribut hewan peliharaan seperti kekuatan, kualitas, dan level. Di PixelPets, Anda dapat:

 	Menetaskan: Kumpulkan telur hewan peliharaan dan tetaskan. Kamu hanya dapat menetaskan satu telur dalam satu waktu. Semakin tinggi kelangkaan hewan peliharaan, semakin lama waktu yang dibutuhkan untuk menetaskan telur.
 	Melatih: Dengan melatih hewan peliharaanmu, kamu dapat meningkatkan kualitas peringkat. Kamu dapat melatih hewan peliharaanmu dengan mengirim mereka ke gym.
 	Evolve: Setelah mendapatkan poin pengalaman yang cukup dan mendapatkan tingkat kualitas yang diinginkan, hewan peliharaanmu dapat berevolusi ke tingkat berikutnya di ruang evolusi.
 	Bertarung: Pengalaman farming dengan berduel dengan petmaster lain. Kamu juga bisa bertarung di colosseum dan mendapatkan hadiah dan kehormatan.
 	Marketplace: Beli dan jual hewan peliharaan milikmu dengan pixeltoken.

#3 Cryptoheroes


Game ketiga yang dibuat oleh Pixel DApps adalah Cryptoheroes yaitu game berbasis blockchain yang berfokus pada looting PvE, perdagangan dan penempaan item, serta melawan bos dengan teman untuk mendapatkan PXT. Memasuki ruang bawah tanah, mengalahkan minion, dan mengumpulkan hasil jarahan.

Bagaimana kamu mendapatkan PXT:

 	Bergabung dengan sekutu untuk bisa berpartisipasi dalam penyerbuan, mengalahkan bos jahat, dan bersaing untuk mendapatkan hadiah PXT mingguan.
 	Mengumpulkan barang-barang kuat dan jual di pasar.
 	Kamu juga dapat memperbaiki item milikmu untuk meningkatkan perlengkapan yang ada.

Bagaimana Anda berpartisipasi dalam penyerbuan?

 	Setiap serangan memiliki 8 pemain.
 	Penyerbuan dilakukan setiap minggu.
 	20 serangan teratas dihargai setiap minggu.

NEAR Lands


NEAR Lands adalah game berbasis blockchain multipemain 2D yang terdesentralisasi. Kamu sebagai pemain dapat berjalan-jalan atau membangun game dunia terbuka berbasis lahan pixelated. Pemain dapat melakukan:

 	Membuat karakter dan item mereka sendiri.
 	Berbincang dengan teman.
 	Terlibat dengan peserta lain di dunia online.
 	Pemain dapat menjelajahi lanskap dan menciptakan dunia online yang imersif dan interaktif.

Kesimpulan
Ekosistem game NEAR memang masih terlalu dini, tetapi sudah menunjukkan banyak harapan untuk kedepan. Jadi, pastikan kamu untuk terus memantau dan mengawasi proyek-proyek baru yang sedang dibangun di NEAR.

### Compte NEAR – Guide Express

Introduction au Compte NEAR

 	NEAR utilise des identifiants de compte lisibles par les humains au format nom.near. Par exemple, maria.near ou jane.near.
 	Le système de compte NEAR est similaire au système de domaine de site Web en ce sens qu'un compte peut créer autant de sous-comptes que nécessaire. Par exemple, un compte avec le nom maria.near peut créer un compte comme sub.maria.near, et il peut à son tour créer les comptes first.sub.masha.near, second.sub.maria.near et ainsi de suite.
 	NEAR Wallet (https://wallet.near.org/) (portefeuille NEAR Protocol), NEAR Faucet (https://faucet.paras.id/) (un faucet pour les utilisateurs d'Ethereum и Metamask) ou near-cli (https: //github.com/near/near-cli) (interface de ligne de commande qui offre des fonctionnalités pour l'intégration NEAR) peuvent tous être utilisés pour créer un compte.
 	Dans NEAR, vous pouvez créer un compte et l'envoyer à un ami ou à un abonné en cadeau à l'aide du service https://nearnames.com.
 	Vous pouvez vérifier les informations de compte dans NEAR Explorer (https://explorer.near.org/) ainsi que dans le NEAR Wallet
 	Outre les comptes visibles (type name.near), l'écosystème NEAR prend également en charge la création de comptes invisibles à l'aide de quasi-cli (ils ressemblent aux adresses Bitcoin et Ethereum). Vous pouvez trouver un guide détaillé en anglais ici
 	Chaque compte du système ne peut avoir qu'un seul contrat intelligent. Pour les applications qui nécessitent que l'utilisateur utilise plusieurs contrats intelligents, des comptes enfants peuvent être utilisés. Par exemple contract_1.maria.near, contract_2.maria.near, etc.
 	Il existe des comptes de développeur (https://docs.near.org/docs/concepts/account#dev-accounts) dans l'écosystème NEAR. Leur spécialité réside dans le fait qu'ils sont faits pour tester et déboguer les contrats intelligents.

COMPTE NEAR – Clés

 	NEAR, comme la plupart des autres blockchains, est basé sur la cryptographie avec une clé ouverte. Il s'appuie sur des paires de clés constituées chacune d'une clé ouverte (clé publique) associée à une clé fermée (clé privée).
 	NEAR utilise la clé ouverte pour l'identification et la clé fermée pour la signature des transactions (confirmation de la propriété du compte lors de la création de la transaction).
 	Dans NEAR, il existe 3 types de clés. Les clés d'accès servent à signer les transactions à partir du compte, les clés de validation permettent les opérations relatives à la validation du réseau, les clés de nœud (nœud de réseau) permettent une communication de bas niveau entre les nœuds du réseau.
 	Les clés peuvent être stockées dans 3 stockages différents. InMemoryKeyStore - stockage de mémoire, utilisé pour des scénarios temporaires. BrowserLocalStorageKeyStore – stockage de navigateur local non chiffré, utilisé pour travailler avec des applications dans le navigateur. UnencryptedFileSystemKeyStore – stockage non chiffré dans le système de fichiers, utilisé lorsque vous travaillez avec quasi-cli.
 	Un compte peut avoir plusieurs clés d'accès ou aucune.
 	Les clés peuvent avoir différents niveaux d'accès - FullAccess (accès complet) ou FunctionCall (uniquement la possibilité d'appeler des méthodes de contrat).
 	Toutes les clés sont uniques au sein d'un même compte, mais la clé publique peut être attribuée à différents comptes avec différents niveaux d'accès. Le niveau d'accès détermine les actions du compte qui peuvent être effectuées avec cette clé.
 	Pour le niveau d'accès FullAccess, les 8 types d'actions sont disponibles : CreateAccountAction (créer un compte), DeployContractAction (déployer un contrat), FunctionCallAction (appeler des méthodes de contrat), TransferAction (envoyer des tokens à un autre compte), StakeAction (staking de tokens), AddKeyAction (ajouter une clé à un compte), DeleteKeyAction (supprimer une clé de compte), DeleteAccountAction (supprimer un compte).
 	Pour le niveau d'accès FunctionCall, seule FunctionCallAction est disponible (appel des méthodes de contrat). De plus, pour une telle clé, vous pouvez spécifier les méthodes de contrat qu'elle peut appeler.

### Marchés des NFT en NEAR Protocol

Avec la croissance de la technologie blockchain, nous avons vu plusieurs nouveaux cas d'utilisation qui stimulent l'adoption de la blockchain, l'aidant à se généraliser. En 2021, nous avons vu la montée des NFT comme un nouveau cas d'utilisation de la technologie blockchain. Les NFT ont attiré l'attention de l'espace blockchain, ce qui a entraîné leur popularité croissante alors que les utilisateurs se précipitaient pour mettre la main dessus. Une mesure de leur popularité peut être mesurée par la vente d'une collection d'art NFT par Beeple qui s'est vendue pour un montant stupéfiant de 69 millions de dollars.

Avec le succès fulgurant des NFT, nous avons vu plusieurs artistes, musiciens et autres créateurs plonger dans les NFT. Nous avons vu des artistes tels que Grimes et des groupes tels que The Rolling Stones et Kings of Leon monter dans le train NFT en vendant des versions symboliques de leurs chansons, pochettes d'album et produits numériques et virtuels. Avec autant d'attention sur eux, les NFT sont un sujet brûlant, et il est essentiel de les comprendre et de savoir comment vous pouvez les acheter ou les vendre via un marché NFT tel que le marché des NFT NEAR. Mais d'abord, nous devons comprendre la définition d'un NFT.
Qu'est-ce qu'un NFT ?
Un NFT peut être décrit comme un actif numérique unique dont les informations d'identification sont stockées sur des contrats intelligents. Ce sont ces informations qui rendent chaque NFT unique. Parce que chaque NFT est unique, ils ne peuvent pas être échangés entre eux comme des éléments fongibles tels que la monnaie fiduciaire ou même le BTC. Les NFT sont également indivisibles, contrairement aux éléments fongibles, qui peuvent être divisés en actifs ou en montants plus petits, puis envoyés à d'autres. Par exemple, vous ne pouvez pas vendre la moitié d'un tableau ou la moitié d'un billet de train à qui que ce soit. La même logique s'applique à un NFT, chaque NFT unique contenant un ensemble unique de données qui ne peuvent être ni divisées ni échangées.

Les NFT sont basés sur deux types de normes de jeton sur la blockchain Ethereum, la norme de jeton ERC-721 et la norme de jeton ERC-1155. Les deux normes de jetons garantissent que l'actif en question agira d'une certaine manière, permettant aux développeurs de déployer facilement leurs NFT à l'aide de ces normes de jetons tout en garantissant la compatibilité avec les services et l'écosystème crypto. Cependant, plusieurs autres blockchains telles que EOS, NEAR et Tron ont maintenant publié leurs propres normes de jetons pour attirer les développeurs et créer des NFT sur leurs plateformes.
Histoire des NFT
Nous avons déjà discuté de ce qu'est un NFT ci-dessus. Cependant, d'où viennent les NFT ? Le premier NFT créé remonte à 2014, lorsque Kevin McCoy a créé le premier NFT intitulé "Quantum" le 3 mai 2014, bien avant l'explosion des NFT et de l'espace de l'art cryptographique. Le Quantum NFT peut être décrit comme une image pixélisée, consistant en un octogone rempli de cercles, d'arcs et d'autres formes. Toutes les formes partagent le même centre, les plus grandes entourant les plus petites.

En approfondissant l'histoire, les NFT ont été alimentés par des phénomènes culturels tels que CryptoPunks et CryptoKitties. Cependant, l'histoire va beaucoup plus loin que cela. En 2012, nous avons vu l'émergence de "pièces colorées", auxquelles on peut attribuer l'idée des NFT. Ces pièces colorées ont été initialement émises sur la blockchain de Bitcoin. Puis en 2014, Counterparty a émergé, créé sur la blockchain Bitcoin et permettant la création d'actifs. En 2016, nous avons vu l'émergence de Rare Pepes et, peu de temps après, de CryptoPunks, qui a conduit au boom des NFT, propulsant les NFT dans le courant dominant et capturant l'imagination du grand public.




	

	
	
		
			
				Which of the following is true about NFTs? 
			
		

		
					

		
			
			
			
			An NFT is a unique digital asset that has its identifying information stored on smart contracts 
		
			
			An NFT is an asset that is divisible and can be divided and shared or distributed to other individuals 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Qu'est-ce qu'un marché NFT ?
Tout comme vous avez besoin d'un marché pour acheter la plupart des articles, à la fois dans le monde réel et numérique, un marché NFT permet aux utilisateurs d'acheter, de vendre, d'échanger, d'afficher ou de minter (créer) leurs propres NFT. Considérez un marché NFT comme un eBay ou un Amazon, mais exclusivement pour les NFT. Pratiquement tout le monde peut utiliser un marché NFT, mais pour accéder à ces marchés, un utilisateur a besoin des éléments suivants

 	Un compte utilisateur sur le marché NFT qui vous permettra d'acheter le NFT à partir d'une plateforme particulière.
 	Un portefeuille crypto compatible avec la blockchain sur laquelle vous avez l'intention d'acheter les NFT. Par exemple, si vous envisagez d'utiliser la blockchain Ethereum pour acheter ou vendre vos NFT, vous aurez besoin d'un portefeuille compatible tel que MetaMask. Si vous envisagez d'utiliser Solana, vous aurez besoin d'un portefeuille compatible avec Solana, tel que Sollet.

Les places de marché NFT sont cruciales car elles relient les acheteurs et les vendeurs et offrent aux utilisateurs une multitude d'outils leur permettant de créer leurs propres NFT en quelques minutes. Les artistes peuvent utiliser le marché pour mettre leurs NFT en vente, et les acheteurs peuvent parcourir le marché, en achetant l'article par le biais d'un processus d'enchères.
Marchés NFT populaires
Il existe plusieurs marchés NFT parmi lesquels vous pouvez choisir en fonction de vos besoins. Les marchés NFT universels sont extrêmement populaires, tandis que d'autres marchés de niche existent pour des NFT spécifiques qui pourraient consister en des cartes à collectionner, des mondes numériques terrestres virtuels tels que Decentraland, ou même certains objets et objets de collection dans le jeu. Certains des marchés NFT les plus populaires sont

 	OpenSea
 	SuperRare
 	Rarible 
 	Mintable
 	Nifty Gateway 

Comment la montée en puissance d'OpenSea a alimenté les NFT
OpenSea s'est imposé comme le leader et est le plus grand marché NFT, hébergeant et fournissant un support pour toutes sortes d'actifs numériques. Le marché était initialement utilisé comme marché pour le jeu populaire CryptoKitties. Cependant, il s'est depuis étendu bien au-delà des objets de collection et constitue un marché pour divers actifs tels que la musique, les actifs du jeu et les objets de collection, les objets de collection numériques, l'art, etc. OpenSea est responsable de la croissance des NFT sur les NFT et les projets NFT  tels que CryptoKitties, CryptoPunks, Ethermon et autres, qui ont tous été lancés en 2017, la même année qu'OpenSea, ce qui a conduit le marché à diriger la charge des NFT vers le grand public.




	

	
	
		
			
				Which are the token standards used for NFTs? 
			
		

		
					

		
			
			
			
			ERC-721 and ERC-1155
		
			
			ERC-20
		
			
			ERC-725
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Le NEAR Protocol
Le NEAR Protocol a été fondé en 2018 et est une plate-forme de développement décentralisée qui crée un environnement parfait pour les contrats intelligents et les applications décentralisées. NEAR se concentre sur les lacunes d'autres protocoles dans le même espace, tels qu’Ethereum, rivalisant facilement avec les capacités de la plate-forme numéro un pour la Finance Décentralisée et les Applications Décentralisées. NEAR corrige l'une des lacunes les plus criantes d'Ethereum, celle de la scalabilité. Pour ce faire, il utilise un processus appelé "sharding". Le sharding permet au protocole NEAR de scaler de façon exponentielle.

NEAR utilise une blockchain Proof-of-Stake qui utilise le sharding et est conviviale pour les développeurs. NEAR est peu coûteux et hautement évolutif, permettant aux développeurs de créer facilement des applications décentralisées. NEAR présente également Doomslug, qui permet aux blocs d'atteindre la finalité en quelques secondes. Le protocole utilise la même technologie que Bitcoin, en la combinant avec d'autres fonctionnalités telles que le sharding. Le protocole NEAR scale de manière linéaire, ce qui lui permet de prendre en charge des milliards de transactions de manière décentralisée.

NEAR se compose également de plusieurs plates-formes NFT uniques car de plus en plus de projets choisissent NEAR Protocol pour lancer leurs projets. La collaboration de NEAR avec Ed Young a vu la plateforme lancer des portraits de figures emblématiques de l'histoire du hip-hop. La plate-forme Arterra de NEAR permet l'engagement des fans pour les influenceurs, les équipes de sports et les streamers, permettant aux fans de collecter des NFT auprès de leurs créateurs préférés. Un autre projet sur NEAR est Pixelparty, composé de 600 jetons, chaque jeton étant une représentation d'une sous-trame d'une trame Pixelparty. Un autre projet sur NEAR est Metamon, qui permet aux utilisateurs de collecter des monstres basés sur NFT. Les utilisateurs peuvent également combiner deux monstres, les transformant en NFT plus puissants et plus rares.

NEAR permet aux utilisateurs d'accéder à plusieurs protocoles allant des DAO, DeFi et NFT, avec un écosystème dynamique qui a plusieurs projets en cours. Parce que nous nous concentrons sur les marchés NFT, nous examinerons les projets NFT sur le protocole NEAR, à savoir Paras, Mintbase et TenK.
Mintbase 


Source: NEAR

Créé par Nate Geier et Carolin Wend en 2018, Mintbase permet aux utilisateurs de créer et de vendre des NFT NEAR. Ces NFT pourraient être n'importe quoi allant de l'art cryptographique aux actifs numériques et tout le reste entre eux. Toute personne ayant accès à Internet peut créer un NFT sur Mintbase et le vendre sur le marché des NFT NEAR ou le vendre sur d'autres marchés tels que OpenSea ou d'autres marchés. Mintbase permet aux créateurs de conclure des contrats intelligents, limitant la transférabilité des jetons mintés. Cela contribue à réduire considérablement la fraude ou le transfert illégal de NFT.

Mintbase est passé d'Ethereum à NEAR grâce aux frais de gaz élevés sur le premier. Les frais de gaz sont devenus si élevés que Mintbase a dû demander aux utilisateurs d'attendre que les prix du gaz baissent avant de déployer un magasin. Avec des frais de gaz nettement inférieurs, NEAR était et continue d'être la plate-forme idéale pour Mintbase. Le protocole est en mesure d'obtenir des frais de gaz inférieurs grâce à un modèle d'exécution de contrat efficace. NEAR utilise également une approche dynamique du sharding appelée Nightshade, ce qui lui confère un avantage considérable sur d'autres plates-formes telles qu'Ethereum.
Paras

Source: NEAR

Paras est un marché de cartes d'art numérique créé sur le protocole NEAR. Le protocole est différent des autres marchés car il propose exclusivement des collections au lieu de versions uniques. Paras s'inspire des cartes à collectionner du monde réel, avec ses NFT similaires à ceux des collections de cartes de sport, d'autres cartes à collectionner de franchises populaires telles que Pokemon. Contrairement à d'autres marchés, en particulier ceux d'Ethereum qui permettent aux utilisateurs de télécharger à peu près n'importe quoi, Paras adopte une approche plus mesurée des NFT.

Pour créer sur Paras, les artistes doivent postuler, avec seulement 30 artistes approuvés chaque semaine. Les œuvres d'art créées par les artistes doivent respecter le rapport d'aspect de Paras de 64:89 tout en contenant également des informations spécifiques liées à l'œuvre. Paras a choisi NEAR car il offrait des vitesses de transaction rapides et des frais de transaction peu élevés. Un autre facteur majeur pour lequel Paras a choisi NEAR était le Rainbow Bridge, qui permet le transfert d'ETH vers NEAR, permettant l'achat transparent de NFT.

Récemment, Paras a lancé Boom Boom, une mini-série de bandes dessinées créée exclusivement pour l'écosystème NEAR. Le protocole a également lancé sa première bande dessinée, Paradigm, avec les trois premiers numéros disponibles gratuitement, tandis que les versions suivantes seront au prix de 0,3 $ NEAR par numéro.
TenK 


Source: Twitter

 

Mintbase et Paras sont considérées comme les plates-formes NFT les plus importantes disponibles sur le protocole NEAR. Cependant, il existe un troisième projet disponible sur NEAR, appelé TenK. TenK peut être décrit comme une plate-forme d'art génératif open-source qui apporte une multitude d'œuvres d'art NFT au protocole NEAR. Le protocole lance déjà plusieurs projets importants sur NEAR. TenK est le protocole derrière NEAR Misfits, qui a été lancé en 2021. NEAR Misfits est la première collection d'images de profil cryptographiquement complète basée sur le protocole NEAR.
Réflexions finales
Le protocole NEAR a rendu la frappe des marchés NFT et NFT beaucoup plus facile qu'Ethereum, lui permettant de devenir l'un des protocoles les plus prometteurs et les plus recherchés dans l'espace crypto. NEAR prend Ethereum de front, fournissant des solutions à des problèmes de longue date tels que le manque de scalabilité, la lenteur des transactions et des vitesses de traitement et les frais de gaz extrêmement élevés. NEAR est devenu une alternative réussie à Ethereum, avec de nouveaux projets affluant vers le protocole et d'autres passant d'Ethereum à NEAR. D'autres projets tels que Paras et TenK fonctionnent déjà sur NEAR.




	

	
	
		
			
				What shortcomings of Ethereum does NEAR address? 
			
		

		
					

		
			
			
			
			High gas fees 
		
			
			Scalability
		
			
			Slow transaction speeds 

		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### Qu'est-ce que le Web3 ?

Le protocole NEAR est une plate-forme de développement décentralisée qui vise à créer un écosystème Web3 sain via sa plate-forme évolutive et facile à utiliser. Aujourd'hui, comprenons les implications de Web3 et ce qu'il peut potentiellement faire pour l'écosystème.
Le besoin de Web3

Image Credit
Le Web 1.0 a été lancé par Berners-Lee en 1990 et est depuis devenu le fondement d'Internet tel que nous le connaissons aujourd'hui. Voici quelques-uns des piliers fondamentaux du Web 1.0 :

 	HTML ou HyperText Markup Language, qui est le langage de formatage du Web.
 	URL ou Uniform Resource Locator - une adresse unique pour identifier une ressource sur le Web.
 	HTTP ou HyperText Transfer Protocol vous permet de récupérer des ressources sur le Web.

Bien que cette étape ait été vraiment révolutionnaire, les pages Web étaient très statiques et assez différentes des sites Web conçus par des professionnels auxquels nous sommes habitués aujourd'hui. De plus, alors que les pages Web étaient loin d'être interactives, de nouveaux concepts comme le « courrier électronique » allaient devenir une partie importante de nos vies à l'avenir.

Au cours des deux dernières décennies, nous avons assisté à l'essor du Web 2.0. Les sites Web sont maintenant plus interactifs que jamais. Cependant, cela ne fait qu'effleurer la surface. Pensez aux entreprises qui se sont imposées au cours des deux dernières décennies. Meta, TikTok, Airbnb, Uber, etc. Quelle est la chose commune qui les relie ? Ils prospèrent grâce au contenu ou aux ressources générés par les utilisateurs. Essentiellement, c'était la percée majeure que nous avons vue à cette époque. On ne peut atteindre une véritable évolutivité qu'en permettant à vos utilisateurs de participer activement au sein de votre écosystème.

Cependant, le Web 2.0 a prospéré uniquement grâce à la centralisation. Vous ne nous croyez pas ? Pensez au nombre d'audiences du Congrès que les PDG de Google, Meta et Twitter ont dû passer pour expliquer tout ce qu'ils font avec les données des utilisateurs. Meta, en particulier, s'est rendu coupable de détournement de données d'utilisateurs. En fait, les données des utilisateurs qu'ils ont vendues à Cambridge Analytica étaient le fondement même des campagnes présidentielles américaines.
Qu'est-ce que le Web3 ?
La prochaine itération du Web et d'Internet sera le Web3, qui reposera sur certains principes fondamentaux. Examinons-les un par un.

Décentralisation

On peut affirmer sans risque que la décentralisation est le principe de base de la révolution Web3. L'idée est qu'il n'y aura plus d'autorité centrale ou de conseil d'administration centralisé qui contrôle la croissance et le récit de l'entreprise. Dans le monde d'aujourd'hui, la censure des plateformes est devenue un problème important. Il semble qu'à moins que vous ne suiviez une idéologie politique particulière, vos pensées finiront par être supprimées de la plateforme de médias sociaux. Les entreprises fabriquent délibérément des profils spécifiques "difficiles à trouver" pour réduire la propagation de certaines idéologies. Twitter a ouvertement admis avoir tendance à censurer les profils de droite. Le principal élément constitutif du Web3 sera la résistance à la censure apportée par la décentralisation.

Manque de confiance

C'est à peu près une extension du point de décentralisation. Dans le Web 2.0, vous auriez à faire confiance à des tiers avec vos informations sensibles. Le plus souvent, ces entreprises ont abusé des données à leur disposition, entraînant d'énormes scandales (Facebook et Cambridge Analytica). Désormais, conformément à la décentralisation, il n'y aura plus un seul organe au centre de l'entreprise qui contrôle toutes les données cruciales. Les applications Web3 fonctionneront à l'aide de la technologie blockchain et du réseau peer-to-peer pour garantir l'absence de confiance et la décentralisation.

Composabilité

L'un des aspects fascinants du Web3 sera son interconnectivité et sa composabilité. Nous l'avons déjà vu dans l'écosystème DeFi (finance décentralisée) et l'IoT (internet des objets). Dans DeFi, plusieurs plates-formes peuvent se connecter les unes aux autres et créer un écosystème soudé dans lequel vous pouvez profiter de nombreux instruments financiers.

Intelligence artificielle

Web3 utilisera l'IA et l'apprentissage automatique (Machine learning) (ML) pour permettre à ses systèmes de produire des résultats plus rapides et plus pertinents.




	

	
	
		
			
				Logging in to a website with your Facebook account is an example of:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cas d'utilisation de Web3
Web3 a plusieurs cas d'utilisation, les monnaies numériques, les NFT et d'autres entités dans l'espace crypto et blockchain devenant cruciaux pour Web3. Les organisations autonomes décentralisées ou DAO sont également un cas d'utilisation important pour Web3, utilisant des jetons pour rendre les pouvoirs de prise de décision plus justes et impartiaux.
Organismes Autonomes Décentralisés
Une connaissance de base des DAO et de leur fonctionnement est très utile pour comprendre et contribuer à Web3. Un DAO est une entité qui n'a pas besoin d'une autorité centrale pour fonctionner. Au lieu de cela, il est piloté par sa communauté et offre une autonomie et une transparence complètes. Les contrats intelligents régissent toutes les règles fondamentales ; les contrats exécutent également toute décision convenue par la communauté, avec tous les processus, y compris le vote ou les propositions, accessibles au public pour vérification. Essentiellement, un DAO est régi par des membres individuels qui font partie de la communauté, prenant collectivement des décisions critiques concernant le projet, allant des allocations aux mises à niveau.

Une équipe centrale de membres de la communauté établit des règles pour le DAO par le biais de contrats intelligents, définissant le cadre du DAO. Ces contrats intelligents sont vérifiables publiquement, permettant aux membres de la communauté de comprendre chaque étape liée au fonctionnement du DAO. Les membres de la communauté peuvent créer des propositions, après quoi l'ensemble de la communauté vote sur la proposition. Une fois qu'une proposition atteint un niveau de consensus au sein de la communauté, elle est acceptée et appliquée par le contrat intelligent.

Le paysage DAO peut être divisé en différents groupes tels que les DAO de protocole, les DAO d'investissement, les DAO de service, les DAO sociaux, les DAO de subventions, les DAO de collecteur et les DAO de médias. Certains des principaux DAO que vous pouvez suivre sont MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO, DAOhaus, Opolis, MolochDAO et BanklessDAO.




	

	
	
		
			
				Berners-Lee pioneered:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Pourboire
L'économie décentralisée offre une collaboration globale qui permet aux participants de contrôler leur façon de travailler, d'allouer leur temps et leur expertise, avec plusieurs outils déjà existants et émergents qui les responsabilisent et leur style de travail. Le pourboire est l'une de ces méthodes qui contribue à la croissance des communautés Web3 en incitant à la participation. Avant d'aller de l'avant, il est important de comprendre le « pourboire ». Dans le monde réel, on donne un pourboire à une personne qui fournit un service. Des pourboires sont souvent donnés aux femmes de ménage, au personnel des restaurants, aux livreurs et à d'autres personnes qui nous aident à accomplir ou à effectuer certaines tâches pour nous. Dans Web3, les pourboires fonctionnent sur le même principe, la principale différence étant que le transfert de fonds s'effectue via la blockchain.

Dans Web3, les membres de la communauté peuvent recevoir des pourboires pour diverses contributions, telles que la contribution au code d'un projet, la réponse à des questions, la rédaction d'un article ou lorsqu'un membre de la communauté apporte son expertise à un projet. Les pourboires peuvent être effectués sous n'importe quelle forme, allant des parachutages NFT et des jetons de gouvernance aux pourboires en ETH, USDC ou toute autre crypto-monnaie. Donner un pourboire aux contributeurs aide à renforcer la confiance dans la communauté, à s'assurer que les participants restent investis dans le projet et à donner le ton pour une participation future.

Actuellement, les utilisateurs de Web3 reçoivent des conseils dans les jetons NEAR sur Twitter et Telegram.
Se connecter avec votre portefeuille
Une autre chose intéressante que Web 3 change sont les procédures de connexion. À l'époque du Web 1.0, vous pouviez vous connecter à un compte de site Web de deux manières : soit par e-mail, soit via un compte unique créé uniquement pour ce site Web.

Ensuite, pendant la phase Web 2.0, vous pourriez vous connecter à tout avec votre compte Google ou votre compte Facebook. Bien que cela soit pratique, cela présentait toujours une lacune majeure - le transfert de valeur. Vous deviez toujours fournir vos informations de paiement séparément pour effectuer des achats.

Désormais, avec le Web 3.0, vous pouvez simplement vous connecter à différents sites Web avec votre portefeuille de crypto-monnaie. Par exemple, dans OpenSea, vous devez vous connecter directement à votre MetaMask et effectuer des achats. En fait, au Learn NEAR Club, vous DEVEZ vous connecter avec votre portefeuille NEAR pour participer aux activités (L)Earn.



 

Traiter avec les utilisateurs Web3 permet aux dapps de transmettre instantanément non seulement des données, mais également une valeur monétaire sans aucun intermédiaire impliqué !
Le rôle du protocole NEAR dans Web3
Avec sa plate-forme évolutive et facile à utiliser, NEAR Protocol fournit une plate-forme qui vous permet de créer des applications DeFi et des NFT sans brûler un trou dans votre poche.

DeFi TVL pour NEAR n'est que d'environ 141,72 millions de dollars. C'est un écosystème très jeune et se développe actuellement à un rythme rapide.



L'application DeFi la plus dominante qui représente plus de 80% de la TVL globale est Ref Finance.

Ref Finance présente certaines similitudes avec Uniswap V2, en plus il prend en charge plus de types de pools, des frais configurables et il appartient entièrement à la communauté. Ref se trouve également être la première plate-forme DeFi sur NEAR. L'objectif principal de Ref est de rassembler DEX, les protocoles de prêt, l'émetteur d'actifs synthétiques et plus encore sous un même parapluie.

NEAR a récemment lancé un énorme fonds de subventions de 800 millions de dollars qui visait spécifiquement à créer un écosystème DeFi plus vaste et plus sain. Le fonds a certaines exigences majeures, notamment les suivantes :

 	100 millions de dollars pour les startups
 	Fonds régional de 100 millions de dollars
 	250 millions de dollars de subventions écosystémiques à répartir sur quatre ans.

Lisez ceci pour en savoir plus sur DeFi sur NEAR.Read this to know more about DeFi on NEAR.

Côté NFT, plusieurs projets ont été créés sur la blockchain NEAR comme Mintbase, Paras, Hip Hop Heads, etc.

Mintbase est la plate-forme NEAR NFT la plus populaire car elle permet à quiconque de créer un NFT et de le mettre à disposition à la vente sur son marché ou sur des marchés NFT comme OpenSea. Les Minters peuvent créer un contrat intelligent et limiter la transférabilité des jetons frappés, aidant ainsi à prévenir la fraude ou le transfert illégal d'objets uniques. Mintbase se concentre sur la création d'une expérience de création NFT unique, c'est pourquoi, comme mentionné précédemment, il prend en charge différents actifs numériques. Ceci est contraire aux plates-formes concurrentes qui se concentrent sur une catégorie NFT spécifique.
Le revers de la médaille - Y a-t-il trop de battage médiatique ?
Récemment, ce mème a circulé sur Twitter, recevant des commentaires de Jack Dorsey et Elon Musk.


Image credit
À l'heure actuelle, les applications Web3 attirent énormément l'attention des VC de la Silicon Valley. Cela soulève un point de discorde majeur. Avec autant de parties prenantes inconditionnelles, les applications Web3 vont-elles être décentralisées au sens le plus vrai ? Dorsey et Musk ne le croient pas. Cependant, il sera intéressant de voir comment cela se déroulera à l'avenir.




	

	
	
		
			
				Which of the following does not require a central authority to function:
			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook
		
	
		

		
		
			
				Correct!
				Wrong!

### Top 5 des jeux NEAR sur NEAR

NEAR Protocol est une plate-forme de contrat intelligente qui met l'accent sur la convivialité pour les développeurs et les utilisateurs. Alors que GameFi et le jeu blockchain deviennent la prochaine grande nouveauté, examinons certains des protocoles de jeu qui sont actuellement en ligne sur NEAR. Plus précisément, nous examinerons :

 	Chain Typing
 	Pixel DApps: Pixelparty, Pixelpets, et Cryptoheroes.
 	Lands

Chain Typing
Chain Typing est un jeu pour gagner (play-to-earn) qui vous permet d'améliorer votre efficacité lors du typing. Vous devrez posséder un personnage pour jouer au jeu, comme représenté sur le classement. Au départ, il n'y aura que 30 personnages disponibles pour jouer au jeu. À mesure que le jeu évolue, il y aura plus de personnages jouables disponibles. Les caractères peuvent être utilisés comme espace publicitaire pour contenir des descriptions.



Les dons iront aux fonds du jeu pour aider à faire avancer le jeu. Les frais de minting des personnages de la chaîne sont également reversés aux fonds du jeu et ne sont pas remboursables.
Pixel DApps


Pixel DApps a créé trois jeux pour l'écosystème NEAR, à savoir :

 	Pixelparty
 	Pixelpets
 	Crypto-héros

#1 Pixelparty


PixelParty est l'un des jeux Pixel Dapps. Il s'agit d'une Cadre vitrine NFT avec un approvisionnement total de 600 jetons. Parallèlement à cela, vous devez noter ce qui suit :

 	Chaque jeton que vous possédez vous permet de dessiner sur un cadre de 20x20px.
 	Les utilisateurs peuvent acheter différents cadres connectés pour dessiner un cadre plus grand.
 	Tous les détenteurs de cadres reçoivent des récompenses de l'écosystème pixeltoken.
 	Les détenteurs de cadres actifs avec un minimum de cadres peuvent participer au DAO.

Voici comment participer à PixelParty :

 	Connectez-vous avec votre portefeuille NEAR.
 	Choisissez et achetez l'un des cadres disponibles.
 	Vos cadres seront situés dans la barre latérale.
 	Vous êtes libre de les dessiner, de les modifier ou de les lister sur le marché.

#2 Pixelpets


PixelPets est un jeu créé par Pixel DApps pour échanger et combattre avec vos animaux de compagnie. Il s'agit d'un jeu NFT dans lequel chaque jeton représente l'un des 60 types d'animaux différents. De plus, chaque animal de compagnie possède l'un des quatre traits de rareté : commun, rare, épique et légendaire. Le trait affecte les différents attributs de l'animal comme la force, la qualité et le niveau. Dans PixelPets, vous pouvez :

 	Éclosion : Récupérez les œufs d'animaux et faites-les éclore. Vous ne pouvez faire éclore qu'un seul œuf à la fois. Plus la rareté de l'animal est élevée, plus il faut de temps pour faire éclore l'œuf.
 	Entraînement : En entraînant votre animal de compagnie, vous pouvez augmenter le rang de qualité. Vous pouvez entraîner votre animal de compagnie en l'envoyant au gymnase.
 	Évoluer : après avoir accumulé suffisamment de points d'expérience et atteint le niveau de qualité souhaité, votre animal peut évoluer vers le niveau suivant dans la chambre d'évolution.
 	Combattez : expérience à la ferme en duel avec d'autres maîtres d’animaux de compagnie. Vous pouvez également vous battre dans le Colisée et gagner des prix et des honneurs.
 	Marketplace : Achetez et vendez vos animaux de compagnie avec pixeltoken.

#3 Cryptoheroes


Le troisième jeu créé par Pixel DApps est Cryptoheroes – un jeu basé sur la blockchain axé sur le pillage PvE, le commerce et la fabrication d'objets, et la lutte contre les boss avec des amis pour gagner du PXT. Entrez dans des donjons, battez des sbires et récupérez du butin.

Comment gagnez-vous des PXT :

 	Faites équipe avec vos alliés pour participer à des raids, vaincre des boss maléfiques et concourir pour des récompenses PXT hebdomadaires.
 	Collectez des objets puissants et vendez-les sur le marché.
 	Vous pouvez également reforger vos objets pour améliorer votre équipement existant.

Comment participez-vous aux raids ?

 	Chaque raid a 8 joueurs.
 	Des raids ont lieu chaque semaine.
 	Les 20 meilleurs raids sont récompensés chaque semaine.

NEAR Lands


NEAR Lands est un jeu multijoueur 2D décentralisé basé sur la blockchain. En tant que joueur, vous pouvez vous promener ou créer un jeu de monde ouvert terrestre pixélisé. Les joueurs peuvent :

 	Créez leurs propres personnages et objets.
 	Parler à des amis.
 	S'engager avec d'autres participants dans l'univers en ligne.
 	Les joueurs peuvent explorer le paysage et créer un royaume en ligne immersif et interactif.

Conclusion
L'écosystème de jeu NEAR est encore jeune, mais il est déjà très prometteur. Assurez-vous donc de rester attentif et de garder un œil sur les nouveaux projets en cours de construction sur NEAR.

### Eine kurze Einführung in das DeBio-Netzwerk

Die dezentralisierte und biomedizinische Lösung im Octopus-Netzwerk
Das derzeitige biomedizinische System ist defekt. Der Status quo hindert Patienten daran, frei auf ihre Daten zuzugreifen und Gesundheitsdienstleister können die Sicherheit der Daten ihrer Patienten nicht garantieren. Das DeBio-Netzwerk will das ändern.

Das DeBio Netzwerk ist eine dezentrale und anonyme Plattform für Medizin und Bioinformatik, die sich auf genomische Tests spezialisiert hat. DeBio hat sich zum Ziel gesetzt, die derzeitige biomedizinische Industrie zu revolutionieren, indem es den Patienten mithilfe modernster Blockchain-Technologien die volle Hoheit über deren Daten gibt.

Die Einführung von Blockchain in das aktuelle Tech-Ökosystem spielt eine große Rolle bei der Verfolgung eines dezentralisierten globalen Finanzwesens, aber die Anwendungsfälle, die Blockchain bietet, gehen über das Finanzwesen hinaus. DeBio ist der Ansicht, dass die Zukunft medizinischer Daten zum Teil von der Verwendung von Blockchain abhängt, insbesondere bei der Spezialisierung von technologischen Anwendungsfällen und der Interoperabilität.
Zentralisierte Gentests sind ein Risiko für die Privatsphäre
In den letzten Jahren hat die Beliebtheit von Gentests explosionsartig zugenommen. Infolgedessen haben Plattformen für Gentests, die direkt an den Verbraucher gerichtet sind, wie 23andMe und AncestryDNA, einen Anstieg der Kundenzahlen verzeichnet. Was viele Menschen jedoch nicht wissen, ist das implizite Datenschutzrisiko, das mit der Nutzung dieser Plattformen verbunden ist. 

Die gängigen Plattformen für Gentests, die direkt an den Verbraucher gerichtet sind, sind zentralisiert, was sie zu einem leichten Ziel für Datenschutzverletzungen macht. Im Jahr 2020 gab es allein in den Vereinigten Staaten 1001 Datenschutzverletzungen, von denen die Gesundheitsbranche am stärksten betroffen war (Govtech hat darüber berichtet).

Noch besorgniserregender ist, dass genetische Daten nicht nur für eine Person, sondern auch für ihren Familienstammbaum einzigartig sind. Durch die Nutzung eines zentralisierten Bioinformatikdienstes setzt Du nicht nur Deine Privatsphäre, sondern auch die Deiner entfernten Verwandten aufs Spiel. 

Der Schaden ist eindeutig, denn es besteht die Möglichkeit, dass Deine entfernten Verwandten, z. B. ein Cousin zweiten Grades, von Deiner Entscheidung betroffen sein können. Beunruhigend ist der Gedanke, dass ein entfernter Verwandter, von dem Du nicht einmal weißt, dass es ihn gibt, einen Gentest macht und dass seine genetischen Daten zu Ihnen zurückverfolgt werden können.

Genetische Daten können sogar mit wenigen demografischen Informationen, wie Alter und Bundesland, auf Dich zurückgeführt werden. Diese Art von Informationen können von Versicherungsgesellschaften gegen Dich verwendet werden, um das Beste aus ihren Kunden herauszuholen.
Das DeBio-Netzwerkkonzept
Das Hauptkonzept von DeBio basiert auf der Idee, den Verbrauchern mehr biomedizinische und genetische Tests zu ermöglichen, ohne deren Privatsphäre zu verletzen. DeBio will aber auch Anreize für die genetische Forschung schaffen, indem es die Zusammenarbeit zwischen unabhängigen Laboren fördert.
Eine physisch-digitale Verbindung für anonyme Tests
Auf dem Marketplace für Gentests von DeBio können die Verbraucher eine breite Palette von Produkten und Laborempfehlungen auswählen. Nachdem sich der Verbraucher für ein Produkt entschieden hat, muss er nur noch zwei DNA-Proben mittels Wangenabstrich oder Mundschleimhautproben mit Wattestäbchen nehmen.

Der Verbraucher schickt dann die DNA-Probe in einem Umschlag an das Labor. Die einzige identifizierbare Information auf dem Umschlag ist die genetische Tracking-ID für die Probe. Die Labore können die Proben ohne Tracking-ID nicht identifizieren, da DeBio aus Gründen der Anonymität keinerlei personenbezogene Daten sammelt, so dass die DNA-Proben nicht zum Verbraucher zurückverfolgt werden können.

Die Ergebnisse (z. B. Test und Genom) werden dann mit dem consumer's public key verschlüsselt, der von der DeBio-Blockchain abgerufen und dann auf einem dezentralen Speicher hochgeladen wird. Auf diese Weise behalten die Verbraucher die volle Souveränität über ihre verschlüsselten Daten. Um die Ergebnisse zu entschlüsseln, muss der Besitz des dazugehörigen private Keys nachgewiesen werden.

Das Team des DeBio-Netzwerks ist dabei, dieses Konzept der "physisch-digitalen Verbindung" auf Anwendungsfälle außerhalb des Markts für Gentests auszudehnen, z. B. auf Labortests für Krankheiten und andere elektronische Krankenakten oder persönliche Gesundheitsinformationen.
Die Kooperation zwischen souveränen Laboren bietet gemeinsame Produkte an, die Dienstleistungen mehrerer Labore miteinander verbinden
Nachdem der Verbraucher die DNA-Probe an das Labor geschickt hat, wird das Labor benachrichtigt. Sobald die Probe eintrifft, beginnt das Labor mit der Sequenzierung der physischen Proben oder mit Biomarker-Tests. Nach Abschluss der nachfolgenden Tests verschlüsselt das Labor die Ergebnisse mit dem consumer's public key und lädt sie in einen dezentralen Speicher hoch.

Die Ergebnisse können ohne den consumer's private key nicht entschlüsselt werden, so dass die Kontrolle des Verbrauchers über seine biomedizinischen Testergebnisse gesichert ist. Um jedoch weitere Anreize für Gentests zu schaffen, können die Verbraucher ihre Gentestdaten für andere Labore freigeben.

Das Ziel souveräner Labore ist es, die Verfügbarkeit von Produkten zu erhöhen und gemeinsame Produkte zu ermöglichen, indem die Dienstleistungen mehrerer Labore zusammengeführt werden. Dies ermöglicht DeBio auch eine Skalierung, da die Labore nicht zentralisiert sein müssen und mehrere unabhängige Genetikeinrichtungen teilnehmen können.




	

	
	
		
			
				Welches Problem will das DeBio-Netzwerk lösen?
			
		

		
					

		
			
			
			
			Datenschutzbedenken bei Online-Plattformen für Gentests
		
			
			Hindernisse bei der Arbeit von souveränen Laboren
		
			
			Der Mangel an Forschung in der Genomik
		
			
			Teure Gesundheitsversorgung
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Der DeBio Netzwerk Techstack
Bioinformatik und biomedizinische Ökosysteme müssen einerseits für die Fachleute, welche die Studien durchführen, zugänglich sein, andererseits aber auch sicher genug, um die Privatsphäre und die Souveränität der Patienten zu schützen. Um die Souveränität der Patienten über ihre Daten zu gewährleisten, besteht der gesamte Tech-Stack aus dezentralen Lösungen, die von der dezentralen Authentifizierung bis zur dezentralen Dateispeicherung reichen.



Das Bild stammt vom DeBio Deck

 

DeBio hat eine Reihe von Spitzentechnologien in die Lösung integriert, einschließlich, aber nicht beschränkt auf:

 	

 	Substrate
 	KILT Protocol
 	Das Octopus Network
 	Das InterPlanetary File System (IPFS)
 	Ocean Protocol



Substrate
Die erste nennenswerte integrierte Technologie ist Substrate. Substrate ist das Framework hinter dem Polkadot-Token, das es Entwicklern ermöglicht, zweckmäßige Blockchains zu erstellen. Die Kerndienste werden mit Substrate aufgebaut, was sie zu den Kernbausteinen der Lösung macht. DeBio hat Substrate aus den folgenden zwei Gründen gewählt:

 	Blockchain-Interoperabilität (im Wesentlichen die Möglichkeit, zwischen verschiedenen Blockchains zu kommunizieren).
 	Relay-Chain-Sicherheit (Anwendung strengerer Sicherheitsstandards der Host-Relay-Chain).

Die Interoperabilitäts Funktion ermöglicht nicht nur die Kommunikation zwischen Blockchains, sondern setzt auch einen Sicherheitsstandard durch, der von jeder mit der Haupt-Relay-Chain verbundenen Para-Chain übernommen wird. Infolgedessen wird die Sicherheit der DeBio-Blockchain verbessert, indem die Standards der entsprechenden Relais Chain befolgt werden.
KILT Protocol
Als nächstes ist hier das KILT-Protokoll zu nennen. KILT ist ein Protokoll zur Erstellung, Bestätigung und Verifizierung von Identitäten auf anonyme Weise im Web3. Um sich zu authentifizieren, muss jeder Nutzer einen Claim erstellen, der dann an einen vertrauenswürdigen Prüfer gesendet wird.

Dieser hat die Aufgabe, den Claim eines Nutzers zu zertifizieren, der dann in einen Hash umgewandelt wird, der in der KILT-Blockchain gespeichert wird. Der Claim eines Nutzers enthält manchmal sensible Daten über den Nutzer, aber da der Hash nicht in einen Claim zurückverwandelt werden kann, ist die Privatsphäre des Nutzers gewährleistet.

Nach Erhalt des Zertifikats vom vertrauenswürdigen Prüfer kann der Benutzer nun seine Claims in Anwendungen verwenden, die KILT nutzen und dem genannten Prüfer vertrauen. KILT ist auf Datenschutz ausgelegt. Anwendungen, die den Claim verifizieren, müssen nicht über den Prüfer gehen und vergleichen den Claim direkt mit dem in der KILT-Blockchain gespeicherten Claim, wodurch der Prüfer vom Verifizierungsprozess abgeschnitten und dieser vollständig dezentralisiert wird.

Das KILT-Protokoll bietet eine Lösung, die verhindert, dass Daten in einer einzigen Einrichtung konzentriert werden. Es ermöglicht Datensouveränität für Menschen, die sich ihrer Privatsphäre bewusst sind. DeBio hat sich mit KILT zusammengetan, um ein dezentralisiertes Authentifizierungssystem zu implementieren, weil es perfekt zu DeBios anonymen ersten Anwendungsfall passt.
Das Octopus Network
Octopus ist ein Krypto-Netzwerk für den Launch und den Betrieb von Web3-anwendungsspezifischen Blockchains zu einem Bruchteil der Kosten. Einer der Gründe für die Nutzung von Octopus ist, dass sie im Vergleich zu Polkadot eine deutlich günstigere Security Lease und vergleichbare Cross-Chain-Fähigkeiten bieten. Octopus wird durch das NEAR-Protokoll unterstützt. NEAR ist eine Hochleistungs-Blockchain, die das Problem der Skalierbarkeit lösen und die Produktivität der Entwickler durch Vereinfachung des Entwicklungsprozesses und Schaffung einer entwicklerfreundlichen Umgebung steigern soll.

DeBio ist bereits eine Partnerschaft mit Octopus eingegangen und wird eine der ersten fünf anwendungsspezifischen Blockchains (App Chains) sein, die im Octopus Network eingeführt werden. DeBio ist auch bereits Teil der Octopus Guild, einer Gemeinschaft von Entwicklern und App Chains im Octopus Network.
Das InterPlanetary File System (IPFS)
Das InterPlanetary File System (IPFS) ist ein Protokoll für die vollständig dezentralisierte Peer-to-Peer-Datenteilung und -Speicherung. IPFS wurde als Lösung für dezentrale Projekte entwickelt, die eine Datenmenge speichern wollen, die zu groß ist, um in der Blockchain selbst gespeichert zu werden. IPFS erstellt eindeutige Inhaltsadressen, indem der Inhalt selbst gehasht wird. Jeder einzigartige Inhalt hat eine andere Adresse, die auf seinen Standort verweist. DeBio fügt IPFS hinzu, um biomedizinische Daten wie verschlüsselte menschliche Genome und verschlüsselte elektronische Krankenakten zu speichern.
Ocean Protocol
Das Ocean-Protokoll wurde für die Nutzung von Datenbeständen in einer sicheren, die Privatsphäre wahrenden Weise entwickelt. Es ermöglicht die Monetarisierung von Daten, ohne dass diese jemals in den Besitz des Nutzers übergehen müssen, und zwar über die Funktion "Compute to Data". Der Open-Source-Daten Market Place des Ocean-Protokolls, Ocean Market genannt, ist forkbar; das DeBio-Netzwerk-Team wird Ocean für biomedizinische Daten nutzen.
Privacy Computing
Um biomedizinische Daten zu staken, wird DeBio anonyme biomedizinische Daten in seinem privaten Datenspeicher hosten. Dieser Prozess beinhaltet nicht das bereits erwähnte IPFS, da der Datenspeicher vollständig vom IPFS getrennt ist. Nutzer, die ihre Daten staken wollen, müssen ihre biomedizinischen Daten entschlüsseln und in ihren privaten Datenspeicher hochladen. Die Übertragung entschlüsselter biomedizinischer Daten in einen privaten Datenspeicher klingt zwar unheimlich, aber DeBio wird innerhalb des Datenspeichers Datenschutzkonzepte implementieren, um Deine Privatsphäre zu schützen.



Bild entnommen aus dem DeBio Whitepaper

Erst nach der Zustimmung des Nutzers werden die Datensätze über den Compute-to-Data-Proxy von Ocean zusammengeführt und der Drittanbieter kann Analysen erstellen und die Daten verarbeiten, während sie im privaten Datenspeicher bleiben.

Durch den Anreiz für die Nutzer ihre genomischen/biomedizinischen Daten zu staken, erhoffen wir uns weitere Anreize für die Forschung in diesem Bereich. Darüber hinaus werden in dem privaten Datenspeicher keine personenbezogenen Daten gesammelt, so dass Du dir keine Sorgen machen musst, dass Deine Proben zu dir zurückverfolgt werden könnten.

Pandu Sastrowardoyo, die Geschäftsführerin von DeBio, erklärte, dass einer der Gründe für die Gründung von DeBio darin besteht, die genetische Forschung durch die Schaffung eines vollständig anonymen Marktplatzes für genetische Daten zu fördern. "DeBio ist ein völlig neues Wirtschaftssystem für die Genomik, das genetische Souveränität ermöglicht, die Beteiligung kleinerer Labors sicherstellt und gleichzeitig die genetische Forschung vorantreibt. All dies geschieht auf der Grundlage eines DeFi-Modells, das vollständig dezentralisiert ist", sagte Pandu.




	

	
	
		
			
				Wo speichert DeBio die gestaketen Daten?
			
		

		
					

		
			
			
			
			In der DeBio-Blockchain
		
			
			Innerhalb der Daten-Token
		
			
			Auf einem privaten Datenspeicher
		
			
			Auf dem IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Technische Architektur-Ebenen
Unsere technische Architektur besteht aus vier Schichten: der Haupt-Blockchain-Infrastruktur, der Transport- und allgemeinen Geschäftslogikschicht und schließlich der obersten Geschäftslogikschicht.



DeBio Proposed Technical Architecture, Bild aus dem DeBio Whitepaper
Ebene 1: Die Blockchain-Infrastruktur
Die erste Ebene wird die Kerndienste enthalten. Die Kerndienste werden auf Substrate, Octopus und IPFS aufgebaut. Substrate ist der Kernbaustein für den Blockchain-Dienst. Zum Speichern großer Dateien wird DeBio IPFS verwenden und stattdessen die Inhaltsadresse in Substrate speichern. Schließlich wird die gesamte App-Chain mit der Octopus-Relay-Chain verbunden sein.
Ebene 2 & 3: Die Transport- und allgemeine Geschäftslogikschicht
Die zweite und dritte Ebene enthalten den Transport und die allgemeine Geschäftslogik. Diese Ebenen sind für die direkte Bereitstellung von Daten an die Nutzer verantwortlich. Jede Plattform enthält die grundlegende Geschäftslogik für die Interaktion mit der Blockchain und dient als Abstraktionsschicht von der vierten Schicht zur Kommunikation mit den Substrate-Diensten auf der ersten Schicht.
Schicht 4: Die oberste Schicht der Geschäftslogik
Die vierte Ebene besteht aus der DeBio-Benutzeroberfläche und der Metamask. Die gesamte Interaktion zwischen den Nutzern und der Blockchain wird über die vierte Ebene abgewickelt. Alle Abfragen werden ebenfalls auf der obersten Ebene definiert und dann auf allen zuvor genannten Ebenen verarbeitet. Um jede Transaktion zu finanzieren, können die Nutzer Metamask verwenden, um mit einem ERC20 Stablecoin zu bezahlen. In diesem Fall wird DeBio DAI als Stablecoin der Wahl verwenden.
Das Token-Modell


Bild entnommen aus dem DeBio Whitepaper

Das DeBio-Netzwerk Team beabsichtigt, sechs Token zu entwickeln:

 	Mainnet Transaction Rewards & Validator Token ($DBIO)
 	Der Governance Token ($GBIO)
 	Der Genomik-Data-Token ($GENE, über Ocean Protocol)
 	Der Biomed-Data-Token ($MED, über das Ocean-Protokoll)
 	Der Electronic Medical Records Data Token ($EMR, über das Ocean Protocol)

Mainnet Coin (stable coin, etc)
Der Mainnet Coin wird durch einen Stable Coin gedeckt sein. DeBio hat sich für einen Stable Coin entschieden, weil er als stabiler Austausch für Transaktionen und Gebühren im Zusammenhang mit der Arbeit der entsprechenden Labore verwendet werden muss. DeBio wird $DAI als stabilen Token verwenden.
Governance Token ($GBIO)
Governance Token werden hauptsächlich für die Abstimmung durch die registrierten Labore verwendet. Das DeBio-Netzwerk ist eine dezentralisierte Organisation, daher muss ein Governance-Schema für die Abstimmung auf dem DAOGenics-Market Place vorhanden sein. Alternativ kann der Governance-Token auch als Methode für das Onboarding von Labs dienen.
Die Data Token ($GENE, $MED, und $EMR)
Diese Token werden als Transaktionsmethode auf dem Data Market Place verwendet. Beim Staken von biomedizinischen Daten auf dem Ocean Market Place werden die Verbraucher mit Data Tokens belohnt, die in $OCEAN umgewandelt werden können.
Validator & Transaktion Rewards ($DBIO)
The validator token is used to incentivize the node owners to validate transactions and secure the dApp from unauthorized users. The intended incentives provided for validators are LP rewards and governance tokens.
Verbrauchertransaktionen im DeBio-Netzwerk
$DAI ist der Mainnet Stable Coin, der für Transaktionen auf der DeBio-Plattform verwendet wird. Verbraucher können den Mainnet Coin verwenden, um für Produkte und Servicegebühren zu bezahlen. Zu den Produkten, die auf dem Markt verfügbar sein werden, gehören genomische Testprodukte, biomedizinische Testprodukte und ein souveräner elektronischer Krankenakten-Speicherdienst (EMR).



Bild entnommen aus dem DeBio WhitepaperDeBio Whitepaper
Transaktionsbezogene Belohnungen
Jede Transaktion, die der Verbraucher durchführt, wird mit einem Validator-Token, genauer gesagt einem $DBIO-Token, belohnt. Der Preis eines einzelnen $DBIO-Tokens wird durch den Data Market Place des DeBio-Netzwerks bestimmt, auf dem die für das Staking verfügbaren genomischen Daten der Verbraucher gespeichert sind.
Data Staking im DeBio-Netzwerk
Nach dem Kauf eines Produkts auf dem Market Place können die Verbraucher entscheiden, ob sie ihre Ergebnisse auf dem Ocean Marketplace staken wollen. Die von den Verbrauchern gestakten Daten werden als Daten-Token kategorisiert, die $GENE, $MED und $EMR für genomische Daten, biomedizinische Daten bzw. elektronische Krankenakten (EMR) genannt werden. Die Data Token werden im DeBio-Netzwerk aufbewahrt und über das Ocean Protocol als ERC20-Token auf dem Data Market Place zusammengeführt. Da die genomischen Daten, biomedizinischen Daten oder EMR selbst zu groß sind, um in den ERC20-Daten-Token gespeichert zu werden, werden die Daten-Token in erster Linie als Zeiger/Link zu den entsprechenden Daten dienen.

Verbraucher, die ihre Daten-Token staken, werden auf dem Data Market Place die Rolle eines "Datenanbieters" einnehmen. Alle Transaktionen auf dem Ocean-Data Market Place werden mit $OCEAN-Tokens durchgeführt. Wenn die Transaktion erfolgreich ist, tauscht der Käufer $OCEAN-Token gegen die Daten-Token ($GENE oder $EMR oder $MED). Der "Datenanbieter" hingegen erhält die nachfolgenden $OCEAN-Tokens.



Bild entnommen aus dem DeBio Whitepaper

Wenn der Datenkäufer auf die mit dem Daten-Token verknüpften Daten zugreifen möchte, muss er den Daten-Token zuvor an den Datenanbieter senden. Infolgedessen verfügt der Datenanbieter sowohl über den $OCEAN-Token als auch über die Daten-Token, während der Datenkäufer die mit dem Daten-Token verknüpften Daten erhält.



Bild entnommen aus dem DeBio Whitepaper

Umgekehrt werden Daten-Token ($GENE oder $MED oder $EMR), die die DAOGenics Foundation erhält, in $OCEAN-Token umgewandelt. Nach einer bestimmten Zeit werden die von der DAOGenics Foundation erhaltenen $OCEAN-Token durch einen non-permission Smart Contract  in einen $DBIO-Token umgewandelt.

Infolgedessen wird die DAOGenics Foundation die $DBIO-Token immer durch einen non-permission Smart Contract zurückkaufen, der auf dem Transaktionsvolumen des Data Market Place basiert. Mehr Transaktionen auf dem Data Market Place werden die Nachfrage nach dem $DBIO-Token erhöhen.




	

	
	
		
			
				Was verdienst Du, wenn Du Daten auf dem Data Market Place von DeBio-Natzwerk stakest?
			
		

		
					

		
			
			
			
			Den Mainnet coin ($DAI)
		
			
			Governance tokens ($GBIO)
		
			
			Transaction reward token ($DBIO)
		
			
			Ocean token ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Fazit
Gentests sind in vielerlei Hinsicht von Vorteil. Zum ersten Mal in der Geschichte der Menschheit sind die Menschen in der Lage, ihren Lebensstil zu bestimmen, um ein langes Leben zu erreichen; der Vorteil eines solchen Wissens ist überwältigend. Gentests haben zwar wunderbare Vorteile, aber ohne angemessene Vorschriften und Standards haben sie auch ihre Schwächen. Ohne die Garantie, dass Deine genetischen Daten privat und sicher sind, könnten in der Zukunft Probleme verursacht werden..

DeBio will dieses Problem lösen, bevor es zu spät ist. DeBio baut eine dezentralisierte Plattform für Deine persönlichen medizinischen Bedürfnisse auf, angefangen bei der Genetik. Unser Konzept ermöglicht Synergien zwischen Laboren aller Größenordnungen und garantiert gleichzeitig die Anonymität und Souveränität der Nutzer in jedem Schritt des genomischen Datenforschungs-Workflows - von der Probenerfassung über die Datenspeicherung bis hin zur Berichterstellung.

Manche Leute würden sagen, dass unsere DNA das Privateste ist, was wir haben, und das nehmen wir sehr ernst. Die Anonymität von Gentests sollte für alle Unternehmen an erster Stelle stehen.

Die Zukunft ist da: DeBio entwickelt Lösungen, die das Gesundheitswesen und die Gentestbranche revolutionieren werden. Bist 

Du bereit, die Welt mit uns zu verändern?Angepasst an den ursprünglichen Artikel auf Medium.

### Wie entwickelt man auf dem NEAR Protocol? Ein Leitfaden

Voraussetzungen:

 	Lies "What is NEAR?"
 	Erfahrung in der JavaScript-Entwicklung

Entwickler sind das Lebenselixier des Blockchain-Ökosystems. Damit die Blockchain-Technologie von der breiten Masse angenommen wird, müssen die Einstiegshürden für Entwickler gesenkt werden. So können sie unterhaltsame und ausgefeilte Anwendungen erstellen, an denen sich auch normale Leute erfreuen können. Genau aus diesem Grund sind die Smart Contracts von NEAR in AssemblyScript geschrieben, da es dem JavaScript sehr ähnlich ist.

Wenn Du also gerne auf dem NEAR Protocol entwickeln möchten, kannst die folgenden Tools verwenden:

 	JavaScript SDK. Verbinden, signieren, Transaktionen tätigen und deployen in jedem NEAR-Network aus jedem JS-Kontext
 	Rust Contract SDK. Erstelle sichere Contracts, die hochwertige Assets managen.
 	AssemblyScript Contract SDK. Lernen und Prototyping ohne Schwierigkeiten mit JS-Syntax
 	JSON RPC API. Die gesamte Kommunikation mit der Plattform läuft über diese API, einschließlich des
 	Command Line Interface. Voll funktionsfähiges Kommandozeilen-Toolkit für Entwickler
 	NEAR-Explorer. Ein Blockchain-Suchwerkzeug, mit dem Entwickler Transaktionsdetails, Accounts, Blockdetails und mehr anzeigen können
 	NEAR-Wallet. Erstellen von Accounts, Verwalten von Access Keys und mehr mit unserer benutzerfreundlichen UI und human-readable public keys
 	Nearup. Lokales Management von Deployments und Zugang zu jedem öffentlichen oder privaten Netzwerk
 	Rainbow Bridge. Schnelle, sichere Interoperabilität mit der Ethereum Blockchain
 	EVM. Ethereum-kompatible virtuelle Maschine.

Gut, lasst uns die ersten Schritte unternehmen.
Eine kurze Übersicht
Anwendungen auf NEAR haben zwei unterschiedliche Teile - ein Back-End und ein Front-End.

 	Smart Contract (Back-End): Speichern und Ändern von Daten auf der Blockchain. Contracts müssen Methoden deployen, die es den Clients ermöglichen, den Zustand zu "view" und zu "change" anzupassen.
 	Interaktionen mit Smart Contract (Front-End): Du kannst mit Deinen Contracts oder mit Contracts, die von anderen Personen bereitgestellt wurden, interagieren. Du tust dies, indem Du near-api-js Quickstart und Code Snippets in Deiner Anwendung verwendest.




	

	
	
		
			
				Anwendungen auf NEAR bestehen aus zwei verschiedenen Teilen - einem Backend und einem Frontend. Das Backend ist das.....
			
		

		
					

		
			
			
			
			Mainnet
		
			
			Testnet
		
			
			Smart contracts
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Wie man Smart Contracts erstellt und bezeichnet.

NEAR unterstützt derzeit:

 	Rust - near-sdk-rs: Ein Wrapper, der die Sicherheit der Programmiersprache Rust für hochwertige Contracts verwendet, die nach WASM compiled werden.
 	AssemblyScript near-sdk-as: Eine Sammlung von Hilfsmitteln, die Ihre SmartContracts ähnlich wie TypeScript aussehen lassen, während sie für die Ausführung nach Wasm compiled werden.

HINWEIS: AssemblyScript wird derzeit nicht für produktive Finanzanwendungen empfohlen, da die Sprache und die verfügbaren Compilation Tools noch neu sind.

In Ordnung, legen wir los.
Einrichten des Testnet
Der einfachste Weg, einen Account bei NEAR zu erstellen, ist mit der NEAR Wallet. NEAR hat mehrere Development Networks, die unabhängig voneinander mit eigenen AccountIDs arbeiten. Folge den Schritten, um eine Wallet zu erstellen. Vergewissere Dich, dass Du die erforderlichen Schritte für Dein Sicherheits-Backup befolgt hast.

HINWEIS: Das Erstellen eines Accounts im Mainnet ist fast identisch mit dem Testnet, erfordert jedoch eine anfängliche Finanzierung des Kontos. Hier findest Du eine Anleitung zur Erstellung eines Mainnet-Kontos.

Beim Deployment spielt es keine Rolle, ob die Anwendung in Rust oder AssemblyScript geschrieben ist. Der gesamte Contract-Code wird in WebAssembly compiled und in das Netzwerk deployed, um in einer Wasm-kompatiblen virtuellen Maschine ausgeführt zu werden. Für die meisten Anwendungen wirst Du einen Befehl wie yarn dev verwenden, aber Du kannst eine Anwendung genauso einfach über NEAR CLI mit near dev-deploy für TestNet deployen (oder near deploy, wenn Du bereits einen Account erstellt hast).




	

	
	
		
			
				Der gesamte Contract-Code wird in WebAssembly compiled und im Netz deployed, um in eienr _______ ausgeführt zu werden.
			
		

		
					

		
			
			
			
			Sandbox
		
			
			Wasm-kompatiblen virtuelle Maschine
		
			
			EVM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Mache nun Folgendes, um Dich aufzuwärmen:

 	Schaue Dich  im NEAR Explorer um. Hier kannst du nach allen Transaktionen und Blöcken suchen, die auf NEAR erzeugt wurden. Versuche, nach dem Account zu suchen, den Du gerade erstellt hast, und sieh Dir die Transaktionen an, die Du erstellt hast.
 	Installiere nun near-cli. Dies ist eine Command Line Interface, mit der Du nahtlos mit NEAR interagieren kannst. In den NEAR-Dokumenten findest Du alle near-cli-Befehle mit Beispielen.
 	Versuche Deinen ersten Befehl auszuführen: near login. Dadurch wirst Du zu Deiner NEAR-Wallet weitergeleitet und die Keys Deines Testnet Accounts werden lokal gespeichert.

Nachdem Du das Testnet ausprobiert hast, kannst Du die lokale Node ausführen. Wenn du jedoch vorerst nur mit dem Code herumspielen möchtest ist es empfohlen, im Testnet zu bleiben.
Wie betreibe ich eine eigene Node?
Wie bei jedem Blockchain-basierten Ökosystem läuft das NEAR-Protokoll auf einer Sammlung von öffentlich betriebenen Computern (oder "Nodes").

Du kannst sich aus verschiedenen Gründen dafür entscheiden, eine eigene Node zu betreiben:

 	Um Contracts auf einer mit dem MainNet, TestNet oder BetaNet verbundenen Node zu entwickeln und deployen.
 	Um Contracts auf einer lokalen (unabhängigen und isolierten) Node zu entwickeln und deployen (manchmal "LocalNet" genannt).
 	Um einem Netzwerk als Validierer beizutreten, der eine "Validator Node" betreibt

Da kannst NEAR betanet- und testnet-Nodes starten, indem Du nearup installierst. Befolge dazu die Anweisungen unter https://github.com/near/nearup




	

	
	
		
			
				Wie jedes Blockchain-basierte Ökosystem läuft auch das NEAR-Protokoll auf einer Sammlung von öffentlich gewarteten Computern, die _______ genannt werden.
			
		

		
					

		
			
			
			
			Nodes
		
			
			Blockchain
		
			
			NEAR Protokoll
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Betreiben einer offiziellen Node mit Docker
NEAR verwendet standardmäßig Docker, um den Client auszuführen. Als Erstes musst Du also Docker und Nearup installieren. Führe nun Dein System hiermit aus:
nearup betanet
(Wenn Du TestNet verwenden möchten, ersetze im obigen Befehl "betanet" durch "testnet")

Du wirst dann zur Eingabe einer Account-ID aufgefordert. Du kannst diese leer lassen, wenn Du nur eine Node ausführen möchtest. Validatoren sollten die Account-ID des Accounts verwenden, mit dem sie staken wollen. Anschließend musst Du diesen Code eingeben:

Gib Deine Ihre Account-ID ein (leer lassen, wenn Du kein Validator sein willst)

Nun wird Deine Node im Hintergrund mit Docker gestartet. Um die Protokolle innerhalb von Docker zu überprüfen, führe "docker logs -follow nearcore" aus.
Einen einfachen Code auf NEAR erstellen
NEAR hat eine Liste von hilfreichen Programmen oder Beispielcodes, die Du einfach abrufen kannst. Der Code, den wir uns ansehen werden, ist das Guest Book. Mit diesem Programm kannst Du Dich bei NEAR anmelden und eine Nachricht in das Guest Book eintragen! Es handelt sich hierbei um eine Starter-App, die mit einem AssemblyScript-Backend und einem React-Frontend entwickelt wurde. 

Einblick in den Guest Book Code
Um dieses Projekt lokal auszuführen, musst Du Folgendes sicherstellen.

 	Stelle sicher, dass Du Node.js ≥ 12 installiert hast (https://nodejs.org), dann installiere damit yarn: npm install -global yarn (oder einfach npm i -g yarn)
 	Installiere Dependencies: yarn install (oder einfach nur yarn)
 	Starte nun den Lokalen Development Server: yarn dev (siehe package.json für eine vollständige Liste der Skripte, die Du mit yarn ausführen kannst)

Jetzt hast Du eine lokale Entwicklungsumgebung, die durch das NEAR TestNet unterstützt wird! Wenn Du yarn dev ausführst, wird Dir die URL mitgeteilt, die Du in Deinem Browser aufrufen kannst, um die Anwendung zu sehen.

Oh, und stelle sicher, dass Du die GitHub-Seite geöffnet hast. 

Vielleicht findest Du auch dieses Video nützlich.

https://youtu.be/B6Gc_OQjX9E

Den Code erforschen
Wie Du siehst, gibt es zwei Seiten des Codes - Backend und Frontend:

 	Der Backend-Code befindet sich im /assembly folder. Dieser Code wird auf der NEAR-Blockchain deployed, wenn Du yarn deploy:contract ausführst. Dies ist ein Smart Contract von NEAR.
 	Der Frontend-Code befindet sich im /src folder. /src/index.html ist ein guter Ort, um mit der Entdeckung zu beginnen. Beachte, dass der Code in /src/index.js geladen wird, wo Du lernen kannst, wie das Frontend mit der NEAR-Blockchain verbunden ist.

Der Backend Code
#1 Contract Data Model :  assembly/model.ts

[code lang="js"]import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");[/code]

Analysis

@nearBindgen markiert die Klasse als serialisierbar. "Serializable" ist ein Marker Interface, das verwendet wird, um Klassen zu "markieren", so dass die Objekte dieser Klassen eine bestimmte Capability erhalten können.

Die Klasse "PostedMessage" hat drei Eigenschaften -

 	Premium zur Kennzeichnung von Nachrichten mit angehängten NEAR-Tokens
 	Sender, um den Signer der Guest Book Message zu ermitteln
 	Text, um die Guest Book Message zu speichern

Schließlich ist "messages" eine Sammlung von Guest Book Messages, die als ein PersistentVector von PostedMessage-Objekten gespeichert wird
#2 Contract Behavior :  assembly/main.ts

[code lang="js"]import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}[/code]

Analysis

MESSAGE_LIMIT wird verwendet, um unbegrenzte (d.h. potenziell teure) Aufrufe zum Abrufen von Guest Book Messages aus dem Storage zu vermeiden.

Wir verwenden in diesem Contract auch zwei verschiedene öffentliche Funktionen - addMessage() und getMessages()
Der Frontend Code
#1 Network Connection :  src/config.js

[code lang="js"]const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;[/code]

Analysis

Der obige Code definiert die Daten und Endpunkte, die für die Verbindung mit dem NEAR-Netzwerk erforderlich sind. Die hier definierten Verbindungsinformationen sind sowohl für MainNet, TestNet und BetaNet als auch für die Standardkonfiguration LocalNet enthalten
#2 Configuration :  src/index.js

[code lang="js"]import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });[/code]

Analysis

Dies ist das Kernstück des Frontend-Abschnitts bei der Konfigurierung der Verbindung zum NEAR-Netzwerk. Du kannst das Contract Interface konfigurieren, indem Du eine Wallet-Verbindung einrichtest und beide Contract-Methoden miteinander verbindest.
Deployen eines Smart Contracts
Jeder Smart Contract in NEAR hat sein eigenen, zugehörigen Account. Wenn Du yarn dev ausführst, werden Deine Smart Contracts mit einem temporären Account im NEAR TestNet deployed. Wenn Du diesen Account nun dauerhaft einrichten möchtest, musst Du Folgendes tun.
Schritt 0: near-cli installieren
So installierst Du near-cli global
npm install --global near-cli
Dadurch erhältst Du das Near-CLI-Tool. Stelle sicher, dass es mit installiert ist:
near --version
Schritt 1: Erstelle einen Account für den Contract
Besuche die NEAR Wallet und erstelle einen neuen Account. Du wirst diese Smart Contracts für diesen neuen Account deployen.

Autorisiere nun NEAR CLI für diesen neuen Account und folge den Anweisungen, die es Dir gibt:
near login
Schritt 2: Festlegen des Contract-Namens im Code
Ändere die Zeile in src/config.js, die den Account Namen des Contracts festlegt. Setze ihn auf die Account-ID, die Du oben verwendet hast.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Schritt 3: Ändere die Remote-URL, wenn Du dieses Repository geklont hast.
Wenn Du das Repository forkst, musst Du die Remote-URL in ein Repository ändern, auf das Du "commit"-Zugriff hast. Dies ermöglicht das automatische Deployment auf Github Pages über die Command Line.

Gehe zu GitHub und erstelle ein neues Repository für dieses Projekt.

Öffne Dein Terminal und gib im Root des Projekts Folgendes ein:
$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`
Schritt 4: Deploy!
Du brauchst nur den folgenden Befehl, um Deinen Smart Contract zu deployen:
yarn deploy
Dieser Befehl führt zwei Dinge aus:

 	Er erstellt Smart Contracts und deployed sie im NEAR TestNet.
 	Er erstellt und deployed den Code des Contract-Frontends auf GitHub mit gh-pages. Dies funktioniert nur, wenn für das Projekt bereits ein Repository auf GitHub eingerichtet wurde. Es steht Dir frei, das Deployment-Skript in package.json zu ändern, um es anderswo zu deployen.




	

	
	
		
			
				Jeder Smart Contract in NEAR hat seinen eigenen, zugehörigen ____
			
		

		
					

		
			
			
			
			Token
		
			
			Wallet
		
			
			Account
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Wie geht es weiter?
Nun, da Du weißt, wie man einen grundlegenden Code ausführt, möchtest Du vielleicht tiefer in NEAR einsteigen. Sieh Dir dazu die NEAR-Developer Docs an.

### NEAR PROTOCOL DAN POLYGON

Polygon berhasil meraih kesuksesan dan mengalami lonjakan pengguna dalam beberapa waktu terakhir. Dengan masalah skalabilitas yang menjadi isu utama di dalam komunitas Ethereum, menjadi masuk akal apabila solusi Layer-2 yang ditawarkan oleh Polygon sukses menjaring sejumlah pengguna. Namun, NEAR Protocol tidak hanya menawarkan sebuah platform yang hanya memberi solusi mengenai skalabilitas, namun juga sanggup menyediakan solusi Layer-2 yang kompatibel dengan Ethereum Virtual Machine (EVM). Artikel berikut menampilkan perbandingan antara NEAR Protocol dan Polygon Network.
APA ITU POLYGON?
Untuk mengerti Polygon, sebelumnya kita mengenal terlebih dahulu apa yang dimaksud dengan Layer-2. Di dalam Ethereum, pada dasarnya jaringan Ethereum adalah sebagai jaringan fondasi, yang biasa kita sebut sebagai “Layer-1”. Jaringan  Terdesentralisasi (Decentralized Network) memprioritaskan tingkat keamanan dan keberlangsungan jaringan tersebut, dengan mengorbankan kecepatan. Solusi yang ditawarkan disini adalah membangun sebuah jaringan tambahan di atas jaringan fondasi tersebut, jaringan tambahan ini biasa disebut dengan Layer-2, dimana hal tersebut secara akan meningkatkan throughput (jumlah keberhasilan transaksi yang diukur pada rentang waktu tertentu) secara drastis. Polygon adalah contoh dari solusi Layer-2.

Native token dari ekosistem Polygon dinamakan MATIC. Utilitas dari MATIC adalah :

 	Pembayaran dan sebagai penggunaan untuk setiap transaksi antara participant
 	Staking dan Governance. Semakin banyak MATIC yang dimiliki, maka kekuatan kita untuk pengambilan keputusan mengenai nasib jaringan MATIC akan semakin besar.


 	Membayar gas fee dalam network Polygon.
 	Imbalan untuk pengguna (Validator) yang menyediakan sumber daya komputasi untuk keberlangsungan jaringan 

MATIC mempunyai jumlah token maksimal sebesar 10 Milyar MATIC.
Mekanisme Polygon
Polygon mempunyai multi level ekosistem yang memanfaatkan beberapa sidechain yang kompatibel dengan Ethereum Virtual Machine (EVM). Fungsi dari sidechain ini adalah untuk menghindari kemacetan data di main chain Polygon itu sendiri. Sidechain adalah jaringan blockchain sampingan yang terhubung kepada jaringan utama melalui sebuah saluran 2 arah. Sebuah sidechain dapat mempunyai aturan sendiri dan ekosistem sendiri. Dalam jangka waktu tertentu, setiap sidechain wajib melaporkan data-data transaksi ke dalam jaringan utama untuk memastikan kelancaran keseluruhan ekosistem. 

Developer dapat menciptakan sidechain, untuk memastikan dapp (Decentralized Application) yang mereka kembangkan tidak mengalami masalah skalabilitas, dengan menggunakan Polygon SDK stack. Polygon mendapatkan popularitas dikarenakan biaya yang dikenakan jauh lebih murah dari sisi pengguna dan developer dan juga jauh lebih cepat.

Polygon menggunakan mekanisme PoS (Proof of Stake) dan setiap orang dapat menjadi  Validator dengan melakukan staking (pengumpulan) token MATIC. Validator mempunyai peran di dalam ekosistem sebagai berikut :

 	Memvalidasi transaksi dengan menyetujui dan mengkonfirmasi pertukaran data pada sidechain
 	Network Validator dapat berperan serta melakukan pengambilan keputusan (Governance) perihal berbagai peningkatan pada jaringan Polygon keseluruhan.
 	Bertanggungjawab dalam memilih block producer pada setiap checkpoint (selanjutnya akan dibahas)

Sidechain pada Polygon adalah sebuah bagian dalam ekosistem Ethereum, dimana pengguna dapat mengeksekusi project mereka tanpa harus mencemaskan gas fee dan throughput pada Ethereum.

Bagaimana Polygon Memastikan Kecepatan dan Desentralisasi

Proof-of-Stake (PoS) pada Polygon mayoritas digunakan untuk “checkpointing”. Ini artinya dari setiap tim penghasil block (block producer) ditunjuk untuk mengawasi setiap checkpoint, dan para tim penghasil inilah yang bertanggungjawab memelihara dan memastikan konsensus dari seluruh jaringan. Dengan tim penghasil block yang terbatas, memastikan Polygon menghasilkan block berisi data transaksi lebih cepat dibanding Ethereum (1 block dalam 1 detik dihasilkan melawan 1 block dalam 20 detik).

Selain itu, Polygon memastikan desentralisasi jaringannya dengan mendelegasikan PoS checkpoint secara berkala ke jaringan utama Ethereum. Untuk setiap block yang dihasilkan oleh para tim penghasil block harus divalidasi melalui semacam proof-of-block yang ditulis di atas jaringan Ethereum

Bagaimana Berinteraksi dengan Polygon?

Begini caranya berinteraksi dengan sebuah proyek yang berbasis di atas sidechain Polygon :

 	Kenali kontrak smart contractnya di dalam jaringan Ethereum dan tulis berapa jumlah token yang hendak dikirimkan menuju sidechain Polygon.
 	Sebuah smart contract khusus “RootChainManager” akan mengaktifkan sebuah kontrak lain yaitu “ChildChainManager”. Kedua contract ini bekerja berdampingan untuk memastikan berapa jumlah token yang akan kamu kirim ke jaringan Polygon.
 	Kemudian pengguna dapat menuju jaringan Polygon dan menerima token tersebut.

Bagaimana dengan sebaliknya? Apabila pengguna hendak meninggalkan Polygon dan kembali ke Polygon? Langkah ini yang harus pengguna ikuti 

 	Kita harus melakukan burn token yang kita miliki di Polygon
 	Bukti dari burn tersebut akan dikirimkan ke jaringan Ethereum
 	Setelah verifikasi, pengguna akan menerima kembali di dalam wallet jaringan Ethereum.

APA ITU NEAR PROTOCOL?
Pada musim panas tahun 208, Illia Polosukhin dan Alexander Skidanov menciptakan sebuah protokol bernama NEAR Protocol sebagai platform ideal bagi para developer untuk membangun decentralized applications (dApps). Platform lainnya saat itu mengalami masalah kecepatan, finalisasi hasil transaksi dan kompabilitas yang buruk dengan jaringan lain.

NEAR Protocol dibangun dari awal dan mempunyai fitur-fitur sebagai berikut untuk memastikan skalabilitas dan keamanan :

 	NEAR menggunakan mekanisme penghasil block yang diberi nama “Doomslug”. Doomslug memastikan keberhasilan penulisan sebuah block dalam hitungan detik.
 	NEAR adalah jaringan yang terpecah (sharding network) dan hal tersebut mengizinkan skalabilitas tak terbatas. Dengan keunikan tersebut, jaringan NEAR mampu mencapai skala jutaan transaksi dengan tetap mempertahankan desentralisasi dibanding memastikan proses yang sentralisasi di jaringan lain.

Apa itu Sharding?

Melanjutkan hal di atas, mari kita bersama-sama memahami maksud dari “sharding”tersebut. Sharding adalah sebuah teknik tertentu pada database dalam menangani jumlah data yang banyak atau besar.  Sharding membagi seluruh database jaringan ke dalam beberapa bagian, dan bagian-bagian dari database tersebut dinamakan “shards”. Shards ini dapat diproses secara paralel untuk mencapai kecepatan tinggi dalam mengolah data. 

Apa yang terjadi pada sebuah jaringan blockchain dengan teknologi sharding? Mari kita bahas :

 	Seluruh jaringan blockchain dibagi menjadi shard yang lebih kecil
 	Setiap 1 akun hanya berlaku di dalam 1 shard, dan mereka hanya bisa berinteraksi hanya dengan akun pada jaringan shard yang sama.

Permasalahan yang muncul pada normal sharding adalah ini membutuhkan node yang harus dijalankan pada sebuah hardware yang kompleks. Namun sebaliknya sharding pada NEAR dipastikan bisa dijalankan oleh para penyedia node dengan hanya menggunakan hardware simple berbasis cloud.

Apa itu Aurora?

Aurora menyediakan sebuah jaringan layer-2 yang kompatibel dengan Ethereum di atas jaringan NEAR dan berisi Aurora Bridge dan Aurora Engine. Para developer dari Ethereum dapat menjalankan dapps buatan mereka di atas Aurora lengkap dengan fitur utama NEAR seperti gas fee dan sharding. Ini adalah sebagian kelebihan dari Aurora :

 	dApps dapat melakukan jutaan proses ribuan transaksi per detik. Ini adalah pengembangan luar biasa daripada Ethereum.
 	Aurora menghasilkan finalisasi block dalam waktu 2 detik, dibandingkan Ethereum yang membutuhkan waktu 15 detik.
 	Sharding pada NEAR memungkinan sebuah ekosistem tumbuh secara horizontal.
 	Fee pada Aurora 1000x lebih murah dibandingkan Ethereum.
 	Mempunyai kompatibilitas penuh terhadap Ethereum di atas jaringan NEAR Protocol.

DeFi Pada NEAR dan Polygon
Polygon DeFi
Polygon memungkinkan pengguna menggunakan beberapa dApps DeFi yang populer di atas Ethereum seperti Curve Finance, 1inch dan Beefy Finance. Menurut DappRadar, ini adalah 5 dapp populer dalam waktu 24 jam :



SushiSwap adalah dApp yang paling populer.=

Ekosistem DeFi dalam Polygon berkembang pesat. Gambar dibawah berikut adalah Jumlah Nilai Terkunci (TVL / Total Value Locked) di dalam Polygon. Sekitar 5,19 Milyar USD ($5.19 Billions)



Puncak TVL terjadi pada tanggal 15 Juni 2021, dengan nilai sebesar 10,54 Milyar USD. Dan Aave mendominasi sebesar 40% dari nilai total TVL.
NEAR DeFi
Dibandingkan dengan Polygon, tentunya ekosistem DeFi pada NEAR masih amat sangat muda, namun mengalami pertumbuhan yang pasti saat artikel ini ditulis TVL dalam NEAR hanya sebesar 141 Juta USD.



dApp DeFi paling dominan adalah Ref Finance dengan menguasai sebanyak 80% dari TVL. Ref Finance memiliki kemiripan dengan Uniswap v2, di samping itu juga mendukung lebih banyak tipe pool, fee yang bisa dikonfigurasi, dan sepenuhnya milik publik / komunitas. Ref Finance juga adalah platform DeFi pertama pada NEAR. Tujuan utama dari Ref adalah sebagai Decentralized Exchange (DEX) , lending protocol, synthetic asset issuer dan lainnya dalam satu wadah.

NEAR saat ini mengucurkan dana bantuan sebesar 800 juta USD yang spesifik ditujukan untuk menciptakan ekosistem DeFi yang lebih besar dan lebih sehat. Dana ini termasuk di dalamnya dibagi menjadi :

- 100 jt USD untuk startup

- 100 jt USD untuk dana regional

- 250 jt USD untuk bantuan kepada dApps di dalam ekosistem yang dibagikan berkala selama 4 tahun.
NFT pada NEAR dan Polygon
Polygon adalah salah satu dari 3 jaringan blockchain yang beroperasi di dApp Opensea (bursa NFT terbesar di dunia) bersama dengan Ethereum dan Klaytn. Dari peringkat website, berikut adalah Top 5 NFT di Polygon



ZED RUN adalah pemimpin dalam sektor NFT pada Polygon.

Apakah itu ZED RUN? Ini adalah semacam permainan balap kuda digital yang dibuat di atas jaringan blockchain. Idenya adalah pengguna mengoleksi sebanyak mungkin kuda balap untuk menciptakan istal kuda yang berkualitas dan kompetitif.


NEAR NFT
Untuk saat ini ada beberapa platform NFT pada NEAR seperti Mintbase. Mintbase didirikan tahun 2018 oleh Nate Geier dan Caroline Wend dan berhasil mendapatkan pendanaan sebesar 1 juta USD dari seed round pada tahun 2020. Platform ini memungkinkan pengguna untuk menciptakan dan menjual aset NFT, dari artwork hingga tiket konser.



Fakta menarik, Mintbase awalnya berasal dari Ethereum. Namun dikarenakan tingginya gas fee dan membludaknya traffic jaringan Ethereum, membuat Mintbase melirik NEAR sebagai wadah yang jauh lebih baik dibandingkan Ethereum, ditambah dengan fitur gas fee yang jauh lebih rendah dikarenakan model eksekusi kontrak yang lebih efisien.
KESIMPULAN
Polygon sukses meningkatkan pengguna pada jaringannya dalam beberapa tahun ke belakang, dengan fitur layer-2 yang lebih memungkinkan daripada sebelumnya. Ditambah lagi karena hubungan dekatnya dengan komunitas Ethereum, membuat jaringan mereka mengalami pertumbuhan yang cepat.

Di sisi lain, NEAR menunjukkan janjinya dalam mengatasi masalah skalabilitas dengan teknologi sharding yang dimilikinya. Ditambah dengan dana 800 jt USD yang siap dikucurkan bagi para developer yang hendak membuat dApp di atas NEAR. Kedua protokol ini - Polygon dan NEAR - menyediakan sebuah wadah bagi para developer yang hendak bersama-sama membangun ekonomi terdesentralisasi dengan skalabilitas tinggi dan efisien.

### NEAR 🤝 Ethereum 

Heute ist Ethereum die Nummer eins unter den Smart-Contract-Plattformen im Krypto Bereich. Die meisten Smart Contracts und dezentralen Anwendungen (dApps) basieren auf dessen Blockchain. Wie Ethereum gibt es auch mehrere andere Smart-Contract-Plattformen auf dem Markt. 

Doch nur weil Ethereum die Nummer eins ist, wenn es um Smart Contracts und DeFi geht, heißt das nicht, dass es keine Probleme gibt. Ethereum hat ein eklatantes Problem, und zwar erhebliche Skalierungsprobleme. Es schafft es einfach nicht, sein Netzwerk zu skalieren. 

An dieser Stelle kommt das NEAR-Protokoll ins Spiel. Das Alleinstellungsmerkmal von NEAR ist, dass es einen Proof-of-Stake-Konsens Mechanismus verwendet, der Sharding einsetzt. Bevor wir tiefer eintauchen, sollten wir sowohl Ethereum als auch NEAR besser kennenlernen. 
Was ist Ethereum?
Wenn Sie sich die Definition von Ethereum auf der Website des Unternehmens ansehen, lautet sie wie folgt:

"Ethereum ist eine Technologie, welche die Grundlage für digitales Geld, globale Zahlungen und Anwendungen bildet. Die Gemeinschaft hat eine boomende digitale Wirtschaft aufgebaut, kühne neue Wege für Schöpfer, um online zu verdienen, und so viel mehr ins Leben gerufen. Sie steht jedem offen, egal wo auf der Welt man sich befindet."

Ethereum wurde 2015 von Vitalik Buterin gegründet und hat sich nach der Marktkapitalisierung als zweitgrößte Kryptowährung nach Bitcoin etabliert. Ethereum baut auf der Blockchain von Bitcoin auf und ist damit mehr als nur eine weitere Kryptowährung, die es den Nutzern ermöglicht, ohne Eingreifen Dritter Werte zu senden oder zu empfangen. 

Ethereum gewährleistet die Dezentralisierung, indem es zentrale Server durch Tausende von Knotenpunkten ersetzt, die sicherstellen, dass die Plattform immer online und frei von jeglichem Einfluss Dritter ist. Da die Plattform sowohl dezentralisierte Anwendungen als auch intelligente Verträge unterstützt, ist sie für Entwickler und Nutzer gleichermaßen äußerst attraktiv. 

Ethereum wird nun auf Ethereum 2.0 oder Serenity umgestellt. Das Upgrade wird die Skalierbarkeit, Effizienz und Geschwindigkeit der Ethereum-Blockchain erheblich verbessern. Darüber hinaus ermöglicht das Upgrade Ethereum die Gaskosten zu senken und mehr Transaktionen zu verarbeiten, was die Skalierbarkeit der Blockchain verbessert, ohne die Sicherheit zu beeinträchtigen. 

Mit dem Upgrade wird Ethereum auch zu einem Proof-of-Stake-Konsens Mechanismus wechseln. Bei PoS sorgen algorithmisch ausgewählte Validatoren für Sicherheit auf der Plattform. Die Validatoren sichern die Plattform, indem sie ihre ETH sperren. Jeder Validator, der gegen die Interessen der Plattform handelt, verliert seinen Einsatz, um die Sicherheit der Plattform zu gewährleisten. 
Was ist das NEAR-Protokoll?
Das NEAR-Protokoll wurde im Sommer 2018 ins Leben gerufen. Als dezentrale Entwicklungsplattform wurde das Protokoll entwickelt, um die perfekte Umgebung für dezentrale Anwendungen zu schaffen und sich auf die Mängel anderer Plattformen im Smart Contract- und dApp-Bereich zu konzentrieren. Diese Unzulänglichkeiten sind hauptsächlich Probleme mit niedrigen Geschwindigkeiten, geringem Durchsatz und schlechter Kompatibilität mit anderen Blockchains. 

NEAR basiert auf dem NEAR-Protokoll, einer Proof-of-Stake (PoS)-Blockchain, die mehrere Funktionen und Innovationen enthält, um die Kosten zu senken und die Skalierbarkeit sowohl für Nutzer als auch für Entwickler zu verbessern. Darüber hinaus verfolgt NEAR einen einzigartigen Ansatz zum "Sharding".

Außerdem wird ein Mechanismus zum Generieren von neuen Blöcken namens "Doomslug" eingeführt, der 2019 vorgeschlagen wurde. Doomslug ermöglicht eine praktische oder "Doomslug"-Finalität, die sicherstellt, dass die Blöcke innerhalb von Sekunden ihre Finalität erhalten.

Das Protokoll basiert auf der gleichen Technologie wie Bitcoin und kombiniert sie mit Funktionen wie Datenbank-Sharding. Das NEAR-Protokoll wurde von Grund auf neu entwickelt und ist das am besten zugängliche Netzwerk für Endnutzer und Entwickler, das gleichzeitig Skalierbarkeit und Sicherheit gewährleistet. 

Die meisten skalierbaren Blockchains zentralisieren die Verarbeitung und beschränken sie auf High-End-Hardware, was ihren Durchsatz vorübergehend erhöht. NEAR ermöglicht der Plattform eine lineare Skalierung bis zu Milliarden von Transaktionen auf völlig dezentralisierte Weise. 

NEAR wird vom NEAR-Kollektiv entwickelt, einer Gemeinschaft von Entwicklern und Forschern, die am Aufbau des Projekts mitarbeiten. Einige wichtige Merkmale von NEAR sind 

 	NEAR ist ein Sharded-System, was eine unendliche Skalierbarkeit ermöglicht. 
 	NEAR ist ein benutzerfreundliches Protokoll, mit dem Entwickler einfach und schnell Anwendungen erstellen können. 
 	NEAR ist keine Sidechain, sondern ein Layer-1-Protokoll. 
 	Mit NEAR erstellte dApps laufen auf der zugrunde liegenden NEAR-Schicht, also dem Layer 1.

Was ist das NEAR-Kollektiv?
Das NEAR-Kollektiv umfasst einzelne Organisationen und andere Mitwirkende, die kontinuierlich an der Verbesserung des NEAR-Protokolls arbeiten. Das Kollektiv arbeitet an Projekten wie dem Schreiben des ursprünglichen Codes und der Implementierung für das NEAR-Netzwerk. NEAR ist vollständig dezentralisiert, arbeitet unabhängig und kann nicht abgeschaltet oder manipuliert werden, auch nicht von denen, die es aufgebaut haben.

Das NEAR-Kollektiv hat Mitglieder wie die NEAR Foundation. Die NEAR Foundation ist eine gemeinnützige Organisation, die sich auf die Schaffung eines lebendigen Ökosystems rund um die NEAR-Blockchain konzentriert. Sie hilft bei der Koordination von Governance-Aktivitäten und der Entwicklung. Das NEAR Collective hat mehrere Projekte, wobei die NEAR-Blockchain nur eines von mehreren Projekten ist, die unter der Ägide des Kollektivs stehen. 
Warum sind Blockchains wie NEAR notwendig?
Um dies zu verstehen, müssen wir zunächst die Entwicklung der Blockchain-Technologie verstehen. Blockchain lässt sich in drei Stufen oder Generationen unterteilen. Blockchains der ersten Generation waren als einfacher Zahlungsmechanismus konzipiert. Bitcoin ist ein Beispiel für eine Blockchain der ersten Generation, die sich im Kryptobereich als Plattform Nummer eins etabliert hat. Allerdings haben Blockchains der ersten Generation ihre Grenzen, wenn es um komplexe Transaktionen geht. 

Blockchain-Plattformen der zweiten Generation traten mit Ethereum und dem Konzept der Smart Contracts in den Vordergrund und ermöglichen es Entwicklern, diese zu nutzen, anspruchsvollere Transaktionen zu programmieren und dApps zu erstellen. Blockchains der zweiten Generation leiden jedoch unter erheblichen Skalierungsproblemen. So kann Ethereum beispielsweise nur etwa 25 Transaktionen pro Sekunde verarbeiten. Vergleicht man diese Zahl mit Mainstream-Plattformen wie Visa oder PayPal, wird deutlich, wie weit Ethereum hinterherhinkt. 

Ethereum hat versucht, seine Skalierbarkeitsprobleme zu beheben, indem es Layer-2-Lösungen wie das Plasmaprotokoll implementiert hat, das eine zusätzliche Schicht schafft, die parallel zur Hauptkette läuft. Allerdings haben sich Layer-2-Lösungen noch nicht ausreichend durchgesetzt. 

Dies bringt uns zu NEAR, einer Blockchain der dritten Generation. NEAR verwirft die Idee, dass jeder Knoten im Netzwerk den gesamten Code ausführen muss, da das Team glaubt, dass dies nur zu Engpässen führt. Stattdessen behebt die Blockchain Skalierbarkeitsprobleme, indem sie eine Sharding-Technik einsetzt, die es der Blockchain ermöglicht, die Kapazität des Netzwerks zu erweitern. Und im Gegensatz zu Blockchains der zweiten Generation, die eine Layer-2-Lösung verwenden, ist Sharding eine Layer-1-Lösung. 
Was ist Sharding?
Bevor wir fortfahren, sollten wir Sharding verstehen. Manchmal müssen Systeme mit einer großen Datenmenge umgehen. Dies wirkt sich auf die Leistung des Systems aus, verringert den Durchsatz und beeinträchtigt die Leistung des Systems. Sharding überwindet dieses Problem, indem es die Daten horizontal partitioniert, so dass sie kleiner, handhabbar und vor allem schneller zu verarbeiten sind. 

NEAR und Ethereum: Wie funktionieren NEAR und Ethereum?
Ethereum
Ethereum fungiert nicht nur als Finanzplattform zur Durchführung von Transaktionen, sondern unterstützt auch dezentrale Anwendungen und intelligente Verträge. Ethereum basiert auf der Blockchain-Technologie und verwendet ein öffentliches Hauptbuch, in dem alle verifizierten Transaktionen gespeichert werden. Die Transaktionen sind für jeden zugänglich, der sie einsehen möchte, wodurch vollständige Transparenz gewährleistet ist und gleichzeitig sichergestellt wird, dass die in der Blockchain gespeicherten Daten nicht verändert oder manipuliert werden können. 

Die Ethereum-Blockchain ähnelt der Bitcoin-Blockchain und fungiert als öffentliches Hauptbuch, in dem alle Transaktionen und die Geschichte der Smart Contracts gespeichert sind. Freiwillige auf der ganzen Welt speichern eine Kopie der gesamten Ethereum-Blockchain, wodurch die Blockchain vollständig dezentralisiert ist. Jedes Mal, wenn eine Aktion wie eine Transaktion oder ein intelligenter Vertrag auf der Blockchain stattfindet, wird sie von allen Knoten weltweit verarbeitet, um sicherzustellen, dass die Regeln der Blockchain eingehalten werden. 

Alle Knotenpunkte sind miteinander verbunden und befolgen dieselben Regeln für intelligente Verträge und Transaktionen. Die Ethereum-Knoten verfolgen auch den Status aller Anwendungen, der Benutzer Guthaben und des Smart-Contract-Codes und stellen so sicher, dass alle Informationen immer aktuell sind.

Dank Solidity können Entwickler intelligente Verträge schreiben, die Transaktionen auf der Blockchain und deren Ergebnisse verwalten können. Smart Contracts unterscheiden sich von herkömmlichen Verträgen, da sie sicherstellen, dass die Vertragsbedingungen erfüllt werden. Darüber hinaus führen sie automatisch Transaktionen aus, wenn eine Reihe vorher festgelegter Bedingungen erfüllt sind, wodurch alle an einer Transaktion beteiligten Dritten ausgeschaltet werden. 
NEAR
NEAR nutzt die Blockchain-Technologie, genau wie andere Blockchains wie Ethereum und Cardano. NEAR dient als Basis-Blockchain, auf der Anwendungen erstellt und bereitgestellt werden können. Sie verwendet einen Konsensmechanismus namens Nightshade, der ihr zu ihrem hohen Durchsatz verhilft. Der Konsensmechanismus von NEAR geht davon aus, dass die Transaktionen aller Shards zusammen einen Block bilden, weshalb jeder Shard ein Segment eines jeden Blocks einreicht. Dieses Segment wird als "Chunk" bezeichnet. 

Die Validatoren werden nach dem Zufallsprinzip ausgewählt und verarbeiten dann Transaktionen über mehrere Shard-Blockchains hinweg, wodurch die Transaktionskapazität des NEAR-Protokolls verbessert wird. Die Chunks werden verarbeitet und dann in der Blockchain gespeichert, wodurch die Transaktionen abgeschlossen werden. 

NEAR basiert nicht auf der Idee, dass jeder Knoten den gesamten Code verarbeiten muss. Stattdessen werden Skalierbarkeitsprobleme mit Hilfe von Sharding gelöst. Durch Sharding werden die Daten horizontal aufgeteilt, wodurch sie einfacher zu verwalten und schneller zu verarbeiten sind. 
NEAR und Ethereum: Der Konsens-Mechanismus
Ethereum
Derzeit verwendet Ethereum einen Proof-of-Work-Konsensmechanismus, aber mit Ethereum 2.0 am Horizont wird die Plattform zu einem Proof-of-Stake-Konsensmechanismus übergehen. Proof-of-Stake wird mit dem Casper-Protokoll implementiert und schafft ein vertrauensloses Ökosystem. Vor der vollständigen Umstellung auf einen Proof-of-Stake-Mechanismus wird Ethereum einen hybriden PoW-PoS-Konsensmechanismus implementieren. 

Lassen Sie uns verstehen, wie sowohl Proof-of-Work als auch Proof-of-Stake funktionieren. Proof-of-Work erfordert, dass Miner miteinander konkurrieren und große Mengen an Rechenleistung einsetzen, um komplexe mathematische Probleme zu lösen und Transaktionen zu validieren. Sobald eine Transaktion validiert ist, wird der Miner belohnt. Ethereum wechselt zu einem Proof-of-Stake-Mechanismus, da Proof-of-Work mehrere Probleme hat, wie z. B. einen hohen Energieverbrauch. Die Umstellung erfolgt auch, um die Skalierbarkeit von Ethereum zu verbessern. 

Bei einem Proof-of-Stake-Konsensverfahren setzen die Validierer ihre ETH ein, woraufhin sie zufällig ausgewählt werden, um einen Block zu bestätigen. Der ausgewählte Validierer schlägt einen Block vor, während die anderen Validierer bestätigen müssen, dass sie den Block gesehen haben. Sobald sie den Block validiert haben, wird er der Blockchain hinzugefügt, und die Validierer werden belohnt. Die Validierer werden also sowohl für das Vorschlagen als auch für das Bestätigen des Blocks belohnt. 
NEAR
Das NEAR-Protokoll hat Nightshade Sharding als Proof-of-Stake-Konsensmechanismus implementiert. Wir haben bereits besprochen, was Sharding ist, also können wir das überspringen. Die heute verwendete Sharding-Methode hat jedoch ihre Tücken, da die Fork-Choice-Regel sowohl in der Shard- als auch in der Beacon-Kette anders aufgebaut und getestet werden muss. 

Bei Nightshade wird das System jedoch als eine einzige Blockchain behandelt, und jeder Block enthält Transaktionen für alle Shards. Die Teilnehmer müssen jedoch nicht den gesamten Status herunterladen, sondern nur den Status, der zu dem Shard gehört, für den sie Transaktionen validieren. Es wird eine Liste aller Transaktionen in jedem Block erstellt, die dann in Chunks aufgeteilt wird, wobei jedem Chunk ein Shard zugewiesen wird. 

Die Validierer sind ein wichtiger Bestandteil des NEAR-Protokolls, da sie den Konsens über das Protokoll aufrechterhalten. Daher müssen sie ihre Systeme stets auf dem neuesten Stand halten und auch ihre Server online halten. 

 	Die Validatoren werden mit jeder Epoche auf der Grundlage ihres Einsatzes ausgewählt. 
 	Validatoren können erneut registriert werden, indem sie ihre Token und Belohnungen erneut einsetzen. 
 	Validatoren können ihren Einsatz auf zwei Arten verstärken: Sie können Token kaufen oder sie über eine Einsatz Delegation ausleihen. 

NEAR und Ethereum: Die Token
Der Ethereum-eigene Token, Ether, bietet Programmierern einen Anreiz, das Blockchain-Protokoll weiterzuführen, da die Hardware, die Ethereum antreibt, teuer ist und eine beträchtliche Menge an Energie verbraucht. Daher werden sowohl Miner als auch Programmierer in Ether dafür belohnt, dass sie ihre Ressourcen nutzen und das Ethereum-Ökosystem sicher und funktionsfähig halten. 

Entwickler zahlen auch mit Ether, damit sie Smart Contracts oder dezentrale Anwendungen auf der Ethereum-Blockchain starten können. Er wird auch für den Zugang zu intelligenten Verträgen verwendet. 

Der NEAR-Token wird verwendet, um Anreize für Validierer im Netzwerk zu schaffen. Der Token steuert auch Transaktionen und Smart Contracts auf der Blockchain. Da es sich bei NEAR um eine gemeinschaftlich verwaltete Plattform handelt, spielen die Token-Inhaber eine wichtige Rolle bei der Verwaltung der NEAR-Plattform und stimmen über mögliche Änderungen auf der NEAR-Plattform ab. 
Projekte auf Ethereum und dem NEAR-Protokoll
Ethereum ist führend, wenn es um dezentrale Anwendungen und dezentrales Finanzwesen geht, mit über 3000 dApps, die auf seiner Blockchain laufen. Die meisten Ethereum-Projekte konzentrieren sich auf DeFi und erweitern die Einsatzmöglichkeiten von Kryptowährungen, um komplexere finanzielle Zwecke zu erfüllen. 

Einige der Top-Projekte auf der Ethereum-Blockchain sind 

 	Uniswap
 	MakerDAO 
 	Chainlink 
 	Aave

Obwohl das Mainnet von NEAR erst vor etwas mehr als einem Jahr gestartet wurde, bauen bereits mehrere Plattformen darauf auf. Einige der Projekte, die auf dem NEAR-Protokoll aufbauen, sind 

 	Mintbase - Eine Plattform, die sich der Vereinfachung der Ausgabe und des Verkaufs von NFTs widmet und gleichzeitig den gesamten Prozess kostengünstig gestaltet.  
 	Flux - Flux ist ein dezentrales Open-Market-Protokoll. Es wurde im Jahr 2020 auf dem NEAR-Protokoll eingeführt. 
 	Paras - Paras ist ein NFT-Marktplatz, der sich auf Werke von ausgewählten Künstlern konzentriert. 

Das NEAR Grants Program, das derzeit von der NEAR Foundation betrieben wird, unterstützt Projekte, die das Wachstum des NEAR-Ökosystems ermöglichen. 
Aurora auf dem NEAR-Protokoll
Aurora ist ebenfalls auf dem NEAR-Protokoll gestartet und bietet eine Ethereum-Layer-2-Erfahrung. Eine Lösung, die es Entwicklern ermöglicht, zusätzliche Märkte zu erschließen. Aurora nutzt die Vorteile des NEAR-Protokolls, wie z. B. die Vergütung von Gasgebühren und Sharding. Es läuft auf zwei entscheidenden Komponenten, der Aurora Bridge und der Aurora Engine. 

Einige der Verbesserungen, die Aurora mit sich bringt, sind:

 	Die Fähigkeit, Tausende von Transaktionen pro Sekunde zu verarbeiten, eine 50-fache Steigerung gegenüber Ethereum. 
 	Eine Block-Finalitätszeit von 2 Sekunden im Vergleich zu einer einzelnen Block Bestätigungszeit von 13 Sekunden bei Ethereum. Die schnelle Endgültigkeit reduziert auch Frontrunning-Angriffe. 
 	Zukunftssicheres Wachstum des Ökosystems: Der Sharding-Ansatz des NEAR-Protokolls ermöglicht eine horizontale EVM-Skalierung und asynchrone Kommunikation zwischen mehreren Shards. 
 	Die Gebühren auf Aurora sind 1000-mal niedriger als die auf Ethereum. Ein Beispiel: Die Übertragung eines ERC-20-Tokens auf Aurora kostet weniger als 0,01 US-Dollar, während sie auf Ethereum rund 5,40 US-Dollar kostet. 
 	Aurora bietet kompromisslose Kompatibilität mit Ethereum über das NEAR-Protokoll. 

Aurora bietet eine Lösung für die Herausforderungen des Ethereum-Ökosystems, wobei sowohl Smart Contracts als auch der Front-End-Code erhalten bleiben.
Vorteile des NEAR-Protokolls
Die Sharded-Lösung von NEAR bietet einen großen Vorteil gegenüber Plattformen wie Ethereum und Bitcoin und löst das Problem der geringen Skalierbarkeit und der häufigen Engpässe im Ethereum-Netzwerk. Indem sie ihr Protokoll sharded machen, zerlegen die Gründer von NEAR den Code der Blockchain in Teile, die auf parallelen Knoten laufen. Dies führt dazu, dass der gesamte Code schnell verarbeitet wird und NEAR dank dieser Fähigkeit, den Code zu fragmentieren von Skalierungsproblemen befreit wird. 

Das NEAR-Protokoll hat mehrere einzigartige Merkmale, die es für Nutzer und Validierer attraktiv machen. 

 	Eine flexible Benutzeroberfläche und der Zugang zu den Diensten, die auf der NEAR-Plattform laufen, bieten einen einfachen Einstiegsprozess. 
 	Dank des Sharded-Protokolls von NEAR können Validierer der Plattform beitreten, ohne eine komplexe Software herunterladen zu müssen. Sie können dann Token verdienen, indem sie Transaktionen im Netzwerk validieren. 
 	NEAR ermöglicht es Unternehmen, die Berechtigungen für ihre Nutzer anzupassen. Mit dem stetigen Wachstum des Marktes erhalten die Entwickler auch Zugang zu einem wachsenden Kundenstamm. 

Der Weg des NEAR-Protokolls in die Zukunft
Mit der Einführung der Ethereum-zu-NEAR-Brücke, auch Rainbow Bridge genannt, können Nutzer ihre Ethereum ERC-20 Token zu NEAR überbrücken und sie innerhalb des dezentralen Ökosystems von Anwendungen der NEAR Blockchain verwenden. Diese Entwicklung ist ein großer Schritt in Richtung der Vision des Gründerteams, die Plattform so zugänglich wie möglich zu machen. 

NEAR unterstützt auch eine Ethereum Virtual Machine (EVM). Diese erlaubt es Entwicklern dApps direkt von Ethereum zu NEAR zu portieren - und das mit minimalem Aufwand für Veränderungen. Auch möglich ist es, Cross-Chain-Launches von dApps durchzuführen, wobei eine App gleichzeitig auf verschiedenen Blockchains gehosted wird.

Das NEAR-Protokoll kündigte eine Partnerschaft mit Chainlink sowie die Einführung der Rainbow Bridge an, die eine Interaktion zwischen NEAR und Ethereum ermöglicht. 
Schlussfolgerung
Das NEAR-Protokoll hat sich als vielversprechend erwiesen, da es die Skalierbarkeitsprobleme von Blockchains der zweiten Generation durch Sharding löst. Darüber hinaus erhöht NEAR den Durchsatz erheblich, ohne die Sicherheit der Plattform zu beeinträchtigen. 

Dank des NEAR-Kollektivs arbeiten Hunderte von Blockchain-Ingenieuren und Entwicklern rund um die Uhr an der Verbesserung des Protokolls. NEAR hat auch sein Mainnet gestartet, und das Netzwerk ist bereit, dApps und andere Dienste zu unterstützen. NEAR konzentriert sich darauf, sicherzustellen, dass die NEAR-Plattform für Validierer, Endnutzer und Entwickler einfach zu bedienen ist, und hat sich so zu einer festen Größe im Bereich der Smart-Contract-Plattformen entwickelt.

Ethereum hingegen hat seine Position auf dem Thron dank seiner beneidenswerten Entwicklergemeinschaft und den florierenden Ökosystemen DeFi und NFTs beibehalten. Beide Protokolle bieten eine hervorragende Plattform für Entwickler, um das dezentrale Ökosystem der Zukunft aufzubauen.

### Bagaimana Cara Kerja Rainbow Bridge NEAR?

Artikel oleh Matt Henderson mengenai Aurora 

Rainbow Bridge NEAR merupakan hal unik di kripto sebagai satu-satunya penghubung yang bersifat trustless (tidak perlu mempercayakan/ bergantung pada suatu pihak) dan permissionless (siapapun bisa menggunakan tanpa izin dari pihak manapun) ke Ethereum. Pada artikel ini, kita akan mengungkapkan bagaimana cara kerjanya!

NEAR Protocol menciptakan Rainbow Bridge - sesuatu yang sifatnya unik dan berharga di dunia kripto, penghubung yang sepenuhnya bersifat “trustless” untuk mentransfer token antara Ethereum, NEAR dan juga Aurora. Meskipun ada artikel yang menjelaskan teknis mengenai penghubung ini diluar sana, artikel ini akan menjelaskan cara kerjanya dengan cara yang sekiranya dapat dipahami oleh siapa saja yang memiliki pengetahuan dasar tentang kripto.
Konsep
Mari mulai dengan membayangkan ketika kita ingin mentransfer 20 DAI dari Ethereum ke NEAR. Dikarenakan transfer fisik token tidak memungkinkan antar jaringan, ini berarti kita perlu mengeluarkan 20 DAI dari peredaran di jaringan Ethereum, dan menempatkan 20 DAI ke dalam sirkulasi di jaringan NEAR, sehingga pasokan global DAI tidak berubah.

Inilah cara kita melakukannya dengan secara trustless dan permissionless:

 	Kita menginformasikan ke jaringan Ethereum bahwa kita ingin mentransfer 20 DAI ke tempat lain.
 	Jaringan Ethereum mengunci 20 DAI kita di brankas (smart contract), sehingga mereka dikeluarkan dari peredaran.
 	Setelah kita yakin 20 DAI tersebut telah dikunci di Ethereum, kemudian kita memberi tahu NEAR untuk membuat 20 DAI baru untuk kita di sana.
 	NEAR tentunya tidak mempercayai kita, oleh sebab itu NEAR meminta kita untuk membuktikan bahwa kita telah mengunci 20 DAI di jaringan Ethereum.
 	Kita memberikan NEAR dengan bukti bahwa kita telah mengunci DAI tersebut di Ethereum.
 	NEAR secara independen memverifikasi bukti yang kita miliki, dan kemudian membuat 20 DAI baru untuk bisa kita gunakan di NEAR.

Setelah itu, jika kita ingin memindahkan DAI kembali ke jaringan NEAR, gunakan prosedur yang sama secara reversal, sederhana bukan?
Para Aktor (Pemain)
Jadi sekarang mari kita lihat bagaimana semua itu terjadi dalam praktik, menggunakan Rainbow Bridge. Cerita ini akan melibatkan sejumlah komponen teknis yang membentuk penghubung/ jembatan yaitu:

Rainbow Bridge UI — ini merupakan situs web tempat anda sebagai pengguna dapat berinteraksi dengan jembatan untuk mentransfer aset anda antar jaringan.

LiteNode — Ini seperti nodes pada blockchain, kecuali bahwa ia hanya menyimpan header blok, secara dramatis mengurangi ruang penyimpanan yang dibutuhkan. LiteNode diimplementasikan sebagai smart contract, dan kita memiliki keduanya dimana satu digunakan di jaringan Ethereum, yang menyimpan header blok NEAR, dan satu lagi digunakan di NEAR yang menyimpan header blok Ethereum.

Sekadar informasi, LiteNode sebenarnya disebut sebagai "klien ringan" pada artikel lain, karena alasan historis. Jika anda bertanya kepada kami, "apa yang menyimpan data blockchain?", Dipikiran kami pertama kali tentunya adalah "sebuah node", dan seterusnya. Pada artikel ini untuk membantu dengan model penjelasan, kita menyebutnya sebagai LiteNode.

Relayers — Karena LiteNodes adalah smart contract, mereka tidak dapat menjalankan dan memperbarui diri sendiri. Relayer adalah skrip yang berjalan di server tradisional, yang secara berkala membaca blok dari satu blockchain, dan mengkomunikasikannya ke LiteNode yang berjalan di blockchain lainnya. Jadi relayer menjaga LiteNodes tetap up-to-date.

Karena akan ada biaya transaksi dimana diistilahkan sebagai gas fee yang setiap kali relayer memperbarui LiteNode,  jaringan di NEAR (yang berisi blok Ethereum) akan diperbarui pada setiap blok Ethereum (karena biaya gas NEAR murah), sedangkan frekuensi pembaruan pada Ethereum (yang berisi blok NEAR) dapat dikonfigurasi dan ditentukan oleh anggaran ekonomi (saat ini sekitar 12 hingga 16 jam).

Connectors — Konektor adalah smart contract yang bertanggung jawab atas semua logika yang terkait dengan manajemen cross-chain dari jenis aset tertentu. Seperti LiteNodes, mereka berpasangan dimana satu berjalan di jaringan Ethereum, dan satu lagi berjalan di jaringan NEAR. Misalnya, ada sepasang "Konektor ETH" yang bertanggung jawab untuk mentransfer ETH antara dua jaringan dan ada pasangan “Konektor ERC-20” yang bertanggung jawab untuk mentransfer token ERC-20. Seseorang dapat menulis Konektor "NFT", Konektor "Hasil Pasar Prediksi" atau Konektor "Hasil Suara DAO" jika mereka mau. Aset atau data apa pun dapat ditransfer melintasi Rainbow Bridge, jika ada Konektor yang relevan!
Menyatukan Semua Potongan Secara Bersamaan
Untuk memahami bagaimana semua elemen ini bekerja bersama untuk memungkinkan kita mentransfer token secara permissionless dan trustless  antara Ethereum dan NEAR, mari kita telusuri contoh kita seperti sebelumnya:

 	Dengan menggunakan UI Rainbow Bridge, kita memulai melakukan transfer 20 DAI dari Ethereum ke NEAR.
 	Ketika kita mengkonfirmasi satu dari dua transaksi di MetaMask, Rainbow Bridge berkomunikasi dengan Konektor ERC-20 di Ethereum (karena DAI adalah token ERC-20), dimana 20 DAI akan ditransfer dan dikunci di brankasnya. DAI ini kemudian tidak lagi beredar di jaringan Ethereum.
 	Berdasarkan data header di blok transaksi kita tadi, UI Rainbow Bridge menghitung "bukti" kriptografis bahwa kita benar-benar mengunci 20 DAI.
 	Karena selanjutnya kita akan meminta jaringan NEAR untuk membuat beberapa DAI berdasarkan apa yang baru saja terjadi di Ethereum, pertama-tama kita menunggu Relayer untuk mengirim sekitar 20 header blok Ethereum ke LiteNode yang berjalan di NEAR. Untuk faktor keamanan, sama seperti cara di crypto exchange dimana kita harus menunggu beberapa konfirmasi sebelum bisa menggunakan dana yang telah kita setorkan.
 	Setelah menunggu, UI Rainbow Bridge kemudian memungkinkan kita untuk mengambil langkah kedua dalam proses yaitu meminta Konektor ERC-20 di NEAR untuk membuat 20 DAI baru untuk di jaringan NEAR kita.
 	Saat kita mengajukan permintaan Konektor ERC-20 ini, kita memberikan bukti kriptografis yang kita terima sebelumnya, "membuktikan" bahwa kita telah mengunci 20 DAI di Ethereum.
 	Konektor ERC-20 di NEAR kemudian akan mencari header blok Ethereum di LiteNode yang berjalan di NEAR, dan membuat perhitungan independen dari bukti kriptografi.
 	Jika bukti yang kita berikan cocok dengan bukti yang dihitung oleh Konektor ERC-20, maka diketahui bahwa 20 DAI tersebut dikunci dengan aman di Ethereum—dan bahwa kitalah yang telah menguncinya!—dan mulai membuat (mint) 20 DAI baru di NEAR dan mengirimkannya ke dompet kita.

Ketika kita ingin mentransfer DAI dari jaringan NEAR kembali ke jaringan Ethereum, proses yang sama dapat dilakukan secara reversal/ terbalik, yaitu daripada mengunci 20 DAI, kita dapat membakarnya (atau sering dikenal dengan burning) dan memberikan “bukti” pembakaran itu ke Konektor berjalan di Ethereum. Dengan memiliki akses ke blok NEAR di LiteNode yang berjalan di Ethereum, itu memvalidasi bukti milik kita dan melepaskan 20 DAI dari brankasnya dan mengirimkannya ke dompet milik kita.

Begitulah singkatnya mengenai cara kerja Rainbow Bridge! Ini merupakan satu-satunya jembatan Ethereum di crypto yang dapat bekerja dengan cara ini dimana memungkinkan anda untuk mentransfer aset secara permissionless antara Ethereum, NEAR dan segera di Aurora—tanpa harus menaruh kepercayaan pada pihak ketiga. Sangat keren bukan!
Potongan-Potongan Lainnya
Berikut ini beberapa catatan menarik untuk disertakan dengan dari penjelasan sebelumnya:

 	Karena NEAR-to-Ethereum Relayer hanya mengirimkan header blok NEAR ke Ethereum LiteNode setiap 16 jam sekali, akan ada penundaan sekitar 16 jam antara langkah satu dan dua saat memindahkan token ke jaringan tersebut. (Ingat, ini karena biaya gas Ethereum membuat Relayer sangat mahal untuk memperbarui LiteNode di setiap blok.) Ada sejumlah pendekatan yang memungkinkan kami mengurangi penundaan ini, dan tim secara aktif mengerjakannya.
 	Di NEAR, LiteNode menyimpan semua header blok Ethereum sebelumnya. Agar ruang penyimpanan tidak lepas kendali, LiteNode "memangkas" (menghapus) blok yang lebih lama dari sekitar dua minggu. Ini berarti jika Anda memulai transfer dari Ethereum ke NEAR, dan pergi berlibur selama tiga minggu antara langkah satu dan dua, Anda tidak akan dapat menyelesaikan transfer Anda, karena data Ethereum yang disimpan NEAR diperlukan untuk memverifikasi "bukti" Anda akan telah dihapus!
 	Karakteristik menarik dari desain header blok NEAR, adalah bahwa dengan satu blok header, kita dapat menghitung historis dari blok sebelumnya untuk waktu yang cukup lama. Jadi secara teori, LiteNode di Ethereum hanya membutuhkan satu blok NEAR; namun, kami menyimpannya karena biaya gas yang diperlukan untuk melakukan pemangkasan pada dasarnya akan membuang-buang sumber daya.
 	Tim yang menciptakan Rainbow Bridge adalah tim yang sama yang menciptakan Aurora—EVM NEAR. Karena tim itu telah berubah menjadi entitasnya sendiri, Rainbow Bridge akan berada di bawah manajemennya untuk operasi, pemeliharaan, dan pengembangan di masa depan.
 	Tim Aurora sedang mengerjakan "finalisasi otomatis" untuk Rainbow Bridge, sehingga Anda tidak perlu lagi memulai langkah kedua dari transfer ini secara manual. Ini akan sangat nyaman bagi pengguna (dan artinya Anda dapat memulai transfer Ethereum ke NEAR dan kemudian pergi liburan!)
 	Transfer antara Ethereum dan Aurora dilakukan oleh Aurora Bridge, yang menggunakan teknologi inti yang sama dengan Rainbow Bridge, tetapi ditambah untuk menangani langkah tersembunyi NEAR/Aurora dalam transfer.
 	Antarmuka pengguna dan pengalaman Aurora Bridge berbeda dari Rainbow Bridge, dan di beberapa titik di masa depan, ini akan diselaraskan.

Meskipun beberapa detail teknis telah disederhanakan, Anda sekarang memiliki pemahaman mendasar tentang cara kerja Rainbow Bridge!

Untuk penjelasan lebih dalam tentang Rainbow Bridge, Anda dapat membaca artikel ini, dan untuk mengikuti semua yang terkait dengan Aurora, pastikan untuk mengikuti Aurora di Twitter!

### NEAR-Protokoll und Solana

Heute wollen wir uns zwei der vielversprechendsten Smart-Contract-Plattformen der Welt ansehen - Near Protocol und Solana. Ethereum dominiert zwar nach wie vor diesen Markt, doch die mangelnde Skalierbarkeit und die hohen Gebühren für Transaktionen haben die meisten Entwickler dazu gezwungen, nach praktikablen Alternativen zu suchen. Near und Solana haben sich als die beiden Spitzenreiter herauskristallisiert.
Was ist Solana?
Solana wurde 2017 von Anatoly Yakovenko gegründet, der zuvor bei DropBox gearbeitet hatte. Yakovenko schuf Solana zusammen mit Eric Williams und CTO Greg Fritzgerald, um die bestehenden Probleme in Bitcoin und Ethereum zu lösen. Das Projekt hat Investitionen von Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures und anderen angezogen. 



Merkmale der Solana-Blockchain

 	50.000 Transaktionen pro Sekunde und 0,4 Sekunden Blockzeit
 	Das System kann 28,4 Millionen Transaktionen pro Sekunde in einem 40-Gigabit-Netzwerk durchführen.
 	Solana verwendet den Proof-of-History-Konsensalgorithmus.

Wie funktioniert der Proof-of-History (PoH)?

In einem dezentralen Netzwerk, das sich über ein großes Gebiet erstreckt, ist ein Konsens unerlässlich. Bitcoin verwendet den Proof-of-Work-Konsens (PoW), um den Konsens zu gewährleisten. Obwohl diese Methode sehr sicher ist, kann man ihr größtes Problem nicht ignorieren - die fehlende Skalierbarkeit. Man darf nicht vergessen, dass Bitcoin nur 7 Transaktionen pro Sekunde durchführen kann.

Solana verwendet Proof-of-History, d.h. es erstellt historische Aufzeichnungen, um zu beweisen, dass ein Ereignis zu einem bestimmten Zeitpunkt stattgefunden hat. Hier sind einige Punkte, die Sie im Auge behalten müssen:

 	Der Algorithmus verwendet eine hochfrequente Verifizierbare Verzögerungsfunktion, die eine bestimmte Anzahl von aufeinanderfolgenden Schritten benötigt, um abgeschlossen zu werden.
 	Die im Netzwerk getakteten Transaktionen oder Ereignisse werden mit einem eindeutigen Hashwert versehen, der öffentlich verifiziert werden kann.
 	Anhand der Zählung kann das Netz genau feststellen, wann die Transaktion oder das Ereignis stattgefunden hat.
 	Jeder Knoten verfügt über eine kryptografische Uhr, mit deren Hilfe die Netzwerkzeit und die Reihenfolge der Ereignisse verfolgt werden können.

Dank PoH unterstützt das Solana-Netzwerk 50.000 Transaktionen pro Sekunde, während es mit GPUs läuft. 

Was ist ein Solana-Cluster?

Ein Cluster ist eine Gruppe unabhängiger Computer, die zusammenarbeiten und als ein einziges System betrachtet werden können. Die Hauptmerkmale des Clusters sind wie folgt:

 	Sie helfen bei der Überprüfung der Ausgabe von nicht vertrauenswürdigen, vom Benutzer eingereichten Programmen. 
 	Er führt Aufzeichnungen über jede Transaktion oder jedes Ereignis, das ein Benutzer durchführt.
 	Es wird festgehalten, welche Computer sinnvolle Arbeit geleistet haben, um das Netzwerk am Laufen zu halten.
 	Es verfolgt den Besitz von realen Gütern.




	

	
	
		
			
				Which of the following utilizes sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			Both
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Programmierung in Solana

Die Smart Contracts in Solana werden in Rust oder C geschrieben und in Berkeley Packet Filter (BPF) Bytecode kompiliert. Da mehr Werkzeuge zur Verfügung stehen, ist es empfehlenswert, in Rust zu programmieren. Anfänger sollten ihre Programme unter Verwendung des Anchor-Frameworks programmieren, das die Ausführung vereinfacht.

Solana hat ein einzigartiges Kontomodell, das den Dateien im Linux-Betriebssystem ähnelt. Sie können beliebige Daten aufnehmen und enthalten auch Metadaten darüber, wie auf sie zugegriffen werden kann. Beachten Sie jedoch, dass die Konten eine feste Größe haben und nicht in der Größe verändert werden können. 

Das derzeitige Programmiermodell von Solana zwingt Sie möglicherweise dazu, die Anwendungslogik aus der Kette auszulagern oder die Funktionalität so zu modifizieren, dass sie ineffizient und durch die feste Kontengröße eingeschränkt ist. 




	

	
	
		
			
				Which of the following is an integral part of Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Collective
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Beispielvertrag
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
Was geschieht in dem Vertrag?

 	Alle Konten, auf die zugegriffen werden soll, sind in der Struktur für jeden Aufruf mit #[derive(Accounts)] vermerkt. 
 	Die Funktionen helfen, die Kontodaten für den anfänglichen Besitzer und den Kauf zu initialisieren. Dadurch kann jeder das Konto für weitere Token kaufen. 
 	Temporäre Daten werden als Funktionsparameter übergeben. Diese Parameter befinden sich innerhalb der Funktionen initialize und purchase. Dazu gehört auch der Kontext, in dem die für die Transaktion erforderlichen Konten geführt werden.
 	Der Zustand des Vertrags befindet sich in der ContentRecord-Struktur. Diese ist zusätzlich mit #[account] annotiert, um anzuzeigen, dass sie das Datenlayout für ein Konto darstellt.

Was ist das NEAR-Protokoll?
Das im Sommer 2018 entstandene Protokoll wurde entwickelt, um die perfekte Umgebung für dezentrale Anwendungen zu schaffen, indem es höhere Geschwindigkeiten, einen höheren Durchsatz und eine bessere Kompatibilität mit anderen Chains bietet. NEAR verfügt über eine einzigartige Sharding-Technik und führt einen Blockgenerierungsmechanismus namens "Doomslug" ein, der 2019 vorgeschlagen wird. Doomslug ermöglicht eine praktische oder "Doomslug"-Finalität, die sicherstellt, dass die Blöcke innerhalb von Sekunden ihre Finalität erhalten.

Das NEAR-Protokoll wird vom NEAR-Kollektiv entwickelt, einer Gemeinschaft von Entwicklern und Forschern, die an der Entwicklung des Projekts mitarbeiten. Einige wichtige Merkmale von NEAR sind:

 	NEAR ist ein Sharded-System, das eine unendliche Skalierbarkeit ermöglicht. 
 	NEAR ist ein benutzerfreundliches Protokoll, mit dem Entwickler einfach und schnell Anwendungen erstellen können. 
 	NEAR ist keine Side Chain, sondern ein Layer-1-Protokoll. 
 	dApps, die mit NEAR erstellt werden, laufen auf der zugrunde liegenden NEAR-Schicht, also dem Layer 1. 

Was ist das NEAR-Kollektiv? 

Zum NEAR-Kollektiv gehören einzelne Organisationen und andere Mitwirkende, die kontinuierlich an der Verbesserung des NEAR-Protokolls arbeiten. Das Kollektiv arbeitet an Projekten wie dem Schreiben des ursprünglichen Codes und der Implementierung für das NEAR-Netzwerk. NEAR ist vollständig dezentralisiert, arbeitet unabhängig und kann nicht abgeschaltet oder manipuliert werden, auch nicht von denen, die es aufgebaut haben.

Es handelt sich um eine gemeinnützige Organisation, die sich auf die Schaffung eines lebendigen Ökosystems rund um die NEAR-Blockchain konzentriert. Sie hilft bei der Koordination von Governance-Aktivitäten und der Entwicklung. Das NEAR-Kollektiv hat mehrere Projekte, wobei die NEAR-Blockchain nur eines von mehreren Projekten ist, die unter der Ägide des Kollektivs stehen. 

NEAR-Konsens-Mechanismus

Der bei NEAR implementierte Konsensmechanismus heißt Nightshade. Nightshade modelliert das System als eine einzige Blockchain. Die Liste aller Transaktionen in jedem Block wird in physische Chunks aufgeteilt, ein Chunk pro Shard. Alle Chunks werden zu einem Block akkumuliert. Beachten Sie, dass Chunks nur von Knoten validiert werden können, die den Status dieses Shards verwalten.

Apropos Validierung: Eine Schlüsselkomponente von NEAR sind die Validierer. Diese Validatoren sind für die Aufrechterhaltung des Konsenses innerhalb des Protokolls verantwortlich. Validatoren sind spezialisierte Knoten, die ihre Server zu 100 % der Zeit online halten und ihre Systeme ständig aktualisieren müssen. 

Hier sind einige Punkte, die Sie bei den Netzwerk-Validatoren beachten müssen.

 	NEAR bestimmt seine Netzwerk-Validatoren in jeder neuen Epoche und wählt sie auf der Grundlage ihres Einsatzes.
 	Die bereits gewählten Validatoren werden erneut registriert, indem sie automatisch ihre Token und die angesammelten Belohnungen erneut einsetzen.
 	Potenzielle Validatoren müssen einen dynamisch festgelegten Wert überschreiten.
 	Es gibt zwei Methoden, mit denen ein Validator seinen Einsatz erhöhen kann - er kann die Token selbst kaufen oder über die Delegation von Einsätzen leihen.
 	Die Belohnung, die Sie erhalten, ist direkt proportional zu Ihrem Einsatz - je höher Ihr Einsatz, desto höher Ihre Belohnung.

Der Konsens basiert auf dem schwersten Blockchain Konsens. Das heißt, sobald ein Blockproduzent einen Block veröffentlicht, sammelt er die Unterschriften der Validierungsknoten. Das Gewicht eines Blocks ist dann der kumulierte Einsatz aller Unterzeichner, deren Unterschriften in dem Block enthalten sind. Das Gewicht einer Kette ist die Summe der Blockgewichte. Zusätzlich verwendet der Konsens eine Finalitätsfunktion, die zusätzliche Bedingungen für eine höhere Blockchain Sicherheit einführt.




	

	
	
		
			
				Doomslug” is a block generation mechanism of which protocol?
			
		

		
					

		
			
			
			
			NEAR protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Aurora und NEAR-Protokoll

Aurora wurde auch auf dem NEAR-Protokoll eingeführt und bietet eine Ethereum Layer-2 Erfahrung. Aurora verbessert NEAR unter anderem in folgenden Punkten: 

 	Es hilft, den Durchsatz auf Tausende von Transaktionen pro Sekunde zu erhöhen.
 	Eine Block-Finalitätszeit von 2 Sekunden.
 	Zukunftssicheres Wachstum des Ökosystems
 	Niedrige Transaktionsgebühren, die 1000-mal niedriger sind als bei Ethereum.
 	Uneingeschränkte Kompatibilität mit Ethereum.

Beispielvertrag
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

Was ist in dem Vertrag geregelt?

Was steht nun in dem Vertrag? Schauen wir uns das mal genauer an.

 	Der Vertrag wird durch #[near_bindgen] im ContentTracker definiert. Er ähnelt einem Konstruktor in Solidity und wird aufgerufen, wenn der Vertrag bereitgestellt wird.
 	Die Kauffunktion ist mit #[payable] annotiert.
 	Der Vertrag enthält asynchrone Aufrufe in Form von Promise::new(...).transfer(...); Zeilen.
 	Die Datenstruktur LookupMap<String, ContentRecord> behandelt die Schlüssel-Wert-Suche, die auf den Speicher zugreift. Dies entspricht dem Solidity-"Mapping".

Schlussfolgerung
Sowohl Solana als auch NEAR Protocol sind brillante Smart-Contract-Plattformen, die eine sehr aktive Community aufgebaut haben. Beide bringen spezielle Funktionen mit, die helfen, das größte Problem der dezentralen Welt zu bekämpfen - Geschwindigkeit. Beide Plattformen befinden sich noch im Wachstum und sind vielversprechend.

### Update - March 23, 2022

Brief Summary:

 	
We say "NO to WAR"! Learning is all about Peace!


Results:

 	💸 Ⓝ600 sent to 300 (L)Earners on March Redeem Window
 	🧪It was intense 3 week dWork and dForm Beta test sprints brought SUPERSOLID feedback! 🔥🔥
💸 Ⓝ100 were sent to the best LNC Pro Beta Testers

 	🌐Learn NEAR Club is available in EIGHT languages!!! Many thanks to our Translators
 

 

 	


📚"(L)Earn about "NEAR NFT Marketplaces""














Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC NFT certificates coming to Mainnet!

### NEAR PROTOCOL dan SOLANA

Pada artikel ini mari kita bahas dua platform smart contract yang paling menjanjikan saat ini - NEAR Protocol dan Solana. Walaupun Ethereum masih mendominasi pasar, namun fakta membuktikan bahwa Ethereum mengalami masalah skalabilitas dan gas fee yang besar dan memaksa para developer untuk mencari jalan alternatif. NEAR dan Solana sukses menjadi dua alternatif terdepan.
Apa Itu Solana?
Solana didirikan pada tahun 2017 oleh Anatoly Yakovenko, yang sebelumnya bekerja di DropBox. Yakovenko, bersama Eric Williams dan CTO Greg Fritzgerald, menciptakan Solana untuk memecahkan masalah-masalah yang terjadi pada jaringan Bitcoin dan Ethereum. Solana telah menarik minat para investor, antara lain Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Venture dan lainnya.



Fitur Menarik Pada Solana

 	50,000 transaksi per detik dan 0.4 detik finalisasi block
 	Jaringan ini sanggup menangani 28,4 juta transaksi per detik pada saat dijalankan di atas 40 Gigabit Network.
 	Solana menggunakan alghoritma konsensus PoH , atau Proof-of-History 

Bagaimana Proof-of-History Bekerja?

Dalam lingkup jaringan terdesentralisasi dengan cakupan besar, konsensus adalah elemen esensial. Bitcoin menggunakan konsensus Proof-of-Work. Meskipun metode ini dianggap memiliki keamanan tertinggi, namun tidak bisa disangkal ini juga menimbulkan masalah lainnya - yaitu masalah skalabilitas. Jangan lupa Bitcoin hanya sanggup menangani transaksi sebanyak 7 transaksi per detik.

Solana menggunakan Proof-of-History , menciptakan catatan (Historical Records) bahwa sebuah kejadian terjadi pada waktu yang spesifik. Berikut adalah point-point yang perlu kita ingat :

 	Algoritmanya menggunakan Verifiable Delay Function dengan frekuensi tinggi, yang membutuhkan beberapa langkah berurutan untuk menyelesaikannya.
 	Transaksi atau kejadian di dalam jaringan akan diajukan untuk mendapatkan sebuah hitungan hash yang unik, dan hash tersebut akan diverifikasi secara publik
 	Hitungan tersebut memungkinkan seluruh jaringan mengetahui kapan transaksi atau kejadian itu terjadi.
 	Setiap node dalam jaringan Solana, mempunyai semacam “cryptographic clock” yang membantu melacak waktu dalam jaringan dan kapan transaksi atau kejadian itu terjadi.

Dengan demikian, penggunaan Proof-of-History memungkinkan Solana mendukung 50,000 transaksi per detik dengan hardware yang menggunakan GPU.

Apa Itu Solana Cluster?

“Solana Cluster” adalah sebuah kelompok komputer yang masing-masing dimiliki secara independen namun dapat saling bekerjasama satu dengan lainnya dan dianggap sebagai satu kesatuan sistem. Fitur unggulan dari Solana Cluster adalah sebagai berikut :

 	Mereka membantu memberikan verifikasi atas data yang dihasilkan oleh pengguna yang anonim
 	Mencatat transaksi atau kejadian yang dilakukan pengguna.
 	Membantu penelusuran dari set komputer manakah yang benar-benar bekerja untuk menjalankan sistem Solana secara keseluruhan.
 	Membantu penelusuran dari kepemilikan atas aset dalam dunia nyata.




	

	
	
		
			
				Manakah jaringan berikut ini yang mempunya fitur Sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR Protocol
		
			
			Keduanya
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Pemrograman Di Dalam Solana

Smart Contract di Solana ditulis dengan bahasa pemrograman menggunakan Rust atau C dan dikompilasi menggunakan Berkeley Packet Filter ( BFP) bytecode. Dari beragam tools yang ada, direkomendasikan kepada para developer untuk menulis aplikasinya menggunakan Rust. Khusus pemula yang ingin menulis program mereka di Solana juga dapat menggunakan Anchor framework, ini memudahkan eksekusinya.

Solana mempunyai model account yang unik dan mirip dengan database file di dalam sistem operasi Linux. Mereka dapat menyimpan data arbitrase dan sanggup menyimpan metadata tentang bagaimana data tersebut diakses. Namun harap diingat, account tersebut mempunyai besaran file yang tetap dan tidak dapat dirubah.

Model pemrograman Solana saat ini memaksa para developer untuk memindahkan application logic menjadi off-chain (di luar blockchain) atau melakukan modifikasi namun menjadi tidak efisien karena terbatasnya alokasi besaran account tersebut.




	

	
	
		
			
				Manakah dari berikut ini yang merupakan bagian integral dari Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Collective
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Example Contract
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
Apa Yang Terjadi di Dalam Smart Contract Tersebut?

 	Semua account yang akan diakses dijelaskan di dalam struktur untuk setiap call dengan tanda # [derive(Accounts)].
 	Fungsi-fungsi tersebut untuk membantu melakukan inisialisasi (Initialize)  data account untuk pemilik awal dan melakukan transaksi (Purchase). Hal tersebut memungkinkan untuk pengguna lain melakukan transaksi kembali untuk mendapatkan token lebih banyak lagi.
 	Data sementara kemudian diteruskan melalui parameter-parameter function. Parameter tersebut berada di dalam Initialize dan Purchase function. Termasuk juga Context yang menyimpan account yang terlibat dalam transaksi tersebut.
 	

Apa Itu NEAR Protocol?
Dimulai saat musim panas di tahun 2018, protocol ini didesain untuk menciptakan environment sempurna untuk decentralized applications dengan menyediakan kecepatan dan throughput yang tinggi serta kompabilitas dengan jaringan blockchain lain. NEAR mempunyai teknik pemecahan (Sharding) yang unik dan pada 2019 memperkenalkan mekanisme penghasilan block (block producing) yang disebut “Doomslug”. Mekanisme ini memungkinkan jaringan NEAR menghasilkan finalisasi block dalam hitungan detik.

NEAR Protocol dikembangkan oleh NEAR Collective, sebuah komunitas developer dan ahli riset yang berkolaborasi membangun jaringan ini. Fitur utama NEAR adalah :

 	NEAR menggunakan sistem pemecahan jaringan yang memungkinkan skalabilitas tak terhingga.
 	Protokol yang mudah digunakan, memungkinkan Developer membangun aplikasi dalam waktu singkat dan mudah.
 	NEAR bukanlah sidechain namun adalah Layer-1 Protocol.
 	Dapp yang diciptakan menggunakan NEAR, berjalan di atas Layer NEAR

Apa itu NEAR Collective?

NEAR Collective berisikan didalamnya individu, organisasi dan kontributor yang secara terus menerus bekerja mengembangkan NEAR Protocol. NEAR Collective menulis code awal dan implementasinya di dalam NEAR Network. NEAR sepenuhnya desentralisasi, beroperasi secara independen dan tidak bisa dimatikan, dimanipulasi bahkan bagi mereka yang membangun dan mengembangkan.

NEAR Collective adalah sebuah organisasi nirlaba yang memfokuskan untuk menciptakan ekosistem di atas jaringan blockchain NEAR. Fungsinya membantu terbentuknya perkembangan dan aktifitas Governance. NEAR Collective mempunyai beberapa proyek, dimana blockchain NEAR adalah salah satunya di bawah naungan mereka.

Mekanisme Konsensus NEAR.

Mekanisme Konsensus yang diimplementasikan pada NEAR dinamakan Nightshade. Nightshade menganggap sistem jaringan adalah model dari single blockchain. Daftar dari semua transaksi dalam setiap block dibagi menjadi beberapa bagian besar (chunk), satu bagian untuk satu shard. Semua chunk diakumulasikan dalam satu block. Perhatikan bahwa setiap chunk hanya bisa divalidasi dari sekumpulan node yang memelihara shard tersebut.

Bicara mengenai validasi, komponen terpenting dari NEAR adalah validator. Validator-validator ini bertanggungjawab atas pemeliharan konsensus jaringan di dalam NEAR protocol. Validator adalah node yang diwajibkan menjaga server mereka nyala 100% untuk menjaga keberlangsungan sistem.

Beberapa point penting untuk diperhatikan :

 	NEAR memilih validator network setiap epoch baru, berdasarkan berapa banyak NEAR yang mereka miliki dan pertaruhkan (stake) dalam network.
 	Validator yang sudah terpilih didaftarkan ulang dengan secara otomatis mempertaruhkan ulang token mereka ditambah hadiah yang diperoleh.
 	Validator potensial harus mempertaruhkan token NEAR mereka di atas ambang batas dinamis yang ditentukan oleh jaringan.
 	Ada dua metode yang bisa dipilih oleh setiap validator untuk memperkuat stake mereka. Membeli NEAR dari kas mereka sendiri, atau meminjam via stake delegation.
 	Imbalan yang diterima sesuai dengan proporsi stake, semakin banyak stake, maka reward akan semakin besar.

Konsensus berdasarkan dari konsensus chain terbesar, artinya ketika seorang block producer sukses menciptakan block baru, maka jaringan akan mengumpulkan signature dari setiap node validator. Berat dari sebuah block adalah akumulasi gabungan semua token yang dimiliki oleh para validator yang diikutsertakan dalam sebuah block. Sebagai tambahan, konsensus jaringan juga akan menggunakan tools tambahan untuk block finality dan mengenalkan tambahan kondisi pemotongan imbalan sebagai jaminan untuk keamanan jaringan.




	

	
	
		
			
				“Doomslug” adalah mekanisme penciptaan block (block generation0 dari protocol?
			
		

		
					

		
			
			
			
			NEAR Protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Jaringan Aurora sudah diluncurkan di atas NEAR dan menyediakan pengalaman Layer 2 seperti dalam Ethereum. Beberapa keunggulan Aurora adalah :

 	Membantu menghasilkan throughput menjadi ribuan transaksi per detik.
 	Hanya 2 detik untuk block finality.
 	Perkembangan ekosistem yang sangat baik untuk kedepannya.
 	Kecilnya biaya transaksi, 1000x lebih rendah dibanding di jaringan utama Ethereum.
 	Kompatibilitas dengan jaringan Ethereum. 

Example Contract
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

What is going on in the contract?

Jadi apa yang terjadi pada Smart Contract di atas? Mari kita lihat :

 	Contract dijelaskan oleh #[near_bridgen] di dalam ContentTracker dan ini mirip dengan sebuah constructor dalam Solidity, dan akan dipanggil  (call) saat contract diluncurkan.


 	Purchase Function dijelaskan dengan #[payable]


 	Contract mengikutsertakan asynchronous calls dalam bentuk Promise::new(..).transfer(...); lines.


 	Struktur data pada LookupMap<String, ContentRecord> menangani “value lookup”, dan memungkinkan mengakses storage. Mempunyai kemiripan pada fitur “mapping” pada Solidity.

Kesimpulan
Baik Solana maupun NEAR Protocol adalah platform smart contract yang sedang menjadi sorotan para penggiat aktif dalam dunia blockchain dan cryptocurrency. Keduanya memiliki fitur unik yang sama-sama memberikan solusi kepada masalah utama dalam dunia desentralisasi, yaitu kecepatan. Kedua platform tersebut kedepannya akan terus tumbuh dan sangat menjanjikan.

### Apa itu NEAR Protocol?

Luaran yang diharapkan: pengetahuan dasar bagaimana cara kerja NEAR dari sudut pandang pengguna
NEAR merupakan platform aplikasi terdesentralisasi yang dijalankan pada blockchain NEAR Protokol. Blockchain tersebut, dimana saat ini menjalankan ratusan perangkat mesin di seluruh dunia, didesain agar dapat bekerja tanpa otoritas, memiliki kinerja dan cukup aman untuk membuat lapisan data yang kuat dan terdesentralisasi untuk web baru. 

Misi utama NEAR adalah untuk menghadirkan sebuah platform yang ideal untuk menjalankan aplikasi yang dapat dibagikan dan  memiliki akses yang aman sebagai wadah untuk keuangan, identitas dan data yang dimiliki pengguna. Ini mengkombinasikan fitur jaringan yang tidak bisa dipartisi, komputasi tanpa server dan ruang penyimpanan terdistribusi dalam suatu platform jenis baru.

Sebelum kita melangkah lebih jauh, mari kita pelajari beberapa latar belakang dan melihat bagaimana platform blockchain berkembang dari hari ke hari.
Evolusi Teknologi Blockchain
Sejak Satoshi Nakamoto merilis whitepaper Bitcoin pada Oktober 2008, dunia telah mengenal teknologi blockchain yang mengubah tatanan dan wajah dunia. Selama beberapa dekade terakhir, blockchain telah melalui tiga tahap evolusi.

Generasi 1 : Bitcoin (BTC)

Bitcoin merupakan contoh sempurna dari blockchain generasi pertama. Tujuan dari blockchain ini adalah untuk menjadi sistem pembayaran yang sederhana dan mudah. Dimulai dengan dikenal sebagai “mata uang internet,” Bitcoin sejak saat itu menjadi salah satu aset yang paling banyak peminatnya. Namun, terdapat masalah besar pada BTC. Sangat sulit untuk melakukan transaksi yang rumit dengan BTC dimana mungkin memiliki beberapa lapisan metadata dan logika yang melekat padanya.

Generasi 2 : Ethereum dan Plaftom Smart Contract

Ethereum mengantarkan platform blockchain generasi kedua dengan smart contract. Pada akhirnya, developer dapat memprogram transaksi yang rumit melalui smart contract ini, dan mampu membuat aplikasi terdesentralisasi (dApps). Melalui dApps, aktivitas dan kegiatan blockchain semakin naik ke tingkatan yang lebih tinggi.

Namun, inovasi ini masih memiliki beberapa kekurangan yang harus diatasi. Hal utama yang masih menjadi masalah pada blockchain ini adalah isu skalabilistas. Seperti contoh, Bitcoin memiliki uotput proses (throughput) sebesar 7 transaksi per detik (tps), sedangkan Ethereum hanya mampu mengelola 25 transaksi per detiknya. Jika dibandingkan dengan Paypal (115 tps) dan Visa (1,700 tps), maka Ethereum masih belum begitu bagus.

Untuk mengatasinya, Ethereum dan Bitcoin baru-baru ini mencoba untuk memperbaiki masalah skalabilitas ini dengan beberapa solusi layer-2 seperti lightning network, raiden, plasma protocol, dll. Idenya disini adalah untuk membuat lapisan tambahan di atas blockchain yang mendasarinya sehingga dapat digunakan oleh jaringan protokol utama serta mendelegasikan tugas yang berulang dan rumit.

Bagaimanapun juga, ada dua masalah besar pada pendekatan ini. Pertama, solusi layer-2 ini belum banyak diterima oleh beberapa kalangan pengguna. Kedua, solusi layer-2 ini merusak arsitektur asli protokol, yang mungkin memiliki implikasi jangka panjang kedepan.

Maka dari itu disinilah generasi ketiga hadir untuk mengatasinya.

Generasi 3 : NEAR

NEAR merupakan contoh dari blockchain generasi-3 dimana bertujuan untuk menyelesaikan permasalahan terkait skalabilitas dan memberikan pengguna (end-user) dan pengembang (developer) untuk menikmati kemampuan smart contract dan jaringan blockchain secara maksimal. Dibandingkan harus bergantung pada teknologi layer-2, NEAR membebaskan diri dari gagasan bahwa setiap node yang berpartisipasi pada suatu jaringan harus menjalankan semua kode, karena pada dasarnya itu akan menciptakan hambatan besar dan memperlambat semua pendekatan yang ada.

Untuk membenahi ini semua, NEAR menggunakan teknik yang sudah sangat umum di dunia database yakni sharding. Jika dijalankan dengan benar, ini memungkinkan untuk meningkatkan kapasitas jaringan karena jumlah node dalam jaringan meningkat sehingga tidak ada batasan teoritis pada kapasitas jaringan. Bagian terbaiknya, Sharding adalah teknik skalabilitas untuk layer-1.
Apa itu Sharding?
Pada database, terkadang kita dihadapkan dengan jumlah data yang begitu banyak dan besar. Ini secara dramatis akan menghambat performa dan output proses serta membuat proses menjadi sangat tidak efisien. Inilah kegunaan dari sharding. Sharding menggunakan partisi secara horizontal pada database dan mengubahnya menjadi bagian tabel yang lebih kecil sehingga lebih mudah dikelola.

Lantas, mengapa partisi secara horizontal, bukan vertikal?

Perhatikan tabel berikut ini:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Sekarang jika kita membagi tabel secara vertikal, maka diperoleh:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Bisa kita lihat, dengan membagi tabel secara vertikal maka tabel akan menjadi tabel yang berbeda informasinya. 

Sebaliknya, jika dibagi secara vertikal akan menghasilkan :



A
B
A*B
A/B


3
3
9
1


4
4
16
1



Pembagian secara horizontal akan membuat database terpisah menjadi tabel yang lebih kecil dari database yang sama. Inilah yang dimaksud dengan shards.

Bagaimana Sharding dapat membantu Blockchain?
Sejauh yang kita amati hingga sekarang, semakin banyak nodes yang memasuki ekosistem Ethereum dan Bitcoin, semua konsensus dan proses verifikasi akan membutuhkan waktu yang lebih lama lagi. Sekarang, bagaimana sharding membantu menyelesaikan masalah ini?

Sharding akan memecah keadaan blockchain global menjadi pecahan yang lebih kecil dan lebih mudah untuk dikelola.

Apa yang terjadi pada aktivasi shard?

 	Bagian dibagi menjadi beberapa shards
 	Setiap akun unik yang ada dalam suatu shard maka akun di shard itu hanya akan bertransaksi dengan akun lain di shard yang sama

Secara sederhana, bayangkan skenario sebagai berikut. Ada jaringan hipotetis dengan tiga nodes yakni: A, B, dan C dan mereka harus memverifikasi data T. Data T dipecah menjadi tiga pecahan yaitu T1, T2, dan T3. Alih-alih semua node ini bekerja pada T secara keseluruhan, mereka dapat bekerja secara individual pada shard pada waktu yang sama. Seperti yang kita lihat, jumlah waktu yang bisa dihemat akan menjadi eksponensial.

Tidak seperti pendekatan sharding pada umumnya dimana masih memerlukan node untuk dijalankan pada perangkat keras yang semakin kompleks (mengurangi kesempatan orang banyak untuk terlibat dalam jaringan), teknik yang digunakan NEAR memungkinkan node tetap cukup kecil untuk dapat berjalan pada ruang penyimpanan (hosting) pada cloud.
Mengapa blockchain yang dapat diskalakan seperti NEAR dibutuhkan?
Ketika kita berbicara tentang blockchain generasi kedua dan ketiga, apa yang benar-benar menentukan nilai bawaannya adalah ekosistem dapp yang berjalan dengan baik diatasnya. Dengan begitu, sebagian besar platform blockchain ini akan berada dalam kompetisi tiap harinya untuk menarik sebanyak mungkin developer agar aktif terlibat dan menggunakannya.

Namun, masalah platform yang ada saat ini adalah mereka tidak memiliki teknologi mutakhir yang diperlukan untuk meng-host aplikasi berkualitas tinggi. Sebagai gambaran, ini sama seperti developer yang mencoba membuat game PS4 pada platform yang setara dengan Windows 98. Karena itu, developer harus banyak melakukan penyesuaian ada fungsionalitas keseluruhan dApps yang dibuat.

Ditambah lagi, ada faktor lain yang harus dipertimbangkan yakni kecepatan. Kecepatan adalah faktor penting dalam hal kegunaan aplikasi. Lantas bagaimana mungkin pengguna (end-user) akan menggunakan aplikasi jika tidak dapat digunakan sama sekali? Developer membutuhkan sejumlah pengguna untuk terus bisa menggunakan aplikasi mereka sebelum mencapai habis masanya.

Oleh sebab itu, inilah yang menyebabkan platform yang bisa diskalakan seperti NEAR sangat penting untuk diadopsi blockchain dan smart contract secara umum.

NEAR memungkinkan para developer untuk menanam aplikasi mereka tanpa perlu memikirkan tentang bagaimana infrastrukturnya beroperasi maupun dikembangkan layaknya infrastruktur cloud modern seperti Amazon AWS atau GCP atau Azure yang menggerakkan hampir semua aplikasi web saat ini.
Sejarah Singkat Tentang NEAR
NEAR dimulai pada musim panas 2018 saat Alex Skidanov dan Illia Polosukhin memutuskan untuk beralih dari aktivitas entrepreneurial yang mereka jalankan sebelumnya. Kamu bisa mempelajarinya lebih lanjut disini. Dengan cepat, saat Misha keluar dari MemSQL, tim semakin berkembang dari beberapa orang menjadi 9 orang dalam kurun waktu 3 hari di bulan Agustus. Tim awal mulanya terdiri dari 7 orang engineer, dimana Erik menjalankan operasional bisnis, dan Sasha mengurus hal yang berkaitan tentang market.

Sekarang, NEAR Collective adalah grup tim yang terdistribusi secara global, terdiri dari banyak organisasi dan kontributor individual, yang mampu mengatur diri mereka sendiri untuk menghidupkan teknologi ini. Ini bukanlah bisnis atau apa pun yang terlihat begitu formal. Anggap saja seperti sekelompok orang yang menjalankan proyek software open-source dengan skala besar.

Salah satu proyek Kolektif adalah menulis kode awal dan implementasi referensi untuk jaringan NEAR open source, ibaratnya seperti membangun pendorong roket di pesawat ulang-alik. Tugas mereka adalah melakukan pekerjaan riset dan pembangunan (R&D) yang diperlukan untuk membantu blockchain masuk kedalam orbit. Kode untuk rantai itu bersifat open source sehingga siapa pun dapat berkontribusi atau menjalankannya sendiri.

Penting untuk ditekankan bahwa jaringan seperti NEAR dirancang untuk sepenuhnya bisa terdesentralisasi. Ini berarti NEAR pada akhirnya beroperasi sepenuhnya sendiri dan tidak bisa disensor, dihentikan, atau dikacaukan oleh orang lain atau pihak ketiga. Bahkan tim yang menciptakannya pun tak akan bisa. Jadi, ketika anggota kolektif ini ada di sini untuk memulai membangun implementasi referensi, mereka akan menjadi tidak terlibat lagi untuk pengoperasian jaringan setelah mulai dijalankan. Faktanya, setelah siap diluncurkan, siapa pun dapat memodifikasi dan menjalankan kode NEAR Protocol untuk memulai blockchain mereka sendiri karena semuanya bersifat open source dan setiap perubahan harus diterima secara demokratis oleh validator independen yang menjalankannya.
Bagaimana Blockchain NEAR Bekerja
Blockchain merupakan teknologi yang dapat menyimpan catatan transaksi dengan aman di jaringan peer-to-peer alih-alih menyimpannya pada satu jenis lokasi. Server independen di seluruh dunia, yang disebut node, membentuk jaringan yang mengoperasikan jaringan blockchain.

Salah satu aspek yang paling menentukan dari teknologi blockchain adalah desentralisasi. Mengapa desentralisasi sangat bermanfaat? Mari kita lihat dari perspektif pengembang (developer) dan pengguna (end-user).

Developer: Di dunia yang tersentralisasi, developer sering kali bergantung pada platform cloud atau bahkan pemerintah untuk memastikan bahwa mereka dapat terus bisa menjalankan aplikasi. Di dunia yang terdesentralisasi, tidak ada perantara yang mendominasi.

End User: Transparansi dari aplikasi terdesentralisasi dapat memungkinkan pengguna untuk melihat kode backend dan tahu persis bagaimana jalannya aplikasi menggunakan informasi pribadi Anda.

Apa itu algoritma konsensus NEAR?

Protokol konsensus digunakan untuk mencapai kesepakatan tentang sebuah nilai (value) antara banyak pengguna dalam suatu sistem. Jika semua pengguna jaringan berkolaborasi sesuai dengan protokol konsensus, value baru dapat ditambahkan ke ledger dan diverifikasi oleh nodes. Namun dalam beberapa kasus, jaringan dapat berfokus pada keamanan atau kehidupan.

Mekanisme konsensus yang diterapkan pada NEAR disebut Nightshade. Nightshade memodelkan sistem sebagai satu blockchain. Daftar dari semua transaksi di setiap blok dibagi menjadi beberapa bentuk potongan (chunks), satu chunks per shard. Semua chunks terakumulasi menjadi satu blok. Perhatikan bahwa chunks hanya dapat divalidasi oleh node yang mempertahankan status shard tersebut.

Berbicara tentang validasi, komponen kunci dari NEAR adalah validator. Validator ini bertanggung jawab untuk menjaga konsensus dalam protokol. Validator adalah node khusus yang perlu menjaga server mereka online 100% sepanjang waktu sambil menjaga sistem mereka terus diperbarui.

Berikut adalah beberapa poin yang harus kamu pahami tentang validator jaringan.

 	NEAR menentukan validator jaringannya setiap epoch (~12 jam), memilih mereka berdasarkan jumlah kepemilikan mereka (stake).
 	Validator yang sudah terpilih didaftarkan ulang dengan secara otomatis mempertaruhkan ulang (re-staking) token mereka ditambah hadiah / kompensasi yang diperoleh
 	Validator potensial harus memiliki kepemilikan mereka di atas level yang ditentukan secara dinamis.
 	Ada dua metode yang dapat digunakan validator untuk memperkuat kepemilikan mereka yakni dengan  membeli token sendiri atau meminjam melalui delegasi kepemilikan.
 	Hadiah yang anda terima berbanding lurus dengan staking anda. Semakin banyak yang di stake, semakin banyak keuntungan yang diperoleh.

Konsensus didasarkan pada konsensus dengan rantai (chain) terbanyak. Artinya, setelah produsen blok menerbitkan blok baru, mereka mengumpulkan signature dari node validator. Bobot dari sebuah blok merupakan kepemilikan kumulatif dari semua signers dimana signature termasuk dalam blok tersebut. Berat dari chain adalah jumlah dari berat blok tersebut. Selain itu, konsensus menggunakan gadget finalitas yang memperkenalkan kondisi potongan ekstra untuk keamanan chain yang lebih tinggi.



	

	
	
		
			
				Bobot dari Sebuah blok adalah:
			
		

		
					

		
			
			
			
			Jumlah maksimum kepemilikan dari signers dimana signaturenya terdapat pada suatu blok
		
			
			Akumulasi dari kepemilikan semua signers dimana signaturenya terdapat pada suatu blok 
		
			
			Rata-rata dari kepemilikan semua jaringan dibagi dengan jumlah signers yang terdapat pada suatu blok
		
			
			Pernyataan diatas tidak ada yang tepat
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Runtime
Layer Runtime digunakan untuk mengeksekusi kontrak pintar dan tindakan lain yang dibuat oleh pengguna dan mempertahankan status di antara eksekusi. Hal ini dapat dijelaskan dari tiga sudut pandang yang berbeda: langkah demi langkah melalui berbagai skenario, menjelaskan komponen runtime, dan menggambarkan fungsi yang dijalankan oleh runtime.

Apa itu token NEAR?
Token NEAR merupakan native-asset fundamental dari ekosistem NEAR dan fungsinya diaktifkan untuk semua akun. Setiap token merupakan aset digital unik yang mirip dengan Ether yang dapat digunakan untuk:

 	Membayar sistem untuk bisa memproses transaksi dan menyimpan data.
 	Menjalankan node validasi sebagai bagian dari jaringan dengan berpartisipasi dalam proses staking.
 	Membantu menentukan bagaimana sumber daya jaringan dialokasikan dan ke mana arah teknisnya di masa depan dengan berpartisipasi dalam proses tata kelola (governance).

Token NEAR memungkinkan untuk koordinasi ekonomi dari semua pengguna yang mengoperasikan jaringan, dan juga memungkinkan aktivitas baru antar aplikasi yang dibangun di atas jaringan tersebut.
Bagaimana cara memulai menggunakan NEAR?
Account/Wallet
Sebelum memulai menggunakan NEAR, hal pertama yang harus kamu lakukan adalah membuat akun NEAR. 
Untuk lebih jelasnya, kamu bisa menonton video dibawah ini mengenai akun NEAR


Wallet memungkinkan anda melakukan panggilan kontrak ke blockchain, mengatur node lokal anda, dan mengirim dan menerima dana dari pengguna lain. Saat anda mendaftarkan ID Akun, anda harus memberikan nama yang unik. Meskipun setiap wallet harus memiliki nama yang unik, setiap pengguna dapat mengatur beberapa wallet.

Dapat dibayangkan ini mirip dengan akun Facebook atau Google. Setelah kita mendaftar ke salah satu layanan, kita dapat menggunakan akun yang sama untuk masuk ke layanan pihak ketiga. Perbedaan antara ID Akun NEAR dan akun Google adalah bahwa data, yang disimpan dengan ID Akun, hanya dapat diakses dan dikelola oleh pemilik wallet. Selain itu, semua informasi disimpan di jaringan node yang terdistribusi, bukan di satu server yang terpusat.

Buat akun NEAR kamu sekarang di : https://wallet.near.org/create

Info lebih lanjut tentang akun, bisa kunjungi : https://learnnear.club/doc/videos/accounts-keys/
NEAR Explorer
NEAR Explorer memungkinkan kita untuk melihat pembuatan blok secara langsung. Ini merupakan tools berguna yang membuat kita dapat mencari informasi terkait transaksi dan akun serta memungkinkan kita untuk melihat interaksi antara pengguna dan smart contract. 


Bagaimana cara mendapatkan Token NEAR?
Ada beberapa cara untuk mendapatkan token $NEAR

Anda bisa mendapatkan token $NEAR dengan mengambil bagian dalam hadiah pengembangan, dengan menjalankan komunitas yang membantu orang membangun di NEAR, dengan memenangkan hackathon NEAR atau menjadi bagian aktif dari komunitas. Jika anda dapat mengajak orang lain untuk meminjamkan tokennya kepada anda untuk distake, kamu bisa memperoleh $NEAR dengan menjalankan validator.

$NEAR juga tersedia di beberapa bursa utama kripto di mana kamu bisa mendaftar dan membeli token menggunakan mata uang fiat atau kripto.

Kita bisa melihat harga dan pasangan media tukarnya di coinmarketcap dan coingecko.

https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

Selain itu, bisa juga mendapatkan NEAR dari NEARdrop, mengikuti acara yang membagikan token NEAR secara cuma-cuma di beberapa kegiatan.

Ada beberapa cara untuk mendapatkan token $NEAR

Anda bisa mendapatkan token $NEAR dengan mengambil bagian dalam hadiah pengembangan, dengan menjalankan komunitas yang membantu orang membangun di NEAR, dengan memenangkan hackathon NEAR atau menjadi bagian aktif dari komunitas. Jika anda dapat mengajak orang lain untuk meminjamkan tokennya kepada anda untuk distake, kamu bisa memperoleh $NEAR dengan menjalankan validator.

$NEAR juga tersedia di beberapa bursa utama kripto di mana kamu bisa mendaftar dan membeli token menggunakan mata uang fiat atau kripto.

Kita bisa melihat harga dan pasangan media tukarnya di coinmarketcap dan coingecko.

https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

Selain itu, bisa juga mendapatkan NEAR dari NEARdrop, mengikuti acara yang membagikan token NEAR secara cuma-cuma di beberapa kegiatan.
Apa yang bisa saya lakukan dengan token NEAR?
Transfer

Kamu dapat menerima dan mengirimkan $NEAR ke akun teman dan akun pengguna lain dan melihat transaksi yang berjalan di Block Explorer. Karena biaya transaksi yang sangat rendah, kamu bisa dengan cepat dan mudahnya memindahkan saldo $NEAR dan menggunakannya.

Kamu bisa mengirimkan token $NEAR sebagai hadiah dengan menggunakan http://redpacket.near.org/

Kamu juga bisa mengundang orang lain untuk menggunakan near dengan NEAR Drop https://near.org/blog/send-near-to-anyone-with-near-drops/

Menggunakan aplikasi di NEAR

Kamu bisa menggunakan beberapa aplikasi yang dibangun diatas NEAR seperti yang ada pada list di sini

Melakukan jual beli NFT di Paras

Dan juga berpartisipasi membuat karya di BerryClub  
Berapa biaya yang dikeluarkan untuk menggunakan NEAR (Gas)?
Saat kita melakukan pemanggilan ke jaringan blockchain NEAR untuk memperbaharui atau mengubah data, orang yang menjalankan infrastruktur blockchain akan dikenakan biaya. Pada akhirnya, beberapa komputer di suatu tempat memproses permintaan kita, dan validator yang menjalankan komputer ini menghabiskan sejumlah modal untuk menjaga komputer ini tetap berjalan.

Seperti blockchain lain yang dapat diprogram, NEAR mengkompensasi orang-orang ini dengan membebankan biaya transaksi, juga disebut biaya gas.

Jika Anda terbiasa dengan penyedia layanan cloud web2 (Layanan Web Amazon, Google Cloud, dll), perbedaan besar dengan blockchain adalah pengguna akan langsung dikenai biaya saat mereka melakukan panggilan ke suatu aplikasi, tanpa membuat developer menanggung biaya penggunaan semua infrastruktur tersebut.

Ini menciptakan kemungkinan baru, seperti aplikasi yang tidak memiliki risiko jangka panjang untuk dihapus karena dana pengembang/perusahaan habis. Namun, ini juga dilengkapi dengan beberapa kecepatan penggunaan yang menonjol. Untuk membantu hal ini, NEAR juga menyediakan kemampuan bagi developer untuk menutupi gas fee bagi pengguna, untuk menciptakan pengalaman yang lebih familiar bagi mereka yang datang dari web2.
Ketika memahami tentang gas, ingatlah dua konsep dibawah ini:


 	Gas Price : unit gas kemudian dikalikan dengan harga gas (gas fee) untuk menentukan berapa banyak yang harus dibebankan kepada pengguna. Harga ini secara otomatis dihitung ulang setiap blok tergantung pada kebutuhan permintaan jaringan (jika blok sebelumnya lebih dari setengah maka harga akan naik, jika tidak maka akan turun, dan tidak akan berubah lebih dari 1% setiap blok), dan turun di harga yang dikonfigurasi oleh jaringan, saat ini 100 juta yoctoNEAR.
 	Gas Unit:  secara internal, biaya transaksi tidak dihitung secara langsung dalam token NEAR, tetapi melalui fase “unit gas” di antara keduanya. Manfaat unit gas adalah sifatnya yang deterministik – transaksi yang sama akan selalu menghabiskan jumlah unit gas yang sama.




	

	
	
		
			
				1 TeraGas atau TGas sebanding dengan :
			
		

		
					

		
			
			
			
			1 mikrodetik waktu komputasi
		
			
			10 detik waktu komputasi
		
			
			1 milidetik waktu komputasi
		
			
			1 nanodetik waktu komputasi
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Biaya Kegiatan Umum
Untuk memberi kita titik awal mengenai estimasi biaya di NEAR, tabel di bawah mencantumkan beberapa kegiatan umum dan berapa banyak TGas yang dibutuhkan saat ini, berapa biayanya dalam miliNEAR, dengan harga gas minimum 100 juta yN.

 



Kegiatan
TGas
Biaya (mN)
Biaya (NEAR)


Membuat Akun
0.42
0.042
4.2x10^-5


Mengirim Dana
0.45
0.045
4.5x10^-5


Stake
0.50
0.050
5.0x10^-5


Menambahkan Kode Akses
0.42
0.042
4.2x10^-5


Menghapus Key
0.41
0.041
4.1x10^-5



Bagaimana cara menghasilkan dengan NEAR?
Stake NEAR yang kamu miliki

Kunci dari model Proof-of-Stake (PoS) adalah bagaimana validator mendukung komunitas dengan cara Staking. Validator akan mendapatkan token NEAR sebagai hadiah karena mengoperasikan nodes yang menjalankan jaringan dalam bentuk tingkat inflasi sekitar 5% setiap tahunnya, menciptakan token baru untuk Validators setiap epoch (~12 hours) sebagai hadiah.

Validator harus mempertahankan jumlah minimum Stake untuk mempertahankan tempat mereka sebagai Validator. Pemegang Token dapat melakukan stake dengan Validator tertentu yang mereka yakini memiliki kinerja baik untuk jaringan, selain itu mendapatkan sebagian dari hadiah Token yang dihasilkan oleh jaringan juga. Ini mendorong pemegang Token untuk tetap terlibat dengan komunitas.

NEAR wallet saat ini memiliki antarmuka pengguna yang dipasang langsung ke dalam aplikasi web.

Untuk melakukan staking:

 	Pilih “Staking” dari navigation bar (dropdown di mobile phone)
 	Klik tombol “Select Validator”
 	Pilih validator yang sesuai
 	Konfirmasi pilihanmu dan pilih “Stake with Validator”
 	Masukkan jumlah NEAR yang akan di stake, dan klik “Submit Stake”

Anda membutuhkan konfirmasi daru dua transaksi, satu untuk memilih validator dan satu lagi untuk melakukan deposit dan stake dengan validator.

Untuk melakukan unstaking:

 	Pada laman staking, pilih validator yang sedang berjalan
 	Klik “Unstake” dan konfirmasi transaksi

Setelah 36 hingga 48 jam (4 full epochs), anda akan bisa menarik apa yang telah di stake. Untuk melakukannya, kembali ke laman validator dan pilih “Withdraw”




	

	
	
		
			
				Token baru dibuat sebagai hadiah setelah epoch yang kira-kira berlangsung setiap:
			
		

		
					

		
			
			
			
			12 menit
		
			
			12 detik
		
			
			12 hari
		
			
			12 jam
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Membangun DeFi di NEAR
Ekosistem DeFi (Keuangan Terdesentralisasi) saat ini sedang ramai diperbincangkan. Ethereum saat ini memiliki jaringan DeFi senilai lebih dari $100 miliar. Ketika diterapkan di NEAR, ekosistem DeFi ini masih baru dan sedang dikembangkan.



Menurut DeFiLlama, Total Value Locked (TVL) dari ekosistem NEAR kurang dari $100 juta, dengan Ref Finance sebagai pemimpin pasar. Fakta bahwa ekosistem DeFi Ethereum 1000X lebih besar dari ekosistem NEAR menunjukkan bahwa NEAR masih terlalu awal untuk DeFi nya. Faktanya, pada tahun 2021, NEAR Protocol telah mengumumkan inisiatif pendanaan sebesar $800 juta dimana mayoritas dana diatur untuk menumbuhkan sektor protokol DeFi.

Jika kamu ingin mempelajari lebih lanjut tentang ekosistem DeFi NEAR, kamu bisa mengaksesnya disini.
Ekosistem NFT yang berkembang di NEAR
Non-Fungible Asset (aset yang tidak dapat dipertukarkan) memiliki sifat yang berbeda atau sifat yang membedakannya dari aset lainnya. Non-Fungible Token (NFT) didasarkan pada aset yang tidak dapat dipertukarkan dan merupakan aset digital unik yang menggunakan teknologi blockchain. Saat ini, sektor ini tengah digandrungi dan meledak popularitasnya.

NEAR Protocol merupakan platform yang sempurna untuk NFT karena memiliki dua keunggulan utama dibandingkan Ethereum:

 	NEAR secara signifikan lebih cepat.
 	Ethereum memiliki biaya gas yang jauh lebih tinggi.

Faktor-faktor ini membuat NEAR ideal untuk membeli dan menjual NFT. Baca artikel ini untuk mengetahui lebih banyak tentang 3 proyek NFT teratas di NEAR.
Jadi, bagaimana sekarang? Bagaimana cara untuk berinteraksi dengan NEAR?
Baik, sekarang apa yang harus dilakukan sekarang? Jika anda sudah membaca sejauh ini, tentunya kamu akan mempelajari lebih dalam mengenai NEAR Protocol. Jadi, selanjutnya akan lebih baik jika kamu membaca NEAR Whitepaper. Jika kamu pengguna baru di blockchain dan mau mempelajari lebih lanjut mengenai teknologi ini, disarankan untuk menonton video terkait dekonstruksi dari ekosistem blockchain.

Jangan lupa untuk follow NEAR Discord dan NEAR Forum.

### LNC NFT Certificate Beta test

Requirements:
Follow @LearnNEAR on Twitter

Beta Test sprint starts: March 14, 11 am ET
Beta Test sprint ends: March 17, 11pm ET.
ToDo:

 	Complete Build on NEAR   course if you have not done before
 	Go to My Certificates and click on "Build on NEAR"

 	Sign in into minting Dapp with your NEAR testnet wallet

 	 Mint NFT Certificate
 	Make a screenshot at your testnet wallet and tweet:
I completed @learnnear community course "Build on NEAR" and minted my LNC NFT Certificate


Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy testing!

### NEAR 🤝 Ethereum 

Saat ini, Ethereum merupakan platform smart contract nomor satu di dunia kripto, dengan mayoritas smart contract dan berbasis aplikasi terdesentralisasi (dApps) berdasarkan blockchain-nya. Seperti Ethereum, ada beberapa platform smart contract lainnya di beberapa pasar lainnya juga.

Bagaimanapun juga hanya karena Ethereum merupakan platform nomor satu dalam hal smart contract dan DeFi, bukan berarti ini tidak memiliki masalah sama sekali. Ethereum memiliki satu permasalahan yang mencolok, yaitu masalah skalabilitas yang signifikan. Ini menyebabkan jaringannya tidak bisa diskalakan.

Di sinilah NEAR Protocol berperan. Poin unik yang menjual dari NEAR yaitu menggunakan mekanisme konsensus Proof-of-Stake yang menggunakan sharding. Sebelum kita menngetahui lebih lanjut, mari kita mengenal Ethereum dan NEAR.
Apa itu Ethereum?
Jika kamu membaca definisi Ethereum melalui websitenya seperti yang diterangkan:

“Ethereum adalah teknologi yang menjadi rumah bagi uang digital, pembayaran global, dan aplikasi. Komunitas telah membangun ekonomi digital yang berkembang pesat, cara-cara baru yang berani bagi pembuat konten untuk menghasilkan uang secara online, dan banyak lagi. Ini terbuka untuk semua orang, di mana pun Anda berada di dunia.”

Didirikan pada tahun 2015 oleh Vitalik Buterin, Ethereum telah memantapkan dirinya sebagai cryptocurrency terbesar kedua berdasarkan nilai kapitalisasi pasar, kedua setelah Bitcoin. Ethereum dibangun di atas blockchain dari Bitcoin, menjadikannya lebih dari sekadar cryptocurrency lain yang memungkinkan pengguna untuk mengirim atau menerima nilai tanpa intervensi dari pihak ketiga.

Ethereum memastikan desentralisasi dengan mengganti server pusat dengan ribuan nodes, memastikan bahwa platform selalu online dan bebas dari pengaruh pihak ketiga. Smart Contract  juga merupakan bagian integral dari ekosistem Ethereum, dan karena platform ini mendukung aplikasi terdesentralisasi dan smart contract, ini sangat menarik bagi pengembang dan pengguna.

Ethereum sekarang berpindah ke Ethereum 2.0 atau Serenity. Pembaruan terkini akan secara signifikan meningkatkan skalabilitas, efisiensi, dan kecepatan dari blockchain Ethereum. Selain itu, pembaharuan akan memungkinkan Ethereum untuk mengurangi biaya gas (gas fee) dan memproses lebih banyak transaksi, meningkatkan skalabilitas blockchain tanpa mengorbankan faktor keamanan.

Upgrade ini juga akan melihat Ethereum beralih ke mekanisme konsensus Proof-of-Stake. PoS akan melihat validator yang telah dipilih secara algoritmik memberikan keamanan ke platform. Validator akan mengamankan platform dengan mengunci ETH mereka. Setiap validator yang bertindak melawan kepentingan platform akan dipotong stake nya, untuk  memastikan keamanan platform.
Apa itu NEAR Protocol?
NEAR Protocol hadir pada musim panas 2018. Sebuah platform pengembangan terdesentralisasi dimana protokol ini dirancang untuk menciptakan lingkungan yang sempurna untuk aplikasi terdesentralisasi, dengan fokus pada kekurangan platform lain dalam smart contract  dan ruang dApp. Kekurangan ini rata-rata ditenggarai oleh masalah dengan kecepatan rendah, throughput rendah, dan kompatibilitas yang buruk dengan chain lain.

NEAR beroperasi di atas NEAR Protocol yakni blockchain Proof-of-Stake (PoS), dengan menggabungkan beberapa fitur dan inovasi untuk mengurangi biaya dan meningkatkan skalabilitas bagi pengguna dan pengembang. Selain itu, NEAR mengambil pendekatan unik untuk "Sharding."

NEAR juga memperkenalkan mekanisme pembuatan blok yang disebut "Doomslug" yang diusulkan pada tahun 2019. Doomslug memungkinkan finalitas praktis untuk memastikan bahwa blok menerima finalitas dalam hitungan detik.

Protokol ini didasarkan pada teknologi yang sama dengan Bitcoin, menggabungkannya dengan fitur-fitur seperti sharding database.NEAR Protocol dibangun dari awal dan merupakan jaringan yang paling mudah diakses oleh end user dan pengembang sekaligus memastikan skalabilitas dan keamanan.

Sebagian besar blockchain yang dapat diskalakan memusatkan pada pemrosesan, membatasinya pada perangkat keras kelas atas, yang memberikan dorongan sementara pada throughputnya, NEAR memungkinkan platform untuk menskalakan secara linier, hingga miliaran transaksi dengan cara yang sepenuhnya terdesentralisasi.

NEAR dikembangkan oleh NEAR Collective, sebuah komunitas pengembang dan peneliti yang berkolaborasi dalam membangun proyek. Beberapa fitur penting dari NEAR diantaranya adalah:

 	NEAR adalah sistem sharded yang memungkinkan skalabilitas tak terbatas
 	Protokol yang mudah digunakan, NEAR memungkinkan pengembang untuk membangun aplikasi dengan mudah dan cepat.
 	NEAR bukan side chain tetapi merupakan protokol Layer-1.
 	dApps yang dibuat menggunakan NEAR berjalan di atas lapisan NEAR yang mendasarinya.

Apa itu NEAR Collective?
NEAR Collective terdiri dari organisasi individu dan kontributor lain yang terus berupaya meningkatkan NEAR Protocol. The Collective bekerja pada proyek-proyek seperti menulis kode awal dan implementasi untuk Jaringan NEAR. NEAR sepenuhnya terdesentralisasi, beroperasi secara independen dan tidak dapat dimatikan atau dimanipulasi, bahkan oleh mereka yang membangunnya sendiri.

NEAR Collective memiliki anggota seperti NEAR Foundation. NEAR Foundation merupakan organisasi nirlaba yang berfokus pada penciptaan ekosistem yang dinamis di sekitar blockchain NEAR. Ini membantu dalam koordinasi kegiatan governance dan pengembangan. NEAR Collective memiliki beberapa proyek, dengan blockchain NEAR hanya salah satu dari beberapa proyek di bawah naungan kolektif.
Kenapa Blockchain Seperti NEAR Sangat Diperlukan?
Untuk memahami hal ini, pertama-tama kita harus memahami evolusi dari teknologi blockchain. Blockchain dapat dibagi menjadi tiga tahap atau generasi. Blockchain generasi pertama dirancang untuk menjadi mekanisme pembayaran sederhana. Bitcoin adalah contoh dari blockchain generasi pertama yang telah memantapkan dirinya di ruang crypto sebagai platform nomor satu. Namun, blockchain generasi pertama memiliki keterbatasan dalam hal transaksi yang kompleks.

Platform blockchain generasi kedua muncul dengan Ethereum dan konsep smart contract, memungkinkan pengembang untuk menggunakannya dan memprogram transaksi yang lebih canggih dan membuat dApps. Tetapi blockchain generasi kedua mengalami masalah skalabilitas yang parah. Misalnya, Ethereum hanya dapat memproses sekitar 25 transaksi per detik, jika dibandingkan  jumlah ini dengan platform utama seperti Visa atau PayPal, maka kamu dapatt melihat seberapa jauh ketertinggalannya Ethereum.

Ethereum telah mencoba untuk memperbaiki masalah skalabilitasnya dengan menerapkan solusi Layer-2 seperti protokol plasma, menciptakan lapisan tambahan yang berjalan bersama-sama dengan rantai utama. Namun, solusi Layer-2 masih belum mendapatkan daya tarik yang cukup.

Ini membawa kita ke NEAR, blockchain generasi ketiga. NEAR membuang gagasan bahwa setiap node di jaringan harus menjalankan seluruh kode karena tim percaya bahwa yang dilakukannya hanyalah menciptakan kemacetan. Sebagai gantinya, blockchain memperbaiki masalah skalabilitas dengan memanfaatkan teknik sharding, memungkinkan blockchain untuk meningkatkan kapasitas jaringan. Dan tidak seperti blockchain generasi kedua yang menggunakan solusi Layer-2, sharding adalah solusi Layer-1.
Apa itu Sharding?
Sebelum kita mulai lebih jauh, ayo kita memahami apa itu sharding. Terkadang sistem harus berurusan dengan banyak data. Hal ini mempengaruhi kinerja sistem, mengurangi throughput dan mempengaruhi kinerja sistem. Sharding mengatasi ini dengan mempartisi data secara horizontal, membuatnya lebih kecil, dapat dikelola, dan, yang lebih penting, lebih cepat untuk diproses.

NEAR dan Ethereum : Bagaimana Cara Kerja NEAR dan Ethereum?
Ethereum
Ethereum berfungsi lebih dari sekadar platform keuangan yang melakukan transaksi; itu juga mendukung aplikasi terdesentralisasi dan smart contract. Ethereum didasarkan pada teknologi blockchain dan menggunakan public ledger tempat dimana semua transaksi terverifikasi disimpan. Transaksi dapat diakses oleh siapa saja yang ingin melihatnya, memastikan transparansi lengkap sambil memastikan bahwa data yang disimpan di blockchain tidak dapat diubah atau dimanipulasi.

Blockchain Ethereum mirip dengan blockchain bitcoin dan bertindak sebagai public ledger yang menyimpan catatan semua transaksi dan riwayat smart contract. Relawan di seluruh dunia menyimpan salinan seluruh blockchain Ethereum, membuat blockchain sepenuhnya terdesentralisasi. Setiap kali tindakan seperti transaksi atau kontrak pintar terjadi di blockchain, semua node di seluruh dunia memprosesnya, memastikan bahwa aturan blockchain diikuti.

Semua node terhubung dan mengikuti aturan yang sama mengenai transaksi dan smart contract.. Node Ethereum juga melacak status semua aplikasi, saldo pengguna, dan kode smart contract, memastikan bahwa semua informasi selalu up-to-date.

Berkat Solidity, pengembang dapat menulis smart contract yang dapat mengelola transaksi di blockchain dan hasilnya. Smart contract berbeda dari kontrak tradisional karena mereka memastikan bahwa persyaratan kontrak terpenuhi. Selain itu, mereka secara otomatis mengeksekusi transaksi ketika serangkaian kondisi yang telah ditentukan terpenuhi, menghilangkan semua pihak ketiga yang terlibat dalam transaksi apa pun.
NEAR
NEAR menggunakan teknologi blockchain, sama seperti blockchain lainnya seperti Ethereum dan Cardano. NEAR bertindak sebagai blockchain dasar di mana aplikasi dapat dibangun dan digunakan. Ini menggunakan mekanisme konsensus yang dikenal sebagai Nightshade yang membantunya mencapai throughput yang tinggi. Mekanisme konsensus NEAR mengasumsikan bahwa transaksi dari semua pecahan bergabung untuk membuat blok, itulah sebabnya setiap pecahan mengirimkan segmen dari setiap blok. Segmen ini disebut chunk.

Validator dipilih secara acak kemudian memproses transaksi di beberapa rantai shard, meningkatkan kapasitas transaksi protokol NEAR. Chunk lalu diproses dan kemudian disimpan di blockchain ketika menyelesaikan transaksi.

NEAR tidak berjalan pada gagasan bahwa setiap node harus memproses seluruh kode. Sebaliknya, ini mengatasi masalah skalabilitas dengan menggunakan sharding. Melalui sharding, data dipartisi secara horizontal, sehingga lebih mudah dikelola dan lebih cepat diproses.
NEAR dan Ethereum : Mekanisme Konsensus
Ethereum
Saat ini, Ethereum menggunakan mekanisme konsensus Proof-of-Work (PoW), tetapi dengan Ethereum 2.0 di cakrawala, platform akan beralih ke mekanisme konsensus Proof-of-Stake. Proof-of-Stake akan diimplementasikan dengan protokol Casper, menciptakan ekosistem yang tidak dapat dipercaya. Sebelum sepenuhnya beralih ke mekanisme Proof-of-Stake, Ethereum akan menerapkan mekanisme konsensus PoW-PoS hybrid.

Mari kita memahami cara kerja Proof-of-Work dan Proof-of-Stake. Proof-of-Work mengharuskan miners bersaing satu sama lain, memanfaatkan sejumlah besar daya komputasi untuk memecahkan masalah matematika yang kompleks untuk memvalidasi transaksi. Setelah transaksi divalidasi, miners mendapatkan bayaran. Ethereum beralih ke mekanisme Proof-of-Stake karena Proof-of-Work memiliki beberapa masalah, seperti konsumsi energi yang tinggi. Peralihan ini juga dilakukan untuk mengatasi masalah skalabilitas Ethereum.

Dalam mekanisme konsensus Proof-of-Stake, validator mempertaruhkan ETH mereka, setelah itu mereka dipilih secara acak untuk membuktikan blok. Validator yang dipilih mengusulkan sebuah blok, sedangkan validator lainnya perlu membuktikan bahwa mereka telah melihat blok tersebut. Setelah mereka memvalidasi blok, itu ditambahkan ke blockchain, dan validator diberi hadiah. Dengan demikian, validator dihargai karena mengusulkan dan membuktikan blok.
NEAR
NEAR Protocol  telah menerapkan Nightshade Sharding sebagai mekanisme konsensus Proof-of-Stake mereka. Kita sudah membahas apa itu sharding, jadi kita bisa melewatinya. Namun, metode sharding yang digunakan saat ini memiliki masalah, seperti aturan pilihan fork di rantai shard dan beacon perlu dibangun dan diuji secara berbeda.

Namun, Nightshade memperlakukan sistem sebagai satu blockchain, dan setiap blok berisi transaksi untuk semua shard. Namun, peserta tidak perlu mengunduh status penuh, melainkan hanya mempertahankan status yang merupakan bagian dari shard yang mereka validasi transaksinya. Daftar semua transaksi di setiap blok dibuat, yang kemudian dibagi menjadi beberapa bagian, dengan setiap shard diberi satu shard.

Validator merupakan bagian penting dari NEAR Protocol untuk menjaga konsensus pada protokol. Oleh karena itu, mereka perlu memperbarui sistem mereka setiap saat sambil juga menjaga server mereka tetap online.

 	Validator dipilih dengan setiap epoch berdasarkan stake yang dimilikinya.
 	Validator dapat didaftarkan lagi dengan men-stake kembali token dan hadiah mereka.
 	Validator dapat memperkuat stake mereka dengan dua cara yaitu dengan membeli token atau meminjamnya melalui delegasi stake.

Token NEAR dan Ethereum
Token asli Ethereum, Ether, mendorong pemrogram untuk terus menjalankan protokol blockchain karena perangkat keras yang mendukung Ethereum sangat mahal dan menghabiskan banyak daya energi. Dengan demikian, miners dan pemrogram sama-sama dihargai dalam Eter karena memanfaatkan sumber daya mereka dan menjaga ekosistem Ethereum tetap aman dan berfungsi.

Pengembang juga menggunakan Eter untuk membayar sehingga mereka dapat meluncurkan smart contract  atau aplikasi terdesentralisasi di blockchain Ethereum. Ini juga digunakan untuk mengakses smart contract.

Native token NEAR yakni $NEAR, digunakan untuk memberi insentif kepada validator di jaringan. Token juga mendorong transaksi dan smart contract di blockchain. Karena NEAR adalah platform yang diatur komunitas, pemegang token memainkan peran penting dalam tata kelola platform NEAR, memberikan suara pada perubahan potensial pada platform NEAR.
Project pada Ethereum dan NEAR Protocol
Ethereum merupakan leader dalam hal aplikasi terdesentralisasi (dApps) dan keuangan terdesentralisasi (DeFi), dengan lebih dari 3000 dApps berjalan di blockchain-nya. Sebagian besar proyek Ethereum berfokus pada DeFi, memperluas penggunaan cryptocurrency untuk memenuhi penggunaan finansial yang lebih kompleks.

Beberapa proyek teratas di blockchain Ethereum diantaranya adalah:

 	Uniswap
 	MakerDAO
 	Chainlink
 	Aave

Meskipun mainnet NEAR diluncurkan kurang lebih baru setahun yang lalu, beberapa platform sedang dibangun diatasnya. Beberapa proyek di Protokol NEAR adalah:

 	Mintbase - Platform yang didedikasikan untuk menyederhanakan penerbitan dan penjualan NFT sekaligus membuat seluruh proses menjadi murah.


 	Flux - Flux merupakan protokol open-market terdesentralisasi. Ini diluncurkan di NEAR Protocol pada tahun 2020
 	Paras -  Paras merupakan NFT marketplace yang berfokus pada hasil karya artist dan kreator

Program Hibah NEAR, yang saat ini dioperasikan oleh NEAR Foundation, mendukung proyek-proyek yang memungkinkan pertumbuhan ekosistem NEAR.
AURORA di NEAR Protocol
Aurora juga telah diluncurkan pada NEAR Protocol, memberikan pengalaman Ethereum Layer-2 sebagai sebuah solusi yang memungkinkan pengembang untuk menjangkau pasar tambahan, Aurora memanfaatkan fitur yang ada di NEAR Protocol seperti remunerasi biaya gas dan sharding. Ini berjalan pada dua komponen penting, Aurora Bridge dan Aurora Engine.

Beberapa peningkatan yang dibawa Aurora adalah:

 	Kemampuan untuk memproses ribuan transaksi per detik, peningkatan 50x dari Ethereum.
 	Waktu finalitas blok 2 detik, dibandingkan dengan waktu konfirmasi blok tunggal 13 detik di Ethereum. Finalitas cepat juga mengurangi frontrunning attack.
 	Pertumbuhan ekosistem masa depan, pendekatan sharding protokol NEAR memungkinkan penskalaan EVM horizontal, dan komunikasi asinkron antara banyak shard.
 	Biaya di Aurora 1000x kali lebih rendah daripada di Ethereum. Sebagai contoh, Mentransfer token ERC-20 di Aurora berharga kurang dari $0,01, sedangkan di Ethereum, biayanya sekitar $5,40.
 	Aurora menawarkan kompatibilitas tanpa kompromi dengan Ethereum melalui Protokol NEAR.

Aurora memberikan solusi untuk tantangan yang dihadapi oleh ekosistem Ethereum, sambil mempertahankan smart contract dan kode front-end.
Manfaat dari NEAR Protocol
Solusi sharded dari NEAR memberikannya keuntungan besar dibandingkan platform lain seperti Ethereum dan Bitcoin, memecahkan masalah skalabilitas rendah dan kemacetan yang sering terjadi pada jaringan Ethereum. Dengan membuat protokol mereka di-shard, para pendiri NEAR memecah kode blockchain menjadi chunc-chunk yang dijalankan pada node paralel. Ini menghasilkan seluruh kode yang diproses dengan cepat dan membebaskan NEAR dari masalah skalabilitas berkat kemampuan untuk memecah kode ini.

NEAR Protocol  memiliki beberapa fitur unik yang menjadikannya proposisi yang menarik bagi pengguna dan validator yaitu:

 	UX yang fleksibel dan akses ke layanan yang berjalan di platform NEAR juga menampilkan proses orientasi yang mudah.
 	Karena protokol sharded NEAR, validator dapat bergabung dengan platform tanpa mengunduh perangkat lunak yang rumit. Mereka kemudian dapat memperoleh token dengan memvalidasi transaksi di jaringan.
 	NEAR memungkinkan bisnis untuk menyesuaikan izin bagi para penggunanya. Dengan pertumbuhan pasar yang stabil, pengembang juga mendapatkan akses ke basis pelanggan yang berkembang.

Jalan Kedepan untuk NEAR Protocol
Dengan peluncuran bridge dari Ethereum-ke-NEAR, juga disebut Rainbow Bridge, pengguna dapat menjembatani token Ethereum ERC-20 mereka ke NEAR, dan mulai menggunakannya dalam ekosistem aplikasi terdesentralisasi NEAR. Perkembangan ini merupakan langkah besar menuju visi tim pendiri untuk membuat platform dapat diakses semudah mungkin.

NEAR juga bekerja untuk mengimplementasikan dukungan Ethereum Virtual Machine (EVM). Setelah proses ini selesai, pengembang dapat menerapkan kembali dApps mereka di NEAR dengan sedikit perubahan, dan mengaktifkan peluncuran lintas chain.

NEAR Protocol  mengumumkan kemitraan dengan Chainlink, bersamaan dengan peluncuran Rainbow Bridge, yang memungkinkan interaksi NEAR dan Ethereum.
Kesimpulan
NEAR Protocol telah menunjukkan begitu banyak hal yang menjanjikan, memanfaatkan sharding untuk memecahkan masalah skalabilitas blockchain generasi kedua. Selain itu, NEAR secara signifikan meningkatkan throughput tanpa mengorbankan faktor keamanan platform.

Berkat NEAR Collective, ratusan engineer dan pengembang blockchain bekerja untuk meningkatkan protokol 24/7. NEAR juga meluncurkan mainnetnya, dan jaringannya siap mendukung dApps dan layanan lainnya. Dengan fokusnya untuk memastikan bahwa Platform NEAR mudah digunakan untuk validator, end-user, dan pengembang, NEAR telah muncul sebagai kekuatan di ruang platform smart contract.

Ethereum, di sisi lain, telah mempertahankan posisinya di atas takhta berkat komunitas pengembangnya yang patut ditiru dan ekosistem DeFi dan NFT yang berkembang pesat. Kedua protokol ini menyediakan platform yang brilian bagi pengembang untuk membangun ekosistem terdesentralisasi di masa depan.

### Crypto Best Practices: Những lời khuyên để có trải nghiệm tuyệt vời trong thế giới tiền mã hóa

Thế giới tiền mã hóa có thể khiến nhiều người choáng ngợp, ngay cả với những người nhiều kinh nghiệm trong lĩnh vực này. Và khi tiền mã hóa trở nên ngày càng phổ biến, những rủi ro với tài sản của bạn cũng sẽ tăng lên theo cấp số nhân. Những nhà đầu tư vào tiền mã hóa ngày càng quan tâm hơn tới khía cạnh bảo mật và sự an toàn cho tài sản của mình. Mặc dù tiền mã hóa hay các loại tài sản điện tử được bảo vệ bởi những nền tảng mà chúng được dùng để giao dịch, nhà đầu tư hay người dùng vẫn nên chủ động hơn trong vấn đề bảo vệ tài sản của mình.

Người dùng cần phải nắm được những hiểu biết căn bản về tiền mã hóa trước khi đầu tư vào lĩnh vực này. Một trong những khía cạnh bạn cần phải biết chính là vấn đề pháp lý về tiền mã hóa tại đất nước của bạn để từ đó hiểu được tính pháp lý của mỗi loại tiền mã hóa cũng như cách để bạn tiếp tục đầu tư một cách hợp pháp. Hãy tham khảo những lời khuyên trong bài viết này để bạn luôn bảo vệ được tài sản điện tử của mình cũng như có những trải nghiệm thật tuyệt vời trong thế giới tiền mã hóa.
Những rủi ro tiềm ẩn đối với người dùng tiền mã hóa 
Những biến động là một phần không thể thiếu trong thế giới tiền mã hóa. Bất kỳ cá nhân nào đầu tư vào lĩnh vực này cũng cần nhận thức rõ những biến động này để giảm thiểu rủi ro đầu tư. Bên cạnh đó, còn có một số mối đe dọa tới khoản đầu tư của bạn như:

 	Hoạt động rửa tiền
 	Lừa đảo đầu tư thông qua hình thức ICO
 	Lừa đảo bơm thổi và bán phá giá (pump dump scam)
 	Sàn giao dịch tiền mã hóa lừa đảo
 	Các hình thức tấn công giả mạo (Phishing scam)

Ngoài ra còn có những rủi ro gây ra bởi các hacker. Nhà đầu tư luôn phải cảnh giác với khả năng bị lừa đảo, trộm cắp và thất thoát tài sản. Ở phần tiếp theo, bài viết sẽ đưa ra một số cách mà nhà đầu tư có thể áp dụng để bảo vệ tài sản kỹ thuật số của mình cũng như có khả năng trải nghiệm thế giới tiền mã hóa một cách tốt nhất.




	

	
	
		
			
				Đâu KHÔNG phải là chiến lược đúng đắn trong đầu tư tiền mã hóa?
			
		

		
					

		
			
			
			
			Nghiên cứu kỹ vấn đề pháp lý ở quốc gia của bạn trước khi đầu tư
		
			
			So sánh thật kỹ càng các sàn giao dịch tiền mã hóa và tìm ra sàn phù hợp nhất cho bạn
		
			
			Tìm kiếm những đồng coin thay thế Bitcoin, Ethereum
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Những lời khuyên thực tế để có một trải nghiệm tiền mã hóa mượt mà
Tài sản kỹ thuật số của bạn có thể bị xâm phạm qua một số con đường như ví trữ tiền, sàn giao dịch, hay seed phrase. Sau đây là một số cách đơn giản mà bạn có thể áp dụng.
Luôn sử dụng mật khẩu mạnh
Khi sử dụng sàn giao dịch để giao dịch tiền mã hóa, bạn sẽ được yêu cầu tạo một tài khoản. Bạn bắt buộc phải bảo mật tài khoản giao dịch này bằng mật khẩu mạnh bao gồm các số và ký tự đặc biệt. Mật khẩu mạnh là lớp phòng thủ đầu tiên của bạn chống lại bất kỳ nhóm hoặc hacker nguy hiểm nào. Bạn cũng nên sử dụng những trình quản lý mật khẩu, cho phép bạn tạo và ghi nhớ các mật khẩu phức tạp. Bạn có thể sử dụng trình quản lý mật khẩu như Dashlane để giúp bạn tạo mật khẩu an toàn. Nên thay đổi mật khẩu thường xuyên và sử dụng trình quản lý mật khẩu, như đã đề cập ở trên, kết hợp với công nghệ Xác thực hai lớp (2-factor authentication).




	

	
	
		
			
				Đâu là những rủi ro tiềm ẩn với nhà đầu tư tiền mã hóa?
			
		

		
					

		
			
			
			
			Lừa đảo đầu tư qua hình thức ICO
		
			
			Bơm thổi giá và bán phá giá
		
			
			Rửa tiền
		
			
			Tất cả các ý trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Sử dụng xác thực hai lớp 2FA
Cùng với việc tạo một mật khẩu mạnh, hãy áp dụng 2FA khi sử dụng các sàn giao dịch tiền mã hóa. Thay vì sử dụng xác thực SMS, bạn có thể sử dụng các ứng dụng như Google Authenticator hoặc Authy. Lý tưởng nhất là hãy sử dụng 2FA mạnh nhất được nền tảng cho phép. Các loại khóa bảo mật phần cứng như Yubikey cũng rất tốt. Nếu bạn không có lựa chọn ngoài 2FA dựa trên SMS, bạn nên sử dụng thêm mã-dùng-một-lần (OTP) được gửi đến thiết bị di động của bạn mỗi khi bạn đăng nhập vào tài khoản giao dịch tiền mã hóa của mình.
Bảo vệ khóa cá nhân (private keys) của bạn
Để lưu trữ tiền mã hóa của mình, bạn sẽ cần một chiếc ví chứa các khóa công khai và khóa riêng tư của bạn để gửi, nhận và lưu trữ tiền mã hóa. Mặc dù khóa công khai của bạn được chia sẻ với những người dùng khác, bạn tuyệt đối không được chia sẻ khóa riêng tư của mình với bất kỳ cá nhân hoặc tổ chức nào. Nếu ai đó có quyền truy cập vào khóa cá nhân của bạn, thì bạn hoàn toàn có thể mất tất cả số tiền có trong ví của mình. Bạn có thể bảo mật khóa của mình bằng cách làm theo một vài bước đơn giản sau:

 	Sử dụng một khóa hoặc cụm mật khẩu ngẫu nhiên
 	Duy trì quyền kiểm soát các khóa của bạn và tuyệt đối không cho sàn giao dịch tập trung nào nắm giữ chúng
 	Sử dụng ví cứng

Sử dụng ví lạnh
Như chúng ta đã biết, ví tiền mã hóa được chia thành hai loại, ví nóng và ví lạnh. Ví nóng mang lại sự dễ dàng và đơn giản nhưng cũng dễ bị tấn công. Mặc dù bạn có thể dễ dàng truy cập vào tiền mã hóa của mình, nhưng chúng cũng dễ bị tấn công bởi các mối đe dọa bảo mật như việc bị hack. Ví lạnh được hầu hết các chuyên gia tiền mã hóa khuyên dùng, đặc biệt nếu bạn có ý định giữ tiền mã hóa của mình trong một khoảng thời gian dài. Ví lạnh về bản chất là một ví ngoại tuyến, có nghĩa là tài sản của bạn được lưu trữ ngoại tuyến, đảm bảo tài sản của bạn khỏi bất kỳ nỗ lực tấn công nào. Ví lạnh đảm bảo an toàn hoàn toàn khỏi các mối đe dọa mà bạn thường phải đối phó khi sử dụng ví nóng. Ví dụ về ví lạnh là ví cứng và ví giấy.
Kết hợp nhiều giải pháp
Việc áp dụng phương pháp kết hợp đòi hỏi phải sử dụng cả ví nóng và ví lạnh. Khi sử dụng phương pháp này, bạn có thể lưu trữ ngoại tuyến tiền mã hóa của mình khi chúng không được giao dịch. Khi thực hiện giao dịch, bạn chỉ cần chuyển tài sản bạn định bán vào ví nóng của mình, hoàn tất giao dịch và sau đó chuyển tài sản của bạn trở lại ví lạnh.
Sử dụng VPN (Mạng riêng ảo)
Một điều cực kỳ quan trọng là sử dụng kết nối internet an toàn khi truy cập vào tài khoản và thực hiện các giao dịch tiền mã hóa. Tuyệt đối không bao giờ thử và thực hiện giao dịch khi dùng mạng WiFi công cộng và ngay cả khi sử dụng mạng gia đình, bạn nên sử dụng VPN để tăng cường bảo mật. Sử dụng VPN sẽ giúp giữ an toàn cho hoạt động duyệt web của bạn trước các tin tặc tiềm ẩn hoặc các phần mềm độc hại. Điều quan trọng nữa là phải bảo mật thiết bị cá nhân của bạn, thiết bị mà bạn sẽ sử dụng để thực hiện giao dịch. Cập nhật phần mềm cho thiết bị của bạn thường xuyên và đảm bảo rằng bạn không nhấp vào bất kỳ liên kết độc hại nào hoặc truy cập bất kỳ trang web độc hại nào.
Đừng bỏ tất cả trứng vào cùng một giỏ
Cũng giống như thị trường chứng khoán truyền thống, đa dạng hóa là chìa khóa trong đầu tư ở thị trường tiền mã hóa. Là một nhà đầu tư, đa dạng hóa luôn có lợi cho danh mục đầu tư tiền mã hóa của bạn. Thay vì bỏ tất cả tiền của mình vào, chẳng hạn như BTC, đầu tư vào cả BTC, NEAR và một số loại tiền mã hóa khác có thể giúp bảo vệ bạn khỏi sự biến động tiềm ẩn của thị trường đồng thời cho phép bạn hưởng lợi từ nhiều nguồn khi thị trường đi lên. 
Tìm hiểu kỹ trước khi đầu tư
Trước khi đầu tư vào tiền mã hóa, điều quan trọng là phải hiểu loại tài sản mà bạn chuẩn bị đổ tiền vào, cách sử dụng và cách nó hoạt động. Hầu hết mọi đồng tiền mã hóa đều có sẵn các sách trắng(whitepaper) trực tuyến, đây là nơi giúp bạn hiểu rõ hơn về chúng và nâng cao kiến thức về tiềm năng của dự án. Nếu dự án không có sẵn tài liệu chính thống nào hoặc nếu tài liệu chính thống không đề cập hay mô tả hoạt động của đồng tiền mã hóa đó thì tốt nhất nên tránh đầu tư vào dự án như vậy.
Thời gian cũng là chìa khóa tới thành công
Cũng giống như việc thẩm định kỹ tài sản mà bạn muốn đầu tư, thời gian cũng được coi là một yếu tố quan trọng khi đầu tư vào thị trường tiền mã hóa. Bạn cần phải có hiểu biết về tiền mã hóa, sau đó phải có khả năng sắp xếp thời gian đầu tư của mình một cách phù hợp. Thị trường tiền mã hóa luôn biến động và sự thay đổi giá là điều rất thường thấy. Đừng quay cuồng đầu tư vào các đồng tiền mới để tìm kiếm Bitcoin tiếp theo hoặc Ethereum tiếp theo. Luôn tìm hiểu kỹ về dự án trước khi đầu tư, theo dõi các biểu đồ giá và theo dõi tin tức để đón đầu các sự kiện có thể tác động tiêu cực đến giá trị khoản đầu tư của bạn (sàn bị hack, thao túng giá). tiền mã hóa có tính đầu cơ cao, vì vậy hãy luôn nghiên cứu đủ kỹ và đủ sâu trước khi bỏ tiền vào đầu tư.
Kiểm tra kỹ các giao dịch
Các giao dịch trên blockchain là không thể thay đổi, có nghĩa là một khi được thực hiện, chúng không thể bị đảo ngược. Điều này khiến cho việc kiểm tra kỹ tất cả các chi tiết trước khi thực hiện giao dịch là cực kỳ quan trọng. Số tiền của bạn chỉ có thể được hoàn trả lại cho bạn nếu bên đối diện đồng ý làm như vậy.
Đừng bao giờ đầu tư với số tiền nhiều hơn khả năng chi trả của bản thân
Đây là một trong những điểm quan trọng nhất mà bạn cần lưu ý khi muốn trở thành một nhà đầu tư. Mặc dù tiền mã hóa có thể được coi là nơi trữ tiền an toàn, và chúng thậm chí được sử dụng bởi công dân của các quốc gia như Venezuela, nơi đang quay cuồng với siêu lạm phát, nhưng tiền mã hóa là một khoản đầu tư rủi ro cao với sự biến động lớn. Bạn có thể có lãi vào buổi sáng nhưng hoàn toàn có thể cháy tài khoản vào buổi chiều. Nếu bạn là người mới bắt đầu, sẽ là hợp lý nếu bắt đầu bằng cách đầu tư một số vốn nhỏ.
Kết luận
Tiền mã hóa là một lĩnh vực đầu tư rủi ro cho người mới bắt đầu và kể cả những người có kinh nghiệm. Theo nguyên tắc chung, các khoản đầu tư rủi ro cao chỉ nên chiếm một phần nhỏ trong danh mục đầu tư. Trong trường hợp của tiền mã hóa, hãy đa dạng hóa các khoản đầu tư của bạn để chúng có thể tăng giá hoặc giảm giá ở các mức độ khác nhau, giúp bạn có một sự an toàn nhất định.

Những điểm được đề cập ở trên thường được coi là chiến thuật cơ bản nhất mà bạn có thể sử dụng để có được trải nghiệm tiền mã hóa tốt nhất. Thế giới tiền mã hóa liên tục thay đổi và bạn phải chủ động trong việc đảm bảo an toàn cho các khoản đầu tư và tài sản của mình bằng cách bảo mật kỹ lưỡng tài khoản và ví. Luôn cập nhật cho mình những tin tức và sự phát triển mới nhất trong không gian tiền mã hóa.




	

	
	
		
			
				Sử dụng mật khẩu mạnh, bảo mật 2FA, dùng ví lạnh, hay sử dụng VPN là những lời khuyên hữu ích khi đầu tư và giao dịch tiền mã hóa?
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!

### Top 5 game trên NEAR

NEAR Protocol là nền tảng hợp đồng thông minh tập trung vào tính thân thiện với nhà phát triển và người dùng. Với GameFi và các game trên blockchain đang trở thành xu hướng lớn tiếp theo, hãy cùng tìm hiểu một số tựa game đã ra mắt trên NEAR sau đây:

 	Chain Typing
 	Pixel DApps: Pixelparty, Pixelpets và Cryptoheroes.
 	Lands

Chain Typing
Chain Typing là một trò chơi dạng play-to-earn (chơi để kiếm tiền) giúp bạn cải thiện khả năng đánh máy. Bạn cần phải sở hữu một nhân vật để chơi game, và nhân vật này sẽ được hiển thị trên Leaderboard. Ban đầu, trò chơi sẽ chỉ có 30 nhân vật có sẵn ban đầu. Khi Chain Typing mở rộng quy mô, sẽ có nhiều nhân vật có thể chơi được hơn. Các nhân vật có thể được sử dụng như một dạng quảng cáo vì có khả năng chứa mô tả.



 

Các khoản đóng góp sẽ được chuyển vào quỹ của Chain Typing giúp tiếp tục phát triển game. Phí đúc nhân vật cũng được quyên góp vào quỹ của game và không được hoàn lại.
Pixel DApps


Pixel DApps đã tạo ra ba game cho hệ sinh thái của NEAR, đó là:

 	Pixelparty
 	Pixelpets
 	Cryptoheroes

#1 Pixelparty


PixelParty là một trong những trò chơi của Pixel Dapps. Đây là dự án hiển thị các NFT dưới dạng khung ảnh, tổng nguồn cung cấp là 600 token. Cùng với đó, bạn phải lưu ý những điều sau:

 	Mỗi token mà bạn sở hữu cho phép bạn vẽ trên khung kích thước 20x20 pixel.
 	Người dùng có thể mua các khung khác nhau để vẽ ra một khung lớn hơn.
 	Tất cả những người sở hữu khung đều nhận được phần thưởng từ hệ sinh thái của pixeltoken.
 	Những người sở hữu khung hoạt động với số lượng khung nhất định có thể tham gia vào DAO.

Đây là cách tham gia vào PixelParty:

 	Kết nối với ví NEAR của bạn.
 	Chọn và mua một trong những khung có sẵn.
 	Khung của bạn sẽ nằm trong phần sidebar của trang web.
 	Bạn có thể tự do vẽ, chỉnh sửa hoặc bán chúng trên các chợ mua bán.

#2 Pixelpets


PixelPets là một game do Pixel DApps tạo ra để giao dịch hoặc chiến đấu cùng thú cưng của bạn. Đây là một trò chơi NFT, trong đó mỗi token đại diện cho một trong 60 loại vật nuôi khác nhau. Ngoài ra, mỗi vật nuôi có một trong bốn đặc điểm về độ hiếm: phổ biến, hiếm, sử thi và huyền thoại. Những đặc điểm này ảnh hưởng đến các thuộc tính khác nhau của vật nuôi như sức mạnh, chất lượng và cấp độ. Trong PixelPets, bạn có thể:

 	Hatch: Thu thập trứng vật nuôi và ấp chúng. Bạn chỉ có thể ấp một quả trứng tại một thời điểm. Độ hiếm của thú cưng càng cao, thời gian nở trứng càng lâu.
 	Huấn luyện: Bằng cách huấn luyện thú cưng của mình, bạn có thể nâng cấp rank. Bạn có thể huấn luyện thú cưng của mình bằng cách gửi chúng đến phòng tập thể hình - the gym.
 	Tiến hóa: Sau khi đạt đủ điểm kinh nghiệm và đạt được cấp độ mong muốn, thú cưng của bạn có thể tiến hóa lên cấp độ tiếp theo trong buồng tiến hóa - evolution chamber.
 	Chiến đấu: Trải nghiệm cày kéo bằng cách đấu tay đôi với các thú cưng khác. Bạn cũng có thể chiến đấu trong đấu trường và giành được giải thưởng và danh dự.
 	Thị trường: Mua và bán vật nuôi của bạn với pixeltoken.

#3 Cryptoheroes


Trò chơi thứ ba được tạo bởi Pixel DApps là Cryptoheroes - một trò chơi dựa trên blockchain tập trung vào PvE looting, giao dịch và rèn vật phẩm, đồng thời đánh boss với bạn bè để kiếm PXT token. Vào ngục tối, đánh bại tay sai và thu thập chiến lợi phẩm.

Làm thế nào để bạn kiếm được PXT:

 	Lập nhóm với đồng minh của bạn để tham gia raid, đánh bại những tên trùm độc ác và cạnh tranh để nhận phần thưởng PXT hàng tuần.
 	Thu thập các vật phẩm mạnh mẽ và bán chúng trên thị trường.
 	Bạn cũng có thể forge (hợp nhất) các vật phẩm của mình để cải thiện đồ hiện có của mình.

Làm thế nào để bạn tham gia vào các raid (cuộc đột kích)?

 	Mỗi raid có 8 người chơi.
 	Các raid diễn ra hàng tuần.
 	20 raid hàng đầu được thưởng mỗi tuần.

NEAR Lands


NEAR Lands là trò chơi dựa trên blockchain 2D nhiều người chơi và phi tập trung. Bạn, với tư cách là một người chơi, có thể đi bộ xung quanh hoặc xây dựng game thế giới mở được pixel hóa. Người chơi có thể:

 	Tạo nhân vật và vật phẩm của riêng họ.
 	Nói chuyện với bạn bè.
 	Tương tác với những người tham gia khác trong vũ trụ trực tuyến.
 	Người chơi có thể khám phá cảnh quan và tạo ra một vương quốc riêng của mình.

Kết luận
Hệ sinh thái game trên NEAR vẫn còn non trẻ, nhưng nó đã cho thấy rất nhiều điều hứa hẹn. Vì vậy, hãy dành sự chú ý tới các dự án mới hơn đang được xây dựng trên NEAR.

### 7 PROYEK NFT TERBAIK DI ATAS NEAR PROTOCOL

Pertumbuhan sektor DeFi telah membawa inovasi NFT menjadi ke arah mainstream, dan perkembangan pesat NFT pulalah juga menimbulkan masalah-masalah baru yang butuh perhatian khusus. Jaringan blockchain Ethereum saat ini memonopoli sektor tersebut, dengan banyaknya proyek berbasis NFT diciptakan di atas jaringannya. Permasalahan apakah yang timbul dengan menciptakan NFT di atas jaringan paling popular di dunia? Masalahnya adalah sangat tingginya gas fee (biaya penggunaan jaringan blockchain) di dalam jaringannya. Ethereum mempunyai masalah yang sangat besar apabila berbicara mengenai gas fee yang dapat mencapai ratusan Dollar, hal tersebut menjadikannya sangat tidak praktis.

Apakah ada opsi lain untuk NFT dan proyek-proyek berbasis NFT?  Adakah pilihan lain? NEAR Protocol mempunyai beberapa proyek penting di atas platformnya, dan sering digadang-gadang sebagai Ethereum killer. NEAR Protocol adalah jaringan blockchain berfitur skalabilitas, yang memudahkan dan mempercepat pengembangan dari dApps. Saat ini ada 19 platform terdesentralisasi di atas NEAR blockchain, dan beberapa marketplace  untuk menciptakan (mint) dan berdagang NFT. NEAR Protocol mempunyai keunggulan signifikan jauh di atas Ethereum, jauh lebih cepat, dengan biaya gas fee yang amat sangat murah, menjadikannya sebagai platform ideal untuk perdagangan NFT.
NEAR Protocol dan NFT
NEAR Protocol adalah platform terbaik untuk NFT dikarenakan berbagai kelebihannya dibandingkan dengan Ethereum. Protokol ini jauh lebih cepat dan di samping itu, Ethereum juga bermasalah dengan tingginya gas fee. Faktor-faktor tersebut menjadikan NEAR ideal untuk perdagangan NFT.Seperti yang disebutkan sebelumnya, sudah ada proyek-proyek berbasis NFT yang dibangun di atas jaringan blockchain NEAR. Namun, sebelum kita membahas proyek-proyek tersebut, mari kita bersama-sama memahami konsep dan pengertian tentang NFT.
Arti dari Non-Fungible
Sebuah aset fungible adalah aset yang dapat ditukarkan dengan aset lain yang mempunyai persamaan yang identik. Bitcoin adalah contoh sempurna atas sebuah aset fungible, artinya pengguna bisa menukarkan 1 Bitcoin dengan 1 Bitcoin lainnya tanpa ada masalah berarti. Di sisi lain aset Non-fungible adalah aset yang mempunyai keunikan. Contoh sebuah aset non-fungible dapat berupa sebuah lukisan atau sebuah barang koleksi dengan jumlah terbatas. 

Sebuah Aset non-fungible mempunyai keunikan tersendiri yang membedakan dari aset-aset non-fungible lainnya. Non-Fungible Token diciptakan berbasis aset non-fungible digital unik di atas sebuah jaringan blockchain.
Apa itu NFT?
NFT adalah aset-aset digital yang mempunyai keunikan tersendiri, dengan identitas informasi masing-masing keunikan tercatat di dalam sebuah smart contract (kontrak pintar). Informasi di dalam smart contract tersebutlah yang menjadikan sebuah NFT mempunyai keunikan. Aset fungible seperti Bitcoin dapat dipertukarkan, artinya pengguna dapat mengirim dan menerima tanpa ada kendala. Aset Fungible juga tidak dapat dipecah, sederhananya pengguna tidak dapat mengirim ke pengguna lain, sebagai bagian dari lukisan atau hanya sebagian dari tiket.

NFT adalah sertifikat digital atas kepemilikan sebuah aset digital. Sebuah NFT adalah sebuah smart contract yang difungsikan terkait dengan sesuatu aset digital. Sekali dicatat di atas jaringan blockchain maka smart contract tersebut akan diterbitkan menjadi sebuah token (contohnya token dengan tipe ERC-721 di atas Ethereum). Apapun bisa dijadikan menjadi sebuah NFT, contoh paling populer adalah file JPEG, video atau GIF. 




	

	
	
		
			
				Berikut ini yang manakah adalah NFT?
			
		

		
					

		
			
			
			
			Bitcoin
		
			
			Mata Uang Fiat
		
			
			Koleksi Digital
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proyek NFT di atas Near Protocol
Saat ini ada beberapa platform NFT dan proyek berbasis NFT di atas NEAR, mari kita lihat beberapa yang populer di antaranya.
Mintbase
Mintbase didirikan tahun 2018 oleh Nate Geier dan Caroline Wend. Nate menjabat sebagai CEO, sementara Caroline sebagai COO yang ahli dalam manajemen dan pengembangan bisnis. Mintbase meraih $1 Juta USD dalam pendanaan awal pada tahun 2020 yang dipimpin oleh Sino Global, beserta venture capital lainnya seperti Block Oracle Capital, D1 Ventures dan beberapa angel investor lainnya.

Fish Woman by From my Dream

Platform Mintbase memungkinkan pengguna untuk menerbitkan (minting) dan menjual NFT NEAR. Pengguna dapat minting beragam aset digital, dari artwork , kupon FnB hingga tiket acara. 

Mintbase juga memungkinkan siapa saja asal dengan mempunyai akses internet untuk minting dan bisa menjualnya (listing) baik di platform marketplace Mintbase di atas NEAR atau marketplace lainnya seperti OpenSea (menggunakan Ethereum). Pengguna Mintbase dapat menciptakan smart contract di atas platform tersebut dan membatasi jumlah transfer dari NFT yang diciptakan. Hal ini adalah fitur untuk mencegah pemalsuan atau transfer ilegal dari sebuah aset yang unik. Mintbase lebih menitikberatkan fokus untuk menciptakan pengalaman baru dan unik dalam menciptakan NFT,seperti yang sudah dijelaskan, mendukung beragam kategori aset digital. Berlawanan dengan platform lainnya yang menitikberatkan fokus kepada 1 kategori NFT saja.
Mengapa Mintbase pindah dari Ethereum ke NEAR ?
Jawabannya adalah gas fee. Di atas Ethereum, gas fee menjadi sesuatu yang sangat mahal. Dalam proses minting NFT melalui aplikasi Mintbase , pengguna sebelumnya harus menciptakan sebuah toko digital atau lapak digital terlebih dahulu menggunakan smart contract yang sudah disediakan dan tentunya hal tersebut menggunakan gas fee dengan Ethereum. Awalnya gas fee masih terjangkau, pengguna dapat membuat toko digital dengan cepat. Namun dengan meledaknya pertumbuhan pengguna di dalam jaringan Ethereum, nilai gas fee perlahan-lahan mulai meningkat ditambah dengan cacatnya mekanisme traffic di dalam jaringan Ethereum, menyebabkan membuat toko digital menjadi sangat mahal hingga membutuhkan ratusan dollar. Hal tersebut memaksa Mintbase untuk memberikan informasi kepada para penggunanya agar bersabar menunggu nilai gas fee turun sebelum menciptakan sebuah toko. Tidak dalam waktu lama, Ethereum menjadi tidak efektif dalam menciptakan ataupun melakukan jual beli NFT.

Mintbase melihat NEAR sebagai platform jaringan protokol yang lebih baik dibandingkan Ethereum, dengan gas fee yang jauh lebih signifikan murah dikarenakan model eksekusi smart contract yang lebih efisien. Dimana NEAR juga mempunyai fitur Nightshade, sebuah pencapaian yang lebih dinamis di dalam hal pemecahan distribusi jaringan (blockchain sharding) .  Namun selain itu, ada hal lainnya mengapa Mintbase memilih pindah ke NEAR.

 	Penggunaan Rust atau AssemblyScript untuk smart contract di atas NEAR memudahkan developer untuk menulis code pemrograman
 	NEAR mempunya fitur alamat yang dapat dibaca pada umumnya, baik untuk alamat akun wallet maupun alamat smart contract
 	Developer mudah masuk ke dalam NEAR, melalui NEAR Drops. Mereka dapat membayar untuk akun NEAR mereka dan langsung mengirim token NEAR
 	Developer dan pengguna dapat memindahkan aset antar jaringan blockchain ETH - NEAR dan sebaliknya melalui dApp Rainbow Bridge.
 	Platform DeFi yang populer di Ethereum seperti Aave dan Balancer akan berada di NEAR dalam waktu dekat, memudahkan integrasi yang mudah di masa depan.




	

	
	
		
			
				Mengapa Mintbase memutuskan untuk pindah ke NEAR?
			
		

		
					

		
			
			
			
			Gas Fee yang sangat tinggi
		
			
			NEAR adalah platform yang lebih baik
		
			
			Developer dapat memindahkan aset secara cepat
		
			
			Semua di atas.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras didirikan dengan visi menyediakan solusi untuk mengatasi peremajaan berkaitan dengan aset koleksi kartu (collectible cards). Platform ini memberikan validasi kepemilikan aset koleksi melalui teknologi blockchain melalui transaksi yang murah dan kencang. Platform ini memberikan fokus kepada penciptaan koleksi kartu berbasis kripto yang nantinya bisa dikembangkan lagi ke arah medium lain yang lebih menonjol.

PunkyPoN#0006 by monztre.near

Paras adalah marketplace terlengkap untuk koleksi kartu digital yang dibangun di atas NEAR. Platform ini memvalidasi kepemilikan dan memberi akses kepada user untuk menciptakan dan melayani transaksi perdagangan. Dengan kapasitas transaksi yang cepat dan biaya gas fee uang murah, Paras juga memberi perbedaan dari marketplace lainnya dengan menawarkan koleksi yang terdiri dari beberapa seri, dibandingkan hanya dengan single release. Hal unik yang membedakan Paras dari yang lain :

 	Paras mengurangi beban pemeliharaan kepada kolektor dengan menjamin bahwa koleksi mereka akan tidak dimakan waktu. Platform ini menyingkirkan batas-batas antara creator atau seniman dan para kolektor dengan memberi akses market berbasis digital. Dengan NEAR Protocol, Paras mengurangi biaya dari para creator atau seniman untuk menjual kreasi kartu mereka.
 	Paras mengembangkan sistem vertikal bagi para seniman, gamer dan insan kreatif untuk penciptaan kartu koleksi digital mereka agar bisa berkesinambungan dengan sebuah tema atau hikayat. Dengan metode ini, koleksi kartu digital di Paras sangat kaya dengan latar belakang dan narasi.

Paras menggunakan pendekatan dengan kurasi dan menciptakan komunitas berbasis NFT. Paras secara konsisten memastikan kualitas dari para artist dalam berbagai format. Para artist dapat menciptakan sebuah koleksi kartu baru di dalam Paras setelah melalui proses kurasi. Dan jumlah artist baru dibatasi hanya 30 setiap minggunya. Artist juga dipastikan harus memenuhi persyaratan medium mereka dengan rasio standar 64:89.




	

	
	
		
			
				Apakah itu Paras?
			
		

		
					

		
			
			
			
			Sebuah marketplace yang mencakup semua yang berhubungan dengan karya seni digital
		
			
			Platform smart contract
		
			
			Sebuah bahasa pemrogramman
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Semenjak diluncurkan, para artist di Paras telah mendapatkan lebih dari $25,000 USD, dimana platform sanggup memfasilitasi volume perdagangan lebih dari $35,000 USD lebih dari 700 transaksi. Platform tersebut mempunyai 80 kolektor aktif dan lebih dari 70 artist. Gas Fee yang murah menyebabkan batasan yang lebih rendah, memberi keuntungan kepada para artist tanpa harus khawatir terhadap biaya minting.
Mengapa NEAR sangat cocok untuk Paras?
Karena tingginya permintaan di dalam blockchain Ethereum dan hal tersebut menyebabkan timbulnya biaya yang sangat tinggi, memaksa para creator NFT yang baru terjun mencari alternatif dan solusi. NEAR wallet sangat efisien dan transaksi diselesaikan hampir secara instan disamping itu transaksi di atas NEAR sangat murah. Dan kedepannya Rainbow Bridge memastikan antara transaksi lintas jaringan antar NEAR dan Ethereum.
(L)Earner NFT
Learn NEAR Club juga akan menerbitkan koleksi PFP kami sendiri yaitu NEAR NFTs - (L)Earner Genesis Edition. Proyek ini akan kami luncurkan pada pertengahan February dan kami sudah memulai kolaborasi dengan salah satu graphic designer yang mendapatkan penghargaan tingkat global untuk menambah tingkat keberhasilan proyek kami. Kami percaya proyek ini akan menyebabkan perubahan secara masif di ranah NEAR NFT. Detail lengkap mengenai (L)Earner NFT termasuk biaya minting akan segera kami umumkan.

Pengguna dapat berlangganan di sini untuk mendapatkan early access untuk minting. Dan tentunya, pengguna wajib menjadi anggota LNC dan menyiapkan nLEARNs untuk partisipasi.
Hip Hop Heads
Hip Hop Heads menandai masuknya kultur amerika ke dalam ranah kripto. Seri kolaborasi artwork ini menampilkan karya Andre LeRoy Davis, pencipta The Last World dari The Source Magazine dan juga menampilkan animasi latar dari salah satu pemilik The Source Magazine, Ed Young.

Hip Hop Heads lahir dari kolaborasi antara Universal Hip Hop Museum, NEAR Protocol dan Ed Young. Bersama-sama mereka memutuskan untuk menciptakan koleksi NFT yang menampilkan para musisi hiphop dari tahun 70an hingga saat ini. Koleksi ini diberi judul NFT.HipHop  akan menampilkan 47 rapper legendaris dan memperingati 47 tahun era Hip Hop. Proyek ini menghubungkan kembali cikal bakal rap dengan teknologi terkini.

HipHopHead 10.292.22166

Setiap edisi menampilkan periode spesifik dalam industri hiphop, dan setiap NFT mempunyai penawaran sendiri-sendiri. Edisi 1 menampilkan periode 1973-1974, Edisi 2 menampilkan periode 1974-1975, dan seterusnya hingga 2021. Koleksi ini akan dilelang setiap harinya hingga tanggal 24 July.
Mengapa Hip Hop Heads memilih NEAR ?
NEAR Protocol memberikan kemudahan dan akses yang lebih mudah kepada khalayak luas. Seperti disebutkan sebelumnya, setiap harinya koleksi akan dilelang hingga tanggal 24 Agustus dan bisa dibeli menggunakan kartu kredit. Ini membuat proyek lebih dapat diterima dengan menggunakan NEAR. Lelang di dalam marketplacenya juga memberikan fokus lebih kepada fitur-fitur yang ada di atas NEAR Protocol, seperti interface yang familiar dan bersahabat mirip dengan Web2.0 , kemudahan dan harga minting yang relatif murah, dan aksesibilitas kepada end-user.

Dikarenakan disini pengguna dapat membeli NFT menggunakan kartu kredit, ini menjadikan hal yang amat sangat mudah untuk memiliki NFT tanpa prosedur yang rumit. Royalti untuk NFT di atas NEAR Protocol tertulis dalam code pada smart contract tersebut, yang memberi keuntungan atas royalti kepada creator apabila NFT tersebut dijual kembali oleh pemilik awalnya kepada pemilik baru (secondary marketplace) walau di marketplace lainnya. Hal tersebut dimungkinkan karena standarisasi contract pada NEAR Protocol. NEAR memberi para artist dan creator kendali atas hasil karya NFT mereka, menguntungkan mereka dari hasil karya mereka.
NPunks
Setelah kesuksesan Cryptopunks, Solpunks dan TPunks, NEAR akhirnya memiliki versi sendiri dari proyek tersebut, yang diberi judul Npunks. Seperti proyek Punks pendahulunya, akan ada 10,000 NPunks yang unik dengan perbedaan sendiri-sendiri. Koleksi ini memiliki 9 Alien, 24 Ape, 88 Zombie dan 111 Bots.



Untuk menghindari pengepul atau bandar dan memastikan partisipasi yang adil antar pengguna, semua pengguna memiliki kesempatan untuk membeli satu atau lebih NPunks. Pembelian bersifat acak dan setiap NFT adalah rahasia hingga semua minting awal selesai, setelahnya pengguna bisa menjual NPunks mereka.
NEAR Misfits
NEAR Misfits adalah koleksi NFT kriptografi yang pertama. Koleksi ini terdiri dari 1600 Normi, 150 Zombie, 101 Skellies, 50 Meerkats dan 22 Glitch Misfits. Pada bulan November 2021 sebanyak 1,923 Misfit terjual habis dalam rentang waktu 36 jam. Saat ini pengguna dapat mendapatkan NEAR Misfit di marketplace seperti Paras dan Mintbase


NEARNauts
NEARNauts adalah NFT berbasis komunitas yang dihasilkan secara acak bertujuan memiliki komunitas yang loyal dan organik. Daftar atribut kelangkaan memastikan keunikan setiap NFT (verifiable uniqueness). VRF atau Verifiable Random Function di dalamnya terdiri dari 3 algoritma - penciptaan (generated), pembuktian (proof) dan verifikasi (verification).

 	Generated : menciptakan 2 pasang kunci (keys) - satu secret key (SK) dan satu public key (pk)


 	Proof : mengambil SK dan message (x) untuk menghasilkan sebuah hasil acak (random output / y) dan sebuah bukti (proof)
 	Verification : algoritma ini mengambil pk, x dan y dan menggunakan proof untuk verifikasi dan validasi sebuah output.

NEARNauts Community DAO akan diluncurkan pada kuartal 1 tahun 2022 (Q1,2022)



The NEARNauts Community DAO will go live in Q1, 2022.
Kesimpulan
NEAR Protocol memberi kemudahan, kecepatan dan biaya yang murah terhadap dApp yang dibuat dan diluncurkan di atasnya dibandingkan dengan protokol jaringan blockchain lainnya dan adalah proyek dengan masa depan yang terjamin di ranah kripto saat ini. NEAR memecahkan beragam masalah yang dihadapi pada proyek di atas Ethereum, seperti mahalnya biaya gas fee dan masalah kecepatan transaksi. Dan juga mempunyai ragam keuntungan lainnya berkat solusi pemecahan data dalam blockchainnya (sharding)

NEAR Protocol menunjukkan kemajuan yang signifikan, dengan fitur Sharding untuk memecahkan masalah yang dihadapi pada jaringan blockchain lainnya. Dengan pendekatan ini NEAR mampu menaikkan jumlah kecepatan (throughput) tanpa harus mengorbankan keamanan jaringan. NEAR Collective juga memastikan setiap engineer dan developer akan konstan bersama-sama bekerja untuk kemajuan NEAR Protocol.

### NEAR NFT Marketplaces

With the growth of blockchain technology, we have seen several new use cases that are driving blockchain adoption, helping it move into the mainstream. In 2021, we saw the rise of NFTs as a new use case of blockchain technology. NFTs caught the eye of the blockchain space resulting in their soaring popularity as users scrambled to get their hands on them. A measure of their popularity can be gauged by the sale of an NFT art collection by Beeple that sold for a staggering $69 million. 

With the staggering success of NFTs, we have seen several artists, musicians, and other creators dive into NFTs. We have seen artists such as Grimes and bands such as The Rolling Stones and Kings of Leon hop on to the NFT bandwagon by selling tokenized versions of their songs, album art, and digital and virtual merchandise. With so much attention on them, NFTs are a hot topic, and it is essential to understand them and how you can buy or sell them through an NFT marketplace such as the NEAR NFT marketplace. But first, we must understand the definition of an NFT.
What Is An NFT? 
An NFT can be described as unique digital assets that have their identifying information stored on smart contracts. This is the information that makes each NFT unique. Because each NFT is unique, they cannot be exchanged with one another like fungible items such as fiat currency or even BTC. NFTs are also indivisible, unlike fungible items, which can be divided into smaller assets or amounts and then sent to others. For example, you cannot sell half a painting or half a train ticket to anyone. The same logic applies to an NFT, with each unique NFT containing a unique set of data that cannot be divided or traded. 

NFTs are based on two types of token standards on the Ethereum blockchain, the ERC-721 token standard and the ERC-1155 token standard. Both token standards ensure that the asset in question will act in a certain way, allowing developers to easily deploy their NFTs using these token standards while also ensuring compatibility with services and the crypto ecosystem. However,  several other blockchains such as EOS, NEAR, and Tron have now released their own token standards to attract developers and create NFTs on their platforms. 
History Of NFTs
We’ve already discussed what an NFT is above. However, where did NFTs originate from? The first minted NFT can be traced to 2014, when Kevin McCoy minted the first NFT titled “Quantum” on 3rd May 2014, much before the explosion of NFTs and the crypto art space. The Quantum NFT can be described as a pixelated image, consisting of an Octagon filled with circles, arcs, and other shapes. All the shapes share the same center, with the larger shapes surrounding the smaller ones.

Going deeper into history, NFTs were fueled by cultural phenomenons such as CryptoPunks and CryptoKitties. However, the history goes much further than just these. In 2012, we saw the emergence of “colored coins,” which can be credited with the idea of NFTs. These colored coins were initially issued on Bitcoin’s blockchain. Then in 2014, Counterparty emerged, created on the Bitcoin blockchain and allowing asset creation. In 2016 we saw the emergence of Rare Pepes and, shortly after that, CryptoPunks, which led to the NFT boom, thrusting NFTs into the mainstream and capturing the public’s imagination at large.




	

	
	
		
			
				Which of the following is true about NFTs? 
			
		

		
					

		
			
			
			
			An NFT is a unique digital asset that has its identifying information stored on smart contracts 
		
			
			An NFT is an asset that is divisible and can be divided and shared or distributed to other individuals 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What Is An NFT Marketplace?
Just as you require a marketplace to purchase most items, both in the real and digital worlds, an NFT marketplace allows users to buy, sell, trade, display, or mint (create) their own NFTs. Think of an NFT marketplace as an eBay or an Amazon, but exclusively for NFTs. Pretty much anyone can use an NFT marketplace, but to access these marketplaces, a user requires the following 

 	A user account on the NFT marketplace that will allow you to purchase the NFT from a particular platform.
 	A crypto wallet that is compatible with the blockchain that you intend to buy the NFTs on. For example, if you plan to use the Ethereum blockchain to buy or sell your NFTs, you will require a compatible wallet such as MetaMask. If you plan to use Solana, you would require a wallet compatible with Solana, such as Sollet. 

NFT marketplaces are crucial because they bridge buyers and sellers and offer users a host of tools enabling them to create their own NFTs within minutes. Artists can use the marketplace to put up their NFTs for sale, and buyers can browse the marketplace, purchasing the item through a process of bidding. 
Popular NFT Marketplaces 
There are several NFT marketplaces that you can choose from depending on your requirements. Universal NFT markets are extremely popular, while other niche marketplaces exist for specific NFTs that could consist of collectible cards, virtual land digital worlds such as Decentraland, or even certain in-game items and collectibles. Some of the most popular NFT marketplaces are 

 	OpenSea
 	SuperRare
 	Rarible 
 	Mintable
 	Nifty Gateway 

How OpenSea’s Rise Fueled NFTs  
OpenSea has established itself as the leader and is the largest NFT marketplace, hosting and providing support for all sorts of digital assets. The marketplace was initially used as a marketplace for the popular game, CryptoKitties. However, it has since expanded far beyond just collectibles and is a marketplace for various assets such as music, in-game assets, and collectibles, digital collectibles, art, etc. OpenSea is responsible for driving the growth of NFTs on NFTs and NFT projects such as CryptoKitties, CryptoPunks, Ethermon, and others, all of which were launched in 2017, the same year as OpenSea, which led to the marketplace leading the charge of NFTs into the mainstream. 




	

	
	
		
			
				Which are the token standards used for NFTs? 
			
		

		
					

		
			
			
			
			ERC-721 and ERC-1155
		
			
			ERC-20
		
			
			ERC-725
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The NEAR Protocol 
The NEAR Protocol was founded in 2018 and is a decentralized development platform that creates a perfect environment for smart contracts and decentralized applications. NEAR focuses on the shortcomings of other protocols in the same space, such as Ethereum, easily rivaling the capabilities of the number one platform for Decentralized Finance and Decentralized Applications. NEAR addresses one of Ethereum’s most glaring shortcomings, that of scalability. It does this through a process called “sharding.” Sharding allows the NEAR protocol to scale up exponentially. 

NEAR uses a Proof-of-Stake blockchain that uses sharding and is developer-friendly. NEAR is low-cost and highly scalable, allowing developers to create decentralized applications easily. NEAR also introduces Doomslug, which allows blocks to achieve finality in mere seconds. The protocol uses the same technology as Bitcoin, combining it with other features such as sharding. The NEAR protocol scales linearly, allowing it to support billions of transactions in a decentralized manner. 

NEAR also consists of several unique NFT platforms as more and more projects choose the NEAR protocol to launch their projects. NEAR’s collaboration with Ed Young saw the platform launch portraits of iconic figures from the history of hip-hop. NEAR’s Arterra platform allows fan engagement for influencers, sports teams, and streamers, allowing fans to collect NFTs from their favorite creators. Another project on NEAR is Pixelparty, consisting of 600 tokens, with each token a representation of a subframe of a Pixelparty Frame. Another project on NEAR is Metamon, which allows users to collect NFT-based monsters. Users can also combine two monsters, evolving them into more powerful and rarer NFTs. 

NEAR allows users to access several protocols that range from DAOs, DeFi, and NFTs, with a vibrant ecosystem that has several projects up and running. Because our focus is on NFT marketplaces, we will look at NFT projects on the NEAR protocol, namely Paras, Mintbase, and TenK. 
Mintbase 


Source: NEAR

Created by Nate Geier and Caroline Wend in 2018, Mintbase allows users to create and sell NEAR NFTs. These NFTs could be anything ranging from crypto art to digital assets and everything in between. Anyone with access to the internet can create an NFT on Mintbase and sell it on the NEAR NFT marketplace or sell it on other marketplaces such as OpenSea or other marketplaces. Mintbase allows creators to smart contracts, limiting the transferability of tokens minted. This helps to reduce fraud or the illegal transfer of NFTs significantly. 

Mintbase made the switch from Ethereum to NEAR thanks to the high gas fees on the former. Gas fees became so high that Mintbase had to ask users to wait for gas prices to drop before deploying a store. With significantly lower gas fees, NEAR was and continues to be the perfect platform for Mintbase. The protocol is able to achieve lower gas fees due to an efficient contract execution model. NEAR also uses a dynamic approach to sharding called Nightshade, giving it a considerable advantage over other platforms such as Ethereum. 
Paras

Source: NEAR

Paras is a digital art card marketplace created on the NEAR protocol. The protocol is different from other marketplaces because it exclusively offers collections instead of single releases. Paras takes its inspiration from trading cards in the real world, with its NFTs similar to those of sports cards collections other trading cards of popular franchises such as Pokemon. Unlike other marketplaces, especially those on Ethereum that allows users to upload pretty much anything, Paras takes a more measured approach to NFTs. 

To create on Paras, artists have to apply, with only 30 artists approved every week. Artwork created by the artists must comply with Paras’ aspect ratio of 64:89 while also containing specific information related to the artwork. Paras chose NEAR because it offered quick transaction speeds low transaction fees. Another major factor why Paras chose NEAR was because of the Rainbow Bridge, which enables the transfer of ETH to NEAR, allowing the seamless purchase of NFTs. 

Recently, Paras launched Boom Boom, a mini-comic series exclusively created for the NEAR ecosystem. The protocol also launched its first comic, Paradigm, with the first three issues available for free, while subsequent releases will be priced at $0.3 NEAR per issue. 
TenK 


Source: Twitter

 

Mintbase and Paras are considered the more prominent NFT platforms available on the NEAR protocol. However, there is a third project available on NEAR, called TenK. TenK can be described as an open-source generative art platform that brings a host of NFT artwork to the NEAR protocol. The protocol is already launching several prominent projects on NEAR. TenK is the protocol behind NEAR Misfits, which launched in 2021. NEAR Misfits is the first cryptographically complete profile picture collection based on the NEAR protocol. 
Closing Thoughts 
The NEAR Protocol has made the minting of NFTs and NFT marketplaces far easier than Ethereum, allowing it to become one of the most promising and sought-after protocols in the crypto space. NEAR takes Ethereum head-on, providing solutions for long-standing issues such as a lack of scalability, slow transaction and processing speeds, and extremely high gas fees. NEAR has become a successful alternative to Ethereum, with new projects flocking to the protocol and others switching from Ethereum to NEAR. Other projects such as Paras and TenK already operate on NEAR.




	

	
	
		
			
				What shortcomings of Ethereum does NEAR address? 
			
		

		
					

		
			
			
			
			High gas fees 
		
			
			Scalability
		
			
			Slow transaction speeds 

		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!

### dForm Beta Testers Feedback

Requirements:
Follow @LearnNEAR on Twitter

Beta test sprint starts: March 6, 8 pm ET
Beta Test sprint ends: March 10, 11pm ET.

dForm: https://www.d-suites.com/form
How to use dForm
Participate as a Form Owner:
1. Login
2. Create dForm
3. Share the dForm link to other participant
4. See the analysis
5. Export csv
6. Take a screenshot
7. Tweet about this with a screenshot "I just created  a Form at dForm, project from @LearnNEAR LNC Barrel" +link your form
Participate as a Form User:
1. Login
2. Using the dForm invitation link to join form
3. Fill the form
4. Take a screenshot
5. Submit entry
6. Tweet about this with a screenshot "I just filled a Form at dForm, project from @LearnNEAR LNC Barrel"
7. Fill the feedback form (edited)
Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy testing!

### Crypto Hero - Game trên NEAR

Crypto Hero là gì?

Crypto Hero là một trò chơi dựa trên công nghệ blockchain, chủ yếu tập trung vào chế độ chơi PVE (Player versus environment) - Nơi bạn có thể đi vào các ngục tối và trao đổi vật phẩm với những người chơi khác, cũng như chơi với những người bạn của mình trong hệ thống raid - nơi bạn có thể kiếm được những Pixel Token hàng tuần.

Ý tưởng được lấy cảm hứng từ những trò chơi nhập vai truyền thống, cũng như những trò chơi nhập vai hành động như Diablo.



Nó đang cố gắng triển khai những cơ chế từ những trò chơi một cách đơn giản nhất có thể, cho phép trải nghiệm hợp lý nơi mà những người chơi có thể phát triển các kỹ năng của họ, cạnh tranh với những người chơi khác, quan trọng nhất là kiếm được tiền.

Trò chơi bao gồm có 5 thành phần, tôi sẽ liệt kê cụ thể dưới đây

Tai sao bạn nên chơi Crypto Hero?

Crypto Hero là phần trò chơi thứ 2 trên PixelDapps và không phải là cuối cùng - một nhóm đã sản xuất thành công các trò chơi blockchain nơi những người chơi tìm thấy có hội kiếm giải thưởng trong lúc vui chơi giải trí. Mã thông báo hiện tại đang ổn định và phát triển, là thời điểm hoàn hảo để đầu tư sớm.

Ngoài ra, Crypto Hero rất thú vị. Nó tạo ra một hệ thống phát triển từ trò chơi nhập vai lên một cấp độ mới với những vật phẩm NFT được thu thập và giao dịch trong cộng đồng trước hết là kết nối các ý tưởng và nguyện vọng trong hệ sinh thái.

Làm thế nào để chơi Crypto Hero?

Luật chơi Crypto Hero

Khi nào có thể chơi Crypto Hero?

Bản Mainet phát hành vào ngày 22/1/2022

Bạn có thể chơi Crypto Hero ở đâu?

Chơi Crypto Hero tại đây

 	

 	The Auction House - Nhà đấu giá

Các vật phẩm có thể được trao đổi trong nhà đấu giá với các mã thông báo Pixel

Bạn có thể lọc các vật phẩm theo các danh mục và các loại trang bị khác nhau để dễ dàng tìm kiếm hơn.



 	

 	The Items - Các vật phẩm

Tướng của bạn có thể được trang bị lên tới 6 vật phẩm khác nhau: 1 vũ khí, giáp bảo vệ, giầy, 1 vòng cổ, 1 nhẫn và một mũ bảo hiểm.

Các vật phẩm được xác định theo độ hiếm: thông dụng, hiếm, sử thi và huyền thoại.

Các vật phẩm có thể được rơi ra khi chạy trong ngục tối, ngục tối càng sâu thì vật phẩm rơi ra càng tốt.

Các vật phẩm làm cho tướng của bạn mạnh mẽ hơn.




 	

 	The Hero - Tướng

Tướng của bạn có Máu, Cấp độ và Kinh Nghiệm

Tướng của bạn có thể được nâng cấp độ khi nhận đủ kinh nghiệm

Tướng có cấp độ càng cao thì sức mạnh có được cũng càng cao.



 	

 	The Dungeon - Ngục tối

Bạn có thể gửi tướng của mình khám phá ngục tối, nơi đó anh ta sẽ đối mặt với rất nhiều sinh vật.

Bạn có thể chọn mức độ ngục tối bạn muốn tới,  ngục càng sâu sẽ mang lại những chiến lợi phẩm tốt và nhiều kinh nghiệm hơn, nhưng độ khó cũng tăng theo số nhân,

Khi bạn đánh bạn ngục tối, bạn có thể được thưởng vật phẩm và kinh nghiệm và phải đợi một khoảng thời gian để vào chơi một lần nữa.



 	

 	The Ranking Ladder - Bảng xếp hạng

Bảng xếp hạng hiển thị vị trí level cao nhất + những vật phẩm cấp độ cao nhất trong trò chơi, tạo ra kịch bản cạnh tranh giữa những người chơi.



 	

 	 The Raids - Những cuộc đột kích

Hệ thống đột kích là nơi thúc đẩy giúp người chơi kết nối với nhau, cũng là phần kiếm tiền chính của trò chơi. Bạn có thể tạo nhóm lên tới 7 người để chiến đấu với boss với độ khó khác nhau và phần thưởng cũng khác nhau.

### Игра Land to Empire

Land to Empire — это стратегическая игра на Near Protocol. Действие игры разворачивается в фэнтезийном мире, где игрок является властелином земли. В Land to Empire игроки должны улучшать свои земли, используя ресурсы, полученные от нападения на земли других игроков или производства их на своей земле. Для атаки игроки тренируют разные виды войск, используя ресурсы. 
Как можно начать играть? 

 	Начать играть можно бесплатно (без возможности вывода ресурсов в свой Near кошелек, без возможности продавать NFT на внутриигровом рынке). В дальнейшем можно выкупить свою землю за 8 Near и продолжить развивать свою деревню, также после выкупа станут доступны все возможные операции (вывод средств, продажа NFT и т.д.)
 	Покупка за 8 Near. Вы получите голую землю с ратушей 1-го уровня и начнете развивать свою деревню. Доступны все возможные операции (вывод средств, продажа NFT и т.д.)
 	Покупка за 16 Near Premium земля (кол-во ограничено, 10 000 земель). В чем заключается смысл покупки данной земли, вы рандомно (зависит от вашей удачи) получаете уже прокаченную землю от 4-го и выше уровня, с постройками которые включает в себя данный уровень. Плюс Premium земли — это время на развитие, которое вы сэкономите! После продажи всех Premium земель, доступна будет только бесплатная игра и покупка за 8 Near.

Во всех 3-х вариантах Вам будут предоставлены 2 строителя из 5-ти, с помощью которых вы будете улучшать все свои здания. В игре всего можно иметь 5 строителей, но остальных 3-х Вам в любом случае нужно будет купить за кристаллы (gem). 
Ресурсы
Ресурсы — это валюта, используемая для покупки и улучшения.

В Land to Empire есть 3 основных ресурса: золото, эликсир и драгоценные камни.

Эти ресурсы производятся и хранятся в соответствующих зданиях.



 	Золото — можно использовать для постройки и улучшения оборонительных сооружений и ловушек, защищающих деревню игрока от нападений других игроков, а также для постройки и улучшения зданий. Золото используется для улучшения защиты, стен, сборщиков и хранилищ эликсира, а также ратуши. (В основном оборонительные вещи.) Золото (небольшое количество) также используется для поиска рейдов.



 	Эликсир — используется для обучения и улучшения войск и заклинаний. Эликсир и золото — два взаимодополняющих ресурса в Land to Empire. Эликсир используется для улучшения казарм, армейских лагерей, фабрики заклинаний, лаборатории, сборщиков и хранилищ золота. Эликсир также используется для создания войск и заклинаний, а также для их улучшения в лаборатории.



 	Драгоценные камни (гемы) — это премиальный жетон. Жетон премиум-класса GEM используется для ускорения строительства и модернизации. GEM можно получить, проходя уровни и выполняя различные задания.


 	 Драгоценные камни можно использовать для покупки других ресурсов, таких как золото и эликсир, в различных количествах.
 	   Можно использовать для усиления или завершения обучения Войск в Казармах и Темных казармах.
 	 Можно использовать для мгновенного завершения строительства или улучшения Зданий, улучшений в Лаборатории и Звездной Лаборатории.

Постройки


В игре доступны постройки, они разделяются на группы в зависимости от их функций.

 	Ресурсные постройки -  Золотые Шахты и Сборщики Эликсира. Золотохранилище и Эликсирохранилище служит для хранения добываемых ресурсов. Ратуша тоже имеет емкость для хранения ресурсов. 
 	Защитные постройки - Башни лучниц, Пушки, Мортиры, Башни колдунов, Воздушная оборона.  В Land to Empire иметь сильную защиту также важно, как и иметь сильное войско для нападения. Во многих случаях оборона играет очень важную роль. Оборона служит для защиты трофеев и защиты ресурсов от вражеских войск. Каждая защита имеет свои сильные и слабые стороны, и ее расположение в вашей деревне должно отражать это.
 	Военные постройки - Военный лагерь, Казарма, Лаборатория. Служат для тренировки, улучшения и проживания Войск. В этом разделе описывается все, что будет влиять на силу ваших войск и то, что поможет вам выигрывать больше боев. Все здания в этом разделе для производства требуют Эликсир.

NFT в игре.
NFT — не взаимозаменяемый токен, он служит как обменная единица для торговли на маркетплейсе игры. Для того чтобы начать торговать в игре Вам нужен аккаунт с возможность продажи NFT. В игре можно превратить любое здание в NFT, кроме Ратуши и Забора, для этого Вам нужно нажать кнопку Market->My Units выбрать то, что вы хотите продать и на этой картинке нажать Mint&Sale, после этого ниже в разделе Minted NFT’s в столбце Status дождитесь слова success, это будет означать, что минт закончился, данное сооружение исчезнет с Вашей земли и будет отображаться в виде NFT вот здесь Market->My NFT’s. Теперь в поле Price Вы можете указать свою сумму в Near за которую хотите продать данное NFT и нажать на кнопку Sale NFT, после этого данное NFT будет выставлено на продажу в маркеплейсе игры. Но если вдруг Вы передумали и не хотите продавать его, можно нажать на кнопку Land it, заплатить небольшую комиссию через свой кошелек Near и вернуть здание на свою землю(оно останется такого же уровня, что и было, заново улучшать его не нужно).

Команда игры поддерживает стандарт Proof-of-Game — это значит, что создатели игры не будут торговать токенами и nft, все выставленные на продажу токены будут исходить от реальных игроков с привязкой к их земле. Доход команды — это роялти от p2p-трейдинга nft. Все остальное — заработок игроков.
Кланы
Игроки могут объединяться в кланы, которые затем могут участвовать в клановых боях и общаться друг с другом.  Что бы вступить в клан у вас должен быть построен Клан Кастл, который находится у вас на земле в разрушенном состоянии. Вы можете его восстановить за 40 000 золотых монет.

Клан нужен для сплочения игроков. В клане ты можешь попросить подкрепление для защиты своей деревни. В дальнейшем планируется устраивать клановые войны, что повысит интерес к игре.

Для того чтобы вступить в клан необходимо в игре нажать на свои кубки, появится список всех кланов которые существуют в игре, выбрать понравившийся и нажать на кнопку join clan, не забывайте у каждого клана могу стоять свои ограничения по вступлению в клан людей, это может быть ограничение по минимальному количеству кубков, которое должно быть у игрока или вовсе в клан можно вступить только по приглашению.

Сайт игры: https://www.landtoempire.com

Твиттер: https://twitter.com/LandToEmpire

RU обзоры игр на NEAR: https://t.me/play_on_near

### Top 5 Juegos en NEAR

NEAR Protocol es una plataforma de contratos inteligentes que se centra en la facilidad de uso para el usuario final y también para el desarrollador. Ahora que GameFi y los juegos de cadenas de bloques se están convirtiendo en la próxima gran novedad, veamos algunos de los protocolos de juego que están disponibles actualmente en NEAR. Específicamente, estaremos viendo:

 	Chain Typing
 	DApps de píxeles: Pixelparty, Pixelpets y Cryptoheroes.
 	Lands

Chain Typing - Escribiendo en Cadena
Chain Typing es un juego de jugar para ganar que te ayuda a mejorar la eficiencia al escribir. Necesitarás tener un personaje para jugar el juego, como se representa en la Tabla de clasificación. Inicialmente, solo habrá 30 personajes disponibles para jugar, pero a medida que el juego se amplíe, habrá más personajes jugables disponibles. Los personajes se pueden utilizar como un espacio publicitario para contener descripciones.



Las donaciones irán a los fondos del juego para ayudar a promover el juego. Las tarifas de acuñación (minteo) de personajes en cadena también se donan a los fondos del juego y no son reembolsables.
Pixel DApps - DApps de píxeles


Pixel DApps ha creado tres juegos para el ecosistema NEAR, son los siguientes:

 	Pixelparty
 	Pixelpets
 	Criptoheroes

#1 Pixelparty - fiesta de píxeles


PixelParty es uno de los juegos de Pixel DApps (Dapps de Pixeles). Es un escaparate NFT con un suministro total de 600 tokens. Junto con eso, debes tener en cuenta lo siguiente:

 	Cada token que tu poseas te permite dibujar en un marco de 20x20px.
 	Los usuarios pueden comprar diferentes marcos conectados para dibujar un marco más grande.
 	Todos los poseedores de marcos reciben recompensas del ecosistema pixeltoken.
 	Los titulares de marcos activos con una cantidad mínima de marcos pueden participar en el DAO.

A continuación se explica cómo participar en PixelParty:

 	Elige y compra uno de los marcos disponibles.
 	Tus marcos se ubicarán en la barra lateral.
 	Eres libre de dibujarlos, editarlos o incluirlos en el mercado para venderlos.

#2 Pixelpets - Mascotas Pixeles


PixelPets es un juego creado por Pixel DApps para intercambiar y luchar con tus mascotas. Es un juego NFT en el que cada ficha representa uno de los 60 tipos de mascotas diferentes. Además, cada mascota tiene uno de los cuatro rasgos de rareza: común, raro, épico y legendario. El rasgo afecta los diferentes atributos de la mascota, como la fuerza, la calidad y el nivel. En PixelPets, puedes:

 	Eclosionar: recoger huevos de mascotas e incubarlos. Solo puedes incubar un huevo a la vez. Cuanto mayor sea la rareza de la mascota, más tiempo tardará en eclosionar el huevo.
 	Entrena: al entrenar a tu mascota, puedes elevar el rango de calidad. Puedes entrenar a tu mascota enviándola al gimnasio.
 	Evolucionar: después de ganar suficientes puntos de experiencia y obtener el nivel de calidad deseado, tu mascota puede evolucionar al siguiente nivel en la cámara de evolución.
 	Lucha: experiencia de granja al batirse en duelo con otros dueños de mascotas. También puedes luchar en el coliseo y ganar premios y honor.
 	Marketplace: compra y vende tus mascotas con pixeltoken.

#3 Criptoheroes


El tercer juego creado por Pixel DApps es Cryptoheroes, un juego basado en blockchain centrado en el saqueo PvE, el intercambio y la forja de elementos, y la lucha contra jefes con amigos para ganar PXT. Entra en mazmorras, derrota a los súbditos y recoge el botín.

¿Cómo se gana PXT?

 	Forma un equipo con tus aliados para unirte a incursiones, derrotar a jefes malvados y competir por recompensas PXT semanales.
 	Recoge artículos poderosos y véndelos en el mercado.
 	También puedes reformar tus artículos para mejorar tu equipo existente.

¿Cómo participas en las redadas?

 	Cada incursión tiene 8 jugadores.
 	Los allanamientos se realizan semanalmente.
 	Las 20 mejores incursiones son recompensadas cada semana.

NEAR Lands - Terrenos NEAR


NEAR Lands es un juego multijugador 2D descentralizado basado en blockchain. Tú, como jugador, puedes caminar o construir un juego de mundo abierto de tierras pixeladas. Los jugadores pueden:

 	Crear sus propios personajes y elementos.
 	Hablar con amigos.
 	Interactuar con otros participantes en el universo en línea.
 	Los jugadores pueden explorar el paisaje y crear un reino en línea inmersivo e interactivo.

Conclusión
El ecosistema de juegos en NEAR aún es joven, pero ya se muestra muy prometedor. Así que asegúrate de estar atento y mantener un ojo en los proyectos más nuevos que se están construyendo en NEAR.

### Wie man ein Play To Earn-Spiel auf der NEAR Blockchain erstellt

Ausführliche Beschreibung des aktuellen Prototyps - BerryClub




Dieser Leitfaden soll Dir helfen, die grundlegende Dynamik zu verstehen, mit der Du ein Play-to-Earn-Spiel auf der NEAR Blockchain erstellen kannst.

Absicht dieses Tutorials ist es nicht jemanden reich zu machen, sondern mithilfe eines einfachen HTML5-Frontends zu verdeutlichen, wie man ein einfaches Farming-Spiel erstellen kann.

Wir werden einen Smart Contract und die JS/Rust-Dateien hinter dem bestehenden Farming-Spiel BerryClub analysieren. Wenn Du die gleiche Logik auf Ihre Spielideen anwendest, werden vielleicht noch witzigere Ergebnisse entstehen.

Um der technischen Seite dieses Tutorials zu folgen, empfehlen ich Dir, die Abbildung NEAR Pathway, um eine Transaktion zu erstellen und deinen ersten Smart Contract auf NEAR zu deployen. Es wird für Dich viel einfacher sein, diesem Tutorial zu folgen, wenn Du während des Lesens der Erklärung einen Tab auf der verlinkten Quelldatei offen hältst. Ein Großteil des erwähnten Codes wird mit Zeilennummern referenziert, aber hier nicht wiedergegeben. Das ursprüngliche BerryClub-Repository wurde für dieses Tutorial geforked, um die Gültigkeit des Codes auf der Blockchain aufrechtzuerhalten. Wie Du im nächsten Abschnitt sehen wirst, hat sich das Spiel selbst im Laufe der Zeit weiterentwickelt und wird sich auch in Zukunft weiterentwickeln. An dieser Stelle werden wir uns aber nur mit dem Stand zum Zeitpunkt des Erstellens von diesem Artikel beschäftigen.
Das BerryClub Frontend
BerryClub wurde mit React entwickelt, also werden wir als allererstes in die app.js-Datei im src-Ordner des Github-Repos einsteigen. Das spart uns Zeit bei der Analyse des Contracts, so dass wir uns auf das konzentrieren können, was wir brauchen, um die Logik außerhalb des eigentlichen Spiels zu erschließen (das im Übrigen Spaß macht und von einer großen Community gespielt wird).

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
Nach dem Importieren von React ist die erste Library, die benötigt wird, bn.js, ein einfaches Dienstprogramm zum Verwalten von dezimalen Zahlen oder nicht dezimalen Zahlen. Viele Funktionen werden diese Library verwenden, um mit dem UI zu interagieren, wie zum Beispiel die folgende Konstante:

const PixelPrice = new BN(“10000000000000000000000”);
Das Spiel BerryClub basiert auf der Immobilienökonomie. Es gibt ein Brett, das von einem Teil des Contracts namens board.rs verwaltet wird. Es ist in Pixel unterteilt. Jedes Pixel hat einen Preis, der bezahlt werden muss, um darauf zu zeichnen. Die Finanz Mechanik der "Draw"-Aktion ist der Kern der Farming- und Selbsterhaltungsfähigkeiten des Spiels und wird im Detail analysiert, wenn wir zum Smart Contract kommen.
Wie Du hier sehen kannst, wird der Preis für ein Pixel gleich zu Beginn unserer Anwendung als Konstante deklariert und kann mit den Frontend-Tools und der bn.j-Bibliothek geändert werden. Der zweite Import ist das NEAR SDK, welches uns die Interaktion mit der Near-Blockchain ermöglicht, wie in der Abbildung NEAR Pathway erläutert. Die erste Verwendung der Near-Api besteht darin, die verwendeten Contract-Variablen zu benennen und sicherzustellen, dass das Mainnet verwendet wird, wenn der Code über die BerryClub-Url ausgeführt wird:

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Zunächst importieren wir die React-UI-Utilities, um unsere Oberfläche zu erstellen und den Benutzern das Zeichnen zu ermöglichen: react-color, react-switch und react-compound-timer. Die erste davon ist der Timer. Dieser wird genutzt um eine Zeitüberschreitung für die Auffrischung des Boards in Zeile 62 zu setzen.

Die " Aktualisierung " des Boards wird vom Frontend durchgeführt, um den aktualisierten Board-Status über einen RPC-Aufruf an den Smart Contract anzuzeigen.
const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
Was wir hier sehen, sind zwei Konstanten mehr als die, die für die Auffrischung benötigt werden. Die letzten beiden werden tatsächlich für das Farmen der Pixel nach dem Zeichnen verwendet und setzen ein Zeitfenster von einem Tag, um die Belohnungen zu berechnen. Andere Konstanten werden ebenfalls angegeben, um das Board entsprechend mit dem Smart Contract zu verwalten. Hier kreuzen wir zum ersten Mal das Konzept der Linien, das sehr wichtig sein wird, um das Board-Management zu verstehen und welches das am meisten wiederverwendbare Element der gesamten Schnittstelle ist:

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
Wie Du sehen, wird das Board in 50×50 Pixel unterteilt und das Interface wird angewiesen, nur die Zeilen nach der Anweisung "RefreshBoardTimeout" abzurufen. Die Länge jeder Zeile wird als BoardWidth multipliziert mit 12, also der Größe einer einzelnen Zelle betrachtet.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Die Pixel werden im Stapeln und nicht unabhängig voneinander betrachtet. Sowohl beim Aufruf der Zeichen Aktion als auch beim Aktualisieren des Interface.
Zu guter Letzt enthalten unsere Importe eine benutzerdefinierte UI-Komponente namens Weapons,js: Diese Komponente wurde später in der Entwicklungsgeschichte der BerryClub-Community eingeführt, damit jeder Benutzer ein komplettes Bild auf das Board hochladen, zeichnen und auf dem NFT-Marktplatz für Berry Cards verkaufen kann.

DeFi-Mechanik
Die Zeilen zwischen 27 und 51 sind ein nützlicher Hinweis darauf, wie diese dezentrale App ihre Farming-Fähigkeiten über einige grundlegende DeFi-Mechanismen aufbaut. Diese werden in den letzten Teilen dieses Tutorials analysiert. Bis jetzt haben wir nur kurz erwähnt, dass, um ein Pixel zu zeichnen/kaufen BerryClub Dich durch eine Reihe von DeFi Operationen auf ref.finance leitet.  Dabei werden spezifische Token, die Avocados, für den Kauf von Pixeln und Bananen verwendet. Diese Token werden von den Pixeln verdient, die Du gekauft hast.







Es wurde ein einfacher Uniswap-Klon erstellt, um Bananen/Avocados gegen NEAR zu tauschen, der auf demselben Smart Contract basiert, der für die anderen Token dieses Spiels/Prototyps erstellt wurde. Es wurde auch einen Farming Token für das Spiel erstellt, genannt Gurke. Er ermöglicht es den Spielern, einen Teil der Token zu verdienen, den die ganze Spielgemeinschaft zahlt, um auf dem Brett zu zeichnen.







Wie Nutzer Geld verdienen
Dies ist der allererste Schritt, den wir im Rust-Code des Smart Contracts machen.  Ich erinnere daran, dass diese DeFi-Mechanik nicht der einzige Weg ist, wie BerryClub einen Spieler Token verdienen lässt. Der Account hat eine spezielle Datei im BerryClub Smart Contract, die wir uns nicht jetzt ansehen müssen. Was wir aber wissen müssen ist, dass einige Informationen, die für die Farming- und Earning-Mechanismen entscheidend sind, werden im Konto-Objekt gesammelt werden:

 	AccountID
 	AccountIndex für die Liste der Konten, welche die Pixeltafel zum letzten Mal berührt haben
 	Balance(Vector für den Besitz mehrerer Token)
 	Anzahl der Pixel
 	Claimed Timestamp (Nanosekunden, wann der betreffende Account das letzte Mal Belohnungen beansprucht hat)
 	Farming-Präferenzen (entweder Bananen oder Gurken)

Die letzten beiden Informationen dienen dazu, die Belohnungen zu einem bestimmten Zeitpunkt zu berechnen. Wenn beispielsweise 5 Pixel für einen Tag kontrolliert werden, ergibt das 5 Bananen. Wenn man einen Pixel der Kontrolle eines Anderen entnimmt, verdient dieser weniger, weil die Anzahl der Pixel, die er besitzt, abnimmt. Dabei wird der Zeitstempel im Bezug auf die besessenen Pixel erneuert. Wie wir gleich sehen werden, werden die Belohnungen auf der Grundlage dieser beiden Variablen berechnet. Die Operation, die auf dem Account des vorherigen Besitzers angewandt wird, wenn ein Pixel gezeichnet wird, heißt das "touch" und ist in der Datei account.rs rust zu finden. Der Besitz eines einzelnen Pixels ist die Grundlage für das Verdienen auf BerryClub. Auf diese Weise ist diese Mechanik so ziemlich die gleiche, die ein NFT Staking Interface verwenden könnte, das NFT Besitz belohnt.

pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
Um alle Zweifel auszuräumen, ist der anfängliche Besitzer des Boards 0, der Contract selbst. Wenn es nicht möglich ist, einen früheren Besitzer zu finden, wird der Contract als der frühere Besitzer verwendet. Um das Spiel zu starten, wurden einige Token auf dem Contract Account gespeichert. Der "Tresor" des Spiels ist immer mit einigen Token gefüllt, die die Benutzer gewinnen können. Kommen wir nun zu unserem Interface zurück.

Zahlen zu Farben und zurück






Die Zeilen zwischen 67 und 82 in app.js werden zur Dekodierung von Zahlen in Farben und zurück verwendet. Damit die UI-Elemente mit dem Board interagieren können werden zwei konstante Variablen definiert, intToColor und rgbaToInt. Hierbei können wir feststellen, dass zur Umwandlung einer Integer Zahl in einem “colour string” die drei Farben Rot, Grün und Blau verwendet werden.

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
Um die "colour string" in eine ganze Zahl umzuwandeln, wenden wir einfach eine math.round()-Funktion an und verwenden die resultierende ganze Zahl.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
In den Zeilen darunter geht es um das Hochladen und Rendern von Bildern auf dem Board mit der "weapon"-Komponente, auf die wir nicht näher eingehen werden. imgColorToInt und int2hsv wandeln Zahlen in zwei verschiedene Arten von Farbskalen um, dann wird transparentColor definiert und ein Gamma für das zu rendernde Bild mit generateGamma. In decodeLine wandeln wir den Buffer in ein Array von Pixeln um, die mit den oben genannten Farben auf das Board gedruckt werden sollen, und iterieren sie mit einer for-Schleife.

Erster React-Constructor
In den nächsten Zeilen der app.js definieren wir einen Constructor, der die Zustände festlegt, die wir später in unserer UI zur Interaktion mit der Blockchain verwenden werden.

class App extends React.Component {
  constructor(props) {
    super(props);
Die hier definierten Eigenschaften sind die standardmäßig ausgewählte Farbe und die Farbpalette:







const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
Und für den Timer, der das Board aktualisiert:

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Dann wird der Zustand des Benutzerkontos definiert, vor allem, ob der Benutzer sich angemeldet hat oder ob es irgendwelche ausstehenden Transaktionen gibt (definiert als pendingPixels). Der boardLoaded-Zustand lädt das Canvas-Board zum Zeichnen der selectedCell Alpha- und PickerColor-Zustände. Diese definieren die Zustände der interaktiven Komponenten, um dem Board Farben hinzuzufügen. Zusammen mit pickingColor zum Auswählen der Farbe vom Board und gammaColors wird der Bilddruck auf dem Board gerendert, sowie den weaponsOn- und weaponsCodePosition-Zuständen.

Die hier folgenden Variablen definieren, welche dem Account des Spielers zugeordnet sind. Diese Informationen sind nützlich um die Spiel Token Ausschüttung zu berechnen:
owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
Bei den letzten drei Zuständen wird der Timer für die spätere Verwendung eingerichtet:

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
Die folgende Liste (Zeilen 203-215) definiert Objekte und Aktionen, die mit den Zuständen interagieren und zum ersten Mal ein DOM-Element referenzieren, das “Canvas board”.

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Schließlich definieren wir einige der Zustände, nachdem die Anmeldung erfolgt ist:

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Grundlegende Interaktionen
Nun beginnen wir mit der Beschreibung von Interaktionen auf dem Board/Canvas und verbinden diese mit den zuvor definierten Zuständen. Für diese Interaktionen verwenden wir Funktionen. Die erste Funktion verwendet unseren vorherigen Verweis auf das Canvas-Element, um es zu erstellen und ihm Details über die Art der Mausbewegung mitzuteilen, die wir unseren Benutzern erlauben. Beim ersten Klick aktivieren wir den Watchmode, um den Timer zu starten:

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
Und den "image rendering mode", wenn der Benutzer ein Bild auf dem Board rendern möchte:

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
Der nächste wichtige Teil ist, dass wir definieren, wie die Schnittstelle die Maus- und Touch-Bewegung über das Board liest:

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
Der verwendete Code berücksichtigt die Bedürfnisse der mobilen Benutzer, indem er eine Ad-hoc-Funktion zur Berechnung der Position und einen Listener für Berührungsereignisse zum Canvas/Board hinzufügt: canvas.addEventListener("touchmove", mouseMove); Diese Interaktionen werden dann verwendet, um den selectedCell-Status zu setzen und sowohl den Beginn und das Ende der Maus-/Berührungsaktion auf dem Canvas als auch die Bewegung auf jeder Zelle zu verfolgen:

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
Die Interaktion hier funktioniert über die zuvor definierten Zustände. Beispielsweise der "color picker" ermöglicht uns, Farben vom Board zu wählen und dann zu zeichnen.Die Taste, welche vom color picker verwendet wird, ist die Alt-Taste. Wir können Bilder auf dem Bord nur dann rendern, wenn diese Taste nicht gedrückt ist, da wir andererseits die generategamma Funktion triggern würden. Auf diese Art und Weise ist die pickcolor() Funktion, wenn sie von einem Pixel referenziert wird, nützlich um einen einzelnen Pixel oder das gesamte Board zu färben.

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
An dieser Stelle kommen wir zum Kern unserer DApp, dem Smart Contract. Wir wissen, wie wir die Pixel im Interface zeichnen, aber wir müssen die Transaktionen mit der Blockchain verbinden, damit unser Interface ein echtes Spiel zum Verdienen von Token ist. Achte also bitte genau auf das, was ich jetzt sage, denn auch wenn dein Spiel in Bezug auf das UI völlig anders aussieht als dieses, kann die Earn-Mechanik sehr wohl für jede andere Art von Spiel geeignet sein und wird hier auf die einfachste Weise erklärt, die ich kann.






Der BerryClub Smart Contract
Linien
Wir sind den Linien zum ersten Mal zu Beginn dieses Artikels begegnet, als wir uns mit den Definitionen des UI für die Zustände beschäftigt haben. Linien sind ein wichtiges Konzept der BerryClub-Benutzeroberfläche. Sie sind die Zeilen, durch die das Board/Canvas unterteilt ist. Jeder Pixel in dem Board ist ein Teil der Metadaten. Sie sind ein Teil des UI, welches mit dem Smart Contract interagiert und sie sind das am meisten wiederverwendbare Objekt des Spiels (zum Beispiel, um Level in einem zusammenhängenden Spiel zu erstellen). Also werden wir ein wenig Zeit damit verbringen, zu analysieren, wie sie verwendet werden, um Daten vom Board zu speichern und auszuwerten, während die Benutzer das Spiel spielen.

Zunächst einmal finden wir in der Datei board.rs eine Definition von PixelLine direkt nach der Definition der Pixel:
pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
Ein Vektor (Array) von String-Daten, unterteilt durch die Breite des Boards.

Und dann definieren wir das PixelBoard als einen Vektor der PixelLines auf diese Weise:
pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
Jede Linie wird also im Board als einzelner Datensatz mit einem Metadatenfeld namens line_versions gespeichert, das bei jeder Änderung einer Linie erweitert wird. Jedes Mal, wenn unser Interface das Board abruft, erhält man also 50 Zeilen, aber auch Metadaten für jede Linie wie zum Beispiel wie oft diese Linie aktualisiert wurde. Wenn man diese Metadaten abruft, weiß das Interface, wie oft die Linie geändert wurde. Wenn die Linie seit dem letzten Abruf geändert wurde, dann holt man die Daten für jedes Pixel, wenn nicht, dann eben nicht.

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
Dies ist ein effizienter Weg, um Daten zu speichern und über das Interface abzurufen. Merke dir dies für dein nächstes play-to-earn NEAR Spiel.







Transaktionen
Gehen wir kurz zurück zu unserem UI in app.js, um sicherzustellen, dass wir verstehen, wie die Transaktionen vom Frontend aus verwaltet werden. Zuerst brauchen wir eine Funktion, um den Account zu überprüfen, wenn etwas schief läuft:

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Erinnerst Du dich dann an die Arrays _queue und _pendingPixels, die wir in unserem Constructor definiert haben? Es ist definitiv an der Zeit sie zu verwenden, da die Transaktionen in Abhängigkeit davon verwaltet werden, welche Pixel auf dem Board gezeichnet wurden:

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Warten Sie, ich war nicht bereit für diese Menge an Code... Doch, das bist Du! Aber schauen wir es uns genau an, wir erstellen ein Pixel-Objekt (vector), wir ändern unser _queue-Objekt, damit es in die Pixel passt und wir weisen deren Wert dem _pendingPixel-Objekt in einer async Funktion zu.

Und was dann? Wir zeichnen einfach auf ein Contract Objekt, das aus dem NEAR SDK aufgerufen wird. Somit ist die Aktion für das Zeichnen (ein Teil der Aktionen, die wir für den Benutzer definiert haben) in der Rust Datei lib.rs definiert.
pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
Für den Smart Contract sind Pixel eine Farbe und eine Account-ID (der Mystical Owner), und es ist ein immobilien basiertes Spiel: Wir haben also einen alten Besitzer, der das Pixel zuvor gezeichnet hat, und einen neuen Besitzer, der es jetzt zeichnen möchte. Mit der Draw-Aktion holen wir uns den alten Besitzer und ersetzen ihn durch den neuen Besitzer, indem wir den Farbwert aller Pixel innerhalb des PixelRequest-Vektors ändern, dann senden wir Belohnungen an den alten Besitzer und belasten den neuen. Die Zeitstempel für die Belohnungen werden zurückgesetzt und die Zählung beginnt wieder bei Null mit einem Pixel weniger für den alten Besitzer und einem mehr für den neuen. Die Aktion setPixelRequest ist in der Datei board.rs unseres Contract definiert, aber kommen wir zurück zu unserer libs.rs.

Wie sieht die Funktion maybe_send_rewards() aus? Hier ist sie in ihrer ganzen Pracht:
impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
Bitte werde nicht faul, wenn es nicht anders geht, kann später das Video des Spieleautors angesehen werden. Die Erklärungen, die ich verwenden werde, stammen ebenfalls aus diesem Video.

Die Funktion verifiziert die Zeit auf der Blockchain (wir verwenden hier nicht den Timer auf dem Interface, weil wir sicher gehen wollen, dass nicht geschummelt wird) und nutzt die Farming-Capabilities des Contracts für einen Global Timestamp mit der Funktion get_next_reward_timestamp() und last_reward_timestamp() 

. Anschließend wird get_expected_reward() aufgerufen, um dem Account die verdienten Rewards zuzuteilen.
pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
Wir nehmen also den aktuellen Kontostand des BerryClub-Accounts (erinnerst Du dich, dass wir ein Guthaben Feld auf dem Account haben?), die aktuelle Speichernutzung und -kosten und eine Sicherheitsreserve von 50 Avocados. Wenn das Guthaben sicher für die Nutzung außerhalb der Speicherkosten ist, teilen wir das Guthaben in 24 (Stunden) * 60 (Minuten) Teile der Belohnung. Das bedeutet, dass Du im Grunde genau das gleiche Guthaben erhältst, wie wenn Du es jede Minute aufrufen würdest. Dies ist  am Anfang der lib.rs Datei definiert:

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
Ich wette, ihr Leute denkt, der Belohnung Prozess ist vorbei. Falsch gedacht.

Wir müssen tatsächlich zurück in unsere Funktion maybe_send_reward() gehen, um zu sehen, dass sie den neuen BerryClub-Farm-Contract aufruft, wo wiederum die Staking-Rewards verteilt werden, die... Gurken. Die Gurken sind ja der Staking-Token auf BerryClub 🙂
const FARM_CONTRACT_ID_PREFIX: &str = "farm";
Das ist aber nicht die einzige Quelle um Einnahmen mit dieser Funktion zu verteilen, denn sie gleicht auch die Netzwerk Gebühren in Gas aus, die die Leute bezahlen, um Avocados zu kaufen und Bananen zu tauschen, um die ganze Spiel Gemeinschaft zu belohnen!

Wie ist das möglich? Das Wichtigste zuerst: GAS_BASE_COMPUTE wird in der Datei token.rs definiert, wo die Gasmenge für den Smart Contract festgelegt wird. Ja, Du hast Recht! Der Gaspreis ist auf der NEAR Blockchain niedrig und kann verwendet werden, um Benutzer zu belohnen, die mit Ihrem Videospiel interagieren!!!

Um besser zu verstehen, wie GAS-Gebühren auf NEAR funktionieren, lies diese detailierte Beschreibung.

Dieses Tutorial wurde von jilt.near und ihrem NFT Gaming Projekt zur Verfügung gestellt. Unterstützte diesen Account durch den Kauf von NFTs!

### Beispiel für Dapplets × NEAR

Das Beispiel für Dapplets × NEAR ist ein Dapplet (eine Augmentation-App), die Twitter-Posts analysieren und im NEAR-Contract speichern kann. Die App kann auch Deine gespeicherten Tweets auf der Overlay Seite anzeigen.
1. Einleitung
Dapplets - applications that interact with web-pages, augment them by inserting different widgets, parse the pages’ data and add some new functionalities. They can improve the user experience when using social media, video services and other sources.

Dapplets use the extension we are creating. This extension gives a simple API for dapplets developers and big abilities for the dapplets community. Our platform is decentralized. We use NEAR and Ethereum networks for our registries and contracts. We also use decentralized storages, like Swarm, IPFS and SIA for hosting dapplets code and multimedia.

To use our platform at first you need to install the Dapplets Extension . Currently it’s in the alpha-stage and is not published to Google Chrome or any other store. To install it follow this steps:

 	Öffne einen der folgenden Browser: Google Chrome, Firefox, Brave, Tor.

Die folgenden Schritte sind für Google Chrome beschrieben. Bei anderen Browsern können die Schritte abweichen.

 	Lade die Dapplets Browser Extension herunter.
 	Öffne chrome://extensions in einem neuen Tab.
 	Schalte den Developer Modus ein und drücke F5, um die Seite zu aktualisieren. 
 	Ziehe die heruntergeladene Datei per Drag & Drop auf die Extensions-Seite.Wenn Du Ubuntu oder ein anderes Linux-Betriebssystem verwendest, kann die Dapplets-Extension nach einem Neustart des PCs aus den Chrome-Extensions verschwinden. Um dies zu vermeiden, unzippe das Archiv und verwende den Button Load unpacked, um die Extension hinzuzufügen.
 	Klicke auf das Symbol für die Dapplets-Extension in der Extension Bar. Probiere Dapplets × NEAR example Dapplet.

2. Leitfaden
Lasst uns untersuchen, wie dieses Dapplet funktioniert und warum Dapplets eine NEAR-freundliche Plattform sind.

Das Ziel dieses Beispiels ist es, die Interaktion zwischen NEAR und Dapplets zu zeigen. Wenn dies Deine erste Begegnung mit Dapplets ist, empfehlen wir Dir, zunächst unsere Dokumentation zu diesem Thema zu lesen. Sie enthält mehrere Übungen, die erklären, wie man Dapplets und Adapter erstellt, von einfachen bis hin zu komplexen Dapplets. Wir empfehlen Dir, die Beispiele ex01 und ex04 durchzugehen, die beschreiben, wie man die einfachsten Dapplets sowie Dapplets mit einem Overlay erstellt. Durch das dabei erlangte wissen wird es dir leichter fallen, das aktuelle Beispiel zu verstehen.

Der ursprüngliche Code für dieses Beispiel befindet sich in einem separaten Branch: exercise.

Du kannst dieses Repo klonen. Es wird nicht direkt funktionieren. Versuche die folgenden Schritte, um es zu starten.

Schauen wir uns die Struktur an. Es gibt drei Komponenten: Dapplet, Overlay und Contract.

Das Dapplet ist der Einstiegspunkt der Anwendung. Es verwendet Adapter für die Interaktion mit Webseiten, definiert Kontexte zum Erweitern und Widgets um etwas einzufügen. Die Kernfunktionen der Extension sind in einem Dapplet zu finden. Wir verwenden TypeScript in unserem Projekt.

Wir definieren Overlay als einen Ort, an dem ein Benutzer etwas mit den parsed Daten tun kann. Außerdem kann eine Verbindung zu den Kernfunktionen des Dapplets über die Dapplet-Bridge hergestellt und Augmentierungs Parameter verwaltet werden. Es ist ein wichtiger Teil der Anwendung, aber dieser Teil läuft in einer anderen Umgebung und wird als separates Bundle veröffentlicht. In den meisten Fällen verwenden wir React. Es ist eines der beliebtesten Frameworks. Du kannst aber auch ein Framework Deiner Wahl oder reines JavaScript oder TypeScript verwenden.

Der Contract ist nicht direkt mit anderen Modulen verbunden und kann sich auch außerhalb des Dapplets befinden. Dieser einfache NEAR Contract wurde jedoch speziell für dieses Dapplet erstellt. Deshalb ist es praktisch, ihn in der Anwendungsstruktur zu platzieren.

Schauen wir uns die einzelnen Module an.
2.1. Dapplet
Schauen wir uns folgendes an: /dapplet/src/index.ts. 

Zuerst erstellen wir eine Injectable Class mit dem Decorator @Injectable und verwenden @Inject, um den Twitter Adapter als Adapter Class Variable hinzuzufügen. Außerdem erstellen wir eine activate method. Sie wird ausgeführt, wenn der ausgewählte Adapter einen bestimmten Kontext findet und geladen wird. Die active method wird die gesamte main logic enthalten.



Füge diesen Button zu jedem Tweet hinzu und den folgenden Code zum Aktivieren ein:



Sieh Dir den Code an. Wir erhalten den Widget-Button vom Adapter. Dann führen wir die Method attachConfig des Adapters aus. Sie empfängt ein Objekt mit den Namen der Kontexte, die verwendet werden sollen als Keys. Werte sind Funktionen, die den geparsten Kontext als einziges Argument erhalten und ein Widget oder ein Array von Widgets zurückgeben. Sie können auch null, false oder undefined zurückgeben.

Das Widget ist eine Funktion, die ein Objekt empfängt, das aus Widget-states besteht. Status Parameter sind in der Dokumentation des Adapters beschrieben. Die Dokumentation zum Twitter Adapter findest Du Hier. In unserem Fall fügen wir dem Button und dem Tooltip ein Bild hinzu. Exec ist eine Funktion, die beim Anklicken ausgeführt wird. Jetzt zeigen wir einfach den geparsten Kontext in der Konsole an.

Starte das Dapplet:


⚠️ Da der Browser Seiten mit problematischen Sicherheitszertifikaten blockiert, geh zu https://localhost:3001/dapplet.json, wenn die Anwendung läuft, und stimme der Ausführung im unsicheren Modus zu.
Öffne die Extension. Geh auf den Developer Tab und schalte den Development Server ein:  https://localhost:3001/dapplet.json.



Schalte die Registerkarte Dapplets ein. In der Nähe unseres Dapplets siehst Du das Dev-Badge. Schalte es ein.



Jetzt siehst Du zusätzliche Buttons auf unseren Tweets. Klicke auf den Button und öffne die Konsole. Du wirst nun den geparsten Kontext des Tweets sehen.



Du hast es geschafft! Herzlichen Glückwunsch!!! Gehe nun zurück zum Code.

Wir wollen die geparsten Daten nicht in der Konsole, sondern für die Benutzer anzeigen. Hierfür werden wir ein Overlay verwenden. Aber bevor wir das Overlay implementieren, fügen wir die Interaction Logic zwischen dem Dapplet und dem Overlay zum Dapplet hinzu.

Dafür ändern wir unseren Code. Füge die private Class Variable _overlay of type any hinzu. Anschließend ergänze im activate den folgenden Code:



Die Kernfunktion Core.overlay (Tippfehler werden bald behoben) empfängt ein Objekt mit dem Namen des Overlay und einem Overlay Title und gibt das Overlay Object zurück, das wir in der Variable _overlay speichern.

Fügen wir der Class die Method openOverlay hinzu:



In diesem Beispiel nennen wir die Methode send the overlay. Du benötigst zwei Argumente: den Namen dieser Daten und die Daten, die an das Overlay gesendet werden sollen.

Füge openOverlay zur exec-Funktion hinzu und übergib den geparsten Kontext an das Overlay. Dies ist der aktuelle Code des Dapplets:



Öffne das Manifest ./dapplet/dapplet.json.


⚠️ Da der Browser Seiten mit problematischen Sicherheitszertifikaten blockiert, öffne https://localhost:3000, wenn die Anwendung läuft, und stimme der Ausführung im unsicheren Modus zu.
Hier sehen wir die URL des Overlays mit dem Namen "Overlay", das im Developer Mode verwendet wird. Während der Veröffentlichung des Dapplets in der Registry wird das Overlay im dezentralen Speicher veröffentlicht.

Wir sehen auch den Twitter Adapter in den Abhängigkeiten. In unserem Beispiel verwenden wir die Version 0.9.0.

Gehen wir nun zum Overlay.
2.2. Overlay
Wie bereits erwähnt, kann das Overlay auf jede beliebige Weise erstellt werden. Wir verwenden in den meisten unserer Projekte React. Wir werden nicht den gesamten Overlay-Code analysieren, sondern nur die für unsere architektonischen Aspekte wichtigen Punkte.

Für die Interaktion mit dem Dapplet installiere das npm-Paket @dapplets/dapplet-overlay-bridge:



Um die Daten aus dem Dapplet zu erhalten, benötigen wir die Class Bridge im Overlay-Teil. Sieh Dir das Modul ./overlay/src/dappletBridge.ts an. Hier ist die onData-Methode, mit der wir das Ereignis "data" subscriben, das wir im Dapplet beschrieben haben.



Dann verwenden wir es im Modul App.tsx.



Speichere nun die Änderungen und lade die Twitter-Seite neu. Wenn Du auf den Button klickst, siehst Du das Overlay mit den ausgewählten Tweet-Daten.



Das ist schon mal super! Aber unser Ziel ist es, diese Daten in der NEAR-Blockchain zu speichern und sie zurückzubekommen. Schauen wir uns also den Contract an.
2.3. NEAR smart contract
Sieh Dir das Modul ./contract an. Es gibt einen einfachen NEAR Smart Contract, geschrieben in AssemblyScript mit der create-near-app.

In ./contract/assembly/index.ts sehen wir eine PersistentUnorderedMap namens tweetsByNearId. Sie speichert ein Array von serialisierten Tweets-Daten mit der aktuellen Benutzer-ID. Sie hat Methoden zum Speichern, Entfernen und Abrufen von gespeicherten Tweets.

Alle notwendigen Informationen zum Schreiben, Testen und Bereitstellen von NEAR Smart Contracts findest Du in der offiziellen Dokumentation und in den Learn NEAR Kursen und Anleitungen.

Schauen wir uns an, wie man sich mit dem Smart Contract verbindet und seine Methoden im Dapplet verwendet.

Füge den folgenden Code in die activate-Methode des Moduls



Es gibt eine Core.contract-Methode, die 3 Parameter erhält: den Namen des Networks ('near' oder 'etherium'), den Contract-Namen und ein Objekt mit View- und Change-Methoden.

Jetzt werden wir die Contract-Methoden im Overlay verfügbar machen. Um die Methoden durch die Dapplets Bridge zu leiten, füge eine Listen-Funktion zum Overlay-Call hinzu. Keine Angst, einfach diesen Code kopieren und einfügen 🙂



Die letzten drei asynchronen Funktionen übergeben unsere Contract-Methoden an das Overlay. Die ersten vier Funktionen müssen die Wallet mit dem Dapplet koppeln. Um das Wallet-Objekt zu erhalten, verwenden wir die Methode Core.wallet mit den Parametern name (near oder ethereum) und network. Die Wallet hat die Methoden isConnected, connect, disconnect und den Parameter accountId.

Der nächste Schritt ist die Änderung von ./overlay/src/dappletBridge.ts. Wir müssen die Funktionen, die im Dapplet beschrieben wurden, im Overlay verfügbar machen. Kopiere den folgenden Code in die Bridge-Class:



Jetzt können wir Contract-Methoden in den Overlay-Modulen verwenden. Wir können das Dapplet mit der NEAR-Testnet-Wallet autorisieren und die Daten der ausgewählten Tweets im Smart Contract speichern. Wir können unsere gespeicherten Daten auch im Overlay sehen.

Uncommitte den gesamten committed Code in der ./overlay/src/App.tsx. Speichere die Änderungen und lade die Twitter-Seite neu.



Als Sahnehäubchen wird die Möglichkeit hinzugefügt, gespeicherte Tweets anzuzeigen, ohne neue Tweets zu parsen. Dazu genügt es, die Methode Core.onAction zu activate in ./dapplet/src/index.ts hinzuzufügen und ihr die Funktion zum Öffnen des Overlays zu übergeben.



Jetzt siehst Du das Home-Symbol neben dem Namen des Dapplets.



A click on the button opens an overlay with saved tweets.



Herzlichen Glückwunsch an alle, die es bis zum Ende des Tutorials geschafft haben! Wir hoffen, es war erfolgreich.

Hier ist das Ergebnis: dapplets-near-example

Falls etwas nicht geklappt hat oder Ihr noch Fragen habt, seid Ihr in unseren Chats in Discord und Telegram herzlich willkommen.

Wir danken Dir für Deine Zeit. Wir hoffen, dass dieses neue Wissen nützlich sein wird und du weiterhin beeindruckende und erfolgreiche Anwendungen auf der Dapplets-Plattform entwickeln wirst, indem Du die Möglichkeiten des NEAR-Protokolls nutzt 🚀✨.
Contacts
Web: dapplets.org

Docs: docs.dapplets.org

GitHub: github.com/dapplets

Discord: discord.gg/YcxbkcyjMV

Telegram: t.me/dapplets

Twitter: @dappletsproject

### Update - March 3, 2022

Brief Summary:

 	
We say "NO to WAR"! Learning is all about Peace!


Results:

 	💸 Ⓝ130 sent to 4 projects NEAR Certified Developer Demo February Day participants. Check projects repos at LNC GitHub
 	dWork Beta test sprint is 🔥🔥🔥 Join now!

 	🏆🏅🥇 Dapplets Developers contest AKA LNC Partners Bounty - more than 100 $NEAR in Awards! Register NOW!
 
 	


🔐(L)Earn "Crypto Best Practices: Tips For A Seamless Crypto Experience"














Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	TokenHub|LNC Beta coming soon!

### Akun NEAR - Panduan Ringkas

Pengenalan tentang Akun NEAR

 	NEAR menggunakan pengenal akun yang mudah dibaca oleh manusia dengan format .near. Seperti contoh agung.near atau maria.near.
 	Sistem akun NEAR mirip dengan sistem domain website yang dalam artian akun dapat membuat banyak sub akun sesuai kebutuhan. Misalnya, akun dengan nama maria.near dapat membuat akun turunan seperti sub.maria.near dan selanjutnya dapat membuat akun turunannya lagi seperti first.sub.masha.near, second.sub.maria.near dan seterusnya.
 	NEAR Wallet (https://wallet.near.org/) ( wallet NEAR Protocol), atau near-cli (https: //github.com/near/near-cli) (command line antarmuka yang memberikan fungsionalitas untuk integrasi NEAR) semuanya dapat digunakan untuk membuat akun.
 	Di NEAR, kamu dapat membuat akun dan mengirimkannya ke teman, kolega maupun pelanggan sebagai hadiah dengan menggunakan jasa dari https://nearnames.com
 	Kamu dapat memeriksa informasi akun di NEAR explorer (https://explorer.near.org/) begitu juga dengan NEAR wallet
 	Selain akun yang terlihat (dengan tipe nama.near), ekosistem NEAR juga mendukung pembuatan akun yang sifatnya invisible dengan bantuan near-cli (mirip seperti yang ada di alamat Bitcoin dan Ethereum). Kamu dapat mempelajari panduan lebih lanjut disini (english version)
 	Untuk setiap akun didalam sistem hanya bisa memiliki 1 smart contract. Untuk aplikasi yang mengharuskan pengguna untuk menggunakan banyak smart contract, beberapa sub-akun dapat digunakan. Contoh : contract_1.maria.near, contract_2.maria.near
 	Ada akun developer (https://docs.near.org/docs/concepts/account#dev-accounts) di ekosistem NEAR. Keistimewaannya terletak pada fakta bahwa mereka dibuat untuk menguji dan men-debug smart contract.

NEAR Account - Keys

 	NEAR mirip seperti blockchain pada umumnya yang berbasis kriptografi dengan open key. Ini bergantung pada pasangan kunci yang terdiri dari open key (public key) yang cocok dengan closed key (private key)
 	NEAR menggunakan open key untuk mengidentifikasi dan closed key untuk menandatangani transaksi (konfirmasi kepemilikan akun saat pembentukan transaksi)
 	Pada NEAR terdapat 3 tipe keys. Access keys digunakan untuk menandatangain transaksi dari akun, validator keys memungkinkan untuk operasi yang berkaitan dengan operasi jaringan, node keys (network node) memungkinkan untuk komunikasi tingkat rendah antar node di jaringan.
 	Keys dapat disimpan di 3 (tiga) tempat penyimpanan berbeda. InMemoryKeyStore - Penyimpanan memori, digunakan untuk skenario sementara. BrowserLocalStorageKeyStore - penyimpanan browser lokal tidak terenkripsi, digunakan untuk bekerja dengan aplikasi di browser. UnencryptedFileSystemKeyStore - penyimpanan tidak terenkripsi di sistem file, digunakan ketika bekerja di near-cli.
 	Sebuah akun dapat memiliki banyak access keys atau tidak sama sekali
 	Keys dapat memiliki level akses yang berbeda - FullAccess (full access) atau FunctionCall (hanya kemampuan untuk memanggil metode kontrak.
 	Semua keys unik dalam satu akun, namun public key dapat ditetapkan ke akun berbeda dengan akses level yang berbeda. Akses level menentukan tindakan apa dalam akun yang dapat dilakukan dengan key ini.
 	Untuk tingkat akses FullAccess, tersedia 8 jenis tindaka:: CreateAccountAction (membuat akun), DeployContractAction (menyebarkan kontrak), FunctionCallAction (memanggil metode kontrak), TransferAction (mengirim token ke akun lain), StakeAction (staking token), AddKeyAction (menambahkan kunci ke akun), DeleteKeyAction (menghapus kunci akun), DeleteAccountAction (menghapus akun).
 	Untuk tingkat akses FunctionCall, hanya FunctionCallAction yang tersedia (memanggil metode kontrak). Dan juga untuk kunci seperti itu, Anda dapat menentukan metode kontrak mana yang dapat dipanggil.

### dWork Beta Testers Feedback

Requirements:
Follow @LearnNEAR on Twitter
Explore How to use dWork

dWork Beta Test sprint ends on March 4th, 11pm ET.
Participate as a requester:

 	Create a Requester account
 	Create a new Task - capture a screenshot
 	Invite at least 3 of your friends to participate in your Task
 	Approve/Reject their work - capture your screenshot

Participate as a worker:

 	Create a Worker account.
 	Participate in at least five Tasks - capture a screenshot of  your submissions list
 	Tweet about this with a screenshot "I just completed jobs and earned NEAR at dWork project from @LearnNEAR LNC Barrel

Fill the Feedback form
The top 20 beta testers will get 2 NEAR, the best feedback submitter will get 10 NEAR. Please make sure your NEAR testnet and mainnet account MATCH exactly. – eg. john.testnet and john.near.

Happy testing!



 

### Crypto Best Practices: Tips For A Seamless Crypto Experience

The cryptocurrency space can be somewhat overwhelming, even to the most experienced of heads. As crypto gains more mainstream popularity, the risks to your assets also increase exponentially. Investors in crypto are increasingly concerned about the security of their investments and assets. While crypto-assets and cryptocurrencies are secured by platforms on which they are traded, investors and users of these exchanges need to be more proactive when securing their digital assets. 

It is imperative that users have a thorough idea of the cryptocurrency space before investing in cryptocurrencies. It is also essential to have an idea of the regulatory landscape in your country so that you would know the legal status of cryptocurrencies and how you can go about investing. Following a set of best practices is ideal for safeguarding your crypto investments and having a seamless crypto experience. 
Potential Risks To Crypto Consumers 
Volatility is a risk that is considered part and parcel of the crypto space. Any individual investing in crypto is well aware of the volatility aspects of crypto. However, several other risks could pose a significant threat to cryptocurrency investors and their investments. Some of these risks are 

 	Money laundering 
 	Fake investment scams through ICOs. 
 	Crypto pump and dump scams 
 	Fake cryptocurrency exchanges
 	Phishing scams.

Apart from the risks mentioned above, there is always the looming threat of hackers. Investors should always be alert towards the possibility of fraud, theft, loss of assets. Let’s look at some of the ways in which investors can safeguard their cryptocurrencies and ensure that they have a smooth crypto experience.

 


	

	
	
		
			
				Which of the following is not considered a sound strategy when investing in crypto?
			
		

		
					

		
			
			
			
			Studying and understanding the regulatory landscape in your jurisdiction before investing. 
		
			
			Carefully comparing cryptocurrency exchanges and checking which one works best for you. 
		
			
			Looking for the next Bitcoin or Ethereum 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Crypto Best Practices To Ensure A Seamless Crypto Experience 
Your crypto can be compromised through several avenues such as cryptocurrency wallets, a compromised exchange, or a compromised seed phrase. Here are a few simple steps that can go a long way in ensuring that you have a seamless crypto experience. 
Always Use A Strong Password 
When using an exchange to trade crypto, you will be required to create an account. It is imperative that you secure this trading account with a strong password consisting of numbers and special characters. A strong password is your first line of defense against any malicious hacker or party. Using a password manager also helps, allowing you to create and remember complex passwords. You can use password managers such as Dashlane to help you create a secure password. It is also imperative to change your password regularly and use a password manager, as mentioned above, along with Two Factor Authentication.




	

	
	
		
			
				What can be considered as potential risks to crypto investors?
			
		

		
					

		
			
			
			
			Fake investment scams through ICOs 
		
			
			Pump and dump scams 
		
			
			Money laundering 
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Use 2FA (Two-Factor Authentication) 
Along with keeping a strong password, implement 2FA when using cryptocurrency exchanges. Instead of using SMS authentication, you can use applications such as Google Authenticator or Authy. Ideally, it would help if you used the strongest 2FA allowed by the platform. Hardware security keys such as Yubikey are ideal, along with applications like Google Authenticator and Authy, which have already been mentioned above. If you have no choice and SMS-based 2FA, you should enable a one-time code to be sent to your mobile device every time you log into your crypto trading account. 
Safeguard Your Private Keys 
To store your cryptocurrencies, you will require a wallet that will hold your public and private keys to send, receive, and store cryptocurrencies. While your public address has to be shared with other users, you must not share your private keys with any individual or entity. If anyone gains access to your private key, then you could end up losing all the funds present in your wallet. The same applies to your private keys when it comes to your blockchain or trading account. You can secure your keys by following a few simple steps. 

 	Using a random key or passphrase
 	Maintaining control of your keys and not giving them up to a centralized exchange. 
 	Using a hardware wallet

Use A Cold Wallet 
As we know, cryptocurrency wallets fall into two categories, hot wallets, and cold wallets. Hot wallets offer ease and simplicity but also significant vulnerability. While you get easy access to your cryptocurrency, they are also vulnerable to security threats such as hacking. A cold wallet is what most experts in the crypto space recommend, especially if you intend to keep your cryptocurrencies for a significant amount of time. A cold wallet is essentially an offline wallet, meaning your assets are stored offline, securing your assets from any hacking attempts. Cold wallets ensure complete safety from threats you would usually have to deal with when using a hot wallet. Examples of cold wallets are hardware wallets and paper wallets. 
Adopt A Hybrid Approach 
Adopting a hybrid approach entails using both hot wallets and cold wallets. When using this approach, you can store your cryptocurrencies offline when they are not traded. However, when executing a trade, you can simply transfer the assets you intend to sell into your hot wallet, complete the trade, and then transfer your assets back into the cold wallet. 
Use A VPN
It is extremely important to use a secure internet connection when accessing your cryptocurrency trading account and making crypto transactions. Never try and conduct a trade on a public WiFi network, and even when using your home network, the use of a VPN is recommended for additional security. Using a VPN will help keep your browsing activity safe from potential hackers or malicious entities. It is also important to secure your personal device, which you would be using to conduct transactions. Always keep your device up-to-date, and ensure that you do not end up clicking on any malicious link or visit any malicious website. 
Don’t Put All Your Eggs In One Basket 
Just as with the traditional stock market, diversification is key in the crypto market. As an investor, diversification is always healthy for your crypto portfolio. Instead of putting all your money in, say BTC, investing in a combination of BTC, ETH, and a handful of other cryptocurrencies could help protect you from potential market volatility while also allowing you to benefit from multiple sources when the market is on a bull run. 
Due Diligence Is Key  
Before investing in a cryptocurrency, it is important to understand the underlying asset, its uses, and how it functions. Almost every coin has whitepapers available online, which can help you better understand the coin and improve your knowledge about the coin’s potential. If there is no whitepaper available or if the whitepaper does not mention or describe the coin’s functioning, then that coin is best avoided. 
Timing Is Also Key 
Just like due diligence, timing is also considered a key factor when it comes to investing in the crypto market. Think you know that there is to know about crypto, then you must be able to time your investment perfectly. The cryptocurrency market is volatile, and price swings are common. Don’t go around investing in new coins looking for the next Bitcoin or the next Ethereum. Always be thorough about the project before investing, follow price patterns, and keep track of the news to stay ahead of events that could negatively impact the value of your investment (exchange hack, price manipulation). Cryptocurrencies are highly speculative, so always do your homework before jumping into the space. 
Double Check All Transaction Details 
Remember, blockchain transactions are immutable, meaning once executed, they cannot be reversed. This makes it extremely important to double-check all transaction details before going ahead with the transaction. Your funds can only be reverted back to you if the opposite party agrees to do so. 
Don’t Invest More Than You Can Afford To Lose 
This is one of the most critical points that you should keep in mind as an investor. While cryptocurrencies may be considered as a safe haven, and yes, they are for countries that are for citizens of counties such as Venezuela, which is reeling under hyperinflation. But cryptocurrencies are a high-risk investment with significant volatility. What was profitable in the morning could be red in the afternoon. If you are a beginner, it is always advisable to start by investing lower amounts of money. 
In Closing 
Cryptocurrencies are a somewhat risky investment for beginners and for experienced heads. As a rule of thumb, high-risk investments should make up only a small portion of your portfolio. In the case of cryptocurrencies, it is always good to diversify your investments into several coins so that your investments can appreciate or depreciate at varying degrees, insulating you to some degree. 

The points mentioned above are generally considered as the most basic tactics you could employ to ensure a seamless crypto experience. The space is constantly in flux, and you must be proactive in ensuring the security of your investments and funds by thoroughly securing your accounts and wallets. Always keep yourself updated with the latest news and developments in the crypto space. 




	

	
	
		
			
				Using a strong password, 2FA, cold wallet, and a VPN when conducting transactions are considered part of crypto best practices 
			
		

		
					

		
			
			
			
			True 
		
			
			False
		
	
		

		
		
			
				Correct!
				Wrong!

### Как работает мост NEAR Rainbow Bridge

Статья Мэтта Хендерсона из Aurora

Rainbow Bridge на NEAR уникален в криптографии, он единственный, не требующий разрешения и доверия мост к Ethereum. В этой статье мы расскажем, как это работает! 

NEAR создал Rainbow Bridge — нечто уникальное и ценное в криптопространстве, полностью «надежный» мост для передачи токенов между Ethereum и NEAR. Rainbow Bridge - это Aurora. Несмотря на то, что существуют технические описания моста, в этой статье объясняется, как он работает простым языком. Думаю, те, кто хоть немного знаком с криптографией, поймут как работает этот мост.
Концепция
Давайте представим, что я хочу перевести 20 DAI из Ethereum в NEAR. Поскольку физическая передача токенов между сетями невозможна, это означает, что нам нужно вывести 20 DAI из обращения на Ethereum и ввести 20 DAI в обращение на NEAR, чтобы глобальное предложение DAI не изменилось. 

Вот как я мог бы сделать это без доверия и разрешения: 

 	Я сообщаю сети Ethereum, что хочу перевести 20 DAI куда-то еще. 
 	Сеть Ethereum блокирует мои 20 DAI в хранилище (смарт-контракт), чтобы они были изъяты из обращения. 
 	Убедившись, что эти 20 DAI заблокированы в Ethereum, я прошу NEAR создать для меня там 20 новых DAI. 
 	NEAR, конечно, мне не доверяет, поэтому просит доказать, что я заблокировал 20 DAI на Ethereum. 
 	Я предоставляю NEAR доказательство того, что я заблокировал эти DAI на Ethereum. 
 	NEAR самостоятельно проверяет мое доказательство, а затем создает 20 новых DAI для использования в NEAR. 

Позже, если я захочу перенести свой DAI из NEAR обратно в Ethereum, я просто отменю вышеописанную процедуру. Отлично, да? 
Деятели
Итак, теперь давайте посмотрим, как все это происходит на практике, используя Rainbow Bridge. Описание будет включать в себя ряд технических компонентов, из которых состоит мост: 

Пользовательский интерфейс Rainbow Bridge — это веб-сайт, на котором вы, как пользователь, взаимодействуете с мостом для передачи своих активов между сетями. 

LiteNode — это как узел обнаружения, за исключением того, что он хранит только заголовки блоков, что позволяет значительно увеличить пространство для хранения. LiteNode реализует как смарт-контракт, и у нас есть два из них — один в сети Ethereum, в которых находятся заголовки блоков NEAR, а другой расположен в NEAR, в которых находятся заголовки блоков Ethereum. 

( LiteNode на самом деле упоминается в других статьях как «легкий клиент». Если вы спросите меня: «Что хранит данные блокчейна?». Моя первая мысль будет «узел»,  так и в статье, чтобы помочь с моделями, я называю ее LiteNode.) 

Ретрансляторы. Поскольку LiteNodes — это смарт-контракты, они не могут запускаться и обновляться сами по себе. Ретрансляторы — это скрипты, работающие на традиционных серверах, которые периодически считывают блоки из одного блокчейна и передают их на LiteNode, работающий на другом. Таким образом, ретрансляторы поддерживают LiteNodes в актуальном состоянии. 

Поскольку существуют транзакционные издержки, т.е. плата за газ — каждый раз, когда ретранслятор обновляет LiteNode, узел в NEAR (содержащий блоки Ethereum) обновляется в каждом блоке Ethereum (поскольку плата за газ NEAR невелика), в то время как частота обновления в Ethereum (содержащая блоки NEAR) настраивается и определяется экономическим бюджетом (в настоящее время от 12 до 16 часов). 

Коннекторы. Коннекторы — это смарт-контракты, отвечающие за всю логику, связанную с межсетевым управлением активами данного типа. Как и LiteNodes, они существуют парами — один работает на Ethereum, а другой — на NEAR. Например, есть пара «коннекторов ETH», отвечающих за передачу ETH между двумя сетями. И есть пара «соединитель ERC-20», отвечающая за передачу токенов ERC-20. Кто-то может использовать коннектор «NFT», коннектор «Прогнозирование результатов рынка» или коннектор «Результаты голосования DAO», если пожелает. Любой актив или данные могут быть переданы через Rainbow Bridge, если существуют соответствующие коннекторы! 
Соберем всё воедино
Чтобы понять, как все эти элементы работают вместе, и позволяют мне без разрешения и без доверия передавать токены между Ethereum и NEAR, снова рассмотрим наш исходный пример: 

 	Используя пользовательский интерфейс Rainbow Bridge, я запускаю перевод 20 DAI из Ethereum в NEAR. 
 	Когда я подтверждаю первую из двух транзакций в MetaMask, Rainbow Bridge связывается с соединителем ERC-20 на Ethereum (поскольку DAI — это токен ERC-20), который передает и блокирует 20 DAI в своем хранилище. Эти DAI больше не используются в сети Ethereum. 
 	На основе данных заголовка в моем блоке транзакций пользовательский интерфейс Rainbow Bridge вычисляет криптографическое «доказательство» того, что я действительно заблокировал 20 DAI. 
 	Поскольку в следующий раз мы собираемся попросить сеть NEAR создать DAI на основе того, что только что произошло в Ethereum, мы сначала ждем, пока ретранслятор отправит около 20 заголовков блоков Ethereum на LiteNode, работающий на NEAR. Это сделано для безопасности, так же как ваша криптобиржа заставляет вас ждать некоторое количество подтверждений, прежде чем зачислить ваши средства. 
 	После этого ожидания пользовательский интерфейс Rainbow Bridge позволяет нам сделать второй шаг в этом процессе — попросить коннектор ERC-20 в NEAR создать для нас 20 новых DAI в сети NEAR. 
 	Когда мы отправляем этот запрос соединителю ERC-20, мы предоставляем наше криптографическое доказательство, которое мы получили ранее, «доказывая», что мы заблокировали 20 DAI на Ethereum. 
 	Коннектор ERC-20 на NEAR затем будет искать заголовок нашего блока Ethereum в LiteNode, работающем на NEAR, и произведет собственный независимый расчет криптографического доказательства. 
 	Если предоставленное нами доказательство совпадает с доказательством, которое вычисляет коннектор ERC-20, то он знает, что эти 20 DAI заблокированы в Ethereum — и что это я их заблокировал! Затем он приступает к созданию (чеканке) 20 новых DAI на NEAR и переводит их на мой кошелек. 

Когда мы хотим перевести DAI из NEAR обратно в Ethereum, процесс происходит в обратном порядке. Вместо того чтобы блокировать 20 DAI в NEAR, мы уничтожаем их — так называемое «сжигание»,  а затем предоставляем «доказательство» этого сжигания в Коннектор, работающий на Ethereum. Имея доступ к блокам NEAR в LiteNode, работающем на Ethereum, он подтверждает наше доказательство, выпускает 20 DAI из своего хранилища и отправляет их на наш кошелек! 

Кратко мы описали как работает Rainbow Bridge! В настоящее время это единственный мост Ethereum в криптовалюте, который работает таким образом, позволяя вам без разрешения передавать активы между Ethereum, NEAR и, вскоре, Aurora, без необходимости доверять третьим сторонам. Это очень круто!
Oстатки
Вот несколько интересных фактов, дополняющих этот обзор: 

 	Поскольку NEAR-to-Ethereum ретранслятор отправляет заголовки блоков NEAR в Ethereum LiteNode каждые 16 часов, при перемещении токенов в этом направлении между первым и вторым этапами возникает 16-часовая задержка. (Помните, это связано с тем, что сборы за газ Ethereum делают обновление LiteNode в каждом блоке непомерно дорогим для ретранслятора.) Существует ряд подходов, которые позволили бы нам уменьшить эту задержку, и команда активно работает над этим. 
 	На NEAR LiteNode хранит все прошлые заголовки блоков Ethereum. Чтобы пространство для хранения не вышло из-под контроля, LiteNode «обрезает» (удаляет) блоки старше двух недель. Это означает, что если вы начнете перевод из Ethereum в NEAR и уйдете в отпуск на три недели между первым и вторым этапами, вы не сможете завершить свой перевод, потому что данные Ethereum, хранящиеся в NEAR, необходимые для проверки вашего «доказательства», будут удалены! 
 	Интересное свойство заголовка блока NEAR заключается в том, что с помощью одного заголовка блока мы можем вычислить историю прошлых блоков за довольно длительный период. Так что теоретически LiteNode на Ethereum нужен только один блок NEAR. Однако мы сохраняем их, потому что затраты на газ, необходимые для выполнения обрезки, в основном были бы пустой тратой ресурсов. 
 	Команда, создавшая Rainbow Bridge, та же самая, что создала Aurora — NEAR EVM. Поскольку эта команда самостоятельная организация, Rainbow Bridge перейдет под ее управление для эксплуатации, обслуживания и будущего развития. 
 	Команда Aurora работает над «автоматической финализацией» Rainbow Bridge, чтобы вам больше не приходилось вручную инициировать второй этап этих переносов. Это будет очень удобно для пользователей (и это означает, что вы можете начать перевод Ethereum в NEAR, а затем отправиться в отпуск!) 
 	Передачи между Ethereum и Aurora выполняются Aurora Bridge, который использует ту же базовую технологию, что и Rainbow Bridge, но дополнен для обработки скрытого шага NEAR/Aurora в передаче. 
 	Пользовательский интерфейс и возможности Aurora Bridge отличаются от Rainbow Bridge и в будущем они будут унифицированы. 

Хотя некоторые технические детали были упрощены, теперь у вас есть общее представление о том, как работает Rainbow Bridge! 

Подробное описание Rainbow Bridge вы можете прочитать в этой статье, а чтобы быть в курсе всего, что связано с Авророй, обязательно подписывайтесь на Аврору в Твиттере! 

### Toп - 5 игр на NEAR

NEAR Protocol — это платформа смарт-контрактов, удобная для разработчиков и пользователей. Поскольку GameFi и игры на блокчейне развиваются с каждым днем, давайте посмотрим на некоторые игровые проекты, которые в настоящее время работают на NEAR. Сегодня мы рассмотрим:

 	Chain Typing
 	Pixel DApps: Pixelparty, Pixelpets, and Cryptoheroes.
 	Lands

Chain Typing
Chain Typing — это игра, в которой можно зарабатывать деньги, также она помогает повысить эффективность набора текста. Чтобы играть в игру, вам понадобится персонаж, представленный в таблице. Изначально для игры будет доступно только 30 персонажей. По мере масштабирования игры будут добавляться новые персонажи. Персонажей  можно использовать как рекламное пространство.



Пожертвования пойдут в фонды игры, чтобы помочь развитию игры. Плата за чеканку других персонажей также передается в фонд игры и не подлежит возврату.
Pixel DApps


Pixel DApps создала три игры для экосистемы NEAR, это: 

 	Pixelparty
 	Pixelpets
 	Cryptoheroes

#1 Pixelparty


PixelParty — одна из игр Pixel Dapps. Это витрина NFT Frame с общим запасом 600 токенов. У нее есть следующие особенности:

 	Каждый токен, которым вы владеете, позволяет вам рисовать на фрейме размером 20x20px. 
 	Пользователи могут покупать различные соединительные рамки, чтобы нарисовать рамку большего размера.
 	Все держатели фреймов получают вознаграждение от экосистемы pixeltoken.
 	Активные держатели фреймов могут участвовать в DAO. 

Вот как начать играть в PixelParty: 

 	Подключится с помощью своего NEAR кошелька
 	Выбрать и купить одну из доступных рамок.
 	Ваши рамки будут расположены на боковой панели. 
 	Вы можете рисовать, редактировать или размещать их на рынке. 

#2 Pixelpets


PixelPets — это игра, созданная Pixel DApps для обмена и сражения  питомцами. Это игра NFT, в которой каждый токен представляет один из 60 различных типов питомцев. Кроме того, у каждого питомца есть одна из четырех черт редкости — обычная, редкая, эпическая и легендарная. Черта влияет на различные атрибуты питомца, такие как сила, качество и уровень. В PixelPets вы можете: 

 	Вылупление: собирайте яйца животных и высиживайте их. Вы можете высиживать только одно яйцо за раз. Чем выше редкость питомца, тем больше времени требуется, чтобы высидеть яйцо. 
 	Тренировка: обучая своего питомца, вы повышаете ранг качества. Тренировать своего питомца вы можете отправив его в спортзал. 
 	Эволюция: набрав достаточное количество очков опыта и получив желаемый уровень качества, ваш питомец может перейти на следующий уровень в камере эволюции. 
 	Бой: получайте опыт, участвуя в дуэлях с другими петмастерами. Вы также можете сражаться в Колизее и зарабатывать призы и честь. 
 	Торговая площадка: покупайте и продавайте своих питомцев с помощью пиксельных токенов. 

#3 Cryptoheroes


Третья игра, созданная Pixel DApps - это Cryptoheroes.  Игра на основе блокчейна, ориентированная на грабеж, PvE, торговлю, создание предметов, а также на сражения с боссами с друзьями. Чтобы заработать PXT отправляйтесь в подземелья, побеждайте миньонов и собирайте добычу. 

Как зарабатывать PXT: 

 	Объединяйтесь со своими союзниками, чтобы участвовать в рейдах. Побеждайте злых боссов и соревнуйтесь за еженедельные награды PXT.
 	Собирайте предметы и продавайте их на рынке.
 	Улучшайте существующее снаряжение. 

Система рейдов 

 	В каждом рейде участвуют 8 игроков. 
 	Рейды проходят еженедельно. 
 	20 лучших игроков награждаются каждую неделю. 

NEAR Lands


NEAR Lands — это децентрализованная многопользовательская 2D-игра, основанная на блокчейне. Вы, как игрок, можете ходить или создавать пиксельную наземную игру с открытым миром. Игроки могут: 

 	Создавать своих персонажей и предметы.
 	Говорить с друзьями.
 	Взаимодействовать с другими участниками онлайн-вселенной.
 	Игроки могут исследовать ландшафт и создавать захватывающее и интерактивное онлайн-пространство. 

Вывод
Игровая экосистема NEAR еще молода, но стремительно развивается. Так что следите за обновлениями и новостями, чтобы не пропустить новые игровые проекты на NEAR.

### Интеграция с NEAR

Давайте начнем с трех основных параметров протокола NEAR:

 	Proof of Stake
 	Шарды
 	WASM смарт-контракт

Консенсус блокчейна Proof of Stake достигается за счет количества токенов, а не майнинга. NEAR почти мгновенно достигает завершения транзакции благодаря 1-секундному созданию блока.

Блокчейн сегментирован, что означает, что вызовы между контрактами являются асинхронными (не путать с синхронными, как в Ethereum или Solana). При написании на NEAR кода контракта вам нужно принять во внимание работу с факторной моделью.  Требование асинхронности необходимо, чтобы сегменты могли обрабатываться параллельно, что приводит к гораздо большей пропускной способности транзакций. Блокчейны, в которых смарт-контракты не сегментированы, просто достигнут потолка масштабируемости, разгрузка на GPU или ASIC (оставаясь синхронными) может только отсрочить этот потолок, но не приведет к экспоненциальному масштабированию.  

NEAR контракты — это код поддерживающий WASM, поэтому вы можете кодировать на любом языке, который может быть скомпилирован в WASM. В настоящее время AssemblyScript и RUST больше всего поддерживаются с соответствующими инструментами. 

Построить WebApp на протоколе NEAR (именно это и есть доступ Near) очень просто по сравнению с другими блокчейнами.

Давайте клонируем пример отсюда https://github.com/near-examples/counter
git clone https://github.com/near-examples/counter

yarn

















Нас интересуют только эти 2 папки и 1 файл. Assembly/ — это место, где находится наш смарт-контракт (который будет скомпилирован в WASM). src/ — это место, где находится наш  код интерфейса, взаимодействующий с контрактом. package.json — это место, куда помещаются наши дополнительные зависимости JavaScript.
















Ядро нашего контракта включает в себя хранение в цепочке, ведение журнала управления для сгенерированного чека и экспортированные публичные функции. Функции, которые устанавливают хранилище, должны быть вызваны, иначе их можно будет посмотреть (даже без учетной записи NEAR). 

Near поддерживает несколько типов коллекций (которые сами себя описывают) в Near-sdk-as.












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections
Вот основные из них которые вам понадобятся: 

 

 	storage.getPrimitive — get/set
 	persistentMap — set/get
 	persistentUnorderedMap — set/get/query/length

Мы не  включаем постоянный вектор, нам следует избегать его использования так как очень легко сжечь огромное количество итерационных векторов газа. Мы стараемся использовать наборы, когда это возможно. 

Значения по умолчанию для коллекций persistMap имеют суффикс.
let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log будет печатать вывод журнала в квитанции при вызове функции. Это полезно для управления потоком того, что произошло, особенно когда контракты становятся более сложными. Пример удобочитаемого контракта на чеканку, он имеет сообщение в журнале «alice.near отчеканил 5,0 ZOD из zod.near».  

Развернем наш контракт, для этого нам понадобится Near-Cli. 






npm install near-cli -g
Для развертывания создадим фиктивную учетную запись testnet. Учетные записи являются контрактами, и вы можете иметь только 1 контракт на учетную запись. Для создания нескольких контрактов вам необходимо использовать дополнительные учетные записи, contract1.me.near, contract2.me.near. 

Давайте вызовем функцию getCounter. 
yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
На выходе
View call: dev-1623290109414-64922580028342.getCounter({})
0
Увеличивает счетчик 

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Посмотрим на этот вызов в обозревателе блоков.https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342
Отлично.

Чтобы просмотреть функцию, мы можем использовать curl, но нам нужно проанализировать некоторые выходные данные командной строки, проще написать скрипт быстрого узла. Нам даже не нужен near аккаунт.






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
В следующем коде используется API RPC.  https://docs.near.org/docs/api/rpc чтобы запросить состояние контракта zodtv.near

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
Near деноминации 24, yocto.

3_000_000_000_000__000_000_000_000

3,0

На этом и завершим. А в  следующий раз рассмотрим работу с веб-интерфейсом, а также правильное получение баланса, состояния и много другого.

### Как создать игру “Играйте и зарабатывайте” на NEAR

Подробный обзор — Berry Club




Это руководство предназначено для того, чтобы помочь вам понять основные моменты, которые позволят вам создать игру, чтобы заработать c NEAR.

Возможно игра не сделает вас или ваших игроков богатыми, но вы поймете как работает механика Near, как небольшие транзакции очень полезны в простом пользовательском интерфейсе HTML5. В итоге вы сами сможете создать простую и увлекательную игру для фарминга.

Мы проанализируем смарт-контракт и файлы js/rust существующей фармерской игры berry club. Если вы примените те же методы к своим идеям игры, вы сможете получить еще лучшие результаты! 

Чтобы следовать технической стороне этого руководства, мы настоятельно рекомендуем проверить Near Pathway, чтобы создать транзакцию и создать свой первый смарт-контракт на Near. Концепции, представленные в этих материалах, не включены в это руководство. Вам будет намного проще изучать это руководство, если вы будете держать открытой вкладку связанного исходного файла во время чтения , потому что большая часть упомянутого кода имеет номера строк, но не воспроизводится здесь. Исходный репозиторий Berry Club был разветвлен для этого руководства, чтобы сохранить актуальность, поскольку код работает на блокчейне. Как вы увидите в следующем разделе, сама игра развивалась с течением времени и будет развиваться в дальнейшем, мы рассмотрим ее состояние на текущий момент . 
Интерфейс Berry Club
Berry Сlub создан на React, поэтому самое первое, что мы рассмотрим файл app.js, он расположен в папке src репозитория github, это сэкономит нам время при анализе контракта и позволит нам сосредоточиться на том, что нам нужно изучить:

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
После импорта react первой необходимой библиотекой будет bn.js, простая утилита для управления целыми или десятичными числами, многие функции  появятся в вашем интерфейсе с этой библиотекой, здесь она используется для управления транзакциями: 

const PixelPrice = new BN(“10000000000000000000000”);
Игра berry club основана на экономике недвижимости, есть доска, управляемая частью контракта, называемой board.rs, она разделена на пиксели, и у каждого пикселя есть цена, которую нужно заплатить, чтобы рисовать на нем. Механизм действия «вытягивания» является ядром фармерских способностей игры и будет подробно проанализирован, когда мы доберемся до смарт-контракта. 
Как вы можете видеть здесь, цена одного пикселя объявлена как константа в самом начале нашего приложения и может быть изменена с помощью инструментов внешнего интерфейса и библиотеки  bn.js. Второй инструмент - это Near sdk, который позволяет нам взаимодействовать с Near blockchain, как описано в  Figment Near. Первое использование API — это объявление используемых переменных контракта и обеспечение использования основной сети при запуске кода с URL-адреса berry club:

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Затем мы импортируем утилиты пользовательского интерфейса, чтобы построить наш интерфейс и позволить людям рисовать, реагировать на цвет, реагировать на переключение и реагировать на таймер. Первой из этих утилит, которая используется, является таймер, он используется для установки тайм-аута для обновления доски в строке 62. 

«Обновление» доски выполняется внешним интерфейсом для отображения обновленного состояния доски с помощью RPC-вызова смарт-контракта.
const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
Что мы видим здесь, на две константы больше, чем те, которые необходимы для обновления, последние две фактически используются для обработки пикселей после их рисования, и устанавливают временной интервал в один день для расчета вознаграждения. Другие константы служат для управления доской в соответствии со смарт-контрактом, и здесь мы впервые пересекаем концепцию линий, которая будет очень важна для понимания управления доской и является наиболее используемым элементом всего интерфейса: 

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
После разделения доски 50×50 мы сообщаем нашему интерфейсу, чтобы он извлекал только те строки, которые следуют за RefreshBoardTimeout, и рассматривал длину каждой строки как ширину доски, умноженную на 12, размер одной ячейки.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Пиксели учитываются пакетно, а не независимо, как при вызове действия рисования, так и при обновлении интерфейса. 

И последнее, но не менее важное: наш импорт включает настраиваемый компонент пользовательского интерфейса под названием Weapons,js: этот компонент был разработан позже в berry club, чтобы каждый пользователь мог загружать и рисовать на доске целое изображение, а также отчеканьте его на торговой площадке berrycards NFT. 
Механика DeFi
Строки между 27 и 51 показывают, как это децентрализованное приложение строит свои возможности ведения фарминга с помощью некоторых базовых механизмов DeFi, которые будут проанализированы в последних частях этого руководства. Сейчас мы лишь вкратце упомянем, что для того, чтобы нарисовать/купить пиксель, berry club проводит вас через пару операций DeFi на Ref.finance, используя свои собственные токены, авокадо для покупки пикселей и бананы, заработанные на купленных вами пикселях.







Существует простой клон uniswap, созданный для обмена бананов/авокадо, который работает на том же смарт-контракте, созданном для других токенов этой игры. Для игры также создан фармерский токен, который называется огурец. Он позволяет людям зарабатывать часть токенов, которые все пользователи, играющие в игру, платят за газ, чтобы рисовать на доске.







Как пользователи зарабатывают деньги
Это самый первый шаг, который мы делаем в коде смарт-контракта, но хотелось бы напомнить вам, что механика DeFi — не единственный способ, которым Berry club позволяет вам зарабатывать токены. У учетной записи есть определенный файл в смарт-контракте berry club, изучим его. Нам нужно знать, что в  учетной записи собирается некоторая информация, которая имеет решающее значение для механики фарма и заработка:

 	идентификатор учетной записи
 	 accountIndex для списка учетных записей, которые рисовали на пиксельной доске последний раз 
 	баланс 
 	количество пикселей
 	запрошенная временная метка (наносекунды, когда данная учетная запись запрашивала вознаграждение в последний раз)
 	фармерские предпочтения (бананы или огурцы) 

Последние два пункта предназначены для расчета вознаграждения , например, если у вас есть 5 пикселей в течение одного дня, вы получаете 5 бананов. Если вы покупаете у кого-то еще, их заработок уменьшается, потому что количество пикселей, которыми они владеют, уменьшается, сумма заработка рассчитывается, а временная метка обновляется с учетом нового количества принадлежащих пикселей. Как мы видим, вознаграждение рассчитывается на основе этих двух переменных. Операция, применяемая к учетной записи предыдущего владельца при отрисовке пикселя, называется «touch», и вы можете найти ее в файле account.rs. Владение единством одного пикселя является основой для заработка на berry club, таким образом, эта механика почти такая же, как интерфейс стейкинга NFT, вознаграждающий владельцев NFT. 

pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
Первоначальный владелец доски = 0, это сам контракт, и если найти предыдущего владельца невозможно, то используется контракт. Чтобы запустить игру, некоторые токены хранятся на счете контракта, и они всегда увеличиваются с использованием цены на газ, установленной для людей, чтобы покупать авокадо и бананы. Так что «хранилище» игры всегда заполнено некоторыми токенами для пользователей. Теперь вернемся к нашему интерфейсу. 

Цифры в цвета и обратно






Строки между 67 и 82 в app.js используются для декодирования чисел в цвета и обратно, чтобы элементы пользовательского интерфейса могли взаимодействовать с доской, определены две постоянные переменные - intToColor и rgbaToInt. Здесь мы видим, что для преобразования целого числа в цвет используются строковые методы, чтобы разделить 3 числа на красный, зеленый и синий: 

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
Чтобы преобразовать строку цвета в целое число, мы просто применяем функцию math.round() и используем полученное целое число.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
Строки ниже относятся к загрузке и выводу изображений на доске с помощью компонент,  мы не будем подробно рассматривать их. imgColorToInt и int2hsv преобразуют числа в два разных вида цветовых шкал, затем определяется TransparentColor и гамма изображение для печати с помощью generateGamma. В decodeLine мы преобразуем буфер в массив пикселей для печати на доске с использованием вышеуказанных цветов, перебирая их с помощью for. 

Первый конструктор React
В следующих строках app.js мы определяем конструктор, который будет определять состояния, его  мы будем использовать позже в нашем пользовательском интерфейсе для взаимодействия с блокчейном. 

class App extends React.Component {
  constructor(props) {
    super(props);
Определенные здесь состояния являются выбранным по умолчанию цветом и цветовой палитрой:







const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
И для таймера, который обновляет доску: 

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Затем определяются состояния, используемой учетной записи пользователя. Важно знать, вошел ли пользователь в систему, есть какие-либо ожидающие транзакции (определенные как pendingPixels). boardLoaded загрузит доску холста для рисования альфа-канала selectedCell, а состояния pickerColor определяют состояния интерактивных компонентов для добавления цветов на доску. pickingColor служит для выбора цвета с доски, а gammaColors полезно для печати изображения на доске вместе с состояниями WeaponOn и WeaponCodePosition. 

Эти и другие состояния, нужны для учетной записи, они дают возможность зарабатывать на игре при помощи пикселей и DeFi: 
owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
Последние три состояния настраивают таймер для последующего использования: 

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
Следующий список (строки 203-215) определяет объекты и действия, которые будут взаимодействовать с состояниями, впервые ссылаясь на элемент DOM, доску холста. 

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Наконец, мы определяем некоторые состояния после входа в систему: 

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Базовые взаимодействия
Теперь приступим к описанию взаимодействий на доске/холсте, связывая их с ранее определенными состояниями. Для этих взаимодействий мы используем функции. Первая будет использовать нашу предыдущую ссылку на элемент доски, чтобы создать его и сообщить информацию о типе движения мыши. При первом нажатии мы включаем режим наблюдения для запуска нашего таймера: 

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
И режим рендеринга изображения, если пользователь хочет разместить изображение на доске: 

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
Следующая важная часть, мы определяем, как интерфейс считывает движения мыши и касания доски:

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
Используемый код учитывает мобильных пользователей, создавая специальную функцию для расчета положения и добавляя прослушиватель на холст/доску для событий касания: canvas.addEventListener("touchmove", mouseMove). Затем эти взаимодействия используются для установки состояния selectedCell и отслеживания как начала, так и конца действия мыши/касания на холсте, а также его перемещения по каждой ячейке: 

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
Взаимодействие здесь работает с ранее определенными состояниями, например, палитра цветов позволяет нам выбирать цвета с доски и использовать их для рисования. Клавиша, используемая палитрой цветов — это клавиша alt, и мы можем загружать и печатать изображения на доске, только если палитра цветов отключена, потому что тогда мы активируем функцию generategamma. Таким образом, функцию pickcolor(), ссылающуюся на ячейку, можно будет использовать для установки одного пикселя или всей доски для рендеринга изображения: 

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
Теперь мы добрались до сути. Давайте рассмотрим смарт-контракт. Мы знаем, как рисовать пиксель в интерфейсе, но нам нужно привязать к ним транзакции, чтобы наш интерфейс был реальной игрой для заработка. Поэтому, пожалуйста, обратите внимание на то, что мы собираемся сделать, потому что даже если ваша игра выглядит совершенно иначе с точки зрения пользовательского интерфейса, механика заработка вполне может подойти для любой другой игры и будет объяснена здесь в самом простом виде.






Смарт-контракт Berry Club
Линии
Впервые мы познакомились с линиями в начале этой статьи, когда рассматривали определения состояний пользовательского интерфейса. Линии — важная концепция интерфейса berry club, это строки, на которые делится доска, и каждый пиксель в них — это часть метаданных. Они являются частью пользовательского интерфейса, который взаимодействует со смарт-контрактом, и они являются наиболее используемыми объектами игры. Мы потратим немного времени на анализ того, как они работают и используются для хранения данных с доски.

Прежде всего, в файле board.rs мы находим определение PixelLine сразу после определения Pixel: 
pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
Вектор (массив) строковых данных, разделенных по ширине доски. 

Затем мы определяем в PixelBoard как вектор PixelLines:
pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
Таким образом, каждая строка хранится на доске как отдельная запись с полем метаданных, называемым line_versions, которая увеличивается каждый раз, когда вы изменяете строку. Каждый раз, когда наш интерфейс извлекает доску, вы получаете 50 строк, а также метаданные для каждой строки, которые показывают, сколько раз строка была обновлена. Получая эти метаданные, интерфейс знает, сколько раз строка была изменена. Если строка была изменена по сравнению с предыдущей выборкой, вы извлекаете данные для каждого пикселя, если нет, вы просто этого не делаете.   

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
Это хороший способ хранения и извлечения данных из интерфейса, которые могут быть полезны для использования в вашей игре.







Транзакции
Давайте  вернемся к нашему пользовательскому интерфейсу в app.js, чтобы убедиться, что мы понимаем, как транзакциями управляют из внешнего интерфейса. Во-первых, нам нужна функция для проверки учетной записи, если что-то пойдет не так, и вот она: 

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Вы помните массивы _queue и _pendingPixels, которые мы определили в нашем конструкторе? Пора их использовать, так как транзакции управляются в зависимости от того, какие пиксели вы нарисовали на доске: 

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Давайте изучим это более детально. Мы создаем объект пикселей (вектор), мы модифицируем наш объект _queue, чтобы он соответствовал пикселям, и мы присваиваем его значение объекту _pendingPixel в асинхронной функции. 

Потом мы просто рисуем объект контракта, который вызывается из sdk, а действие для рисования (часть из действий, которые мы определили для пользователя) определяется в файле lib.rs . 
pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
Пиксели смарт-контракта — это цвет и идентификатор учетной записи. У нас есть старый владелец, который рисовал пиксель раньше, и новый владелец, который хочет нарисовать его сейчас. С помощью действия рисования мы получаем old_owner и заменяем его учетной записью нового владельца, изменяя значение цвета всех пикселей внутри вектора PixelRequest. Затем мы отправляем вознаграждение старому владельцу, взимая плату с нового. Временные метки для наград сбрасываются, и отсчет начинается снова с нуля, на один пиксель меньше для старого владельца и на один больше для нового. Действие setPixelRequest определено в файле board.rs нашего контракта, но давайте вернемся к нашему libs.rs. 

Вот так выглядит функция may_send_rewards:
impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
Не ленитесь и разберитесь в этом. Вот видео от автора проекта

Функция проверяет время в блокчейне (здесь мы не используем таймер в интерфейсе, потому что мы хотим быть уверенными!) и использует возможности фарма контракта по глобальной метке времени с помощью функций get_next_reward_timestamp() и last_reward_timestamp(). затем  вызывает get_expected_reward() для расчета вознаграждения, положенных учетной записи. 
pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
Итак, мы берем текущий баланс из учетной записи berry club (помните, у нас есть поле баланса в учетной записи?), текущее использование хранилища и затраты, а также порог безопасности 50 авокадо. Если баланс есть, мы делим его на 24 (часа) * 60 (минут) часть вознаграждения, что означает, что вы в основном получаете точно такой же баланс, который у вас есть один раз, если вы вызываете его каждую минуту. Вы можете найти его в начале файла lib.rs

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
Вы думаете процесс вознаграждения окончен ? Нет!

Нам нужно вернуться к нашей функции may_send_reward(), чтобы увидеть, что она вызывает новый контракт фарма berry club для распределения вознаграждений за стейкинг, которые представляют собой… огурцы, токен стейкинга на berryclub.  
const FARM_CONTRACT_ID_PREFIX: &str = "farm";
На самом деле это не единственный источник распределения доходов с помощью этой функции, он также использует затраты на газ, которые люди платят за покупку авокадо и обмен бананами.

Как это возможно? Прежде всего, GAS_BASE_COMPUTE определяется в файле token.rs, где задается количество газа для смарт-контракта. Цена на газ очень низкая, и ее можно использовать для вознаграждения пользователей, взаимодействующих с вашей игрой!!!

Чтобы лучше понять, как работают сборы GAS на Near, обратитесь к этой подробной документации!

### Что такое WEB 3.0 ?

NEAR — это децентрализованная платформа разработки, целью которой является создание экосистемы Web 3 с помощью масштабируемости и простоты в использовании. Давайте разберемся в Web 3 и тем, что он может сделать для экосистемы.
Потребность в WEB 3

Image Credit
Web 1.0 был разработан Бернерсом-Ли в 1990 году.  С тех пор он стал основой Интернета, таким мы его знаем и сегодня. Вот некоторые из основных столпов Web 1.0: 

 	HTML - код, который используется для структурирования и отображения веб-страницы и её контента. 
 	URL-адрес или унифицированный указатель ресурса — уникальный адрес для идентификации ресурса в Интернете. 
 	HTTP или протокол передачи гипертекста позволяют получать данные через Интернет.

Этот этап был действительно новаторским, веб-страницы были очень статичными и сильно отличались от профессионально разработанных веб-сайтов, к которым мы привыкли сегодня. Веб-страницы были далеки от интерактивных, новые понятия, такие как «электронная почта», станут важной частью нашей жизни в будущем. 

За последние пару десятилетий мы стали свидетелями подъема Web 2.0. Веб-сайты стали интерактивными. Но не в этом суть, давайте подумаем о компаниях, которые добились успеха за последние пару десятилетий: Meta, TikTok, Airbnb, Uber и т. д. Что их объединяет? Они процветают благодаря пользовательскому контенту или ресурсам. По сути, это был главный прорыв того времени. Настоящую масштабируемость можно достичь, только предоставив пользователям возможность активно участвовать в экосистеме. 

Web 2.0 процветал исключительно за счет централизации. Не верите ? Подумайте о количестве слушаний в Конгрессе, через которые пришлось пройти руководителям Google, Meta и Twitter, чтобы объяснить, что они делают с пользовательскими данными. Meta, в частности, была виновна в незаконном присвоении пользовательских данных. На самом деле пользовательские данные, которые они продавали Cambridge Analytica, были той самой основой, на которой строились президентские кампании в США. 
Что такое WEB 3.0?
Децентрализация 

Можно с уверенностью сказать, что децентрализация является основным принципом Web3. Идея состоит в том, что больше не будет центрального органа или централизованного совета директоров, которые контролировали бы рост компании и ее работу. В современном мире цензура платформ стала серьезной проблемой. Похоже, что если вы не следуете определенной политической идеологии, ваши мысли в конечном итоге будут удалены из социальных сетей. Компании намеренно делают определенные профили «труднодоступными», чтобы уменьшить распространение определенных идеологий. Твиттер открыто признал, что склонен подвергать цензуре профили. Основой Web3 будет сопротивление цензуре, вызванное децентрализацией. 

Отсутствие доверия

Это в значительной степени расширение точки децентрализации. В Web 2.0 вам приходится предоставлять конфиденциальную информацию третьим лицам. Чаще всего эти компании злоупотребляли имеющимися в их распоряжении данными, что приводило к огромным скандалам (Facebook и Cambridge Analytica). Теперь, в соответствии с децентрализацией, в компании не будет единого органа, контролирующего все важные данные. Приложения Web3 будут работать с использованием технологии блокчейна и одноранговой сети, чтобы обеспечить доверие и децентрализацию. 

Компоновка

Одним из важных аспектов Web3 будет его взаимосвязь и компоновка. Мы уже видели это в экосистеме DeFi (децентрализованные финансы) и IoT (интернет вещей). В DeFi несколько платформ могут соединяться друг с другом и создавать тесную экосистему, в которой вы можете воспользоваться многочисленными финансовыми инструментами. 

Искусственный интеллект 

Web3 будет использовать искусственный интеллект и машинное обучение (ML), чтобы дать своим системам возможность получать более быстрые и релевантные данные. 




	

	
	
		
			
				Вход на веб-сайт с помощью учетной записи Facebook является примером: 
			
		

		
					

		
			
			
			
			WEB 1.0
		
			
			WEB 2.0
		
			
			WEB 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Варианты использования Web3
У Web3 есть несколько вариантов использования. Цифровые валюты, NFT и другие объекты в пространстве криптографии и блокчейна становятся критически важными для Web3. Децентрализованные автономные организации или DAO также являются важным вариантом использования Web3, используя токены, чтобы сделать принятие решений более справедливыми и беспристрастными. 
Децентрализованные автономные организации (DAO)
Базовые знания о DAO и о том, как оно функционирует, очень полезны для понимания и участия в Web3. DAO — это организация, для работы которой не требуется центральный орган. Вместо этого он управляется своим сообществом и обеспечивает полную автономию и прозрачность. Смарт-контракты регулируют все основные правила. Контракты также выполняют любое решение, согласованное сообществом, при этом все процессы, включая голосование или предложения, общедоступны для проверки. По сути, DAO управляется отдельными членами, которые являются частью сообщества, коллективно принимающими важные решения относительно проекта, начиная от ассигнований и заканчивая обновлениями. 

Основная группа членов сообщества устанавливает правила для DAO с помощью смарт-контрактов, определяя структуру DAO. Эти смарт-контракты доступны для публичной проверки, что позволяет членам сообщества проверить каждый шаг, связанный с функционированием DAO. Члены сообщества могут создавать предложения, после чего все сообщество голосует за предложение. Как только предложение достигает уровня консенсуса в сообществе, оно принимается и одобряется смарт-контрактом. 

Структуру ДАО можно разделить на различные группы, такие как ДАО протокола, ДАО инвестиций, ДАО услуг, ДАО социальных сетей, ДАО грантов, ДАО коллекционеров и ДАО медиа. Некоторые из известных DAO, за которыми вы можете следить — это MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO, DAOhaus, Opolis, MolochDAO и BanklessDAO.




	

	
	
		
			
				Бернерс-Ли был пионером:
			
		

		
					

		
			
			
			
			WEB 1.0
		
			
			WEB 2.0
		
			
			WEB 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Чаевые
Децентрализованная экономика предлагает глобальное сотрудничество, которое позволяет участникам контролировать то, как они работают, распределять свое время и опыт с несколькими уже существующими и появляющимися инструментами, которые расширяют их возможности и их стиль работы. Чаевые — один из таких методов, который помогает росту сообществ web3, стимулируя участие. Прежде чем мы двинемся дальше, важно понять, что такое чаевые. В реальном мире мы даем чаевые человеку, который оказывает услугу. Чаевые часто даются домработницам, персоналу ресторана, доставщикам и другим лицам, которые помогают нам выполнять или выполняют определенные задачи для нас. В Web3 чаевые работают по тому же принципу, с той ключевой разницей, что перевод средств происходит через блокчейн. 

В Web3 члены сообщества могут получать чаевые за различные вклады, такие как добавление кода для проекта, ответы на вопросы, написание статьи или когда член сообщества делится своим опытом в проекте. Чаевые могут осуществляться в любой форме, начиная от аирдропов NFT и токенов и заканчивая чаевыми в ETH, USDC или любой другой криптовалюте. Чаевые участникам помогают укрепить доверие в сообществе, убедиться, что участники продолжают инвестировать в проект, а также стимулируют желание участвовать дальше в проекте. 

В настоящее время пользователи web3 получают чаевые в токенах NEAR в Twitter и Telegram. 
Вход с помощью вашего кошелька
Еще одна интересная вещь, которую меняет Web 3, — это процедуры входа в систему. Во времена Web 1.0 было два способа войти в учетную запись веб-сайта — либо по электронной почте, либо через уникальную учетную запись, созданную исключительно для этого веб-сайта. 

Затем, на этапе Web 2.0, вы могли входить, используя свою учетную запись Google или учетную запись Facebook. Хотя это было удобно, у этого все же был один существенный недостаток — перенос данных. Вам по-прежнему приходилось указывать свои платежные реквизиты отдельно, чтобы совершать покупки. 

Теперь, с Web 3.0, вы можете просто подключаться к различным веб-сайтам с помощью своего крипто валютного кошелька. Например, в OpenSea вам можно напрямую подключиться к MetaMask и совершать покупки. В Learn NEAR Club вы ДОЛЖНЫ войти своей учетной записью NEAR (кошельком), чтобы участвовать в мероприятиях (L)Earn. 



 

Работа с пользователями web3 позволяет dapps мгновенно передавать не только данные, но и деньги без участия посредников!
Роль NEAR в Web3
Благодаря своей масштабируемой и простой в использовании платформе протокол NEAR предоставляет платформу, которая позволяет создавать приложения DeFi и NFT с минимальными затратами.

DeFi TVL для NEAR составляет около 141,72 миллиона долларов. Это очень молодая экосистема, и в настоящее время она быстро растет. 



Самым большим приложением DeFi, на долю которого приходится более 80% общего TVL, является Ref Finance.  

Ref Finance имеет некоторое сходство с Uniswap V2, плюс он поддерживает больше типов пулов, настраиваемые сборы и полностью принадлежит сообществу. Ref также является первой платформой DeFi на NEAR. Основная цель Ref — объединить DEX, протоколы кредитования, эмитента синтетических активов и многое другое под одной крышей. 

NEAR недавно запустил огромный грантовый фонд в размере 800 миллионов долларов, который был специально направлен на создание более крупной  экосистемы DeFi. К фонду предъявляются некоторые основные требования: 

 	100 миллионов долларов для стартапов
 	100 миллионов долларов Региональный фонд 
 	250 миллионов долларов Экосистемные гранты, которые будут распределены в течение четырех лет.

Что касается NFT, на NEAR было создано несколько проектов, таких как Mintbase, Paras, Hip Hop Heads и т. д. 

Mintbase — самая популярная платформа NEAR NFT, поскольку она позволяет любому создавать NFT и делать его доступным для продажи, на своем рынке или на торговых площадках NFT, таких как OpenSea. Минтеры могут создавать смарт-контракты и ограничивать возможность передачи отчеканенных токенов, помогая предотвратить мошенничество или незаконную передачу уникальных предметов. Mintbase ориентирован на создание уникального опыта создания NFT, он поддерживает различные цифровые активы. Это отличает его от конкурирующих платформам, которые фокусируются на одной конкретной категории NFT.
Обратная сторона – слишком ли много шума?
Недавно этот мем гулял по Твиттеру Его комментировали такие люди, как Джек Дорси и Илон Маск. 


Image credit
На данный момент приложения Web3 привлекают огромное внимание венчурных фондов Силиконовой долины. Это вызывает главный спорный момент. Будут ли приложения Web3 в прямом смысле децентрализованными с таким количеством заинтересованных сторон? Дорси и Маск в это не верят. Тем не менее, будет интересно посмотреть, во что это выльется в будущем. 




	

	
	
		
			
				Что из нижеперечисленного не требует центрального органа для функционирования: 

			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook

		
	
		

		
		
			
				Correct!
				Wrong!

### Обзор Octopus Network

Общее понимание Octopus Network для конечного пользователя.

Осьминог сильно отличается от человека. Вместо центральной нервной системы, как у людей, две трети нейронов осьминога разбросаны по всему его телу и распределены по его щупальцам. Эти нейроны могут принимать решения самостоятельно без участия мозга, что, по сути, делает осьминога децентрализованной разумной формой жизни.

Octopus Network — это совместимая с несколькими цепями криптосеть, которая эмулирует осьминога. Подобно щупальцам осьминога, каждая подключенная цепочка приложений (appchain) наделена собственным интеллектом и механизмами принятия решений для адаптации к постоянно меняющимся условиям. При объединении в единое целое все участники извлекают выгоду из значительных сетевых эффектов и экономии за счет масштаба — создавая Интернет блокчейнов.



Octopus Network — это многоцепочечная криптосеть для запуска и работы блокчейнов приложений Web3.0 — appchains.

Аппчейны в сети Octopus Network выигрывают от гибкой и экономичной  безопасности (LPoS), совместимы с несколькими цепочками, полной инфраструктуры и готового к работе сообщества.

Сеть Octopus снижает стоимость запуска аппчейна с нескольких миллионов долларов до менее ста тысяч долларов, запуская 3-ю инновационную волну криптосетей.
Эволюция приложений Web3.0
Web3.0 еще не было. Но, основываясь на первых данных, мы уверены, что в конечном итоге это произойдет. 

Рынок идет туда, где наименьшие транзакционные издержки, точно так же, как вода всегда течет вниз по склону.

Платформы Web2.0 принадлежат и управляются компаниями, цели которых напрямую связаны с максимизацией акционерной стоимости. Они извлекают как можно больше прибыли из экономической деятельности, которую они координируют. Криптосети — это рынки цифровых услуг с минимальными транзакционными издержками. Таким образом, у платформ Web2.0 просто нет защиты от того, чтобы в конечном итоге их заменили криптосетями. 

Web3 относится к децентрализованным приложениям, работающим на блокчейнах, которые принадлежат сообществу пользователей, а не корпорациям, извлекающим прибыль. Web3.0 стремится вернуть ценность настоящим создателям. 

Но платформы Web2.0 отлично подходят для пользователей Интернета. Чтобы приложение Web3.0 вытеснило приложение Web2.0, оно должно быть в первую очередь хорошим веб-приложением и обеспечивать взаимодействие с пользователем, по крайней мере, такое же хорошее, как и его аналог Web2.0.  

При разработке приложений Web3.0, как правило, приходится жертвовать пользовательским интерфейсом, потому, что технология распределенного реестра связана с большей сложностью и более высокими затратами, чем Web2.0, что приводит к ухудшению UX. 

Надвигается 3-я волна инноваций в криптосети, и она принесет с собой новые решения для приложений Web3.0.
3-я волна инноваций в криптосети
Биткойн — это блокчейн для конкретных приложений (appchain),  первый и самый удачный.

Вдохновленные биткоином люди, с 2011 по 2015 год разработали ряд других блокчейнов. Некоторые пытались улучшить биткоин, в то время как другие были нацелены на различные варианты использования, отличные от валюты. Многие проекты уже не работают. Общепризнанная причина этого заключается в том, что блокчейн биткойна не подходит для решения других вариантов использования путем разветвления или масштабирования. Мы можем назвать этот период «1-й волной инноваций в криптосети». 

Вторая волна инноваций в криптосети появилась вместе с Ethereum. Ethereum — это децентрализованная вычислительная платформа, оснащенная виртуальной машиной Turing-Complete (которая теоретически может выполнять любые вычисления, пока остается в пределах ограничения сложности, также известного как лимит газа). Основной язык программирования EVM - Solidity,  его синтаксис похож на Javascript, прост в освоении и очень хорошо контролирует активы в сети. 

Ethereum позволил тысячам разработчиков создавать децентрализованные приложения (dApps). К сожалению, очень немногие смогли удержать пользователей в течение длительного периода времени до взрыва DeFi в 2020 году. 

Ключевой проблемой, стоящей перед Ethereum, является масштабируемость, а плата за газ, для запуска смарт-контрактов, сделала некоторые варианты использования очень дорогими. В то время как Ethereum 2.0 нацелен на решение этих проблем с помощью протокола сегментированного блокчейна, Ethereum 2.0 представляет собой многолетнюю дорожную карту с неизвестными рисками выполнения. 

Тем не менее, третья волна инноваций в криптосети не за горами. Фреймворки блокчейна, такие как Substrate и Cosmos SDK, могут предоставить разработчикам приложений Web3.0 огромные возможности для проектирования. 

Теперь разработчики могут создавать полностью оптимизированные приложения Web3.0, создавая аппчейн. 


Что такое Appchain?
Децентрализованное приложение или dApp — это веб-приложение, но хотя бы часть его серверной части находится в блокчейне. Серверная часть dApp может быть реализована двумя способами: смарт-контракты могут быть размещены на платформе блокчейна, или децентрализованное приложение может работать на собственном блокчейне.

Когда у dApp есть собственный блокчейн, он называется аппчейном для конкретного приложения или сокращенно appchain. В отличие от dApps, аппчейн позволяет разработчикам настраивать приложения со своей структурой управления, дизайном и,  лежащего в их основе, алгоритмом консенсуса.  

Аппчейн также предоставляет разработчикам выделенные возможности обработки транзакций, а это означает, что приложение в цепочке приложений не должно конкурировать с другими приложениями за пропускную способность обработки транзакций в сети. 

Для примера, в то время как тысячи различных приложений могут использовать стандартный набор конфигураций на универсальной платформе смарт-контрактов, каждый аппчейн в PoS может легко достичь пропускной способности 1K + TPS и быстрой завершенности —  вся эта мощность обработки транзакций будет выделена только для одного приложения. 

В отличие от смарт-контрактов, аппчейны могут быстро развиваться благодаря легитимности. Каждый аппчейн представляет собой самоуправляемую экономику с четко определенными кодовыми процессами для достижения консенсуса об обновлениях протокола. И, благодаря Substrate, основная функция сетевого управления готова к использованию. Любая криптосеть может отражать процесс управления другой с помощью копирования и вставки кода. Управление блокчейном может развиваться подобно программному обеспечению с открытым исходным кодом. 

Тем не менее, нельзя игнорировать тот факт, что смарт-контракты отлично подходят для случаев использования при торговле активами, например, DeFi. Поскольку смарт-контракты работают на основе одних и тех же предположений о безопасности, компоновка между ними является важным фактором для взрыва DeFi. 

Хоть пользовательский опыт DeFi не такой большой, как онлайн-банкинг, у него все еще есть много преимуществ, особенно с учетом более функционального блокчейна уровня 1, чем Ethereum, такого как NEAR Protocol.
Почему Octopus выбрал NEAR?
Хотя Substrate и Cosmos SDK снизили стоимость разработки аппчейна до уровня,  сравнимого со смарт-контрактами, загрузка аппчейна по-прежнему остается технически сложной и емкой работой для разработчиков. 

NEAR Protocol — это блокчейн на Proof-of-Stake(PoS), в котором особое внимание уделяется масштабируемости и удобству. NEAR часто называют готовым решением масштабируемости для существующих приложений Ethereum dApp, но оно в равной степени способно работать с набором других типов децентрализованных решений, таких как аппчейн.

По сравнению с другими платформами 1 уровня , которые могут поддерживать аппчейн, такие как Polkadot или Cosmos, NEAR имеет некоторые ключевые технические и экономические преимущества.  

По сравнению с Cosmos запуск аппчейна на NEAR проще, поскольку валидаторам не нужно загружать каждый аппчейн.

Например, в Cosmos каждый аппчейн должен защищать себя с помощью достаточного количества децентрализованных валидаторов. Таким образом, разработчики аппчейна должны сначала получить признание ценности собственного токена аппчейна на рынках крипто активов, а затем запустить активное сообщество валидаторов с нуля.

По сравнению с Polkadot, NEAR предлагает аппчейнам значительно более дешевую аренду безопасности и не имеет ограничения на количество аппчейнов, которые можно запустить.   

Парачейн Polkadot должен позволить себе согласованную стоимость одного сегмента сети, которая может равняться десяткам миллионов долларов в год. 

В вычислительной системе более высокий уровень безопасности не обязательно означает более высокий уровень безопасности, потому что высокий уровень безопасности всегда сопряжен с высоким уровнем затрат. Итак, вычислительная система нуждается в подходящей и адекватной безопасности. 

Кроме того, высокие затраты на безопасность с самого начала могут привести парачейн к гиперинфляции, потому что он должен выдать большой объем нативных токенов кредиторам Crowdloan. По крайней мере, это экономическое бремя оставляет парачейну очень мало возможностей для стимулирования реальных создателей стоимости его протокола — участников, которые помогают создавать сетевые приложения криптосети. 

Проще говоря, Octopus выбрала NEAR, а не Polkadot и Cosmos, потому что они  более рентабельны, масштабируемы, удобны для пользователя и совместимы с такими сетями, как Ethereum.

Мы верим, что аппчейны станут 3-й волной инноваций в криптосетях, которая приведет нас к Web3.0, и что сеть Octopus сделает аппчейны доступными для множества проектов с любым бюджетом.




	

	
	
		
			
				Что такое appchain?
			
		

		
					

		
			
			
			
			децентрализованные приложения
		
			
			общий блокчейн
		
			
			приложение для конкретного блокчейна
		
			
			смарт-контракт
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Преимущества арендованного PoS (LPoS) 

Что такое безопасность в блокчейне?

Проще говоря, безопасность — это уровень уверенности в том, что предопределенные протоколы будут применяться в соответствии с ожиданиями большинства заинтересованных сторон — будь то на базовом уровне или на уровне приложений. 

Безопасность блокчейна обычно считается количественным свойством. Не может быть абсолютной или неограниченной безопасности. Если блокчейн обладает абсолютной безопасностью, он непригоден для использования и недоступен по цене. 

По сравнению с общей моделью безопасности парачейна Polkadot, сеть приложений Octopus Network Leased PoS (LPoS) гораздо более масштабируема и гибка. Поскольку лизинг ценных бумаг по сути является лизингом капитала или залоговым лизингом, он масштабируется без физических ограничений. 

В Polkadot каждый парачейн будет содержать определенное количество валидаторов в пуле исключительно в любую заданную эпоху. Алгоритм консенсуса ограничивает общий размер пула. (Вот почему ожидается, что общее количество парачейнов будет менее 100, а в этом году будет доступно менее 10 слотов для парачейнов.) 

Арендованный PoS Octopus намного экономичен, чем Polkadot. Поскольку у Octopus нет собственного блокчейна, а токен $OCT выпускается и управляется смарт-контрактом. Octopus не нужно напрямую оплачивать затраты на консенсус. Таким образом, уровень инфляции в $OCT можно установить равным нулю, что означает, что базовая процентная ставка экономической системы Octopus равна нулю. 

Когда базовая процентная ставка равна нулю, годовой доход в размере 3-5% является приличным годовым доходом (в этом диапазоне ожидается, что аппчейн будет платить за свои арендованные ценные бумаги). Напротив, парачейн Polkadot должен платить 20% или больше APY, чтобы стать привлекательным для кредиторов Crowdloan $DOT, потому что ставка на Polkadot Relay даст инвесторам безрисковый годовой доход в размере 14%. 

Поскольку LPoS — это безопасность, основанная на потребностях, и предлагает аппчейнам рычаг для органического масштабирования, мы считаем, что LPoS больше способствует долгосрочному развитию аппчейнов, чем независимый PoS. Однако мы также считаем, что право выбора всегда принадлежит любому сообществу аппчейна.

Если какая-либо аппчейн в сети Octopus решит прекратить использование LPoS, чтобы преобразоваться в независимый блокчейн PoS, Octopus предоставит инструменты для поддержки трансформации — его соединение с сетью Octopus будет понижено до уровня стандартного моста IBC. и существующие межсетевые активы не будут затронуты.  
Обзор сети Octopus

Условные обозначения: D-делегатор, S-стейкинг, V-валидатор, RT-время выполнения, N-нода 
Ретранслятор Octopus расположен в ядре сети Octopus. Octopus Relay — это набор смарт-контрактов, работающих на блокчейне NEAR (также известном как mainchain), который реализует рынок лизинга ценных бумаг. 

Аппачейны Octopus находятся на стороне спроса на рынке. Аппачейны Octopus арендуют безопасность у держателей $OCT, оплачивая арендную плату их собственными токенами. Каждый аппачейн может выбрать собственную экономическую модель, включая количество нативных токенов, которые она готова заплатить валидаторам за безопасность.  

Валидаторы и делегаторы Octopus находятся на стороне предложения на рынке лизинга ценных бумаг. 

Валидаторы Octopus размещают токены $OCT для проверки конкретной аппачейна и настраивают узел для запуска протокола этого аппачейна. В свою очередь, валидаторы имеют право на получение соответствующего нативного токена аппачейна, который они проверяют. 

Делегаторы Octopus могут делегировать свои $OCT валидаторам для получения доли вознаграждения за стейкинг нативного токена аппачейна. Награды за стейкинг распределяются среди делегаторов сразу после того, как валидаторы собирают единую комиссию.

Если валидаторы ведут себя некорректно (например, выходят из сети, атакуют сеть или запускают модифицированное программное обеспечение), они (и их делегаторы) сокращаются, теряя процент от поставленных ими $OCT. Все наказания применяются к делегатам пропорционально, когда их валидаторам наносят удар. Таким образом, стейкинг действует как сдерживающий фактор для злонамеренного поведения. 

Поскольку держатели $OCT несут ответственность за решение, на какой аппчейн они хотели бы сделать ставку, сеть Octopus Network работает как свободный рынок, где аппчейн могут в любое время арендовать необходимый им уровень безопасности по рыночной цене. 

Сеть Octopus также имеет ряд инструментов для поставщиков безопасности, таких как инструменты автоматического развертывания и управления валидатора аппачейна, экономические представления сети и инструменты статистического анализа. 

Рынок Octopus Network LPoS позволяет любому разработчику, проекту или предпринимателю быстро, эффективно и недорого создать свой собственный аппчейн на NEAR. 

Octopus Network также поддерживает аппчейны многими другими способами, включая обеспечение взаимодействия между аппчейнами, встроенную инфраструктуру и готовое к участию сообщество. 




	

	
	
		
			
				Какие преимущества LPoS? 
			
		

		
					

		
			
			
			
			LPoS экономически выгоден
		
			
			LPoS гибкий
		
			
			LPoS масштабируемый
		
			
			все перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Совместимость
Сейчас нельзя утверждать, что все общедоступные блокчейны и аппчейны в конечном итоге будут взаимосвязаны, образуя Интернет блокчейнов. Сеть Octopus специально разработана, чтобы быть частью этого. 

Команда Octopus (ранее известная как Cdot) уже более двух лет работает над универсальным протоколом взаимодействия блокчейнов IBC и межсетевой интеграцией. 

Octopus Relay обеспечивает совместимость аппчейна с протоколом NEAR и Ethereum через Rainbow Bridge. Кроме того, аппчейны могут использовать готовый IBC для прямого подключения к любым блокчейнам с поддержкой IBC.

Любой актив, выпущенный на Ethereum, NEAR или любом блокчейне с поддержкой IBC, может быть передан и использован аппчейном Octopus без каких-либо доверительных отношений. И наоборот, любые активы, выпущенные в аппчейне, могут быть переведены в Ethereum, NEAR и любой блокчейн с поддержкой IBC.  

Благодаря полной совместимости Octopus Network с NEAR, разнообразие крипто активов, выпущенных в аппчейнах Octopus, будет способствовать процветанию экосистемы DeFi NEAR. 
Инфраструктура
Сеть Octopus предоставляет полный набор инфраструктуры для аппчейнов, включая API Gateway, Blockchain Explorer, Archive Gateway и т. д. 

Octopus Bridge развернет контракт-оболочку NEP-141 на NEAR для каждого нативного токена аппчейна. Кошельки и биржи смогут интегрировать стандартные токены-оболочки вместо того, чтобы интегрироваться с каждым аппчейном по отдельности. 

Таким образом, командам создающим аппчейн нужно сосредоточиться только на среде выполнения Substrate и разработке внешнего интерфейса, в то время как сеть Octopus обрабатывает все остальные технические потребности.
Сообщество
Криптосеть принадлежит сообществу. В этом суть децентрализации и принципиальное отличие от платформ Web2.0. 

Сеть Octopus выступает в качестве мета-сообщества для поддержки сотен сообществ приложений Web3.0. Разработчики приложений Web3.0 и основатели аппчейна могут продемонстрировать достоинства своей криптосети, чтобы привлечь различных сторонников, таких как инвесторы, валидаторы, делегаторы и участники протокола.

Пользователи, интересующиеся различными приложениями Web3.0, обратят внимание на свои любимые приложения благодаря таким событиям, как запуск сети приложений Octopus. Таким образом, Octopus является базой сообщества для аппчейна, чтобы поддерживать их собственный путь создания активных сообществ вокруг себя.  

Сеть Octopus также обеспечивает отличную возможность разветвления всех аппчейнов, что делает бессмысленным захват аппчейна любыми магнатами или корпорациями без согласия сообщества, сохраняя ее децентрализованной. Octopus будет обслуживать все свои аппчейны с возможностью разветвления, архивируя историю блоков аппчейнов в Arweave — протокол децентрализованного постоянного хранения. 

Основываясь на заархивированной истории блоков, каждый аппчейн может быть разветвлена на любом уровне, чтобы стать новым аппчейном, если его сообщество поддержит разветвление. И любую основную команду аппчейна можно заменить, если она потеряет доверие своего сообщества. Вот как участие пользователей обеспечивает децентрализацию.
Что из себя представляет программа Octopus Accelerator?
 



Команда Octopus прекрасно осознает, что пространство блокчейна по-прежнему является лишь кусочком всей интернет-индустрии. И в пространстве блокчейна разработчики смарт-контрактов Solidity гораздо более продуктивны, чем разработчики Substrate. 

Чтобы найти и привлечь хорошие проекты аппчейнов, нужно превратить разработчиков Web и Solidity в разработчиков Substrate. В этом команда Octopus очень опытна. 

Команда Octopus успешно сделала IBC для Substrate, а также предложила онлайн-курсы по Substrate в Китае с другими энтузиастами Substrate. Эти курсы обучили первую группу разработчиков в Китае, положив начало роста китайского сообщества Substrate. Разработчики Octopus также являются организаторами сообщества Rust в Китае (включая RustCon). 

На сегодняшний день многие члены команды Octopus работали ассистентами преподавателя курса, который теперь является официальным курсом, финансируемым Parity Inc. Основываясь на этом опыте, мы ведем переговоры с партнерами по всему миру, включая образовательную команду NEAR, чтобы предоставить аналогичные учебные курсы по всему миру.

Но Octopus признает, что квалифицированные разработчики Substrate — это еще не все, что требуется для успешных проектов приложений Web3.0. Вот почему мы запускаем программу Octopus Accelerator — набор открытых и составных курсов,  семинаров, доступных как для разработчиков Substrate, так и для команд Web3.0 по всему миру. 

Каждый квартал программа Octopus Accelerator будет проводить серию курсов продолжительностью десять недель. В течение каждого периода курса предлагаемые предметы будут включать такие темы, как экономика токенов, дизайн продукта Web3.0, построение сообщества, управление блокчейном, регулирование криптовалюты и сбор средств для проекта криптовалюты. Приглашенные эксперты будут участвовать в семинарах, презентовать видеоматериалы по конкретным темам и выступать в качестве наставников. 

В конце каждой серии курсов Octopus Foundation будет проводить мероприятие Demo Day, чтобы выбрать пять лучших проектов аппченов и предоставить им  вознаграждение в размере до 250 000 долларов США в квартал. 

Таким образом, Octopus Foundation будет напрямую финансировать 20 проектов по аппчейнам через программу Octopus Accelerator каждый год, предоставляя им в общей сложности более 1 миллиона долларов.




	

	
	
		
			
				Что верно в отношении команды разработчиков Octopus? 
			
		

		
					

		
			
			
			
			команда разработчиков Octopus создала IBC для Substrate
		
			
			команда разработчиков Octopus помогала обучать первых разработчиков Substrate в Китае
		
			
			команда разработчиков Octopus раньше была командой Сdot
		
			
			все перечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Как аппчейн запустить в Octopus


Архитектура сети Octopus в сочетании с вычислительной мощностью протокола NEAR упрощает размещение сотен аппчейнов. Процесс выбора аппчейна является частью протокола Octopus, а полномочия по принятию решений принадлежат сообществу Octopus.

Владельцы токенов $OCT не только являются валидаторами и делегаторами аппчена, но и имеют право выбирать лучшие проекты аппчейна, голосуя за или против.

Аппчейны на основе Substrate могут стать аппчейнами Octopus, успешно пройдя следующие этапы:  

 	Регистрация 
 	Аудит 
 	Голосование 
 	Постановка 
 	Загрузка 

Этап регистрации
Любая аппчейн на основе Substrate может стать аппчейном Octopus. Для регистрации требуется технический документ или спецификация, а также версия среды выполнения, прошедшая внутреннее тестирование и аудит. Во избежание злоупотреблений при регистрации требуется внести небольшой депозит в токенах $OCT.
Этап аудита
После регистрации аппчейна, члены рабочей группы сообщества проведут ее аудит. Цель аудита — убедиться, что в аппчейне нет известных уязвимостей безопасности и что логика приложения соответствует официальному документу или спецификации. 

Аудит аппчейна, в настоящее время, является неудовлетворенной потребностью в пространстве блокчейна. Только несколько компаний в отрасли имеют соответствующий опыт, но  услуги, которые они предоставляют, стоят дорого. 

Аудит, проводимый Octopus Network, не только значительно снижает стоимость запуска аппчейна для ее основателей, но и способствует накоплению актуальных знаний и профессиональных возможностей. 
Этап голосования
После того, как аппчейн прошел фазу аудита, он попадает в очередь кандидатов, где за него проголосуют держатели $OCT. 

В течение периода, который обычно длится от одной до двух недель, аппчейн, который занимает первое место с наибольшим количеством голосов «за» за вычетом «против» в очереди, войдет в промежуточное состояние как наиболее поддерживаемый сообществом Octopus. 
Этап подготовки
На промежуточном этапе держатели $OCT могут делать ставки или делегировать в аппчейн свои токены.

По окончании промежуточного периода, если аппчейн привлек достаточное количество токенов, сверх минимального уровня безопасности, он перейдет в состояние загрузки.  
Этап загрузки
На этапе загрузки члены целевой группы запустят 4 ноды, чтобы запустить аппчейн. Валидаторы должны запустить свои ноды, чтобы присоединиться к консенсусу аппчейна. 

Сеть Octopus также будет запускать полный кластер нод для каждого аппчейна и предоставлять услуги доступа API к внешнему интерфейсу аппчейна. Разработчикам аппчена нужно просто обновить конфигурацию внешнего интерфейса, и аппчен готов для конечных пользователей. 
Награды аппчейна
Octopus понимает, что проекты аппчейнов создают ценность для сети. В то время как другие сети взимают плату за доступ к аппчейнам, Octopus считает, что команды аппчейнов наиболее важны для сообщества и очень рад поделиться с ними преимуществами расширения сетевого эффекта. 

Таким образом, первые 100 запущенных аппчейнов Octopus получат  вознаграждение в размере 100 000 долларов США. 

Также фонд решил предоставить дополнительные вознаграждения в размере 1 млн долларов США для первых десяти аппчейнов, чтобы признать их аппчейн-основателями. 
Что такое токен $OCT?
$OCT -  это токен Octopus Network, представляет собой взаимозаменяемый неинфляционный токен с тремя основными функциями:

 	Залог, гарантирующий безопасность аппчейна
 	Управление
 	Одобрение кандидатов в аппчейн путем голосования за них 

Обеспечение безопасности
$OCT играет ключевую роль в сети Octopus, благодаря стекингу аппчейна. Владельцы делают ставки своими токенами $OCT, чтобы обеспечить безопасность аппчейна, и получать вознаграждение в токенах соответствующих аппченов. 

Ставка $OCT также служит сдерживающим фактором для злоумышленников, которые будут наказаны сокращением их $OCT, что является источником арендованной безопасности для аппчейнов Octopus. 

Когда Octopus заработает на полную мощность, ежегодно в сети будет запускаться 30-50 аппчейнов.

Если долгосрочная доходность стейкинга AppChain составляет 5% в год, только недавно запущенные AppChain будут ежегодно приносить около 400 миллионов долларов.
Управление
Вторая функция $OCT — предоставить владельцам право управлять сетью (точнее, Octopus Relay, где применяются все экономические правила) путем формирования Octopus DAO. 

Совет Octopus DAO насчитывает менее 100 членов, но, скорее всего, он вырастет.

Каждый член Совета важен, но все же достаточно рассредоточен, чтобы избежать сговора. 

По нашему мнению, в большинстве случаев ценность управления токеном не может быть отделена от его полезности. Надежное управление с широким участием даст держателям токенов более стабильные стоимостные ожидания и подавит резкие колебания цены токена, тем самым снизив неявные опционные затраты на стейкинг аппчейна.
Голосование в аппчейне
Третья функция $OCT — это выбор , какие аппчейны будут продолжать жить в сети, путем голосования за или против кандидатов в аппчейн.

Команды Appchain должны будут убедить сообщество Octopus в том, что их приложение Web3.0 имеет смысл и создает ценность для инвесторов, которые вкладывают $OCT в их аппчейн.

Владельцы $OCT будут тщательно выбирать, какие аппчейны они поддерживают, поскольку аппчейны которые не так ценны, создают издержки. 
Вывод
Мы назвали Octopus Network в честь самого умного морского существа - осьминога. С эволюционной точки зрения, осьминоги, насчитывающие около 300 видов,  невероятно успешные организмы. Они существуют уже 155 миллионов лет, обитают в каждом океане, и многие их  виды успешно адаптировались к разным средам обитания. 

Мы ожидаем, что Octopus Network будет поставлять децентрализованные приложения для каждой онлайн-индустрии, которую до сих пор контролировал традиционный посредник Web2.0, и возвращать ценность настоящим создателям. 

В сети Octopus мы можем создавать приложения Web3.0 с отличным пользовательским интерфейсом, используя технологию аппчейна — будь то игры, NFT, DAO, реклама, создатели (видео, аудио, графика, текст), рынки прогнозов, токены, и многое другое.

3-я волна инноваций в крипто сетях в настоящее время начинается на базе универсального Octopus, принося с собой потенциал для волны децентрализованных инноваций Web3.0, ограниченных только воображением.

### Update - February 22, 2022

Brief Summary:

 	February nLEARNs Redeem to NEAR Window was the HU-U-U-GE!

Results:

 	💸 Ⓝ850sent to 425 (L)Earners. Congrats and happy (L)Earning!
nLEARNs farmers were detected, LNC community working on how to determine and mitigate such activities.
 	🏆🏅🥇 Dapplets Developers contest - more than 100 $NEAR in Awards! Register NOW!

 	🕵 Check out Neatar Security Analysis by Pessimistic
 	📲 (L)Earners help one another and get NEAR tips for legit questions and answers at LearnNEAR.Club Official Telegram group

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	It is gonna be SUPERHOT spring! Stay tuned!

### Neatar Security Analysis by Pessimistic

Please take a look at  Blockchain Security Analysis of NEATAR - project of LNC Barrel.

Audit provide by Pessimistic

"The audit showed four issues of high severity. Also, several low-severity issues were found.
The only provided documentation for the project is a readme.md file in the repository. The
code base is thoroughly covered with tests."

Explore more here: Neatar Security Analysis by Pessimistic (public) (pdf) 

### NEAR-Protokoll und Polygon

Polygon hat in den letzten Monaten eine Menge an Popularität gewonnen. Da Skalierbarkeit in der Ethereum-Community in aller Munde ist, macht es Sinn, dass Layer-2-Lösungen wie Polygon eine so große Anhängerschaft gewonnen haben. NEAR Protocol bietet jedoch nicht nur eine hoch skalierbare Plattform auf der Basisschicht, sondern auch eine Layer-2-Erfahrung, die zudem auch noch mit der EVM kompatibel ist. Heute wollen wir diese beiden Projekte miteinander vergleichen.
Was ist Polygon?
Um Polygon zu verstehen, sollten wir uns zunächst Layer-2 Skalierbarkeitslösungen im allgemeinen ansehen. Im Ethereum-Netzwerk ist die Ethereum-Blockchain als "Layer-1" bekannt. Bei dezentralen Netzwerken stehen Sicherheit und Verfügbarkeit im Vordergrund, was unweigerlich zu Lasten der Geschwindigkeit geht. Die Lösung besteht darin, ein zusätzliches Netzwerk oberhalb der Kern-Blockchain aufzubauen, das als Layer-2 bezeichnet wird. Die Blockchain delegiert komplexe Berechnungen an Layer-2, was den Gesamtdurchsatz exponentiell beschleunigt. Polygon ist ein Beispiel für eine Layer-2-Lösung.

Der native Token des Polygon-Ökosystems ist MATIC. Die Hauptnutzen des MATIC-Tokens sind:

 	Zahlungs- und Abrechnungszwecke zwischen Teilnehmern.
 	Staking und Governance. Um so mehr MATIC gestaked werden, um so weiter erhöht sich das Wahlrecht.
 	Bezahlen von Transaktionsgebühren.
 	Belohnung der Nutzer für die Bereitstellung von Rechenressourcen und Dienstleistungen.

Die MATIC hat eine feste Obergrenze von 10 Milliarden Token.
Polygon Mechanik
Polygon hat ein mehrstufiges Ökosystem, das EVM-kompatible Sidechains verwendet. Der Zweck dieser Sidechains ist es, die Hauptchain zu entlasten. Sidechains sind Neben-Blockchains, die mit der Hauptkette über eine Zwei-Wege-Verbindung verbunden sind. Die Sidechain kann ihre eigenen, einzigartigen Regeln und ihr eigenes Ökosystem haben. In regelmäßigen Abständen sollen die Sidechains Daten an die Hauptblockchain übertragen, um einen reibungslosen Betrieb zu gewährleisten.

Entwickler erstellen ihre eigenen Sidechains, um ihre Anwendungen zu skalieren, indem sie den Polygon SDK-Stack verwenden. Polygon hat vor allem deshalb an Popularität gewonnen, weil es viel billiger und schneller ist als das Ethereum Mainnet ist.

Polygon verwendet einen Proof-of-Stake-Mechanismus (PoS) und jeder kann ein Validator werden, indem er seine MATIC-Token staked. Validatoren haben die folgenden Aufgaben im Ökosystem:

 	Validierung von Transaktionen durch Freigabe und Bestätigung von Tauschvorgängen in den Sidechains.
 	Netzwerk-Validatoren können sich um die Governance kümmern, indem sie über verschiedene Upgrades abstimmen.
 	Verantwortlich für die Auswahl von Blockproduzenten für jeden Kontrollpunkt (mehr dazu in Kürze).

Polygon-Sidechains sind ein Teil des Ethereum-Ökosystems, in dem Nutzer ihre Projekte schnell ausführen können, ohne sich um überhöhte Gaspreise und langsamen Durchsatz sorgen zu müssen.

Wie Polygon Geschwindigkeit und Dezentralisierung sicherstellt

Polygons PoS wird hauptsächlich für "Checkpointing" verwendet. Das bedeutet, dass für jeden Checkpoint ein Team von Blockproduzenten ernannt wird, die für die Aufrechterhaltung und Sicherstellung des Konsenses verantwortlich sind. Mit einer begrenzten Anzahl von Produzenten kann Polygon Blöcke viel schneller bilden als Ethereum (1 Sekunde Blockrate anstelle von 20 Sekunden).

Darüber hinaus stellt Polygon die Dezentralisierung sicher, indem es PoS-Kontrollpunkte in regelmäßigen Abständen an die Ethereum-Haupt-Blockchain delegiert. Jeder einzelne Block, der vom Blockproduzenten (Nodes) erstellt wird, muss durch einen Proof of Block validiert werden, der an die Ethereum-Blockchain übermittelt wird.

Wie kann man mit Polygon interagieren?

Dies ist, was Sie tun müssen, um mit einem Projekt auf der Polygon Sidechain zu interagieren:

 	Identifizieren Sie den Vertrag im Ethereum-Netzwerk und deklarieren Sie die Anzahl der Token, die Sie an die Polygon-Sidechain senden möchten.
 	Ein spezieller Smart Contract namens "RootChainManager" aktiviert einen weiteren Contract namens "ChildChainManager". Diese beiden Verträge arbeiten im Tandem, um sicherzustellen, dass die Anzahl der Token, die Sie im Ethereum-Netzwerk sperren, nahtlos in das Mainnet übertragen wird.
 	Nun kann der Nutzer zum Polygon-Netzwerk wechseln und seine Token entgegennehmen.

Und wie sieht es andersherum aus? Was ist, wenn Sie das Polygon-Ökosystem verlassen und zu Ethereum zurückkehren möchten? Dies sind die Schritte, die Sie befolgen müssen:

 	Sie müssen Ihre Token auf Polygon brennen.
 	Die Verifizierung dieser Verbrennung muss an die Ethereum-Mainchain gesendet werden.
 	Nach der Verifizierung werden Ihnen Ihre Ressourcen in Ihrer Ethereum Mainnet Wallet wieder zugewiesen.

Was ist das NEAR-Protokoll?
Im Sommer 2018 schufen Illia Polosukhin und Alexander Skidanov das NEAR-Protokoll als ideale Entwicklungsplattform für dezentrale Anwendungen. Die meisten anderen Plattformen leiden unter niedrigen Geschwindigkeiten, geringem Durchsatz und schlechter Kompatibilität mit anderen Ketten. 

Das NEAR-Protokoll wurde von Grund auf neu entwickelt und verfügt über die folgenden Merkmale, die eine gute Skalierbarkeit und Sicherheit ermöglichen:

 	NEAR verwendet einen Blockerzeugungsmechanismus namens "Doomslug". Doomslug ermöglicht eine praktische oder "Doomslug"-Finalität, die sicherstellt, dass die Blöcke innerhalb von Sekunden ihre Finalität erhalten.
 	NEAR ist ein Sharded-System, das eine unendliche Skalierbarkeit ermöglicht. Es verfolgt einen einzigartigen Ansatz, um Milliarden von Transaktionen vollständig dezentral zu skalieren, anstatt von zentralisierten Prozessen wie bei anderen Protokollen abhängig zu sein.

Was ist Sharding? 

Um mit dem letzten Punkt fortzufahren, sollten wir verstehen, was Sharding ist. Sharding ist eine Technik, die in Datenbanken verwendet wird, um große Datenmengen zu verwalten. Beim Sharding wird die gesamte Datenbank in überschaubare Teile, sogenannte "Shards", aufgeteilt. Diese Shards können für schnelle Berechnungen parallel verarbeitet werden.

Was genau passiert nun in einer Blockchain beim Sharding? Schauen wir uns das mal an:

 	Der gesamte Blockchain-Status wird in kleinere Shards aufgeteilt.
 	Jedes einzelne Konto gehört zu einem einzigen Shard und kann nur mit den Konten interagieren, die zum selben Shard gehören.

Das Problem beim normalen Sharding ist, dass die Knoten auf immer komplexerer Hardware laufen müssen, was die Einstiegshürden senkt. Das Sharding von NEAR ermöglicht es kleinen Knoten, auf einfachen, in der Cloud gehosteten Instanzen zu laufen.

Was ist Aurora?

Aurora bietet eine Ethereum-kompatible Layer-2-Erfahrung auf NEAR und besteht aus der Aurora Bridge und der Aurora Engine. Ethereum-Entwickler können ihre Anwendungen in Aurora ausführen, um die Vorteile der verschiedenen positiven Funktionen von NEAR zu nutzen, wie z. B. Gasgebühren und Sharding. Insgesamt sind dies die Verbesserungen, die Aurora mit sich bringt:

 	Apps können ein Vielfaches von Tausenden von Transaktionen pro Sekunde verarbeiten. Dies ist eine exponentielle Verbesserung gegenüber Ethereum.
 	Aurora ist extrem schnell, da es eine Blockzeit von 2 Sekunden hat, verglichen mit Ethereums 15 Sekunden.

Das Sharding von NEAR ermöglicht dem Ökosystem eine horizontale Skalierung.

Die Gebühren auf Aurora sind 1000-mal niedriger als die auf Ethereum. 

Vollständig kompatibel mit Ethereum über das NEAR-Protokoll. 
DeFi auf NEAR und Polygon
Polygon DeFi
Polygon ermöglicht es, die meisten der beliebten DeFi-Apps zu nutzen, die auf Ethereum verbreitet sind, wie Curve Finance, 1inch Exchange und Beefy Finance. Laut DappRadar sind die Top 5 Apps von Nutzern in den letzten 24 Stunden wie folgt:



Sushi scheint bei weitem die beliebteste App zu sein.

Das zunehmend begeisterte DeFi-Ökosystem von Polygon ist ein beeindruckender Anblick. Das folgende Bild zeigt Ihnen den Gesamtwert (TVL) in Polygon, der derzeit rund 5,19 Milliarden Dollar beträgt.



Die TVL erreichte am 15. Juni 2021 einen Höchststand von 10,54 Milliarden Dollar. Was den tatsächlich gebundenen Wert betrifft, so ist Aave mit einem Anteil von 40 % am gesamten TVL mit Abstand das größte Protokoll.
NEAR DeFi
Im Vergleich zu Polygon verfügt NEAR DeFi über ein noch sehr junges Ökosystem, das in den letzten drei Monaten stetig gewachsen ist. Im Moment beträgt das TVL nur etwa 141,72 Millionen Dollar.



Die dominierende DeFi-App, auf die über 80 % der gesamten TVL entfallen, ist Ref Finance.

Ref Finance weist einige Ähnlichkeiten mit Uniswap V2 auf, unterstützt aber mehr Pooltypen und konfigurierbare Gebühren und ist vollständig in Gemeinschaftsbesitz. Ref ist außerdem die erste DeFi-Plattform auf NEAR. Das Hauptziel von Ref ist es, DEX, Leihprotokolle, Emittenten synthetischer Vermögenswerte und mehr unter einem Dach zu vereinen.

NEAR hat vor kurzem einen gigantischen Zuschuss Fonds in Höhe von 800 Millionen Dollar aufgelegt, der speziell auf die Schaffung eines größeren und gesünderen DeFi-Ökosystems abzielt. Der Fonds hat einige wichtige Anforderungen, zu denen die folgenden gehören:

 	100 Millionen Dollar für Start-ups
 	100 Millionen Dollar für regionale Fonds
 	250 Millionen Dollar für Ökosystem Zuschüsse, die über vier Jahre verteilt werden sollen.

NFT auf NEAR und Polygon
Polygon NFT
Polygon ist eine der drei Blockchains, die derzeit auf Opensea (einem der größten NFT-Marktplätze der Welt) verfügbar sind, zusammen mit Ethereum und Klaytn. Gemäß der Rangliste der Website sind hier die Top 5 NFTs auf Polygon:



Es scheint, als sei ZED RUN der unangefochtene Spitzenreiter, wenn es um Polygon NFTs geht. 

Also, was ist ZED? Es ist ein nachweislich faires digitales Pferderennspiel, das auf der Blockchain basiert. Die Idee ist, dass Sie so viele Rennpferde wie möglich sammeln, um einen hochwertigen Stall aufzubauen.


NEAR NFT
Derzeit gibt es mehrere NFT-Plattformen auf NEAR wie Mintbase. Mintbase wurde 2018 von Nate Geier und Calorine Wend gegründet und erhielt in einer Seed-Finanzierungsrunde im Jahr 2020 1 Million US-Dollar. Die Plattform ermöglicht es Nutzern, mit NFTs unterlegte Vermögenswerte zu erstellen und zu verkaufen. Darüber hinaus können die Nutzer verschiedene digitale Vermögenswerte als NFTs prägen. Diese Vermögenswerte können von Veranstaltungstickets bis hin zu Kryptokunst und allem dazwischen reichen.



Interessanterweise sollte Mintabase eigentlich auf Ethereum starten. Die hohen Gasgebühren und die zunehmende Überlastung hinderten sie jedoch daran, dies zu tun. Stattdessen sah Mintbase in NEAR eine bessere Plattform als Ethereum, mit deutlich niedrigeren Gasgebühren dank eines effizienteren Vertragsausführungs Modells.
Fazit
Polygon hat im letzten Jahr stark an Zugkraft gewonnen, wobei Layer-2 heißer als je zuvor ist. Darüber hinaus hat es aufgrund seiner engen Beziehung zur Ethereum-Community eine rasche Akzeptanz erfahren.

Auf der anderen Seite hat NEAR durch die Lösung von Skalierbarkeits Problemen mit Sharding vielversprechend gewirkt. Außerdem wird die 800-Millionen-Dollar-Förderung für Entwickler eine erhebliche Menge an Nutzen in das Netzwerk bringen. Beide Protokolle - Polygon und NEAR - bieten eine perfekte Plattform für Entwickler, um eine skalierbare und effiziente dezentralisierte Wirtschaft aufzubauen.

### Die 7 wichtigsten NEAR NFT-Projekte

Das Wachstum von DeFi hat NFTs in den Fokus des Mainstream. Dabei traten allerdings auch einige Probleme hervor. Die Ethereum Blockchain hat eine Monopolstellung in diesem Bereich, da viele NFTs auf der Ethereum-Blockchain erstellt werden. Was ist also das Problem bei der Erstellung von NFTs auf einer der beliebtesten Plattformen der Welt? Das Problem der hohen Gasgebühren. Ethereum hat ein großes Problem, wenn es um Gebühren geht, die potenziell Hunderte von Dollars überschreiten können, was es sehr unpraktisch macht NFTs auf dieser Blockchain zu minten, bzw zu erstellen. 

Was sind also die Optionen für NFTs und NFT-Projekte? Welche anderen Möglichkeiten gibt es für sie? Das NEAR-Protokoll hat mehrere wichtige Projekte auf seiner Plattform und wird oft als der Ethereum-Killer angepriesen. Das NEAR-Protokoll ist eine skalierbare Blockchain, welche die Entwicklung von dApps vereinfacht und beschleunigt. Derzeit gibt es 19 dezentrale Plattformen und NEAR NFT-Marktplätze, um NFTs auf der NEAR-Blockchain zu prägen und zu handeln. Das NEAR-Protokoll hat einen erheblichen Vorteil gegenüber Ethereum, da es deutlich schneller ist als Ethereum und Transaktionen so gut wie nichts kosten, was es zu einer idealen Plattform für den Handel mit NFTs macht
NEAR-Protokoll und NFTs
Das NEAR-Protokoll ist die perfekte Plattform für NFTs, da es viele Vorteile gegenüber Ethereum hat. Das Protokoll ist deutlich schneller als Ethereum. Ethereum hat auch wesentlich höhere Gasgebühren, während NEAR die Abwicklung von Transaktionen zu einer vernachlässigbaren Gebühr ermöglicht. Diese Faktoren machen NEAR ideal für den Kauf und Verkauf von NFTs.

Wie bereits erwähnt, gibt es bereits mehrere NFT-Projekte, die auf der NEAR-Blockchain erstellt wurden. Bevor wir jedoch einen Blick auf die Projekte werfen, sollten wir kurz das Konzept der NFTs verstehen.
Die Bedeutung von Non-Fungible
Ein “fungible token” ist ein Vermögenswert, der gegen einen anderen identischen Vermögenswert getauscht werden kann. Bitcoin ist ein hervorragendes Beispiel für einen fungiblen Vermögenswert, was bedeutet, dass Sie einen Bitcoin problemlos gegen einen anderen Bitcoin eintauschen können. Nicht-fungible Vermögenswerte hingegen sind einzigartige Vermögenswerte, die nicht gehandelt werden können. Ein Beispiel für einen nicht fungiblen Vermögenswert ist ein einzigartiges Gemälde oder eine limitierte Auflage eines Sammlerstücks.

Ein nicht fungibler Vermögenswert hat eine bestimmte Eigenschaft oder Eigenschaften, die ihn von anderen Vermögenswerten unterscheiden. Nicht-fungible Token basieren auf nicht-fungiblen Vermögenswerten und sind einzigartige digitale Vermögenswerte, die die Blockchain-Technologie nutzen.
Was ist ein NFT?
NFTs sind einzigartige digitale Vermögenswerte, deren identifizierende Informationen in einem Smart Contract gespeichert sind. Die Informationen auf dem Smart Contract machen eine NFT einzigartig. Fungible Assets wie Bitcoin können getauscht werden, d.h. Sie können Bitcoin ohne Probleme senden oder empfangen. Fungible Assets sind auch teilbar, so dass Sie kleinere Beträge senden können. Nicht-fungible Vermögenswerte sind nicht teilbar. Sie können zum Beispiel nicht einen Teil eines Gemäldes oder einer Eintrittskarte an jemanden schicken.

NFTs sind digitale Eigentumszertifikate für digitale Vermögenswerte. Ein NFT ist ein Smart Contract, der zur Sicherung eines digitalen Vermögenswerts verwendet wird. Sobald er geschrieben ist, wird er in einem Token (ERC-721) auf der Blockchain veröffentlicht. Alles kann in einen NFT umgewandelt werden, wobei Videos, GIFs oder JPEGs die beliebtesten sind.




	

	
	
		
			
				Welcher der folgenden Begriffe ist ein NFT?
			
		

		
					

		
			
			
			
			 Bitcoin
		
			
			Fiat Währung
		
			
			Ein digitales Sammlerstück
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFT-Projekte auf dem NEAR-Protokoll
Derzeit gibt es mehrere NFT-Plattformen auf NEAR, also lassen Sie uns einen Blick auf einige der beliebtesten Projekte auf der Plattform werfen.
Mintbase
Mintbase wurde 2018 gegründet und wurde von Nate Geier und Calorine Wend ins Leben gerufen. Nate Geier ist der CEO des Unternehmens, während Caroline Wend der COO ist und ihr Know-how in den Bereichen Management und Geschäftsentwicklung einsetzt. Mintbase konnte in einer Seed-Finanzierungsrunde im Jahr 2020 1 Million US-Dollar aufbringen. Die Runde wurde von Sino Global geleitet und bestand auch aus anderen VCs wie Block Oracle Capital, D1 Ventures und anderen Angel-Investoren.

Fish Woman von From my Dream

Die Mintbase-Plattform ermöglicht es Benutzern, NEAR NFTs zu erstellen und zu verkaufen. Benutzer können verschiedene digitale Vermögenswerte als NFTs prägen. Diese Vermögenswerte können von Veranstaltungstickets bis hin zu Kryptokunst und allem dazwischen reichen.

Mintbase ermöglicht es so gut wie jedem, der Zugang zum Internet hat, ein NFT zu erstellen und ihn auf dem NEAR NFT-Marktplatz oder auf NFT-Marktplätzen wie OpenSea zum Verkauf anzubieten. Minters können einen intelligenten Vertrag erstellen und die Übertragbarkeit der geprägten Token einschränken, um Betrug oder die illegale Übertragung einzigartiger Gegenstände zu verhindern. Mintbase konzentriert sich darauf, ein einzigartiges NFT-Erstellungserlebnis zu schaffen, weshalb es, wie bereits erwähnt, verschiedene digitale Vermögenswerte unterstützt. Dies steht im Gegensatz zu konkurrierenden Plattformen, die sich auf eine bestimmte NFT-Kategorie konzentrieren.
Warum hat Mintbase zu NEAR gewechselt?
Warum also der Wechsel von Ethereum zu NEAR? Die Antwort sind die Gas-Gebühren. Die Ethereum-Gas-Gebühren wurden langsam lächerlich teuer. Um NFTs auf Mintbase zu prägen, muss ein Benutzer einen digitalen Speicher erstellen. Dazu muss der Nutzer einen Smart Contract erstellen und Ethereum eine Gas-Gebühr zahlen. Anfänglich war die Gebühr niedrig, und die Nutzer konnten den Laden schnell einrichten. Mit zunehmender Überlastung des Ethereum-Netzwerks wurden die Gebühren jedoch immer höher, so dass die Erstellung eines Geschäfts Hunderte von Dollar kostete. Die Kosten wurden so hoch, dass Mintbase seinen Nutzern sagen musste, sie sollten warten, bis die Gaspreise sinken, bevor sie einen Shop einrichten. Ethereum wurde schnell untragbar, um NFTs zu kaufen, zu verkaufen oder zu erstellen.

Mintbase sah in NEAR eine im Vergleich zu Ethereum bessere Plattform, die dank eines effizienteren Vertragsausführungsmodells deutlich niedrigere Gasgebühren bietet. Außerdem verwendet es Nightshade, einen dynamischen Ansatz für Sharding. Es gibt jedoch noch mehrere andere Gründe, warum Mintbase zu NEAR gewechselt hat.

 	Die Verwendung von Rust oder AssemblyScript für Smart Contracts auf der NEAR-Plattform erleichtert den Entwicklern das Schreiben von Code
 	NEAR bietet menschenlesbare Adressen sowohl für Verträge als auch für Konten
 	Entwickler können dank NEAR Drops Nutzer schnell einbinden. Sie können für ihre NEAR-Konten bezahlen und NEAR-Tokens senden.
 	Entwickler und Nutzer können dank der ETH-NEAR Rainbow-Bridge schnell Vermögenswerte bewegen
 	Andere DeFi-Plattformen wie Aave und Balancer sind ebenfalls an NEAR angeschlossen, was eine zukünftige Integration leicht machen wird.




	

	
	
		
			
				Warum hat Mintbase zu NEAR gewechselt?
			
		

		
					

		
			
			
			
			Hohe Gas-Gebühren
		
			
			NEAR ist eine bessere Plattform
		
			
			Entwickler können Assets schneller verschieben
		
			
			Alle oben genannten Punkte
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras wurde mit der Vision gegründet, die Lösung für alternde traditionelle Sammelkarten zu bieten. Die Plattform validiert das Eigentum über die Blockchain durch schnelle und kostengünstige Transaktionen. Die Plattform konzentriert sich auf die Erstellung von kryptonativen Sammlungen, die weiter in prominentere Medien diversifiziert werden können.

PunkyPoN#0006 by monztre.near

Paras ist ein All-in-One-Marktplatz für digitale Kunstkarten, welcher auf NEAR basiert. Die Plattform kann die Eigentümerschaft validieren und den Nutzern Zugang zu jedem Kauf und jedem Mint geben. Sie bietet schnelle und günstige Transaktionen und unterscheidet sich von anderen Marktplätzen durch das Angebot von Sammlungen anstelle von Einzelausgaben. Die Plattform unterscheidet sich auf folgende Weise.

 	Paras reduziert den Wartungsaufwand für Sammler, indem es sicherstellt, dass ihre Sammlerstücke nicht mit der Zeit verschleißen. Die Plattform beseitigt Barrieren und ermöglicht Künstlern und Sammlern einen einfachen Zugang zum digitalen Sammlermarkt. Dank des NEAR-Protokolls kann Paras die Kosten, die Künstlern beim Verkauf ihrer Karten entstehen, reduzieren
 	Paras entwickelt das Digital Art Card-Vertical für zukünftige Künstler, Gamer und Kreative und ermöglicht es Künstlern, eine Sammlung zu erstellen, die mit einem Thema oder einer Überlieferung verknüpft ist. Durch diese Methode sind die digitalen Kunstkarten in Paras reich an Geschichten und Hintergründen.

Paras ist in der Lage, einen kuratierten Ansatz zu verfolgen und eine NFT-Community und -Erfahrung zu schaffen. Paras gewährleistet Konsistenz und Qualität durch die Auswahl von Künstlern und Formaten. Die Anzahl der Künstler, die neue Karten auf Paras erstellen können, ist auf 30 pro Woche begrenzt. Außerdem müssen die Künstler das Standard-Seitenverhältnis von 64:89 einhalten.




	

	
	
		
			
				Was ist Paras?
			
		

		
					

		
			
			
			
			Ein All-in-One-Marktplatz für digitale Kunstkarten
		
			
			Eine Smart Contract Plattform
		
			
			Eine Programmiersprache
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Seit dem Start der Plattform haben die Künstler auf Paras bereits mehr als 25.000 $ verdient, wobei die Plattform ein Handelsvolumen von mehr als 35.000 $ aus über 700 Transaktionen ermöglicht hat. Die Plattform hat mehr als 80 aktive Sammler und über 70 Künstler. Die niedrige Mint-Gebühr hält die Einstiegshürde für digitale Künstler ziemlich niedrig, und die Künstler können Karten minten, ohne sich um die Mintkosten zu kümmern.
Warum ist NEAR eine gute Ergänzung für Paras?
Da die Nachfrage nach Speicherplatz auf Ethereum die Kosten auf der Plattform in die Höhe treibt, suchen neuere NFT-Schöpfer nach Alternativen und Lösungen. NEAR arbeitet mit Ethereum an einer interoperablen Lösung. Transaktionen auf NEAR kosten nur wenige Cents, manchmal sogar weniger. Die NEAR-Wallet ist äußerst effizient, und Transaktionen werden fast sofort abgeschlossen. Die Rainbow-Bridge stellt sicher, dass NEAR mit auf Ethereum basierenden Vermögenswerten interoperabel ist.
(L)Earner NFT
Learn NEAR Club gibt auch unsere eigenen PFP NEAR NFTs aus - (L)Earner, Genesis Edition. Wir werden dieses Projekt Mitte Februar herausgeben und haben bereits begonnen, mit einem der weltbesten Grafikdesigner zusammenzuarbeiten, um es zu einem großen Erfolg zu machen. Wir sind davon überzeugt, dass dieses Projekt den NEAR NFT Bereich massiv weiterentwickeln wird. Weitere Einzelheiten zu den (L)Earner NFTs, einschließlich der Prägekosten, werden bald bekannt gegeben.

Sie können sich hier anmelden, um frühzeitigen Zugang zur Münzprägung zu erhalten. Und natürlich müssen Sie ein LNC-Mitglied sein und bereit sein, einige nLEARNs auszugeben, um teilzunehmen.
Hip Hop Heads
Mit Hip Hop Heads betritt eine wichtige Säule der amerikanischen Kultur den Kryptoraum. Die kollaborative Kunstserie zeigt die Arbeit von Andre LeRoy Davis, dem Schöpfer des kultigen The Last Word des Source Magazins, sowie die Hintergrundanimation von Ed Young, einem der Miteigentümer des Source Magazins.

Hip Hop Heads entstand aus einer Zusammenarbeit zwischen dem Universal Hip Hop Museum, dem NEAR Protocol und Ed Young. Gemeinsam beschlossen sie, eine NFT-Kollektion mit Künstlern von den 70er Jahren bis heute zu erstellen. Die Kollektion mit dem Namen NFT.HipHop Heads umfasst 47 der größten Rap-Künstler und ehrt nicht nur die Künstler, sondern markiert auch das 47-jährige Bestehen der HipHop-Ära. Das Projekt knüpft an die Wurzeln des Rap an und nutzt dabei die neuesten technologischen Fortschritte.

HipHopHead 10.292.22166

Jede Illustration wird als eine Sammlung von 47 Exemplaren existieren, die 47 Jahre der Hip-Hop-Ära repräsentieren. Die Erstausgabe jedes Hip-Hop-Kopfes ist nach dem Platz des Künstlers in der Geschichte des Hip-Hops benannt. Die Bedeutung eines jeden Künstlers wird durch eine von Andre LeRoy Davis geschaffene Illustration veranschaulicht. Der Animationscode im Hintergrund ist das Ergebnis der wichtigsten Zahlen in der Geschichte des Hip Hop, die den Verlauf der Hip Hop-Ära im Laufe von 47 Jahren zeigen. Die NFT-Kollektion wird bis zum 24. Juli täglich auf ihrer Website versteigert.
Warum haben sich Hip-Hop-Heads für NEAR entschieden?
Durch das NEAR-Protokoll wird die Hip-Hop-Heads-Sammlung für die breite Öffentlichkeit zugänglicher. Wie bereits erwähnt, wird die Kollektion bis zum 24. August täglich versteigert und kann per Kreditkarte erworben werden. Dies ermöglicht NEAR, das Projekt rentabler zu machen. Der Auktionsmarktplatz hebt auch die Merkmale des NEAR-Protokolls hervor, wie z. B. eine vertraute und freundliche Benutzeroberfläche, die dem Web 2 ähnelt, eine einfache und relativ billige NFT-Prägung und die Zugänglichkeit für den Endnutzer.

Da die Benutzer die NFTs mit einer Kreditkarte kaufen können, bietet der Marktplatz eine einfache Möglichkeit, NFTs zu erwerben, ohne unnötige komplizierte Schritte, welche die Nutzer abschrecken könnte. Die Lizenzgebühren (Royalties) für NFTs auf dem NEAR-Protokoll sind im NFT-Code verankert, so dass die Schöpfer von NFTs auch dann noch Lizenzgebühren aus Sekundärverkäufen erhalten, wenn die NFT auf einen anderen Marktplatz umzieht. Dies ist dank des NEAR-Standards für NFT auf Vertragsebene möglich. NEAR gibt den Künstlern und Urhebern die Kontrolle über ihre NFT und ermöglicht es ihnen, von ihrer Arbeit zu profitieren.
NPunks
Nach dem großen Erfolg von Cryptopunks, Solpunks und Tpunks wird NEAR endlich eine eigene Version des Projekts namens Npunks haben. Wie bei dem ursprünglichen Punks-Projekt wird es 10.000 einzigartige NPunks mit ihren eigenen Seltenheitsmerkmalen geben. Die Sammlung wird 9 Aliens, 24 Affen, 88 Zombies und 111 Bots enthalten.



Um Horten zu vermeiden und eine faire Teilnahme zu gewährleisten, hat jeder die Möglichkeit, einen (oder mehrere) Npunks zu kaufen. Die Käufe werden nach dem Zufallsprinzip getätigt und die Identität bleibt ein Geheimnis, bis die Transaktion als abgeschlossen gilt. Es steht den Benutzern frei, ihre Npunks nach der Prägung auf dem Sekundärmarkt zu verkaufen.
NEAR Misfits
NEAR Misfists sind die erste kryptografisch vollständige NFT-Sammlung von NEAR. Die Misfits bestehen aus 1.600 Normie, 150 Zombies, 101 Skellies, 50 Meerkats und 22 Glitch Misfits.



Bereits im November 2021 waren 1.923 Misfit NFTs in weniger als 36 Stunden ausverkauft. Ab sofort kannst du diese NFTs auf NEAR NFT-Marktplätzen wie Paras und Mintbase kaufen.
NEARNauts
NEARNauts ist ein von der Community betriebenes, zufällig generiertes NFT, das darauf abzielt, eine organische und loyale Community um das Projekt herum aufzubauen. Ein Pool von seltenen Merkmalen sorgt für nachprüfbare Einzigartigkeit. Diese verifizierbare Zufallsfunktion (VRF) umfasst drei Algorithmen - Generierung, Nachweis und Verifizierung. 

 	Erzeugt: Hierbei werden zwei Schlüsselpaare erzeugt - ein geheimer Schlüssel (SK) und ein öffentlicher Schlüssel (pk).
 	Beweisen: Nimmt den SK und die Nachricht (x), um eine Zufallsausgabe (y) und einen Beweis zu liefern.
 	Verifizierung: Der Verifizierungsalgorithmus nimmt pk, x und y und verwendet den Beweis, um die Gültigkeit der Ausgabe zu überprüfen.



Die NEARNauts Community DAO wird im ersten Quartal 2022 in Betrieb gehen.
Fazit
NEAR macht die Entwicklung und Bereitstellung von dApps einfacher, schneller und billiger als jedes andere Blockchain-Protokoll und ist eines der vielversprechendsten Projekte im Kryptobereich. Es behebt mehrere Probleme, mit denen Projekte auf Ethereum konfrontiert sind, wie z. B. hohe Gasgebühren und langsame Verarbeitungsgeschwindigkeiten. Außerdem hat es dank seiner Sharded-Lösung noch weitere Vorteile gegenüber der Ethereum-Blockchain.

Das NEAR-Protokoll hat sich als sehr vielversprechend erwiesen, da es Sharding nutzt, um Probleme zu lösen, mit denen andere Blockchains konfrontiert sind. Dank dieses Ansatzes ist NEAR in der Lage, den Durchsatz zu erhöhen, ohne Kompromisse bei der Sicherheit einzugehen. Das NEAR-Kollektiv sorgt dafür, dass Ingenieure und Entwickler ständig an dem Protokoll arbeiten.

### NEAR Konto - Express Leitfaden

Einführung in das NEAR-Konto

 	NEAR verwendet Kontokennungen, die für Menschen lesbar sind, im Format name.near. Zum Beispiel: maria.near oder jane.near.
 	Das NEAR-Kontosystem ähnelt dem Website-Domainsystem in dem Sinne, dass ein Konto so viele Unterkonten wie nötig erstellen kann. Zum Beispiel kann ein Konto mit dem Namen maria.near ein Konto wie sub.maria.near erstellen, und dieses wiederum kann die Konten first.sub.masha.near, second.sub.maria.near und so weiter erstellen.
 	NEAR Wallet (https://wallet.near.org/) (NEAR-Protokoll-Wallet), NEAR Faucet (https://faucet.paras.id/) (ein Faucet für Ethereum и Metamask-Nutzer) oder near-cli (https://github.com/near/near-cli) (Kommandozeilen-Schnittstelle, die Funktionen für die NEAR-Integration liefert) können alle verwendet werden, um ein Konto zu erstellen.
 	In NEAR können Sie ein Konto erstellen und es mit Hilfe des https://nearnames.com Dienstes an einen Freund oder Abonnenten als Geschenk senden.
 	Sie können die Kontoinformationen sowohl im NEAR Explorer (https://explorer.near.org/) als auch in der NEAR Wallet überprüfen.
 	Neben sichtbaren Konten (Typ name.near) unterstützt das NEAR-Ökosystem auch die Erstellung von unsichtbaren Konten mit Hilfe von near-cli (sie sehen ähnlich aus wie Bitcoin- und Ethereum-Adressen). Eine detaillierte englische Anleitung finden Sie hier.
 	Jedes Konto im System kann nur 1 Smart-Contract haben. Für Anwendungen, bei denen der Benutzer mehrere Smart Contracts verwenden muss, können untergeordnete Konten verwendet werden.  Zum Beispiel contract_1.maria.near, contract_2.maria.near, etc.
 	Im NEAR-Ökosystem gibt es Entwicklerkonten (https://docs.near.org/docs/concepts/account#dev-accounts). Ihre Besonderheit liegt darin, dass sie zum Testen und Debuggen von Smart Contracts gedacht sind.

NEAR ACCOUNT - Schlüssel

 	

 	NEAR basiert wie die meisten anderen Blockchains auf Kryptographie mit einem offenen Schlüssel. Sie stützt sich auf Schlüsselpaare, die jeweils aus einem offenen Schlüssel (öffentlicher Schlüssel oder "public-key") und einem geschlossenen Schlüssel (privater Schlüssel oder "private-key") bestehen.
 	NEAR verwendet den offenen Schlüssel zur Identifizierung und den geschlossenen Schlüssel zum Signieren von Transaktionen (Bestätigung der Kontoinhaberschaft bei der Transaktionserstellung).
 	In NEAR gibt es 3 Arten von Schlüsseln. Zugriffsschlüssel dienen zum Signieren von Transaktionen über das Konto, Validierungsschlüssel ermöglichen Operationen im Zusammenhang mit der Netzwerkvalidierung, Knotenschlüssel (Netzwerkknoten) ermöglichen die Kommunikation auf niedriger Ebene zwischen den Knoten im Netzwerk.
 	Schlüssel können in 3 verschiedenen Speichern abgelegt werden. InMemoryKeyStore - Speicherplatz, der für temporäre Szenarien verwendet wird. BrowserLocalStorageKeyStore - unverschlüsselter lokaler Browser-Speicher, der für die Arbeit mit Anwendungen im Browser verwendet wird. UnencryptedFileSystemKeyStore - unverschlüsselter Speicher im Dateisystem, wird bei der Arbeit mit near-cli verwendet.
 	Ein Konto kann mehrere Zugangsschlüssel oder keinen haben.
 	Schlüssel können verschiedene Zugriffsstufen haben - FullAccess (Vollzugriff) oder FunctionCall (nur die Möglichkeit, Vertragsmethoden aufzurufen).
 	Alle Schlüssel sind innerhalb eines Kontos eindeutig, aber der öffentliche Schlüssel kann verschiedenen Konten mit unterschiedlichen Zugriffsstufen zugewiesen werden. Die Zugriffsstufe bestimmt, welche Aktionen im Konto mit diesem Schlüssel durchgeführt werden können.
 	Für die Zugriffsstufe FullAccess sind alle 8 Arten von Aktionen verfügbar: CreateAccountAction (Erstellen eines Kontos), DeployContractAction (Bereitstellen eines Vertrags), FunctionCallAction (Aufrufen von Vertragsmethoden), TransferAction (Senden von Token an ein anderes Konto), StakeAction (Einsetzen von Token), AddKeyAction (Hinzufügen eines Schlüssels zu einem Konto), DeleteKeyAction (Löschen eines Kontoschlüssels), DeleteAccountAction (Löschen eines Kontos).
 	Für die Zugriffsstufe FunctionCall steht nur die FunctionCallAction zur Verfügung (Aufruf von Vertragsmethoden). Außerdem können Sie für einen solchen Schlüssel angeben, welche Vertragsmethoden er aufrufen kann.

### Dapplets Developers contest

Create your own web3 app on Dapplet Project platform
Dapplets Project
An open and self-governing web3 platform for augmented web. This is a web of small decentralized applications (dapplets) that run on top of other websites.

The platform is publicly available to anyone and enables a lot of new augmenting applications, both public good and commercial.

Anyone can join the project and build their own dapp.
Dapplets Developers Contest
Dapplets Project is launching a special competition for dapplets developers.

Create a dapplet and experience the true power of web3!

You will have your own, full-functioning dapp with an active audience.

Prize fund:

 	1 place - 50 NEAR
 	2 place - 30 NEAR
 	3 place - 20 NEAR
 	participation prizes from Learn NEAR Club
 	special Dapplets Developer NFT for all participants.

How to join:

 	Read Dapplets Project documentation and examples
 	Choose one of the suggested development ideas or select your own idea
 	Create a dapplet which serves the function you chose and publish it in the Dapplets Store
 	Dapplets Project team will select the top 10 most interesting creations
 	The winners will be chosen by Dapplet team
 	Community Winner will be chosen through a public vote by Learn NEAR Club members

Development ideas:
Dapplets Project is an Augmented Web platform. This means that the main function of this platform is creating an additional information layer on top of the traditional web. With the platform’s help you can make connections between traditional sites and crypto-protocols, creating new business models.

What can you do with Augmented Web?

 	work with NFTs on traditional websites - demonstrate, sell, set as profile pictures and avatars
 	decentralized reviews and site ratings. These can be saved directly into the blockchain and displayed for all site visitors
 	decentralized chat or comments on any website
 	social media skins/themes (new icons, images, backgrounds)
 	decentralized public reactions or stickers for social media
 	services for modifying/painting others’ profile pictures
 	avatar and profile customizing for different viewer groups
 	tips and donations for different websites and projects

This is just a small bundle of ideas. We are relying on your imagination and creativity.

Don’t forget that every dapplet is a complete and fully functioning web3 app which can have its own economics and tokenomics.

This means that after creating a dapplet you become an owner of a decentralized app, it’s future is in your hands.
Important Dates:
 

Contest starts: Feb 16, 2022

Contest ends: March 9, 2022

Winners announcement : March 16, 2022
Documentation:
Docs: https://docs.dapplets.org/docs/

Developers Quickstart: https://learnnear.club/dapplets-x-near-example/
Contacts:
https://dapplets.org/

https://twitter.com/dappletsproject

https://discord.gg/YcxbkcyjMV

Register Now:

 

### Crypto Hero, Un Juego de NEAR

¿Qué es Crypto Hero?

Crypto Hero es un juego basado en la blockchain (cadena de bloques) principalmente enfocado en PvE (Player Versus Enemy o Jugador Contra Enemigo) donde puedes moler mazmorras e intercambiar objetos con otros jugadores, así como también jugar con amigos en un sistema compartiso donde puedes ganar premios semanales en Pixel Tokens (Monedas Pixel). La idea fue inspirada de tradicionales RPGs (Juego de Rol) como también RPGs de acción como Diablo



El juego trata de implementar mecánicas de aquellos juegos en una manera más simple, permitiendo una experiencia optimizada donde los jugadores pueden desarrollar sus personajes, competir contra otros y, más importante, ganar.

El juego contiene 5 elementos principales, los cuales voy a listar a continuación.

¿Por qué deberías jugar Crypto Hero?

Crypto Hero es la segunda entrega de PixelDapps y no será la última - un equipo que ha producido juegos en blockchain exitosamente donde los jugadores encuentran oportunidades de ganar premios mientras se divierten. El token actual se encuentra estable y en aumento, con lo cual es el momento perfecto para una inversión temprana.

Además de eso, Crypto Hero es divertido. Crea un sistema de progresión desde RPGs hacia un nuevo nivel completamente, con items NFT (Token no fungible) que son coleccionados e intercambiados a lo largo de una comunidad que es primero y ante todo conectada con ideas y aspiraciones en el ecosistema.

¿Cómo juegas Crypto Hero?

Reglas de Crypto Hero

¿Cuándo puedo jugar a Crypto Hero?

El lanzamiento en la red principal es el 22 de Enero

¿Dónde puedo jugar a Crypto Hero?

Juega a Crypto Hero

 	La casa de subasta

Los objetos pueden ser intercambiados en la casa de subasta con Pixel Tokens.

Puedes filtrar los ítems mediante categorías así como también diferentes tipos de equipamiento para facilitar la búsqueda.



 	Los objetos

Tu héroe puede equipar hasta 6 diferentes objetos: un arma, armadura, botas, un collar, un anillo y un casco.

Los objetos son definidos por rareza: común, raro, épico y legendario

Los objetos pueden aparecer en las runas de los calabozos, mientras más profundo sea el nivel del calabozo, mejores serán los objetos que aparecen.

Los objetos van a hacer a tu héroe más fuerte.



 	El Héroe

Tu héroe tiene puntos de vida, nivel y experiencia.

Tu héroe puede subir de nivel cuando gana suficiente experiencia

Mientras más alto sea el nivel de tu héroe, más fuerte se vuelve.



 	El Calabozo 

Puedes enviar a tu héroe a explorar el calabozo, donde va a enfrentarse contra una horda de criaturas.

Tu puedes elegir que tan profundo quieres ir dentro de un calabozo, niveles más profundos tienen mejor botín y experiencia, pero se vuelven más difíciles exponencialmente.

Una vez que vences el calabozo, eres recompensado con botín y experiencia y necesitarás esperar hasta ir al calabozo de nuevo.



 	La escala de clasificación

La escala de clasificación muestra los niveles más altos y niveles de objetos en el juego, creando un escenario competitivo entre jugadores.



 	Modo raid (cooperativo)

El sistema raid es un impulso social para que los jugadores se conecten entre sí, como también es la parte principal de ganancia del juego. Puedes agruparte con otros 7 jugadores con el fin de luchar en batallas de jefes que tienen diferentes dificultades en la escala de clasificación y diferentes recompensas.

### ¿Qué es Web3?

El Protocolo NEAR es una plataforma de desarrollo descentralizada que tiene como objetivo construir un ecosistema Web3 saludable a través de su plataforma escalable y fácil de usar. Hoy, comprendamos las implicaciones de Web3 y lo que potencialmente puede hacer al ecosistema.
La Necesidad de Web3

Crédito de la imagen
La Web 1.0 fue iniciada por Berners-Lee en 1990, y desde entonces se ha convertido en la base de Internet tal como la conocemos hoy. Estos son algunos de los pilares fundamentales de la Web 1.0:

 	HTML o Lenguaje de Marcado de Hipertexto, que es el lenguaje de formato de la web.
 	URL o localizador uniforme de recursos: una dirección única para identificar un recurso en la web.
 	HTTP o Protocolo de transferencia de hipertexto le permite recuperar recursos a través de la web.

Si bien esta etapa fue realmente innovadora, las páginas web eran muy estáticas y bastante diferentes de los sitios web diseñados profesionalmente a los que estamos acostumbrados hoy. Además, si bien las páginas web estaban lejos de ser interactivas, nuevos conceptos como “correo electrónico” se convertirían en una parte importante de nuestras vidas en el futuro.

Durante las últimas dos décadas, hemos visto el surgimiento de la Web 2.0. Los sitios web ahora son más interactivos que nunca. Sin embargo, eso es apenas rascar la superficie. Piense en las empresas que triunfaron en las últimas dos décadas. Meta, TikTok, Airbnb, Uber, etc. ¿Qué es lo que los une en común? Prosperan con el contenido o los recursos generados por los usuarios. En esencia, ese fue el mayor avance que vimos durante esta era. Sólo se puede lograr una verdadera escalabilidad al capacitar a sus usuarios para que participen activamente dentro de su ecosistema.

Sin embargo, la Web 2.0 prosperó únicamente con la centralización. ¿No nos cree? Piense en la cantidad de audiencias en el Congreso por las que tuvieron que pasar los directores ejecutivos de Google, Meta y Twitter para explicar todo lo que hacen con los datos de los usuarios. Meta, en particular, fue culpable de apropiación indebida de datos de usuarios. De hecho, los datos de los usuarios que vendieron a Cambridge Analytica fueron la base sobre la que se desarrollaron las campañas presidenciales de EE. UU.
¿Qué es Web3?
La próxima iteración de la web e Internet será Web3, que se basará en ciertos principios básicos. Vamos a revisarlos uno por uno.

Descentralización

Se puede decir con seguridad que la descentralización es el principio central de la revolución Web3. La idea es qué ya no habrá una autoridad central o una junta directiva centralizada que controle el crecimiento y la narrativa de la empresa. En el mundo actual, la censura de plataformas se ha convertido en un problema importante. Parece qué, a menos que esté siguiendo una ideología política en particular, sus pensamientos eventualmente se eliminarán de la plataforma de redes sociales. Las empresas hacen deliberadamente perfiles específicos "difíciles de encontrar" para reducir la difusión de ciertas ideologías. Twitter ha admitido abiertamente que tiende a censurar los perfiles de derecha. El bloque de construcción principal de Web3 será la resistencia a la censura presentada por la descentralización.

Desconfianza

Esto es más o menos una extensión del punto de descentralización. En la Web 2.0, tendría que confiar a terceros su información confidencial. La mayoría de las veces, estas empresas hicieron un mal uso de los datos a su disposición, lo que provocó enormes escándalos (Facebook y Cambridge Analytica). Ahora, según la descentralización, no habrá un solo organismo en el centro de la empresa que controle todos los datos cruciales. Las aplicaciones Web3 se ejecutarán utilizando la tecnología blockchain y la red peer-to-peer (persona a persona) para garantizar  que no falte la confianza y la descentralización.

Componibilidad

Uno de los aspectos fascinantes de Web3 será su interconectividad y componibilidad. Ya hemos visto esto en el ecosistema DeFi (Finanzas Descentralizadas) e IoT (internet de las cosas). En DeFi, varias plataformas pueden conectarse entre sí y crear un ecosistema muy unido en el que usted puede aprovechar numerosos instrumentos financieros.

Inteligencia artificial

Web3 utilizará IA y Machine Learning (ML) para potenciar sus sistemas y producir resultados más rápidos y relevantes.




	

	
	
		
			
				Iniciar sesión en un sitio web con su cuenta de Facebook es un ejemplo de:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Casos de uso de Web3
Web3 tiene varios casos de uso, con monedas digitales, NFT y otras entidades en el espacio criptográfico y blockchain que se vuelven cruciales para Web3. Las Organizaciones Autónomas Descentralizadas o DAO también son un caso de uso importante para Web3, utilizando tokens para hacer que los poderes de toma de decisiones sean más justos e imparciales.
Organismos Autónomos Descentralizados
El conocimiento básico de las DAO y cómo funcionan es muy útil para comprender y contribuir a Web3. Una DAO es una entidad que no requiere una autoridad central para funcionar. En cambio, es impulsado por su comunidad y brinda total autonomía y transparencia. Los contratos inteligentes rigen todas las reglas fundamentales; los contratos también ejecutan cualquier decisión acordada por la comunidad, con todos los procesos, incluyendo votaciones o propuestas, disponibles públicamente para su verificación. En esencia, una DAO está gobernada por miembros individuales que son parte de la comunidad, quienes toman colectivamente decisiones críticas con respecto al proyecto, que van desde asignaciones hasta actualizaciones.

Un equipo central de miembros de la comunidad establece reglas para la DAO a través de contratos inteligentes, estableciendo el marco de la DAO. Estos contratos inteligentes son verificables públicamente, lo que permite a los miembros de la comunidad comprender cada paso relacionado con el funcionamiento de la DAO. Los miembros de la comunidad pueden crear propuestas, después de lo cual toda la comunidad vota sobre la propuesta. Una vez que una propuesta logra un nivel de consenso dentro de la comunidad, el contrato inteligente la acepta y la hace cumplir.

El panorama de DAO se puede dividir en diferentes grupos, como DAO de protocolo, DAO de inversión, DAO de servicio, DAO social, DAO de subvenciones, DAO de coleccionista y DAO de medios. Algunas de las DAO destacadas de las que puede realizar un seguimiento son MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO, DAOhaus, Opolis, MolochDAO y BanklessDAO.




	

	
	
		
			
				Berners-Lee fue pionero de:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Propinas
La economía descentralizada ofrece una colaboración global que permite a los participantes controlar cómo trabajan, asignar su tiempo y experiencia, con varias herramientas ya existentes y emergentes que los empoderan a ellos y a su estilo de trabajo. La propina es uno de esos métodos que ayuda al crecimiento de las comunidades Web3 al incentivar la participación. Antes de seguir adelante, es importante entender las "propinas". En el mundo real, damos propina a una persona que brinda un servicio. A menudo, se dan propinas a las amas de llaves, al personal del restaurante, a los repartidores y a otras personas que nos ayudan a completar o realizar ciertas tareas para nosotros. En Web3, las propinas funcionan con la misma premisa, con la diferencia clave de que la transferencia de fondos se realiza a través de la cadena de bloques.

En Web3, los miembros de la comunidad pueden recibir propinas por una variedad de contribuciones, como contribuir con el código de un proyecto, responder preguntas, escribir un artículo o cuando un miembro de la comunidad presta su experiencia a un proyecto. Las propinas se pueden realizar de cualquier forma, desde NFT airdrops y tokens de gobierno hasta propinas en ETH, USDC o cualquier otra criptomoneda. Dar propina a los contribuyentes ayuda a generar confianza en la comunidad, asegura que los participantes sigan involucrados en el proyecto y también ayuda a establecer un tono para futuras participaciones.

Actualmente, los usuarios de Web3 están recibiendo propinas en tokens NEAR en Twitter y Telegram.
Iniciar sesión con su billetera
Otra cosa interesante que cambia Web 3 son los procedimientos de inicio de sesión. En los días de la Web 1.0, había dos formas de iniciar sesión en una cuenta de sitio web: ya sea por correo electrónico o mediante una cuenta única creada únicamente para ese sitio web.

Luego, durante la fase Web 2.0, podía iniciar sesión en todo con su cuenta de Google o su cuenta de Facebook. Si bien esto era conveniente, todavía tenía una deficiencia importante: la transferencia de valor. Todavía tenía que dar sus detalles de pago por separado para realizar compras.

Ahora, con la Web 3.0, simplemente puede conectarse a diferentes sitios web con su billetera de criptomonedas. Por ejemplo, en OpenSea, debe conectarse directamente con su MetaMask y realizar compras. De hecho, en Learn NEAR Club DEBE iniciar sesión con su billetera NEAR para participar en las actividades de (L)Earn.



 

Tratar con usuarios de Web3 permite que las dapps transmitan instantáneamente no sólo datos sino también valor monetario sin ningún intermediario involucrado.
El papel del protocolo NEAR en Web3
Con su plataforma escalable y fácil de usar, NEAR Protocol proporciona una plataforma que le permite crear aplicaciones DeFi y NFT sin quemar un agujero en su bolsillo.

La DeFi TVL para NEAR está sólo alrededor de $141,72 millones. Es un ecosistema muy joven y actualmente está creciendo a un ritmo rápido.



La aplicación DeFi más dominante que representa más del 80% del TVL general es Ref Finance.

Ref Finance tiene algunas similitudes con Uniswap V2, además admite más tipos de grupos, tarifas configurables y es completamente propiedad de la comunidad. Ref también resulta ser la primera plataforma DeFi en NEAR. El objetivo principal de Ref es reunir DEX, protocolos de préstamo, emisor de activos sintéticos y más bajo un mismo paraguas.

NEAR ha lanzado recientemente un enorme fondo de subvenciones de 800 millones de dólares que se ha destinado específicamente a crear un ecosistema DeFi más grande y saludable. El fondo tiene algunos requisitos importantes, que incluyen lo siguiente:

 	$100 millones para nuevas empresas
 	$100 millones para fondos regionales
 	$250 millones de subvenciones para ecosistemas que se distribuirán en cuatro años.

Lea esto para saber más sobre DeFi en NEAR.


En el frente de NFT, se han creado varios proyectos en NEAR blockchain como Mintbase, Paras, Hip Hop Heads, etc.


Mintbase es la plataforma NEAR NFT más popular, ya que permite que cualquier persona haga un NFT y lo ponga a la venta en su mercado o en mercados de NFT como OpenSea. Minters puede crear un contrato inteligente y limitar la transferibilidad de los tokens acuñados, lo que ayuda a prevenir el fraude o la transferencia ilegal de artículos únicos. Mintbase se enfoca en crear una experiencia de creación de NFT que sea única, por lo que, como se mencionó anteriormente, admite diferentes activos digitales. Esto es contrario a las plataformas de la competencia que se enfocan en una categoría específica de NFT.
The Flipside: ¿hay demasiada exageración?
Recientemente, este meme ha estado flotando en Twitter, recibiendo comentarios de gente como Jack Dorsey y Elon Musk.


Crédito de la imagen
A partir de ahora, las aplicaciones Web3 están recibiendo una enorme atención por parte de los capitalistas de riesgo de Silicon Valley. Esto trae a colación un importante punto de discordia. Con tantas partes interesadas incondicionales, ¿las aplicaciones Web3 se descentralizarán en el sentido más verdadero? Dorsey y Musk no lo creen. Sin embargo, será interesante ver cómo se desarrolla esto en el futuro.




	

	
	
		
			
				¿Cuál de los siguientes no requiere una autoridad central para funcionar?
			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook
		
	
		

		
		
			
				Correct!
				Wrong!

### Los mejores 7 Proyectos NFT en NEAR

El crecimiento de DeFi (Finanzas Descentralizadas) ha traído a los NFTs (Tokens no fungibles) a un foco más convencional, y este mismo crecimiento también ha puesto muchos problemas bajo un foco más nítido.
Ethereum tiene el monopolio sobre este sector, con muchos NFTs creados en la blockchain (cadena de bloques) de Ethereum. Entonces ¿Cuál es el problema de crear estos NFTs en una de las plataformas más populares del mundo? Este problema son las altas tarifas de gas. Ethereum tiene un gran problema cuando se trata de tarifas que pueden potencialmente llegar a los cientos de dólares, lo cual lo hace muy poco práctico.

Entonces ¿Cuáles son las opciones disponibles cuando se trata de NFTs y proyectos NFTs? ¿Qué otras opciones tenemos? El Protocolo NEAR tiene varios proyectos importantes en su plataforma y muchas veces se la promociona como el asesino de Ethereum. El protocolo NEAR es una blockchain escalable que simplifica y acelera el desarrollo de dApps (Apps descentralizadas). Hasta el momento, existen 19 plataformas descentralizadas y mercados NFT de NEAR para mintear (generar) e intercambiar NFTs en la blockchain de NEAR. El Protocolo NEAR tiene una ventaja significativa sobre Ethereum, ya que es considerablemente más rápido que Ethereum y los costos de transacción son despreciables, convirtiéndo a NEAR en una plataforma ideal para intercambiar NFTs.
El Protocolo NEAR y los NFTs
El Protocolo NEAR es la plataforma perfecta para los NFTs debido a que tiene muchas ventajas sobre Ethereum. El protocolo es significativamente más rápido que Ethereum. Ethereum también tiene tarifas de gas sustancialmente más altas, mientras que NEAR permite a las transacciones ser procesadas por tarifas despreciables. Estos factores hacen que NEAR sea ideal para comprar y vender NFTs

Como se mencionó previamente, ya existen varios proyectos NFT que han sido creados en la blockchain de NEAR. Sin embargo, antes de echar un vistazo a los proyectos, vamos a explicar brevemente el concepto de los NFTs.
El Significado de No-Fungible
Un activo fungible es un activo que puede ser intercambiado por otro activo idéntico. Bitcoin es un excelente ejemplo de un activo fungible, debido a que puedes intercambiar un bitcoin por otro bitcoin sin problemas.
Los Activos no fungibles, en cambio, son activos únicos que no pueden ser intercambiados. Un ejemplo de un activo no fungible puede ser una pintura única o ediciones limitadas coleccionables.

Un activo no fungible tiene una propiedad distintiva o propiedades que lo diferencian de otros activos. Los Tokens no fungibles están basados en activos no fungibles y son activos digitales únicos que utilizan la tecnología blockchain.
¿Qué es un NFT?
Los NFTs son activos digitales únicos que tienen su información de identidad registrada en un contrato inteligente. La información en el contrato inteligente es lo que hace que un NFT sea único. Los Activos fungibles como Bitcoin pueden ser intercambiados, lo que significa que puedes enviar o recibir Bitcoin sin ningún obstáculo. Los activos fungibles también son divisibles, lo que te permite enviar cantidades más pequeñas.
Los activos no fungibles no son divisibles. Por ejemplo, no puedes enviar a alguien una parte de una pintura o de un ticket.

Los NFTs son certificados digitales de propiedad por activos digitales. Un NFT es un contrato inteligente que  es utilizado para asegurar un activo digital. Una vez escrito, es publicado dentro de un token (ERC-721) en la blockchain. Cualquier cosa puede ser convertida en un NFT, con las más populares siendo vídeos, GIFs o JPEGs




	

	
	
		
			
				Which of the following is an NFT? 
			
		

		
					

		
			
			
			
			Bitcoin 
		
			
			Fiat currency
		
			
			A digital collectible
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proyectos NFT en el Protocolo NEAR
Actualmente, existen varias plataformas de NFTs en NEAR, entonces echemos un vistazo a algunos de los proyectos más populares en la plataforma
Mintbase
Mintbase nació en 2018 y fue creada por Nate Geier y Caroline Wend. Nate Geier es el CEO de la compañía mientras que Caroline es la COO, utilizando su experiencia en desarrollo de negocios y administración. Mintbase consiguió recaudar $1 millón de una ronda de financiación inicial en 2020. Sino Global encabezó la ronda y también consistió de otros capitalistas de riesgo tal como Block Oracle Capital, D1 Ventures, y otros ángeles inversores

Fish Woman by From my Dream (Mujer pez de mis sueños).

La plataforma Mintbase permite a los usuarios crear y vender NFTs en NEAR. Los usuarios pueden mintear diferentes activos digitales como NFTs. Estos activos pueden variar desde tickets de eventos o arte crypto y todo lo que se encuentre de por medio.

Mintbase permite casi a cualquiera que tenga acceso al internet, crear un NFT y que esté disponible para la venta en su mercado NFT de NEAR o en mercados NFT parecidos como OpenSea. Los creadores pueden realizar contratos inteligentes y limitar la transferibilidad de los tokens minteados, lo cual ayuda a prevenir el fraude o la transferencia ilegal de ítems únicos. Mintbase se enfoca en crear una experiencia de creación NFT que sea única, por lo cual como se mencionó anteriormente, soporta a diversos activos digitales. Esto es lo contrario que ocurre con plataformas de la competencia que se enfocan en una categoría específica de NFTs.
¿Por qué Mintbase cambió hacia NEAR?
Entonces ¿Por qué el cambio desde Ethereum hacia NEAR? La respuesta son las tarifas de gas. Las tarifas de gas de Ethereum se han vuelto ridículamente costosas. Para mintear NFTs en Mintbase, el usuario necesita crear una tienda digital. Esto implica que el usuario cree un contrato inteligente y que pague una tarifa de gas de Ethereum. Inicialmente la tarifa era baja, y los usuarios podían lanzar la tienda rápidamente. Sin embargo, con la congestión incrementando en la red Ethereum, las tarifas comenzaron a aumentar más y más, costando cientos de dólares la creación de una tienda. El costo se volvió tan alto que Mintbase tuvo que decirle a sus usuarios que esperen a que las tarifas bajen antes de lanzar una tienda. Ethereum rápidamente se volvió insostenible para comprar, vender o crear NFTs

Mintbase vio a NEAR como una mejor plataforma comparada con Ethereum, con tarifas significativamente más bajas gracias a un modelo de ejecución del contrato más eficiente. Además utiliza Nightshade, un acercamiento dinámico hacia el Sharding (fragmentado). De todas formas, hay muchas otras razones de porque Mintbase cambió hacia NEAR.

 	El uso de Rust o AssemblyScript para contratos inteligentes en la plataforma NEAR hace que sea más fácil escribir código para los desarrolladores
 	NEAR tiene la cualidad de direcciones humano-legible para ambos contratos y cuentas
 	Los desarrolladores pueden integrar usuarios rápidamente, gracias a NEAR Drops. Pueden pagar por sus cuentas de NEAR y enviar NEAR tokens.
 	Desarrolladores y usuarios pueden mover activos rápidamente gracias al ETH-NEAR Rainbow Bridge (Puente Rainbow).
 	Otras plataformas DeFi como Aave y Balancer se encuentran también en NEAR, lo cual va a hacer que cualquier futura integración sea más fácil.




	

	
	
		
			
				Why did Mintbase switch to NEAR? 
			
		

		
					

		
			
			
			
			High Gas fees
		
			
			NEAR is a better platform 
		
			
			Developers can move assets faster
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras fue creada con la visión de proveer la solución a las envejecidas tradicionales cartas coleccionables. La plataforma válida la propiedad mediante la blockchain por medio de transacciones rápidas y poco costosas. La plataforma se enfoca en crear colecciones nativas crypto que pueden ser luego diversificadas en medios desatascados.

PunkyPoN#0006 by monztre.near

Paras es un todo-en-uno en cuanto a un mercado de arte digital en cartas construido en NEAR. La plataforma puede validar la propiedad y dar acceso a la compra y minteo a los usuarios. Ofrece transacciones rápidas y baratas y se diferencia a sí misma de otros mercados ofreciendo colecciones en vez de lanzamientos singulares. La plataforma se diferencia a sí misma de la siguiente manera.

 	Paras reduce la carga de mantenimiento a coleccionistas asegurando que sus coleccionables no se desgastan con el pasar del tiempo. La plataforma remueve barreras y otorga a artistas y coleccionistas un fácil acceso al mercado digital de colecciones. Gracias al Protocolo NEAR, Paras puede reducir los costos incurridos por artistas para vender sus cartas.
 	Paras está desarrollando el arte de cartas digitales vertical para futuros artistas, gamers y creativos y permitiendo a artistas crear una colección que los una a un tema o lore (saber popular). Mediante este método, el arte de cartas digitales en Paras se enriquece con historias y antecedentes.

Paras es capaz de tomar un acercamiento curado y crear una experiencia y comunidad NFT. Paras asegura consistencia y calidad eligiendo artistas y formatos. Los artistas pueden crear nuevas cartas en Paras solo si son aprobadas, y el número de nuevos artistas aprobado es limitado a 30 artistas por semana. Los artistas también tienen que ajustarse a la proporción standard de 64:89




	

	
	
		
			
				What is Paras? 
			
		

		
					

		
			
			
			
			An all-in-one digital art card marketplace
		
			
			A smart contract platform 
		
			
			A programming language 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Desde el lanzamiento de la plataforma, artistas en Paras ya han recaudado más de $25,000, con la plataforma facilitando un volumen de intercambio de más de $35,000 por encima de 700+ transacciones. La plataforma tiene más de 80 coleccionistas activos y más de 70 artistas. Las tarifas bajas de minteo mantienen la barrera de entrada de artistas digitales bastante baja, y los artistas pueden mintear cartas sin preocuparse del costo de minteo.
¿Por qué NEAR encaja perfecto con Paras?
Debido a que la demanda de espacio en Ethereum está elevando los costos en la plataforma, nuevos creadores de NFT están buscando alternativas y soluciones. NEAR está trabajando junto con Ethereum en una solución interoperable. Las transacciones en NEAR cuestan solamente unos pocos centavos y a veces incluso menos. 

La billetera NEAR es altamente eficiente y las transacciones son completadas casi instantáneamente. El Rainbow Bridge se asegura de que NEAR sea interoperable con activos basados en Ethereum
(L)Earner NFT
Lear NEAR Club también está emitiendo su propio NEAR (L)Earner NFT, Edicion Genesis. Vamos a lanzar este proyecto en mediados de Febrero y ya comenzamos a colaborar con uno de los mejores diseñadores gráficos en el mundo para que sea un éxito masivo. Creemos que este proyecto va a evolucionar el espacio NFT de NEAR en una forma masiva. Más detalles respecto el NFT (L)Earner, incluyendo el costo de minteo, van a ser anunciados pronto.

Puedes suscribirte aquí para adquirir acceso anticipado al mint. Además lógicamente, necesitas ser un miembro de LNC y estar listo para gastar unos nLEARNs para participar.
Hip Hop Heads
Hip Hop Heads marca la entrada de un pilar de la cultura Americana en el espacio crypto. La serie de arte colaborativo caracteriza el trabajo de Andre LeRoy Davis, el creador de la icónica “The Last Word” de la revista Source Magazine y también atribuye a la animación de fondo de uno de los copropietarios de la revista The Source Magazine, Ed Young

Hip Hop Heads nace de la colaboración entre el Museo Universal del Hip Hop, el Protocolo NEAR y Ed Young. Juntos decidieron crear una colección NFT que caracteriza a artistas de los 70s hasta el presente. La colección, llamada NFT.HipHop Heads va a mostrar 47 de los más grandes raperos y artistas y va a hacer honor no solo a artistas sino marcar el año número 47 de la era del Hip Hop. El proyecto reconecta con las raíces del rap utilizando los últimos avances en tecnología.

HipHopHead 10.292.22166

Cada ilustración va a existir como una colección de 47, representando 47 años de la era del Hip Hop. La primera edición de cada Hip Hop Head se llama según el lugar del artista en la historia del Hip Hop. La importancia de cada artista se demuestra mediante una ilustración creada por Andre LeRoy Davis. El código de la animación de fondo es un resultado de los números más significativos en la historia del Hip Hop que demuestra el pasaje de la era del Hip Hop por el transcurso de 47 años. La colección de NFTs va a ser subastada todos los días en su página web hasta el 24 de Julio
¿Por qué los Hip-Hop Heads eligieron NEAR?
El Protocolo NEAR permite a la colección de Hip Hop Heads ser más accesible a la población general. Como se mencionó anteriormente, la colección va a ser subastada diariamente hasta el 24 de agosto y puede ser comprada mediante tarjeta de crédito. Esto permite a NEAR hacer el proyecto más viable. El mercado de subasta también pone en foco las características del Protocolo Near como una interfaz familiar y amigable similar a web-2, fácil y relativamente barato mintear NFT y la accesibilidad del usuario final


Debido a que los usuarios pueden comprar los NFTs utilizando una tarjeta de crédito, el mercado ofrece una forma simple de comprar NFTs sin ningún paso complicado que hagan que los usuarios tengan que estar sorteando obstáculos. Las regalías NFT en el Protocolo NEAR están escritas dentro del código NFT, permitiendo a los creadores ganar regalías de ventas secundarias, incluso si el NFT se mueve a otro mercado. Esto es posible gracias al nivel de contrato estándar NFT en NEAR. NEAR brinda a los artistas y creadores el control de su NFT, permitiéndoles beneficiarse de su trabajo.
NPunks
Luego del tremendo exito de Cryptopunks, Solpunks, and Tpunks (Colecciones de NFTs) NEAR finalmente tendra su propia version del proyecto, llamada Npunks. Tal como su version original del proyecto Punks, van a existir unos 10,000 unicos NPunks con sus propios rasgos de rareza. La coleccion tendra 9 aliens, 24 monos, 88 zombies y 111 robots.



Para evitar acaparamiento y asegurar una participación justa, todos han tenido la oportunidad de comprar uno (o más Npunks). Las compras se han hecho al azar y la identidad se mantiene en misterio hasta que la transacción sea considerada completa. Los usuarios son libres de vender sus Npunks en un mercado secundario luego del mint.
NEAR Misfits
NEAR Misfists Son la primera colección NFT criptográficamente completa de NEAR. Los Misfits consisten de 1600 Normie (normales), 150 Zombies, 101 Skellies (esqueletos), 50 Meerkats (suricata) y 22 Glitch (falla) Misfits



En Noviembre 2021, 1923 Misfit NFTs fueron vendidos dentro de las 36 horas. Actualmente puedes comprar estos NFTs en los mercados NFT de NEAR como Paras y Mintbase.
NEARNauts
NEARNauts son NFTs aleatoriamente generados, impulsados por comunidad que apuntan a un crecimiento orgánico y una comunidad leal alrededor del proyecto. Un conjunto de rasgos raros verifica su unicidad. Esta Verifiable Random Function (Función verificable al azar) incluye tres algoritmos - Generated (generado), Proof (prueba) y Verification (Verificación)

 	Generated: Produce dos pares de llaves – Una llave secreta (SK) y una llave pública (pk).
 	Proof: toma la llave secreta y el mensaje (x) para proveer una salida aleatoria (y) y una prueba.
 	Verification: El algoritmo de verificación toma “pk”, “x” e “y” y utiliza la prueba para verificar la validez de la salida.



El DAO de la comunidad de NEARNauts va a ser lanzado en el Q1, 2022.
Conclusión
NEAR está construyendo y lanzando dApps más rápidas, fáciles y baratas que cualquier otro protocolo blockchain y es uno de los proyectos más prometedores en el espacio crypto. Aborda muchos problemas enfrentados por otros proyectos en Ethereum, tales como las altas tarifas y lenta velocidad de procesamiento. También tiene varias ventajas sobre la blockchain de Ethereum gracias a su solución fragmentada  

El Protocolo NEAR ha mostrado ser prometedor, utilizando Sharding para resolver problemas encontrados por otras blockchains. Gracias a este acercamiento, NEAR puede incrementar su rendimiento sin comprometer la seguridad. El colectivo NEAR asegura que ingenieros y desarrolladores están constantemente trabajando en el protocolo.

### Lo que Puedes Hacer en el Protocolo NEAR

En el espacio criptográfico, Ethereum domina como la plataforma de referencia cuando se trata de contratos inteligentes, aplicaciones descentralizadas y finanzas descentralizadas. Sin embargo, Ethereum no es el único protocolo en el espacio de contratos inteligentes y aplicaciones descentralizadas, con varios otros protocolos en la imagen. Aunque Ethereum es la plataforma número uno en el espacio, tiene algunas deficiencias, como tarifas de gas extremadamente altas y problemas de escalabilidad significativos.

El Protocolo NEAR es una de las cadenas de bloques que puede rivalizar con Ethereum yendo directamente a la deficiencia más evidente del protocolo, su falta de escalabilidad, mediante el uso de algo conocido como sharding (fragmentación). Esto permite que NEAR aumente su escalabilidad exponencialmente. El protocolo también ha recaudado una financiación significativa y cuenta con el fondo a16z de Andreessen Horowitz como uno de sus patrocinadores.
Una Mirada más Cercana al Protocolo NEAR 
El Protocolo NEAR es una plataforma de desarrollo descentralizada que se fundó en 2018. NEAR crea el entorno perfecto para aplicaciones descentralizadas y contratos inteligentes al centrarse en las deficiencias de otros protocolos en el mismo espacio. Ya hemos mencionado las deficiencias anteriormente. NEAR utiliza el protocolo NEAR, una cadena de bloques de prueba de participación (Proof-of-Stake Blockchain) que es conocida por ser pública, amigable para los desarrolladores y fragmentada. El protocolo es una plataforma de bajo costo y altamente escalable que los desarrolladores pueden utilizar para crear aplicaciones descentralizadas (dApps). Otras características que los desarrolladores pueden usar incluyen aplicaciones de billetera y componentes de interoperabilidad que les permiten utilizar fácilmente el ecosistema NEAR y crear aplicaciones.

NEAR presenta Doomslug, un mecanismo de generación de bloques que se propuso en 2019. Permite una finalidad práctica; que significa que los bloques pueden alcanzar la finalidad en segundos. NEAR funciona con la misma tecnología que impulsa tecnologías como Bitcoin y la combina con funciones como la fragmentación de bases de datos. Otras cadenas de bloques centralizan el procesamiento, lo que significa que está limitado a hardware de muy alta gama. Este enfoque sólo proporciona un impulso temporal al rendimiento. Por otro lado, NEAR se escala linealmente y puede admitir incluso miles de millones de transacciones de manera completamente descentralizada.
Características importantes de NEAR
El protocolo NEAR es desarrollado por NEAR Collective. Algunas de las características del protocolo son las siguientes.

 	NEAR como protocolo es fácil de usar, y los desarrolladores pueden construir aplicaciones fácil y rápidamente en él.
 	NEAR permite una escalabilidad casi infinita gracias al uso de sharding
 	Near es un protocolo de capa 1.

Comprender el colectivo NEAR 
El Colectivo NEAR, una comunidad de investigadores y desarrolladores, está detrás del desarrollo del protocolo NEAR. El colectivo trabaja continuamente para desarrollar y mejorar el protocolo NEAR y también ha trabajado en proyectos como escribir el código inicial del protocolo y la implementación de la red NEAR. El Protocolo NEAR funciona de forma completamente independiente y descentralizada, e incluso los desarrolladores e investigadores que lo construyeron no pueden apagarlo.

El Colectivo NEAR está formado por la Fundación NEAR, que es una organización sin fines de lucro que crea un ecosistema en torno al protocolo NEAR. El Colectivo NEAR ayuda en las actividades de desarrollo y gobernanza del protocolo. El Protocolo NEAR es sólo uno de los varios proyectos del colectivo.
¿Qué puede hacer en el protocolo NEAR?
El Protocolo Near permite a los usuarios acceder a varios proyectos y protocolos que van desde NFTs hasta DAOs y DeFi. NEAR ha desarrollado un ecosistema nativo vibrante, tiene varios proyectos que ya están funcionando en el protocolo, mientras que hay más proyectos en proceso.
Primeros pasos con NEAR
Para comenzar con NEAR, lo primero que necesitas es una cuenta NEAR. Puedes aprender cómo configurar una cuenta NEAR aquí. Una vez que hayas creado tu cuenta NEAR, puedes conectarla a su billetera NEAR, lo que te permite realizar llamadas de contrato a la blockchain, enviar o recibir fondos y configurar los nodos locales. Para crear una cuenta NEAR, debes tener al menos 0,2 NEAR o 0,62 USD para poder mantener tu lugar en la red NEAR.
El Token NEAR
Hay dos formas de obtener tokens NEAR; puedes ganarlos o comprarlos directamente. Los tokens NEAR se pueden ganar participando en la red, participando en recompensas de desarrollo o ejecutando nodos comunitarios que pueden permitir a las personas de la comunidad construir en NEAR. También puedes comprar tokens NEAR que están disponibles en todas las principales plataformas de intercambios de criptomonedas.
¿Qué puedes hacer con los tokens NEAR?
El token NEAR te permite realizar varias tareas; puedes transferir tokens NEAR entre cuentas y realizar un seguimiento de las transacciones en Block Explorer. Las tarifas de transacción en NEAR son extremadamente bajas, lo que te permite mover tokens fácilmente. También puedes enviar NEAR a cualquier persona que necesite crear una cuenta NEAR utilizando NEAR Drops. Los tokens NEAR también te permiten acceder a un número creciente de aplicaciones que se están construyendo en NEAR. También puedes comprar, publicar o intercambiar NFT y arte digital en NEAR o crear creaciones artísticas colectivas.
Staking 
La comunidad NEAR puede apoyar a los validadores a través de Staking. Los validadores son aquellos usuarios que operan nodos que ayudan a ejecutar la red NEAR. Se requiere que los validadores mantengan una cantidad mínima stakeada para que puedan permanecer como validadores. Los titulares de tokens en NEAR pueden stakear con un validador de su elección y obtener una recompensa de los tokens generados por la red. Los usuarios pueden stakear siguiendo los siguientes pasos

 	Seleccionar Staking en la barra de navegación y elegir un validador
 	Confirmar las opciones que haya seleccionado y luego seleccionar "Stake with Validator"
 	Elegir la cantidad de tokens NEAR que deseas stakear y hacer clic en "Submit".

Lo que puedes hacer en el ecosistema NEAR
NFT
Los NFT han estado ganando una cantidad significativa de enfoque general. Si bien Ethereum es el jugador principal cuando se trata de NFT, su paso a la corriente principal también ha puesto de relieve las altas tarifas de gas de Ethereum, lo que lo hace bastante poco práctico. El Protocolo NEAR es una alternativa viable y ya tiene varios proyectos ejecutándose en su plataforma. La escalabilidad del protocolo garantiza que el desarrollo de dApps sea rápido y fácil. Actualmente, hay 19 plataformas descentralizadas para NFT en la plataforma NEAR. NEAR también es significativamente más rápido que otros jugadores en el espacio NFT y tiene costos de transacción extremadamente bajos.

El Protocolo NEAR se puede describir como la plataforma perfecta para NFT y tiene varias ventajas sobre otras plataformas NFT en el espacio e incluyendo Ethereum. El protocolo NEAR puede procesar transacciones mucho más rápido que Ethereum y, a diferencia de Ethereum, no sufre las altas tarifas de gas ni la congestión de la red. Las transacciones en NEAR se procesan casi instantáneamente con un costo insignificante adjunto. Todos estos factores hacen que NEAR sea ideal para comprar y vender NFT y actuar como un incentivo para que diferentes proyectos construyan sus NFT en NEAR. Hay varios proyectos de NFT que ya se están ejecutando en NEAR, como Mintbase y Paras.
Crea y vende NFT a través de Mintbase
Los usuarios de NEAR Protocol pueden usar varios de los proyectos NFT para comprar, vender o crear NFT. Uno de esos proyectos, Mintbase, permite a los usuarios crear un NFT y ponerlo a la venta en mercados como OpenSea. Los usuarios pueden crear contratos inteligentes para limitar la transferibilidad de los tokens, lo que ayuda a prevenir el fraude y la transferencia ilegal de activos.

Mintbase cambió de la blockchain de Ethereum al Protocolo NEAR debido a las altas tarifas de gas del primero. Inicialmente, las tarifas de gas en Ethereum eran bajas y los usuarios podían implementarlo rápidamente, sin embargo, con el aumento del uso y la congestión en Ethereum, los costos de gas comenzaron a descontrolarse. Hay varias otras razones por las que Mintbase eligió NEAR Protocol.

 	NEAR usa Rust o AssemblyScript para codificar contratos inteligentes, lo que permite a los desarrolladores escribir código fácilmente.
 	NEAR tiene direcciones legibles por humanos para cuentas y contratos inteligentes.
 	Los desarrolladores pueden usar las NEAR drops para integrar a los usuarios fácil y rápidamente. También pueden pagar sus cuentas NEAR y enviar o recibir tokens NEAR.
 	Los desarrolladores pueden usar ETH-NEAR Rainbow Bridge y mover sus activos rápidamente.
 	Los proyectos DeFi como Balancer y Aave también están en NEAR, lo que facilita cualquier posible integración futura.

Crea, intercambia y colecciona tarjetas de arte digital
Paras es un mercado de tarjetas digitales basado en el protocolo NEAR que brinda a los usuarios una solución para las tarjetas coleccionables tradicionales antiguas. Valida la propiedad a través de blockchain mediante transacciones rápidas y económicas. También se diferencia por ofrecer colecciones en lugar de lanzamientos independientes. Paras es beneficioso para los coleccionistas, ya que reduce significativamente la carga de los coleccionistas al garantizar que sus objetos de colección no se desgasten. Tanto los artistas como los coleccionistas pueden acceder fácilmente al mercado de artículos de colección.

Desde el lanzamiento de Paras, hemos visto a artistas ganar más de $25,000, y la plataforma puede procesar más de 700 transacciones que le permitieron facilitar un volumen comercial de más de $35,000. Actualmente, la plataforma cuenta con más de 70 artistas y 80 coleccionistas. El Protocolo NEAR y Paras encajan perfectamente porque los creadores de NFT están buscando alternativas a Ethereum por sus altas tarifas de gas. Las transacciones en NEAR cuestan casi nada y se pueden completar en segundos, mientras que Rainbow Bridge garantiza la interoperabilidad entre Ethereum y NEAR.
Explorar y subastar colecciones NFT
Hip-Hop Heads es el resultado de una colaboración entre NEAR Protocol, Ed Young y Universal Hip-Hop Museum. La colección NFT presenta artistas desde los años setenta hasta el presente y cuenta con 47 de los artistas más importantes del género rap. La colección honra a ambos artistas y también marca el 47º año de la era Hip-Hop.

NEAR permite que la colección sea más accesible para la comunidad, y la subasta presenta nuevas ediciones de los 103 Hip-Hop Heads. Los miembros de la comunidad pueden comprar fácilmente los NFT a través de una tarjeta de crédito sin ningún sistema de incorporación complicado.

Los usuarios del protocolo pueden acceder a varios otros proyectos de NFT en NEAR, como Metamon, WebAssembly Music, Snark.Art, etc. Metamon crea un universo de monstruos que los usuarios pueden capturar, evolucionar y jugar. Los monstruos están clasificados como criaturas de edición limitada en peligro de extinción que un grupo selecto de coleccionistas de NFT puede adoptar. Los coleccionistas pueden combinar dos del mismo tipo de Metamon y verlo evolucionar hacia un Metamon más raro y poderoso.

WebAssembly Music es la primera música que se ha almacenado en la cadena de bloques como NFT. La música es creada por Peter Salomonsen y se publica en el Protocolo NEAR. La pieza musical estuvo entre las primeras piezas musicales que se renderizaron en un binario ejecutable de WebAssembly. Los usuarios pueden ejecutar el archivo binario WASM y obtener los datos de audio sin procesar a través de un tiempo de ejecución de WebAssembly.




	

	
	
		
			
				NEAR utiliza lo siguiente para codificar contratos inteligentes:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust o AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi en NEAR
Entendamos primero que DeFi, DeFi o finanzas descentralizadas se refieren a un sistema financiero completamente descentralizado que utiliza cadenas de bloques como Ethereum. Consiste en activos como aplicaciones descentralizadas, protocolos DeFi y contratos inteligentes. El objetivo detrás de DeFi es crear un sistema financiero de código abierto, sin permisos y descentralizado que opere independientemente de la jurisdicción de cualquier autoridad de gobierno central o de terceros. DeFi brinda a los usuarios un fácil acceso a los servicios financieros y es especialmente beneficioso para las personas que no tienen acceso a los servicios bancarios.

NEAR está llevando DeFi a las masas con varios proyectos en vivo en el protocolo, con proyectos que van desde proyectos DeFi, DEXs, Oracles, etc. Veamos cómo puedes usar algunos de los proyectos en NEAR.
Accede a casi todas las Cadenas Compatibles con Rainbow Bridge
Rainbow Bridge actúa como un puente entre NEAR y Ethereum y es un protocolo sin permiso y sin confianza que conecta dos cadenas de bloques diferentes. Los usuarios pueden implementar fácilmente un puente nuevo o unirse a un puente existente sin necesidad de la aprobación de un tercero. Rainbow Bridge permite que cualquier información que se pueda usar en NEAR se utilice en contratos inteligentes de Ethereum y viceversa. Esto también permite a los usuarios votar con ETH en un DAO basado en NEAR sin pasar por Ethereum.

El Rainbow Bridge es de fácil acceso para los usuarios, gracias a un diseño intuitivo, y se integra directamente a través de MetaMask. El Rainbow Bridge también se puede reutilizar y conectar NEAR con casi todas las cadenas compatibles con Ethereum. Rainbow Bridge también busca admitir cadenas que no sean EVM como Bitcoin.
SputnikDAO 
Las DAOs son extremadamente importantes cuando se trata de la estrategia de gobernanza de un protocolo. SputnikDAO empodera a las comunidades e individuos que conforman el ecosistema NEAR, actuando como la infraestructura para DAO en el protocolo NEAR y permite que individuos y otros proyectos lancen sus DAOs, actualicen contratos inteligentes de protocolo y configuren la gobernanza para la gestión de tesorería fácilmente. SputnikDAO también permite que los proyectos establezcan un gobierno de múltiples firmas o emitan tokens de gobierno o combinen los dos y los usen juntos.
Lanzamiento y Mint de NFTs de audio con DAOrecords
DAOrecords planea convertirse en el primer sello discográfico descentralizado del mundo y actualmente emplea un modelo híbrido. El proyecto ha estado experimentando continuamente con Audio NFT, y hasta ahora ha lanzado 350 NFTs y ha trabajado con más de 60 artistas. DAOrecords quiere devolver el control de la música a los artistas que la crearon y cambiar la forma en que interactúan con sus fans.

Los artistas independientes pueden lanzar nueva música utilizando los NFTs de audio y los servicios de transmisión (streaming) de DAOrecord. También pueden mintear sus NFTs de audio. DAOrecords ya ha publicado un NFT de audio interactivo llamado "MintTape Vol 1".
Accede a Préstamos a través de Aave
Aave implementa una estrategia de préstamo basada en grupos en lugar de una estrategia descentralizada entre pares. Los préstamos en Aave no se casan individualmente. En su lugar, dependen de los fondos de grupos y de la garantía junto con las cantidades prestadas. Aave se lanzó en noviembre de 2017 como una plataforma de préstamos entre pares y se renombró como Aave en septiembre de 2018. El protocolo se puso en marcha en Mainnet, tiene casi $6 mil millones bloqueados en contratos inteligentes y se encuentra entre los 3 proyectos principales en el espacio DeFi.

Aave ofrece préstamos flash, que son básicamente préstamos sin garantía que se toman prestados y se pagan en una sola transacción, lo que significa que los usuarios no requieren ninguna garantía para el préstamo, mientras que el prestatario devuelve el monto original prestado y una pequeña tarifa. Aave introdujo préstamos flash, en los que cualquiera puede tomar prestada liquidez, usarla con otros protocolos y devolverla en una sola transacción. Los préstamos flash son esenciales en el espacio DeFi, ya que brindan a las personas acceso a la liquidez sin necesidad de garantías.
Acceda a fuentes de datos con Chainlink
Chainlink se desarrolló como una red Oracle descentralizada que permite que los contratos inteligentes transfieran datos entre blockchains y sistemas fuera de la cadena de manera confiable y segura. Utiliza una red descentralizada de oráculos independientes para recuperar datos de múltiples recursos diferentes, agregar los datos y luego entregar los datos validados al contrato inteligente, lo que desencadena la ejecución del contrato.

El protocolo Chainlink también proporciona seguridad multicapa para garantizar una confianza total en la red de Oracle. Permite la creación y ejecución de redes de Oracle, lo que permite a los usuarios conectarse a redes de Oracle personalizadas sin tener que depender de otras redes de Oracle.

 	Data Signing (Firma de datos): los datos de entrada de Chainlink Oracles se firman mediante una firma cartográfica única que permite a los usuarios probar que los datos se originaron en un nodo de oracle específico.
 	High-Quality Data (Datos de alta calidad): Chainlink proporcionará contratos inteligentes con datos obtenidos de fuentes externas, como proveedores de datos externos.
 	Blockchain Agnostic: Chainlink puede ejecutarse de forma nativa en cualquier blockchain, admitiendo blockchains públicas, blockchains empresariales, etc.




	

	
	
		
			
				DAOrecords te permite mintear:
			
		

		
					

		
			
			
			
			Arte Digital
		
			
			Gatos Digitales
		
			
			Audios NTFs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora: Una Experiencia de Capa 2 de Ethereum
Aurora on NEAR Protocol proporciona una experiencia Ethereum Layer-2. Los desarrolladores pueden usar esto para llegar a mercados adicionales mientras aprovechan las características del Protocolo NEAR, como la remuneración de la tarifa de gas y la fragmentación. Se ejecuta en dos componentes críticos, Aurora Bridge y Aurora Engine. Aquí hay algunas características que aporta Aurora:

 	La capacidad de procesar miles de transacciones por segundo, un aumento de 50 veces sobre Ethereum.
 	Un tiempo de finalización de bloque de 2 segundos, en comparación con el tiempo de confirmación de bloque único de 13 segundos en Ethereum.
 	Permite que EVM escale horizontalmente con el enfoque de fragmentación de NEAR.
 	Las tarifas de Aurora son 1000 veces más bajas que las de Ethereum.
 	Aurora ofrece una compatibilidad inquebrantable con Ethereum a través del protocolo NEAR.

Pensamientos finales
NEAR está creando un ecosistema donde los usuarios pueden acceder fácilmente a dApps, NFT y DeFi. El protocolo es más rápido y más barato que otros jugadores en el espacio criptográfico. NEAR ofrece soluciones para problemas como velocidades de procesamiento lentas, congestión de la red y altas tarifas de gas mediante el uso de fragmentación, lo que brinda a la plataforma una cantidad significativa de escalabilidad sin comprometer la seguridad del protocolo.




	

	
	
		
			
				Este protocolo permite a los usuarios de NEAR acceder a Ethereum en la capa 2:
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			Plasma
		
	
		

		
		
			
				Correct!
				Wrong!

### ¿Qué es la Red Octopus?

Resultado esperado: una comprensión general de la Red Octopus desde la perspectiva del usuario final

Un pulpo es muy diferente de un humano. En lugar de tener un sistema nervioso centralizado como los humanos, dos tercios de las neuronas de un pulpo están repartidas por todo su cuerpo y distribuidas entre sus brazos. Esas neuronas pueden tomar decisiones por sí mismas sin la intervención del cerebro, lo que esencialmente convierte al pulpo en una forma de vida inteligente descentralizada.

Octopus Network o la Red Octopus, es una criptored interoperable multicadena que emula a un pulpo. Al igual que los brazos de un pulpo, cada aplicación específica de la cadena de bloques (appchain) está empoderada con su propia inteligencia y mecanismos de toma de decisiones para adaptarse a entornos en constantes cambios. Cuando están conectados como un todo, todos los miembros se benefician de importantes efectos de red y economías de escala, creando una Internet de Blockchains o cadena de bloques.



Octopus Network es una red criptográfica multicadena para lanzar y ejecutar las aplicaciones específicas Web 3.0 de blockchains - appchains.

Appchains en la Octopus Network se benefician de valores alquilados flexibles y rentables (LPoS), interoperabilidad multicadena lista para usar, infraestructura completa y una comunidad lista para participar.

Octopus Network reduce el costo de lanzar una appchain de varios millones de dólares a menos de cien mil dólares, lo que desencadena la tercera ola de innovación de Cryptonetworks o criptoredes.
La Evolución de las Aplicaciones Web3.0
La Web3.0 aún no ha sucedido. Pero basados en los fundamentos iniciales, estamos seguros de que finalmente lo hará.

El comercio siempre fluye hacia el mercado con costos de transacción más bajos, al igual que el agua siempre fluye cuesta abajo.

Las plataformas Web2.0 son propiedad y están dirigidas por empresas cuyos objetivos están directamente alineados con la maximización del valor para los accionistas. Extraen tanto beneficio como pueden de las actividades económicas que coordinan. Las criptoredes son mercados de servicios digitales con costos de transacción minimizados. Entonces, las plataformas Web2.0 simplemente no tienen defensa contra ser eventualmente reemplazadas por criptonetworks.

La Web3 se refiere a aplicaciones descentralizadas que se ejecutan en cadenas de bloques que son propiedad de la comunidad de usuarios en lugar de corporaciones que extraen ganancias. La Web3.0 aspira a devolver valor a los verdaderos creadores.

Pero las plataformas Web2.0 son fantásticas para los usuarios de Internet. Para que una aplicación Web3.0 suplante a una aplicación Web2.0, primero tiene que ser una gran aplicación Web y brindar una experiencia de usuario que sea al menos tan buena como su contraparte Web2.0.

El desarrollo de aplicaciones Web3.0 generalmente tiene que sacrificar la experiencia del usuario porque la tecnología de contabilidad distribuida implica más complejidades y mayores costos que Web2.0, lo que da como resultado una experiencia de usuario degradada.

Pero una tercera ola de innovación de criptoredes está sobre nosotros y está trayendo con la marea prometedoras soluciones de aplicaciones Web3.0.
La tercera Ola de Innovación de Criptoredes
Bitcoin es una aplicación de cadena de bloques específica (appchain), la primera y la más exitosa.

Inspirándose en Bitcoin, se desarrollaron una variedad de appchain - cadenas de aplicaciones entre 2011 y 2015. Algunas intentaron convertirse en un mejor Bitcoin, mientras que otras se enfocaron en una variedad de casos de uso distintos de la moneda, dejándonos con una gran cantidad de monedas muertas. La razón comúnmente acordada para esto es que la blockchain de Bitcoin se creó específicamente para un propósito y no era adecuada para abordar otros casos de uso al bifurcarse o extenderse. Podemos llamar a este período la "Primera Ola de Innovación de Criptoredes".

La segunda ola de innovación de criptoredes nació con Ethereum. Ethereum es una blockchain pública de uso general equipada con una máquina virtual Turing-Complete (que, en teoría, podría ejecutar cualquier cálculo, siempre que se mantenga dentro del límite de complejidad, también conocido como límite de gas). El principal lenguaje de programación EVM, Solidity, con su sintaxis similar a Javascript, es fácil de aprender y muy bueno para controlar los activos en cadena.

Ethereum permitió a miles de desarrolladores crear aplicaciones descentralizadas (dApps). Desafortunadamente, muy pocos pudieron retener a muchos usuarios durante un período prolongado de tiempo hasta la explosión de DeFi de 2020.

Pero el desafío clave que enfrenta Ethereum es la escalabilidad, y las tarifas de gas para ejecutar contratos inteligentes han hecho que ciertos casos de uso sean prohibitivamente costosos. Mientras que Ethereum 2.0 tiene como objetivo abordar estos problemas con un protocolo de cadena de bloques fragmentado (sharded blockchain protocol), Ethereum 2.0 es una hoja de ruta de varios años con riesgos de ejecución desconocidos.

Sin embargo, una tercera ola de innovación de criptoredes está a la vuelta de la esquina. Los marcos de blockchain como Substrate y Cosmos SDK pueden proporcionar un espacio de diseño colosal sin precedentes para los desarrolladores de aplicaciones Web3.0.

Los desarrolladores ahora pueden ofrecer una aplicación Web3.0 totalmente optimizada mediante la creación de una cadena de aplicaciones - appchain.


¿Qué es una cadena de aplicaciones?
Una aplicación descentralizada o dApp es una aplicación web con al menos una parte de su backend residiendo en una blockchain. El backend de una dApp se puede implementar de dos maneras: los contratos inteligentes se pueden alojar en una plataforma de blockchain o una aplicación descentralizada podría vivir en su propia blockchain dedicada.

Cuando una dApp tiene su propia blockchain, se denomina blockchain específica de la aplicación o cadena de aplicaciones - appchain para abreviar. A diferencia de las dApps, las appchain permiten a los desarrolladores personalizar su aplicación en términos de estructura de gobierno, diseño económico e incluso su algoritmo de consenso subyacente.

Las appchains también brindan a los desarrolladores una capacidad de procesamiento de transacciones dedicada, lo que significa que una aplicación en una appchain no tiene que competir con otras aplicaciones por la capacidad de procesamiento de transacciones en una red.

Para ilustrar, mientras que miles de aplicaciones diferentes pueden compartir un conjunto estándar de configuraciones en una plataforma genérica de contrato inteligente, cada appchain en una configuración de PoS podría lograr fácilmente un rendimiento de 1K+ TPS y una finalización rápida, y toda esta capacidad de procesamiento de transacciones estaría dedicada a una sola aplicación.

A diferencia de los contratos inteligentes, las appchains pueden evolucionar rápidamente con legitimidad. Cada appchain es una economía autónoma con procesos explícitos definidos por código para llegar a acuerdos sobre actualizaciones de protocolos. Y, gracias a Substrate, la función principal de la gobernanza en cadena está lista para usar. Cualquier criptored puede reflejar el proceso de gobierno de otra mediante un código copiado y pegado. El gobierno de blockchain en sí mismo podría evolucionar como un software de código abierto.

Aún así, nadie puede ignorar que los contratos inteligentes son excelentes para casos de uso de comercio de activos, por ejemplo, DeFi. Debido a que los contratos inteligentes se basan en los mismos supuestos de seguridad, la componibilidad entre ellos es la receta esencial para la explosión de DeFi.

Sin embargo, si bien la experiencia del usuario de DeFi no es tan mala como la banca en línea, todavía tiene mucho margen de mejora, especialmente cuando se considera una blockchain de capa 1 más capaz que Ethereum, como NEAR Protocol.
¿Por qué Octopus eligió NEAR?
Si bien Substrate y Cosmos SDK han reducido el costo de desarrollo de las appchains a un nivel al menos comparable con los contratos inteligentes, el arranque de la appchain sigue siendo un trabajo técnicamente complejo y que requiere mucho capital para los desarrolladores.

NEAR Protocol es una blockchain fragmentada a prueba de participación - Proof-of-Stake (PoS) que enfatiza la escalabilidad y la usabilidad. NEAR a menudo se conoce como una solución de escalabilidad lista para usar para las dApps de Ethereum existentes, pero es igualmente capaz de manejar un conjunto de otros tipos de soluciones descentralizadas, como las appchains.

En comparación con otras plataformas de Capa 1 que también pueden admitir appchains, como Polkadot o Cosmos, NEAR tiene algunas ventajas técnicas y económicas claves.

En comparación con Cosmos, lanzar una appchain en NEAR es más fácil porque no es necesario arrancar los validadores para cada appchain individualmente.

Por ejemplo, en Cosmos, cada appchain debe protegerse con un conjunto de validadores descentralizados suficientemente comprometidos. Por lo tanto, los desarrolladores de una appchain primero deben obtener el reconocimiento del valor del token nativo de la appchain en los mercados de criptoactivos y luego iniciar una comunidad de validadores activa desde cero.

En comparación con Polkadot, NEAR ofrece a las appchain un alquiler de seguridad significativamente menos costoso y no tiene un límite en la cantidad de appchains que se pueden iniciar.

Una parachain o paracadena de Polkadot debe poder pagar el costo de consenso de un fragmento de la red, lo que podría equivaler a decenas de millones de dólares al año.

En un sistema de cómputo, una mayor seguridad no necesariamente equivale a una mejor seguridad, porque un mayor nivel de seguridad siempre conlleva un mayor nivel de costo. Entonces, lo que necesita un sistema de cómputo es una seguridad apropiada y adecuada.

En Polkadot, los desarrolladores no pueden decidir un nivel de seguridad apropiado y adecuado para su parachain. Solo tienen una opción: ganar un espacio en la subasta. Pero incluso si una parachain gana la subasta, generalmente paga de más por la seguridad porque una criptored en sus fases de lanzamiento no necesita un nivel de seguridad de miles de millones de dólares.

Además, una carga de costos de seguridad de alto nivel desde el principio podría hundir una parachain en hiperinflación porque tiene que prometer emitir una gran cantidad de tokens nativos a los prestamistas de Crowdloan. Como mínimo, esta carga económica deja muy poco espacio a una parachain para incentivar a los verdaderos creadores de valor de su protocolo: los participantes que ayudan a construir los efectos de red de la criptored.

En pocas palabras, Octopus eligió NEAR sobre Polkadot y Cosmos porque es simplemente más rentable, escalable, fácil de usar e interoperable con redes como Ethereum que cualquier otra solución L1(capa 1) existente.

Creemos que las appchains serán la tercera ola de innovación de Cryptonetworks o criptoredes que nos llevará a Web3.0, y que Octopus Network hará que las appchains sean accesibles para proyectos en myriad con todo tipo de presupuestos.




	

	
	
		
			
				¿Qué es una cadena de aplicaciones?
			
		

		
					

		
			
			
			
			Una aplicación descentralizada
		
			
			Una blockchain de todo uso
		
			
			Una aplicación blockchain específica 
		
			
			Un contrato inteligente
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Las ventajas del alquileres PoS (LPoS)

¿Qué es la seguridad en el contexto de blockchain?

En pocas palabras, la seguridad es el nivel de certeza de que los protocolos predefinidos se aplicarán como esperaban la mayoría de las partes interesadas, ya sea en la capa base o en la capa de aplicación.

La seguridad de la blockchain generalmente se considera una propiedad cuantificable. No puede haber seguridad absoluta o ilimitada. Si una blockchain tuviera seguridad absoluta, debería ser tanto inutilizable como inasequible.

En comparación con el modelo de seguridad compartida de una parachain de Polkadot, la appchain Leased PoS (LPoS) de Octopus Network es mucho más escalable y flexible. Debido a que el arrendamiento de valores es esencialmente arrendamiento de capital o arrendamiento de garantías, escala sin limitaciones físicas.

En Polkadot, cada parachain acomodará una cierta cantidad de validadores en el grupo exclusivamente en una epoch determinada. El algoritmo de consenso limita el tamaño total del grupo. (Es por eso que se espera que el número total de parachains sea inferior a 100 con menos de 10 espacios para parachains disponibles este año).

El alquiler PoS de Octopus es mucho más rentable que el de Polkadot. Dado que Octopus no tiene su propia blockchain, y el token de $OCT se emite y administra mediante un contrato inteligente, Octopus no necesita pagar los costos de consenso directamente. Entonces, la tasa de inflación de $OCT podría establecerse en cero, lo que significa que la tasa de interés base del sistema económico Octopus es cero.

Cuando la tasa de interés base es cero, un APY del 3% al 5% es un rendimiento anual decente (que es el rango que esperamos que una appchain pague por su valor arrendado). En contraste, una parachain de Polkadot tiene que pagar 20% o más APY para volverse atractivo para los prestamistas de Crowdloan $DOT porque hacer staking en Polkadot Relay les dará a los inversores un rendimiento anual libre de riesgo del 14%.

Debido a que LPoS es una seguridad basada en las necesidades y ofrece a las appchain el apalancamiento rentable para escalar orgánicamente, creemos que LPoS es más propicio para el desarrollo a largo plazo de las appchain que los PoS independientes. Sin embargo, también creemos que el derecho a elegir siempre pertenece a cualquier comunidad de appchain.

Si alguna appchain en Octopus Network decide dejar de usar LPoS para transformarse en una blockchain de PoS independiente, Octopus incluso proporcionará las herramientas para respaldar su transformación. Su conexión con Octopus Network se degradaría a la de un puente IBC estándar y los activos de cadena cruzada existentes no se verían afectados.
Descripción general de la red Octopus

Leyenda: D-Delegator, S- Staking, V- Validator, RT - Runtime, N- Node
Octopus Relay está situado en el núcleo de Octopus Network. Octopus Relay es un conjunto de contratos inteligentes que se ejecutan en la blockchain de NEAR (también conocida como cadena principal o aka mainchain) que implementa el mercado de arrendamiento de seguridad.

Las appchains de Octopus se ubican en el lado de la demanda del mercado. Las appchains de Octopus alquilan la seguridad de los titulares de $OCT pagando el alquiler en sus tokens nativos. Cada appchain puede elegir su propio modelo económico, incluída la cantidad de tokens nativos que está dispuesta a pagar a los validadores por seguridad.

Los validadores y delegadores de Octopus se ubican en el lado de la oferta del mercado de arrendamiento de valores.

Los validadores de Octopus u Octopus Validators apuesta o hace stake de tokens de $OCT para validar una appchain en particular y configurar un nodo para ejecutar el protocolo de esa appchain. A cambio, los Validadores son elegibles para recibir el respectivo token nativo de la appchain que están validando.

Los delegadores de Octopus pueden delegar su $OCT a los validadores para obtener una parte de las recompensas de participación del token nativo de una appchain. Las recompensas de participación se distribuyen a los delegadores directamente después de que los validadores cobran una comisión unificada.

Si los validadores se comportan mal (por ejemplo, se desconectan, atacan la red o ejecutan software modificado), ellos (y sus delegadores) son reducidos al perder un porcentaje de su $OCT apostado o stakeados. Todos los castigos se aplican a los Delegadores proporcionalmente cuando sus Validadores son cortados. De esta manera, el staking actúa como un desincentivo para el comportamiento malicioso.

Debido a que los titulares de $OCT son responsables de decidir en qué blockchain les gustaría hacer staking o apostar, Octopus Network funciona como un mercado libre donde las appchains pueden arrendar el nivel de seguridad que necesitan al precio de mercado en cualquier momento.

La Octopus Network también tiene una serie de herramientas para proveedores de seguridad, como herramientas de implementación y administración automáticas de nodos validadores de appchains, vistas económicas de redes y herramientas de análisis estadístico.

El mercado LPoS de Octopus Network permite a cualquier desarrollador, proyecto o empresario crear su propia appchain en NEAR de manera rápida, eficiente y económica.

Pero Octopus Network también es compatible con las appchains de muchas otras maneras, incluida la interoperabilidad entre cadenas, la infraestructura integrada y una comunidad lista para participar.




	

	
	
		
			
				¿Cuáles son las ventajas de LPoS?
			
		

		
					

		
			
			
			
			La LPoS es poco costosa
		
			
			La LPoS es flexible
		
			
			La LPoS es escalable
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interoperabilidad
Ahora es menos controvertido afirmar que todas las blockchains públicas y las redes multicadena eventualmente se interconectarán, formando la Internet de las blockchains. Octopus Network está diseñado específicamente para ser parte de esto.

El equipo de Octopus (anteriormente conocido como Cdot) ha estado trabajando en el protocolo de interoperabilidad de blockchain universal IBC y la integración entre cadenas durante más de dos años.

Octopus Relay permite la interoperabilidad de las appchains con el protocolo NEAR y Ethereum a través de Rainbow Bridge. Además, las appchains pueden utilizar una plataforma lista para usar IBC para conectarse directamente con cualquier blockchain habilitada para IBC.

Cualquier activo emitido en Ethereum, NEAR o cualquier blockchain habilitada para IBC puede transferirse y utilizarse en las appchains de Octopus sin desconfiar. Por el contrario, cualquier activo emitido en blockchain se puede transferir sin confianza a Ethereum, NEAR y cualquier cadena de bloques habilitada para IBC.

Basado en la interoperabilidad perfecta entre Octopus Network y NEAR, la variedad de criptoactivos emitidos en las appchains de Octopus también contribuirá a la prosperidad del ecosistema DeFi de NEAR.
Infraestructura
Octopus Network proporciona un conjunto completo de infraestructura para appchains, que incluye API Gateway, Blockchain Explorer, Archive Gateway, etc.

Octopus Bridge implementará un contrato contenedor NEP-141 en NEAR para cada token nativo de la appchain. Luego, las billeteras y los intercambios pueden integrar tokens de envoltura estándar en lugar de tener que integrarse con cada appchain individualmente.

Por lo tanto, los equipos de la appchain sólo deben concentrarse en el tiempo de ejecución de Substrate y el desarrollo de front-end, mientras que Octopus Network se encarga de todas las demás necesidades técnicas.
Comunidad
Una criptored es propiedad de su comunidad. Esta es la esencia de la descentralización y la diferencia fundamental con las plataformas Web2.0.

Octopus Network actúa como una metacomunidad para nutrir cientos de comunidades de aplicaciones Web3.0. Los desarrolladores de aplicaciones Web3.0 y los fundadores de cadenas de aplicaciones pueden mostrar los méritos de su criptored para atraer a una variedad de seguidores, como inversores, validadores, delegadores y participantes del protocolo.

Los usuarios interesados ​​en diferentes aplicaciones Web3.0 prestarán atención a sus aplicaciones favoritas a través de eventos como los lanzamientos de las appchains en Octopus. De esta manera, Octopus es una base comunitaria para appchains para apoyar su propio viaje de construir comunidades activas alrededor de ellas.

Octopus Network también brinda una gran bifurcación a todas sus cadenas de aplicaciones, por lo que no tiene sentido que cualquier tipo de magnate o tirano se haga cargo de una appchain sin el acuerdo de la comunidad, manteniéndola descentralizada. Octopus servirá todas sus appchains con capacidad de bifurcación al archivar el historial de blockchains de aplicaciones en Arweave, un protocolo de almacenamiento permanente descentralizado.

Según el historial de bloques archivado, cada appchain se puede bifurcar a cualquier altura para convertirse en una nueva appchain si su comunidad apoya la bifurcación. Y cualquier equipo central de la appchain es reemplazable si pierde la confianza de su comunidad. Así es como la conciencia del usuario asegura la descentralización.
¿Qué es el Programa Acelerador Octopus?
 



El equipo de Octopus es muy consciente de que el espacio de la blockchain sigue siendo sólo una parte de toda la industria de Internet. Y dentro del espacio blockchain, los desarrolladores de contratos inteligentes de Solidity son mucho más prolíficos que los desarrolladores de Substrate.

Para encontrar y atraer proyectos destacados de appchains, la primera tarea es transformar a los desarrolladores de Web y Solidity en desarrolladores de Substrate. En este sentido, el equipo de Octopus tiene mucha experiencia.

El equipo de Octopus ha construido con éxito IBC para Substrate y también ha ofrecido cursos de capacitación en línea de Substrate en China con otros entusiastas de Substrate. Estos cursos capacitaron al primer lote de desarrolladores de Substrate en China, iniciando la génesis de la Comunidad de Substrate de China. Los desarrolladores de Octopus también son organizadores de la comunidad Rust en China (incluida RustCon).

Hasta la fecha, muchos miembros del equipo de Octopus se han desempeñado como asistentes de enseñanza para el curso, que ahora es un curso oficial financiado por Parity, Inc. Con base en estas experiencias, estamos negociando con socios en todo el mundo, incluido el equipo educativo de NEAR, para brindar cursos de formación similares en todo el mundo.

Pero Octopus reconoce que los desarrolladores de Substrate calificados no son todo lo que requieren los proyectos exitosos de aplicaciones Web3.0. Es por eso que estamos lanzando el Programa Octopus Accelerator, una colección de cursos y seminarios abiertos y componibles disponibles tanto para los desarrolladores de Substrate como para los equipos de Web3.0 en todo el mundo.

Cada trimestre, el Programa Acelerador Octopus realizará una tanda de cursos con una duración de diez semanas. Durante cada período del curso, los temas ofrecidos incluirán temas como Economía de tokens, Diseño de productos Web3.0, Construcción de comunidades, Gobernanza de blockchain, Regulación criptográfica y Recaudación de fondos para proyectos criptográficos. Los expertos invitados participarán en seminarios, proporcionarán videos sobre temas específicos y estarán disponibles como mentores.

Al final de cada lote de cursos, la Fundación Octopus llevará a cabo un evento de Demo Day para seleccionar los cinco mejores proyectos de appchain y brindarles hasta $250,000 en recompensas totales por trimestre.

De esta manera, la Fundación Octopus financiará directamente 20 proyectos de appchain a través del Programa Octopus Accelerator cada año, otorgándoles más de $1 millón en total.




	

	
	
		
			
				¿Qué es cierto sobre el equipo de desarrollo de Octopus?
			
		

		
					

		
			
			
			
			El equipo de la red Octopus ha desarrollado un IBC para Substrate
		
			
			El equipo de la red Octopus ha formado los primeros desarrolladores Substrate en China
		
			
			El equipo de la red Octopus fue inicialmente conocido con el nombre de Cdot
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Cómo se activan las Appchains en Octopus?


El diseño arquitectónico de Octopus Network, junto con la potencia de procesamiento del protocolo NEAR, facilita el alojamiento de cientos de appchains. El proceso de selección de la appchain es parte del protocolo Octopus y el poder de toma de decisiones pertenece a la Comunidad Octopus.

Además de ser validadores y delegadores de appchains, los poseedores de tokens de $OCT tienen derecho a seleccionar los mejores proyectos de appchains votando a favor o en contra en una cola de candidatos en la cadena.

Las cadenas basadas en Substrate pueden convertirse en appchain de Octopus al completar con éxito las siguientes etapas:

 	Registro
 	Auditoría
 	Votación
 	Puesta en escena
 	Arrancando

Etapa de Registro
Cualquier cadena basada en Substrate puede postularse para convertirse en una cadena de aplicaciones Octopus. El registro requiere un documento técnico o una especificación y una versión de tiempo de ejecución que se haya probado y auditado internamente. Para evitar abusos, el registro requiere un pequeño depósito de $OCT.
Etapa de auditoría
Una vez registrada la appchain, los miembros del grupo de trabajo de la comunidad la auditarán. El propósito de la auditoría es garantizar que la appchain no tenga vulnerabilidades de seguridad conocidas y que la lógica de su aplicación sea consistente con su documento técnico o especificación.

La auditoría de Appchain en sí misma es actualmente una necesidad insatisfecha en el espacio blockchain. Sólo unas pocas empresas en la industria tienen la experiencia relevante y los servicios que brindan son costosos.

La auditoría realizada por Octopus Network no sólo reduce en gran medida el costo del lanzamiento de una appchain para sus fundadores, sino que también contribuye a la acumulación de conocimientos relevantes y capacidades profesionales.
Etapa de votación
Una vez que una appchain ha pasado la fase de auditoría, ingresa a la cola de candidatos donde los titulares de $OCT la votarán a favor o en contra.

En un período continuo que dura de una a dos semanas, la appchain que ocupa el primer lugar con la mayor cantidad de votos a favor menos los votos a favor en la cola entrará en el estado provisional como la appchain con más apoyo de la comunidad Octopus.
Etapa de puesta en escena
En la etapa de puesta en escena, los titulares de $OCT pueden participar o delegar en la cadena de aplicaciones.

Cuando finaliza el período de puesta en escena, si la cadena de aplicaciones ha atraído suficientes participaciones más allá del resultado final de seguridad, entrará en el estado de arranque.
Etapa de arranque
En la etapa de arranque, los miembros del grupo de trabajo ejecutarán 4 nodos de arranque para iniciar la appchain. Luego, los validadores deben ejecutar sus nodos para unirse al consenso de la appchain.

Octopus Network también ejecutará un clúster de nodos completo para cada appchain y proporcionará servicios de acceso API al front-end de la appchain. Los desarrolladores de la appchain sólo necesitan actualizar la configuración del front-end y la cadena de aplicaciones está lista para los usuarios finales.
Recompensas de la cadena de aplicaciones
Octopus reconoce que los proyectos de appchain son los creadores de valor de la red. Mientras que otras redes multicadena cobran la entrada a las appchains, Octopus considera que los equipos de appchains son la parte más crítica de la comunidad y está muy feliz de compartir con ellos los beneficios de la expansión del efecto de red.

Por lo tanto, las primeras 100 appchains Octopus lanzadas serán recompensadas directamente con 100k $OCT.

Además, la fundación ha decidido proporcionar recompensas adicionales de 1 millón de $OCT para las primeras diez appchains para reconocerlas como appchains fundadoras.
¿Qué es el token de $OCT?
$OCT, el token nativo de Octopus Network, es un token fungible y no inflacionario con tres utilidades principales:

 	Colateral para garantizar la seguridad de la appchain
 	Gobernanza
 	Apoyar a los candidatos de la appchain votándolos en la cola de candidatos

Seguridad Colateral
$OCT juega un papel clave en Octopus Network a través del staking de la appchain. Los titulares apuestan o ponen a stakear su $OCT para brindar seguridad a las appchains en las que creen para obtener recompensas en los tokens nativos de las respectivas appchains.

El staking de $OCT también actúa como un desincentivo para los participantes maliciosos que serían penalizados con la reducción de su $OCT, que es la fuente de seguridad alquilada para las appchains en Octopus.

Cuando Octopus funcione a plena capacidad, se lanzarán entre 30 y 50 appchains en la red anualmente.

Si la tasa de rendimiento de equilibrio a largo plazo de la participación en la appchain es del 5% anual, las appchains recién lanzadas por sí solas generarían alrededor de $400 millones en demandas de garantía cada año.
Gobernanza
La segunda función de $OCT es dar derecho a los titulares a controlar la gobernanza de la red (más específicamente, Octopus Relay, donde se aplican todas las reglas económicas) mediante la formación de Octopus DAO.

El Octopus DAO Council tiene un máximo de 100 miembros, pero lo más probable es que crezca de unos pocos miembros al principio a unas pocas docenas cuando se estabilice.

El poder de gobernanza de cada miembro del Consejo es valioso, pero lo suficientemente disperso como para evitar la colusión.

En nuestra opinión, en la mayoría de los casos, el valor de gobernanza de un token no puede desvincularse de su valor de utilidad. Una gobernanza sólida y ampliamente participada brindará a los titulares de tokens expectativas de valor más estables y suprimirá las fluctuaciones extremas en el precio del token, lo que reducirá el costo implícito de la opción de participación en la cadena de aplicaciones.
Votación de la cadena de aplicaciones
La tercera función de $OCT a través de titulares de $OCT es la selección de qué appchains vivirán en la red votando a favor o en contra de los candidatos de la appchain.

Los equipos de Appchain deberán convencer a la comunidad de Octopus de que su aplicación Web3.0 es significativa y creará flujos de valor continuos para los inversores que apuestan o stakean $OCT en sus appchains.

Los titulares de $OCT seleccionarán cuidadosamente las appchains que admiten, ya que existe un costo de oportunidad de perder aquellas que podrían ser más valiosas.
Conclusión
Nombramos Octopus Network en honor a la criatura bentónica marina más ferozmente inteligente. Desde una perspectiva evolutiva, el pulpo, que consta de unas 300 especies, es un organismo increíblemente exitoso. Ha existido durante 155 millones de años, vive en todos los océanos y sus muchas especies se han adaptado con éxito a una amplia gama de diversos hábitats marinos.

Esperamos que Octopus Network entregue aplicaciones descentralizadas para todas las industrias en línea que el intermediario tradicional Web2.0 ha controlado hasta ahora, y que devuelva valor a los verdaderos creadores.

En Octopus Network, podemos crear aplicaciones Web 3.0 con una gran experiencia de usuario aprovechando la tecnología de appchains, ya sea en juegos, NFT, DAO, publicidad, la economía de los creadores (vídeo, audio, gráficos, texto), mercados de predicción, el token registro curado (TCR), y más.

La tercera ola de innovación de criptoredes se está presentando actualmente en la parte posterior del versátil Octopus, que trae consigo el potencial de un tsunami de innovación descentralizada Web3.0, limitada solo por la imaginación.

### NEAR Revisión de contrato en vivo | Parte 4: Berry Farm (Granja de bayas)

Introducción
Soy Eugene, y hoy vamos a hablar sobre el contrato de Berry Farm (Granja de Bayas), que es el complemento de Berry Club que le permite convertir sus bananas en pepinos y cultivar NEAR. Primero hagamos una revisión rápida de Berry Farm. El repositorio se puede encontrar en mi Github. Aquí está el video original en el que se basa esta guía:


UI


 

 Berry farm es una aplicación muy bien diseñada con texto grande y muchos emojis. La forma en que funciona es que muestra sus saldos una vez que haya iniciado sesión. Lo extrae de dos contratos diferentes, así como de su cuenta. Los combina de múltiples fuentes. El aguacate y las bananas provienen del contrato de Berry Club, los pepinos son locales para ese contrato y NEAR proviene del saldo de su cuenta. Si usted formó algo, obtiene recompensas cuando éstas se distribuyen. Parece que alguien hizo muchas compras de aguacate recientemente y las recompensas en realidad aumentaron. También tiene estadísticas globales, lo que significa que se transfirieron 2500 NEAR de Berry Club a Berry Farm. Gané 116,9 NEAR y mi recompensa será 0,014332 NEAR según la cantidad de pepinos que tengo en comparación con la cantidad total de pepinos.



El número total de pepinos es 54116.4. Obtengo una participación del 3% de esta recompensa cada vez que hay una recompensa. Entonces, cuando hago clic en actualizar, básicamente actualizo las estadísticas de varias cuentas, y puedo reclamar NEAR  el cual se transfiere desde el contrato a mi cuenta. También puedo cambiar plátanos por pepinos y estoy haciendo una llamada al contrato de Berry Club.





Voy a transfer_with_vault, el cual está usando el nuevo estándar, y requiere una pequeña cantidad de NEAR, y creo que es como 1 yocto NEAR para confirmar que no estoy haciendo esto a través de una clave de acceso. No puedo hacer una transferencia a través de una clave de acceso para evitar los retiros automáticos, y esto es sólo una medida de seguridad. Si, por ejemplo, le gustaría autorizar a Berry Club desde alguna otra aplicación que intente vaciar todos sus bananas, fallaría, porque no podrá llamar a transfer_raw o transfer_with_vault. Para aclarar, transfer_raw es el nuevo nombre para transferir sin contrato, por lo que sólo puedes depositar en la cuenta de alguien que ya existe, y en transfer_with_vault la bóveda llama al receptor para retirar tokens.



Gasté 10 bananas para obtener más pepinos, y puedo actualizar el saldo nuevamente para ver si alguien retiró algo. Así es como funciona la interfaz de usuario (IU), pero hay más funciones para esto y no solo esto. El contrato admite pepinos como token fungible, también bananas. Potencialmente, puede crear otra aplicación que transfiera pepinos y hay una más que es Banana Swap que construyó Vlad Garchina.



Es un uniswap simplificado con un solo pool donde se puede comprar y vender bananas. En realidad no lo he probado antes. Quiero comprar 1 NEAR a través de bananas para lo cual necesito vender 6 bananas. Veamos si funciona.





Este llama a las transferencias en Berry Club que vuelve a estar implicado, pero con otro contrato. Actualmente no mostramos argumentos, pero eventualmente lo haremos.



Dice que me lo transferí y obtuve 1 NEAR por lo que gasté 6 bananas. Está genial.



Usted no puede agregar liquidez y se necesita un recorte del 10%. Así que esta es la interfaz de usuario (IU).
Revisión del contrato
Berry Club (club de bayas)
Permíteme presentarte el contrato. Entonces, comenzaremos con el contrato de Banana Farm, pero probablemente deba echarle un vistazo al contrato del token de pixelboard, el contrato de Berry Club, así como el que envía tokens.



Berry club tiene un contrato codificado llamado farm contract Id (id del contrato de la granja).



Cuando dibuja, éste verifica que no dibuje píxeles vacíos; de lo contrario, puede activar una recompensa sin gastar aguacates.



Luego llama a maybe_send_reward, que obtiene la hora actual de la cadena de bloques y verifica que next_reward_timestamp sea menor que la hora actual.



La próxima recompensa es el comienzo del tiempo de cultivo, que es una marca de tiempo global que originalmente habilitaba una cuenta regresiva de 26 horas o last_reward_timestamp cuando la activamos por última vez más 60 segundos.



Entonces, si es hora de enviar la próxima recompensa, recuerda la hora actual y calcula la recompensa en función de esta lógica, por lo que toma el saldo actual de Berry Club, toma el almacenamiento actual, calcula el almacenamiento por el costo de almacenamiento más alguna barra de margen de seguridad, que es 50 NEAR.



Siempre mantiene 15 NEAR para los saldos futuros. Entonces está diciendo si el saldo está disponible, si nuestro saldo es mayor que la cantidad que necesitamos para el almacenamiento más la seguridad, entonces calculamos el saldo líquido y lo dividimos por la porción de recompensa que daremos cada vez que es 24 veces 68. Si usted lo llama cada minuto, agotará la mayor parte de la cuenta, pero siempre está disminuyendo por sí mismo, porque el saldo disminuye por sí mismo, pero en su mayoría da todo el saldo en un día si lo llama cada minuto. En primer lugar, no puede producir un bloque que tenga una marca de tiempo anterior, y luego no puede producir un bloque más allá de su ranura, tiene una ranura dedicada cuando necesite producir un fragmento. Entonces, lo máximo que puede hacer es producir una parte del bloque final en el último milisegundo de su ranura, que está un segundo por delante. Realmente no puede avanzar demasiado, de lo contrario, todos los demás nodos también romperán el protocolo, por lo que están limitados por su comprensión del tiempo más la barra que usan para decidir si aceptan un bloque o no, por lo que no puede realmente hacer que el tiempo corra más rápido a menos que todos los validadores quieran hacer esto. Esto significaría que tenemos los validadores que esencialmente dejarán de seguir el protocolo. Necesitan coordinar su tiempo.



Así que al final obtuvo la recompensa, dice que voy a distribuir esta recompensa, y lo que hace es llamar al contrato de la granja y llamar a take_my_near y simplemente no pasa ningún argumento y pasa su recompensa y gas. Solo se necesita una cantidad mínima de gas para agregar los saldos. Así fue como se actualizó Berry Club para comenzar a distribuir recompensas potencialmente después de cada sorteo. Se necesita un poco más. Utiliza el gas que se gastó en dibujar para distribuir la recompensa de vez en cuando, lo que necesita alrededor de 10 tera gas para esto.
Berry Farm - Granja de bayas
Vayamos a Berry Farm y comencemos con este contrato. La forma en que funciona la granja de bayas necesita, en tiempo constante, poder distribuir recompensas en función del número total de pepinos, lo cual no es una tarea trivial, es algo similar al grupo de participación y cómo el grupo de participación distribuye las recompensas. El Staking pool (grupo de participación) crea un montón de shares o acciones por cada depósito que realiza y la acción tiene un precio global actual que dice: "Oye, compré o acuñé más  shares o acciones, y ahora mis acciones se pueden canjear por una cantidad determinada de tokens NEAR". El precio de las acciones comienza desde 1 yocto NEAR por acción, y luego, cuantas más recompensas acumule, más sube el precio de las acciones. Cuando usa la opción de no participación (unstake), vende las acciones al precio actual, y obtiene NEAR al cambio, y está unstaked (no apostada, sin participación), y se redondea hacia abajo. El desafío allí es que cuando usted hace staking o apuesta pepinos, el precio de un pepino es cero, y cuando hace staking o  apuesta por primera vez, realmente no puede comprar shares o acciones y mint shares, porque el precio de ellas es cero. La lógica de las shares o acciones no funciona muy bien para esto, así que yo necesitaba crear algo diferente para hacer la contabilidad. Vayamos a los ejemplos. Digamos que Mike es la primera persona que depositó 10 pepinos en el contrato, y luego digamos que se distribuyeron 100 NEAR. Mike se llevará todas las recompensas porque es el único, ahora controla el 100% de la participación en Berry Farm. Mike estaba desconectado, por ejemplo, y no los reclamó, por lo que realmente no podemos actualizar su cuenta, porque tiene que hacerse en tiempo constante. No podemos iterar a través de todas las cuentas, pero de alguna manera debemos recordar que Mike obtuvo todo en NEAR por sus pepinos. Ahora digamos que Josh entra y hace staking o apuesta otros 10 pepinos ahora la participación de Mike es del 50 % y la participación de Josh es del 50 %, pero Josh hizo staking o apostó los pepinos después de que ya se distribuyeron estos 100 NEAR iniciales. No tiene derecho a nada de esto ahora, otros 100 NEAR caen y  Mike ahora necesita obtener 50 más, porque tiene una participación del 50% y Josh obtiene 50 NEAR. Cuando Mike vuelva a estar en línea, debemos poder mostrar su saldo en 150 NEAR que ganó en tiempo constante. Entonces, este es el desafío que necesitábamos abordar con este contrato, y la forma en que se resolvió es tener una relación global de la llamada  NEAR por pepinos que dice cuánto NEAR recibe un saldo por pepino dado cuando se crea una cuenta, o tocado de ninguna manera. Recordamos el último valor de esta fracción.



Entonces tenemos un saldo en NEAR, por lo que si la última fracción fue menor que la fracción actual, significa que podemos multiplicar los pepinos de la cuenta dada por la diferencia entre 2 fracciones, y calcular a cuántos NEAR tengo derecho. Cuando se creó la cuenta de Mike, la fracción era 0 dividida por uno y cuando se depositaron 100 NEAR donde el recuento total de pepinos era 10, esta fracción se volvió igual a 10. Luego, una vez que Josh se unió y dejó caer otros 10 pepinos al total, y otros 100 NEAR se repartieron, esta fracción se incrementó en 5, debido a que había un total de 20 pepinos y 100 NEAR. Entonces, 100 NEAR dividido por 20 significa 5 NEAR por pepino, por lo que se convirtió en 15. Ahora, cuando Mike regresa, mira su saldo de pepino, que es 10 NEAR por pepino en un contrato global, es 15, su último valor recordado es cero, así que solo toma la diferencia que es 15 multiplicada por 10 y reclama este saldo en NEAR, y este 1 vuelve a 15. Cuando Josh regresa, obtiene este valor que era 10, y tiene 10 pepinos y el valor actual es 15. La diferencia es 5 multiplicado por el saldo de pepino de 10 por lo que obtiene 50 NEAR. Así es cómo administramos el saldo NEAR y nos apropiamos de las recompensas recibidas de las personas que usan tiempo constante para recalcularlo. Entonces, en lugar de mantener una fracción completa en la memoria, usamos un denominador global que es fijo y lo usé a 10 elevado a 18, que es la misma precisión que los pepinos, bananas y aguacates. Ese es el trasfondo de cómo se calcula todo.



Veamos la estructura principal del contrato, un contrato llamado farm (granja). Tiene un mapa de búsqueda de cuentas y utiliza hashes cortos similares a tokens fungibles con vaults o bóvedas. Tiene la identificación de la cuenta del token banana que también se puede codificar, pero se usó desde el contrato porque en realidad podemos pasarlo, porque esta cuenta se implementó después y no quería actualizar el estado del contrato de banana Berry Club. No quería volver a modificar el estado a través de la capacidad de actualización, así que codifiqué el valor en el contrato anterior. NEAR por pepino, la fracción que expliqué anteriormente es el numerador y se necesita el saldo total de pepinos como denominador. Las bóvedas y el próximo voto se utilizan para transferencias; en realidad, probablemente nunca terminaron acostumbrándose a transferir pepinos, excepto tal vez una vez para una prueba.



Esto es lo que vimos antes, esto es una vez más un hash de la identificación de la cuenta.



La estructura de la cuenta es el último valor antes de que la cuenta fuera tocada con esta fracción. El near_balance es el saldo no reclamado. Cada vez que usted toca una cuenta, ya sea depositando más pepinos o reclamando NEAR, este actualiza el último valor y mueve todo el NEAR no reclamado a su saldo local fuera de la diferencia, y el saldo de pepinos es su saldo en pepinos. Near_claimed son las estadísticas, es decir, la cantidad de recompensas que ya usted la reclamó. No es necesario para la lógica del contrato.



Hay dos estructuras auxiliares solo para la parte delantera. HumanAccount devuelve valores de una forma más legible y HumanStats son estadísticas globales de consumo. Vayamos a la función take_my_near para ver cómo funciona.



Lo primero que hacemos es verificar que haya suficientes pepinos allí, porque lo usamos como denominador. Solo queremos que 1 pepino desencadene esto, y esto es solo una precaución. A usted no le gustaría desencadenar este tipo de cosas. Exploremos este valor. Qué sucede si  usted obtiene la cantidad de NEAR, y yocto NEAR, y la multiplica por el denominador global. Por lo que está resolviendo una fracción que es NEAR por pepino dividida por el denominador más el saldo adjunto dividido por el saldo total de pepino. Esta es la fórmula: near_per_pepino/denom+attached_deposit/total_pepino_balance. Entonces new_near_per_pepino es en realidad el numerador con el attached_deposit y el denominador luego dividido por el denominador. Esta es la fórmula: new_near_per_pepino = (near_per-pepino_numer +denom + attached_deosit) / denom. Esta es la fórmula que usamos para calcular new_near_per_pepino. Cada vez que toca una cuenta, siempre convierte su saldo actual no reclamado en un número fijo, y luego puede modificar cualquiera de los valores sin romper la lógica. Este método táctil es llamado por cada getter y cada método de cambio. Antes de modificar la cuenta, siempre llama touch on the account (toque en la cuenta).



Por ejemplo, en get_near_balance obtenemos la cuenta interna. Si la cuenta existe, la tocamos localmente. Entonces deberíamos obtener el near_balance



Si obtiene la cuenta, la tocamos antes, obtenga su near_balance, cucumber_balance y claim balance o saldo reclamado. Esas son funciones de vista que están cambiando cosas, pero no lo guarda, por lo que solo cambia temporalmente el valor de la cuenta y no lo vuelve a guardar. Simplemente hace un toque que es una especie de cálculo con el valor más reciente.



Lo guarda cuando realmente realiza una llamada de cambio, por ejemplo, llame a Claim_near. Obtenemos su cuenta y get_mut_account realmente toca la cuenta. Obtiene la cuenta que ya está actualizada, y near_balance es el saldo real. Este lleva el near_blance a cero, dice que reclamó todo esto y guarda su cuenta. Luego, si reclama un valor positivo, se lo transferiremos de su cuenta. Devuelve cuánto NEAR reclamó. La belleza de este método tocar o “touch” es que se puede llamar en cualquier momento. No tiene que llamarse en el punto dado, por lo que siempre le dará el mismo resultado sin importar si lo llamó dos veces en el medio o lo llamó una vez. Esto es solo para devolverle al usuario cuánto tiene. Simplemente le dice cuánto NEAR ganó al calcular desde el estado actual. En Berry Club también hacemos las mismas cosas, tenemos “touch”, y esto es necesario, porque digamos que quiere saber cuántas bananas cultivó. Como sabemos la última vez que tocó su cuenta, la última vez que dibujó algo, sabemos cuántos píxeles tiene. Podemos calcular desde un momento dado hasta el momento anterior multiplicado por la cantidad de píxeles que tenía, cuántas bananas debería tener en este momento, y la parte frontal hace lo mismo. El front-end lo simula, obtiene la misma información excepto la más reciente, y luego simplemente crea un temporizador que lo calcula. En teoría, el método get_near_balance no tiene que devolver su valor de NEAR actualizado, solo puede decir aquí están los NEAR totales por pepino y su último NEAR total por pepino y también su último saldo NEAR, pero en su lugar esto se hace en el nivel de contrato. Digamos que no tenemos métodos de visualización por los que no paga y solo devuelve y recupera un estado, entonces tendría que hacer esta lógica en el front-end en lugar de hacerlo aquí en la memoria.
Token.rs
La lógica final que debemos hacer es cómo recibe sus pepinos de Berry Club, y esto se hace usando transfer_with_vault de Berry Club. Anteriormente discutimos cómo funciona el mapa 122.



Pasas el receiver_id, amount y payload. Esto tiene un chequeo assert_paid que solo verifica que el depósito sea positivo. Está diciendo, oh, necesita al menos 1 yocto NEAR para evitar llamadas de teclas de acceso a funciones para evitar que una interfaz de usuario maliciosa de Berry Club agote todas sus bananas. Obtiene el gas y luego inicia una llamada que pone bananas en una vault o bóveda. También inicia una llamada al receptor. En este caso, lo llamamos un on-farm contract o contrato en la granja y pasa la identificación del remitente una cantidad de bananas, una identificación de bóveda que es solo un u64 sin JSON y una carga útil que es una cadena. En el ejemplo anterior, cuando hablábamos del mapa 122, la carga útil era un binario de vec q8 en base64, porque era una carga útil serializada borsh. Durante la discusión, noté que si revisa este argumento en una billetera, no podrá ver la carga útil que deseas hacer, por lo que en la implementación de este contrato, en realidad usamos JSON para la carga útil, de modo que insertamos el JSON desde el carga útil de cadena. Es una enumeración con una sola opción llamada deposit_and_stake.



Ahora, cuando realiza una llamada de función desde la interfaz de usuario de la granja que irá a la billetera en los argumentos, la carga útil será como una cadena adyacente dentro de una cadena que dice depósito y apuestas en lugar de ser un cero codificado como base, en lugar de ser un borsh versión serializada, es legible por humanos. Este contrato tiene diferentes tipos de carga útil que Uniswap, por ejemplo, tendrá una carga útil que indica cuánto NEAR deseas recibir como máximo o al menos. La interfaz de usuario maliciosa de Uniswap puede reemplazar este valor, y si no lo verificaste en el lado de la billetera, es posible que se caiga por debajo de la tendencia principal. Obtuvimos la cuenta usando get_mut_account, que obtiene una cuenta existente o crea una nueva cuenta donde establece todos los saldos en 0, pero el último numerador cercano por pepino es el global actual. Esto significa que no cultivaste nada y tienes un saldo de pepino cero. Se toca de todos modos, incluso si no es necesario, podríamos haberlo evitado si hubiéramos mapeado, y luego devuelve el hash y la cuenta. La cuenta ya está actualizada. Lo que hacemos es primero aumentar el saldo total de pepinos y luego lo guardamos en el estado de la cuenta y también aumentamos el saldo global de pepinos por la cantidad de pepinos depositados. Luego, no verificamos realmente que la bóveda contenga pepinos, por lo que confiamos en que la persona que llamó anteriormente, que es un contrato de bananas, realmente puso las bananas en la bóveda, y devolvemos la promesa con este método. Es una combinación extraña con una sola entrada porque la carga útil sólo puede ser de un tipo en este momento. Llamamos a retirar_de_vault, indicamos la cantidad que queremos retirar, que es la cantidad total, y luego la llamamos de vuelta a la identificación de la cuenta del token de banana, que es un contrato de Berry Club. Aun así, este contrato aún no recibió bananas, no le importa porque de todos modos no usa bananas. Este no necesita bananas antes de que pueda continuar, así que no importa cuánto tiempo vaya a poner pepinos allí, y la bóveda ya está cerrada. Aumenta el saldo total de pepinos al diluir las acciones. Ahora, cuando llegue take_my_near, utilizará el nuevo saldo total de pepino. Ahora dividiré el número de acciones entre todos los participantes.
Conclusión
Esa es la descripción general de los contratos de Berry Club, Berry Farm y token.rs. Gracias por leer y buena suerte en sus futuros proyectos con NEAR.

### ¿Qué es la Tokenómica? Guía Express

Uno de los principios básicos de una red descentralizada es su tokenómica. Para ayudar a los proyectos a comprender mejor los matices de sus tokens, Learn Near Club ayudó a lanzar un nuevo campo de juego práctico de tokenómica en NEAR Testnet – LNC|TokenHub. Sin embargo, antes de entrar en detalles, sepamos qué significa tokenómica.
¿Qué es la Tokenómica?
Token fue inicialmente sólo otro término para una "criptomoneda" o "criptoactivo". Sin embargo, últimamente, hemos usado el término "token" para explicar un activo criptográfico que se emite en el tope de  una cadena de bloques. El término "tokenómica" (tokenomics) es una palabra compuesta de "token" y "economía", y es un término que se usa para describir, lo adivinó, la economía de un token.

Cuando desee medir la tokenómica de la red, debe hacerse estas preguntas:

 	¿Cuál es el suministro total de tokens y cuántos de ellos ingresan al sistema a la vez?
 	¿Cuántos tokens se crearán en el futuro?
 	¿Cómo se distribuyen los tokens entre los usuarios?
 	¿Cuál es el papel exacto del token en la red?
 	¿La red necesita un token para funcionar?

En general, el propósito es establecer un vínculo claro entre la plataforma y el activo.
Elementos definidos en la Tokenómica
La tokenómica se puede diferenciar ampliamente entre control de suministro y utilidad. Veamos cada uno de estos elementos.
#1 Control de suministro
Cuánto de los tokens de protocolo estarán realmente en circulación. ¿Cuánto del suministro está siendo controlado por el contrato base? En este aspecto, debemos entender ciertos términos.

Preminado

Básicamente, cuántos tokens ya están flotando en el ecosistema en el momento del lanzamiento. Por lo general, los tokens son extraídos periódicamente por usuarios especializados llamados "mineros". Sin embargo, los protocolos específicos a menudo ponen a disposición un cierto porcentaje de su suministro total durante el lanzamiento para la distribución de tokens y el acceso a la liquidez. Sin embargo, tenga en cuenta que preminar una gran cantidad de tokens podría generar problemas de centralización.

Asignación de tokens

¿Cómo se asignan los tokens al equipo del proyecto? ¿Calculan una gran cantidad de tokens, lo que genera problemas de centralización? ¿Cuántos de los tokens se asignan a la tesorería para el futuro desarrollo del protocolo?

Adquisición de tokens

La mayoría de los proyectos reciben financiación de capitalistas de riesgo (VCs) u otros inversores, que obtienen una asignación simbólica a cambio de su inversión. Desafortunadamente, la mayoría de las veces, los VCs tienden a deshacerse de su asignación de inmediato para obtener una ganancia rápida, lo que inevitablemente daña el protocolo. Puede bloquear una asignación de token en particular durante un período de tiempo específico con la adquisición de tokens para evitar una venta masiva.

La adquisición de tokens es crucial para inspirar la confianza de los inversores, ya que les dice que el equipo y los inversores se toman en serio el proyecto y no buscan una rentabilidad rápida. La adquisición de derechos es una manera fácil de reducir las manipulaciones del mercado y garantizar el valor de la inversión.

Quema de tokens

Otra táctica simple que utilizan muchos proyectos para controlar el suministro circulante es la quema de tokens. La idea es simple: eliminar periódicamente una cierta cantidad de tokens de la circulación de forma permanente. La mayoría de los proyectos hacen esto enviando tokens a una billetera muerta. Proyectos como Ethereum y Binance utilizan la quema de tokens para controlar el suministro de sus tokens nativos.
#2 Utilidad de tokens
¿Cuáles son los diferentes roles que pueden asumir sus tokens? Echemos un vistazo rápido a algunos de los diferentes roles.

 	Los tokens se pueden usar para fines puramente útiles y de pago dentro o fuera del entorno del protocolo.
 	Los tokens se pueden usar para apostar en el protocolo y participar en la gobernanza.
 	Se requiere tener el token de protocolo para acceder a las diferentes aplicaciones (DeFi y NFT) dentro del sistema.

Jugando con la Tokenómica
La herramienta de la tokenómica de Learn Near le permite mapear los diferentes componentes de su token y jugar con ellos en la red de prueba.

Estos componentes son:

 	Nombre de token
 	Versión inicial
 	Símbolo
 	Tesorería
 	Suministro inicial
 	Hora de inicio de la concesión
 	Duración de la concesión
 	Puntos decimales
 	Intervalo de adquisición

Jugar con estos diferentes valores lo ayudará a comprender el control de suministro de la tokenómica de su protocolo. ¿Quieres experimentar con esta herramienta? ¡Eche un vistazo a LNC TokenHub!

### NEAR Revisión de contrato en vivo | Parte 2: Contrato de grupo de participación (Staking)

Introducción
Hola, soy Eugene y esta es la segunda parte de la serie de revisión de contratos en vivo y hoy vamos a revisar el contrato del grupo de participación (o Staking), que se utiliza en este momento para asegurar el sistema de prueba de participación del Protocolo NEAR. Básicamente, todos los validadores que se ejecutan actualmente en el protocolo NEAR se ejecutan por medio de este contrato. Ellos no controlan la cuenta que bloquea la cantidad de tokens NEAR necesarios para la prueba de la participación por sí mismos, sino que el contrato apuesta la cantidad, y solo proporcionan un grupo de staking y ejecutan sus nodos. Hoy vamos a profundizar en este contrato. Entre los contratos principales, tenemos un contrato de grupo de staking y es un poco más complicado que el contrato anterior que revisamos (el contrato de votación). Así que hoy nos vamos a centrar más en la lógica y menos en near_bindgen y las cosas específicas de Rust, pero probablemente involucrará un poco más de conocimiento de NEAR Protocol. Aquí está el contrato del grupo de staking en el Github de NEAR. A continuación te muestro el video original en el que se basa esta guía.


lib.rs
Estructura del Constructor


Como antes, el contrato parte de la estructura principal. En este caso, se trata de una estructura de contrato de participación. Como puedes ver, hay near_bindgen, BorshSerialize y BorshDeserialize. La estructura ahora tiene muchos más campos que la anterior, y hay algunos comentarios sobre ellos, la mayoría de ellos probablemente estén actualizados. La lógica del contrato del grupo de participación nos permite hacer lo siguiente: básicamente, cualquiera puede depositar una cantidad de tokens NEAR en el grupo de participación y delegarlos en el grupo de participación bloqueandolos en el grupo. Eso nos permite agrupar los saldos de varias personas (aquí las llamamos cuentas) en una gran participación, y de esta manera, este gran grupo puede calificar para puestos de validación. NEAR Protocol tiene una cantidad limitada de asientos para un solo fragmento en este momento, hay como máximo 100 asientos de validación. Puedes pensar en los asientos de la siguiente manera: si tomas la cantidad total de tokens apostados y la divides por 100, el resultado será la cantidad mínima de tokens requeridos para un solo asiento, excepto que es un poco más complicado de implicar la eliminación las apuestas que no están calificadas para contener esta cantidad mínima, etc. Este contrato es básicamente un contrato independiente sin ninguna clave de acceso que esté controlada por el propietario. En este caso, el propietario se proporciona en el método de inicialización.
Método de inicialización


Así que vayamos al método de inicialización. Tienes tres argumentos y el primero es el owner_id, que es el ID de la cuenta del propietario. El propietario tiene varios permisos en este contrato que le permiten realizar acciones que no están disponibles para el resto de las cuentas. Uno de estos métodos es votar en nombre del grupo de participación en el contrato de votación que discutimos la última vez. Entonces el propietario puede llamar al método de voto.





Luego verificamos que el predecesor (predecessor_account_id) sea igual al propietario, ya que este método solo puede ser llamado por el propietario.



Entonces, lo que hace el método de votación es que verifica que el método fue llamado por el propietario y luego verifica alguna lógica, pero eso no es importante en este momento.



Entonces, el contrato es el propietario, y este propietario puede hacer ciertas cosas, tiene permisos adicionales. Luego, se necesitan algunos campos más: la stake_public_key. Cuando haces staking en NEAR, debes proporcionar una clave pública que será utilizada por tu nodo validador para firmar mensajes en nombre del nodo validador. Esta clave pública puede ser diferente de cualquier clave de acceso, e idealmente debería ser diferente de cualquier clave de acceso porque tu nodo puede ejecutarse en un centro de datos que puede ser vulnerable a algunos ataques. En este caso, lo máximo que pueden hacer es hacer algo malo en la red, pero no en tu cuenta. No pueden robar tus fondos, y puedes reemplazar fácilmente esta clave en comparación con la forma en que se reemplaza una clave de acceso defectuosa. Por último, el tercer argumento que toma el contrato es la reward_fee_fraction inicial. Esta es la comisión que toma el propietario del grupo de participación por ejecutar el nodo validador.



Esta es una fracción que tiene un numerador y un denominador, y le permite básicamente decir "Tomo el 1% de las recompensas por ejecutar este grupo en particular", por ejemplo. Supongamos que tiene 1 000 000 de tokens y ellos adquirieron alguna recompensa, digamos que hay una recompensa de 10 000 tokens, luego el propietario tomará el 1% de esto, que son 100 tokens. El tipo de dato Float tiene un comportamiento impredecible cuando se multiplica. Por ejemplo, con fracciones, puedes usar matemáticas con una mayor cantidad de bits. Entonces, la forma en que haces la división, por ejemplo, es primero multiplicar la cantidad que es u128 por un numerador (esto ya puede desbordarse en u128), pero es por eso que hacemos esto en u256. Luego lo divides por el denominador que debería llevarlo nuevamente por debajo de u128. Esto te da una mayor precisión que float64, que no puede funcionar con una precisión de u128 bits, por lo que tendrás algunos errores de redondeo o errores de precisión cuando hagas los cálculos. Por lo que, de otra manera necesitas float de mayor precisión, que no son realmente diferentes de las matemáticas donde simulamos esto con u256. Solidity originalmente no admitía tipo de dato Float, y nosotros tampoco lo admitimos originalmente, pero eso arrojó algunos problemas sobre el formato de cadenas en Rust para la depuración, por lo que decidimos que no hay nada de malo en admitir floats, especialmente porque estandarizamos esto en el lado de la máquina virtual. El mayor problema con los floats fue el comportamiento indefinido en torno a ciertos valores de cargas, por ejemplo, qué contienen otros bits cuando tienes un float infinito. Estandarizamos esto, y ahora son independientes de la plataforma equivalente. Por lo tanto, está bien usar float ahora en nuestro entorno de VM.



La práctica estándar con “init" es que primero verifiquemos que el estado no existe. Luego verificamos la entrada. Lo primero que hacemos es verificar que la fracción sea válida y comprobar que el denominador no es cero. A continuación, tenemos una declaración "else" que verifica que el numerador sea menor o igual que el denominador, lo que significa que la fracción es menor o igual que 1. Esto es importante para evitar algunos errores lógicos. Lo siguiente que hacemos es verificar que la cuenta sea válida. Este contrato se redactó antes de algunas de las métricas de ayuda que existen ahora. Por ejemplo, tenemos la identificación de cuenta válida en tipos JSON que hace esta verificación automáticamente durante la deserialización, si no es válida, entrará en pánico. Después de eso, extraemos el saldo actual de la cuenta del contrato de participación. Este saldo suele ser lo suficientemente grande porque tiene que pagar por el almacenamiento de este contrato en particular, y luego decimos que vamos a asignar algunos tokens para el STAKE_SHARE_PRICE_GUARANTEE_FUND. El pool de participación tiene ciertas garantías que son importantes para los contratos locales. Las garantías aseguran que cuando depositas en el grupo de staking, deberías poder retirar al menos la misma cantidad de tokens, y no puedes perder tokens ni siquiera por hasta 1000 000 000 000 de yoctoNEAR en este contrato al depositar y retirar de los grupos de staking. El fondo de STAKE_SHARE_PRICE_GUARANTEE_FUND es de alrededor de 1 billón (“1 trillion” en inglés) de yoctoNEAR, mientras que normalmente consumimos alrededor de 1 o 2 billones de yoctoNEAR en errores de redondeo. Finalmente recordamos cuál es el saldo que vamos a bloquear en nombre de este contrato. Esto es necesario para establecer una línea de base para limitar las diferencias de redondeo. A continuación, verificamos que la cuenta aún no se haya bloqueado. Esto podría romper algo de lógica, pero no queremos que esto suceda, por lo que queremos inicializar el contrato antes de bloquear algo. Finalmente, inicializamos la estructura, pero no la devolvemos de inmediato. Acabamos de crear la estructura: StakingContract.



Nota: Un epoch es una unidad de tiempo de aproximadamente ~12 horas o 43,200 segundos para ser exactos.

Luego emitimos una transacción de re-delegación(re-staking). Esto es importante, porque debemos asegurarnos de que esta clave de staking que se proporcionó sea una clave restringida de ristretto válida, por ejemplo, una clave válida 5 119. Hay algunas claves en la curva que son claves válidas, pero no son específicas de ristretto, y las claves de validación solo pueden ser específicas de ristretto. Esto es algo específico de NEAR Protocol, y lo que sucede es que realiza una transacción de participación con la clave dada. Una vez que se crea esta transacción a partir del contrato, validamos esta transacción cuando sale. Si la clave no es válida, arrojará un error y fallará la inicialización completa de este grupo de participación. Si pasa una stake_public_key no válida como entrada, se revertirá la consolidación e implementación de tu contrato, y todo lo que suceda en este lote de transacciones se revertirá. Esto es importante para que el grupo no tenga una clave no válida, porque eso podría permitirle bloquear la participación de otras personas. Como parte de las garantías, decimos que si quitas tu participación, tus tokens se devolverán en 4 epochs. Serán elegibles para el retiro, y esto es importante para poder devolverlos a tu wallet.



Creo que son demasiados detalles antes de explicar la descripción general de alto nivel de cómo funcionan los contratos y cómo funcionan los saldos. Expliquemos el concepto de cómo podemos distribuir recompensas a los propietarios de cuentas en un tiempo constante cuando pasa un epoch. Esto es importante para la mayoría de los contratos inteligentes. Se quiere que actúen en un tiempo constante para cada método en lugar de un tiempo lineal para la cantidad de usuarios, porque si la cantidad de usuarios aumenta, la cantidad de gas necesaria para operar una escala lineal también aumentará, y eventualmente se acabará el gas. Es por eso que todos los contratos inteligentes deben actuar en un tiempo constante.
Estructura de la cuenta


La forma en que funciona para cada usuario está en la estructura denominada account. Cada usuario que ha delegado a este grupo de participación tendrá una estructura llamada account que tiene los siguientes campos: unstaked es el saldo en yoctoNEAR que no está delegado, por lo que es solo el saldo del usuario. Entonces stake_shares es en realidad un saldo, pero no en base NEAR, sino en el número de participaciones compartido. stake_shares es un concepto que se agregó a este grupo de participación en particular. La forma en que funciona es cuando tú delegas tus NEAR, esencialmente compras nuevas acciones al precio actual al convertir tu saldo no invertido en acciones de participación. El precio de una acción de participación es originalmente 1, pero con el tiempo crece con las recompensas, y cuando la cuenta recibe recompensas su saldo total de participación aumenta, pero la cantidad total de acciones de participación no cambia. Básicamente, cuando una cuenta recibe recompensas de validación o algunos otros depósitos directamente al saldo, aumenta la cantidad que puede recibir por cada acción de participación. Supongamos, por ejemplo, que originalmente tenías 1 millón NEAR depositado en esta cuenta. Supongamos que obtienes 1 millón de acciones (ignorando el yoctoNEAR por ahora), si el grupo de participación recibió 10000 NEAR en recompensas, todavía tienes 1 millón de acciones, pero el millón de acciones ahora corresponde a 1 010 000 NEAR. Ahora, si alguien más quiere bloquear NEAR en este momento, comprará acciones de participación internamente dentro del contrato al precio de 1.001 NEAR, porque cada acción vale eso ahora. Cuando recibes otra recompensa, no necesitas comprar más acciones a pesar del saldo total, y en el tiempo constante todos comparten la recompensa proporcionalmente a la cantidad de acciones que tienen. Ahora, cuando quieres retirar tus NEAR bloqueados, básicamente estás vendiendo estas acciones o quemándolas utilizando el concepto de tokens fungibles a favor del saldo no bloqueado. Por lo tanto, vendes al precio actual, disminuye la cantidad total de participación, así como la cantidad total de acciones, y cuando compras, aumenta el saldo total de la participación y la participación total de la acción mientras mantiene el precio constante. Cuando delegas o dejas de delegar no cambias el precio, cuando recibes las recompensas aumentas el precio.



El precio solo puede subir, y esto puede dar lugar a errores de redondeo cuando tu yoctoNEAR y tu saldo no pueden corresponder con precisión. Es por eso que tenemos este fondo de garantía de 1 billón de yoctoNEAR que arrojará un yoctoNEAR adicional a la mezcla varias veces. Finalmente, la parte final está ahí, debido a que NEAR Protocol no retira los NEAR y los devuelve de inmediato, tienes que esperar tres epoch hasta que tu saldo quede como no delegado y sea devuelto a la cuenta. Si dejas de participar, no puedes retirar este saldo inmediatamente del grupo de participación, sino que debes esperar tres epoch. Entonces recuerdas a qué altura de epoch llamaste a la acción unstake (dejaste de participar), y después de tres epoch tu saldo se desbloqueará y deberías poder retirar tus acción sin delegar. Sin embargo, hay una advertencia: si llamas a unstake en el último bloque del epoch, la promesa real de hacer unstaking (retirar tus NEAR) llegará para la próxima epoch. Llegará al primer bloque de la próxima epoch, y eso retrasará tu saldo bloqueado para desbloquearse dentro de cuatro epoch en lugar de tres. Esto se debe a que registramos la epoch en el bloque anterior, pero la transacción real ocurrió en el siguiente bloque, en la siguiente epoch. Para asegurarnos de que eso no suceda, bloqueamos el saldo por cuatro epoch en lugar de tres para tomar en cuenta este caso fronterizo. Eso es lo que constituye una cuenta. La idea de las acciones no es tan nueva, porque en Ethereum la mayoría de los proveedores de liquidez y los creadores de mercado automatizados utilizan un concepto similar. Cuando, por ejemplo, depositas en el grupo de liquidez, obtienes algún tipo de token de este grupo en lugar de la cantidad real que se representa allí. Cuando te retiras del grupo de liquidez, se quema este token y obtienes los tokens representados reales. La idea es muy similar a llamarlas acciones, porque tienen un precio correspondiente y podríamos haberlas llamado de otra manera. Esto fue casi desde el comienzo de este contrato de grupo de participación. Se exploró cómo podemos hacer esto correctamente, y una forma era limitar la cantidad de cuentas que pueden depositar en una cuenta de grupo determinada para esta actualización en particular. Eventualmente aterrizamos en el tiempo de complejidad constante y eso era un modelo más simple. Luego, las matemáticas de la estructura de stake_share se volvieron algo razonables, incluso así que también hay algunas involucradas allí.
Tipos de contrato
Repasemos este contrato. No está tan bien estructurado como un contrato de bloqueo, por ejemplo, porque el bloqueo es aún más complicado. Los tipos todavía están agrupados en el mismo contrato. Hay un montón de tipos de tipos, por ejemplo reward_fee_fraction es un tipo separado.



La cuenta es un tipo separado y también hay una cuenta legible por humanos que también es un tipo que solo se usa en llamadas para ver, por lo que no se usa para la lógica internamente.



Luego, después de terminar con todos los tipos, tenemos llamadas de contrato cruzado utilizando una interfaz de alto nivel.



Hay dos de ellos. La forma en que funciona es que tiene una macro de near_bindgen llamada ext_contract (que significa contrato externo). Puedes darle un nombre corto que generará y que podrás usar. Luego, tienes una descripción del rasgo que describe la interfaz del contrato externo que deseas utilizar. Esto describe el hecho de que puedes llamar a un método de voto en un contrato remoto y pasar un argumento. El argumento is_vote, que es un booleano verdadero o falso. Ahora podrás crear una promesa cuando la necesites y pasar un argumento posicional en lugar de un argumento serializado JSON. La macro se convertirá en apis de promesa de bajo nivel detrás de escena. La segunda interfaz es para una devolución de llamada en nosotros mismos, esto es bastante común, puedes llamarlo ext_self. Cuando necesites hacer una devolución de llamada y hacer algo sobre el resultado de la promesa asincrónica, puedes tener este tipo de interfaz. Lo que hacemos es comprobar si la acción de bloqueo se realizó correctamente. Finalmente, tenemos el cuerpo de la estructura de implementación principal del grupo de participación.
Estructura de archivo de contrato
Este contrato se divide en varios módulos.



Tienes libs.rs, que es la entrada principal, y también tienes un módulo interno. El módulo interno tiene la implementación sin la macro near_bindgen, por lo que ninguno de estos métodos será visible para ser llamado por un contrato por otra persona en la cadena. Solo se pueden llamar dentro de este contrato internamente para que no generen formatos JSON y no deserialicen el estado. Todos actúan como métodos habituales del lenguaje rust. El funcionamiento de este contrato de alto nivel es que cuando pasa una epoch puedes adquirir ciertas recompensas como validador.
Métodos importantes del contrato


Tenemos un método de ping que comprueba con un ping el contrato. El método ping comprueba si ha pasado un epoch y luego necesitamos distribuir recompensas. Si la epoch cambió, también se reiniciará, porque podría haber algún cambio en la cantidad de participación total que tiene que bloquear el contrato. El siguiente es el depósito.



El método de depósito es payable, lo que significa que puede aceptar un depósito adjunto. Esto es similar al decorador de Ethereum que le permite recibir fondos solo de los métodos que los esperan. Entonces near_bindgen por defecto entrará en pánico si intenta llamar a un método, por ejemplo ping, y adjuntar un depósito a este método. En consecuencia, payable nos permite adjuntar depósitos. En cada método hay un ping interno para asegurarnos de que distribuimos las recompensas anteriores antes de cambiar cualquier lógica. La estructura común es que si necesitamos hacer re-staking, primero hacemos algo de lógica y ya luego se hace re-staking.



El siguiente método es deposit_and_stake. Esta es una combinación de dos métodos. Primero, deposita el balance en el balance bloqueado de tu cuenta y también bloquea la misma cantidad inmediatamente en lugar de realizar dos transacciones. También es payable, porque también acepta un depósito.



El siguiente es withdraw_all. Intenta retirar todo el saldo pendiente de la cuenta que lo llamó. Cuando interactúa con el grupo de participación, debe interactuar con la cuenta que posee el saldo. En este caso, este es el predecessor_account_id y básicamente verificamos la cuenta, y luego retiramos la cantidad no bloqueada si podemos. Si no se retira, entrará en pánico. Por ejemplo, si todavía está bloqueado debido a que se quitó el bloqueo hace menos de 4 epoch.



Withdraw te permite retirar solo un saldo parcial.



Luego, stake_all bloquea todo el saldo no bloqueado, aunque es bastante raro usar este método, porque normalmente usas bloqueo de depósito, y ya tienes todo el saldo bloqueado.



Luego, en el método stake, solo bloqueas una cierta cantidad del balance bloqueado. La billetera Moonlight usa un costo separado para depositar el bloqueo, pero usan una transacción por lotes para hacer esto.



Finalmente, tienes unstake_all, que básicamente retira (desbloquea) todas tus acciones de participación convirtiéndolas a yoctoNEAR. Existe un método auxiliar que convierte tu número de acciones a una cantidad de yoctoNEAR y redondea hacia abajo, porque no podemos darte un extra por tu acción multiplicada por el precio. Así es como obtenemos la cantidad y luego llamamos a unstake por la cantidad dada.



La lógica staked_amount_from_num_shares_rounded_down usa u256, porque los saldos operan en u128. Para evitar que se desborde, multiplicamos el total_staked_balance por el número de acciones en u256. El precio es el cociente redondeado a la baja.



La versión redondeada staked_amount_from_num_shares_dered_up es muy similar excepto que hacemos una verificación que nos permite redondear. Al final de ambos lo volvemos a convertir a u128.

Luego tenemos la acción unstake que es muy similar a unstake_all, excepto que pasas la cantidad.


Métodos Getter/View
Después de eso, hay un montón de métodos getter que son llamadas de vista que le devuelven algunas cantidades. Puedes obtener el saldo no bloqueado de la cuenta, el saldo bloqueado de la cuenta, el saldo total de la cuenta, verificar si puedes retirar, el saldo total del bloqueo, que es la cantidad total que el grupo de participación tiene el bloqueo activo.



Luego puedes saber quién es el propietario del grupo de participación, puedes obtener la tarifa de recompensa actual o la comisión del grupo de participación, obtener la clave de participación actual y hay una cosa separada que verifica si el propietario pausó el grupo de participación.



Supongamos que el propietario realiza una migración en el grupo de participación en el nodo. Necesitan retirarse(desbloquearse) completamente, así que, por ejemplo, pueden pausar el grupo de participación que entonces enviará una transacción de estado a NEAR Protocol, y luego no hará re-staking hasta que reanuden el grupo de participación. Sin embargo, aún puedes retirar tus saldos, pero dejarás de adquirir recompensas una vez que haya pasado.



Finalmente, puedes obtener una cuenta legible por humanos que te brinda cuántos tokens tienes realmente para la cantidad de acciones al precio actual, y finalmente dice si puedes retirar o no.



accounts.len() te da la cantidad de cuentas, que es la cantidad de delegadores a este grupo de participación, y también puedes recuperar la información de múltiples delegadores a la vez. Esta es la paginación en una gran cantidad de cuentas dentro del mapa desordenado. Una forma de hacer esto es usar la función ayudante que llamamos keys_as_vector del mapa desordenado. Te brinda una colección persistente de claves del mapa, y luego puedes usar un iterador para solicitar cuentas de estas claves. Esa no es la forma más eficiente, pero te permite implementar la paginación en mapas desordenados.
Métodos Owner (de propietario)


Hay varios métodos de owner. Un método owner es un método que solo puede llamar el propietario. El propietario puede actualizar la clave de bloqueo. Supongamos que tienen un nodo diferente y que el propietario necesita usar una clave diferente. Todos estos métodos primero verifican que solo el propietario pueda llamarlo.



Este es el método que cambia la comisión en el grupo de apuestas. El propietario puede cambiar la comisión que estará activa en esta epoch empezando en esta epoch inmediatamente, pero todas las comisiones anteriores se calcularán utilizando la tarifa anterior.



Entonces este fue el método de votación que nos permitió hacer la transición a la fase dos de la red principal(MainNet).

A continuación, se encuentran los dos métodos que ya describí y que permiten pausar el bloqueo y reanudarlo.



El resto son solo pruebas. La mayor parte de la lógica ocurre en el interior.
Prueba de simulación
Básicamente, también tenemos pruebas de simulación para un grupo en particular. Esta prueba de simulación muestra cómo va a funcionar realmente la red. Primero inicializamos el grupo.



Bob es el delegador. Bob llamó al método de depósito del grupo, que es deposit_amount, utilizando el método de depósito. Luego, Bob puede verificar que el saldo no bloqueado esté funcionando correctamente. Entonces Bob bloquea la cantidad. Luego verificamos la cantidad bloqueada ahora. Verificamos que Bob ha bloqueado la misma cantidad.



Bob llama al método ping. No hay recompensas, pero en las simulaciones, las recompensas no funcionan de todos modos, por lo que debe hacerlo manualmente. Verificaremos una vez más que la cantidad de Bob sigue siendo la misma. Entonces el grupo se reanuda. Verificamos que el grupo se haya reanudado y luego lo bloqueamos a cero. Luego simulamos que el grupo ha adquirido algunas recompensas (1 NEAR) y Bob hace ping al grupo. Luego verificamos que la cantidad que recibió Bob sea positiva. Ese es un caso de simulación muy simple que dice que Bob depositó primero en el grupo, lo que verifica que la pausa y la reanudación funcionen, o simula que funciona y se asegura de que en el grupo no se haga staking(no sé bloqueé más) mientras está en pausa. Luego, cuando se reanuda, el grupo realmente está participando bloqueando. Entonces, esta prueba verifica no sólo esto, sino también que Bob ha obtenido la recompensa y qué se ha distribuido la recompensa. Hay otra prueba que verifica algo de lógica, pero es más complicada. Hay algunas pruebas unitarias en la parte inferior de esto que se supone que verifican ciertas cosas.



Algunas de estas pruebas no son ideales, pero verifican ciertas cosas que fueron lo suficientemente buenas como para asegurarse de que las matemáticas se sumen.
internal.rs
Método de ping interno


Pasemos a internal_ping. Es el método al que cualquiera puede llamar mediante ping para asegurarse de que se distribuyen las recompensas. En este momento tenemos grupos de participación activos y hay una cuenta delegada por una de las personas de NEAR que básicamente hace ping a cada bloqueo en el grupo cada 15 minutos para asegurarse de que se hayan distribuido las recompensas para mostrarlas en el saldo. De esa forma funciona la distribución de recompensas. Primero verificamos la altura de la epoch actual, por lo que si la altura de la epoch es la misma, entonces la epoch no ha cambiado, devolvemos falso para que no sea necesario volver a hacer re-staking. Si la epoch ha cambiado, recordamos que existe la epoch actual (altura de la epoch), obtenemos el nuevo saldo total de la cuenta. Se puede llamar a Ping cuando algunos tokens se depositaron a través de boletas de depósito, y ya son parte de account_balance, y dado que se llamó a ping antes, debemos restar este saldo antes de distribuir las recompensas. Obtenemos la cantidad total que tiene la cuenta, incluido el saldo bloqueado y el saldo desbloqueado. El saldo bloqueado es una cantidad apostada que adquiere recompensas, y el saldo desbloqueado también puede tener recompensas en ciertos escenarios en los que disminuye tu cantidad bloqueada, pero tus recompensas aún se reflejarán durante las próximas dos epoch. Después de eso, llegarán a la cantidad no apostada. Verificamos usando assert! que el saldo total es mayor que el saldo total anterior. Esto es algo invariante que requiere el grupo de participación. Hubo un montón de cosas en la red de prueba que fallaron en este invariante porque las personas todavía tenían claves de acceso en el mismo grupo de participación, y cuando las tienes, gastas el saldo en gas y puedes disminuir tu saldo total sin adquirir la recompensa. Finalmente, calculamos la cantidad de recompensas que recibió el grupo de participación. Este es el saldo total menos el saldo total conocido anteriormente, entonces es el saldo de la epoch anterior. Si las recompensas son positivas las distribuimos. Lo primero que hacemos es calcular la recompensa que el propietario se lleva como comisión.



Multiplicamos reward_fee_fraction por la recompensa total recibida y esto se redondea de manera similar con el numerador en u256 multiplicado por el valor dividido por el denominador en u256.



Owners_fee es la cantidad en yoctoNEAR que el propietario se quedará. La recompensa restante son las recompensas restantes que se deben volver a bloquear. Luego vuelve a re-stake. El propietario recibió las recompensas en yoctoNEAR, no en acciones, pero debido a que toda la lógica tiene que estar en acciones, el propietario del grupo de participación compra acciones al precio de las distribuciones de recompensa posteriores al resto de los delegadores. Entonces num_shares es la cantidad de acciones que el propietario recibirá como compensación por administrar el grupo de participación. Si es positivo, aumentamos la cantidad de acciones y recuperamos la cuenta del propietario, y también aumentamos la cantidad total de participación en acciones. Si por alguna razón durante el redondeo a la baja este saldo se convirtió en cero, fue debido a que la recompensa fue muy pequeña y el precio por acción fue muy grande, y entonces el grupo sólo recibió cero de recompensas. En ese caso, este saldo solo irá al precio por acción en lugar de compensar al propietario. A continuación, colocamos algunos datos de registro totales que dicen que existe la epoch actual, que recibimos las recompensas en una cantidad de acciones o fichas en juego, que el saldo total de la apuesta del grupo es algo y registramos la cantidad de acciones. La única forma en que exponemos el número de acciones al mundo externo es a través de los registros. A continuación, si el propietario recibió recompensas, está diciendo que la recompensa total fueron tantas acciones. Por último, recordamos el nuevo saldo total y eso es todo. Hemos distribuido todas las recompensas en tiempo constante y solo actualizamos una cuenta (la cuenta del propietario) para la comisión, y sólo si la comisión fue positiva.
Método de participación interna


Internal_stake es donde implementamos el fondo de garantía de precio. Digamos que el predecesor, en este caso lo llamaremos account_id quiere bloquear una cantidad de tokens. En realidad, el balance no es un tipo JSON, porque es un método interno, por lo que no necesitamos JSON aquí. Calculamos cuántas acciones redondeadas a la baja se requieren para bloquear la cantidad dada, por lo que esta es la cantidad de acciones que recibirá el propietario, pero la cantidad tiene que ser positiva. Luego verificamos el monto que el propietario debe pagar por las acciones, nuevamente redondeado a la baja. Esto es para garantizar que cuando el propietario compró acciones y las volvió a convertir sin recompensas, nunca perdió el 1 yoctoNEAR, porque eso podría romper la garantía. Finalmente, afirmamos que la cuenta tiene suficiente para pagar el monto cobrado, y disminuimos el saldo interno no bloqueado y aumentamos el saldo interno del número de acciones de la cuenta. A continuación, redondeamos el staked_amount_from_num_shares_rounded_up para que el número de acciones se redondee al alza. Este 1 centavo extra o 1 yoctoNEAR extra procederá del fondo garantizado durante el redondeo de las acciones. Cobramos menos al usuario, pero contribuimos más a la cantidad de este 1 billón de yoctoNEAR que originalmente habíamos designado para esto. Esta diferencia generalmente es de 1 yoctoNEAR que puede provenir del redondeo hacia arriba o hacia abajo. Después de eso, está la cantidad de total_staked_balance y total_stake_shares. A continuación, acuñamos nuevas acciones con ellos. Finalmente ponemos un log y devolvemos el resultado.



Unstaking funciona de manera muy similar. Redondea a la alza la cantidad de acciones que debe pagar. Luego calculamos la cantidad que recibes, redondeando a la alza nuevamente para pagarte de más por esto. Esto también proviene de un fondo de garantía. Luego disminuimos las acciones para aumentar la cantidad e indicamos cuándo puedes desbloquear el saldo entre cuatro epoch. El monto de unstake_amount se redondea a la baja para que desembolsemos un poco menos para garantizar el precio de otros participantes del grupo. Así es básicamente cómo funciona el grupo de apuestas y cómo funcionan las matemáticas. Compensamos los errores de redondeo de los fondos que asignamos.
Conclusión
Actualizamos las claves de ristretto durante el diseño de este contrato y fue tan sorprendente que tenemos que dar cuenta de esto. En el STAKE_SHARE_PRICE_GUARANTEE_FUND, 1 billón de yoctoNEAR debería ser suficiente para 500 mil millones de transacciones, que debería ser lo suficientemente grande para el grupo de apuestas para que no se pueda recargar porque las recompensas se redistribuirán inmediatamente al total_stake_balance en el próximo ping. Dedicamos bastante tiempo y esfuerzo a este contrato, porque hicimos toneladas de revisiones de seguridad, incluso internas y externas, especialmente en torno a estas matemáticas. Eso fue complicado, y se descubrieron algunas cosas como la clave ristretto que apareció durante las revisiones. Marcamos el registro de cambios de este contrato, y en el archivo readme hay un montón de cosas que aparecieron durante el desarrollo y las pruebas en el sistema en vivo, pero la versión original tardó aproximadamente una semana en escribirse. Luego lo limpiamos, lo probamos y lo mejoramos. Luego hicimos un montón de revisiones. El grupo pidió las funciones de pausar y reanudar, porque de lo contrario el propietario no tenía la capacidad de desbloquearse si su nodo falla, o si atacaran la red. Básicamente, esta participación activa estaría solicitando la validación y no ejecutando la red. Solíamos no tener recortes de recompensas. Esto no era un problema para los participantes, pero era un problema para la propia red. De esa manera, el propietario puede pausar el staking, si no quiere ejecutar el grupo, o quiere migrar el grupo y comunicarse tanto como sea posible antes de esto. A continuación, actualizamos la interfaz de votación para que coincida con el contrato de votación de la fase dos final. Agregamos métodos de ayuda de vista para poder consultar cuentas de una manera legible por humanos. Finalmente, hubo algunas mejoras en torno a los métodos de procesamiento por lotes, de modo que las funciones deposit_and_stake, stake_all, unstake_all y withdraw_all en lugar de tener que hacer una llamada de vista primero, obtienen la cantidad y ponen la cantidad para llamar al bloqueo. Así es como lo arreglamos.



Cuando bloqueas, no solo bloqueas la cantidad, también adjuntamos una promesa para verificar si el bloqueo fue exitoso. Es necesario para dos cosas: tu, si estás tratando de bloquear con una clave no válida (no una clave específica de ristretto), la promesa fallará antes de la ejecución. Fallará la validación antes de enviarlo, y eso hará que no necesite verificarlo dentro del contrato. Revertirá la última llamada y todo irá bien. También introdujimos el bloqueo mínimo a nivel de protocolo. El bloqueo mínimo es una décima parte de la cantidad del precio del último asiento, y si tu contrato intenta bloquear menos que esto, la acción fallará y no enviará la promesa. Supongamos que quieres deshacer una cantidad y reduces tu saldo bloqueado por debajo de una décima parte de la cantidad bloqueada. La acción de bloqueo puede fallar, y tu no perderás la cantidad, mientras lo necesites para garantizar que tiene que suceder. En este caso, tenemos esta devolución de llamada que verifica que la acción de replanteo se haya completado con éxito. Esta devolución de llamada básicamente verifica que si falla y el saldo es positivo, debemos deshacernos de la apuesta. Por lo tanto, llamará a unstake para una acción en la que el monto bloqueado sea cero para asegurarse de que se libere todo el saldo. Puede retirarse en 4 epoch durante la prueba de estos contratos que hicimos en la red de prueba (testnet) beta 9 antes del mantenimiento. El contrato estaba listo tal vez alrededor del horario de verano, por lo que la prueba de esta iteración tomó probablemente de 2 a 4 meses debido a la complejidad que implica interactuar con el protocolo. Se aprendió mucho desde la paginación hasta los métodos auxiliares y se agruparon algunas cosas. Una cosa que sería realmente agradable tener sería la opción de bloquear o desbloquear y bloquear todo en un contrato de lockup. En este momento, debes emitir manualmente cuánto deseas bloquear en un contrato de lockup, pero sería genial si no necesitarás pensar en tu yoctoNEAR y cuánto estás bloqueado para almacenamiento. Solo quieres apostar todo desde tu bloqueo, pero como ya estaba implementado, era demasiado tarde para pensar en esto. También hay algo de gas que está hardcodeado, y con la disminución común en la tarifa, estos números no se pueden cambiar porque ya están en la cadena.



Por lo tanto, votar no es importante, pero el método ON_STAKE_ACTION_GAS requiere que tengas un gran número por cada bloqueo y no puedes disminuirlo. El riesgo es que en cada llamada de este contrato requerirá que tengamos una gran cantidad de gas y esto es un desperdicio. Supongamos que estamos de acuerdo en quemar todo el gas, entonces este gas siempre se quemaría y se desperdiciaría, pero además esto limita la cantidad de transacciones que puedes colocar en un bloque si estamos restringiendo el gas basados en este caso. Hubo mucha iteración en la prueba del contrato utilizando el marco de prueba de simulación que mejoramos mucho. Si llegamos a los contratos “lockup”, eventualmente, podrás ver cómo la estructura de los contratos de “lockup” mejoró con respecto a este.

### Intégration avec le protocole NEAR

Une rédaction de notre parcours d'intégration NEAR




Commençons par les 3 piliers du protocole NEAR :

 	Proof-of-Stake (Preuve de participation)
 	Sharded (Fragmentée)
 	Contrats intelligents WASM

En tant que Proof of Stake, le consensus sur la blockchain est atteint par le staking et non par mining. Near a des blocs rapides de 1 seconde avec une finalité courte.

La blockchain est sharded ou fragmentée, ce qui signifie que les appels entre contrats sont asynchrones (à ne pas confondre avec synchrones comme sur Ethereum ou Solana). Codage des contrats NEAR, vous devez adopter l'état d'esprit de travailler avec un modèle d'acteur (ou des microservices, mais je déteste ce terme). L'exigence d'asynchronicité est nécessaire pour que les fragments puissent être traités en parallèle, ce qui entraîne un débit de transaction beaucoup plus important. Les blockchains où les contrats intelligents ne sont pas fragmentés atteindront simplement un plafond d'évolutivité, le déchargement vers le GPU ou l'ASIC (tout en restant synchrone) ne peut que retarder horizontalement ce plafond, mais cela ne conduira pas à une mise à l'échelle exponentielle.

Les contrats de NEAR sont du code WASM, vous pouvez donc coder dans n'importe quel langage pouvant être compilé jusqu'à WASM. Actuellement, AssemblyScript (sous-ensemble de TypeScript) et RUST sont les plus pris en charge avec les chaînes d'outils appropriées.

AVIS DE NON-RESPONSABILITÉ : Cela vous prendra MOINS de 30 minutes si vous pouvez programmer en TypeScript.

Construire une WebApp sur le protocole NEAR (qui est exactement ce à quoi Near accède) est très facile par rapport aux autres blockchains.

Clonons le contre-exemple ici https://github.com/near-examples/counter
git clone https://github.com/near-examples/counter
yarn

















Nous ne nous soucions que de ces 2 dossiers et 1 fichierassembly/ est l'endroit où se trouve notre contrat intelligent (qui se compilera jusqu'à WASM).

src/ est l'endroit où va notre frontend code qui interagit avec le contrat.

package.json est l'endroit où vont nos dépendances JavaScript supplémentaires.


















Le cœur de notre contrat comprend le stockage en chaîne, le contrôle de logging pour le reçu généré et les fonctions publiques exportées. Les fonctions qui définissent le stockage doivent être appelées sinon elles peuvent être visualisées (même sans compte NEAR).

Near prend en charge plusieurs types de collections (qui se décrivent elles-mêmes) sous le near-sdk-as.












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections
Les principaux dont vous aurez besoin :

 	stockage.getPrimitive —  get/set
 	persistentMap —   get/set 
 	persistentUnorderedMap — set/get/query/length  

Je n'inclus pas persistentVector car vous devriez éviter de l'utiliser, il est très facile de brûler des tonnes de gaz à d'itération de vectors, essayez d'utiliser des ensembles chaque fois que possible.

Les valeurs par défaut des collections persistentMap doivent être suffixées avec !
let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log imprimera le log output sur votre reçu lors de l'appel d'une fonction, ce qui est utile pour contrôler le flux de ce qui s'est passé, en particulier lorsque les contrats deviennent plus complexes. Un exemple de  minting contract lisible par l'homme peut avoir un message de log de "alice.near has minted 5,0 ZOD de zod.near".

Déployons notre contrat, pour cela nous avons besoin de near-cli.






npm install near-cli -g
Et pour déployer, nous pouvons créer un compte dummy testnet. Les comptes sont des contrats et vous ne pouvez avoir qu'un seul contrat par compte. Pour créer plusieurs contrats, vous devez utiliser des sous-comptes, contract1.me.near, contract2.me.near.

Déployons et appelons la fonction getCounter.
yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
Output c’est

View call: dev-1623290109414-64922580028342.getCounter({})
0
Permet d'incrémenter le compteur

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Permet de visualiser cet appel sur l'explorateur de blocs https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342
Impressionnant.

Pour afficher une fonction, nous pouvons utiliser curl mais nous devons analyser une commandline output, il est plus simple d'écrire un script de nœud rapide. Nous n'avons même pas besoin d'un compte Near.






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
L'extrait de code suivant utilise l'API RPC https://docs.near.org/docs/api/rpc pour interroger l'état du mint contract zodtv.near.

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
Near se dénomme au 24, le yocto.

3_000_000_000_000__000_000_000_000

est de 3,0

Cela met fin à la première série ici, la suivante travaillerait avec une interface Web et comment obtenir correctement le balance, l'état et plus encore.

### Integración con el Protocolo NEAR

Una versión escrita de nuestro viaje por la integración NEAR




Empecemos por cuales serian los 3 pilares del Protocolo NEAR:

 	Proof of Stake (Prueba de Participación)
 	Sharded (Fragmentado, Fragmentación)
 	WASM Smart Contracts (Contratos Inteligentes de WebAssembly)


Debido a que el consenso en una blockchain (cadena de bloques) de Proof of Stake se logra mediante el staking y no mediante el minado, Near tiene bloques rápidos de hasta 1 segundo de corta finalidad.

La blockchain al ser fragmentada significa que las llamadas entre contratos son asincrónicas (no debe ser confundido con sincrónicas como en Ethereum o Solana). Cuando se programan contratos en Near se necesita tener la mentalidad de trabajar con actores modelos (o microservicios, pero odio ese término). El requerimiento de asincronicidad es necesario para que los shards sean procesados en paralelo llevando a un mayor rendimiento de transacción. Las Blockchains dónde los contratos inteligentes no son fragmentados simplemente van a chocar contra un techo de escalabilidad, descargando al GPU o ASIC, (Aplicación Específica de Circuito Integrado, mientras sean sincrónicas) lo cual solamente demora horizontalmente la llegada de este techo y no permite llegar a escalabilidad exponencial.

Los contratos en NEAR tienen código WASM, por esto puedes desarrollar en cualquier lenguaje que pueda compilar en WASM. Actualmente AssemblyScript (subconjunto de TypeScript) y RUST son los más respaldados con herramientas de cadena decentes. 

DESCARGO DE RESPONSABILIDAD: Esto te va a tomar MENOS de 30 minutos si puedes programar en TypeScript.

Construir una WebApp (Aplicación Web) en el Protocolo NEAR (la cual es exactamente donde accede Near) es muy fácil comparado con otras blockchains

Clonemos el ejemplo del contador aquí: https://github.com/near-examples/counter.
git clone https://github.com/near-examples/counter
yarn

















Solamente nos importan estas 2 carpetas y 1 archivo. assembly/ es donde se encuentra nuestro contrato inteligente (el cual se va a compilar hacia WASM)/src es donde nuestro código frontend se encuentra el cual interactúa con el contrato.package.json es donde nuestras dependencias extras de JavaScript se encuentran.


















La parte principal de nuestro contrato incluye almacenamiento en cadena, control de inicio de sesión para el recibo generado, y funciones públicas exportadas. Las funciones que determinen almacenamiento deben ser llamadas de otra manera para que sean vistas (incluso sin cuenta NEAR).

Near soporta múltiples tipos de colecciones (que se describen a sí mismas) por medio del near-sdk-as.












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections
Las principales que vas a necesitar:

 	storage.getPrimitive — get/set
 	persistentMap — set/get
 	persistentUnorderedMap — set/get/query/length

No incluyo persistentVector ya que deberías intentar evitar usarlo, es muy sencillo quemar toneladas de gas iterando vectores, intenta usar conjuntos cuando sea posible.
Los valores por defecto para colecciones de persistentMap tienen que usar el sufijo !

let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log va a generar una salida de registro en tu recibo cuando invoques una función, esto es útil para control de flujo de lo que pasó, especialmente cuando los contratos se vuelven más complejos. Un ejemplo de un Minting Contract (contrato de minteo) legible por humano puede tener un mensaje de inicio de sesión de “alice.near has minted(ha minteado) 5.0 ZOD desde zod.near”
Lancemos nuestro contrato, para esto vamos a necesitar near-cli.






npm install near-cli -g
Y para lanzarlo vamos a crear una cuenta testnet de prueba. Las cuentas son contratos y solamente puedes tener 1 contrato por cuenta. Para crear multiples contratos necesitas utilizar sub cuentas, contract1.me.near, contract2.me.near
Lancemos e invoquemos la función getCounter

yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
La salida es

View call: dev-1623290109414-64922580028342.getCounter({})
0
Incrementamos el contador

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Miremos esta invocación en el explorador de bloques  https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342
Increíble.

Para visualizar una función podemos usar un curl pero necesitamos analizar gramaticalmente la salida de la línea de comando, en vez de ello es más simple utilizar un script de nodo rápido. No necesitamos siquiera una cuenta en Near.






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
El siguiente snippet (Sección de código) utiliza RPC API  https://docs.near.org/docs/api/rpc para consultar el estado del contrato mint zodtv.near 

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
Near denomina hasta el 24, el yocto.

3_000_000_000_000__000_000_000_000

es 3.0

Con eso concluye la primera serie aquí, la próxima vamos a trabajar con una web frontend y correctamente obtener balance, estado y más.

### ¿Qué son las DAO? Revisando el Sputnik DAO.

Una de las cosas más emocionantes que ha ganado mucha tracción en los últimos tiempos es el concepto de DAO u "Organización Autónoma Descentralizada". La idea es crear una empresa nativa de Internet que sea propiedad de sus miembros y esté administrada por ellos. No hay ningún CEO que controle el flujo del negocio, ningún CMO, ningún CFO, ni una junta directiva centralizada. En cambio, la lógica empresarial y la ejecución se integran en los contratos inteligentes para garantizar una implementación optimizada.

Ejemplos hipotéticos de DAO:

 	Caridad: Cualquiera puede convertirse en miembro y cualquiera puede donar. El grupo decide cómo gastar las donaciones.
 	Freelance Network: Red de contratistas que juntan sus fondos para herramientas relacionadas con freelance.
 	Empresas y subvenciones: un fondo de cobertura descentralizado donde los miembros pueden juntar sus fondos y votar sobre diferentes propuestas.

¿En qué se diferencian las DAO?
Las DAO ejecutan ciertas reglas que se registran en el contrato inteligente y se mantienen en la cadena de bloques. Se puede pensar en un contrato inteligente como un acuerdo automatizado entre dos o más partes. Debido a la naturaleza transparente de la cadena de bloques, es imposible cambiar el código que rige el contrato inteligente sin que toda la red se entere. Esto es lo que hace que las DAO sean más flexibles y robustas que las organizaciones típicas.

 	Las DAO son unas organizaciones democratizadas en las que cada miembro debe votar por cualquier cambio que deba implementarse. Las DAO utilizan una gobernanza basada en la comunidad en lugar de una basada en el ejecutivo.
 	Las DAO son globales y completamente transparentes.

¿Por qué las organizaciones jerárquicas no son lo suficientemente buenas?
Una estructura organizativa jerárquica y vertical es una forma común de organizar una empresa. La idea es simple: cada persona dentro de la organización (excepto la que está en la parte superior) está subordinada a otro individuo o entidad. Por lo tanto, aquellos con más poder están en la parte superior de la tabla. Al mismo tiempo, aquellos con menos poder aparecerán en la parte inferior. Sin embargo, debido a su estructura inherente, tiene varias deficiencias en comparación con las DAO.
 




DAOs
Jerárquico


Estructura
Plana y democrática
Jerárquica


Votación
Cada cambio en el sistema requiere la votación de los miembros.
Depende de la estructura y las reglas definidas por el sistema si requiere votación o no.


Intermediario
Los votos se cuentan y el resultado se implementa sin un intermediario confiable.
En caso de que se permita la votación, los votos deben ser contados por un intermediario.


Automatización
Los problemas relacionados con la gobernanza se manejan automáticamente de manera descentralizada.
Requiere manejo humano y centralizado. Por lo tanto, son vulnerables a la manipulación.


Visibilidad
Totalmente público y transparente
Privado y en su mayoría opaco.



Membership Models In DAO
 

Entonces, ¿cómo funciona exactamente un modelo de membresía DAO? Esto es muy importante ya que convertirse en miembro es clave para el modelo operativo de una DAO.

Muy bien, entonces hay dos modelos de membresía:

 	Basado en token.
 	Basado en acciones.

Basado en token
La mayoría de los protocolos tienen un token de gobernanza que se puede negociar en varios intercambios centralizados y descentralizados. Uno puede ganar estos tokens participando en un algoritmo de consenso o proporcionando liquidez. Como sugiere el nombre, poseer estos tokens te da acceso a los derechos de voto dentro del protocolo. Cuantos más tokens tengas, mayor será tu poder de voto. Un ejemplo de esto es MakerDAO y sus tokens de gobernanza: MKR. Cualquiera puede participar en la gobernanza de MakerDAO comprando los tokens MKR.
Basado en acciones
En comparación con las DAO basadas en tokens, en las DAO basadas en recursos compartidos requieren más permisos. Los miembros potenciales deben presentar una propuesta para unirse al DAO. La propuesta viene acompañada de un tributo en forma de tokens o algún trabajo. La acción de un participante representa su poder de voto directo. Pueden salir en cualquier momento con una parte proporcional de la tesorería. MolochDAO, un protocolo responsable de financiar proyectos basados en Ethereum, es un ejemplo de DAO basada en acciones. No puedes comprar tokens de gobernanza en el mercado abierto para obtener acceso al DAO. Para unirse a él, necesita la experiencia y el capital necesarios para ayudar a respaldar potenciales proyectos.
Aprendiendo de los errores - El hack DAO
Por supuesto, es fundamental aprender sobre el hack DAO que dividió Ethereum en Ethereum y Ethereum Classic. En 2016, Ethereum DAO se creó para cambiar las reglas del juego y repensar completamente la forma en que funcionan los fondos de riesgo. La idea era que los titulares de tokens DAO votarán sobre varias propuestas de proyectos. Si una propuesta obtiene un voto del 20% de la comunidad, obtendrá los fondos necesarios para comenzar.

La DAO también tenía un "mecanismo de división". Básicamente, si los miembros no están contentos con los proyectos incluidos en la lista blanca, podrían separarse del DAO para crear su propio "DAO secundario". De todos modos, el DAO fue un gran éxito y acumuló más de $150 millones en ether en una venta colectiva, para darte una perspectiva, este fue el 14% de todos los tokens de éter emitidos hasta la fecha.

Sin embargo, el DAO tenía una vulnerabilidad de código significativa. El 17 de junio de 2016, un atacante aprovechó esta vulnerabilidad para volver a ingresar continuamente al sistema y desviar $50 millones en ETH. La mayor parte de la comunidad decidió revertir este incidente a través de una dura bifurcación. Sin embargo, parte de la comunidad estaba en contra de esta medida. Esto finalmente llevó a una bifurcación que dividió el protocolo Ethereum en Ethereum y Ethereum Classic.
 Near Protocol y Sputnik DAO
El cofundador de Near Protocol, Illia Polosukhin anunció el Sputnik DAO en este artículo. Explicó que la DAO es una “forma para que las comunidades y organizaciones nuevas y existentes de todo el mundo tengan una representación on-chain de su grupo, gestionen su actividad en la cadena, gobiernen su toma de decisiones y ¡lo más importante! Interactúen con otras DAO. "

Sputnik tomó las siguientes inspiraciones para formar la "primera ola" de experimentación DAO:

 	La forma en que la comunidad controla la gobernanza no se adapta al número de personas involucradas. Muchos DAO han fracasado por varias razones, desde problemas técnicos hasta la falta de interés en votar de los miembros o la falta de un factor unificador y determinante.
 	Es imposible tener un sistema DAO completamente feliz para todos los miembros, los intereses se desviarán y las opiniones de la gente sobre una propuesta podrían cambiar. La minoría en el grupo podría potencialmente bifurcarse o divergir del grupo para seguir un nuevo sistema DAO.
 	Una comunidad u organización necesita liderazgo. Una comunidad ideal debe tener miembros dedicados que sean responsables de la coordinación, potencialmente la moderación.
 	Incluso si la comunidad es sin permisos y tiene un seudónimo, debe haber algunos miembros conocidos públicamente que crearán el núcleo de la comunidad.
 	Cuanto más centrada en el "producto" esté una comunidad descentralizada, más centrado debe estar el liderazgo.
 	La ponderación pura basada en el stake siempre falla porque la mayoría de las partes interesadas no pueden o no quieren ser participantes activos.

La interfaz Sputnik
En el momento en que vayas a la página de inicio de Sputnik, verás la siguiente pantalla.



Al hacer clic en "NEAR Forum", verás los diferentes hilos de conversación clasificados de forma ordenada y adecuada.



En la página de inicio, si haces clic en "Iniciar aplicación", obtendrás acceso a las diferentes DAO listadas en sputnik.



Te damos un ejemplo de algo que te parezca más conocido. Revisemos todas las propuestas en Learn NEAR DAO.



Entonces, como puedes ver, tiene varias propuestas enumeradas aquí, junto con sus respectivos pagos (en NEAR). Si una propuesta se aprueba o rechaza, se marcará así. Por ejemplo, en el ID de propuesta 22, alguien tradujo correctamente la página de inicio y el pie de página a "Vietnamese", por lo que puede ver el "1" junto a Approve y la insignia “Success”.


Cómo usamos Sputnik DAO en LeanNEAR.Club
Hay DOS niveles de DAO en uso:

La DAO principal y las siguientes subDAO:

 	https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near.

Mira a la DAO principal como Cliente/Financiador, a los subDAO como contratistas y a los miembros de los subDAO como subcontratistas.

Echemos un vistazo a cómo funciona para la traducción comunitaria. Una guía de los 3 proyectos principales de NFT sobre el protocolo NEAR debe traducirse al vietnamita.

Los miembros de la SubDAO presentan propuestas para su traducción y revisión.



Luego uno de ellos presentó una propuesta consolidada al DAO Madre con subDAO como receptor de fondos



Una vez que se acepta el trabajo y se publica la Guía traducida, los miembros de la subDAO dividen los fondos recibidos según las propuestas enviadas anteriormente.

Para posibles resoluciones de conflictos, la madre miembro de DAO actúa también como miembro con derecho a voto en TODOS los subDAO.
Conclusión
Así que ahí lo tienes. Los DAO son increíblemente disruptivos. Sin embargo, uno debe implementarlo correctamente para cosechar realmente las recompensas. ¡Parece que Near Protocol realmente ha descifrado el código con Sputnik!

### Una rápida introducción a la Red DeBio

La solución biomédica descentralizada en la red Octopus
El sistema biomédico actual está fracturado. El status quo impide que los pacientes puedan acceder a sus datos libremente y los proveedores de atención médica no pueden garantizar la seguridad de los datos de sus pacientes. La Red DeBio tiene como objetivo cambiar eso.
¿Qué es DeBio Network?
DeBio Network es una plataforma anónima descentralizada para medicina y bioinformática especializada en pruebas genómicas. DeBio tiene como objetivo revolucionar la industria biomédica actual al otorgar a los pacientes total soberanía sobre sus datos utilizando las tecnologías blockchain más innovadoras.

La introducción de blockchain en el ecosistema tecnológico actual juega un papel importante en la búsqueda de las finanzas globales descentralizadas, pero los casos de uso ofrecidos por blockchain superan más que solo las finanzas. DeBio cree que el futuro de los datos médicos se basa en parte en el uso de blockchain, particularmente en la especialización de casos de uso de tecnología, así como en la interoperabilidad.
Las pruebas genéticas centralizadas son un riesgo para la privacidad
Durante los últimos años, la popularidad de las pruebas genéticas se ha disparado. Como resultado, las plataformas de pruebas genéticas directas al consumidor como 23andMe y AncestryDNA han visto un aumento en los consumidores. Pero de lo que muchas personas no se dan cuenta es del riesgo implícito de privacidad al usar estas plataformas.

 

Las principales plataformas de pruebas genéticas directas al consumidor están centralizadas, lo que las convierte en un blanco fácil para las filtraciones de datos. En 2020, hubo 1001 violaciones de datos sólo en los Estados Unidos; con la industria de la salud recibiendo la peor parte, informó Govtech.

Aún más preocupante es que los datos genéticos no son exclusivos de un individuo, sino que son exclusivos del árbol genealógico del individuo. Al utilizar un servicio de bioinformática centralizado, pone en riesgo no solo su privacidad, sino también la privacidad de sus parientes lejanos.

El daño de esto es inequívoco porque existe la posibilidad de que sus parientes lejanos, por ejemplo, un primo segundo, se vean afectados por su decisión. Es preocupante la idea de un pariente lejano que ni siquiera sabes que existe, que se somete a una prueba genética y que sus datos genéticos se remontan a ti.

Los datos genéticos se pueden rastrear hasta usted incluso con una pequeña cantidad de información demográfica, como su edad y estado. Este tipo de información puede ser utilizada en su contra por las compañías de seguros, para aprovechar al máximo a sus clientes.
El concepto de red DeBio
El concepto principal detrás de DeBio se basa en la noción de querer aumentar las pruebas biomédicas y genéticas a los consumidores sin perder su privacidad. Pero DeBio también quiere incentivar la investigación genética ofreciendo colaboraciones entre laboratorios soberanos.
Un puente físico a digital para pruebas anónimas
Los consumidores pueden seleccionar una amplia gama de productos y recomendaciones de laboratorio del mercado de pruebas genéticas de DeBio. Una vez que el consumidor se ha decidido por un producto, solo tendrá que tomar dos muestras de ADN mediante el método de hisopo bucal o tomar muestras de células orales con hisopos de algodón.

Luego, el consumidor envía la muestra de ADN al laboratorio dentro de un sobre con la única información identificable escrita en el sobre es el ID de seguimiento genético de la muestra. Los laboratorios no pueden identificar muestras sin una identificación de seguimiento porque, con fines de anonimato, DeBio no recopilará información de identificación personal de ningún tipo, lo que hace que las muestras de ADN no puedan ser rastreadas hasta el consumidor.

Los resultados (por ejemplo, la prueba y el genoma) se cifran con la clave pública del consumidor recuperada de la cadena de bloques DeBio y se almacenan y luego se cargan en un almacenamiento descentralizado. Esto permite a los consumidores mantener la soberanía total sobre sus datos cifrados; los consumidores deben poseer sus claves privadas para descifrar los resultados.

El equipo de DeBio Network está expandiendo este concepto de “puente físico-digital” para usar casos fuera del mercado de pruebas genéticas, que pueden incluir pruebas de laboratorio para enfermedades y otros datos de registros médicos electrónicos o información de salud personal.
Colaboración de Sovereign Lab para ofrecer productos conjuntos que integran servicios de varios laboratorios
Después de que el consumidor envíe la muestra de ADN al laboratorio, se notificará al laboratorio. Cuando llegue la muestra, el laboratorio comenzará a secuenciar las muestras físicas o comenzará cualquier prueba de biomarcadores. Después de finalizar las pruebas posteriores, el laboratorio cifrará los resultados con la clave pública del consumidor y los cargará en un almacenamiento descentralizado.

Los resultados no se pueden descifrar sin el uso de la clave privada del consumidor, por lo que la soberanía del consumidor sobre los resultados de sus pruebas biomédicas es segura. Sin embargo, para incentivar aún más las pruebas genéticas, los consumidores optan por poner en juego sus datos de pruebas genéticas para que los utilicen otros laboratorios.

El objetivo de tener laboratorios soberanos es aumentar la disponibilidad de productos y permitir productos conjuntos mediante la integración de servicios de varios laboratorios. Esto también permite que DeBio escale porque los laboratorios no necesitan estar centralizados, lo que permite la participación de múltiples instalaciones genéticas independientes.




	

	
	
		
			
				Prueba: ¿Qué problema pretende resolver DeBio Network?
			
		

		
					

		
			
			
			
			Preocupaciones por la privacidad entre las plataformas de pruebas genéticas en línea
		
			
			Obstáculos en laboratorios soberanos para hacer su trabajo
		
			
			La falta de investigación en genómica
		
			
			Cuidado de la salud caro
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El Techstack de la red DeBio
La bioinformática y los ecosistemas biomédicos tienen demandas únicas en cuanto a cómo deben ser accesibles para los profesionales que realizan los estudios, pero también deben ser lo suficientemente seguros para salvaguardar la privacidad y la soberanía del paciente. Por lo tanto, para garantizar la soberanía del paciente sobre sus datos, toda la pila tecnológica consta de soluciones descentralizadas que van desde la autenticación descentralizada hasta el almacenamiento de archivos descentralizados.



Imagen tomada de DeBio Deck

DeBio ha incorporado una gran cantidad de tecnologías de vanguardia en la solución, que incluyen, entre otras, las siguientes:

 	

 	Substrate
 	Protocolo KILT
 	La red Octopus
 	El sistema de archivos interplanetario (IPFS)
 	Protocolo OCEAN



Substrate
La primera tecnología notable incorporada es el Substrate. Substrate es el marco detrás del token Polkadot, lo que permite a los desarrolladores crear cadenas de bloques con propósito. Los servicios centrales se construirán utilizando Substrate, lo que los convertirá en los componentes básicos de la solución. DeBio eligió Substrate por las dos razones siguientes:

 	Interoperabilidad de blockchain (esencialmente poder comunicarse entre diferentes blockchains).
 	Seguridad de la cadena de relés (aplicando estándares de seguridad más estrictos de la cadena de relés del host)

Además de permitir que las cadenas de bloques se comuniquen entre sí, la función de interoperabilidad también impone un estándar de seguridad que será heredado por cada cadena conectada a la cadena de relés principal. Como resultado, la seguridad de la cadena de bloques DeBio se mejora siguiendo los estándares de la cadena de relés correspondiente.
Protocolo KILT
La siguiente mención notable sería el Protocolo KILT. KILT es un protocolo para crear, certificar y verificar identidades de forma anónima en Web3. Para autenticarse, cada usuario debe crear una reclamo, que luego se enviará a un certificador de confianza. 

Un certificador tiene la responsabilidad de certificar el reclamo de un usuario, que luego se transformará en un hash que se guardará en la cadena de bloques KILT. El reclamo de un usuario a veces contiene datos confidenciales sobre el usuario, pero debido a que el hash no se puede transformar nuevamente en un reclamo del usuario, la privacidad del usuario está garantizada.

Después de recibir el certificado del certificador de confianza, el usuario ahora puede usar sus reclamos en aplicaciones que usan KILT y confían en el certificador mencionado anteriormente. KILT es privacidad por diseño. Las aplicaciones que verificarán el reclamo no necesitan pasar por el certificador y compararán directamente el reclamo con el almacenado en la cadena de bloques KILT, cortando al certificador del proceso de verificación y haciéndolo completamente descentralizado.

El protocolo KILT proporciona una solución que evita que los datos se concentren en una entidad. Permite la soberanía de los datos para quienes se preocupan por la privacidad. DeBio se ha asociado con KILT para implementar un sistema de autenticación descentralizado porque encaja perfectamente con el primer caso de uso anónimo de DeBio.
La red Octopus
Octopus es una red de cifrado para lanzar y ejecutar cadenas de bloques específicas de aplicaciones Web3 por una fracción del costo. Una de las consideraciones del uso de Octopus es que, en comparación con Polkadot, ofrecen un arrendamiento de seguridad significativamente más económico y capacidades comparables entre cadenas. Octopus está respaldado por el protocolo NEAR, NEAR es una cadena de bloques de alto rendimiento destinada a resolver el problema de escalabilidad y aumentar la productividad del desarrollador al simplificar el proceso de desarrollo y crear un entorno amigable para el desarrollador.

DeBio ya está asociado con Octopus y será una de las primeras cinco cadenas de bloques específicas de aplicaciones (cadenas de aplicaciones) lanzadas en Octopus Network. DeBio también forma parte de Octopus Guild, una comunidad de desarrolladores y cadenas de aplicaciones en Octopus Network.
El sistema de archivos interplanetario (IPFS)
El InterPlanetary File System (IPFS) es un protocolo creado para el intercambio y almacenamiento de datos de igual a igual totalmente descentralizado. IPFS se creó como una solución para proyectos descentralizados que desean almacenar una cantidad de datos que es demasiado grande para almacenarse en la propia cadena de bloques. IPFS crea direcciones de contenido únicas mediante el hash del contenido en sí. Cada contenido único tendrá una dirección diferente que apunta a su ubicación. DeBio agrega IPFS para almacenar datos biomédicos como genomas humanos encriptados y registros médicos electrónicos encriptados.
Ocean Protocol
Ocean Protocol está diseñado para el consumo de activos de datos de una manera segura y que preserva la privacidad. Lo hace con la función de procesamiento a datos y permite la monetización de datos sin tener que salir del dominio del propietario. El mercado de datos de código abierto de Ocean Protocol, llamado Ocean Market, se puede negociar; el equipo de DeBio Network utilizará Ocean para el resguardo de datos biomédicos.
Privacidad de Cómputos
Para resguardar los datos biomédicos, DeBio alojará datos biomédicos anónimos en su almacén de datos privado. Este proceso no involucra el IPFS mencionado anteriormente porque el almacén de datos estará completamente separado de IPFS. Los usuarios que quieran resguardar sus datos deberán descifrar y cargar sus datos biomédicos en su almacén de datos privado. Si bien la transferencia de datos biomédicos descifrados a un almacén de datos privado suena inquietante, DeBio implementará conceptos informáticos de privacidad dentro del almacén de datos para salvaguardar su privacidad.



Imagen tomada de  DeBio Whitepaper

Solo después del consentimiento del usuario se agregan los conjuntos de datos a través del proxy de procesamiento a datos de Ocean, y un tercero podrá crear análisis y procesar los datos mientras permanezcan en los dominios.

Incentivando a los usuarios a resguardar sus datos genómicos / biomédicos, y esperando que esto incentive aún más la investigación en el campo. Además, el almacén de datos de propiedad privada no recopilará información de identificación personal, por lo que no hay necesidad de preocuparse por el rastreo de sus muestras.

Pandu Sastrowardoyo, directora general de DeBio, afirmó que una de las razones por las que creó DeBio es para ayudar a que prospere la investigación genética mediante la creación de un mercado de datos genéticos completamente anónimo. “DeBio es un sistema económico completamente nuevo para la genómica, que permite la soberanía genética, asegura la participación de laboratorios más pequeños y potencia la investigación genética. Todo hecho sobre un modelo similar a DeFi que está completamente descentralizado ”, dijo Pandu.




	

	
	
		
			
				Prueba: ¿Dónde almacena DeBio los datos resguardados?
			
		

		
					

		
			
			
			
			Dentro de la cadena de bloques DeBio
		
			
			Dentro de los tokens de datos
		
			
			En un almacén de datos privado
		
			
			En IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Capas de arquitectura técnica
Nuestra arquitectura técnica consta de cuatro capas, la infraestructura blockchain principal, la capa de lógica comercial genérica y de transporte y, por último, la capa lógica comercial de nivel superior.



Arquitectura técnica propuesta de DeBio, imagen tomada del documento técnico de DeBio
Capa 1: La infraestructura Blockchain
La primera capa contendrá los servicios básicos. Los servicios principales se basan en Substrate, Octopus e IPFS. Substrate es el componente básico del servicio blockchain. Para guardar archivos grandes, DeBio utilizará IPFS y guardará la dirección del contenido dentro de Substrate. Finalmente, toda la cadena de aplicaciones se conectará con la cadena de relés Octopus.
Capa 2 y 3: la capa de transporte y lógica empresarial genérica
La segunda y tercera capas contienen el transporte y la lógica empresarial genérica. Estas capas son responsables de entregar datos directamente a los usuarios. Cada paleta contiene la lógica comercial base para las interacciones con la cadena de bloques y servirá como una capa de abstracción de la cuarta capa para comunicarse con los servicios de Substrate en la primera capa.
Capa 4: La capa de lógica empresarial de nivel superior
La cuarta capa consistiría en DeBio UI y Metamask. Toda la interacción entre los usuarios y la cadena de bloques se realizará desde la cuarta capa. Todas las consultas también se definirán desde el nivel superior y luego se procesarán en todas las capas mencionadas anteriormente. Para financiar cada transacción, los usuarios pueden usar Metamask para pagar con la moneda estable ERC20. En este caso, DeBio utilizará DAI como la moneda estable de elección.
El modelo de token


Imagen tomada de DeBio Whitepaper

El equipo de DeBio Network tiene la intención de lanzar seis tokens:

 	Recompensas de transacciones de Mainnet y token de validación ($DBIO)
 	El token de gobernanza ($GBIO)
 	El token de datos de genómica ($GENE, a través del protocolo Ocean)
 	El token de datos biomédicos ($MED, a través del protocolo Ocean)
 	El token de datos de registros médicos electrónicos ($EMR, a través del protocolo Ocean)

Moneda Mainnet (moneda estable, etc.)
La moneda de la red principal estará respaldada por una moneda estable. DeBio decidió usar una moneda estable porque debe usarse como un intercambio estable para transacciones y tarifas relacionadas con el trabajo que realizan los laboratorios correspondientes. DeBio utilizará $DAI como nuestro token estable.
Token de gobernanza ($GBIO)
Los tokens de gobernanza se utilizarán principalmente para la votación de los laboratorios registrados. La Red DeBio es una organización descentralizada, por lo que debe existir un esquema de gobierno para votar en el mercado DAOGenics. Alternativamente, el token de gobernanza también puede servir como método para la incorporación del laboratorio.
Los tokens de datos ($GENE, $MED y $EMR)
Estos tokens se utilizan como método de transacción en el mercado de datos. Al resguardar datos biomédicos en el mercado de Ocean, los consumidores serán recompensados con tokens de datos que se pueden convertir a $OCEAN.
Recompensas de validación y transacciones ($DBIO)
El token de validación se utiliza para incentivar a los propietarios de nodos a validar transacciones y proteger la dApp de usuarios no autorizados. Los incentivos previstos proporcionados para los validadores son recompensas LP y tokens de gobernanza.
Transacciones del consumidor en la red DeBio
$DAI es la moneda estable de mainnet utilizada para transacciones en la plataforma DeBio. Los consumidores pueden usar la moneda mainnet para pagar productos y derechos de servicio. Los productos que estarán disponibles en el mercado incluyen productos de pruebas genómicas, productos de pruebas biomédicas y un servicio soberano de almacenamiento de registros médicos electrónicos (EMR).



Imagen tomada de DeBio Whitepaper
Recompensas transaccionales
Cada transacción cometida por el consumidor será recompensada con un token de validación, más específicamente un token de $DBIO. El precio de un solo token de $DBIO lo determina el mercado de datos de DeBio Network que alberga los datos genómicos del consumidor disponibles para el resguardo.
Staking de datos en la red DeBio
Después de comprar un producto en el mercado, los consumidores pueden optar por resguardar sus resultados en Ocean Marketplace. Los datos acumulados por los consumidores se clasificarán como tokens de datos, llamados $GENE, $MED y $EMR para datos genómicos, datos biomédicos y registros médicos electrónicos (EMR), respectivamente. Los tokens de datos se mantendrán en la red DeBio y se agregarán al mercado de datos a través de Ocean Protocol como un token ERC20. Debido a que los datos genómicos, biomédicos o EMR en sí son demasiado grandes para guardarlos dentro de los tokens de datos ERC20, los tokens de datos servirán principalmente como un puntero / enlace a los datos correspondientes.

Los consumidores que resguardan sus tokens de datos tendrán un rol de "proveedor de datos" en el mercado de datos. Todas las transacciones en el mercado de datos de Ocean utilizarán tokens de $OCEAN. Por lo tanto, si la transacción es exitosa, el comprador intercambiará tokens $OCEAN por tokens de datos ($GENE o EMR o $ MED). Mientras que el "proveedor de datos" recibirá los siguientes tokens $OCEAN.



Imagen tomada de DeBio Whitepaper

Si el comprador de datos desea acceder a los datos vinculados en el token de datos, debe enviar el token de datos al proveedor de datos de antemano. Como resultado, el proveedor de datos tendrá tanto el token de $OCEAN como los tokens de datos, mientras que al comprador de datos se le enviarán los datos vinculados por el token de datos.



Imagen tomada de DeBio Whitepaper

Por el contrario, los tokens de datos ($GENE o $MED o $EMR) recibidos por la Fundación DAOGenics se convertirán en tokens de $OCEAN. Después de un cierto período, el token de $OCEAN recibido por DAOGenics Foundation se convertirá en un token de $DBIO a través de un contrato inteligente sin permiso.

Como resultado, DAOGenics Foundation siempre recomprará el token de $DBIO a través de un contrato inteligente sin permiso basado en el volumen de transacciones realizadas en el mercado de datos. Más transacciones en el mercado de datos aumentarán la demanda del token $DBIO.




	

	
	
		
			
				Prueba: ¿Qué gana cuando resguarda datos en el mercado de datos de la red DeBio?
			
		

		
					

		
			
			
			
			La moneda de mainnet ($SDAI)
		
			
			Tokens de gobernanza($GBIO)
		
			
			Tokens de recompensa de transacción ($DBIO)
		
			
			Ocean token ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusión
Son muchos los beneficios de realizar pruebas genéticas. Por primera vez en la historia de la humanidad, las personas han podido determinar su estilo de vida para perseguir la longevidad; la ventaja de tal conocimiento es asombrosa. Pero si bien las pruebas genéticas tienen sus maravillosos beneficios sin las regulaciones y estándares adecuados, también tienen sus deficiencias. Sin la garantía de tener sus datos genéticos privados y seguros, podría causar problemas en el futuro.

DeBio tiene como objetivo resolver el problema antes de que sea demasiado tarde. DeBio está construyendo una plataforma descentralizada para sus necesidades médicas personales, comenzando con la genética. Nuestro concepto permite la sinergia entre laboratorios de todas las escalas al tiempo que garantiza el anonimato y la soberanía del usuario en cada paso del flujo de trabajo de la ciencia de datos genómicos, desde la recolección de muestras, el almacenamiento de datos hasta la generación de informes.

Algunas personas podrían decir que nuestro ADN es lo más privado que tenemos, y nos lo tomamos muy en serio. Las pruebas genéticas basadas en el anonimato deben ser el enfoque número uno para todas las empresas.

El futuro está aquí, DeBio está creando soluciones para revolucionar la industria de la atención médica y las pruebas genéticas. ¿Estás listo para cambiar el mundo con nosotros?

Adaptado del artículo original en Medium.

 

 

### DeFi en NEAR Protocol

NEAR Protocol es una plataforma de contratos inteligentes que se centra en los desarrolladores y en la facilidad de uso para los usuarios. Proporciona una plataforma escalable para ejecutar aplicaciones. NEAR fue fundada en el verano de 2018 por Alex Skidanov e Illia Polosukhin. Hoy, en este artículo, analizaremos las aplicaciones DeFi en el protocolo NEAR.
El auge de DeFi
​​DeFi o Decentralized Finance (Finanzas Descentralizadas) son instrumentos financieros basados en la blockchain. Si bien los instrumentos financieros centralizados están plagados por la falta de interoperabilidad y la burocracia, las aplicaciones DeFi son como bloques de Lego que los usuarios pueden unir para crear nuevos instrumentos. Como resultado, el ecosistema DeFi se ha disparado de $7,40 mil millones el 22 de junio de 2020 a $97,7 mil millones el 7 de septiembre de 2021. ¡Eso es un aumento de 1220% en valor en poco más de un año!



Hasta ahora, el valor total bloqueado en DeFi es de alrededor de $83.86 mil millones.
El verdadero significado de DeFi
Hablar simplemente del valor total bloqueado no es suficiente para comprender el verdadero significado de DeFi. Es un elemento crucial en la construcción de la Web Abierta y ha sido el único responsable de la afluencia de talento que Ethereum ha experimentado durante los últimos dos años. Si lo piensas, esto tiene mucho sentido debido a la naturaleza revolucionaria y modular de DeFi. Las acciones que podrían llevar semanas en el mundo de las finanzas tradicionales ahora toman solo unos segundos.

Sin embargo, esta ecuación también tiene una otra cara. Debido al aumento de la demanda, DeFi ha sido responsable de provocar la congestión de la red y el aumento de los precios del gas. Como tal, la barrera de entrada para Ethereum se ha vuelto significativamente más alta para los desarrolladores y creadores novatos.

NEAR Protocol proporciona una alternativa viable, más rápida y más barata en comparación a Ethereum.
DeFi en NEAR Protocol


Repasemos algunos de los proyectos DeFi más prometedores en NEAR.
Rainbow Bridge


Rainbow Bridge existe entre NEAR y Ethereum. Todos los activos que se originan en Ethereum ahora son completamente utilizables en NEAR. Desde su lanzamiento, más de $1 millón en ETH, DAI y otros tokens han cruzado el puente. La infraestructura del puente se puede reutilizar fácilmente y garantizar conexiones entre NEAR y todas las cadenas compatibles con EVM, como Polygon, BSC, Avalanche, Optimism, Arbitrum, etc. El equipo está trabajando actualmente en ampliar esta infraestructura para admitir cadenas no EVM como Bitcoin, Cosmos, etc.

Aquí hay algunas cosas que necesita saber sobre Rainbow Bridge:

 	Los usuarios pueden incorporarse a Rainbow Bridge directamente a través de MetaMask.
 	Las transacciones en NEAR se confirman en menos de 2 segundos y cuestan menos de 1 centavo en tarifas de gas.

Así es como se ve una transacción NEAR <> Ethereum bridge:

 	Los activos que van de Ethereum a NEAR tardan unos 6 minutos (alrededor de 20 bloques).
 	Las transacciones de ERC-20 cuestan alrededor de $ 10 en promedio.
 	Enviar activos de NEAR a Ethereum toma un máximo de 16 horas (debido a los tiempos de finalización de Ethereum). Este proceso también cuesta alrededor de $ 60 debido a los costos del gas ETH.

El Rainbow Bridge es una innovación importante, ya que es un primer paso esencial en la hoja de ruta de interoperabilidad de NEAR. Además, dado que NEAR ofrece transacciones más rápidas y económicas, puede ser favorable para los usuarios de otras cadenas interactuar con los activos de Ethereum en NEAR en lugar de enviarlos directamente a Ethereum.
Ref Finance


Ref Finance fue la primera plataforma DeFi en NEAR. La primera versión de Ref tenía algunas similitudes con Uniswap V2, junto con soporte para más tipos de pool, tarifas configurables y es propiedad de la comunidad. Su objetivo principal es reunir los componentes centrales de DeFi como el intercambio descentralizado (DEX), el protocolo de préstamos, el emisor de activos sintéticos, etc.

Ref Finance tiene una tesorería de 35 millones de $REF, de los cuales el 10% se asigna a un fondo de desarrollo para próximos proyectos y el 25% para futuras actividades relacionadas con la comunidad, eventos y asociaciones.

Características de Ref Finance

 	El AMM DEX de Ref permite el comercio automatizado entre cualquier token nativo NEAR o token puenteado.
 	 Los proveedores de liquidez pueden ganar tokens $REF o NEP-141 apostando tokens LP.
 	Los usuarios pueden apostar tokens de $REF para ganar más $REF a lo largo del tiempo.

Ref es un proyecto comunitario y es mantenido por un DAO. La Ref DAO tiene dos roles: el consejo y la junta comunitaria.

 	Consejo: El Consejo crea propuestas y las vota. Una propuesta pasa solo si la mayoría del consejo la confirma. El Consejo se cambiará una vez que la DAO esté completamente activa.
 	Junta de la comunidad: La Junta de la comunidad también vota o rechaza una propuesta. En su mayoría, el consejo se someterá a la decisión de la junta comunitaria.

OIN Finance


OIN es una plataforma descentralizada de emisión de monedas estables que permite a los proyectos emitir su moneda estable de su propia marca. En lugar de tener que incluir en la lista blanca su garantía en otras plataformas, OIN lanzará una moneda estable con garantía NEAR para desbloquear liquidez sin vender sus tokens NEAR. Los casos de uso de OIN son: cambiar por otras monedas estables convencionales, agregar apalancamiento, cobertura, préstamos y una gran cantidad de servicios públicos específicos del ecosistema.

Actualmente, la principal línea de productos de OIN es OINDAO. Permite a los proyectos que se unen crear su propio grupo de garantías para acuñar sus propias monedas estables etiquetadas con su marca. OIN establece un proceso de validación rápido para cada transacción iniciada en la cadena de bloques a través del sistema de prueba de Merkle. Lo hacen colocando pequeños fragmentos de información que conducen a una "transacción raíz" en el libro mayor y lo utilizan para validar una base de datos de información más grande.

Algunas características interesantes de OIN son las siguientes:

 	Es fácil y rápido acuñar monedas estables una vez que el proyecto de listado decide los parámetros.
 	Todos los contratos inteligentes de OIN se han auditado exhaustivamente.
 	Soporte técnico para configurar parámetros de riesgo clave para los contratos inteligentes.
 	Soporte técnico para ayudarlo a intercambiar su moneda estable de marca con monedas estables convencionales en Curve y Balancer para desbloquear la liquidez de su activo.

Skyward Finance 


Skyward Finance es una plataforma de lanzamiento de código abierto y sin permiso que los proyectos pueden utilizar para lanzar sus tokens sin ningún tipo de liquidez. Skyward tiene potencialmente uno de los mejores mecanismos de descubrimiento de precios resistente a los ataques de sybil y de bot. La plataforma busca permitir el descubrimiento de precios y la distribución de tokens para proyectos que se basan en el protocolo NEAR. Para ello, utiliza subastas en tiempo real a las que puede acceder la comunidad en general de forma descentralizada. Estas subastas también serán resistentes a la manipulación de precios, la ejecución inicial y los ataques de sybil. Skyward Finance emitirá tokens a la comunidad, lo que les permitirá formar parte de la plataforma y obtener ingresos.
¿Cuáles son algunas de las ventajas de Skyward Finance?
Skyward Finance tiene varias ventajas, algunas de las cuales son las siguientes.

 	Los proyectos pueden lanzar sus tokens sin liquidez.
 	El mecanismo de descubrimiento de precios de Skyward Finance es resistente a los ataques de bot y sybil. Tampoco se puede manipular.
 	Los proyectos pueden recaudar fondos en cualquier token y también pueden lanzar múltiples ventas de tokens que comprenden diferentes tokens.
 	Debido a la inmutabilidad de Skyward Finance ante cualquier tipo de manipulación de precios, los proyectos y sus fundadores pueden maximizar su capital en función del valor de mercado.
 	Los proyectos no requieren el token $ SKYWARD para participar o crear una venta.
 	Skyward Finance es de código abierto y sin permiso, lo que significa que los contratos inteligentes en la plataforma son completamente independientes.
 	Debido a que Skyward Finance se ejecuta en NEAR, puede aprovechar la escalabilidad y las transacciones más económicas de NEAR.




	

	
	
		
			
				¿Cuál de las siguientes es una plataforma de emisión de monedas estables?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool es un protocolo de apuesta líquida que se basa en el protocolo NEAR. Las personas pueden apostar fácilmente sus tokens NEAR utilizando Meta Pool y sus estrategias de apuesta automática. A cambio, reciben tokens "Staked NEAR" que pueden utilizar en DeFi NEARverse. Los tokens también se pueden volver a intercambiar por los tokens NEAR originales en cualquier momento.

Meta Pool se ha convertido en una parte esencial del ecosistema DeFi de NEAR, ya que presenta el primer token de apuesta líquida de NEAR, el stNEAR. El token stNEAR puede acumular recompensas de participación y también representar posiciones de participación en NEAR. Meta Pool ofrece a los poseedores de tokens NEAR una plataforma que es fácil de usar y genera rendimientos mientras crea una red descentralizada. Meta Pool se ejecutará en un DAO en Sputnik V2, la plataforma nativa de NEAR para administrar Organizaciones Autónomas Descentralizadas.

Cuando los poseedores de tokens apuestan en Meta Pool, obtienen tokens de $ META en cada época. Cada época es de 12 horas. Estos se reciben además de las recompensas del Protocolo NEAR, que son del 10,2% APY.
Cheddar 


Cheddar está creando una red de fidelización para NEAR y su ecosistema de aplicaciones descentralizadas. Lo está logrando mediante el establecimiento de asociaciones estratégicas que promueven activamente el uso del Protocolo NEAR al recompensar a los usuarios. Se ha demostrado que las redes de fidelización motivan con éxito a los usuarios a realizar acciones beneficiosas para las empresas. A través de Cheddar, los tokens de la comunidad se pueden iniciar, lo que permite que las aplicaciones aumenten la lealtad del usuario y agreguen nuevas fuentes de ingresos mediante mecanismos agrícolas.

Cheddar es diferente de otras granjas de rendimiento ya que proporciona beneficios a largo plazo a los HODL-ers a través de powerUPs. También promueve el uso de aplicaciones cruzadas en NEARVerse, lo que permite a los usuarios cultivar Cheddar a través de la agricultura de rendimiento, los fondos de liquidez o las dApps.
¿Cómo beneficia el cheddar al protocolo NEAR?

 	Conectividad dApp: Cheddar crea un vínculo común entre las aplicaciones más allá de los tokens individuales, creando así un ecosistema leal para las dApps en NEAR.
 	Compromiso del usuario: Cheddar crea un compromiso del usuario a largo plazo a través de varios incentivos y fomenta la lealtad a través de asociaciones estratégicas.
 	Salto entre cadenas: Cheddar crea interconectividad entre cadenas y mantiene a los usuarios en NEAR activos y comprometidos, lo que garantiza que se conserve el valor total bloqueado.




	

	
	
		
			
				¿Cuál de los siguientes está creando un programa de fidelización en NEAR?
			
		

		
					

		
			
			
			
			Cheddar

		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Berry Club permite a los usuarios crear pixel art compartidos al mismo tiempo que cultivan recompensas de fichas. El Berry Club había comenzado como una prueba de concepto de DeFi, pero desde entonces se ha convertido en un proyecto comunitario extremadamente popular sobre el Protocolo NEAR. Berry Club hace un uso excelente de varias de las características de NEAR Protocol, como los pagos automáticos a los creadores de contratos inteligentes, que no se encuentran en ninguna otra cadena de bloques.

Gracias al diseño único de NEAR, Berry Club y Berry Farm pueden beneficiar tanto a los usuarios como a los creadores de contratos inteligentes, que se pagan en forma de recompensas de contratos inteligentes tanto a los poseedores de tokens como a los creadores. Estos beneficios surgen del mayor uso de la aplicación (Berry Club). Este tipo de distribución de recompensas no es posible en plataformas como Ethereum, al menos no en su implementación actual. Esta es otra razón por la que los usuarios y desarrolladores deberían experimentar con NEAR.




	

	
	
		
			
				El puente entre Ethereum y NEAR se llama:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
Una empresa de investigación y desarrollo que apunta a DeFi en el ecosistema NEAR.
Conclusión
NEAR Protocol ya tiene un ecosistema DeFi muy emocionante y solo crecerá más. Tal como están las cosas, NEAR proporciona una alternativa poderosa y eficiente a Ethereum.

### Qu'est-ce que le protocole NEAR ?

Résultat attendu : compréhension de base du fonctionnement de NEAR du point de vue de l'utilisateur final

NEAR est une plate-forme d'applications décentralisées qui s'exécutent sur le protocole Blockchain de NEAR. Cette blockchain qui traverse des centaines de machines à travers le monde, est organisée pour être sans autorisation, préformatée et suffisamment sécurisée pour créer une couche de données solide et décentralisée pour le nouveau Web.

La mission principale de NEAR est de présenter une plate-forme idéale pour exécuter des applications ayant accès à un ensemble de fonds, d'identités et de données partagés et sécurisés appartenant aux utilisateurs. Il combine des fonctionnalités telles que la résistance aux partitions du réseau, le traitement des données sans serveur et le stockage de données distribué sur un nouveau type de plate-forme.

Alors avant d'aller plus loin, apprenons un peu d'histoire et voyons comment les plateformes blockchain ont évolué au fil du temps.
L'évolution de la technologie Blockchain
Depuis que Satoshi Nakamoto a présenté la documentation Bitcoin en octobre 2008, le monde est en train de se  familiariser avec la technologie révolutionnaire Blockchain. Au cours de la dernière décennie, la blockchain est passée par trois étapes d'évolution.

Génération 1 : Bitcoin

Bitcoin est l'exemple parfait de la blockchain de première génération. Le but de cette blockchain est d'être simplement un système de paiement direct. Au départ la "monnaie d'Internet", le bitcoin est devenu l'un des actifs les plus demandés. Cependant, il y a un plus gros problème quand il s'agit du BTC. Il est impossible d'effectuer des transactions compliquées avec eux, qui ont plusieurs couches de métadonnées et de logia liées à elles-mêmes.

Génération 2 : Ethereum et plateformes de contrats intelligents

Ethereum a inauguré la deuxième génération de plateformes blockchain avec des contrats intelligents. Finalement, les développeurs pourront programmer des transactions sophistiquées grâce à ce contrat intelligent, et ils pourront créer des applications décentralisées (dApps). Grâce à ces dApps, les cas d'utilisation de la blockchain ont explosé.

Cependant, cet espace a traversé des peines croissantes. La cause principale est que ces blockchains souffrent de graves problèmes d'évolutivité. Par exemple, Bitcoin a une performance de 7 transactions par seconde, tandis que Ethereum n'en peut gérer que 25. Lorsqu’on compare cela à Paypal (115 tps) et Visa (1 700 tps), c'est assez épouvantable.

Pour être juste, Ethereum et Bitcoin ont récemment essayé de résoudre ce problème d'évolutivité avec diverses solutions de deuxième couche comme Lighting Network, raiden, le protocole plasma, etc. L'idée ici est de créer une couche supplémentaire au-dessus de la blockchain sous-jacente où le protocole principal peut déléguer des tâches répétitives et fastidieuses.

Cependant, il y a deux problèmes principaux avec cette approche. Principalement, cette solution de deuxième couche n'a pas été acceptée par les masses. Deuxièmement, cette solution de deuxième couche ruine l'architecture d'origine du protocole, ce qui pourrait avoir des implications à long terme.

C'est là qu'intervient la troisième génération.

Génération 3 : NEAR

Near est un exemple de blockchain de troisième génération qui vise à résoudre les problèmes d'évolutivité et permet également aux utilisateurs finaux et aux développeurs de profiter pleinement du potentiel des contrats intelligents dans la technologie blockchain. Plutôt que de s'appuyer sur une technologie de deuxième couche, NEAR se libère de l'idée que chaque nœud participant au réseau doit exécuter tout le code car cela crée essentiellement un embouteillement excessif et ralentit toutes les autres approches.

Pour résoudre ce problème, NEAR utilise une technique déjà assez répandue dans le monde des database (bases de données), le Sharding. S'il est exécuté correctement, il permet au réseau une capacité d'évoluer à mesure que le nombre de nœuds augmente, alors il n'y a pas de limite théorique à la capacité du réseau. La meilleure partie? Le sharding est une technique d'évolutivité de première couche.
Qu'est-ce que le Sharding ? (fragmentation)
Dans une base de données, vous devez parfois faire face à de grandes bases de données. Cela entrave considérablement le débit et les performances et rend l'ensemble du processus extrêmement inefficace. C'est là qu'intervient Sharding.

Le Sharding partitionne horizontalement votre base de données en tables plus petites et plus faciles à gérer.

Alors, pourquoi une cloison horizontale et pas une cloison verticale ?

Considérez ce tableau :



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Maintenant, si nous devions partitionner cette table verticalement :




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Regarde ça ?

En partitionnant la table devient deux tables complètement différentes.

Par opposition à cela, que se passe-t-il lorsque la table est partitionnée horizontalement :

Voyez-vous ce qui se passe? Lorsque vous partitionnez verticalement la table, elles finissent par devenir deux tables complètement différentes ensemble.

Cependant, si nous le partitionnons horizontalement :



A
B
A*B
A/B


3
3
9
1


4
4
16
1



Regarde ça?

Une partition horizontale convertit la base de données en tables plus petites dans la même base de données.

Ces bases de données plus petites sont appelées Shards (partitions)
Comment Sharding aide-t-il la blockchain ?
Comme nous l'avons vu jusqu'à présent, à mesure que de plus en plus de nœuds pénètrent dans l'écosystème Ethereum et Bitcoin, le processus total de consensus et de vérification prend de plus en plus de temps.

Maintenant, que fera le sharding pour aider cela?

Le Sharding va briser l'état global de la blockchain en Shards plus petits et plus gérables.

Que se passe-t-il lors de l'activation des shards?

 	L'état est divisé en éclats
 	Chaque compte est sur une shard et les comptes de cette shard n'échangent qu'avec des comptes sur la même shard.

En termes plus simples, imaginez ce scénario. Il existe un réseau hypothétique avec trois nœuds - A, B et C et ils doivent vérifier les données T. Les données T se divisent en trois shards T1, T2 et T3. Au lieu de tous ces nœuds travaillant sur T dans son ensemble, ils peuvent travailler individuellement sur un shard en même temps. Comme vous pouvez le voir, le temps que vous économisez est exponentiel.

Contrairement à d'autres approches de sharding, où les nœuds doivent s'exécuter sur un hardware de plus en plus complexe (en réduisant des chances pour plus de personnes de participer au réseau), la technique NEAR permet aux nœuds de rester suffisamment petits pour s'exécuter sur un seul réseau dans le cloud.
Pourquoi les blockchains évolutives comme NEAR sont-elles nécessaires ?
Astuce : ce n'est pas qu'une question de vitesse !

En ce qui concerne la blockchain de deuxième et troisième génération, ce qui détermine vraiment sa valeur innée est l'écosystème dapp qui en découle. A ce titre, la plupart de ces plateformes blockchain sont en perpétuelle compétition pour attirer le plus de développeurs possible.

Cependant, le problème avec les plates-formes d'aujourd'hui est qu'elles n'ont pas la sophistication nécessaire pour héberger des applications de haute qualité. Le problème ici est que nous avons des développeurs qui essaient de créer des jeux PS4 sur une plate-forme équivalente à Windows 98. Par conséquent, ils doivent être fortement impliqués dans les performances globales de leurs dApps.

En outre, il y a un autre facteur qui devrait être considéré ici. La vitesse est un facteur essentiel lorsqu'il s'agit de la convivialité de l'application. Après tout, pourquoi les utilisateurs devraient-ils utiliser une application qui n'est pas du tout utilisable ? Les développeurs exigent qu'un certain nombre d'utilisateurs utilisent continuellement leur application avant qu'elle n'atteigne des volumes critiques.

C'est pourquoi une plate-forme blockchain évolutive comme NEAR est importante pour l'adoption de la blockchain et des contrats intelligents.

NEAR permet aux développeurs de déployer simplement leurs applications sans trop réfléchir à la façon dont l'infrastructure qui l'entoure fonctionne ou évolue, ce qui ressemble davantage aux clouds modernes d'Amazon AWS ou GCP ou Azure qui gèrent presque toutes les applications sur le Web aujourd'hui.
Bref historique de NEAR
Near a commencé à l'été 2018 depuis qu'Alex Skidanov et Illia Polosukhin ont décidé de s'éloigner de leurs précédentes aventures entrepreneuriales. Si vous êtes curieux, vous pouvez en savoir plus à ce sujet ici (LIEN). Rapidement, alors que Misha abandonnait MemSQL, l'équipe est passée de plusieurs à 9 personnes sur une période de trois jours en août. L'équipe initiale était composée de 7 ingénieurs, Erik s'occupant des opérations commerciales et Sasha s'adressant au marché.

Aujourd'hui, le collectif NEAR est globalement réparti en équipes d'équipes, composées de nombreuses organisations individuelles et contributeurs, qui s'organisent pour donner vie à cette technologie. Ce n'est pas une entreprise ou quoi que ce soit de moins formel. Vous le considérez comme un groupe de personnes qui dirigent de grands projets open source.

L'un des collectifs du projet écrit le code et l'implémentation de référence pour le réseau  NEAR d' open source (code ouvert), un peu comme la construction des boosters d'une fusée sur la navette spatiale. Leur travail consiste à faire la recherche et le développement nécessaires pour aider la blockchain à entrer en orbite. Le code de cette chaîne est public, donc littéralement n'importe qui peut y contribuer ou l'exécuter.

Il est important de mentionner que les réseaux comme NEAR sont conçus pour être totalement décentralisés. Cela signifie qu'au final, ils fonctionnent entièrement seuls et ne peuvent en fait pas être censurés, fermés ou affectés par des tiers… Pas même l'équipe qui l'a initialement construit ! Ainsi, alors que les membres de ce collectif sont là pour tourner la roue et construire la mise en œuvre de base, ils deviennent rapidement non essentiels au fonctionnement du réseau une fois qu'il démarre. En fait, une fois qu'il est prêt à fonctionner, personne ne peut modifier et exécuter le code du protocole NEAR pour démarrer sa propre blockchain car tout est open source et toute modification devrait être acceptée démocratiquement par les validateurs indépendants qui l'exécutent.
Comment fonctionne la blockchain NEAR
Technologie réaffirmant la crypto-monnaie. La blockchain est une technologie qui peut stocker en toute sécurité les journaux de transactions sur un réseau peer-to-peer au lieu de les stocker dans un seul endroit. Des serveurs indépendants à travers le monde, appelés nœuds, constituent le réseau qui exploite la blockchain.

L'un des aspects les plus déterminants de la technologie blockchain est la décentralisation. Alors pourquoi la décentralisation est-elle si utile ? Regardons-le du point de vue des développeurs et des utilisateurs.

Développeurs : dans le monde décentralisé, les développeurs sont fréquemment à la merci des plateformes cloud ou même des gouvernements pour s'assurer qu'ils peuvent continuer à exécuter leurs applications. Dans le monde décentralisé, il n'y a pas d'intermédiaires dominants.

Utilisateur final : la transparence des applications décentralisées permet aux utilisateurs de voir le code backend et de savoir exactement comment les applications vont utiliser vos informations personnelles.

Qu'est-ce que l'algorithme NEAR Consensus ?

Les protocoles de consensus sont utilisés pour parvenir à des accords sur une valeur unique entre plusieurs participants d'un système. Si tous les participants d'un réseau collaborent conformément au protocole de consensus, de nouvelles valeurs peuvent être attachées à la couche et vérifiées par les nœuds. Cependant, en cas de litige, le réseau ne peut se concentrer que sur la sécurité ou la vivacité.

Le mécanisme de consensus mis en œuvre dans NEAR s'appelle Nightshade. Le Nightshade modélise le système comme une seule blockchain. La liste de toutes les transactions dans chaque bloc est divisée en pièces physiques, une pièce par shard. Toutes les pièces s'accumulent dans un bloc. Notez que ces morceaux ne peuvent être validés que par des nœuds qui maintiennent l'état du shard.

En parlant de validation, les validateurs sont un élément clé de NEAR. Ces validateurs sont chargés de maintenir le consensus dans le protocole. Les validateurs sont des nœuds spéciaux qui doivent maintenir leurs serveurs 100 % du temps tout en gardant leurs systèmes constamment à jour.

Voici quelques points à garder à l'esprit concernant les validateurs de réseau.

 	NEAR détermine ses validateurs de réseau à chaque nouvelle époque, en les choisissant en fonction de leur propre stake. (Staking : consiste à conserver des fonds dans un portefeuille de crypto-monnaies, pour soutenir la sécurité et les opérations d'un réseau de blockchain).
 	Les validateurs déjà choisis sont automatiquement réinscrits en empilant à nouveau leurs tokens plus les gains obtenus.
 	Les validateurs potentiels doivent avoir leur participation au-dessus d'un certain niveau dynamique.
 	Il existe deux méthodes qu'un validateur peut utiliser pour renforcer son stake. Achetez les tokens eux-mêmes ou prêtez-les par délégation de tokens.
 	La récompense que vous recevez est directement proportionnelle au stake. Plus vous avez de tokens, plus vous recevez de récompenses.

Le consensus est basé sur le consensus de chaîne plus lourde. Cela signifie qu'une fois qu'un producteur de bloc produit un bloc, il collecte les signatures des validateurs de nœuds. Le poids d'un bloc est alors le stake cumulée de tous les signataires dont les signatures sont incluses dans le bloc. Le poids de la chaîne est la somme des poids des blocs. De plus, le consensus utilise un appareil supplémentaire pour renforcer la sécurité de la chaîne.



	

	
	
		
			
				Express Quiz: The weight of a block is:
			
		

		
					

		
			
			
			
			The maximum stake of the signers whose signatures are included in the block
		
			
			The cumulative stake of all the signers whose signatures are included in the block
		
			
			The average stake of the entire network divided by the number of signers in the block
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Temps de l'exécution (runtime) de NEAR

La couche d'exécution est utilisée pour exécuter des contrats intelligents et d'autres actions créées par les utilisateurs et préserver l'état entre les exécutions. Il peut être décrit sous trois angles différents : aller pas à pas à travers divers scénarios, décrire les composants du temps d'exécution et décrire les fonctions que le temps d’exécution fait.
Qu'est-ce que le token NEAR ?
Le token NEAR est l'actif natif fondamental de l'écosystème NEAR et sa fonctionnalité est activée pour tous les comptes. Chaque token est un actif numérique unique similaire à Ether qui peut être utilisé pour :

 	Payez au système pour le traitement des transactions et le stockage des données.
 	Exécutez un nœud de validation dans le cadre du réseau en participant au processus de staking.
 	Aidez à déterminer comment les ressources du réseau sont allouées et où ira sa future orientation technique en participant aux processus de gouvernance.

Le Token NEAR permet la coordination économique de tous les participants qui exploitent le réseau et il permet de nouveaux comportements parmi les applications qui sont construites sur ce réseau.
Comment démarrer avec NEAR ?
Compte / Portefeuille

Avant de commencer avec NEAR, la première chose que vous devez faire est de créer un compte NEAR.

Regardez cette vidéo sur les comptes NEAR : 



Le portefeuille vous permet de passer des appels contractuels à la blockchain, de configurer votre nœud local et d'envoyer et de recevoir des fonds d'autres utilisateurs. Lorsque vous enregistrez votre identifiant de compte, vous devez fournir un nom unique. De plus, chaque portefeuille doit avoir un nom unique, chaque utilisateur peut configurer plusieurs portefeuilles.

Vous pouvez imaginer cela similaire aux comptes Facebook ou Google. Une fois que vous vous êtes inscrit à l'un de ces deux services, vous pouvez utiliser le même compte pour accéder à des services tiers. La différence entre l'ID d'un compte NEAR et le compte Google est que les données, stockées par rapport à un ID de compte, ne sont accessibles et gérables que par le propriétaire du portefeuille. De plus, toutes les informations sont stockées dans un réseau distribué de nœuds au lieu d'un seul serveur.

Créez votre compte Near dès maintenant : https://wallet.near.org/create

Des informations plus détaillées sur les comptes sur : https://learnnear.club/doc/videos/accounts-keys/
L'explorateur de NEAR
NEAR Explorer vous permet de visualiser les créations de blocs en temps réel ! Cet outil utile vous permet de rechercher des transactions et des comptes vous permettant de visualiser toutes les interactions entre les utilisateurs et les contrats intelligents.


Comment obtenir des tokens NEAR ?
Il y a 4 façons d'obtenir $NEAR

NEARs gratuits pour les utilisateurs d'Ethereum
Commencez par configurer un portefeuille avec des NEAR gratuits via le faucet pour les utilisateurs d'Ethereum : https://faucet.paras.id/
Gagnez-les
Vous pouvez gagner $NEAR en participant aux récompenses des développeurs, en guidant une communauté, qui aide les gens à construire sur NEAR, en gagnant un hackathhoon ou en participant activement à la communauté. Si vous avez la possibilité que d'autres personnes vous prêtent des tokens pour le staking ; Vous pouvez également gagner $ NEAR pour être un validateur.
Achetez-les
$NEAR est disponible sur plusieurs bourses majeures (voir ci-dessous), où vous pouvez vous inscrire et acheter des tokens en utilisant à la fois la monnaie fiduciaire et la monnaie crypto.
Des échanges qui ont listé $NEAR
Vous pouvez afficher les résumés des prix et des paires sur coinmarketcap et coingecko.
D'un ami
Vous n'avez pas besoin d'avoir un compte NEAR pour recevoir desTOKENS NEAR ! Le "NEAR Drop" est une approche qui permet à vos amis de pré-financer un nouveau compte et de vous envoyer un lien dynamique pour réclamer les Tokens.
Que puis-je faire avec les tokens NEAR ?
Transférer NEAR
Envoyez et recevez $ NEAR entre vos comptes et ceux de vos amis, vérifiez les transactions dans l'explorateur de blocs. Parce que les frais de transaction sont si bas, vous pouvez déplacer rapidement et facilement de petits montants de $NEAR pour payer avec eux.

Envoyez-les en cadeau sur http://redpacket.near.org/
Essayez un NEAR drop (Invitez un ami)
Envoyez à votre ami un NEAR drop s’il a besoin de créer un compte.

Utiliser les applications NEAR
Pour voir la liste croissante d'applications en cours de construction à NEAR, cliquez ici.
Commencez avec NFT - acheter / publier / échanger de l'art sur https://paras.id/
Jouez au BarryClub pour participer à une création artistique collective : https://berryclub.io/

Combien cela coûte-t-il d'utiliser NEAR (Gas) ?
Lorsque vous appelez la blockchain NEAR pour mettre à jour ou modifier des données, les personnes qui gèrent l'infrastructure de la blockchain encourent certains coûts. En fin de compte, certains ordinateurs quelque part traitent votre demande, et les validateurs exécutant ces ordinateurs dépensent des capitaux importants pour faire fonctionner ces ordinateurs.
Comme d'autres blockchains programmables, NEAR rémunère ces personnes en facturant des commissions sur les transactions, également appelées frais de gaz (Gas fees).

Si vous êtes familier avec les fournisseurs de services cloud web2 (Amazon Web Services, Google Cloud, etc.), une grande différence avec la blockchain est que ces utilisateurs sont facturés immédiatement lorsqu'ils appellent une application, au lieu que les développeurs soient confrontés au coût d'utilisation. toute cette infrastructure. Cela crée de nouvelles possibilités, telles que des applications qui ne risquent pas à long terme de disparaître à mesure que les fonds du développeur / de l'entreprise s'épuisent. Cependant, il présente également certaines bosses en ce qui concerne la convivialité. Pour aider à cela, NEAR offre également la possibilité aux développeurs de couvrir le coût du gaz pour les utilisateurs, afin de créer une expérience plus familière pour ceux qui viennent du Web2.

Lorsque vous pensez au gaz, gardez deux concepts à l'esprit

 	Unités de gaz : En interne, les frais de transaction ne sont pas calculés directement dans les tokens NEAR, mais passent par une phase d'« unités de gaz ». L'avantage des unités de gaz est qu'elles sont déterminantes - la même transaction coûtera toujours le même nombre d'unités de gaz.
 	Coût du gaz : les unités de gaz sont ensuite multipliées par le coût du gaz pour déterminer combien l'utilisateur doit être facturé. Ce prix est calculé automatiquement dans chaque bloc en fonction de la demande du réseau (si un bloc précédent est rempli plus de la moitié du prix monte, sinon il baisse, et il ne changera pas de plus de 1% à chaque bloc), et sa valeur minimum est configurée sur le réseau, actuellement 100 millions de yoctoNEAR.

A noter que le prix du gaz peut varier entre le réseau principal de NEAR et le réseau de test. Vérifiez le prix du gaz avant de vous fier aux valeurs ci-dessous.

Penser au gaz

NEAR a environ une seconde de temps de bloc, obtenu en limitant la quantité de gaz par bloc. Les unités de gaz ont été soigneusement calculées pour fonctionner avec des nombres faciles à penser.

10¹² unités de gaz, ou 1 TGas (TeragGas) ...

≈ 1 milliseconde de temps de « compte »

… Ce qui, à un prix du gaz minimum de 100 millions de yoctoNEAR équivaut à 0,1 milliNEAR de commission.

Ce 1 ms est une approximation utile et correspond à la façon dont les unités de gaz sont actuellement définies dans NEAR. Les unités de gaz encapsulent non seulement le temps de calcul/processeur, la bande passante/le temps de réseau et le temps de stockage/E/S. Grâce au mécanisme de gouvernance, les paramètres du système peuvent être affinés, en modifiant le mappage entre Tgas et les millisecondes à l'avenir, mais ce qui précède est toujours un bon point de départ pour réfléchir à ce que signifient les unités de gaz et d'où elles viennent.



	

	
	
		
			
				1 TeraGas or TGas is equal to:
			
		

		
					

		
			
			
			
			1 microsecond of compute time
		
			
			10 seconds of compute time
		
			
			1 millisecond of compute time
		
			
			1 nano second of compute time
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







Le coût des actions ordinaires
Pour vous donner un point de départ sur ce à quoi s'attendre en termes de coûts NEAR, le tableau ci-dessous répertorie certaines des actions les plus courantes et la quantité de TGas qu'elles nécessitent actuellement, ainsi que le montant de la commission, en milliNEAR, au prix minimum du gaz. c'est-à-dire 100 millions d'an.




Operation
TGas
frais (mN)
frais (Ⓝ)


Créer compte
0.42
0.042
4.2⨉10⁻⁵


envoyer Funds
0.45
0.045
4.5⨉10⁻⁵


Stake
0.50
0.050
5.0⨉10⁻⁵


ajouter Full Access Key
0.42
0.042
4.2⨉10⁻⁵


supprimer Key
0.41
0.041
4.1⨉10⁻⁵



Comment puis-je gagner avec NEAR ?
Staking vos NEAR
Un exemple de la façon dont la communauté des validateurs est prise en charge est la preuve de staking. Les validateurs gagnent des tokens NEAR en récompense pour l'exploitation des nœuds qui gèrent le réseau sous la forme d'un taux d'inflation statique de 5% par an, créant de nouveaux tokens pour les validateurs à chaque époque (~ 12 heures) en récompense.

Les validateurs doivent maintenir un montant minimum de staking pour maintenir leur rôle de validateur. Les détenteurs de token peuvent empiler leurs tokens avec un validateur particulier qui, selon eux, fonctionne bien pour le réseau et gagner une partie des tokens de récompense générés par le réseau. Cela incite les détenteurs de tokens à rester impliqués dans la communauté.

Le portefeuille NEAR dispose désormais d'une interface de staking intégrée directement dans l'application Web.

Pour staking :

 	Sélectionnez "Staking" dans la barre de navigation (ou menu déroulant sur mobile).
 	Cliquez sur le bouton "Sélectionner le validateur"
 	Choisissez un validateur
 	Confirmez votre choix et sélectionnez « Stake avec Validator »
 	Entrez le montant de NEAR que vous souhaitez staking et cliquez sur « Submit Stake »

Vous devrez confirmer deux transactions, une pour choisir le validateur et une autre pour déposer et miser avec ce validateur.

Pour UnStacking :

 	Dans le menu staking (/ staking), sélectionner le validateur courant
 	Cliquez sur "unStacking" et confirmez la transaction

Après un délai de 36 à 48 heures (4 époque), vous aurez la possibilité de retirer votre mise, de revenir sur la page du validateur et de cliquer sur « retirer ».



	

	
	
		
			
				New tokens are created as rewards after epoch which is approximately every:
			
		

		
					

		
			
			
			
			12 minutes
		
			
			12 seconds
		
			
			12 days
		
			
			12 hours
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Construire DeFi sur NEAR
L'écosystème DeFi (Finance Décentralisée) est en feu. Ethereum détient actuellement un réseau DeFi d'une valeur de plus de 100 milliards de dollars. En ce qui concerne ce NEAR, son écosystème DeFi est encore jeune et en pleine croissance.



Selon DeFiLlama, la valeur totale verrouillée (TVL) de l'écosystème NEAR est inférieure à 100 millions de dollars, Ref Finance étant le leader du marché. Le fait même que l'écosystème DeFi d'Ethereum soit 1000 fois supérieur à celui de NEAR montre que nous sommes très tôt en ce qui concerne NEAR DeFi. En fait, en 2021, le protocole NEAR a annoncé une initiative de financement de 800 millions de dollars. La majorité du fonds est destinée à développer le secteur DeFi du protocole.

Si vous souhaitez en savoir plus sur l'écosystème DeFi de NEAR, lisez ceci.
L'écosystème NFT en pleine croissance de NEAR
Un actif non fongible a une propriété ou des propriétés distinctes qui le distinguent des autres actifs. Les jetons non fongibles sont basés sur des actifs non fongibles et sont des actifs numériques uniques qui utilisent la technologie blockchain. Dernièrement, ce secteur a pris feu et a explosé en popularité.

Le protocole NEAR est la plate-forme idéale pour les NFT car il présente deux avantages majeurs par rapport à Ethereum :

 	NEAR est nettement plus rapide.
 	Ethereum a également des frais de gaz considérablement plus élevés.

Ces facteurs rendent NEAR idéal pour acheter et vendre des NFT. Lisez cet article pour en savoir plus sur les 3 meilleurs projets NFT sur NEAR.
Et maintenant ? Comment puis-je interagir avec NEAR ?
Eh bien, que se passe-t-il maintenant? Si vous avez lu jusqu'ici, vous voudrez probablement plonger encore plus profondément dans le protocole NEAR. Donc, la prochaine chose que vous devez faire est de consulter le NEAR whitepaper. Si vous débutez dans la blockchain et que vous souhaitez en savoir plus sur la technologie elle-même, vous devriez regarder cette vidéo déconstruisant l'écosystème de la blockchain.

Rejoignez le serveur Discord et consultez le forum NEAR.

 

### Tokennomic là gì? Hướng dẫn nhanh

Một trong những nguyên lý cốt lõi của mạng phi tập trung là tokenomic của mạng lưới. Để giúp dự án hiểu rõ hơn về ý nghĩa của token dự án, Learn Near Club đã giúp khởi chạy một tokenomics playground mới trên NEAR Testnet - LNC | TokenHub. Tuy nhiên, trước khi đi vào chi tiết, hãy tìm hiểu tokenomics nghĩa là gì.
Tokenomics là gì?
Token ban đầu chỉ là một thuật ngữ khác của “tiền điện tử” hoặc “tài sản điện tử”. Tuy nhiên, gần đây, chúng ta đã sử dụng thuật ngữ “token” để giải thích một tài sản tiền điện tử được phát hành trên blockchain. Thuật ngữ “tokenomics” là từ ghép của “token” và “economics” (kinh tế học), nó là một thuật ngữ được sử dụng để mô tả tính kinh tế của token.

Khi bạn muốn đánh giá tokenomics của một mạng lưới, bạn cần tự hỏi mình những câu hỏi sau:

 	Tổng cung của token là bao nhiêu và bao nhiêu trong số chúng được vào hệ thống cùng một lúc?
 	Có bao nhiêu token sẽ được tạo ra trong tương lai?
 	Làm thế nào để các token được phân phối giữa những người dùng?
 	Vai trò chính xác của token trong mạng là gì?
 	Mạng có cần token đó để hoạt động không?

Nhìn chung, mục đích là thiết lập một liên kết rõ ràng giữa nền tảng và tài sản.
Các phần tử được định nghĩa trong Tokenomics
Tokenomics có thể được phân biệt giữa kiểm soát nguồn cung và tính tiện ích. Hãy xem xét những yếu tố sau:
#1 Kiểm soát nguồn cung
Có bao nhiêu token trong giao thức thực sự sẽ được lưu hành. Bao nhiêu nguồn cung đang được kiểm soát bởi hợp đồng cơ sở? Về khía cạnh này, chúng ta phải hiểu một số thuật ngữ nhất định.

Premining - Ra mắt

Về cơ bản, có bao nhiêu token đang lưu thông trong hệ sinh thái tại thời điểm ra mắt. Thông thường, các token được khai thác định kỳ bởi những người dùng chuyên biệt được gọi là “thợ đào”. Tuy nhiên, các giao thức cụ thể thường cung cấp một % nhất định trong tổng nguồn cung của mình trong quá trình khởi chạy để phân phối token và cho phép truy cập thanh khoản. Tuy nhiên, xin lưu ý rằng việc phát hành trước một số lượng lớn token có thể dẫn đến những lo ngại về tính tập trung hóa.

Token Allocation - Phân bổ token

Các token được phân bổ cho đội ngũ của dự án như thế nào? Họ có tính toán sẽ có lượng lớn token dẫn đến các vấn đề tính tập trung hóa không? Bao nhiêu token được phân bổ vào kho bạc để phát triển giao thức trong tương lai?

Token Vesting - Phân bổ token

Hầu hết các dự án nhận được tài trợ từ VC hoặc các nhà đầu tư khác, những người được phân bổ token để đổi lại khoản đầu tư của mình. Thật không may và điều này lại thường xảy ra, các VC có xu hướng dump lượng token được phân bố của họ ngay lập tức để kiếm lợi nhuận nhanh chóng, điều này chắc chắn sẽ làm hỏng giao thức. Bạn có thể khóa lượng token cụ thể trong một khoảng thời gian cụ thể với việc sử dụng token vesting để ngăn chặn các đợt bán tháo lớn.

Token vesting rất quan trọng trong việc giúp cho các nhà đầu tư tự tin vì nó cho biết rằng nhóm và các nhà đầu tư đang nghiêm túc với dự án và không tìm kiếm lợi nhuận nhanh chóng. Vesting là một cách dễ dàng để giảm bớt sự thao túng thị trường và đảm bảo giá trị cho khoản đầu tư.

Token Burning - Đốt token

Một chiến thuật đơn giản khác mà nhiều dự án sử dụng để kiểm soát nguồn cung lưu thông là đốt token. Ý tưởng rất đơn giản - định kỳ loại bỏ vĩnh viễn một lượng token nhất định khỏi lưu thông. Hầu hết các dự án thực hiện điều này bằng cách gửi token đến một ví chết. Các dự án như Ethereum và Binance sử dụng tính năng ghi token để kiểm soát việc cung cấp token gốc của mình.
#2 Tính tiện ích của Token
Các vai trò khác nhau mà token của bạn có thể đảm nhận là gì? Chúng ta hãy xem nhanh một số vai trò khác nhau.

 	Token có thể được sử dụng làm tiện ích và là đơn vị thanh toán bên trong hoặc ngoài giao thức.
 	Token có thể được sử dụng để stake vào giao thức và tham gia vào quản trị.
 	Cần có token giao thức để truy cập các ứng dụng khác nhau (DeFi và NFT) trong hệ thống.

Thực hành với Tokenomics
ông cụ Tokenomics của Learn Near cho phép bạn vạch ra các thành phần khác nhau của token và tiến hành thí nghiệm với chúng trên mạng testnet.

Các phần này là:

 

 	Token Name - Tên token
 	Initial Release - Phát hành lần đầu
 	Symbol - Biểu tượng token
 	Treasury - Kho bạc của token
 	Initial Supply - Lượng cung ban đầu
 	Vesting Start Time - Thời gian bắt đầu trả token
 	Vesting Duration - Thời gian trả token
 	Decimal Points - Số thập phân của token
 	Vesting Interval - Số ngày vesting

Việc sử dụng các các thành phần này giúp bạn hiểu được khả năng kiểm soát nguồn cung của token. Bạn có muốn thử nghiệm với công cụ này không? Hãy truy cập LNC TokenHub

### Was ist das NEAR-Protokoll?

NEAR ist eine dezentralisierte Anwendungsplattform, die auf der NEAR-Protokoll-Blockchain läuft. Diese Blockchain, die auf Hunderten von Rechnern auf der ganzen Welt läuft, ist so organisiert, dass sie erlaubnisfrei, performant und sicher genug ist, um eine starke und dezentralisierte Datenschicht für das neue Web zu schaffen,

Die Hauptaufgabe von NEAR besteht darin, eine Plattform zu präsentieren, die sich ideal für die Ausführung von Anwendungen eignet, die Zugriff auf einen gemeinsamen - und sicheren - Pool von Geld, Identität und Daten haben, der ihren Nutzern gehört. Sie kombiniert die Eigenschaften von partitionsresistenten Netzwerken, serverlosen Berechnungen und verteilter Speicherung zu einer neuen Art von Plattform.

Bevor wir also weitergehen, sollten wir etwas über die Vorgeschichte erfahren und sehen, wie sich Blockchain-Plattformen im Laufe der Zeit entwickelt haben.
Die Evolution der Blockchain-Technologie
Seit Satoshi Nakamoto im Oktober 2008 das Bitcoin-Whitepaper veröffentlichte, hat sich die Welt mit der bahnbrechenden Blockchain-Technologie vertraut gemacht. In den letzten zehn Jahren hat die Blockchain drei Entwicklungsstufen durchlaufen.

Generation 1: Bitcoin

Bitcoin ist das perfekte Beispiel für eine Blockchain der ersten Generation. Der Zweck dieser Blockchain ist es, ein einfaches und unkompliziertes Zahlungssystem zu sein. Angefangen als "Währung des Internets", ist Bitcoin inzwischen zu einer der gefragtesten Anlageklassen geworden. Allerdings gibt es ein großes Problem, wenn es um BTC geht. Es ist nicht möglich, mit ihnen komplizierte Transaktionen durchzuführen, die mit mehreren Schichten von Metadaten und Logik verbunden sein können.

Generation 2: Ethereum und intelligente Vertragsplattformen

Ethereum leitete die zweite Generation von Blockchain-Plattformen mit intelligenten Verträgen (Smart Contract) ein. Endlich waren Entwickler in der Lage, mit diesen Smart Contracts anspruchsvolle Transaktionen zu programmieren und dezentrale Anwendungen (dApps) zu erstellen. Durch diese dApps gingen die Anwendungsfälle der Blockchain durch die Decke.

Allerdings hat dieser Bereich mit seinen Wachstumsschmerzen zu kämpfen. Das Hauptproblem ist, dass diese Blockchains unter schweren Skalierbarkeitsproblemen leiden. Zum Beispiel hat Bitcoin einen Durchsatz von 7 Transaktionen pro Sekunde, während Ethereum nur 25 bewältigen kann. Wenn man das mit PayPal (115 tps) und Visa (1.700 tps) vergleicht, ist das ziemlich miserabel.

Fairerweise muss man sagen, dass Ethereum und Bitcoin in letzter Zeit versucht haben, diese Skalierbarkeitsprobleme mit verschiedenen Lösungen auf der zweiten Ebene (Layer-2) zu beheben, wie Lightning Network, Raiden, Plasma Protocol usw. Die Idee dabei ist, eine zusätzliche Schicht über der zugrunde liegenden Blockchain zu schaffen, an die das Hauptprotokoll sich wiederholende und schwerfällige Aufgaben delegieren kann.

Bei diesem Ansatz gibt es jedoch zwei Probleme. Erstens haben diese Layer-2-Lösungen noch keine Akzeptanz in der breiten Masse gefunden. Zweitens ruinieren diese Layer-2-Lösungen die ursprüngliche Architektur des Protokolls, was langfristige Auswirkungen haben kann.

An dieser Stelle kommt die dritte Generation ins Spiel.

Generation 3: NEAR

NEAR ist ein Beispiel für eine Blockchain der dritten Generation, die darauf abzielt, die Skalierbarkeitsprobleme zu lösen und es sowohl den Endnutzern als auch den Entwicklern zu ermöglichen, das volle Potenzial von Smart Contracts und der Blockchain-Technologie zu nutzen. Anstatt sich auf Layer-2-Technologie zu verlassen, löst sich NEAR von der Idee, dass jeder einzelne Knoten, der am Netzwerk teilnimmt, den gesamten Code ausführen muss, da dies im Wesentlichen einen großen, verschwenderischen Engpass schafft und alle anderen Ansätze verlangsamt.

Um dieses Problem zu lösen, verwendet NEAR eine Technik, die in der Datenbankwelt bereits weit verbreitet ist - das Sharding. Wenn sie richtig ausgeführt wird, kann die Kapazität des Netzwerks mit der Anzahl der Knoten im Netzwerk skaliert werden, so dass es keine theoretische Grenze für die Kapazität des Netzwerks gibt. Und das Beste daran? Sharding ist eine Skalierungstechnik der Schicht 1 (Layer-1).
Was ist Sharding?
In einer Datenbank hat man es manchmal mit großen, sperrigen Daten zu tun. Dies beeinträchtigt die Leistung und den Durchsatz drastisch und macht den gesamten Prozess extrem ineffizient.  An dieser Stelle kommt das Sharding ins Spiel. 

Sharding führt eine horizontale Partitionierung Ihrer Datenbank durch und verwandelt sie in kleinere, besser zu verwaltende Tabellen.

Warum also eine horizontale und nicht eine vertikale Trennwand?

Betrachten Sie diese Tabelle:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Wenn wir nun diese Tabelle vertikal partitionieren würden:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Sehen Sie das?

Durch die Partitionierung wird die Tabelle zu zwei völlig unterschiedlichen Tabellen. 

Was im Gegensatz dazu passiert, wenn die Tabelle horizontal partitioniert wird:

Siehst du, was passiert? Wenn Sie eine Tabelle vertikal partitionieren, werden sie in der Regel zu zwei völlig unterschiedlichen Tabellen.

Wenn wir sie jedoch horizontal partitionieren:



A
B
A*B
A/B


3
3
9
1


4
4
16
1



Sehen Sie das?

Bei einer horizontalen Partitionierung wird die Datenbank in kleinere Tabellen derselben Datenbank unterteilt. Diese kleineren Datenbanken werden "Shards" genannt.
Wie hilft Sharding der Blockchain?
Wie wir bisher gesehen haben, nimmt der gesamte Konsens- und Verifizierungsprozess noch mehr Zeit in Anspruch, wenn mehr und mehr Knoten dem Ethereum- und Bitcoin-Ökosystem beitreten. Was wird Sharding in diesem Zusammenhang bewirken?

Durch Sharding wird der globale Zustand der Blockchain in kleinere, besser zu verwaltende Shards aufgeteilt.

Was passiert bei der Shard-Aktivierung?

 	Der Zustand wird in Shards aufgeteilt.
 	Jedes einzelne Konto befindet sich in einem Shard, und die Konten in diesem Shard können nur mit den anderen Konten im selben Shard Transaktionen durchführen.

Vereinfacht ausgedrückt, stellen Sie sich folgendes Szenario vor. Es gibt ein hypothetisches Netzwerk mit drei Knoten - A, B und C -, die Daten T überprüfen müssen. Die Daten T sind in drei Shards T1, T2 und T3 unterteilt. Anstatt dass alle diese Knoten an T als Ganzes arbeiten, können sie einzeln an einem Shard zur gleichen Zeit arbeiten. Wie Sie sehen können, ist die Zeitersparnis exponentiell.

Im Gegensatz zu vielen anderen Sharding-Ansätzen, bei denen die Knoten auf immer komplexer werdender Hardware betrieben werden müssen (was die Möglichkeit der Teilnahme weiterer Personen am Netzwerk einschränkt), ermöglicht die Technik von NEAR, dass die Knoten klein genug bleiben, um auf einfachen, in der Cloud gehosteten Instanzen zu laufen.
Warum sind skalierbare Blockchains wie NEAR notwendig?
Hinweis: Es geht nicht nur um Geschwindigkeit!

Wenn es um Blockchains der zweiten und dritten Generation geht, ist das Dapp-Ökosystem, das auf ihr gedeiht, entscheidend für ihren Wert. Daher befinden sich die meisten dieser Blockchain-Plattformen in einem ständigen Wettbewerb, um so viele Entwickler wie möglich anzuziehen. 

Das Problem mit den aktuellen Plattformen ist jedoch, dass sie nicht über die erforderliche Raffinesse verfügen, um qualitativ hochwertige Apps zu hosten. Das Problem ist, dass die Entwickler versuchen, PS4-Spiele auf einer Plattform zu entwickeln, die Windows 98 entspricht. Daher müssen sie bei der Gesamtfunktionalität ihrer dApps große Kompromisse eingehen.

Außerdem gibt es noch einen weiteren Faktor, der hier berücksichtigt werden sollte. Geschwindigkeit ist ein entscheidender Faktor, wenn es um die Benutzerfreundlichkeit einer Anwendung geht. Denn warum sollten die Nutzer eine Anwendung nutzen, wenn sie nicht benutzbar ist? Die Entwickler benötigen eine bestimmte Anzahl von Nutzern, die ihre Anwendungen kontinuierlich nutzen, bevor sie eine kritische Masse erreichen.

Aus diesem Grund ist eine skalierbare Blockchain-Plattform wie NEAR wichtig für die allgemeine Verbreitung von Blockchain und Smart Contracts.

NEAR ermöglicht es Entwicklern, ihre Anwendung einfach bereitzustellen, ohne sich allzu viele Gedanken darüber zu machen, wie die Infrastruktur um sie herum funktioniert oder skaliert, was eher den modernen Clouds wie Amazon AWS oder GCP oder Azure entspricht, die fast alle heutigen Webanwendungen betreiben.
Eine kurze Geschichte zu NEAR
NEAR wurde im Sommer 2018 gegründet, als Alex Skidanov und Illia Polosukhin beschlossen, sich von ihrem vorherigen unternehmerischen Abenteuer abzuwenden - wenn Sie neugierig sind, können Sie hier mehr darüber lesen. Sehr schnell, als Misha bei MemSQL aufhörte, wuchs das Team innerhalb von 3 Tagen im August von einigen auf 9 Personen an. Das ursprüngliche Team bestand aus 7 Ingenieuren, Erik, der sich um das operative Geschäft kümmerte, und Sasha, der sich um den Markt kümmerte.

Heute ist NEAR Collective eine weltweit verteilte Gruppe von Teams, die sich aus vielen einzelnen Organisationen und Mitwirkenden zusammensetzt, die sich selbst organisieren, um diese Technologie ins Leben zu rufen.  Es handelt sich nicht um ein Unternehmen oder etwas ähnlich Formelles. Stellen Sie es sich stattdessen wie die Gruppen von Menschen vor, die große Open-Source-Softwareprojekte betreiben.

Eines der Projekte des Kollektivs besteht darin, den ursprünglichen Code und die Referenzimplementierung für das quelloffene NEAR-Netz zu schreiben, ähnlich wie beim Bau der Raketentriebwerke für das Space Shuttle. Ihre Aufgabe ist es, die notwendige Forschungs- und Entwicklungsarbeit zu leisten, um die Blockchain in die Umlaufbahn zu bringen. Der Code für diese Kette ist quelloffen, so dass buchstäblich jeder dazu beitragen oder sie betreiben kann.

Es ist wichtig zu betonen, dass Netzwerke wie NEAR vollkommen dezentralisiert sind. Das bedeutet, dass sie letztlich völlig eigenständig funktionieren und nicht von Dritten zensiert, abgeschaltet oder anderweitig manipuliert werden können - nicht einmal von den Teams, die sie ursprünglich aufgebaut haben! Die Mitglieder dieses Kollektivs sind zwar dazu da, den Ball beim Aufbau der Referenzimplementierung ins Rollen zu bringen, werden aber schnell unwichtig für den Betrieb des Netzes, wenn es erst einmal in Betrieb ist.  Sobald es startklar ist, könnte jeder den Code des NEAR-Protokolls ändern und ausführen, um seine eigene Blockchain zu starten, da alles quelloffen ist und alle Änderungen von den unabhängigen Validierern, die es betreiben, demokratisch akzeptiert werden müssen.
Wie NEAR Blockchain funktioniert
Die Technologie, die Kryptowährungen zugrunde liegt. Blockchain ist eine Technologie, mit der Transaktionsdatensätze sicher in einem Peer-to-Peer-Netzwerk gespeichert werden können, anstatt sie an einem einzigen Ort aufzubewahren. Unabhängige Server auf der ganzen Welt, so genannte Knotenpunkte, bilden das Netzwerk, das die Blockchain betreibt.

Einer der wichtigsten Aspekte der Blockchain-Technologie ist die Dezentralisierung. Warum ist Dezentralisierung also nützlich? Betrachten wir sie aus der Perspektive von Entwicklern und Endnutzern.

 	Entwickler: In der zentralisierten Welt sind die Entwickler oft der Gnade von Cloud-Plattformen oder sogar der Regierung ausgeliefert, um sicherzustellen, dass sie die Anwendungen weiterhin ausführen können. In der dezentralen Welt gibt es keine herrschsüchtigen Vermittler.
 	Endnutzer: Die Transparenz dezentraler Anwendungen ermöglicht es den Nutzern, den Backend-Code einzusehen und genau zu wissen, wie die Anwendungen ihre persönlichen Daten verwenden werden.

Was ist der NEAR-Konsensalgorithmus?

Konsensprotokolle werden verwendet, um eine Einigung über einen einzigen Wert zwischen mehreren Teilnehmern in einem System zu erzielen. Wenn alle Netzwerkteilnehmer im Einklang mit dem Konsensprotokoll zusammenarbeiten, können neue Werte an das Hauptbuch angehängt und von den Knoten überprüft werden. Im Falle von Streitigkeiten kann sich das Netzwerk jedoch entweder auf die Sicherheit oder die Lebendigkeit konzentrieren.

Der in NEAR implementierte Konsensmechanismus wird Nightshade genannt. Nightshade modelliert das System als eine einzige Blockchain. Die Liste aller Transaktionen in jedem Block wird in physische Chunks aufgeteilt, ein Chunk pro Shard. Alle Chunks werden zu einem Block akkumuliert. Beachten Sie, dass Chunks nur von Knoten validiert werden können, die den Status dieses Shards verwalten.

Apropos Validierung: Eine Schlüsselkomponente von NEAR sind die Validierer. Diese Validatoren sind für die Aufrechterhaltung des Konsenses innerhalb des Protokolls verantwortlich. Validatoren sind spezialisierte Knoten, die ihre Server zu 100% der Zeit online halten und ihre Systeme ständig aktualisieren müssen. 

Hier sind einige Punkte, die Sie bei den Netzwerk-Validatoren beachten müssen.

 	NEAR bestimmt seine Netzwerk-Validatoren in jeder neuen Epoche und wählt sie auf der Grundlage ihres Einsatzes.
 	Die bereits gewählten Validatoren werden erneut registriert, indem sie automatisch ihre Token und die angesammelten Belohnungen erneut einsetzen.
 	Potenzielle Validierer müssen einen dynamisch festgelegten Wert überschreiten.
 	Es gibt zwei Methoden, mit denen ein Validator seinen Einsatz erhöhen kann - er kann die Token selbst kaufen oder über die Delegation von Einsätzen leihen.
 	Die Belohnung, die Sie erhalten, ist direkt proportional zu Ihrem Einsatz. Je höher Ihr Einsatz, desto mehr Belohnungen erhalten Sie.

Der Konsens basiert auf dem schwersten Kettenkonsens. Das heißt, sobald ein Blockproduzent einen Block veröffentlicht, sammelt er die Unterschriften der Validierungsknoten. Das Gewicht eines Blocks ist dann der kumulierte Einsatz aller Unterzeichner, deren Unterschriften in dem Block enthalten sind. Das Gewicht einer Kette ist die Summe der Blockgewichte. Zusätzlich verwendet der Konsens eine Finalitätsfunktion, die zusätzliche Bedingungen für eine höhere Kettensicherheit einführt.



	

	
	
		
			
				Das Gewicht eines Blocks ist:
			
		

		
					

		
			
			
			
			Der maximale Einsatz der Unterzeichner, deren Unterschriften in dem Block enthalten sind
		
			
			Der kumulative Einsatz aller Unterzeichner, deren Unterschriften in dem Block enthalten sind
		
			
			Der durchschnittliche Einsatz des gesamten Netzwerks geteilt durch die Anzahl der Unterzeichner des Blocks
		
			
			Keiner der oben genannten Punkte
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR-Laufzeit
Die Laufzeitschicht wird verwendet, um Smart Contracts und andere von den Nutzern erstellte Aktionen auszuführen und den Zustand zwischen den Ausführungen zu erhalten. Sie kann aus drei verschiedenen Blickwinkeln beschrieben werden: Schritt für Schritt durch verschiedene Szenarien gehen, die Komponenten der Laufzeit beschreiben und die Funktionen beschreiben, die die Laufzeit ausführt.

Was ist der NEAR-Token?
Der NEAR-Token ist der grundlegende native Vermögenswert des NEAR-Ökosystems und seine Funktionalität ist für alle Konten aktiviert.  Jeder Token ist ein einzigartiger digitaler Vermögenswert, ähnlich dem Ether, der verwendet werden kann, um:

 	Bezahlen Sie das System für die Verarbeitung von Transaktionen und die Speicherung von Daten.
 	Betreiben Sie einen Validierungsknoten als Teil des Netzwerks, indem Sie am Staking-Prozess teilnehmen.
 	Durch die Teilnahme an Governance-Prozessen mitbestimmen, wie Netzwerkressourcen zugewiesen werden und wohin die zukünftige technische Richtung gehen soll.

Der NEAR-Token ermöglicht die wirtschaftliche Koordinierung aller Teilnehmer, die das Netzwerk betreiben, sowie neue Verhaltensweisen bei den Anwendungen, die auf diesem Netzwerk aufgebaut sind.
Wie beginnt man mit NEAR?
Konto/Wallet
Bevor Sie mit NEAR beginnen, müssen Sie als Erstes ein NEAR-Konto einrichten.

Sehen Sie sich dieses Video über NEAR-Konten an:



Die Wallet ermöglicht es Ihnen, Vertragsaufrufe an die Blockchain zu tätigen, Ihren lokalen Knoten einzurichten und Geld von anderen Nutzern zu empfangen und sie zu senden. Wenn Sie Ihre Konto-ID registrieren, müssen Sie einen eindeutigen Namen angeben. Obwohl jede Wallet einen eindeutigen Namen haben muss, kann jeder Nutzer mehrere Wallets einrichten.

Sie können sich das so ähnlich vorstellen wie ein Facebook- oder Google-Konto. Sobald Sie sich bei einem der beiden Dienste registriert haben, können Sie sich mit demselben Konto bei Diensten Dritter anmelden. Der Unterschied zwischen NEAR-Konto-IDs und Google-Konten besteht darin, dass die unter einer Konto-ID gespeicherten Daten nur für den Besitzer der Geldbörse zugänglich und verwaltbar sind. Außerdem werden alle Informationen in einem verteilten Netzwerk von Knotenpunkten und nicht auf einem einzigen Server gespeichert.

Erstellen Sie jetzt kostenlos ein NEAR-Konto: https://wallet.near.org/create

Ausführlichere Informationen über Konten unter DOCS.NEAR
NEAR-Explorer
Mit dem NEAR Explorer können Sie Blockerstellungen in Echtzeit einsehen! Mit diesem nützlichen Tool können Sie nach Transaktionen und Konten suchen und alle Interaktionen zwischen Benutzern und Smart Contracts einsehen.


Wie bekomme ich NEAR Token?
Es gibt 4 Möglichkeiten, $NEAR zu erhalten

GRATIS NEAR für Ethereum-Benutzer
Beginnen Sie mit dem Einrichten einer Geldbörse mit ein paar kostenlosen NEAR über Faucet für Ethereum-Nutzer: https://faucet.paras.id

Verdienen Sie es
Sie können $NEAR verdienen, indem Sie an Entwicklungsprämien teilnehmen, indem Sie eine Community betreiben, die anderen hilft, NEAR zu entwickeln, indem Sie einen NEAR-Hackathon gewinnen oder anderweitig ein aktiver Teil der Community sind.  Wenn du in der Lage bist, andere Leute dazu zu bringen, dir Token für Einsätze zu leihen, kannst du auch $NEAR verdienen, indem du einen Validator betreibst.

Kaufen
$NEAR ist auf mehreren großen Börsen erhältlich (siehe unten), wo Sie sich anmelden und den Token entweder mit Fiat-Währung oder Kryptowährung kaufen können.
Börsen, die $NEAR listen
Sie können Übersichten über Preise und Paare auf coinmarketcap und coingecko sehen.
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

Von einem Freund
Sie müssen kein NEAR-Konto haben, um NEAR-Token zu erhalten!  Der "NEAR Drop"-Ansatz ermöglicht es Ihrem Freund, ein neues Konto im Voraus zu finanzieren und Ihnen einen Hot Link zu senden, um die Token zu erhalten.

Was kann ich mit den NEAR-Token tun?
NEAR übertragen
Senden Sie $NEAR zwischen Ihren Konten und denen eines Freundes hin und her und sehen Sie sich die Transaktionen im Block Explorer an. Da die Transaktionsgebühren sehr niedrig sind, können Sie schnell und einfach sehr kleine Beträge von $NEAR bewegen, um mit ihnen zu spielen.
Schicken Sie sie als Geschenk auf  http://redpacket.near.org/

Probieren Sie einen NEAR Drop aus (Laden Sie einen Freund ein)
Schicken Sie Ihrem Freund einen NEAR Drop, wenn er ein Konto erstellen muss.

NEAR Apps verwenden
Um die wachsende Liste der auf NEAR basierenden Apps zu sehen, klicken Sie hier.
Einfacher Start mit NFT - Kunst kaufen/veröffentlichen/handeln auf https://paras.id/
Spielen Sie im BerryClub, um an der kollektiven Kunstproduktion teilzunehmen: https://berryclub.io/

Wie hoch sind die Kosten für die Nutzung von NEAR (Gas)?
Wenn Sie die NEAR-Blockchain aufrufen, um Daten zu aktualisieren oder zu ändern, entstehen den Personen, die die Infrastruktur der Blockchain betreiben, einige Kosten. Am Ende des Tages verarbeiten einige Computer irgendwo Ihre Anfrage, und die Validierer, die diese Computer betreiben, wenden erhebliche Mittel auf, um diese Computer am Laufen zu halten.

Wie andere programmierbare Blockchains auch, entschädigt NEAR diese Leute durch Transaktionsgebühren, auch Gasgebühren genannt.

Wenn Sie mit den Anbietern von Web2-Cloud-Diensten (Amazon Web Services, Google Cloud usw.) vertraut sind, besteht ein großer Unterschied zu Blockchains darin, dass den Nutzern die Kosten sofort in Rechnung gestellt werden, wenn sie eine App aufrufen, und nicht die Entwickler die Kosten für die Nutzung der gesamten Infrastruktur tragen müssen. Dies schafft neue Möglichkeiten, wie z. B. Apps, bei denen kein langfristiges Risiko besteht, dass sie verschwinden, weil den Entwicklern/Unternehmen das Geld ausgeht. Allerdings bringt dies auch einige Probleme bei der Benutzerfreundlichkeit mit sich. Um hier Abhilfe zu schaffen, bietet NEAR den Entwicklern die Möglichkeit, die Gas Kosten für die Nutzer zu übernehmen, um denjenigen, die von web2 kommen, ein vertrauteres Erlebnis zu bieten.
Wenn Sie über Gas nachdenken, sollten Sie zwei Konzepte im Hinterkopf behalten:


 	

 	Gaseinheiten: Intern werden die Transaktionsgebühren nicht direkt in NEAR-Token berechnet, sondern durchlaufen eine Zwischenphase von "Gaseinheiten". Der Vorteil von Gaseinheiten ist, dass sie deterministisch sind - die gleiche Transaktion wird immer die gleiche Anzahl von Gaseinheiten kosten.
 	Gaspreis: Die Gaseinheiten werden dann mit einem Gaspreis multipliziert, um den Preis zu ermitteln, der den Nutzern in Rechnung gestellt wird. Dieser Preis wird automatisch in jedem Block neu berechnet, abhängig von der Netznachfrage (wenn der vorherige Block mehr als halb voll ist, steigt der Preis, andernfalls sinkt er, und er ändert sich nicht um mehr als 1 % pro Block), und erreicht seinen Tiefpunkt bei einem Preis, der vom Netz konfiguriert wird, derzeit 100 Millionen yoctoNEAR.



Beachten Sie, dass der Gaspreis zwischen dem Hauptnetz und dem Testnetz von NEAR variieren kann. Prüfen Sie den Gaspreis, bevor Sie sich auf die unten stehenden Zahlen verlassen.
Denken in Gas
NEAR hat eine Blockzeit von mehr oder weniger einer Sekunde, was durch die Begrenzung der Gasmenge pro Block erreicht wird. Die Gaseinheiten wurden sorgfältig berechnet, um einige einfach zu denkende Zahlen zu erhalten:

10¹² Gaseinheiten, oder 1 TGas (TeraGas)...

≈ 1 Millisekunde "Rechen"-Zeit

...was bei einem Mindestgaspreis von 100 Millionen YoctoNEAR einer Ladung von 0,1 MilliNEAR entspricht

Diese 1 ms ist ein grober, aber nützlicher Näherungswert und stellt das derzeitige Ziel für die Festlegung der Gaseinheiten in NEAR dar. Gaseinheiten umfassen nicht nur die Rechen-/CPU-Zeit, sondern auch die Bandbreiten-/Netzwerkzeit und die Speicher-/IO-Zeit. Über einen Governance-Mechanismus können Systemparameter angepasst werden, um die Zuordnung zwischen TGas und Millisekunden in der Zukunft zu ändern, aber die obigen Angaben sind immer noch ein guter Ausgangspunkt, um darüber nachzudenken, was Gaseinheiten bedeuten und woher sie kommen.




	

	
	
		
			
				1 TeraGas oder TGas ist gleich:
			
		

		
					

		
			
			
			
			1 Mikrosekunde Berechnungszeit
		
			
			10 Sekunden Berechnungszeit
		
			
			1 Millisekunde Berechnungszeit
		
			
			1 Nanosekunde an Rechenzeit
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Die Kosten für gängige Aktionen
Um Ihnen einen Anhaltspunkt für die zu erwartenden Kosten auf NEAR zu geben, sind in der nachstehenden Tabelle einige gängige Aktionen aufgeführt und wie viel TGas sie derzeit erfordern und wie hoch die Gebühr in MilliNEAR bei einem Mindestgaspreis von 100 Millionen yN wäre.

 



Handlung
TGas
fee (mN)
fee (Ⓝ)


Konto erstellen
0.42
0.042
4.2⨉10⁻⁵


Geld senden
0.45
0.045
4.5⨉10⁻⁵


Staken
0.50
0.050
5.0⨉10⁻⁵


Vollzugriffsschlüssel hinzufügen
0.42
0.042
4.2⨉10⁻⁵


Key Löschen
0.41
0.041
4.1⨉10⁻⁵



Wie kann ich mit NEAR verdienen?
Staken Sie Ihre NEAR Token
Der Schlüssel zum Proof-of-Stake-Modell ist die Art und Weise, wie die Validatoren von der Community durch Staking unterstützt werden. Validatoren verdienen NEAR-Token als Belohnung für den Betrieb der Knoten, die das Netzwerk betreiben, in Form einer statischen Inflationsrate von 5% pro Jahr, wobei jede Epoche (~12 Stunden) neue Token für Validatoren als Belohnung geschaffen werden.

Validatoren müssen einen Mindestbetrag an Stake halten, um ihren Validator-Sitz zu behalten. Token-Inhaber können bei einem bestimmten Validator, von dem sie glauben, dass er eine gute Leistung für das Netzwerk erbringt, einen Einsatz leisten und einen Teil der vom Netzwerk generierten Token-Belohnungen verdienen. Dies ist ein Anreiz für Token-Inhaber, sich weiterhin in der Community zu engagieren!

Die NEAR Wallet hat jetzt eine Benutzeroberfläche für den Einsatz von Token, die direkt in die Web-App integriert ist.

Wie man staked:

 	Wählen Sie "Staking" aus der Navigationsleiste (oder Dropdown auf dem Handy)
 	Klicken Sie auf die Schaltfläche "Validator auswählen".
 	Wählen Sie einen Validator
 	Bestätigen Sie Ihre Wahl und wählen Sie "Einsätze mit Validator".
 	Geben Sie den Betrag von NEAR ein, den Sie setzen möchten, und klicken Sie auf "Einsatz senden".

Sie müssen zwei Transaktionen bestätigen, eine zur Auswahl des Validators und eine weitere zur Einzahlung und zum Einsatz mit dem Validator.

Wie man unstaked

 	Wählen Sie auf dem Dashboard für Einsätze (/staking) Ihren aktuellen Validator
 	Klicken Sie auf "Unstake" und bestätigen Sie die Transaktion
 	Nach 36 bis 48 Stunden (4 volle Epochen) können Sie Ihren Einsatz abheben. Kehren Sie dazu zur Validator-Seite zurück und klicken Sie auf "Withdraw".




	

	
	
		
			
				Neue Token werden als Belohnungen nach jeder Epoche erstellt, die ungefähr jede ist:
			
		

		
					

		
			
			
			
			12 Minuten
		
			
			12 Sekunden
		
			
			12 Tage
		
			
			12 Stunden
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






DeFi auf NEAR aufbauen
Das DeFi (Decentralized Finance) Ökosystem steht in Flammen. Ethereum besitzt derzeit ein DeFi-Netzwerk im Wert von mehr als 100 Milliarden Dollar. Wenn es um NEAR geht, ist das DeFi-Ökosystem noch jung und wächst. 



Laut DeFiLlama beträgt der Total Value Locked (TVL) des NEAR-Ökosystems weniger als 100 Millionen Dollar, wobei Ref Finance der Marktführer ist. Allein die Tatsache, dass das Ethereum-DeFi-Ökosystem das 1000-fache des NEAR-Ökosystems ausmacht, zeigt, dass wir in Bezug auf NEAR DeFi noch sehr früh dran sind. Tatsächlich hat das NEAR-Protokoll für 2021 eine Finanzierungsinitiative in Höhe von 800 Millionen Dollar angekündigt. Der Großteil des Fonds ist für das Wachstum des DeFi-Sektors des Protokolls vorgesehen.

Wenn Sie mehr über das DeFi-Ökosystem von NEAR erfahren möchten, lesen Sie dies.
Das wachsende NFT-Ökosystem von NEAR
Non-fungible Vermögenswerte haben eine bestimmte Eigenschaft oder Eigenschaften, die ihn von anderen Vermögenswerten unterscheiden. Nicht-fungible Token basieren auf non-fungible Vermögenswerten und sind einzigartige digitale Vermögenswerte, die die Blockchain-Technologie nutzen. In letzter Zeit hat dieser Sektor Feuer gefangen und ist in seiner Popularität explodiert.

Das NEAR-Protokoll ist die perfekte Plattform für NFTs, da es zwei wesentliche Vorteile gegenüber Ethereum aufweist:

 	NEAR ist deutlich schneller.
 	Ethereum hat außerdem wesentlich höhere Gasgebühren.

Diese Faktoren machen NEAR ideal für den Kauf und Verkauf von NFTs. Lesen Sie diesen Artikel, um mehr über die 3 wichtigsten NFT-Projekte auf NEAR zu erfahren.
Und was nun? Wie kann ich mit NEAR interagieren?
Wie geht es nun weiter? Wenn Sie bis hierher gelesen haben, möchten Sie wahrscheinlich tiefer in das NEAR-Protokoll eintauchen. Als Nächstes sollten Sie sich also das NEAR-Whitepaper ansehen. Wenn Sie neu in der Blockchain sind und mehr über die Technologie selbst erfahren möchten, können Sie sich dieses Video über die Dekonstruktion des Blockchain-Ökosystems ansehen.

Treten Sie dem NEAR Discord Server bei und besuchen Sie das NEAR Forum

 

### NEAR Revisión de contrato en vivo | Parte 3: Whitelist y Staking Pool Factory

Introducción
Hola a todos. Hoy vamos a revisar 2 contratos en lugar de 1. Incluiremos contratos que involucran llamadas de contratos cruzados y hablaremos sobre promesas y cómo funcionan en NEAR. Si deseas obtener más información sobre cómo funciona la composición, esta es una buena sesión para leer. El primer contrato que vamos a ver se llama contrato de lista blanca y se usa en la red principal para incluir grupos de participación en la lista blanca. Esto es importante porque la distribución de tokens se realiza a través de contratos inteligentes. Usamos contratos de bloqueo que eventualmente revisaremos en esta serie, pero la forma en que funciona es que el bloqueo es un contrato independiente que contiene tokens que se supone que se liberarán durante un período de tiempo. Digamos que los tokens se lanzan durante 2 años y se asignan linealmente a cada bloque. Lo que queríamos hacer es dar la posibilidad de hacer staking (Delegarlos en un grupo de Participación) con estos tokens, incluidos los tokens que aún no se han lanzado. Esto significa que debería poder delegar todos los tokens que ha bloqueado durante 2 años, por ejemplo, y comenzar a ganar recompensas con ellos. Esto se hace en un contrato inteligente, y un contrato de bloqueo esencialmente llama al contrato del grupo de participación que revisamos antes y transfiere tokens de un contrato a otro. Los tokens del contrato de bloqueo salen de la cuenta y van a la cuenta del grupo de participación. Si un grupo de participación no brinda las garantías que se requieren, como la capacidad de devolver estos tokens, significa que habrá problemas. Digamos que yo construyo un grupo de participación personalizado que me permite no solo apostar tokens, sino también retirarlos a cualquier cuenta. Este tipo de operación te permitirá obtener activos líquidos antes de que finalice el período de liberación. Entonces podrás retirarte, y este no es el comportamiento deseado.

Es por eso que introdujimos la lista blanca donde las implementaciones personalizadas de los grupos de participación que están aprobadas por la Fundación NEAR pueden usarse mediante contratos de bloqueo. Al mismo tiempo, queríamos dar la posibilidad de crear nuevos grupos de participación que ya estén aprobados por cualquier persona sin pasar por la aprobación de la Fundación NEAR. Esto permite que cualquiera pueda crear un nuevo grupo de participación a través de una fábrica de grupos de participación. La fábrica de grupos de participación es el segundo contrato que revisaremos hoy. La forma en que funciona es cuando un contrato de bloqueo quiere delegar, antes de que puedan transferir fondos a este contrato, primero deben seleccionar un grupo de participación. Cuando selecciona el grupo de participación, el bloqueo emite una transacción para verificar si una identificación de cuenta determinada está en la lista blanca en un contrato de lista blanca, y si devuelve verdadero, lo que significa que la cuenta está en la lista blanca, entonces el contrato de bloqueo puede continuar con la delegación. Permite que el bloqueo se transfiera realmente a este contrato. Significa que el contrato del grupo de participación tiene algunas garantías y API que el contrato local espera, y no bloqueará los tokens del propietario ni robará tokens del contrato de bloqueo. Esto también fue importante para los programas de inversión de los empleados de NEAR. Estaba en un cronograma de inversión de cuatro años, y eso permite que la fundación emita una transacción específica para el bloqueo de esa persona con el fin de retirar todo del fondo de participación y devolver el monto invertido a la fundación NEAR en caso de que un empleado se vaya del trabajo o fuera despedido. Ese es el trasfondo de los contratos de bloqueos y de lista blanca.

El repositorio original de estos contratos se puede encontrar en el Github de NEAR. Aquí está el video original en el que se basa esta guía:


Contrato de lista blanca
Estructura principal
Veamos el contrato de lista blanca. En realidad, es un contrato bastante simple, y realmente no tiene mucha lógica, ya sabemos la mayoría de las cosas.



Utiliza una API de NEAR que se llama LookupSet. Es similar a un conjunto desordenado. Es una colección persistente, pero no tiene iteradores, por lo que no puedes iterar sobre las claves de los elementos del conjunto. Solo puedes verificar si un elemento dado está presente o no, y puedes agregarlo al conjunto. No puedes verificar qué elementos están presentes en este conjunto. Al hacer esto se mejora la eficiencia del almacenamiento y reduce el acceso de múltiples lecturas a unas pocas lecturas. El contrato contiene algunos campos. El primero es foundation_account_id, este es la identificación de la cuenta que controla la lista blanca significa que esta cuenta puede incluir en la lista blanca los grupos de participación por 1, y también puede incluir en la lista blanca las fábricas de grupos de participación. La fábrica es un contrato que puede crear una nueva instancia de grupo de participación. La forma en que funciona es que cuando emite una transacción hacia la fábrica de participación que está incluida en la lista blanca por este contrato crea una nueva cuenta como una subcuenta de la fábrica. En nuestro caso, en la red principal se llama poolv1.near, que es la fábrica de grupos de participación que usamos. Crea un contrato, por ejemplo, bisontrails.poolv1.near, en el que implementa el código del grupo de participación en la lista blanca que esta fábrica puede producir. Entraremos en la fábrica del grupo de participación más tarde, pero al mismo tiempo también puede incluir en la lista blanca este grupo de participación determinado. Así es como funciona. La inicialización del contrato solo toma un argumento foundation_account_id. Una cuenta de fundación tiene permisos más altos en este contrato.


Getters
Hay un montón de getters (Captadores).



Puedes verificar si una determinada entrada de participación está en la lista blanca. Así es como un contrato de bloqueo verifica si el grupo está en la lista blanca. Básicamente, solo verifica si un elemento está presente en un conjunto. La segunda forma en que también puede verificar es si la fábrica está en la lista blanca, pero esto no es realmente necesario y nadie lo llama.
Agregar método de grupo de participación


Este es un método que puede ser llamado tanto por una fábrica como por la fundación. Lo que hacemos aquí es verificar que este método de staking agregue un nuevo staking_pool_account_id a una lista blanca. Verifica si la identificación de la cuenta es válida, entonces, verificamos si se trata de una fábrica. Comprobamos en un conjunto que el llamador de este método está presente en la lista blanca de las fábricas. Si es llamado por la fábrica del grupo de participación, entonces está bien. De lo contrario, tiene que ser una identificación de cuenta de la fundación; de lo contrario, el contrato fallará y este método entrará en pánico. Si pasamos la verificación de permisos, simplemente agregamos este grupo de participación a la lista blanca. En este momento solo tenemos una implementación para el grupo de participación, pero en teoría podemos modificar esta implementación cuando introducimos slashing (Penalización) , por ejemplo, y un grupo de participación debe tener el permiso necesario, necesita mantener un saldo mínimo. Hay algún otro cambio en el que necesitamos modificar un contrato validado durante el período de inversión de todos es de 4 años. Pueden suceder muchas cosas en la red y necesitamos tener la capacidad de cambiar potencialmente los grupos de participación. Si la lógica del grupo de staking cambia, por ejemplo. Permite la creación de una nueva fábrica que sea una mejor versión o admita algo que antes no se admitía. No permite cambiar una tarifa de recompensa al instante, sino que solo permite cambiar después de un período de espera de 7 días, o alguna otra idea para una modificación será un factor diferente.



A continuación, solo la fundación puede llamar a remove_staking_pool, por lo que solo la fundación puede eliminar un grupo de participación.

Además, add_factory solo puede ser llamado por la fundación. Es básico, solo se agrega a una lista blanca de las cuentas de fábrica.



Finalmente, remove_factory solo puede ser llamado por la fundación y elimina el factory_account_id. Digamos que la primera fábrica caduca, luego la fundación básicamente puede eliminar la fábrica de la lista blanca, así como también eliminar todos los grupos anteriores de la lista blanca. Ahora, no podrá seleccionar una de las encuestas de participación anteriores de un contrato de bloqueo, y finalmente hay una verificación de que esto es llamado por la fundación, lo cual es una comparación. Este es un contrato muy simple, y solo opera en conjuntos internos y el único método verdadero que es visible desde el exterior es is_whitelisted. Es bastante simple, es solo un grupo de setters y getters.
Inmutabilidad de los contratos inteligentes
La forma en que generalmente se comportan los contratos inteligentes, lo cual es cierto en Ethereum y en otras plataformas, es que son inmutables en sí mismos. En Ethereum, el interior de cada contrato es inmutable, pero usan un contrato proxy que les permite actualizar el punto final para ciertos contratos que son muy críticos para los tokens. En este caso, nuestros contratos principales son en esencia completamente inmutables, y pensamos en ellos como si los fuéramos a implementar una vez y probablemente no podamos cambiarlos, porque de lo contrario tendrá que hacer una bifurcación dura y convencer a todos los validadores para hacer algún tipo de migración de código. Es importante, porque el control sobre ellos debe hacerse a nivel de contrato en lugar de algunas entidades centralizadas. Por ejemplo, si bien la fundación aún mantiene un gran control sobre los grupos de participación al tener la capacidad de eliminar los grupos de participación aquí, no tiene el control para incluir en la lista negra a una entidad en particular en el mundo real para que no implemente un grupo de participación. Todavía pueden crear un grupo de participación con el mayor anonimato posible y crear un grupo de participación sin pedir permiso para convertirse en un validador en la red principal. Algunas cosas provienen de la descentralización, otras provienen de la limitación del control. Si bien se supone que la base debe respaldar la red, es posible que, en algunos escenarios, la base se vea obligada a hacer algo malo por la red. Digamos que el gobierno entra y trata de forzarlos. Si tienen menos capacidad para hacer esto, entonces hay una mayor seguridad en la red. Cuando diseñamos un contrato, pensamos: "¿Cuál es la cantidad de valor en este contrato?" o “¿Cuál es la capacidad de este contrato para influir en la red en general?”. Si es un valor pequeño, entonces está bien mantener la credibilidad mientras la comunidad confíe, si es un valor grande, entonces no está bien. Ya vamos a llegar al contrato de bloqueo, y por la forma en que está diseñado, puedes ver cómo, por ejemplo, la adquisición de derechos se diseñó para, por un lado, permitir que la fundación retire los fondos restantes, pero al mismo tiempo evitar que la fundación retire los fondos adquiridos. Es una forma legal de hacer las cosas, excepto que está escrito en el código. La lista blanca es un contrato muy crítico, porque antes de que se bloqueen los fondos, la mayoría de los fondos controlan la red a través de contratos locales en grupos de participación a través de esta lista blanca en particular, por lo que era importante diseñarlo de tal manera que mantuviera la descentralización y la seguridad de la red sin ceder el control a la fundación. Digamos que algo sucedió y la fundación comenzó a actuar maliciosamente. Digamos que pudo crear un nuevo grupo de participación a través de una fábrica y delegar en el grupo de participación, ahora la fundación realmente no puede evitar que delegue en este grupo de participación.
Contrato de fábrica de grupo de participación
Macro include_bytes


El contrato staking_pool_factory es un contrato que internamente tiene el código de un contrato de grupo de participación. En Rust puedes hacer esto usando la macro include_bytes. Básicamente toma un archivo local y lo incrusta en el binario como un vector. Lo que sucede allí es que dentro de este binario de WebAssembly podemos tener asignada una parte de la memoria que representa un binario de este grupo de participación en particular. Volvamos a la cima.
Estructura
Una vez más esta es la estructura.



Hubo alguna información sobre el gas, volveremos a esto más tarde.



Hay una función reward_fee_fraction que se acaba de copiar del contrato del grupo de participación que revisamos antes.


Contratos Externos
Aquí están los argumentos del grupo de participación que toma, y hay características y contratos externos, por lo que esta es la interfaz de alto nivel que usamos para llamar a ciertos contratos.



Tenemos dos de ellos, el primero puede ser cualquier nombre. Lo llamamos ExtSelf, porque representa nuestro propio contrato y contiene una devolución de llamada a un método on_staking_pool_create. El segundo rasgo es para el contrato de lista blanca que acabamos de ver llamado add_staking_pool. Aquí está.



Es exactamente la misma interfaz, excepto que las características en Rust son como las interfaces en Java, por ejemplo. Simplemente definimos la interfaz de un contrato remoto.
Inicialización


Repasemos primero el escenario. Cuando se crea una fábrica, verificamos que no se haya inicializado y verificamos el staking_pool_whitelist_account_id, la identificación de la cuenta del contrato de la lista blanca, durante la inicialización de StakingPoolFactory. Necesitamos saber el staking_pool_whitelist_account_id. Aquí es donde se implementa el contrato de lista blanca para incluir en la lista blanca nuestras instancias de grupo de participación recién creadas. Recordamos esto y también creamos un conjunto de cuentas ya creadas al final de este fragmento.
Método principal


Ahora que se creó la fábrica de grupos de participación, se llama poolv1.near, por ejemplo, y la fundación ha incluido a la fábrica en la lista blanca en un contrato de lista blanca mediante la emisión de otra transacción. Ahora que esta fábrica de grupos de participación está incluida en la lista blanca, significa que tiene permiso para incluir en la lista blanca los nuevos grupos de participación que crea. Así que ahora entra un validador y quiere crear un grupo de participación para ellos mismos. La forma en que funciona es que llaman a create_staking_pool y requiere un montón de argumentos. El primer argumento es un prefijo. Digamos que es bisontrails sin el sufijo de esta identificación de cuenta actual, y esto proviene del nombre de cuenta de NEAR. Una cuenta solo puede crear una subcuenta, o una cuenta muy larga, por lo que la fábrica del grupo de participación crea una subcuenta debajo de sí misma que será bisontrails.poolv1.near. El id_propietario es el id. de la cuenta del propietario del grupo de participación, como comentamos antes. Estos tres elementos son esencialmente argumentos que pasarías a un grupo de participación cuando lo creas por primera vez. Es un argumento que puedes usar como proxy para el grupo de participación. Por ejemplo, staking_pool_id puede ser bisontrails.near. stake_public_key puede ser la clave de staking de la ejecución de un nodo de validación, y reward_fee_fraction puede ser del 10 %, por ejemplo. Tenga en cuenta que este método también es payable (Que se le adjunta dinero), lo que significa que toma un depósito adjunto entrante, y lo primero que pregunta es: "¿Adjuntaste suficiente depósito?" El depósito que debe adjuntar es 30 NEAR, y tiene muchos ceros, pero esto se debe a que está en yocto NEAR. Debe adjuntar 30 NEAR principalmente porque necesita cubrir el estado del contrato en sí en un grupo de participación recién creado. El contrato es bastante grande, tiene 250 kilobytes y necesita al menos 25 NEAR para esto, pero también se necesita algo de dinero extra para cubrir el fondo de garantía de precio. Este es uno de esos casos en los que debes tener un depósito adjunto, porque no puedes adjuntar tanta gas a esta transacción. Además, no podemos convertir gas a NEAR dentro de un contrato, por lo que, idealmente, la separación de gas permanece igual, solo se usa para el cálculo, algunas operaciones de lectura/escritura y llamadas de contratos cruzados. El saldo se utiliza para almacenamiento y transferencias. Entonces, en nuestro caso, esto creará una nueva cuenta, y la creación de una nueva cuenta en NEAR requiere que pague por el almacenamiento de esta cuenta. El almacenamiento en nuestro caso no solo va a ser la propia cuenta sino también el contrato de esta cuenta. En nuestro caso, este es el código del contrato del grupo de participación.



Lo siguiente que hacemos es verificar que el prefijo no tenga un punto, lo que significa que no es una subcuenta en sí. Luego, creamos un nuevo staking_pool_account_id concatenando el punto de identificación de nuestra cuenta (.) con este nuevo prefijo. Verificamos que la nueva identificación de la cuenta del grupo de participación sea válida. Básicamente, si alguna de estas afirmaciones falla, el Protocolo NEAR reembolsará los tokens. Si una transacción falla con un depósito adjunto, el depósito adjunto volverá al remitente o al predecesor, porque solo el predecesor puede adjuntar un saldo. Es seguro hacer un montón de afirmaciones aquí. A continuación, verificamos que el id_propietario del grupo de participación sea válido. Esto es básicamente solo un grupo de ayudas adicionales que también se verifican en el grupo de participación. Esto es para asegurarse de que si no pasa los argumentos correctos, o los argumentos ligeramente incorrectos, es mejor que falle antes de que todo se ejecute para evitar quemar gas y bloquear los tokens que gastó. Finalmente verificamos usando insert que el grupo de participación no existe. Básicamente, insert devolverá true si es un nuevo elemento único y devolverá false si el elemento ya existe en un conjunto. Así es como funciona el hashset Rust de la misma manera que funciona un conjunto ordenado. Entonces, si el nombre del grupo ya existe, no agregaremos este grupo de participación ni intentaremos crear esta cuenta nuevamente. Insert hace dos cosas: agrega este elemento al almacenamiento, y devuelve true si el elemento es único y no existía antes o devuelve false si el elemento ya está presente. Si el conjunto no tenía este valor presente, se devuelve true, si este conjunto tenía este valor presente, se devuelve false.



Finalmente, usamos una API de nivel medio, no usamos nuestros métodos de costo en bruto, pero al mismo tiempo no usamos una interfaz de alto nivel. La forma en que funciona es que creamos una nueva promesa, que crea una estructura temporal en nuestro NEAR SDK, y recuerda al receptor de esta promesa. Puedes pensar en esto como si el contrato emitiera la transacción hacia esa identificación de cuenta dada. Llamaremos a una identificación de cuenta de grupo de participación no existente. Por supuesto que no es una transacción sino un recibo, pero es un detalle técnico. Lo siguiente es la primera acción además de esta promesa. Comenzamos a agrupar acciones en esta promesa. La primera acción es create_account. Esta acción creará una nueva cuenta o fallará si la cuenta ya existe. Luego depositamos el saldo adjunto. Depositamos todo el depósito que se nos pasó, para que no lo guardemos en esta fábrica, e irá con el mismo recibo en la cuenta remota. A continuación, implementamos un contrato. Como se explicó anteriormente, include_bytes es una macro que crea un segmento estático que convertimos en un vector que pasará a una acción de implementación. Esto implementará código en la cuenta remota. Solo puedes implementar código en la cuenta que controlas, pero create_account te da permiso para actuar como si fueras el propietario de esta cuenta solo para esta transacción en particular. Puede usar el método deployment_contract, puedes stakear y hacer otras cosas en nombre de este contrato en la primera transacción que realizamos. Finalmente, inicializamos el contrato del grupo de participación utilizando la API serda. Tomamos esta estructura y la serializamos en JSON, el método se llama new. El primer argumento es el depósito adjunto a esta llamada de función. No lo necesitamos, porque no lo espera. La siguiente es la cantidad de gas que toma de su cantidad actual de gas, e inmediatamente la saca, después de lo cual va a la promesa. Digamos que nuestro método se llama 100 tera gas, tera gas es un tipo de unidad que es más o menos comprensible para los humanos.



Tienes 100 tera gas cuando ingresas y decimos que vamos a pasar la base (25 tera gas) multiplicada por 2. Inmediatamente pasaremos 50 tera gas a la llamada de función de este método, por lo que este 50 tera gas significa que estamos solo quedándonos con menos de 50 tera gas, porque ya quemamos algo en la lógica antes. Además, cada acción que incluya en esta promesa también le costará algo de gas. Por ejemplo, una acción de implementación le costará transferir los bytes de una cuenta a otra. Finalmente usamos then. Then es similar a cómo funciona javascript, adjunta la dependencia de la promesa anterior. Esta es la primera promesa, y decimos que una vez que se complete haga la segunda promesa. La forma en que funciona es que digamos que bisontrails.near llamó a este contrato (poolv1.near) para crear bisontrails.poolv1.near. Primero creamos una promesa para bisontrails.poolv1.near y luego adjuntamos una devolución de llamada a esta API, algo que no es excelente en términos de usar argumentos posicionales para dos cosas diferentes, de cualquier manera, devuelve la identificación de la cuenta actual. Entonces llamará a poolv1.near después de que se haya ejecutado la primera promesa. Aquí está la estructura: bisontrails.near llama a poolv1.near creando una promesa de grupo de participación. Ahora, esto crea una promesa para bisontrails.poolv1.near, y también crea una promesa para sí mismo en el método on_staking_pool.



Necesita el resultado de este método antes de que comience este método y pasa tres argumentos aquí. Pasa el staking_pool_account_id, el added_deposit y el predecesor_account_id. Eso es quién nos llamó, qué cuenta se intentó crear y cuántos tokens se adjuntaron en caso de que necesitemos hacer un reembolso. Ahora, si bisontrails.poolv1.near se ejecuta correctamente, on_staking_pool_create recibirá el resultado de la ejecución. Digamos que por alguna razón hubo una configuración incorrecta que también llamó a este método, entonces recibirás una devolución de llamada diciendo que falló. Devolvimos la promesa principal después, entonces significa que volvimos on_staing_pool_create primero. Es importante, porque el resultado del método create_staking_pool depende del resultado de la promesa on_staking_pool_create. La transacción no comienza completamente en paralelo, sino que ahora depende de la ejecución de este método en particular.
Llamadas de vuelta
Veamos la devolución de llamada.



Lo primero que hacemos es decir que solo puede ser llamado por el contrato actual usando assert_self, lo que significa que nadie más puede llamar a esta promesa.



Lo siguiente que hacemos es usar otro método auxiliar de utilidad que dice si la dependencia, la creación del grupo de participación, tuvo éxito o falló.



Hacemos esto de la siguiente manera: primero usamos dos métodos finales para comprobar que el número de resultados es 1. Esto es un invariante porque ya sabemos que nadie puede llamar a esto dos veces, y el segundo es si el resultado es correcto. Si el método se ejecutó con éxito, devolvemos verdadero, si la promesa falló, entonces será falso. Así que ahora sabemos sí se creó el pool de participación o no. Nuevamente, también adjuntamos 50 tera gas a la devolución de llamada, por lo que ahora estamos en la devolución de llamada, lo que significa que solo tenemos 50 tera gas.



Si tenemos éxito, registraremos que el grupo se creó correctamente y luego lo incluiremos en la lista blanca. Luego llamamos a otra promesa desde una devolución de llamada y adjuntamos 25 tera gas. Así que ahora llamamos staking_pool_whitelist_account_id, el contrato de lista blanca. Ahora, podemos incluir en la lista blanca el grupo de participación que acabamos de crear, porque pasamos este argumento hacia la devolución de llamada. Devolvemos esta promesa para que no detengamos la ejecución todavía, porque solo queremos completar la transacción completa una vez que se complete la lista blanca. Rust no tiene retorno, porque si se da el último valor sin punto y coma, entonces es un valor de retorno. Si la creación falla, puede fallar por una sola razón: si coloca una clave de ristretto no válida, como discutimos brevemente antes. Si hay alguna curva extraña en la que creó su clave de replanteo, entonces fallará. La razón por la que falla es que significa que el depósito que pasó al grupo de participación para la creación nos será reembolsado a nosotros, y no al predecesor. Tenemos 30 NEAR en este contrato, y debemos devolverlos al remitente para que no los pongamos en staking. Lo primero que hacemos es eliminarlo de la lista de staking pools que se crearon, porque esto no tuvo éxito. Entonces, estamos diciendo que la creación falló y le reembolsaremos el depósito adjunto. Ahora no es un depósito adjunto real, porque la devolución de llamada no recibe el depósito adjunto. Vuela a través de un recibo de reembolso por separado que generalmente llega antes de la devolución de llamada, y también toma el predecesor_account_id. En nuestro caso, si llamamos al predecesor_account_id, seremos nosotros porque se trata de una devolución de llamada. Necesitamos saber a quién debemos devolver los tokens, y la forma en que lo hacemos es crear una promesa usando el nuevo predecesor_account_id, y devolvemos los tokens que se adjuntaron antes. Como puede ver, no devolvemos esta promesa, solo decimos que eso es todo, no nos importa si tiene éxito o falla, el retorno básico de valor falso dice que el grupo no se pudo crear. Lo que sucede ahora es que la transacción continúa ejecutándose, pero el valor se devolverá al front-end. El front-end es NEAR CLI. Inmediatamente sabrá que la transacción ha fallado. Es posible que aún no recupere su dinero, por lo que todavía está esperando que se ejecute este reembolso en particular en el siguiente bloque, pero ya sabe que el grupo no se creó para que pueda continuar. Este es un ejemplo de cómo puedes hacer una promesa paralela. Así es como funciona un factor de grupo de participación. Aquí hay un captador que verifica cuántos grupos de participación se crearon que se pueden llamar en NEAR CLI.


Conclusión
Esto concluye la revisión del contrato NEAR Live | Parte 3: Whitelist y Staking Pool Factory. Gracias por tomarte el tiempo para aprender NEAR, pronto habrá más contenido en esta serie.

### Update - February 7, 2022

Brief Summary:

 	We had a surprise Redeem Window on February 1st!

Results:

 	💸 Ⓝ49 sent to 49 (L)Earners participated in 🧧Red packet Redeem to NEAR Window
 	Ⓝ150 sent to 6 projects NEAR Certified Developer Demo January Day participants. Check projects repos at LNC GitHub
 	🤑There are about Ⓝ30 unclaimed  at Tip with NEAR for Twitter. So please check if some of them are waring for you.

Instructions are here https://github.com/dapplets/tipping-dapplet 
Tweet a cool twit tagging  @LearnNEAR and @dappletsproject and get tips in $NEAR
 	
NEAR Fortified Developer program launched!


 	


(L)Earn Top 5 NEAR Games














Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC Pro Bounty coming soon!

### Dapplet Twitter Tip Beta Testers Feedback

Requirements

 	Follow @LearnNEAR   and @DappletsProject   on Twitter
 	Follow the directions https://github.com/dapplets/tipping-dapplet
 	Find and Tip to at least to 5 tweets from different NEAR ecosystem projects - funny memes preferred
 	Tweet about this with a screenshot and tag the tweet author, @LearnNEAR and @Dapplets Project - this is an example:
https://mobile.twitter.com/LearnNear/status/1463495759941275652
 	Fill the Feedback form.

The top 20 beta testers will get 2NEAR, the best feedback submitter will get 10 NEAR. Please make sure your testnet and mainnet account MATCH exactly. - eg. john.testnet and john.near.

Happy testing!

### Top 10 NEAR Games

NEAR Protocol is a smart contract platform which focuses on developer and user-friendliness. With GameFi and blockchain gaming becoming the next big thing, let’s look at some of the gaming protocols that are currently live on NEAR. Specifically, we will be looking at:

 	Chain Typing
 	Pixel DApps: Pixelparty, Pixelpets, and Cryptoheroes.
 	Lands
 	Zomland
 	Pumpopoly
 	RealityChain
 	Galaxy Online
 	Metamon
 	Land To Empire

Chain Typing
Chain Typing is a play-to-earn game that helps you improve efficiency at typing. You will need to own a character to play the game, as represented on the Leaderboard. Initially, there will only be 30 characters available to play the game. As the game scales, there will be more playable characters available. The characters can be used as an ad space to hold descriptions.



Donations will go to the game’s funds to help further the game. The chain character minting fees are also donated to the game’s funds and are non-refundable.
Pixel DApps


Pixel DApps has created three games for the NEAR ecosystem, namely:

 	Pixelparty
 	Pixelpets
 	Cryptoheroes

Pixelparty


PixelParty is one of Pixel Dapps games. It is an NFT Frame showcase with a total supply of 600 tokens. Along with that, you must note the following:

 	Every token that you own allows you to draw on a 20x20px frame.
 	Users can buy different connected frames to draw a larger frame.
 	All frameholders receive rewards from the pixeltoken ecosystem.
 	Active frameholders with a minimum amount of frames get to participate in the DAO.

Here is how to participate in PixelParty:

 	Connect with your NEAR wallet.
 	Pick and buy one of the available frames.
 	Your frames will be located in the sidebar.
 	You are free to draw, edit or list them on the marketplace.

Pixelpets


PixelPets is a game created by Pixel DApps to trade and battle with your pets. It is an NFT game wherein each token represents one of the 60 different pet types. In addition, each pet has one of the four rarity traits – common, rare, epic, and legendary. The trait affects the pet’s different attributes like strength, quality, and level. In PixelPets, you can:

 	Hatch: Collect pet eggs and hatch them. You can only hatch one egg at a time. The higher the pet's rarity, the longer it takes to hatch the egg. 
 	Train: By training your pet, you can raise the quality rank. You can train your pet by sending them to the gym.
 	Evolve: After gaining enough experience points and getting the desired quality level, your pet can evolve to the next level in the evolution chamber.
 	Fight: Farm experience by dueling with other petmasters. You can also fight in the colosseum and earn prizes and honor.
 	Marketplace: Buy and sell your pets with pixeltoken.

Cryptoheroes


The third game created by Pixel DApps is Cryptoheroes – a blockchain-based game focused on PvE looting, trading and forging items, and fighting bosses with friends to earn PXT. Enter dungeons, defeat minions, and gather loot. 

How do you earn PXT:

 	Team up with your allies to join raids, defeat evil bosses, and compete for weekly PXT rewards.
 	Collect powerful items and sell them on the marketplace.
 	You can also reforge your items to improve your existing gear.

How do you participate in raids?

 	Every raid has 8 players. 
 	Raids take place on a weekly basis.
 	The top 20 raids are rewarded each week.

NEAR Lands


NEAR Lands is a decentralized, 2D multiplayer blockchain-based game. You, as a player, can walk around or build a pixelated land-based open world game. Players can:

 	Create their own characters and items.
 	Talk to friends.
 	Engage with other participants in the online universe.
 	Players can explore the landscape and create an immersive and interactive online realm.

Zomland
ZomLand is an interactive NFT & Play-to-Earn collectable game with exciting gameplay and a lot of fun to be had. You take on the role of a leader of an army of zombies and monsters to battle with other users all over the world and achieve your goals.

The logic of the game starts from Lands. Each land can produce a zombies. You can mint zombies every day (the number of zombies depends on the type of land).

You can claim zombies every 24 hours using your lands.

A monster is a very strong zombie with additional features:

 	Sold in Market
 	Transferred to another player.
 	Destroyed to get ZML Token .
 	Can take a part in Land Discovering  (you may find valuable items or come across monster hunters there).
 	Take a part in Battle Arena .
 	Increase the profitability of Staking .
 	Receive airdrop bonuses and whitelist in our next games (based on Monster Card Rarity).

Pumpopoly
Pumpopoly is a virtual real estate simulator reminiscent of classic board games. Playable on all devices, the game features pixel art on an animated HTML5 canvas.

Gameplay is simple. Players collect a salary from the treasury on every move. Simply click 'Drive& Claim' to claim your salary!

Players who park at player owned land pay rent to the landlord. Parking is free at all city owned properties. Deeper incremental clicker game mechanics exist beneath this simplicity.

Unlike the classic board game, Pumpopoly does not contain a fixed amount of properties. New land is added as players buy or improve property. This mechanic guarantees that the average cost of rent is always less than the salary paid. New land is added at a higher price to ensure your satisfaction.

Level up by buying more land or inviting friends. Earn 50% bonuses when your friends buy land. Progress through 5 levels and upgrade your land at every step. Build bigger buildings to maximize your rental income. The best buildings have a 16x rent multiplier!

Players may buy and sell land on the in-game market or export to NFTs. Pumpopoly tokens can be traded at ref.finance.
RealityChain
RealityChain is an award-winning Social Metaverse that seeks to give you a non-immersive Metaverse experience with the power of Web 3.0. A Metaverse shouldn’t replace your social interactions; and instead, it should be a complementary part of your social life. Reality Chain’s Metaverse provides a “casual” experience while still giving you the benefit of owning pieces of it as NFTs. 

The RealityChain concept:

 	Persistent - One whole Metaverse. Walk, fly, or ride from one location to another without loading screens.
 	Casual - A relaxed in-world experience that allows you to multitask Metaverse & IRL. Even building is a casual, in-world activity.
 	Accessible - Mobile first, light, quick loading times, and browser-based. Users can jump in any time without logging in.
 	User Owned - Every in-world asset, including spatial assets like land, is an NFT owned by users.
 	Multiverse - Modifier tokens instantly change your in-world experience, shifting you to other worlds on the same blockchain.
 	Dynamic NFTs (wishlist) - Create NFTs that are linked with IRL data.

Here is a video showcasing gameplay of the RealityChain Multiverse:


Galaxy Online
Galaxy Online is an epic MMO with blockchain-based game races. Space online strategy game with a huge universe consisting of a variety of galaxies where ruthless battles take place for dominance over planets and rich territories of space. Conquer planets, mine minerals, improve skills and technologies, build your fleet, trade, attack and defend, join corporations and clans.

In addition to the pleasant process of the game, you have the opportunity to earn cryptocurrency without investments just by playing! Be whoever you want and do whatever you want in the inhabited regions of the endless expanses of space!

Here are the two game modes available in Galaxy Online:

 	ARENA - Fast competitive mode of Galaxy Online. There are several different types of this mode, differing in duration and other elements of the game.
 	SEASONS - A new game mode in which players of all races start the game from scratch and fight each other for a week for the right to receive unique rewards. The longest season is 7 days.

Here is the trailer for the game:

https://learnnear.club/wp-content/uploads/2022/02/galaxyonline-en.mp4
LandToEmpire
LandToEmpire is a play-to-earn mobile ready strategy game on Near Protocol. The game is set in a fantasy world where the player is the lord of the land. In LandToEmpire, players have to upgrade their land using resources gained from attacking other players lands or producing them on their land. To attack, players train different types of troops using resources. The main resources are gold and elixir. Players can unite into clans, which can then participate in clan battles, and communicate with each other.

A premium GEM token is used to speed up construction and upgrades. GEMs can be obtained by passing levels and completing various tasks.Players can trade game tokens on the exchange, withdraw and deposit them into the game.

The game team supports the Proof-of-Game standard - this means that the creators of the game will not trade tokens and NFT, all tokens put up for sale will come from real players with a link to their land. The team's earnings are royalties from p2p NFT trading. Everything else is the players' earnings.
Metamon
Metamon is a world of Sci-Fi and Fantasy where you venture into the stars to discover exciting new worlds and majestic life-forms with immeasurable power. You wield a Gauntlet-like device equipped with a rare Forma Crystal which enables you to capture, evolve and transform yourself into a Metamon. You travel across space and time to hunt for more power and resources, to become the very best Metamon warrior. With the power of your Forma Gauntlet, you join an epic battle for the supremacy of your Faction in the Galactic Federation.

Enter the Metamon universe and strive to become the supreme Monster Hunter by growing your collection and career. Build your career in the Galactic Monster Guild by hunting for and capturing rare powerful monsters across alien biospheres. Your actions will determine the future of this universe.

Metamon has 2 ways that you can play the game:

 	SUPREMACY blends your classic Battle Royale- and Raid-type game modes, with touches of MMO elements all packaged together. SUPREMACY is where you can Play-To-Earn loot and coin.
 	MENACE is a fun, free-to-play (no entry fee!) game mode where you can join live Supremacy matches as a Monster. You will spawn as a random Metamon from your roster and your objective is to hunt players and kill them. Stop them from extracting loot. Be a MENACE! The more damage you deal to players, the more METACOINS you earn. 

Here is a video of the game:


Conclusion
NEAR gaming ecosystem is still young, but it's already showing a lot of promise. So make sure to stay tuned and keep an eye out on the newer projects being built on NEAR.

### Update - January 27, 2022

Brief Summary:

 	Busy week - Beta Test Sprint + Crypto Hero launch support!

Results:

 	🧪 Beta test for Zod Edge was the very first one with bonuses from tested Dapp! 
 	📖 If you still do not know why we are doing all that blockchain stuff - check out new Guide "What is Web3?"
 
 	📖 Check out updated Guide Top 7 NEAR NFT Projects

 	LNC helped NEAR Game Crypto Hero on Saturday launch. Pure fun and (L)Earners got tips on Twitter

 	NEAR Certified Developer Live Demo session is on Friday, January 28, 2022 at 11am ET.

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	(L)Earner NFT - Genesis edition. Subscribe to early mint access!

### NEAR Live Révision des contrats  | Partie 3 : Liste blanche et Staking pool de Factory

Introduction
Bonjour à tous. Aujourd'hui, nous allons passer en revue 2 contrats au lieu d'un. Nous allons inclure des contrats impliquant des appels croisés et parler des promesses et de leur fonctionnement chez NEAR. Si vous voulez en savoir plus sur le fonctionnement de la composabilité, c'est une bonne session à lire. Le premier contrat que nous allons examiner s'appelle un contrat de liste blanche, et il est utilisé sur le réseau principal pour mettre en liste blanche les pools de staking. Ceci est important car la distribution des jetons se fait via des contrats intelligents. Nous utilisons des contrats de verrouillage que nous examinerons éventuellement dans cette série, mais la façon dont cela fonctionne est que le verrouillage est un contrat autonome qui contient des jetons censés être libérés sur une période de temps. Disons que les jetons sont libérés sur 2 ans et sont alloués de manière linéaire à chaque bloc. Ce que nous voulions faire, c'est donner la possibilité de jalonner ces jetons, y compris les jetons qui ne sont pas encore sortis. Cela signifie que vous devriez pouvoir déléguer tous les jetons que vous avez verrouillés pendant 2 ans par exemple, et commencer à gagner des récompenses dessus. Cela se fait sur un contrat intelligent, et un contrat de verrouillage appelle essentiellement le contrat de pool de staking que nous avons examiné auparavant et transfère des jetons d'un contrat à un autre. Les jetons du contrat de blocage quittent le compte et vont sur le compte du pool de staking. Si un pool de staking ne fournit pas les garanties requises, telles que la possibilité de retourner ces jetons, cela signifie qu'il y aura des problèmes. Disons que je construis un pool de staking personnalisé qui me permet non seulement de miser des jetons, mais aussi de les retirer sur n'importe quel compte. Ce type d'opération vous permettra d'obtenir des liquidités avant la fin de la période de libération. Vous pourrez donc vous retirer, et ce n'est pas le comportement souhaité.

C'est pourquoi nous avons introduit la liste blanche où les implémentations personnalisées des pools de staking approuvés par la Fondation NEAR peuvent être utilisées par les contrats de verrouillage. En même temps, nous voulions donner la possibilité de créer de nouveaux pools de staking déjà approuvés par quiconque sans passer par l'approbation de la Fondation NEAR. Cela permet à quiconque de créer un nouveau pool de staking via une factory de pool de staking. factory de staking est le deuxième contrat que nous examinerons aujourd'hui. La façon dont cela fonctionne est lorsqu'un contrat de blocage veut déléguer, avant de pouvoir transférer des fonds vers ce contrat, il doit d'abord sélectionner un pool de staking. Lorsque vous sélectionnez le pool de staking, le verrouillage émet une transaction pour vérifier si un identifiant de compte donné est sur liste blanche dans un contrat de liste blanche, et s'il renvoie vrai, ce qui signifie que le compte est sur liste blanche, le contrat de verrouillage peut continuer avec la délégation. Il permet au lock-up de se transférer effectivement sur ce contrat. Cela signifie que le contrat de pool de staking a certaines garanties et API que le contrat local attend, et il ne va pas verrouiller les jetons du propriétaire, ni voler les jetons du contrat de verrouillage. Cela était également important pour les horaires d'investissement des employés de NEAR. C'était sur un calendrier d'investissement de quatre ans, et cela permet à la fondation d'émettre une transaction spécifique au lock-up de cette personne afin de tout retirer du pool de staking et de restituer le montant investi à la fondation NEAR en cas de départ d'un employé. l'emploi ou a été licencié. C'est le contexte des blocages et du contrat de liste blanche.

Le référentiel d'origine de ces contrats se trouve sur le NEAR Github. Voici la vidéo originale sur laquelle ce guide est basé :


Contrat de liste blanche
Structure Main
Regardons le contrat de liste blanche. C'est en fait un contrat assez simple, et il n'a pas vraiment beaucoup de logique, on connaît déjà la majorité des choses.



Il utilise une API NEAR appelée LookupSet. C'est similaire à un ensemble non ordonné. C'est une collection persistante, mais elle n'a pas d'itérateurs, vous ne pouvez donc pas itérer sur les clés des éléments de l'ensemble. Vous pouvez seulement vérifier si un élément donné est présent, ou non, et vous pouvez l'ajouter à l'ensemble. Vous ne pouvez pas vérifier quels éléments sont présents dans cet ensemble. Ce faisant, il améliore l'efficacité du stockage et l'accès de plusieurs lectures à quelques lectures. Le contrat contient quelques champs. Le premier est le foundation_account_id. Il s'agit de l'identifiant du compte qui contrôle la liste blanche. Cela signifie que ce compte peut mettre en liste blanche les pools de staking par 1, et il peut également mettre en liste blanche les factory de pools de staking. factory est un contrat qui peut créer une nouvelle instance de pool de staking. La façon dont cela fonctionne est que lorsque vous effectuez une transaction vers factory de staking qui est sur liste blanche par ce contrat, cela crée un nouveau compte en tant que sous-compte de factory. Dans notre cas, sur le réseau principal, cela s'appelle poolv1.near, qui est factory de pool de staking que nous utilisons. Il crée un contrat, par exemple bisontrails.poolv1.near, sur lequel il déploie le code de pool de staking en liste blanche que cette factory peut produire. Nous entrerons dans factory de pool de staking plus tard, mais en même temps, il peut également mettre en liste blanche ce pool de staking donné. Voilà comment cela fonctionne. L'initialisation du contrat ne prend qu'un argument foundation_account_id. Un compte de fondation a des autorisations plus élevées sur ce contrat.


Getters
Il y a un groupe de getters.



Vous pouvez vérifier si une entrée d'enjeu donnée est sur liste blanche. C'est ainsi qu'un contrat de verrouillage vérifie si le pool est sur liste blanche. Il vérifie simplement si un élément est présent dans un ensemble. La deuxième façon qu'il peut également vérifier est si factory est sur la liste blanche, donc ce n'est pas vraiment nécessaire, et personne ne l'appelle.
Ajouter une méthode staking de pool


C'est une méthode qui peut être appelée à la fois par une factory et par la fondation. Ce que nous faisons ici, c'est vérifier que cette méthode de staking ajoute un nouveau staking_pool_account_id à une liste blanche. Il vérifie si l'identifiant du compte est valide, puis s'il réussit, nous vérifions s'il s'agit d'une factory. On vérifie dans un ensemble que l'appelant de cette méthode est présent dans la liste blanche des factory. S'il est appelé par factory de pool de staking, alors ce n'est pas grave. Sinon, il doit s'agir d'un identifiant de compte de fondation, sinon le contrat échouera et cette méthode paniquera. Si nous réussissons la vérification des autorisations, nous ajoutons simplement ce pool de staking à la liste blanche. À l'heure actuelle, nous n'avons qu'une seule implémentation pour le pool de staking, mais en théorie, nous pouvons modifier cette implémentation lorsque nous introduisons le slashing par exemple, et un pool de staking doit avoir l'autorisation nécessaire. Il doit maintenir un certain équilibre minimum. Il y a un autre changement où nous devons modifier un contrat validé sur la période d'investissement de tout le monde de 4 ans. Beaucoup de choses peuvent se produire autour du réseau et nous devons avoir la possibilité de modifier potentiellement les pools de staking. Si la logique du staking pool change par exemple. Il permet la création d'une nouvelle factory qui est une meilleure version ou prend en charge quelque chose qui n'était pas pris en charge auparavant. Il ne permet pas de modifier instantanément les frais de récompense, mais ne permet de le modifier qu'après une période d'attente de 7 jours, ou une autre idée de modification qui sera un facteur différent.



Ensuite, remove_staking_pool ne peut être appelé que par la fondation, de sorte qu'un pool de staking ne peut être tué que par la fondation.

De plus, add_factory ne peut être appelé que par la fondation. C'est basique, ça s'ajoute juste à une liste blanche des comptes de factory.



Enfin, remove_factory ne peut également être appelé que par la fondation et supprime le factory_account_id. Disons que la première factory expire, alors la fondation peut essentiellement supprimer factory de la liste blanche ainsi que supprimer tous les pools précédents de la liste blanche. Maintenant, vous ne pourrez pas sélectionner l'un des sondages de staking précédents à partir d'un contrat de verrouillage, et enfin, il y a une vérification que cela est appelé par la fondation qui est une comparaison. C'est un contrat très simple, et il ne fonctionne que sur des ensembles internes et la seule vraie méthode visible de l'extérieur est is_whitelisted. C'est assez simple, c'est juste un tas de setters et getters.
Immuabilité des contrats intelligents
La façon dont les contrats intelligents se comportent généralement, ce qui est vrai sur Ethereum, et sur d'autres plateformes, est qu'ils sont immuables sur eux-mêmes. Sur Ethereum, chaque intérieur de contrat est immuable, mais ils utilisent un contrat proxy qui leur permet de mettre à niveau le point de terminaison pour certains contrats très critiques pour les jetons. Dans ce cas, nos contrats de base sont essentiellement complètement immuables, et nous pensons à eux comme si nous allions les déployer une fois, et probablement ne pas être en mesure de les modifier, car sinon vous devrez faire un hard fork et convaincre tous les validateurs de faire un certain type de migration de code. C'est important, car leur contrôle doit se faire au niveau du contrat plutôt que sur certaines entités centralisées. Par exemple, bien que la fondation conserve un contrôle important sur les pools de staking en ayant la possibilité de supprimer des pools de staking ici, elle n'a pas le contrôle de mettre sur liste noire une entité particulière dans le monde réel du déploiement d'un pool de staking. Ils peuvent toujours créer un pool de staking avec autant d'anonymat que possible et créer un pool de staking sans demander la permission de devenir un validateur sur le réseau principal. Certaines choses viennent de la décentralisation, l'autre vient de la limitation du contrôle. Bien que la fondation soit censée soutenir le réseau, il est possible que dans certains scénarios, la fondation soit obligée de faire quelque chose de mal pour le réseau. Disons que le gouvernement arrive et essaie de les forcer. S'ils ont moins de capacité à le faire, alors il y a une plus grande sécurité sur le réseau. Lorsque nous concevons un contrat, nous pensons : « Quelle est la valeur de ce contrat ? » ou « Quelle est la capacité de ce contrat à influencer le réseau en général ? ». Si c'est une petite valeur, alors c'est bien de garder la crédibilité tant que la communauté fait confiance, si c'est une grande valeur, alors ce n'est pas bien. Lorsque nous allons en fait arriver au contrat de blocage, et à la façon dont il est conçu, vous pouvez voir comment, par exemple, l'acquisition a été conçue pour permettre à la fondation de retirer les fonds restants, mais en même temps empêcher la fondation de retirer les fonds acquis. C'est une façon légale de faire les choses, sauf que c'est écrit dans le code. La liste blanche est un contrat très critique, car avant que les fonds ne soient verrouillés, la majorité des fonds contrôlent en quelque sorte le réseau via des contrats locaux dans des pools de staking via cette liste blanche particulière, il était donc important de la concevoir de manière à maintenir la décentralisation. , et la sécurité du réseau sans laisser le contrôle à la fondation. Disons que quelque chose s'est passé et que la fondation a commencé à agir avec malveillance. Disons que vous avez pu créer un nouveau pool de staking via une factory et déléguer au pool de staking, maintenant la fondation ne peut pas vraiment vous empêcher de déléguer à ce pool de staking.
Staking Contrat pool factory
Include Bytes Macro


Le contrat staking_pool_factory est un contrat qui a en interne le code d'un staking de contrat de pool. Dans Rust, vous pouvez le faire en utilisant la macro include_bytes. Il prend essentiellement un fichier local et l'intègre dans le binaire en tant que vecteur. Ce qui se passe là-bas, c'est que dans ce binaire WebAssembly, nous pouvons avoir une partie de la mémoire allouée qui représente un binaire de ce pool de staking particulier. Revenons au sommet.
Structure
C'est encore une fois la structure.



Il y avait quelques informations sur le gas, nous y reviendrons plus tard.



Il y a un reward_fee_fraction qui vient juste d'être copié du contrat de pool de staking que nous avons examiné auparavant.


Contrats externes
Il y a les arguments du pool de staking qu'il faut, et il y a les traits, et les contrats externes, c'est donc l'interface de haut niveau que nous utilisons pour appeler certains contrats.



Nous en avons deux, le premier peut être n'importe quel nom. Nous l'appelons ExtSelf, car il représente notre propre contrat et contient un rappel vers une méthode on_staking_pool_create. Le deuxième trait concerne le contrat de liste blanche que nous venons de voir appelé add_staking_pool. C'est ici.



C'est exactement la même interface, sauf que les caractéristiques de Rust sont comme les interfaces de Java, par exemple. On vient de définir l'interface d'un contrat distant.
Initialisation


Commençons par le scénario. Lorsqu'une factory est créée, nous vérifions qu'elle n'a pas été initialisée et nous vérifions le staking_pool_whitelist_account_id, l'identifiant du compte du contrat de liste blanche, lors de l'initialisation de la StakingPoolFactory. Nous devons connaître le staking_pool_whitelist_account_id. C'est là que le contrat de liste blanche est déployé afin de mettre en liste blanche nos instances de pool de staking nouvellement créées. Nous nous en souvenons et créons également un ensemble de comptes déjà créés à la fin de cet extrait.
Méthode Main


Maintenant que Staking de pool factory est créée, elle s'appelle poolv1.near par exemple, et la fondation a ajouté factory à la liste blanche sur un contrat de liste blanche en émettant une autre transaction. Maintenant que cette factory de pools de staking est sur liste blanche, cela signifie qu'elle a la permission de mettre en liste blanche les nouveaux pools de stakings qu'elle crée. Alors maintenant, un validateur arrive, et ils veulent créer un pool de staking pour eux-mêmes. La façon dont cela fonctionne est qu'ils appellent create_staking_pool, et cela prend un tas d'arguments. Le premier argument est un préfixe. Disons qu'il s'agit de bisontrails sans le suffixe de cet identifiant de compte actuel, et cela provient des noms de compte NEAR. Un compte ne peut créer qu'un sous-compte, ou un compte très long, donc la fabrique de pool de staking crée un sous-compte sous elle-même qui sera bisontrails.poolv1.near. Le owner_id est l'identifiant du compte du propriétaire du pool de staking comme nous l'avons vu précédemment. Ces trois éléments sont essentiellement des arguments que vous transmettez à un pool de staking lorsque vous le créez pour la première fois. C'est un argument que vous pouvez proxy vers le pool de staking. Par exemple, staking_pool_id peut être bisontrails.near. Le stake_public_key peut être la clé de staking de l'exécution d'un nœud de validation, et reward_fee_fraction peut être de 10 % par exemple. Notez que cette méthode est également payable, cela signifie qu'elle accepte un dépôt joint entrant, et la première chose qu'elle demande est : « Avez-vous joint suffisamment de dépôt ? » Le dépôt que vous devez joindre est 30 NEAR, et cela a beaucoup de zéros, mais c'est parce que c'est dans yocto NEAR. Vous devez joindre 30 NEAR principalement parce que vous devez couvrir l'état du contrat lui-même sur un pool de staking nouvellement créé. Le contrat est assez important, il fait 250 kilo-octets et il faut au moins 25 NEAR pour cela, mais il faut aussi un peu d'argent supplémentaire pour couvrir le fonds de garantie des prix. C'est l'un de ces cas où vous devez avoir un dépôt attaché, car vous ne pouvez pas attacher autant de gas à cette transaction. De plus, nous ne pouvons pas convertir le gas en NEAR dans le cadre d'un contrat, donc idéalement, la séparation du gas reste la même, elle n'est utilisée que pour le calcul, certaines opérations de lecture/écriture et les appels de contrats croisés. Le solde est utilisé pour le stockage d'état et les transferts. Donc, dans notre cas, cela créera un nouveau compte, et la création d'un nouveau compte sur NEAR vous obligera à payer pour le stockage de ce compte. Dans notre cas, le stockage ne sera pas seulement le compte lui-même, mais également le contrat de ce compte. Dans notre cas, il s'agit du code de staking du contrat de pool .



La prochaine chose que nous faisons est de vérifier que le préfixe n'a pas de point, ce qui signifie qu'il ne s'agit pas d'un sous-compte lui-même. Ensuite, nous créons un nouveau staking_pool_account_id en concaténant notre point d'identifiant de compte (.) ce nouveau préfixe. Nous vérifions que le nouvel identifiant de compte de pool de staking est valide. Fondamentalement, si l'une de ces assertions échoue, le protocole NEAR remboursera les jetons. Si une transaction échoue avec un dépôt joint, le dépôt joint reviendra à l'expéditeur ou au prédécesseur, car seul le prédécesseur peut joindre un solde. C'est sûr de faire comme un tas d'affirmations ici. Ensuite, nous vérifions que le owner_id du pool de staking est valide. Il s'agit essentiellement d'un groupe d'aides supplémentaires qui sont également vérifiées sur le pool de staking. Cela permet de s'assurer que si vous ne passez pas les bons arguments, ou des arguments légèrement incorrects, vous feriez mieux d'échouer tôt avant que tout ne s'exécute afin d'éviter de brûler du gas et de verrouiller les jetons que vous avez dépensés. Enfin, nous vérifions à l'aide d'insert que le pool de staking n'existe pas. Fondamentalement, insert renverra true s'il s'agit d'un nouvel élément unique et renverra false si l'élément existe déjà dans un ensemble. C'est ainsi que fonctionne le hashset Rust de la même manière qu'un ensemble ordonné fonctionne. Donc, si le nom du pool existe déjà, nous n'ajouterons pas ce pool de staking et n'essaierons pas de recréer ce compte. Insert fait deux choses, il ajoute cet élément au stockage, et renvoie true si l'élément est unique et n'existait pas auparavant ou renvoie false si l'élément est déjà présent. Si l'ensemble n'avait pas cette valeur présente, true est renvoyé, si cet ensemble avait cette valeur présente faux, il est renvoyé.



Enfin nous utilisons une API de niveau moyen, nous n'utilisons pas nos méthodes de coût brut, mais en même temps nous n'utilisons pas d'interface de haut niveau. La façon dont cela fonctionne est que nous créons une nouvelle promesse, qui crée une structure temporaire dans notre NEAR SDK, et il se souvient du destinataire de cette promesse. Vous pouvez penser à cela comme si le contrat émettrait la transaction vers cet identifiant de compte donné. Nous appellerons un identifiant de compte de pool de staking inexistant. Bien sûr ce n'est pas une transaction mais un reçu, mais c'est un détail technique. La prochaine chose est la première action en plus de cette promesse. Nous commençons à regrouper des actions dans cette promesse. La première action est le create_account. Cette action créera un nouveau compte ou échouera si le compte existe déjà. Ensuite, nous déposons le solde ci-joint. Nous déposons la totalité du dépôt qui nous a été transmis, afin que nous ne le gardions pas dans cette factory, et il ira avec le même reçu sur le compte distant. Ensuite, nous déployons un contrat. Comme expliqué précédemment, include_bytes est une macro qui crée une tranche statique que nous convertissons en un vecteur qui passera à une action de déploiement. Cela déploiera le code sur le compte distant. Vous ne pouvez déployer du code que sur le compte que vous contrôlez, mais create_account vous donne la permission d'agir comme si vous étiez le propriétaire de ce compte uniquement pour cette transaction particulière. Vous pouvez utiliser la méthode deploy_contract, vous pouvez miser et faire d'autres choses au nom de ce contrat lors de la première transaction que vous effectuez. Enfin, nous initialisons le contrat de pool de staking à l'aide de l'API serda. Nous prenons cette structure et nous la sérialisons en JSON, la méthode est appelée new. Le premier argument est le dépôt attaché à cet appel de fonction. Nous n'en avons pas besoin, car il ne s'y attend pas. Le suivant est la quantité de gas que vous prenez de votre quantité actuelle de gas et que vous retirez immédiatement, après quoi elle correspond à la promesse. Disons que notre méthode s'appelait 100 téra de gas, le téra de gas est une sorte d'unité qui est à peu près compréhensible par l'homme.



Vous avez 100 téra de gas lorsque vous entrez et nous disons que nous allons passer la base (25 téra de gas) multipliée par 2. Nous passerons immédiatement 50 téra de gas à l'appel de fonction de cette méthode, donc ces 50 téra de gas signifient que nous sommes n'est reparti qu'avec moins de 50 téra de gas, car nous en avons déjà brûlé dans la logique avant. De plus, chaque action que vous incluez dans cette promesse vous coûtera également de l'essence. Par exemple, une action de déploiement vous coûtera pour transférer les octets d'un compte à un autre. Enfin, nous utilisons alors. Ensuite, c'est similaire au fonctionnement de Javascript, il attache la dépendance à la promesse précédente. C'est la première promesse, et nous disons qu'une fois qu'elle est terminée, faites la deuxième promesse. La façon dont cela fonctionne est que vous appelez disons bisontrails.near appelé ce contrat (poolv1.near) pour créer bisontrails.poolv1.near. Nous créons d'abord une promesse à bisontrails.poolv1.near, puis nous attachons un rappel à cette api, ce qui n'est pas génial en termes d'utilisation d'arguments de position pour deux choses différentes. Dans tous les cas, il rappelle l'identifiant du compte actuel. Il appellera donc poolv1.near après l'exécution de la première promesse. Voici la structure : bisontrails.near appelle poolv1.near créant une promesse de pool de staking. Maintenant, cela crée une promesse à bisontrails.poolv1.near, et cela crée également une promesse à lui-même sur la méthode on_staking_pool.



Il a besoin du résultat de cette méthode avant que cette méthode ne démarre et il passe ici trois arguments. Il transmet le staking_pool_account_id, le attachment_deposit et le prédécesseur_account_id. C'est donc qui nous a appelés, quel compte a essayé d'être créé et combien de jetons ont été attachés au cas où nous devions effectuer un remboursement. Maintenant, si bisontrails.poolv1.near est exécuté avec succès, on_staking_pool_create recevra le résultat de l'exécution. Disons qu'il y a eu une mauvaise configuration selon laquelle cette méthode sera également appelée, mais recevra un rappel indiquant qu'elle a échoué. Nous avons renvoyé la promesse principale après, cela signifie que nous avons d'abord renvoyé on_staing_pool_create. C'est important, car le résultat de la méthode create_staking_pool dépend du résultat de la promesse on_staking_pool_create. La transaction ne démarre pas complètement en parallèle, mais dépend maintenant de l'exécution de cette méthode particulière.
Callback
Regardons le Callback .



La première chose que nous faisons est de dire qu'elle ne peut être appelée que par le contrat actuel en utilisant assert_self, ce qui signifie que personne d'autre ne peut appeler cette promesse.



La prochaine chose que nous faisons est d'utiliser une autre méthode d'assistance utilitaire qui indique si la dépendance, la création du pool de staking, a réussi ou échoué.



Nous procédons de la manière suivante : nous utilisons d'abord deux méthodes de fin pour vérifier que le nombre de résultats est de 1. C'est un invariant car nous savons déjà que personne ne peut l'appeler deux fois, et la seconde est si le résultat est un succès. Si la méthode s'est exécutée avec succès, alors nous retournons true si la promesse a échoué, alors ce sera false. Alors maintenant, nous savons si le pool de staking a été créé ou non. Encore une fois, nous avons également attaché 50 téra de gas au rappel, nous sommes donc maintenant dans le rappel, ce qui signifie que nous n'avons que 50 téra de gas.



Si nous réussissons, nous enregistrerons que le pool a été créé avec succès, puis nous le mettrons en liste blanche. Ensuite, nous appelons une autre promesse à partir d'un rappel et attachons 25 téra de gas. Alors maintenant, nous appelons staking_pool_whitelist_account_id, le contrat de liste blanche. Maintenant, nous pouvons ajouter à la liste blanche le pool de staking que nous venons de créer, car nous avons transmis cet argument au rappel. Nous retournons cette promesse afin de ne pas arrêter l'exécution pour le moment, car nous ne voulons terminer l'intégralité de la transaction qu'une fois la liste blanche terminée. Rust n'a pas de retour, car si la dernière valeur sans point-virgule est donnée, c'est une valeur de retour. Si la création échoue, elle peut échouer pour une seule raison : si vous mettez une clé ristretto invalide comme nous en avons discuté brièvement précédemment. S'il y a une courbe étrange dans laquelle vous avez créé votre clé de staking, cela échouera. La raison pour laquelle cela échoue est que cela signifie que le dépôt que vous avez transféré au pool de staking pour la création nous sera remboursé, et non au prédécesseur. Nous avons 30 NEAR sur ce contrat, et nous devons les rendre à l'expéditeur afin de ne pas les enfermer. La première chose que nous faisons est de le supprimer de la liste des pools de staking qui ont été créés, car cela n'a pas réussi. Nous disons donc que la création a échoué et nous allons vous rembourser l'acompte joint. Maintenant, ce n'est pas un véritable dépôt joint, car le rappel ne reçoit pas le dépôt joint. Il parcourt un reçu de remboursement séparé qui arrive généralement avant le rappel, et il prend également le prédécesseur_account_id. Dans notre cas, si nous appelons le prédécesseur_account_id, ce sera nous car il s'agit d'un rappel. Nous devons savoir à qui nous devons retourner les jetons, et la façon dont nous le faisons est de créer une promesse en utilisant le nouveau prédécesseur_account_id, et nous renvoyons les jetons qui étaient attachés auparavant. Comme vous pouvez le voir, nous ne retournons pas cette promesse, nous disons simplement que c'est tout, peu importe si cela réussit ou échoue, le retour de base de la valeur false indique que le pool n'a pas pu être créé. Que se passe-t-il maintenant, la transaction continue d'être exécutée mais la valeur sera renvoyée au frontal. L'extrémité avant est le NEAR CLI. Vous saurez immédiatement que la transaction a échoué. Vous n'avez peut-être pas encore récupéré votre argent, vous attendez donc toujours que ce remboursement particulier s'exécute dans le prochain bloc, mais vous savez déjà que le pool n'a pas été créé pour que vous puissiez continuer. Ceci est un exemple de la façon dont vous pouvez faire une promesse parallèle. C'est ainsi que fonctionne un facteur de pool de staking. Voici un getter qui vérifie combien de pools de staking ont été créés et peuvent être appelés sur le NEAR CLI.


Conclusion
Тhis conclut le NEAR Live Révision des Contracts | Partie 3 : Liste blanche et de staking de pool factory. Merci d'avoir pris le temps d'apprendre NEAR, d'autres contenus seront bientôt disponibles dans cette série.

### DeFi в протоколе NEAR

NEAR Protocol — это платформа смарт-контрактов, ориентированная на удобство для разработчиков и пользователей. Он предоставляет масштабируемую платформу для запуска приложений. NEAR был основан летом 2018 года Алексеем Скидановым и Ильей Полосухиным. Сегодня в этой статье мы рассмотрим приложения DeFi на протоколе NEAR.
Рост DeFi
DeFi или децентрализованные финансы — это финансовые инструменты на основе блокчейна. В то время как централизованные финансовые инструменты увязли из-за отсутствия совместимости и бюрократизма, приложения DeFi подобны блокам Lego, которые пользователи могут объединять для создания новых инструментов. В результате экосистема DeFi выросла с 7,40 млрд долларов на 22 июня 2020 года до 97,7 млрд долларов на 7 сентября 2021 года. Это рост стоимости примерно на 1220% чуть более чем за год! 



На данный момент общая стоимость, заблокированная в DeFi, составляет около 83,86 миллиарда долларов. 
Истинное значение DeFi
Разговора о заблокированной общей стоимости недостаточно, чтобы понять истинное значение DeFi. Это важнейший элемент в построении Open Web, и он единолично отвечает за приток талантов, который Ethereum испытал за последние два года. Если подумать, это имеет абсолютный смысл из-за революционной и компонуемой природы DeFi. Действия, на которые в традиционном финансовом мире могли уйти недели, теперь занимают всего несколько секунд. 

Однако у этого уравнения есть и обратная сторона. Из-за всплеска спроса DeFi стал причиной перегрузки сети и роста цен на газ. Таким образом, барьер для входа в Ethereum стал значительно выше для начинающих разработчиков и создателей. 

Протокол NEAR представляет собой жизнеспособную, более быструю и дешевую альтернативу Ethereum. 
DeFi и протокол NEAR


Давайте рассмотрим некоторые из самых многообещающих проектов DeFi на NEAR. 
Rainbow Bridge


Это мост между NEAR и Ethereum. Все активы, происходящие из Ethereum, теперь полностью пригодны для использования в NEAR. С момента его запуска через мост прошло более 1 миллиона долларов ETH, DAI и других токенов. Инфраструктуру Bridge можно легко перепрофилировать и обеспечить связь между NEAR и всеми цепочками, совместимыми с EVM, такими как Polygon, BSC, Avalanche, Optimism, Arbitrum и т. д. В настоящее время команда работает над расширением этой инфраструктуры для поддержки цепочек, не поддерживающих EVM, таких как Биткойн, Космос и др.

Вот что вам нужно знать о Rainbow Bridge :

 	Пользователи могут быть подключены к Rainbow Bridge напрямую через MetaMask.
 	Транзакции NEAR подтверждаются менее чем за 2 секунды при стоимости газа менее 1 цента. 

Вот как выглядит транзакция через мост NEAR<>Ethereum: 

 	Перемещение активов из Ethereum в NEAR занимает около 6 минут (около 20 блоков).
 	Транзакции ERC20 стоят в среднем около 10 долларов.
 	Отправка активов из NEAR обратно в Ethereum занимает не более 16 часов (из-за окончательного времени Ethereum). Этот процесс также стоит около 60 долларов из-за стоимости газа ETH. 

Rainbow Bridge — важное нововведение, поскольку это важный первый шаг в дорожной карте взаимодействия NEAR. Кроме того, поскольку NEAR предлагает более быстрые и дешевые транзакции, пользователям других сетей может быть выгодно взаимодействовать с активами Ethereum в NEAR, а не напрямую подключаться к Ethereum. 
Ref Finance


Ref Finance была первой платформой DeFi на NEAR. Первая версия Ref имела некоторое сходство с Uniswap V2, наряду с поддержкой большего количества типов пулов, настраиваемой комиссией и полностью принадлежала сообществу. Его основная цель — объединить основные компоненты DeFi, такие как децентрализованный обмен (DEX), протокол кредитования, эмитент цифровых активов и т. д. 

Ref Finance имеет казначейство в размере 35 миллионов долларов REF, из которых 10% выделено на развитие будущих проектов и 25% на будущие мероприятия, мероприятия и партнерские отношения, связанные с сообществом. 

Особенности Ref Finance

 	AMM DEX от Ref позволяет без разрешения и автоматически торговать между любым родным токеном NEAR или промежуточным токеном.
 	Поставщики ликвидности могут зарабатывать токены $REF или NEP-141, размещая токены LP.
 	Пользователи могут размещать токены $REF, чтобы со временем зарабатывать больше $REF. 

Ref — это проект сообщества, который поддерживается DAO. Ref DAO играет две роли: консулы и совет сообщества. 

 	Консулы: Консулы создают предложения и голосуют по ним. Предложение проходит только в том случае, если его подтвердит большинство консулов. Совет будет изменен после того, как DAO станет полностью активным. 
 	Совет сообщества: Совет сообщества также голосует за предложение или отклоняет его. В большинстве случаев консулы подчиняются решению совета сообщества. 

OIN Finance


OIN — это децентрализованная платформа для выпуска стейблкоинов, которая позволяет проектам выпускать стейблкоины под собственным брендом. Вместо того, чтобы вносить свой залог в белый список на других платформах, OIN запустит стабильную монету с обеспечением NEAR, чтобы разблокировать ликвидность без продажи своих токенов NEAR. Варианты использования OIN — обмен на другие основные стейблкоины, добавление кредитного плеча, хеджирование, кредитование и множество утилит, специфичных для экосистемы. 

В настоящее время основной линейкой продуктов OIN является OINDAO. Это позволяет проектам, которые объединяются, создавать собственный пул залога для выпуска стейблкоинов с собственным брендом. OIN устанавливает быстрый процесс проверки для каждой транзакции, инициированной в блокчейне, через систему проверки Merkle. Они делают это, размещая небольшие фрагменты информации, ведущие к «корневой транзакции» в реестре, и используют их для проверки большей базы данных информации. 

Вот некоторые интересные особенности OIN: 

 	Легко и быстро создавать стейбл коин после того, как проект листинга определит параметры.
 	Все смарт-контракты OIN прошли тщательный аудит.
 	Техническая поддержка для настройки ключевых параметров риска для смарт-контрактов.
 	Техническая поддержка, которая поможет вам обменять ваш фирменный стейбл коин на основные стейбл коины на Curve и Balancer, чтобы разблокировать ликвидность вашего актива. 

Skyward Finance 


Skyward Finance — это открытый лаунчпад с открытым исходным кодом, которую проекты могут использовать для запуска своих токенов без какой-либо ликвидности. Skyward потенциально обладает одним из лучших механизмов определения цены, устойчивым к атакам злоумышленников и атакам ботов. Платформа призвана обеспечить обнаружение цен и распределение токенов для проектов, построенных на протоколе NEAR. Это достигается за счет использования потоковых аукционов, основанных на времени, к которым может получить доступ все сообщество децентрализованным образом. Эти аукционы также будут устойчивы к манипулированию ценами и атакам злоумышленников. Skyward Finance будет выпускать токены для сообщества, что позволит им стать частью платформы и получать доход. 
Какие преимущества Skyward Finance? 
Skyward Finance имеет ряд преимуществ, некоторые из которых заключаются в следующем. 

 	Проекты могут запускать свои токены без ликвидности.
 	Механизм определения цен Skyward Finance устойчив к атакам ботов и злоумышленников. Им также нельзя манипулировать.
 	Проекты могут собирать средства в любом токене, а также могут запускать несколько продаж токенов, состоящих из разных токенов.
 	Благодаря непреклонности Skyward Finance к любым манипуляциям с ценами проекты и их учредители могут максимизировать свой капитал на основе рыночной стоимости.
 	Проектам не требуется токен $SKYWARD для участия или создания продажи.
 	Skyward Finance имеет открытый исходный код и не имеет разрешений, а это означает, что смарт-контракты на платформе полностью независимы.
 	Поскольку Skyward Finance работает на NEAR, она может воспользоваться масштабируемостью NEAR и более дешевыми транзакциями. 




	

	
	
		
			
				Что из перечисленного является платформой для выпуска стейблкоинов? 
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool — это протокол ликвидного стейкинга, построенный на протоколе NEAR. Физические лица могут легко размещать свои токены NEAR, используя Meta Pool и его стратегии автоматического размещения. Взамен они получают токены Staked NEAR, которые они могут использовать в DeFi NEARverse. Токены также могут быть обменены обратно на исходные токены NEAR в любой момент времени. 

Метапул стал неотъемлемой частью экосистемы DeFi NEAR, поскольку он представляет первый ликвидный токен NEAR для ставок, stNEAR. Токен stNEAR может начислять вознаграждения за стейкинг, а также представлять позиции по стейкингу на NEAR. Meta Pool предлагает держателям токенов NEAR простую в использовании платформу, приносящую доход при создании децентрализованной сети. Meta Pool будет работать на DAO на Sputnik V2, собственной платформе NEAR для управления децентрализованными автономными организациями. 

Когда держатели токенов делают ставки в Meta Pool, они получают токены $META каждую эпоху. Каждая эпоха составляет 12 часов. Они получаются в дополнение к вознаграждениям по протоколу NEAR, которые составляют 10,2% годовых. 
Cheddar 


Cheddar создает сеть лояльности для NEAR и ее экосистемы децентрализованных приложений. Это достигается за счет установления стратегических партнерских отношений, которые активно продвигают использование протокола NEAR при вознаграждении пользователей. Было доказано, что сети лояльности успешно мотивируют пользователей на выполнение действий, полезных для бизнеса. Через Cheddar можно загружать токены сообщества, что позволяет приложениям повышать лояльность пользователей и добавлять новые потоки доходов с помощью механизмов фарма. 

Cheddar отличается от других фарм-ферм , поскольку он обеспечивает долгосрочные преимущества для холдеров за счет бонусов. Это также способствует использованию нескольких приложений в NEARVerse, позволяя пользователям добывать Cheddar с помощью Yield Farming, пулов ликвидности или dApps. 
Какую пользу приносит Cheddar протоколу NEAR

 	Подключение dApp — Cheddar создает общую связь между приложениями, помимо отдельных токенов, тем самым создавая лояльную экосистему для dApps на NEAR.
 	Взаимодействие с пользователями — Cheddar обеспечивает долгосрочное взаимодействие с пользователями с помощью различных стимулов и укрепления лояльности посредством стратегического партнерства.
 	Переключение между сетями — Cheddar создает взаимосвязь между сетями и поддерживает активность и вовлеченность пользователей NEAR, гарантируя сохранение общей заблокированной стоимости. 




	

	
	
		
			
				Что из следующего является созданием программы лояльности на NEAR? 
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Berry Club позволяет пользователям создавать общие пиксельные изображения, а также зарабатывать токены. Berry Club начинался как демонстрация концепции DeFi, но с тех пор превратился в чрезвычайно популярный проект сообщества по протоколу NEAR. Berry Club отлично использует некоторые функции протокола NEAR, такие как автоматические платежи создателям смарт-контрактов, которых нет ни в одном другом блокчейне. Благодаря уникальному дизайну NEAR, Berry Club и Berry Farm могут принести пользу как пользователям, так и создателям смарт-контрактов, которые выплачиваются в виде вознаграждений по смарт-контрактам как держателям токенов, так и создателям. Эти преимущества возникают в результате более широкого использования приложения (Berry Club). Такой тип распределения вознаграждений невозможен на таких платформах, как Ethereum, по крайней мере, в его текущей реализации. Это еще одна причина, по которой пользователям и разработчикам следует экспериментировать с NEAR. 




	

	
	
		
			
				Мост между Ethereum и NEAR называется:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
Фирма, занимающаяся исследованиями и разработками, нацеленная на DeFi в экосистеме NEAR.

Вывод
NEAR Protocol уже имеет очень интересную экосистему DeFi, и она будет только расти. В сложившейся ситуации NEAR представляет собой мощную и эффективную альтернативу Ethereum.

### Crypto Hero, jeu NEAR

Qu'est-ce que Crypto Hero ?

Crypto Hero est un jeu basé sur la blockchain, principalement axé sur le PvE - où vous pouvez broyer des donjons et échanger des objets avec d'autres joueurs, ainsi que jouer avec des amis dans un système de raid où vous pouvez gagner des prix Pixel Token chaque semaine.

L'idée est inspirée des RPG traditionnels, ainsi que des RPG d'action tels que Diablo.

il essaie de mettre en œuvre les mécanismes de ces jeux de manière simple, permettant une expérience simplifiée où les joueurs peuvent développer leurs personnages, rivaliser avec les autres et, surtout, gagner.

Le jeu contient 5 éléments principaux, que je vais énumérer ci-dessous.



Il essaie de mettre en œuvre les mécanismes de ces jeux de manière simple, permettant une expérience simplifiée où les joueurs peuvent développer leurs personnages, rivaliser avec les autres et, surtout, gagner.

Le jeu contient 5 éléments principaux, que je vais énumérer ci-dessous.

Pourquoi jouer à Crypto Hero ?

Crypto Hero est le deuxième jeu de PixelDapps et ne sera pas le dernier - une équipe qui a produit avec succès des jeux blockchain où les joueurs trouvent des opportunités de gagner des prix tout en s'amusant. Le jeton actuel est stable et en hausse, ce qui est le moment idéal pour un investissement précoce.

En dehors de cela, Crypto Hero est amusant. Il crée un système de progression des RPG vers un tout nouveau niveau avec des objets NFT qui sont collectés et échangés dans une communauté qui est avant tout liée aux idées et aux aspirations de l'écosystème.

Comment jouer à Crypto Hero ?

Règles du héros crypto

Quand puis-je jouer à Crypto Hero ?

La sortie de MainNet est le 22 janvier

Où puis-je jouer à Crypto Hero ?

Jouer à Crypto Hero

 	La salle des ventes

Les objets peuvent être échangés sur l'hôtel des ventes avec des Pixel Tokens.

Vous pouvez filtrer les articles par catégories ainsi que différents types d'équipements pour faciliter la recherche.



 	Les objets

Votre héros peut équiper jusqu'à 6 objets différents : une arme, une armure, des bottes, un collier, une bague et un casque.

Les objets sont définis par leur rareté : commun, rare, épique et légendaire.

Les objets peuvent être lâchés dans les donjons, plus le niveau du donjon est profond, meilleur est l'objet.

Les objets rendront votre héros plus fort.



 	Le héros

Votre héros a HP, Level et Experience.

Votre héros peut monter de niveau lorsqu'il acquiert suffisamment d'expérience.

Plus votre niveau de héros est élevé, plus il devient fort.



 	Le donjon

Vous pouvez envoyer votre donjon héros en exploration, où il affrontera une horde de créatures.

Vous pouvez choisir la profondeur à laquelle vous voulez aller dans un donjon, les niveaux plus profonds offrent un meilleur butin et une meilleure expérience, mais deviennent exponentiellement plus difficiles.

Une fois que vous avez terminé le donjon, vous êtes récompensé par du butin et de l'expérience et vous devez attendre pour retourner dans le donjon.



 	L'échelle de classement

L'échelle de classement affiche les niveaux les plus élevés + les niveaux d'objets dans le jeu, créant un scénario compétitif entre les joueurs.



 	Les Raids

Le système de raid est une incitation sociale pour que les joueurs se connectent les uns aux autres, tout en étant la principale source de revenus du jeu. Vous pouvez vous regrouper avec 7 autres joueurs afin de combattre des boss qui ont des difficultés de classement différentes et des récompenses différentes.

### Qu'est-ce que la Tokenomics ? Guide express

L'un des principes fondamentaux d'un réseau décentralisé est sa tokenomics. Pour aider les projets à mieux comprendre les nuances de leurs jetons, Learn Near Club a contribué au lancement d'un nouveau terrain de jeu pratique de tokenomics sur NEAR Testnet - LNC | TokenHub. Cependant, avant d'entrer dans les détails, sachons ce que signifie Tokenomics.
Qu'est-ce que la Tokenomics ?
Le jeton n'était initialement qu'un autre terme pour une «crypto-monnaie» ou un «cryptoasset». Cependant, dernièrement, nous avons utilisé le terme «token» pour expliquer un actif cryptographique émis au-dessus d'une blockchain. Le terme « tokenomics » est un mot-valise de « jeton » et « d'économie », et c'est un terme utilisé pour décrire, vous l'avez deviné, l'économie d'un jeton.

Lorsque vous souhaitez évaluer la tokenomics du réseau, vous devez vous poser ces questions :

 	Quelle est l'offre totale de jetons et combien d'entre eux entrent dans le système en même temps ?
 	Combien de jetons seront créés à l'avenir ?
 	Comment les jetons sont-ils répartis entre les utilisateurs ?
 	Quel est le rôle exact du jeton dans le réseau ?
 	Le réseau a-t-il besoin d'un jeton pour fonctionner ?

Globalement, l'objectif est d'établir un lien clair entre la plateforme et l'actif.
Éléments définis dans Tokenomics
La Tokenomics peut être largement différenciée entre le contrôle de l'offre et l'utilité. Examinons chacun de ces éléments.
#1 Contrôle de l'approvisionnement
Combien de jetons de protocole vont réellement être en circulation. Quelle part de l'approvisionnement est contrôlée par le contrat de base ? Dans cet aspect, nous devons comprendre certains termes.

Préminage

Fondamentalement, combien de jetons flottent déjà dans l'écosystème au moment du lancement. Habituellement, les jetons sont extraits périodiquement par des utilisateurs spécialisés appelés « mineurs ». Cependant, des protocoles spécifiques mettent souvent un certain % de leur offre globale à disposition lors du lancement pour la distribution de jetons et l'accès à la liquidité. Cependant, notez que la préexploitation d'un grand nombre de jetons pourrait entraîner des problèmes de centralisation.

Attribution de jetons

Comment les jetons sont-ils attribués à l'équipe du projet ? Calculent-ils une grande quantité de jetons, ce qui entraîne des problèmes de centralisation ? Quelle part des jetons est allouée à la trésorerie pour le développement futur du protocole ?

Acquisition de jetons

La plupart des projets reçoivent un financement de VC ou d'autres investisseurs, qui reçoivent une allocation symbolique en échange de leur investissement. Malheureusement, le plus souvent, les VC ont tendance à vider leur allocation immédiatement pour faire un profit rapide, ce qui endommage inévitablement le protocole. Vous pouvez verrouiller une allocation de jetons particulière pendant une période de temps spécifiée avec l'acquisition de jetons pour éviter une vente massive.

L'acquisition de jetons est cruciale pour inspirer la confiance des investisseurs, car elle leur indique que l'équipe et les investisseurs sont sérieux au sujet du projet et ne recherchent pas un gain rapide. L'acquisition est un moyen facile de réduire les manipulations de marché et de garantir la valeur de l'investissement.

Gravure de jeton

Une autre tactique simple que de nombreux projets utilisent pour contrôler l'approvisionnement en circulation est la gravure de jetons. L'idée est simple - retirer périodiquement un certain nombre de jetons de la circulation de façon permanente. La plupart des projets le font en envoyant les jetons à un portefeuille mort. Des projets comme Ethereum et Binance utilisent la gravure de jetons pour contrôler l'approvisionnement de leurs jetons natifs.
#2 Utilitaire de jeton
Quels sont les différents rôles que vos tokens peuvent assumer ? Jetons un coup d'œil à certains des différents rôles.

 	Les jetons peuvent être utilisés à des fins purement utilitaires et de paiement à l'intérieur ou à l'extérieur de l'environnement du protocole.
 	Les jetons peuvent être utilisés pour participer au protocole et participer à la gouvernance.
 	La détention du jeton de protocole est nécessaire pour accéder aux différentes applications (DeFi et NFT) du système.

Jouer avec Tokenomics
L'outil Tokenomics de Learn Near vous permet de cartographier les différents composants de votre jeton et de jouer avec eux sur testnet.

Ces composants sont :

 	Nom du jeton
 	Première version
 	symbole
 	Trésorerie
 	Approvisionnement initial
 	Heure de début d'acquisition
 	Durée d'acquisition
 	Points décimaux
 	Intervalle d'acquisition

Jouer avec ces différentes valeurs vous aidera à comprendre le contrôle de l'approvisionnement de la tokenomics de votre protocole. Vous souhaitez expérimenter cet outil ? Découvrez LNC TokenHub !

### Qu'est-ce que le Réseau Octopus ?

Objectif attendu : compréhension générale du Réseau Octopus du point de vue de l'utilisateur final.

Une pieuvre est très différente d'un humain. Au lieu d'avoir un système nerveux centralisé comme c’est le cas chez les humains, les deux tiers des neurones d'une pieuvre sont répartis entre l'ensemble de son corps et ses bras. Ces neurones peuvent prendre des décisions de manière autonome, sans intervention du cerveau, ce qui fait de la pieuvre une forme de vie intelligente décentralisée.

Le Réseau Octopus est un crypto-réseau interopérable multichaînes, c'est-à-dire qui a la capacité de connecter et permettre l’échange entre différentes blockchains, à l’instar de la pieuvre. Comme les bras d'une pieuvre, chaque blockchain connectée spécifique à une application (appelée appchain sur le Réseau Octopus) est dotée de sa propre intelligence et de ses propres mécanismes de prise de décision pour s'adapter à des environnements en constante évolution. Lorsqu'ils sont connectés dans leur ensemble, tous les membres bénéficient d'importants effets de réseau et d'économies de fonctionnement, créant ainsi un « Internet des blockchains ».



Le Réseau Octopus est un réseau cryptographique multichaîne dont la finalité est le lancement et l'exécution de blockchains spécifiques aux applications Web3.0, également appelées appchains.

Les appchains du Réseau Octopus bénéficient d'une sécurité louée grâce au mécanisme de Proof os Stake (LPoS) flexible et rentable, d'une interopérabilité multichaîne prête à l'emploi, d'une infrastructure complète et d'un engagement important de la communauté.

Le Réseau Octopus réduit le coût de lancement d'une appchain de plusieurs millions de dollars à moins de cent mille dollars, déclenchant ainsi la troisième vague d'innovation des crypto-réseaux.
L'évolution des applications Web3.0
Le Web3.0 n'est pas encore arrivé. Mais sur la base des premières grandes lignes du projet, nous sommes certains qu'il finira par arriver.

Les échanges vont toujours vers le marché où les coûts de transaction sont les plus bas, tout comme l'eau coule toujours vers le bas.

Les plateformes du Web2.0 sont détenues et gérées par des grandes entreprises du numérique (GAFA) dont les objectifs sont directement alignés sur la maximisation de la valeur actionnariale. Elles extraient le plus de profit possible des activités économiques qu'elles coordonnent pour les redistribuer aux actionnaires.

Les crypto-réseaux sont des marchés de services numériques dont les coûts de transaction sont réduits au minimum. Les plateformes du Web2.0 n'ont donc aucune défense contre leur remplacement éventuel par des crypto-réseaux.

Le Web3.0 fait référence à des applications décentralisées fonctionnant sur des blockchains et appartenant à la communauté des utilisateurs plutôt qu'à des entreprises qui cherchent à faire du profit. Le Web3.0 aspire à rendre de la valeur aux véritables créateurs de contenu.

Mais les plateformes du Web2.0 sont largement adoptées et utilisées quotidiennement par les internautes. Pour qu'une application Web3.0 supplante une application Web2.0, elle doit d'abord être une excellente application Web et offrir une expérience utilisateur au moins aussi bonne que son homologue Web2.0.

Le développement d'une application Web3.0 doit généralement sacrifier l'expérience de l'utilisateur, car la technologie utilisée dans le cadre des blockchains est plus complexe et plus coûteuse que le Web2.0, ce qui entraîne une dégradation de l'expérience utilisateur.

On peut toutefois se réjouir de la troisième vague d'innovation des crypto-réseaux en cours et des solutions d'application Web3.0 prometteuses qu’elle entraîne avec elle.
La troisième vague d'innovation des crypto-réseaux
Le Bitcoin est une blockchain spécifique à une application (appchain), la première et la plus réussie de toute l’histoire.

Inspiré par Bitcoin, un assortiment d'appchains s'est ensuite développé de 2011 à 2015. Certaines ont essayé de faire mieux que le Bitcoin, tandis que d’autres ont ciblé une variété de cas d'utilisation autres que la monnaie, nous laissant avec une pléthore de pièces mortes.

La raison communément admise pour cela est que la blockchain Bitcoin était construite à un but unique et qu'elle n'était pas adaptée pour répondre à d'autres cas d'utilisation et n’avait pas pour objectif premier d’évoluer. Nous pouvons appeler cette période la première vague d'innovation des crypto-réseaux.

La seconde vague d'innovation des crypto-réseaux est née avec Ethereum. Ethereum est une blockchain publique polyvalente équipée d'une machine virtuelle « Turing-Complete » (qui pourrait théoriquement exécuter n'importe quel calcul, tant qu'il reste dans la limite de complexité, également appelé limite de gaz). Le principal langage de programmation de la blockchain Ethereum est Solidity, avec sa syntaxe de type Javascript, facile à apprendre et très efficace pour contrôler les actifs sur la chaîne.

Ethereum a permis à des milliers de développeurs de créer des applications décentralisées (dApps). Malheureusement, très peu d'entre elles ont pu fidéliser de nombreux utilisateurs sur une longue période, jusqu'à l'explosion d'Ethereum et de la DeFi en 2020.

Mais le principal défi auquel Ethereum est confronté est sa capacité d’évolution, et les frais de gaz pour l'exécution des smart contracts ont rendu certains cas d'utilisation très onéreux et donc une pauvre expérience utilisateur. Alors qu'Ethereum 2.0 vise à cibler ces problèmes avec un protocole de blockchain « sharded », Ethereum 2.0 présente une feuille de route de plusieurs années avec des risques de mise en place et d’acceptation encore inconnus.

Cependant, une troisième vague d'innovation de cryptomonnaies est sur le point d’arriver. Les frameworks blockchain tels que Substrate et Cosmos SDK peuvent offrir un espace de conception colossal sans précédent aux développeurs d'applications Web3.0.

Les développeurs sont désormais en mesure de fournir une application Web3.0 entièrement optimisée en construisant une appchain.


Qu'est-ce qu'une Appchain ?
Une application décentralisée, ou dApp, est une application web dont au moins une partie du backend réside sur une blockchain. Le backend d'une dApp peut être mis en œuvre de deux façons : les smart contracts peuvent être hébergés sur une plateforme blockchain, ou une application décentralisée peut vivre sur sa propre blockchain dédiée.

Lorsqu'une dApp possède sa propre blockchain, on parle de blockchain spécifique à une application, ou appchain en abrégé. Contrairement aux dApps, les appchains permettent aux développeurs de personnaliser leur application en termes de gouvernance du réseau, de conception économique (également appelé tokenomics) et même d'algorithme de consensus du réseau.

Les appchains offrent également aux développeurs une capacité de traitement des transactions dédiée, ce qui signifie qu'une application sur une appchain n'est pas en concurrence avec d'autres applications pour la capacité de traitement des transactions sur un réseau.

Par exemple, alors que des milliers d'applications différentes pourraient partager un ensemble standard de configurations sur une plateforme générique de smart contracts, chaque appchain dans un contexte de Proof of Stake pourrait facilement atteindre un débit de plus de 1000 Transactions Par Seconde (TPS), et toute cette capacité de traitement des transactions serait dédiée à une seule application.

Contrairement aux smart contracts, les appchains peuvent évoluer rapidement en toute légitimité. Chaque appchain est une économie autogérée avec des processus explicites codées en amont pour parvenir à des accords sur l’évolution du réseau. Et, grâce à Substrate, la fonction primaire de gouvernance du réseau est incluse et prête à être utilisée.

N'importe quelle cryptomonnaie peut reproduire le processus de gouvernance d'une autre par un copier-coller de code. La gouvernance de la blockchain elle-même pourrait évoluer comme un logiciel open-source.

Pourtant, personne ne peut ignorer que les smart contracts sont excellents pour les cas d'utilisation du commerce d'actifs, comme par exemple, la DeFi. Les smart contracts fonctionnant sur la base des mêmes mécanismes de fonctionnement et de sécurité, la composabilité entre eux est la recette essentielle de l'explosion de DeFi.

Toutefois, si l'expérience utilisateur de DeFi n'est pas aussi mauvaise que celle de la banque en ligne, elle peut largement encore être améliorée, surtout si l'on considère une blockchain de niveau 1 plus performante et fonctionnelle qu'Ethereum, comme NEAR Protocol.
 Pourquoi Octopus a-t-il choisi NEAR?
  Bien que Substrate et Cosmos SDK aient réduit le coût de développement des appchains à un niveau au moins comparable à celui des smart contracts, le démarrage d'une appchain reste une tâche techniquement complexe et coûteuse pour les développeurs.

Le protocole NEAR est une blockchain sharded proof-of-stake (PoS) qui met l'accent sur l'évolutivité et la convivialité. NEAR est souvent considéré comme une solution d'évolutivité prête à l'emploi pour les dApps Ethereum existantes, mais il est également capable de gérer une série d'autres types de solutions décentralisées, comme les appchains.

Par rapport à d'autres plateformes de niveau 1 qui peuvent également accueillir des appchains, comme Polkadot ou Cosmos, NEAR présente certains avantages techniques et économiques essentiels.

Par rapport à Cosmos, le lancement d'une appchain sur NEAR est plus facile parce que les validateurs ne doivent pas être déjà mis en route pour chaque appchain.

Par exemple, sur Cosmos, chaque appchain doit se sécuriser avec un ensemble de validateurs décentralisés et suffisamment jalonnés. Ainsi, les développeurs d'une appchain doivent d'abord obtenir la reconnaissance de la valeur du jeton natif de l'appchain sur les marchés des crypto-actifs, puis créer une communauté active de validateurs à partir de la base.

Par rapport à Polkadot, NEAR offre aux appchains un bail de sécurité nettement moins coûteux et ne fixe pas de limite au nombre d'appchains pouvant être lancées.

Une parachain Polkadot doit être en mesure de supporter le coût du consensus d'un emplacement du réseau, ce qui peut représenter des dizaines de millions de dollars par an.

Dans un système de computation, une sécurité plus élevée n'est pas nécessairement synonyme de meilleure sécurité, car un niveau de sécurité plus élevé s'accompagne toujours d'un niveau de coût plus élevé. Par conséquent, ce dont un système de computation a besoin, c'est d'une sécurité appropriée et adéquate aux besoins du projet.

Sur Polkadot, les développeurs n'ont pas la possibilité de décider d'un niveau de sécurité approprié et adéquat pour leur parachain. Ils n'ont qu'un seul choix : gagner un emplacement dans l'enchère. Mais même si un parachain remporte l'enchère, il paie généralement trop cher pour la sécurité, car un réseau de cryptomonnaies dans ses phases de lancement n'a pas besoin d'un niveau de sécurité de plusieurs milliards de dollars.

En outre, un coût de sécurité élevé dès le départ pourrait plonger un parachain dans l'hyperinflation, car il doit promettre d'émettre une quantité massive de jetons liés au Crowdloan. Ce fardeau économique laisse donc à une parachine très peu de marge de manœuvre pour inciter les véritables créateurs de valeur de son protocole, en l’occurence les participants qui aident à construire les effets de réseau de la cryptomonnaie.

Pour faire simple, NEAR a été choisi par Octopus plutôt que Polkadot et Cosmos parce qu'il est tout simplement plus rentable, évolutif, convivial et interopérable avec des réseaux comme Ethereum ainsi que toute autre solution L1 existante.

Nous pensons que les appchains seront la troisième vague d'innovation des crypto-réseaux qui nous mèneront au Web3.0 et que le réseau Octopus rendra les appchains accessibles à une myriade de projets avec toutes sortes de budgets.




	

	
	
		
			
				Qu’est ce qu’une appchain?
			
		

		
					

		
			
			
			
			Une application décentralisée
		
			
			Une blockchain classique
		
			
			Une blockchain spécifique à une application
		
			
			Un smart contract
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Les avantages du PoS loué (LPoS)

Qu'est-ce que la sécurité dans le contexte de la blockchain ?

En termes simples, la sécurité est le niveau de certitude que les protocoles prédéfinis seront appliqués dans l’utilisation réelle du réseau, que ce soit au niveau de la couche de base ou de la couche supplémentaire.

La sécurité des blockchains est généralement considérée comme une propriété quantifiable. Il ne peut y avoir de sécurité absolue ou illimitée. Si une blockchain avait une sécurité absolue, elle devrait être à la fois inutilisable et inabordable.

Comparé au modèle de sécurité partagée d'une parachain Polkadot, le PoS loué (LPoS) de l'appchain du Réseau Octopus est beaucoup plus évolutif et flexible. Parce que le leasing de sécurité est essentiellement un leasing de capitale ou un leasing de garantie, il évolue sans limites physiques.

 Dans Polkadot, chaque parachain accueillera un certain nombre de validateurs exclusivement sur une période donnée. L'algorithme de consensus limite la taille totale du réseau (c'est pourquoi le nombre total de parachains devrait être inférieur à 100 avec moins de 10 emplacements de parachain disponibles cette année).

Le PoS loué d'Octopus est beaucoup plus rentable que celui de Polkadot. Comme Octopus n'a pas sa propre blockchain et que le jeton $OCT est émis et géré par un smart contract, Octopus n'a pas besoin de payer directement les coûts du consensus. Ainsi, le taux d'inflation de $OCT pourrait être fixé à zéro, ce qui signifie que le taux d'intérêt de base du système économique d'Octopus est nul.

Lorsque le taux d'intérêt de base est de zéro, un rendement annuel de 3 % à 5 % constitue un rendement annuel décent (ce qui correspond à la fourchette que nous nous attendons à ce qu'une appchain paie pour son titre loué). En revanche, une parachain Polkadot doit payer 20% ou plus de rendement annuel pour être attractif vis-à-vis des investisseurs $DOT parce que le staking sur le relais Polkadot donnera aux investisseurs un rendement annuel sans risque de 14%.

Parce que le LPoS est une sécurité basée sur les besoins et qu'il offre aux appchains un levier rentable pour se développer, nous pensons que le LPoS est plus propice au développement à long terme des appchains que le PoS indépendant. Cependant, nous pensons également que le droit de choisir appartient toujours à la communauté des appchains.

Si une appchain sur le Réseau Octopus choisit d'arrêter d'utiliser le LPoS afin de se transformer en une blockchain PoS indépendante, Octopus s’engage à fournir les outils pour soutenir sa transformation. Sa connexion avec le Réseau Octopus sera alors rétrogradée à celle d'un pont IBC standard et les actifs cross-chain existants ne seront pas affectés.
Aperçu du Réseau Octopus


Légende: D-Délégateur, S- Staking, V- Validateur, RT - Runtime, N- Node

Le relais Octopus est situé au cœur du réseau Octopus. Le relais Octopus est un ensemble de smart contracts fonctionnant sur la blockchain NEAR (appelée mainchain) qui met en œuvre le marché du leasing de sécurité.

Les appchains Octopus se situent du côté de la demande du marché. Les appchains Octopus louent des titres aux détenteurs de $OCT en payant un loyer en jetons natifs. Chaque appchain peut choisir son propre modèle économique, y compris le nombre de jetons natifs qu'elle est prête à payer aux validateurs pour la sécurité.

Les validateurs et les délégateurs d'Octopus se situent du côté de l'offre du marché de la location de sécurité.

Les validateurs Octopus mettent en jeu des jetons $OCT pour valider une appchain particulière et mettre en place un node pour exécuter le protocole de cette appchain. En retour, les validateurs sont éligibles pour recevoir le jeton natif respectif de l'appchain qu'ils valident.

Les délégateurs Octopus peuvent déléguer leur $OCT aux validateurs pour une part des récompenses de staking du jeton natif d'une appchain. Les récompenses de staking sont distribuées aux délégateurs directement après que les validateurs ont perçu une commission unifiée.

Si les validateurs se comportent mal (par exemple, s'ils se déconnectent, attaquent le réseau ou exécutent un logiciel modifié), ils (et leurs délégateurs) sont sanctionnés en perdant un pourcentage de leurs $OCT investis. Toutes les punitions sont appliquées aux délégateurs proportionnellement à la perte de leurs validateurs. De cette façon, ce mécanisme agit comme une dissuasion pour les comportements malveillants.

Puisque les détenteurs de $OCT sont responsables de décider sur quelle appchain ils souhaitent miser, le Réseau Octopus fonctionne comme un marché libre où les appchains peuvent louer le niveau de sécurité dont ils ont besoin au prix du marché à tout moment.

Le Réseau Octopus dispose également d'une série d'outils pour les fournisseurs de sécurité, tels que des outils de gestion et de déploiement automatique des nodes du validateur d'appchain, des vues économiques du réseau et des outils d'analyse statistique.

Le marché LPoS du Réseau Octopus permet à tout développeur, projet ou entrepreneur de créer rapidement, efficacement et à moindre coût sa propre appchain sur NEAR.

Mais le Réseau Octopus soutient également les appchains de bien d'autres façons, notamment en fournissant une interopérabilité inter-chaînes, une infrastructure intégrée et une communauté prête à s'engager.




	

	
	
		
			
				Quels sont les avantages de la sécurité louée (LPoS)?
			
		

		
					

		
			
			
			
			La LPoS est peu coûteuse
		
			
			La LPoS est flexible
		
			
			La LPoS est évolutive
		
			
			Toutes les réponses sont justes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interopérabilité
Il est moins controversé aujourd'hui d'affirmer que toutes les blockchains publiques et les réseaux multichains finiront par être interconnectés, formant ainsi l'Internet des blockchains. Le réseau Octopus est spécifiquement conçu pour en faire partie.

L'équipe Octopus (précédemment connue sous le nom de Cdot) travaille depuis plus de deux ans sur le protocole universel d'interopérabilité des blockchains IBC et sur l'intégration inter-chaînes.

Le relais Octopus permet l'interopérabilité des appchains avec le protocole NEAR et Ethereum via le Rainbow Bridge. En outre, les appchains peuvent utiliser une palette IBC prête à l'emploi pour se connecter directement à n'importe quelle blockchain compatible IBC.

Tout actif émis sur Ethereum, NEAR ou toute blockchain compatible IBC peut être transféré et utilisé par les appchains Octopus en toute confiance. Inversement, tout actif émis sur les appchains peut être transféré en toute confiance vers Ethereum, NEAR et toute blockchain compatible IBC.

Grâce à l'interopérabilité transparente entre le réseau Octopus et NEAR, la variété des actifs cryptographiques émis sur les appchains Octopus contribuera également à la prospérité de l'écosystème DeFi de NEAR.
Infrastructure
Le Réseau Octopus fournit un ensemble complet d'infrastructures et d’outils pour les appchains avec notamment API Gateway, Blockchain Explorer, Archive Gateway, etc.

Le pont Octopus déploiera un contrat wrapper NEP-141 sur NEAR pour chaque token natif de l'appchain. Les portefeuilles et les plateformes d’échanges pourront alors intégrer des tokens wrapper standard plutôt que de devoir s'intégrer individuellement à chaque appchain.

Ainsi, les équipes d'appchain n'ont qu'à se concentrer sur l'exécution du Substrate et le développement du front-end, tandis que le Réseau Octopus s'occupe de toutes les autres nécessités techniques.
Communauté
         Un réseau de cryptomonnaies appartient à sa communauté. C'est l'essence de la décentralisation et la différence fondamentale avec les plateformes du Web2.0.

Le Réseau Octopus agit comme une méta-communauté pour nourrir des centaines de communautés d'applications Web3.0. Les développeurs d'applications Web3.0 et les fondateurs d'appchains peuvent faire valoir les mérites de leur cryptomonnaie pour attirer une variété de partisans, tels que des investisseurs, des validateurs, des délégateurs et des participants au protocole.

Les utilisateurs intéressés par différentes applications Web3.0 prêteront attention à leurs applications préférées par le biais d'événements tels que les lancements de nouvelles appchains. 
De cette façon, Octopus est une base communautaire pour les appchains afin de soutenir leur propre parcours de construction de communautés.

Le Réseau Octopus fournit également une grande capacité de forkabilité à toutes ses appchains, ce qui rend impossible pour tout type personnes malveillante de prendre le contrôle d'une appchain sans l'accord de la communauté, ce qui a pour finalité le maintien de la décentralisation. Octopus offrira la forkabilité à toutes ses appchains en archivant l'historique des blocs de l'appchain sur Arweave, un protocole de stockage permanent décentralisé.

Sur la base de l'historique des blocs archivés, chaque appchain peut être divisée à tout moment pour devenir une nouvelle appchain si sa communauté soutient le forkage. Et toute équipe d'appchain est remplaçable si elle perd la confiance de sa communauté. C'est ainsi que la sensibilisation des utilisateurs garantit la décentralisation des appchains.
Qu'est-ce que le programme Octopus Incubateur ?
 



L'équipe d'Octopus est bien consciente que l'espace blockchain n'est encore qu'une infime partie de l'ensemble de l'industrie Internet. Et au sein de l'espace blockchain, les développeurs de contrats intelligents Solidity sont beaucoup plus prolifiques que les développeurs Substrate.

Afin de trouver et d'attirer des projets appchain prometteurs, la première tâche consiste à transformer les développeurs Web et Solidity en développeurs Substrate. À cet égard, l'équipe Octopus est très expérimentée.

L'équipe Octopus a construit avec succès IBC pour Substrate et a également proposé des cours de formation en ligne sur Substrate en Chine avec d'autres passionnés de Substrate. Ces cours ont formé le premier groupe de développeurs Substrate en Chine, initiant ainsi la genèse de la communauté Substrate chinoise. Les développeurs d'Octopus sont également les organisateurs de la communauté Rust en Chine (notamment la RustCon).

À ce jour, de nombreux membres de l'équipe Octopus ont servi d'assistants d'enseignement pour le cours, qui est maintenant un cours officiel financé par Parity, Inc. Sur la base de ces expériences, nous sommes en train de négocier avec des partenaires du monde entier, y compris l'équipe éducative de NEAR, pour offrir des cours de formation similaires dans le monde entier.

Mais Octopus reconnaît que les développeurs qualifiés de Substrate ne sont pas tout ce dont les projets d'application Web3.0 ont besoin pour réussir. C'est pourquoi nous lançons le programme Octopus Incubateur, une collection de cours et de séminaires ouverts et composables, accessibles aux développeurs Substrate et aux équipes Web3.0 du monde entier.

Chaque trimestre, le programme Octopus Incubateur organisera une série de cours d'une durée de dix semaines. Au cours de chaque période de cours, les sujets proposés incluront des thèmes tels que les tokenomics, la conception de produits Web3.0, la création de communautés, la gouvernance des blockchains, la réglementation des cryptomonnaies et la collecte de fonds pour les projets de cryptomonnaies. Des experts invités participeront aux séminaires, fourniront des vidéos sur des sujets spécifiques et seront disponibles en tant que mentors.

À la fin de chaque lot de cours, la Fondation Octopus organisera un événement Demo Day pour sélectionner les cinq meilleurs projets appchain et leur offrir une récompense totale allant jusqu'à 200 000 $OCT.

De cette façon, la Fondation Octopus financera directement 20 projets appchain par le biais du programme d'incubation Octopus chaque année, leur accordant plus d'un million de $OCT au total.




	

	
	
		
			
				Quelles affirmations concernant l’équipe d’Octopus Network sont justes?
			
		

		
					

		
			
			
			
			L’équipe d’Octopus Network a développé IBC pour Substrate
		
			
			L’équipe d’Octopus Network a formé les premiers développeurs Substrate en Chine
		
			
			L’équipe d’Octopus Network était précédemment connue sous le nom de Cdot
		
			
			Toutes les réponses sont justes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment les Appchains sont-elles lancées sur le Réseau Octopus?


’architecture du réseau Octopus, associée à la puissance de traitement de NEAR, permet d'héberger facilement des centaines d'appchains. Le processus de sélection des appchains fait partie du protocole Octopus et le pouvoir de décision appartient à la communauté Octopus.

En plus d'être les validateurs et les délégateurs de l'appchain, les détenteurs de jetons $OCT ont le droit de sélectionner les meilleurs projets d'appchain en votant à la hausse ou à la baisse dans une file d'attente de candidats sur la chaîne.

Les chaînes basées sur Substrate peuvent devenir des appchains Octopus en franchissant avec succès les étapes suivantes :

 	     Inscription
 	     Audit
 	     Vote
 	     Mise en scène
 	     Démarrage

Étape d'inscription
 Toute chaîne basée sur Substrate peut demander à devenir une appchain Octopus. L'enregistrement nécessite un livre blanc (whitepaper) ou un descriptif du projet, ainsi qu’une version d'exécution qui a été testée et auditée en interne. Pour éviter les abus, l'enregistrement nécessite un petit dépôt de $OCT.
Phase d'audit
Une fois l'appchain enregistrée, les membres du groupe de travail de la communauté l'auditeront. L'objectif de l'audit est de s'assurer que l'appchain ne présente aucune faille de sécurité connue et que sa logique d'application est conforme à son livre blanc ou à son descriptif.

L'audit d'appchain est actuellement un besoin non résolu dans la sphère blockchain. Seules quelques entreprises du secteur ont l'expérience requise et les services qu'elles proposent sont coûteux.

L'audit réalisé par le Réseau Octopus réduit non seulement considérablement le coût du lancement d'une appchain pour ses fondateurs, mais contribue également à l'accumulation de connaissances et de capacités professionnelles pertinentes.
Phase de vote
Une fois qu'une appchain a passé la phase d'audit, elle entre dans la file d'attente des candidats où elle sera votée à la hausse ou à la baisse par les détenteurs de $OCT.

Au cours d'une période de roulement qui dure une à deux semaines, l'appchain qui se classe première avec le plus grand nombre de votes positifs moins les votes négatifs dans la file d'attente entrera dans l'état de préparation en tant qu'appchain la plus soutenue par la communauté Octopus.
Phase de préparation
Au cours de la phase de préparation, les détenteurs de $OCT peuvent miser ou déléguer sur l'appchain.

À la fin de la période de préparation, si l'appchain a attiré suffisamment de staking au-delà du minimum de fonds de sécurité, elle entrera dans la phase de lancement.
Phase de lancement
Dans la phase de lancement, les membres du groupe de travail exécuteront 4 nodes de lancement pour démarrer l'appchain. Ensuite, les validateurs devront exécuter leurs nodes pour rejoindre le consensus de l'appchain.

Le Réseau Octopus fera également tourner un ensemble complet de nodes pour chaque appchain et fournira des services d'accès API au front-end de l'appchain. Les développeurs d'appchain n'auront plus qu'à mettre à jour la configuration du front-end, et l'appchain sera prête pour les utilisateurs finaux.
Récompenses Appchain
Octopus reconnaît que les projets appchain sont les créateurs de valeur du réseau. Alors que d'autres réseaux multichaînes font payer des droits d'entrée pour les appchains, Octopus considère que les équipes appchain sont la partie la plus importante de la communauté et est très heureux de partager avec elles les avantages de l'expansion du réseau.

Par conséquent, les 100 premières appchains Octopus lancées seront directement récompensées par 100k $OCT.

En outre, la fondation a décidé d'offrir une récompense supplémentaire de 1 million de dollars aux dix premières appchains afin de les reconnaître en tant qu'appchains fondatrices.
Qu'est-ce que le jeton $OCT?
$OCT, le jeton natif du Réseau Octopus, est un jeton fongible et non-inflationniste avec trois utilités principales :

 	     Collatéral pour garantir la sécurité de l'appchain
 	     Gouvernance
 	     Approuver les candidats de l'appchain en les votant dans la file d'attente des candidats.

Garantie de sécurité
Le $OCT joue un rôle clé dans le Réseau Octopus grâce au staking de l'appchain. Les détenteurs mettent en jeu leurs $OCT pour garantir la sécurité des appchains auxquelles ils croient afin de gagner des récompenses en jetons natifs des appchains respectives.

La mise en gage de $OCT a également un effet dissuasif sur les participants malveillants qui seraient pénalisés par la réduction de leur $OCT, qui est la source de sécurité louée pour les appchains Octopus.

Lorsqu'Octopus fonctionnera à pleine capacité, 30 à 50 appchains seront lancées sur le réseau chaque année.

Si le taux de rendement à long terme du staking des appchains est de 5 % par an, les appchains nouvellement lancées rapporteront à elles seules environ 400 millions de dollars chaque année.
Governance
La deuxième fonction de $OCT est de permettre aux détenteurs de contrôler la gouvernance du réseau, (plus précisément, le relais Octopus où toutes les règles économiques s'appliquent,) en formant la DAO (organisation autonome décentralisée) Octopus.

Le conseil de la DAO Octopus a un maximum de 100 membres, mais il est plus probable qu'il passe de quelques membres au début à quelques dizaines lorsqu'il sera stable.

Le pouvoir de gouvernance de chaque membre du conseil est précieux mais suffisamment dispersé pour éviter toute collusion.

À notre avis, dans la plupart des cas, la valeur de gouvernance d'un jeton ne peut être découplée de sa valeur utilitaire. Une gouvernance solide et largement partagée donnera aux détenteurs de jetons des attentes de valeur plus stables et supprimera les fluctuations extrêmes du prix du jeton, réduisant ainsi le coût du staking d'appchain.
Vote des appchains
La troisième fonction de $OCT par l'intermédiaire des détenteurs de $OCT est la sélection des appchains qui vont être lancées dans le réseau en votant à la hausse ou à la baisse sur les différentes appchains candidates.

Les équipes d'appchain devront convaincre la communauté Octopus que leur application Web3.0 est significative et créera des appréciations de la valeur au fil du temps pour les investisseurs qui misent $OCT sur leurs appchains.

Les détenteurs de $OCT choisiront soigneusement les appchains qu'ils soutiennent, car il y a un risque de manquer celles qui pourraient apporter un plus grand retour sur investissement.
Conclusion
Nous avons baptisé le réseau Octopus du nom de la créature sous-marine la plus redoutablement intelligente. Du point de vue de l'évolution, la pieuvre, qui compte quelque 300 espèces, est un organisme incroyablement performant. Elle existe depuis 155 millions d'années, vit dans tous les océans et ses nombreuses espèces se sont adaptées avec succès à un large éventail d'habitats marins divers.

Nous nous attendons à ce que le Réseau Octopus fournisse des applications décentralisées pour chaque industrie en ligne que l'intermédiaire traditionnel du Web2.0 a contrôlé jusqu'à présent, et qu'il restitue la valeur aux véritables créateurs.

Dans le Réseau Octopus, nous pouvons construire des applications Web3.0 avec une grande expérience utilisateur en tirant parti de la technologie appchain, que ce soit dans les jeux, les NFT, les DAO, la publicité, l'économie des créateurs (vidéo, audio, graphiques, texte), les marchés prédictifs, le registre des jetons (TCR), et plus encore.

La troisième vague d'innovation des crypto-réseaux est en train de déferler sur le dos du Réseau Octopus, apportant avec elle le potentiel d'un tsunami d'innovations décentralisées du Web3.0, limité seulement par l'imagination.

### Краткий обзор платформы DeBio

Децентрализованное биомедицинское решение в сети Octopus
Нынешняя биомедицинская система не работает. Статус-кво не позволяет пациентам свободно получать доступ к своим данным, а поставщики медицинских услуг не могут гарантировать безопасность данных своих пациентов. Сеть DeBio стремится изменить это. 
Что такое сеть DeBio?
DeBio  — это децентрализованная анонимная платформа для медицины и биоинформатики, специализирующаяся на геномном тестировании. DeBio стремится произвести революцию в современной биомедицинской отрасли, предоставляя пациентам полный доступ к своим данным с использованием самых передовых технологий блокчейна. 

Внедрение блокчейна в текущую технологическую экосистему играет большую роль в стремлении к децентрализованным глобальным финансам, но варианты использования, предлагаемые блокчейном, выходят за рамки только финансовой сферы. DeBio убеждена, что будущее медицинских данных, частично зависит от использования блокчейна, особенно в специализации вариантов использования технологий, а также в функциональной совместимости. 
Централизованное генетическое тестирование представляет собой риск для конфиденциальности.
За последние несколько лет популярность генетического тестирования резко возросла. В результате этого увеличилось  количество  пользователей  платформ генетического тестирования, ориентированных непосредственно на заказчика, таких как 23andMe и AncestryDNA. Но, к сожалению,   многие пользователи не осознавали , что использование этих платформ представляет явный риск для конфиденциальности их  данных. 

Основные платформы генетического тестирования, ориентированные непосредственно на заказчика, централизованы, что делает их легкой мишенью для утечек данных. В 2020 году только в США произошла в общей сложности   1001 утечка данных. По сообщению Govtech, основной удар приходится на отрасль здравоохранения. 

Еще более тревожным является тот факт, что генетические данные не уникальны для одного человека, а уникальны для генетического древа человека. Используя централизованный сервис биоинформатики, вы подвергаете риску не только свою конфиденциальность, но и конфиденциальность ваших дальних родственников. 

Вред от этого однозначный, ведь есть вероятность, что на ваше решение могут повлиять ваши дальние родственники, например, троюродный брат. Тревожной является мысль о том, что дальний родственник, о существовании которого вы даже не подозреваете, проходит генетический тест и прослеживает его генетические данные до вас. Генетические данные можно отследить до вас,  даже с небольшим количеством информации, такой как возраст и статус. Этот тип информации может быть использован против вас страховыми компаниями, чтобы максимально использовать персональные данные своих  клиентов. 
Концепция сети DeBio
Основная концепция DeBio основана на стремлении увеличить количество биомедицинских и генетических тестов для заказчиков,  без ущерба для их конфиденциальности. Но DeBio также хочет стимулировать исследования в области генетики, предлагая сотрудничество между независимыми лабораториями. 
Физико-цифровой мост для анонимного тестирования
Заказчики  могут выбрать широкий спектр исследований  и лабораторных рекомендаций на рынке генетического тестирования DeBio. После того, как заказчик определился с видом исследования, ему нужно будет взять только два образца ДНК (методом буккального мазка или взять образцы клеток эпителия  ротовой полости  с помощью ватных палочек). 

Затем заказчик отправляет образец ДНК в лабораторию в конверте, при этом единственной идентифицируемой информацией, написанной на конверте, является идентификатор генетического отслеживания образца. Лаборатории не могут идентифицировать образцы без идентификатора отслеживания, потому что в целях анонимности DeBio не будет собирать личную информацию любого рода, что делает образцы ДНК недоступными для заказчиков. 

Затем результаты (например, тест и геном) шифруются с помощью открытого ключа заказчика полученного из блокчейна DeBio, и сохраняются, а затем загружаются в децентрализованное хранилище. Это позволяет заказчикам сохранять полную безопасность своих зашифрованных данных  — и только заказчики  должны иметь свои закрытые ключи для расшифровки результатов. 

Команда DeBio Network расширяет эту концепцию «физико-цифрового моста», чтобы использовать случаи за пределами рынка генетического тестирования , которые могут включать лабораторное тестирование на заболевания и другие данные электронных медицинских карт или личную информацию о здоровье. 
Sovereign Lab Collaboration предлагает совместные продукты, объединяющие услуги нескольких лабораторий
После того, как заказчик отправит образец ДНК в лабораторию, лаборатория будет уведомлена об этом. Когда образец прибудет, то лаборатория начнет секвенирование физических образцов или другие  исследования на биомаркеры. После завершения последующих тестов, лаборатория зашифрует результаты с помощью открытого ключа заказчика  и загрузит их в децентрализованное хранилище. 

Результаты не могут быть расшифрованы без использования закрытого ключа заказчика, поэтому конфиденциальность результатов био-медицинского тестирования обеспечена. Однако, чтобы еще больше стимулировать генетическое тестирование, заказчики предпочитают передавать свои данные генетического тестирования для расшифровки  другими лабораториями. 

Целью независимых лабораторий является повышение доступности исследований и создание совместных исследований, за счет интеграции услуг нескольких лабораторий. Это также позволяет DeBio масштабироваться, потому что лаборатории не должны быть централизованы и это  позволяет участвовать нескольким автономным генетическим учреждениям. 




	

	
	
		
			
				Тест: какую проблему намерена решить платформа DeBio?
			
		

		
					

		
			
			
			
			проблемы конфиденциальности среди онлайн-платформ генетического тестирования 
		
			
			препятствия в независимых лабораториях для выполнения своей работы 
		
			
			отсутствие исследований в области геномики
		
			
			дорогое здравоохранение 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Технологии платформы DeBio
Биоинформатика и биомедицинские экосистемы предъявляют уникальные требования к тому, как они должны быть доступны для специалистов, проводящих исследования, и при этом быть достаточно безопасными для защиты конфиденциальности данных пациента. Таким образом, чтобы гарантировать суверенитет пациентов над своими данными, весь технологический процесс состоит из децентрализованных решений, начиная от децентрализованной аутентификации и заканчивая децентрализованным хранилищем файлов. 



Иллюстрация заимствована  из технической документации DeBio

DeBio внедрила в решение множество передовых технологий включая: 

 	Substrate
 	протокол KILT
 	сеть Octopus 
 	IPFS
 	протокол Ocean

Substrate
Первая заметная технология — это Substrate. Substrate — это фреймворк токена Polkadot, позволяющая разработчикам создавать целенаправленные блокчейны. Основные сервисы будут построены с использованием Substrate, что сделает их основными строительными блоками. DeBio выбрал Substrate по двум следующим причинам: 

 	Функциональная совместимость блокчейна (по сути, возможность взаимодействовать между различными блокчейнами).
 	Безопасность цепочки ретрансляции (применяя более строгие стандарты безопасности цепочки ретрансляции хоста). 

Помимо того, что блокчейны могут взаимодействовать друг с другом, функция взаимодействия также обеспечивает соблюдение стандарта безопасности, который будет унаследован каждой пара-цепочкой, подключенной к основной цепочке ретрансляции. В результате повышается безопасность блокчейна DeBio за счет соблюдения стандартов соответствующей цепочки ретрансляции. 
Протокол KILT
Следующим по значимости  будет протокол KILT. KILT — это протокол для анонимного создания, подтверждения и проверки личности в Web3. Чтобы пройти аутентификацию, каждый пользователь должен создать утверждение, которое затем будет отправлено доверенному лицу, подтверждающему его. 

Подтвердитель несет ответственность за сертификацию заявления пользователя, которое затем преобразуется в хэш для сохранения в блокчейне KILT. Заявка пользователя иногда содержит конфиденциальные данные о пользователе, но, поскольку хэш нельзя преобразовать обратно в заявку пользователя, то конфиденциальность пользователя гарантируется. 

После получения сертификата от доверенного аттестатора пользователь теперь может использовать свои утверждения в приложениях, использующих KILT, и доверяет вышеупомянутому аттестатору. KILT — это конфиденциальность. Приложениям, которые будут проверять заявление, не нужно проходить через аттестатора, и они будут напрямую сравнивать утверждение с тем, которое хранится в блокчейне KILT, отключая аттестатора от процесса проверки и делая его полностью децентрализованным. Протокол KILT предлагает решение, которое предотвращает концентрацию данных в одном объекте. Это обеспечивает суверенитет данных для тех, кто заботится о конфиденциальности. DeBio сотрудничает с KILT для внедрения децентрализованной системы аутентификации, потому что она идеально подходит для варианта использования DeBio с приоритетом на анонимность. 
Сеть Octopus
Octopus — это криптосеть для запуска и работы блокчейнов, специфичных для приложений Web3, за небольшую часть стоимости. Одним из соображений использования Octopus выделяется тем, что по сравнению с Polkadot они предлагают значительно более бюджетную  аренду безопасности и сопоставимые возможности кроссчейна. Octopus поддерживается протоколом NEAR. NEAR — это высокопроизводительный блокчейн, предназначенный для решения проблемы масштабируемости и повышения производительности разработчиков за счет упрощения процесса разработки и создания удобной для разработчиков среды. DeBio уже сотрудничает с Octopus и станет одной из первых пяти блокчейнов для конкретных приложений (цепочек приложений), запущенных в сети Octopus. DeBio также уже является частью Octopus Guild, сообщества разработчиков приложений в сети Octopus. 
The InterPlanetary File System (IPFS)
(IPFS) — это протокол, предназначенный для полностью децентрализованного обмена данными и их хранения в одноранговой сети. IPFS был создан как решение для децентрализованных проектов, которые хотят хранить данные, объем которых слишком большой для хранения в самой цепочке блоков. IPFS создает уникальные адреса контента, проводя хэш самого контента. Каждый уникальный контент будет иметь свой адрес, указывающий на его местоположение. DeBio добавляет IPFS для хранения биомедицинских данных, таких как зашифрованные геномы человека и зашифрованные электронные медицинские записи. 
Протокол Ocean
Протокол Ocean создан для безопасного использования информационных активов с сохранением конфиденциальности. Он делает это с помощью функции вычисления в данных и позволяет монетизировать данные, даже не покидая помещения владельца. Рынок данных Ocean Protocol с открытым исходным кодом под названием Ocean Market можно разветвить; команда DeBio Network будет использовать Ocean для сбора биомедицинских данных. 
Конфиденциальность вычислений
Для стейкинга биомедицинских данных DeBio будет размещать анонимные биомедицинские данные в своем частном хранилище данных. Этот процесс не включает вышеупомянутую IPFS, поскольку хранилище данных будет полностью отделено от IPFS. Пользователям, которые хотят передать свои данные, необходимо будет расшифровать и загрузить свои биомедицинские данные в свое частное хранилище данных. Хотя передача расшифрованных биомедицинских данных в частное хранилище данных звучит страшно, DeBio реализует концепции конфиденциальных вычислений в хранилище данных, чтобы гарантировать вашу конфиденциальность. 



Иллюстрация заимствована из технической документации DeBio

Только после согласия пользователя наборы данных объединяются через прокси-сервер Ocean для обработки данных, и третья сторона сможет создавать аналитику и обрабатывать данные все время, пока они остаются на месте. 

Стимулируя пользователей делиться своими геномными/биомедицинскими данными и надеясь, что это будет способствовать дальнейшим исследованиям в этой области. Кроме того, частное хранилище данных не будет собирать личную информацию, поэтому вам не нужно беспокоиться о том, что ваши образцы могут быть отслежены до вас.

Панду Састровардойо, генеральный директор DeBio, заявила, что одной из причин, по которой она создала DeBio, является помощь в развитии генетических исследований путем создания полностью анонимного рынка генетических данных. «DeBio — это совершенно новая экономическая система для геномики , обеспечивающая генетический суверенитет, гарантирующая участие небольших лабораторий и стимулирующая генетические исследования. Все сделано на основе модели, подобной DeFi, которая полностью децентрализована», — сказала Панду. 




	

	
	
		
			
				Тест: где DeBio хранит данные ?
			
		

		
					

		
			
			
			
			внутри блокчейна DeBio 
		
			
			внутри токенов
		
			
			в частном хранилище данных 
		
			
			в IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Техническая архитектура уровней
Наша техническая архитектура состоит из четырех уровней: основной инфраструктуры блокчейна, уровня транспорта и общей бизнес-логики и, наконец, уровня бизнес-логики верхнего уровня. 

Техническая архитектура DeBio. Иллюстрация заимствована из технической документации DeBio
Уровень 1: инфраструктура блокчейна
Первый уровень будет содержать основные службы. Они построены на основе Substrate, Octopus и IPFS. Субстрат является основным строительным блоком для службы блокчейна. Для сохранения больших файлов DeBio будет использовать IPFS и вместо этого сохранять адрес содержимого внутри Substrate. Наконец, вся цепочка приложений будет связана с цепочкой реле Octopus. 
Уровень 2 и 3: уровень транспорта и общей бизнес-логики
Второй и третий уровни содержат транспортную и общую бизнес-логику. Эти уровни отвечают за предоставление данных непосредственно пользователям. Каждый поддон содержит базовую бизнес-логику, для взаимодействия с блокчейном, и будет служить уровнем абстракции (от четвертого уровня для связи с сервисами Substrate на первом уровне). 
Уровень 4: уровень бизнес-логики верхнего уровня
Четвертый уровень будет состоять из пользовательского интерфейса DeBio и Metamask. Все взаимодействие между пользователями и блокчейном будет осуществляться с четвертого уровня. Все запросы также будут определяться с верхнего уровня и затем обрабатываться на всех ранее упомянутых слоях. Для финансирования каждой транзакции пользователи могут использовать Metamask для оплаты стейблкоином ERC20. В этом случае DeBio будет использовать DAI. 
Токен модель


Иллюстрация заимствована из технической документации DeBio

Команда DeBio Network намерена выпустить шесть токенов:

 	Награды за транзакции в основной сети и токен валидатора ($DBIO)
 	Токен управления ($GBIO)
 	Токен данных геномики ($GENE, Ocean Protocol)
 	Токен биомедицинских данных ($MED, Ocean Protocol)
 	Токен данных электронных медицинских записей ($EMR, Ocean Protocol)

Mainnet Coin (стэйблкоин и т. д.)
Монета основной сети будет обеспечена стейблкоином. DeBio решил использовать стейблкоин, потому что данная криптовалюта стабильна для транзакций и сборов на бирже, связанных с работой, выполняемой соответствующими лабораториями. DeBio планирует использовать $DAI в качестве стэйблкоина. 
Токен управления ($GBIO)
Токены управления будут использоваться в основном для голосования зарегистрированными лабораториями. DeBio Network — это децентрализованная организация, поэтому для голосования на рынке DAOGenics необходима схема управления. Кроме того, токен управления также может служить методом адаптации лаборатории. 
Токены данных ($GENE, $MED и $EMR)
Эти токены используются в качестве транзакций на рынке данных. При размещении биомедицинских данных на торговой площадке Ocean потребители будут вознаграждены токенами данных, которые можно конвертировать в $OCEAN.
Валидатор и вознаграждение за транзакции ($DBIO)
Токен валидатора используется для поощрения владельцев узлов к проверке транзакций и защите dApp от неавторизованных пользователей. Предлагаемые стимулы, предусмотренные для валидаторов, — это вознаграждения LP и токенами управления. 
Транзакции пользователей в сети DeBio
$DAI — это стейблкоин основной сети, используемая для транзакций на платформе DeBio. Пользователи  могут использовать монету основной сети для оплаты продуктов и услуг. Продукты, которые будут доступны на рынке, включают продукты для геномного тестирования, продукты для биомедицинского тестирования и суверенную службу хранения электронных медицинских карт (EMR). 



Иллюстрация заимствована из технической документации DeBio
Вознаграждения за транзакции
Каждая транзакция, совершенная пользователем, будет вознаграждена токеном валидатора, а точнее токеном $DBIO. Цена одного токена $DBIO определяется рынком данных DeBio Network, на котором хранятся геномные данные потребителей, доступные для размещения.
Размещение данных в сети DeBio
После покупки продукта на торговой площадке пользователи могут поставить свои результаты на Ocean Marketplace. Данные, размещаемые пользователями, будут классифицироваться как токены данных, называемые $GENE, $MED и $EMR для геномных данных, биомедицинских данных и электронных медицинских карт (EMR), соответственно. Токены данных будут храниться в сети DeBio и агрегироваться на рынке данных через протокол Ocean Protocol в виде токена ERC20. Поскольку геномные данные, биомедицинские данные или сами EMR слишком велики для сохранения в токенах данных ERC20, токены данных будут в первую очередь служить указателем/ссылкой на соответствующие данные. 

Пользователи, размещающие свои токены данных, будут играть роль «поставщика данных» на рынке данных. Все транзакции на рынке данных Ocean будут использовать токены $OCEAN. Таким образом, если транзакция пройдет успешно, покупатель обменяет токены $OCEAN на токены данных ($GENE, $EMR или $MED). Принимая во внимание, что «поставщик данных» получит последующие токены $OCEAN. 



Иллюстрация заимствована из технической документации DeBio

Если покупатель данных хочет получить доступ к данным, связанным с токеном данных, ему необходимо заранее отправить токен данных поставщику данных. В результате у поставщика данных будет и токен $OCEAN, и токены данных, а покупателю данных будут отправлены данные, связанные с токеном данных. 



Иллюстрация заимствована из технической документации DeBio

И наоборот, токены данных ($GENE, $MED или $EMR), полученные Фондом DAOGenics, будут конвертированы в токены $OCEAN. Через определенный период токен $OCEAN, полученный DAOGenics Foundation, будет преобразован в токен $DBIO посредством смарт-контракта без разрешения. 

В результате DAOGenics Foundation всегда будет выкупать токен $DBIO через смарт-контракт без разрешения на основе объема транзакций, проводимых на рынке данных. Увеличение количества транзакций на рынке данных увеличит спрос на токен $DBIO. 




	

	
	
		
			
				Тест: что вы получаете размещая данные на рынке данных DeBio Network? 
			
		

		
					

		
			
			
			
			$DAI
		
			
			$GBIO
		
			
			$DBIO 
		
			
			$OCEAN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Вывод
Есть много преимуществ проведения генетического тестирования. Впервые в истории человечества люди смогли определить и изучить свой образ жизни, чтобы добиться долголетия; преимущество такого знания поразительно. Но в тоже время, как генетическое тестирование имеет свои замечательные преимущества, без надлежащих правил и стандартов, оно также имеет и  свои недостатки. Без гарантии конфиденциальности и безопасности ваших генетических данных это может вызвать проблемы в будущем. 

DeBio стремится решить проблему, пока не стало слишком поздно. DeBio создает децентрализованную платформу для ваших личных медицинских нужд, начиная с генетики. Наша концепция обеспечивает синергию между лабораториями всех масштабов, гарантируя при этом анонимность и суверенитет пользователей на каждом этапе рабочего процесса геномных данных — от сбора образцов, хранения данных до создания отчетов. 

Некoторые люди могут сказать, что наша ДНК — это самое личное, что у нас есть, и мы относимся к этому очень серьезно. Генетическое тестирование, ориентированное на анонимность, должно стать приоритетом для всех компаний. 

Будущее уже здесь, DeBio создает решения, которые произведут революцию в сфере здравоохранения и генетического тестирования. Вы готовы изменить мир вместе с нами? 

Адаптировано из оригинальной статьи на Medium. 

 

### Crypto Hero, NEAR игра

Что представляет из себя Crypto Hero?

Crypto Hero — это игра на основе блокчейна, в основном ориентированная на PvE, где вы можете проходить подземелья и обмениваться предметами с другими игроками,  играть с друзьями в рейдовой системе. В рейдах вы можете еженедельно зарабатывать призы Pixel Token.

Идея создания данной игры навеяна  ​​традиционными  играми, а также  ролевыми играми, такими как Diablo.



Crypto Hero пытается реализовать механику  этих игр простым способом, обеспечить упрощенный опыт, когда игроки могут развивать своих персонажей, соревноваться с другими и, самое главное, зарабатывать.

Игра содержит 5 основных элементов, которые я перечислю ниже.

Почему вам стоит попробовать Crypto Hero?

Crypto Hero — это вторая игра от PixelDapps. PixelDapps — команда, которая успешно создает игры на блокчейне, в которых игроки находят возможности зарабатывать призы, играя. Pixel Token стабилен и растет, и именно сейчас   оптимальный  момент  для ранних инвестиций.

Crypto Hero — это весело. Игра создает систему прогресса от ролевых игр до совершенно нового уровня с предметами NFT, которые можно коллекционировать и продавать в сообществе. Сообщество развивает идеи и устремления в экосистеме.

Как играть в Crypto Hero?

Crypto Hero Rules

Когда можно начать играть в Crypto Hero?

Релиз в MainNet состоялся 22 января.

Where can I play Crypto Hero?

Где я могу начать играть в Crypto Hero?

Играть в Crypto Hero

5 основных элементов игры

 	Аукцион

Предметы можно продавать на аукционе с помощью Pixel Token.

Вы можете фильтровать предметы по цене, а также различные типы предметов для облегчения поиска.



 

 	 The Items

Ваш герой может экипировать до 6 различных предметов: оружие, доспехи, сапоги, ожерелье, кольца и шлемы.

Предметы определяются по степени редкости: обычные, редкие, эпические и легендарные.

Предметы могут выпадать при прохождении подземелий, чем сложнее уровень подземелья, тем лучше выпадает предмет.

Предметы способны  сделать  вашего героя сильнее.



 	Герои

У вашего героя есть HP(здоровье), уровень и опыт.

Уровень вашего героя повышается, когда вы набираете достаточно опыта.

Чем выше уровень вашего героя, тем сильнее он становится.



 	Подземелья

Вы можете отправить своего героя исследовать подземелье, где он столкнется с ордой монстров.

Вы можете выбрать сложность подземелья, более сложные уровни дают лучшую добычу и опыт, но становятся значительно  сложнее.

Как только вы пройдете подземелье, вы будете вознаграждены добычей и опытом. Для следующего входа в подземелье вам нужно будет подождать некоторое время.



 	Таблица лидеров

Рейтинговая таблица отображает самые высокие уровни персонажей + уровни предметов в игре. Она создает соревновательный сценарий между игроками.



 	Рейды

Система рейдов — это своеобразный стимул  для общения игроков друг с другом, а также основная часть заработка в игре. Вы можете объединиться с другими 7 игроками, чтобы сражаться с боссами, у которых разная рейтинговая сложность и разные награды.

### What is web3?

The NEAR Protocol is a decentralized development platform that aims to build a healthy Web3 ecosystem via its scalable, easy-to-use platform. Today, let’s understand the implications of Web3 and what it can potentially do to the ecosystem.
The Need For web3

Image Credit
Web 1.0 was pioneered by Berners-Lee in 1990, and it has since become the foundation of the internet as we know it today. Here are some of the core pillars of Web 1.0:

 	HTML or HyperText Markup Language, which is the formatting language of the web.
 	URL or Uniform Resource Locator – a unique address to identify a resource on the web.
 	HTTP or HyperText Transfer Protocol allows you to retrieve resources across the web.

While this stage was truly groundbreaking, the web pages were very static and pretty different from the professionally designed websites we are used to today. In addition, while the web pages were far from interactive, new concepts like “email” would become a significant part of our lives in the future.

Over the last couple of decades, we have seen the rise of Web 2.0. Websites are now more interactive than ever before. However, that’s barely scratching the surface. Think of the companies that made it big in the last couple of decades. Meta, TikTok, Airbnb, Uber, etc. What’s the one common thing that ties them together? They thrive on user-generated content or resources. In essence, that was the major breakthrough that we saw during this era. One can only achieve true scalability by empowering your users to participate actively within your ecosystem.

However, Web 2.0 thrived solely on centralization. Don’t believe us? Think about the number of congressional hearings that the CEOs of Google, Meta, and Twitter had to go through to explain what all they do with user data. Meta, in particular, was guilty of misappropriating user data. In fact, the user data that they sold off to Cambridge Analytica were the very foundation upon which the US presidential campaigns were run.
So what is web3?
The next iteration of the web and the internet will be web3, which will be built upon certain core principles. Let’s go through them one-by-one.

Decentralization

One can safely say that decentralization is the core principle of the Web3 revolution. The idea is that there will be no central authority or centralized board of directors anymore that are controlling the company growth and narrative. In today’s world, platform censorship has become a significant issue. It seems like unless you are following a particular political ideology, your thoughts will eventually get deleted from the social media platform. Companies deliberately make specific profiles “hard to find” to reduce the spread of certain ideologies. Twitter has openly admitted that they tend to censor right wing profiles. Web3's main building block will be censorship resistance brought forward by decentralization.

Trustlessness

This is pretty much an extension of the decentralization point. In Web 2.0, you would have to trust third parties with your sensitive information. More often than not, these companies misused the data at their disposal, leading to enormous scandals (Facebook and Cambridge Analytica). Now, as per decentralization, there won’t be one single body at the center of the company in control of all the crucial data. Web3 apps will run using blockchain technology and the peer-to-peer network to ensure trustlessness and decentralization.

Composability

One of the fascinating aspects of Web3 will be its interconnectivity and composability. We have already seen this in the DeFi  (Decentralized Finance) ecosystem and IoT (internet of things). In DeFi, multiple platforms can connect with each other and create a tight knit ecosystem wherein you can take advantage of numerous financial instruments.

Artificial Intelligence

Web3 will be using AI and Machine Learning (ML) to empower their systems to produce faster and more relevant results.




	

	
	
		
			
				Logging in to a website with your Facebook account is an example of:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Use Cases Of web3
Web3 has several use cases, with digital currencies, NFTs, and other entities in the crypto and blockchain space becoming crucial for Web3. Decentralized Autonomous Organizations or DAOs are also a significant use case for Web3, utilizing tokens to make decision-making powers more fair and impartial.
Decentralized Autonomous Organizations
Basic knowledge of DAOs, and how they function is very helpful in understanding and contributing to Web3. A DAO is an entity that does not require a central authority to function. Instead, it is driven by its community and provides complete autonomy and transparency. Smart contracts govern all foundational rules; the contracts also execute any decision agreed upon by the community, with all processes, including voting or proposals, publicly available for verification. In essence, a DAO is governed by individual members who are part of the community, collectively taking critical decisions regarding the project, ranging from allocations to upgrades.

A core team of community members establishes rules for the DAO through smart contracts, laying out the DAO’s framework. These smart contracts are publicly verifiable, allowing community members to understand each step related to the DAO’s functioning. Community members can create proposals, after which the entire community votes on the proposal. Once a proposal achieves a level of consensus within the community, it is accepted and enforced by the smart contract.

The DAO landscape can be divided into different groups such as Protocol DAOs, Investment DAOs, Service DAOs, Social DAOs, Grants DAOs, Collector DAOs, and Media DAOs. Some of the prominent DAOs that you can keep track of are MakerDAO, Proof of Humanity, RaidGuild, Sputnik DAO, DAOhaus, Opolis, MolochDAO, and BanklessDAO.




	

	
	
		
			
				Berners-Lee pioneered:
			
		

		
					

		
			
			
			
			Web 1.0
		
			
			Web 2.0
		
			
			Web 3.0
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tipping
The decentralized economy offers global collaboration that allows participants to control how they work, allocate their time and expertise, with several tools already in existence and emerging that empower them and their style of working. Tipping is one such method that helps the growth of web3 communities by incentivizing participation. Before we move ahead, it is important to understand “tipping.” In the real world, we tip a person who provides a service. Tips are often given to housekeepers, restaurant staff, delivery persons, and other individuals who help us complete or perform certain tasks for us. In Web3, tipping works on the same premise, with the key difference being that the transfer of funds takes place over the blockchain.

In Web3, community members can be tipped for a variety of contributions, such as contributing code for a project, answering questions, writing an article, or when a community member lends their expertise to a project. Tipping can be carried out in any form, ranging from NFT airdrops and governance tokens to tips in ETH, USDC, or any other cryptocurrency. Tipping contributors helps build trust in the community, ensure that participants remain invested in the project, and also helps to establish a tone for future participation.

Currently web3 users are getting tips in NEAR tokens at Twitter and Telegram.
Logging In With Your Wallet
Another interesting thing that Web 3 changes are login procedures. Back in the days of Web 1.0, there were two ways that you could log into a website account – either via email or via a unique account created solely for that website. 

Then, during the Web 2.0 phase, you could log into everything with either your Google account or your Facebook account. While this was convenient, this still had one major shortcoming – value transference. You still had to give your payment details separately to make purchases.

Now, with web3, you can simply connect to different websites with your cryptocurrency wallet. Case in point, in OpenSea, you need to connect directly with your MetaMask and make purchases. In fact, at Learn NEAR Club you MUST log in with your NEAR wallet to participate in (L)Earn activities.



 

Dealing with web3 users allows dapps to instantly transmit not only data but monetary value as well without any middleman involved!
The Role Of NEAR Protocol In web3
With its scalable and easy-to-use platform, NEAR Protocol provides a platform that allows you to create DeFi apps and NFTs without burning a hole through your pocket.

DeFi TVL for NEAR is only around $141.72 million. It is a very young ecosystem and is presently growing at a rapid rate.



The most dominant DeFi app that accounts for over 80% of the overall TVL is Ref Finance.

Ref Finance has some similarities with Uniswap V2, plus it supports more pool types, configurable fees, and it’s completely community-owned. Ref also happens to be the first DeFi platform on NEAR. The main aim of Ref is to bring together DEX, lending protocols, synthetic asset issuer, and more under one umbrella.

NEAR has recently launched a humongous $800 million grant fund that has been specifically aimed at creating a larger and healthier DeFi ecosystem. The fund has some major requirements, which include the following:

 	$100 million for startups
 	$100 million regional fund
 	$250 million ecosystem grants to be distributed over four years.

Read this to know more about DeFi on NEAR.

On the NFT front, several projects have been created on the NEAR blockchain like Mintbase, Paras, (L)Earner, etc. 

Mintbase is the most popular NEAR NFT platform since it allows anyone to make an NFT and make it available for sale in their marketplace or on NFT marketplaces like OpenSea. Minters can create a smart contract and limit the transferability of the tokens minted, helping prevent fraud or the illegal transfer of unique items. Mintbase is focused on creating an NFT creation experience that is unique, which is why, as mentioned earlier, it supports different digital assets. This is contrary to competing platforms that focus on one specific NFT category. 
The Flipside – Is There Too Much Hype?
Recently, this meme has been floating around on Twitter, getting comments from the likes of Jack Dorsey and Elon Musk.


Image credit
As of now, web3 apps are getting a tremendous amount of attention for Silicon Valley VCs.  This brings up a major point of contention. With so many hardcore stakeholders, are Web3 apps going to be decentralized in the truest sense? Dorsey and Musk don’t believe so. However, it will be interesting to see how this pans out in the future.




	

	
	
		
			
				Which of the following does not require a central authority to function:
			
		

		
					

		
			
			
			
			Google
		
			
			DAO
		
			
			Facebook
		
	
		

		
		
			
				Correct!
				Wrong!

### Crypto Hero, NEAR Game

What is Crypto Hero?

Crypto Hero is a blockchain based game, mainly focused on PvE - where you can grind dungeons and trade items with other players, as well as play with friends in a raid system where you can earn Pixel Token prizes weekly.
The idea is inspired by traditional RPGs, as well as action RPGs such as Diablo.



It tries to implement mechanics from those games in a simple manner, allowing for a streamlined experience where players can develop their characters, compete with others and ,most importantly, earn.

The game contains 5 main elements, which I’ll list down below.

Why should you play Crypto Hero?

Crypto Hero is the second game installment from PixelDapps  and will not be the last - a team that has been successfully producing blockchain games where players find opportunities to earn prizes while having fun. The current token is stable and rising, which is the perfect time for early investment.
Other than that, Crypto Hero is fun. It creates a progression system from RPGs into a whole new level with NFT items that are collected and traded throughout a community that is first and foremost connected with ideas and aspirations in the ecosystem.

How do you play Crypto Hero?

Crypto Hero Rules

When can I play Crypto Hero?
MainNet release is on Jan. 22

Where can I play Crypto Hero?

Play Crypto Hero

 	 The Auction House

Items can be exchanged on the auction house with Pixel Tokens.
You can filter down items through categories as well as different types of equipment for easier searching.



 	 The Items

Your hero can equip up to 6 different items: a weapon, armor, boots, a necklace, a ring and a helmet.

Items are defined by rarity: common, rare, epic and legendary.

Items can be dropped in dungeon runs, the deeper the dungeon level, the better the item drops.

Items will make your hero stronger.



 	 The Hero

Your hero has HP, Level and Experience.

Your hero can level up when it gains enough experience. 

The higher your hero level is, the stronger he gets.



 	The Dungeon

You can send your hero dungeon exploring, where he will face a hoard of creatures.

You can choose how deep you want to go into a dungeon, deeper levels give better loot and experience, but become exponentially harder. 

Once you beat the dungeon, you are rewarded with loot and experience and need to wait to go into the dungeon again.



 	 The Ranking Ladder

The ranking ladder displays the highest levels + item levels in the game, creating a competitive scenario between players.



 	 The Raids

The raid system is a social push for players to connect with each other, as well as being the main earning part of the game. You can group up with other 7 players in order to fight bosses that have different ranking difficulties and different rewards.

### Zod EDGE Beta Testers Feedback

Test duration: Jan 20 - Jan 22

About project: The Zod EDGE offers decentralized GPU compute. You submit your jobs in the form of Docker files for farmers to complete. Discord: discord.com/invite/jjBSjSF
ZOD Compute Job
Requirements

 	 Go to https://transcode.zod.tv/compute_creator

 	 Login with NEAR at the top right

 	 Scroll down and click the little blue Copy button after the "CURL Request" text

 	 Paste it into a mac or linux terminal.
This response means that request is Success.
{"error":"ok","uuid":"05v7g4ha6b1515vu757mmkoa4o"}
 	 Go to https://transcode.zod.tv/computes



 	 Wait for status on your job to say Done
 	Click the little [+] button on the left of your job
 	 Take a screenshot of the page that has the Log on the right with Hello Docker in it.


 	Twit "I run my first computational job on  @ZodTV8 - project from @LearnNEAR Barrel
 	Fill the feedback form

The top 20 beta testers will get 1NEAR, the best feedback submitter will get 8NEAR.
Happy testing!

### Update - January 19, 2022

Brief Summary:

 	January nLEARNs Redeem to NEAR Window was the BIGGEST to date!

Results:

 	💸 Ⓝ376 sent to 376 (L)Earners. Congrats and happy (L)Earning!
 	📲 (L)Earners help one another and get NEAR tips for legit questions and answers at LearnNEAR.Club Official Telegram group
 	🤑There are about Ⓝ30 unclaimed  at Tip with NEAR for Twitter. So please check if some of them are waring for you.

Instructions are here https://github.com/dapplets/tipping-dapplet 
Tweet a cool twit tagging  @LearnNEAR and @dappletsproject   and get tips in $NEAR
 	Ⓝ96 sent to 6 projects NEAR Certified Developer Demo December Day participants. Check projects repos at LNC GitHub
 	


Beta test sprint for "NFT Lend", project from LNC Barrel was super fun!















Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	(L)Earner NFT - Genesis edition. Subscribe to early mint access!

### Что вы можете сделать с протоколом NEAR

В крипто пространстве Ethereum доминирует  платформа для смарт-контрактов, децентрализованных приложений и децентрализованных финансов. Тем не менее, Ethereum — не единственный протокол в сфере смарт-контрактов и децентрализованных приложений, на картинке есть несколько других протоколов. Несмотря на то, что Ethereum является платформой номер один в этой области, у нее немало недостатков, таких как чрезвычайно высокая плата за газ и серьезные проблемы с масштабируемостью.

NEAR Protocol — блокчейн, который может соперничать с Ethereum, если использовать самый большой недостаток протокола, его отсутствие масштабируемости, используя то, что называется шардингом. Это позволяет NEAR увеличивать свою масштабируемость в геометрической прогрессии. Протокол также привлек значительное финансирование и считает фонд a16z Андреессена Горовица одним из его сторонников.
Более детальный взгляд на протокол NEAR
Протокол NEAR — это децентрализованная платформа разработки, основанная в 2018 году. NEAR создает идеальную среду для децентрализованных приложений и смарт-контрактов, фокусируясь на недостатках других протоколов в том же пространстве. О недостатках мы уже упоминали ранее. NEAR использует протокол NEAR, блокчейн Proof-of-Stake, который известен своей общедоступностью, удобством для разработчиков и сегментацией. Протокол представляет собой недорогую и хорошо масштабируемую платформу, которую разработчики могут использовать для создания децентрализованных приложений (dApps). Другие функции, которые могут использовать разработчики, включают приложения кошелька и компоненты взаимодействия, которые позволяют разработчикам легко использовать экосистему NEAR и создавать приложения.

NEAR представляет Doomslug, механизм генерации блоков, который был предложен в 2019 году. Он обеспечивает практическую завершенность; это означает, что блоки могут быть завершены за считанные секунды. NEAR работает на основе той же технологии, что и биткойн, и сочетает ее с такими функциями, как сегментирование базы данных. Другие блокчейны централизуют обработку, что означает, что она ограничена очень высокопроизводительным оборудованием. Такой подход обеспечивает лишь временное увеличение пропускной способности. С другой стороны, NEAR масштабируется линейно и может поддерживать даже миллиарды транзакций полностью децентрализованно.
Важные особенности NEAR
Протокол NEAR разработан коллективом NEAR. Ниже приведены некоторые особенности протокола.

 	Протокол NEAR прост в использовании, и разработчики могут легко и быстро создавать приложения на его основе.
 	NEAR обеспечивает почти бесконечную масштабируемость благодаря использованию сегментации.
 	Near — это протокол уровня 1.

Понимание команды NEAR
Команда NEAR, сообщество исследователей и разработчиков, стоит за разработкой протокола NEAR. Команда постоянно работает над развитием и улучшением протокола NEAR, а также работали над такими проектами, как написание исходного кода протокола и реализация сети NEAR. Протокол NEAR работает полностью независимо и децентрализовано, и даже создавшие его разработчики и исследователи не могут его отключить.

Команда NEAR состоит из Фонда NEAR, который является некоммерческой организацией, создающей экосистему вокруг протокола NEAR. Команда NEAR помогает в разработке и управлении протоколом. Протокол NEAR — лишь один из нескольких проектов команды.
Что вы можете сделать с протоколом NEAR
Протокол Near позволяет пользователям получить доступ к нескольким проектам и протоколам, от NFT до DAO и DeFi. NEAR разработал динамичную нативную экосистему, имеет несколько проектов, которые уже запущены и работают на протоколе, в то время как другие проекты находятся в стадии разработки.
Начало работы с NEAR
Чтобы начать работу с NEAR, первое, что вам нужно, — это учетная запись NEAR. Вы можете узнать, как настроить учетную запись NEAR здесь. После того, как вы создали свою учетную запись NEAR, вы можете подключить ее к своему кошельку NEAR, что позволяет вам совершать вызовы контрактов в блокчейне, отправлять или получать средства и настраивать локальные узлы. Чтобы создать учетную запись NEAR, вам необходимо иметь как минимум 0,2 NEAR (или 4 доллара США на момент написания статьи) чтобы вы могли сохранить свою учетную запись в сети NEAR.
Токен NEAR
Есть два способа получить токены NEAR; вы можете либо заработать их, либо купить напрямую. Токены NEAR можно заработать, участвуя в сети, участвуя в наградах за развитие или запуская узлы сообщества, которые могут позволить людям в сообществе развивать NEAR. Вы также можете купить токены NEAR, которые доступны на всех основных крипто валютных биржах.
Что вы можете сделать с токенами NEAR
Токен NEAR позволяет выполнять несколько задач; вы можете передавать токены NEAR между учетными записями и отслеживать транзакции в обозревателе блоков. Комиссия за транзакции на NEAR чрезвычайно низка, что позволяет легко перемещать токены. Вы также можете отправить NEAR всем, кому необходимо создать учетную запись NEAR, используя NEAR Drops. Токены NEAR также позволяют вам получить доступ к растущему числу приложений, которые создаются на основе NEAR. Вы можете покупать, публиковать или продавать NFT и цифровое искусство на NEAR или создавать коллективные произведения искусства.
Стейкинг
Сообщество NEAR может поддерживать валидаторов через стейкинг. Валидаторы — это те пользователи, которые управляют узлами, которые помогают запускать сеть NEAR. Валидаторы должны поддерживать минимальную сумму стейкинга, чтобы они могли оставаться в качестве валидаторов. Владельцы токенов NEAR могут отправлять свои токены валидаторам по своему выбору и получать вознаграждение от токенов, сгенерированных сетью. Пользователи могут стэйкать токены, используя следующие шаги:

 	Выберите Staking на панели навигации кошелька и выберите валидатора.
 	Подтвердите выбранные вами параметры, а затем выберите «Stake with Validator».
 	Выберите количество токенов NEAR, которое вы хотите застэйкать, и нажмите «Отправить».

Что вы можете делать в экосистеме NEAR
NFT
NFT получают значительное внимание. Хотя Ethereum является основным игроком, когда дело доходит до NFT, их переход в мейнстрим также привлек внимание к высокой плате за газ Ethereum, что делает его довольно непрактичным. Протокол NEAR является жизнеспособной альтернативой, и на его платформе уже запущено несколько проектов. Масштабируемость протокола гарантирует, что разработка dApps будет быстрой и простой. В настоящее время на платформе NEAR существует 19 децентрализованных платформ для NFT. NEAR также значительно быстрее, чем другие игроки в пространстве NFT, и имеет чрезвычайно низкие транзакционные издержки.

Протокол NEAR можно назвать идеальной платформой для NFT, и он имеет ряд преимуществ по сравнению с другими платформами NFT в мире и даже с Ethereum. Протокол NEAR может обрабатывать транзакции намного быстрее, чем Ethereum, и, в отличие от Ethereum, он не страдает от высоких комиссий за газ или перегрузки сети. Транзакции на NEAR обрабатываются практически мгновенно с незначительной стоимостью. Все эти факторы делают NEAR идеальным для покупки и продажи NFT и служат стимулом для различных проектов строить свои NFT на NEAR. На NEAR уже запущено несколько проектов NFT, таких как Mintbase и Parashttps://paras.id/ru.
Создавайте и продавайте NFT через Mintbase
Пользователи протокола NEAR могут использовать несколько проектов NFT для покупки, продажи или создания NFT. Один из таких проектов, Mintbase, позволяет пользователям создавать NFT и выставлять их на продажу на таких торговых площадках, как OpenSea. Пользователи могут создавать смарт-контракты, чтобы ограничить возможность передачи токенов, что помогает предотвратить мошенничество и незаконную передачу активов.

Mintbase перешла с блокчейна Ethereum на протокол NEAR из-за высоких комиссий за газ. Первоначально плата за газ в Ethereum была низкой, и пользователи могли быстро развернуться, однако с увеличением использования и перегрузки в Ethereum стоимость газа начала выходить из-под контроля. Есть несколько других причин, по которым Mintbase выбрал протокол NEAR.

 	NEAR использует Rust или AssemblyScript для кодирования смарт-контрактов, что позволяет разработчикам легко писать код.
 	NEAR имеет удобочитаемые адреса для смарт-контрактов и учетных записей.
 	Разработчики могут легко и быстро использовать дроп NEAR и  пользователей. Они также могут оплачивать свои счета NEAR и отправлять или получать токены NEAR.
 	Разработчики могут использовать ETH-NEAR Rainbow Bridge и быстро перемещать свои активы.
 	Проекты DeFi, такие как Balancer и Aave, также включены в NEAR, что упрощает любую потенциальную интеграцию в будущем.

Создавайте, торгуйте и собирайте цифровые художественные карты
Paras — это рынок цифровых карт, основанный на протоколе NEAR, который предоставляет пользователям решение для устаревания традиционных коллекционных карт. Он подтверждает право собственности через блокчейн посредством быстрых и недорогих транзакций. Он также отличается тем, что предлагает коллекции вместо отдельных релизов. Paras полезен для коллекционеров, так как он значительно снижает нагрузку на коллекционеров, гарантируя, что их предметы коллекционирования не изнашиваются. Художники и коллекционеры могут легко получить доступ к рынку предметов коллекционирования.

С момента запуска Paras мы видели, как художники заработали более 25 000 долларов, а платформа смогла обработать более 700 транзакций, что позволило увеличить объем торгов на сумму более 35 000 долларов. В настоящее время на платформе более 70 художников и 80 коллекционеров. Протокол NEAR и Paras отлично подходят, потому что создатели NFT ищут альтернативы Ethereum с его высокими комиссиями за газ. Транзакции в NEAR почти ничего не стоят и могут быть завершены за секунды, а Rainbow Bridge обеспечивает совместимость между Ethereum и NEAR.
Исследуйте и выставляйте на аукцион коллекции NFT
Проект Hip-Hop Heads является результатом сотрудничества между NEAR Protocol, Эдом Янгом и Универсальным музеем хип-хопа. В коллекции NFT представлены исполнители от семидесятых до наших дней, а также 47 крупнейших исполнителей жанра рэп. Коллекция чествует обоих артистов, а также отмечает 47-ю годовщину эры хип-хопа.

NEAR позволяет сделать коллекцию более доступной для сообщества, а на аукционе представлены новые издания всех 103 хип-хоп участников. Члены сообщества могут легко покупать NFT с помощью кредитной карты без какой-либо сложной системы регистрации.

Пользователи протокола могут получить доступ к нескольким другим проектам NFT в NEAR, таким как Metamon, WebAssembly Music, Snark.Art и т. д. Metamon создает вселенную монстров, которых пользователи могут захватывать, развивать и играть с ними. Монстры классифицируются как находящиеся под угрозой исчезновения существа с ограниченным тиражом, которых может приобрести избранная группа коллекционеров NFT. Коллекционеры могут объединить двух Метамонов одного типа и наблюдать, как они превращаются в более редкого и могущественного Метамона.

WebAssembly Music — первая музыка, которая была сохранена в блокчейне как NFT. Музыка создана Питером Саломонсеном и опубликована в протоколе NEAR. Это музыкальное произведение было одним из первых музыкальных произведений, которые были преобразованы в исполняемый двоичный файл WebAssembly. Пользователи могут запускать двоичный файл WASM и получать необработанные аудиоданные через среду выполнения WebAssembly.




	

	
	
		
			
				NEAR использует следующее для кодирования смарт-контрактов:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust or AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi на NEAR
Давайте сначала поймем, что DeFi, DeFi или децентрализованные финансы относятся к полностью децентрализованной финансовой системе, в которой используются блокчейны, такие как Ethereum. Он состоит из таких активов, как децентрализованные приложения, протоколы DeFi и смарт-контракты. Целью DeFi является создание децентрализованной финансовой системы без разрешений с открытым исходным кодом, которая работает независимо от юрисдикции какой-либо третьей стороны или центрального органа управления. DeFi предоставляет пользователям легкий доступ к финансовым услугам и особенно полезен для лиц, не имеющих доступа к банковским услугам.

NEAR двигает DeFi в массы с несколькими проектами, работающими по протоколу, начиная от проектов DeFi, DEX, Oracle и т. д. Давайте посмотрим, как вы можете использовать некоторые из проектов NEAR.
Доступ почти ко всем совместимым цепочкам с Rainbow Bridge
Rainbow Bridge действует как мост между NEAR и Ethereum и представляет собой не требующий разрешений и доверия протокол, который соединяет две разные цепочки блоков. Пользователи могут легко развернуть новый мост или присоединиться к существующему мосту, не требуя одобрения третьей стороны. Rainbow Bridge позволяет использовать любую информацию, которая может быть использована в NEAR, в смарт-контрактах Ethereum и наоборот. Это также позволяет пользователям голосовать с помощью ETH в DAO на основе NEAR, минуя Ethereum.

Rainbow Bridge легко доступен для пользователей благодаря интуитивно понятному дизайну и встроен непосредственно через MetaMask. Rainbow Bridge также можно перепрофилировать и соединить NEAR практически со всеми цепочками, совместимыми с Ethereum. Rainbow Bridge также стремится поддерживать цепочки, не относящиеся к EVM, такие как биткойн.
SputnikDAO 
DAO чрезвычайно важны, когда речь идет о стратегии управления протоколом. SputnikDAO расширяет возможности сообществ и отдельных лиц, составляющих экосистему NEAR, выступая в качестве инфраструктуры для DAO в протоколе NEAR и позволяя отдельным лицам и другим проектам запускать DAO, обновлять смарт-контракты протокола и легко настраивать управление для управления финансами. SputnikDAO также позволяет проектам настраивать управление с несколькими подписями или выпускать токены управления или комбинировать их и использовать вместе.
Выпуск и создание аудио NFT с DAOrecords
DAOrecords планирует стать первым в мире децентрализованным звукозаписывающим лейблом и в настоящее время использует гибридную модель. Проект постоянно экспериментировал с аудио NFT, в рамках проекта было выпущено 350 NFT и на данный момент он работал с более чем 60 артистами. DAOrecords хочет вернуть контроль над музыкой исполнителям, которые ее создали, и изменить то, как они взаимодействуют со своими поклонниками.

Независимые исполнители могут выпускать новую музыку, используя звуковые NFT и потоковые сервисы DAOrecord. Они также могут создаватьсвои аудио NFT. DAOrecords уже опубликовал интерактивный аудио NFT под названием «MintTape Vol 1».
Доступ к кредитам через Aave
Aave реализует стратегию кредитования на основе пула вместо децентрализованной одноранговой стратегии. Ссуды на Aave не выдаются индивидуально. Вместо этого они полагаются на объединенные средства и на залог вместе с заемными суммами. Aave был запущен в ноябре 2017 года как платформа для однорангового кредитования и переименован в Aave в сентябре 2018 года. Протокол был запущен в основной сети и имеет почти 6 миллиардов долларов, заблокированных в смарт-контрактах, и входит в тройку лучших проектов в DeFi. мире.

Aave предлагает быстрые кредиты, которые в основном представляют собой необеспеченные кредиты, которые берутся взаймы и погашаются за одну транзакцию, что означает, что пользователям не требуется никакого залога для кредита, в то время как заемщик возвращает первоначальную сумму займа и небольшую комиссию. Aave представила мгновенные кредиты, где каждый может заимствовать ликвидность, использовать ее с другими протоколами и погашать за одну транзакцию. Мгновенные кредиты необходимы в пространстве DeFi, поскольку они дают людям доступ к ликвидности без необходимости залога.
Доступ к потокам данных с помощью Chainlink 
Chainlink был разработан как децентрализованная сеть оракулов, которая позволяет смарт-контрактам надежно и безопасно передавать данные между блокчейнами и автономными системами. Он использует децентрализованную сеть независимых оракулов для извлечения данных из нескольких различных ресурсов, агрегирования данных, а затем доставки проверенных данных в смарт-контракт, который инициирует выполнение контракта.

Протокол Chainlink также обеспечивает многоуровневую безопасность, чтобы обеспечить полное доверие к сети оракула. Это позволяет создавать и запускать сети оракулов, позволяя пользователям подключаться к настроенным сетям оракулов, не зависит от других сетей оракулов.

 	Подписание данных — входные данные оракулов Chainlink подписываются с использованием уникальной картографической подписи, которая позволяет пользователям доказать, что данные получены из определенного узла оракула.
 	Высококачественные данные — Chainlink будет предоставлять смарт-контракты с данными, полученными из внешних источников, таких как внешние поставщики данных.
 	Blockchain Agnostic — Chainlink может изначально работать на любом блокчейне, поддерживая общедоступные блокчейны, корпоративные блокчейны и т. д.




	

	
	
		
			
				DAORecords позволяет создавать:
			
		

		
					

		
			
			
			
			Цифровое искусство
		
			
			Цифровых кошек
		
			
			Аудио NFT
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora — и Ethereum Layer-2
Aurora на протоколе NEAR обеспечивает возможности Ethereum Layer-2. Разработчики могут использовать это для выхода на дополнительные рынки, используя преимущества протокола NEAR, такие как вознаграждение за газ и сегментирование. Он работает на двух важнейших компонентах: Aurora Bridge и Aurora Engine. Вот некоторые функции, которые предлагает Aurora:

 	Возможность обрабатывать тысячи транзакций в секунду, что в 50 раз больше, чем у Ethereum.
 	Время завершения блока составляет 2 секунды, по сравнению с временем подтверждения отдельного блока, равным 13 секундам в Ethereum.
 	Позволяет EVM масштабироваться по горизонтали с помощью подхода NEAR к сегментированию.
 	Комиссии на Aurora в 1000 раз ниже, чем на Ethereum.
 	Aurora предлагает полную совместимость с Ethereum по протоколу NEAR.

Заключительные мысли
NEAR создает экосистему, в которой пользователи могут легко получить доступ к dApps, NFT и DeFi. Протокол быстрее и дешевле, чем у других игроков в крипто пространстве. NEAR предлагает решения для таких проблем, как низкая скорость обработки, перегрузка сети и высокая плата за газ, используя сегментирование, что обеспечивает значительную масштабируемость платформы без ущерба для безопасности протокола.




	

	
	
		
			
				Этот протокол позволяет пользователям NEAR получать доступ к Ethereum на втором уровне:
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			Plasma
		
	
		

		
		
			
				Correct!
				Wrong!

### Пример Dapplets × NEAR

Пример Dapplets × NEAR —  Dapplet это (приложение расширение), которое может анализировать сообщения Twitter и сохранять их в контракте NEAR. Он также может отображать ваши сохраненные твиты на странице оверлея. 
1. Введение
Дапплеты — приложения, которые взаимодействуют с веб-страницами, дополняют их, вставляя различные виджеты, анализируют данные страниц и добавляют некоторые новые функции. Они могут улучшить взаимодействие с пользователем при использовании социальных сетей, видеосервисов и других источников. 

Дапплеты используют расширение, которое мы создаем. Это расширение предоставляет простой API для разработчиков дапплетов и большие возможности для сообщества дапплетов. Наша платформа децентрализована. Мы используем сети NEAR и Ethereum для наших реестров и контрактов. Мы также используем децентрализованные хранилища, такие как Swarm, IPFS и SIA, для размещения кода дапплетов и мультимедиа. 

Чтобы использовать нашу платформу, сначала вам необходимо установить расширение Dapplets. В настоящее время он находится на стадии альфа-тестирования и не публикуется в Google Chrome или любом другом магазине. Чтобы установить его, выполните следующие действия: 

 	Откройте один из следующих браузеров: Google Chrome, Firefox, Brave, Tor. 
 	Загрузите  расширение браузера.
 	Откройте chrome://extensions в новой вкладке.
 	Включите режим разработчика и нажмите F5, чтобы обновить страницу.
 	Перетащите загруженный файл на страницу расширений. Расширение установится автоматически. Если вы используете Ubuntu. В другой ОС Linux расширение Dapplets может исчезнуть из расширений Chrome после перезагрузки ПК. Чтобы избежать этого, разархивируйте архив и используйте кнопку Load unpacked, чтобы добавить расширение. 
 	Кликните значок расширения Dapplets на панели расширения. Попробуйте  дапплет Dapplets × NEAR. 

2. Руководство
Давайте изучим, как работает этот дапплет и почему Dapplets является дружественной платформой NEAR.

Цель этого примера — показать взаимодействие между NEAR и Dapplets. Если вы впервые сталкиваетесь с дапплетами, мы рекомендуем сначала ознакомиться с нашей документацией. Она содержит несколько упражнений, которые объясняют, как создавать дапплеты и адаптеры, от простых до сложных. Мы настоятельно рекомендуем просмотреть примеры ex01 и ex04, которые описывают, как создавать самые простые дапплеты и дапплеты с наложением. Знания, которые вы получите, облегчат понимание текущего примера. 

Исходный код для этого примера находится в отдельной ветке: упражнение. 

Вы можете клонировать это репо. Оно не будет работать напрямую. Попробуйте выполнить следующие шаги, чтобы запустить его.  

Посмотрим на структуру. Есть три компонента: дапплет, оверлей и контракт. 

Даплет — это точка входа приложения. Он использует адаптеры для взаимодействия с веб-страницами, определяя контексты для расширения и виджеты для вставки. Вы можете найти основные функции расширения внутри дапплета. Мы используем TypeScript в нашем проекте. 

Мы определяем оверлей как место, где пользователь может что-то делать с проанализированными данными, подключаться к основным функциям дапплета через мост дапплета и управлять параметрами дополнения. Это важная часть приложения, но она работает в другой среде и публикуется как отдельный пакет. В большинстве случаев мы используем React как один из самых популярных фреймворков. Но вы можете использовать предпочитаемый вами фреймворк или чистый JavaScript или TypeScript. 

Контракт не соединяется напрямую с другими модулями и может быть расположен вне дапплета. Однако этот простой контракт NEAR создан специально для этого дапплета. Поэтому его удобно размещать в структуре приложения. 

Давайте посмотрим на каждый модуль. 
2.1. Dapplet
Посмотрите файл /dapplet/src/index.ts.

Сначала мы создаем внедряемый класс с помощью декоратора @Injectable и используем @Inject, чтобы добавить адаптер Twitter в качестве переменной класса адаптера. Также создайте метод активации. Он запускается, когда выбранный адаптер находит определенный контекст и загружается. В нем будет вся основная логика. 



Добавьте кнопку в каждый твит. Введите этот код для активации: 



осмотрите на код. Получаем кнопку виджета из адаптера. Затем запустите метод attachConfig адаптера. Он получает объект с именами контекстов, которые будут использоваться в качестве ключей. Значения — это функции, которые получают проанализированный контекст в качестве единственного аргумента и возвращают виджет или массив виджетов. Вы также можете вернуть null, false или undefined. 

Виджет — это функция, которая получает объект, состоящий из состояний виджета. Параметры состояния описаны в документации адаптеров. Документацию по адаптеру Twitter можно найти здесь. В нашем случае мы добавляем изображение на кнопку и всплывающую подсказку. exec — это функция, которая запускается при нажатии. Теперь мы просто показываем разобранный контекст в консоли. 

Запустите дапплет: 


⚠️ Since the browser is blocking pages with problematic security certificates, go to https://localhost:3001/dapplet.json when the application is running and agree to run in insecure mode
Откройте расширение. Перейдите на вкладку «Разработчик» и включите сервер разработки: https://localhost:3001/dapplet.json. 



Включите вкладку Дапплеты. Рядом с нашим дапплетом вы увидите значок разработчика. Включите его. 



Теперь вы можете видеть дополнительные кнопки на наших твитах. Нажмите на кнопку и откройте консоль. Вы увидите проанализированный контекст твита. 



Вы сделали это! Поздравляем!!! Вернемся к коду. 

Мы хотим показывать обработанные данные не в консоли, а пользователям. Для этого мы будем использовать оверлей. Но перед реализацией оверлея добавьте в дапплет логику взаимодействия между дапплетом и оверлеем. 

Давайте изменим наш код. Добавьте переменную закрытого класса _overlay типа any. При активации добавьте следующий код: 



Основная функция Core.overlay (проблемы с вводом будут исправлены в ближайшее время) получает объект с именем оверлея и заголовком оверлея и возвращает объект оверлея, который мы сохраняем в переменной _overlay. 

Добавим в класс метод openOverlay: 



В этом примере мы вызываем метод send the overlay. Он принимает два аргумента: имя этих данных и данные для отправки в оверлей. 

Добавьте openOverlay в функцию exec и передайте проанализированный контекст в оверлей. Это текущий код дапплета: 



Откройте  ./dapplet/dapplet.json. 


⚠️ Since the browser is blocking pages with problematic security certificates, go to https://localhost:3000 when the application is running and agree to run in insecure mode.
Здесь мы видим URL-адрес оверлея с именем «оверлей», который будет использоваться в режиме разработчиков. Во время публикации дапплета в реестр оверлей будет опубликован в децентрализованном хранилище. 

Мы также видим адаптер Twitter в зависимостях. В примере мы используем версию 0.9.0.

Переходим к оверлею. 
2.2. Оверлей
Как мы уже упоминали ранее, оверлей можно создать любым удобным для вас способом. Мы используем React в большинстве наших проектов. Мы не будем анализировать весь код оверлея, а только важные моменты для наших архитектурных аспектов.

Для взаимодействия с дапплетом установите пакет npm @dapplets/dapplet-overlay-bridge: 



Чтобы получить данные из дапплета, нам нужен класс Bridge в оверлейной части. Посмотрите на модуль ./overlay/src/dappletBridge.ts. Вот метод onData, в котором мы подписываемся на событие data, которое мы описали в даплете. 



Затем мы используем его в модуле App.tsx. 



Теперь сохраните изменения и перезагрузите страницу Twitter. При нажатии на кнопку вы увидите оверлей с выбранными данными твита. 



Это классно! Но наша цель — сохранить эти данные в цепочке NEAR и получить их обратно. Итак, давайте посмотрим контракт.
2.3. NEAR смарт-контракт
Посмотрите на модуль ./contract. Существует простой смарт-контракт NEAR, написанный на языке AssemblyScript с функцией create-near-app. 

В ./contract/assembly/index.ts мы видим одну PersistentUnorderedMap с именем tweetsByNearId. Он хранит массив сериализованных данных твитов с текущим идентификатором пользователя. Он имеет методы для сохранения, удаления и извлечения сохраненных твитов. 

Вы можете найти все необходимые данные о том, как писать, тестировать и развертывать смарт-контракты NEAR в официальной документации и курсах и руководствах Learn NEAR. 

Давайте посмотрим, как подключиться к смарт-контракту и использовать его методы в дапплете. 

Добавьте следующий код в метод активации модуля ./dapplet/src/index.ts: 



Есть метод Core.contract, который получает 3 параметра: имя сети («near» или «etherium»), имя контракта и объект с методами просмотра и изменения. 

Теперь мы сделаем методы контракта доступными в оверлее. Чтобы передать методы через мост дапплетов, добавьте функцию прослушивания к вызову наложения. Не бойтесь, просто скопируйте и вставьте этот код :)



Последние три асинхронных функции передают методы контракта в оверлей. Первые четыре функции должны связать кошелек с приложением. Чтобы получить объект Wallet, мы используем метод Core.wallet с именованными параметрами name (near или ethereum) и network. У кошелька есть методы isConnected, connect,disconnect и параметр accountId. 

Следующим шагом будет изменение ./overlay/src/dappletBridge.ts. Мы должны сделать функции, описанные в даплете, доступными в оверлее. Скопируйте следующий код в класс Bridge: 



Теперь мы можем использовать контрактные методы в оверлейных модулях. Мы можем авторизовать дапплет с помощью кошелька NEAR testnet и сохранить данные выбранных твитов в смарт-контракте. Мы также можем видеть наши сохраненные данные в оверлее. 

Отмените коммит всего зафиксированного кода в файле ./overlay/src/App.tsx. Сохраните изменения и перезагрузите страницу Twitter. 



Вишенкой на торте станет добавление возможности просмотра сохраненных твитов без разбора новых. Для этого достаточно добавить метод Core.onAction в активацию в ./dapplet/src/index.ts и передать ему функцию открытия оверлея. 



Теперь вы увидите значок near рядом с именем дапплета.



Щелчок по кнопке открывает оверлей с сохраненными твитами. 



Поздравляем всех, кто добрался до конца урока! Мы надеемся, что он был успешным.

Вот результат: dapplets-near-example

Если у вас что-то не получилось, или у вас остались какие-то вопросы, добро пожаловать в наши чаты в Discord и Telegram.

Спасибо за уделенное время. Мы надеемся, что эти новые знания будут вам полезны, и вы продолжите разработку впечатляющих и успешных приложений на платформе Dapplets, используя возможности протокола NEAR 🚀 ✨
Контакты:
Web: dapplets.org
Docs: docs.dapplets.org
GitHub: github.com/dapplets
Discord: discord.gg/YcxbkcyjMV
Telegram: t.me/dapplets
Twitter: @dappletsproject

### NEAR протокол и Polygon

За последние несколько месяцев протокол Polygon приобрел огромную  популярность. Поскольку в сообществе Ethereum широко распространена масштабируемость, то становится очевидным, почему решения уровня 2 (такие как Polygon)  получили такое внушительное   количество поклонников. Однако, протокол NEAR не только предлагает платформу с высокой степенью масштабируемости на базовом уровне, но также предоставляет возможности уровня 2, которые также совместимы с EVM. Сегодня сравним оба этих протокола.
Что такое Polygon?
Итак, чтобы понять работу Polygon, для начала рассмотрим уровень 2. В сети Ethereum базовая цепочка блоков Ethereum известна как «уровень-1». Децентрализованные протоколы особое внимание уделяют безопасности и работоспособности, что в свою очередь неизбежно снижает скорость. Решением здесь является создание дополнительного протокола над основным блокчейном, так называемым протоколом второго уровня. Блокчейн в свою очередь делегирует сложные вычисления на второй уровень, что экспоненциально увеличивает общую пропускную способность. Polygon является примером протокола второго уровня.
Собственный токен протокола Polygon - MATIC. Основные свойства и преимущества токена MATIC:

 	Платежи и расчеты между участниками.
 	Стэйкинг и управление. Чем больше MATIC вы стэйкаете, тем больше ваше право голоса.
 	Оплата комиссии за транзакции.
 	Вознаграждение пользователей за предоставление вычислительных ресурсов и услуг.

Максимальное количество токенов MATIC 10 миллиардов.
Механика Polygon
Polygon имеет многоуровневую экосистему, в которой используются дополнительные цепи, совместимые с EVM. Эти сайдчейны предназначены для очистки основной цепи. Сайдчейны - это дополнительные блокчейны, которые связаны с основной цепочкой через двустороннюю привязку. Сайдчейн может иметь свои собственные уникальные правила и экосистему. Периодически, дополнительные цепи должны передавать данные в основную цепочку блоков для обеспечения бесперебойной работы.

Разработчики создают свои собственные дополнительные цепи для масштабирования своих приложений с помощью стека Polygon SDK. Polygon приобрел широкую популярность в основном потому, что он намного дешевле в использовании, чем основная сеть Ethereum, а  скорость ее работы намного выше.

Polygon использует механизм Proof-of-Stake (PoS), и любой может стать валидатором, разместив свои токены MATIC. Валидаторы в экосистеме выполняют следующие роли:

 	проверка транзакций путем утверждения и подтверждения обменов в сайдчейнах. 
 	сетевые валидаторы могут управлять, голосуя за различные обновления.
 	отвечает за выбор производителей блоков для каждой контрольной точки (подробнее об этом чуть ниже).

Сайдчейны Polygon - это часть экосистемы Ethereum, в которой пользователи могут быстро выполнять свои проекты, не беспокоясь о высоких ценах на газ и низкой пропускной способности.

Как Polygon обеспечивает скорость и децентрализацию

PoS от Polygon в основном используется для «контрольных точек». Это означает, что для каждой контрольной точки назначается группа производителей блоков, и эти производители отвечают за поддержание и обеспечение консенсуса. Ограниченное количество производителей позволяет Polygon формировать блоки намного быстрее, чем Ethereum (скорость блока составляет 1 секунду вместо 20 секунд).

Кроме того, Polygon обеспечивает децентрализацию, периодически делегируя контрольные точки PoS основной цепочке Ethereum. Каждый отдельный блок, созданный производителем блоков, должен быть подтвержден с помощью подтверждения блока, который передан в цепочку Ethereum.

Как работать с Polygon?

Рассмотрим алгоритм действий для работы с проектом на основе сайдчейна Polygon:

 	определить контракт в сети Ethereum и объявить количество токенов, которое вы хотите отправить в сайдчейн Polygon.
 	специальный смарт-контракт под названием «RootChainManager» активирует другой контракт под названием «ChildChainManager». Эти два контракта работают в тандеме, чтобы гарантировать, что количество токенов, заблокированных вами в сети Ethereum, будет беспрепятственно перенесено в основную сеть.
 	теперь пользователь может перейти в сеть Polygon и принять свои токены.

Это все безусловно хорошо, а как насчет наоборот? -спросите Вы. Что, если вы захотите покинуть экосистему Polygon и вернуться к Ethereum? Вот шаги, которые вам нужно будет выполнить:

 	вы должны сжечь свои токены на Polygon.
 	подтверждение сжигания необходимо отправить в основную цепочку Ethereum.
 	После проверки ваши ресурсы будут перераспределены в вашем кошельке.

Что такое протокол NEAR?
Летом 2018 года Илья Полосухин и Александр Скиданов создали NEAR Protocol как идеальную платформу для разработки децентрализованных приложений. Большинство других платформ страдают от низкой скорости, низкой пропускной способности и плохой совместимости с другими цепями.

Протокол NEAR построен с нуля и имеет следующие преимущества, обеспечивающие хорошую масштабируемость и безопасность:

 	NEAR использует механизм генерации блоков под названием «Doomslug». Doomslug допускает практическую или «Doomslug» завершенность, гарантируя, что блоки создаются за секунды.
 	NEAR - это сегментированная система, обеспечивающая бесконечную масштабируемость. Требуется уникальный подход для масштабирования до миллиардов транзакций полностью децентрализованным способом, вместо того, чтобы зависеть от централизованных процессов, таких, как другие протоколы.

Что такое шардинг?

Продолжая с последнего пункта, давайте разберемся, что такое шардинг. Шардинг - это метод, используемый в базах данных для обработки больших объемов данных. Шардинг , для оперативности,  разбивает всю базу данных на управляемые части, называемые «шардами». Эти сегменты можно обрабатывать параллельно для быстрого вычисления.

Итак, что именно происходит в блокчейне во время шардинга? Давайте взглянем:

 	все состояние блокчейна разбивается на более мелкие шарды.
 	каждая учетная запись принадлежит одному уникальному шарду, и они могут взаимодействовать только с учетными записями, принадлежащими одному и тому же шарду.

Проблема с обычным сегментированием состоит в том, что узлы должны работать на все более сложном оборудовании, что повышает барьеры для входа. Шардинг NEAR позволяет небольшим узлам работать на простом оборудовании, размещенном в облаке.

Что такое Aurora?

Aurora обеспечивает совместимость с Ethereum уровня 2 поверх NEAR и состоит из Aurora Bridge и Aurora Engine. Разработчики Ethereum могут запускать свои приложения в Aurora, чтобы воспользоваться несколькими положительными особенностями NEAR, такими как плата за газ и шардинг. Вот какие внушительные  улучшения приносит с собой Аврора:

 	приложения могут обрабатывать несколько тысяч транзакций в секунду. Это экспоненциальное улучшение по сравнению с Ethereum.
 	Aurora работает очень быстро, так как у нее время создания блока 2 секунды по сравнению с 15 секундами  у Ethereum.
 	шардинг NEAR позволяет экосистеме масштабироваться по горизонтали.
 	комиссии на Aurora в 1000 раз ниже, чем на Ethereum.
 	полностью совместим с Ethereum по протоколу NEAR.

DeFi на NEAR и Polygon
Polygon DeFi
Polygon позволяет использовать большинство популярных приложений DeFi, распространенных в Ethereum, таких как Curve Finance, 1inch Exchange и Beefy Finance. Согласно DappRadar, Топ-5 приложений пользователей за последние 24 часа выглядит следующим образом:



Sushi, несомненно, является самым популярным приложением.

Особого внимания заслуживает экосистема DeFi компании Polygon. На следующем изображении показана общая заблокированная стоимость (TVL) в Polygon, которая в настоящее время составляет около 5,19 миллиарда долларов.



TVL достиг пика в 10,54 миллиарда долларов 15 июня 2021 года. К тому же, когда дело доходит до фактически зафиксированной стоимости, Aave - несомненно, самый крупный протокол, на который приходится ошеломляющие 40% от общего TVL.
NEAR DeFi
По сравнению с Polygon, NEAR DeFi имеет очень молодую экосистему, которая неуклонно растет в течение последних трех месяцев. На данный момент TVL составляет около 141,72 миллиона долларов. 



Самым доминирующим приложением DeFi, на которое приходится более 80% общего TVL, является Ref Finance.

Ref Finance имеет некоторое сходство с Uniswap V2, плюс он поддерживает больше типов пулов, настраиваемые комиссии и полностью принадлежит сообществу. Ref также оказывается первой платформой DeFi на NEAR. Основная цель Ref – объединить под одной крышей DEX, протоколы кредитования, эмитента синтетических активов и многое другое.

NEAR недавно запустил огромный грантовый фонд в размере 800 миллионов долларов, который был специально нацелен на создание более крупной и здоровой экосистемы DeFi. У фонда есть несколько основных требований, которые включают следующее:

 	$100 млн долларов для стартапов
 	$100 млн региональный фонд
 	$250 млн грантов на экосистему будут распределены на четыре года.

NFT On NEAR And Polygon
Polygon NFT
Polygon - один из трех блокчейнов, которые в настоящее время доступны на Opensea (одной из крупнейших торговых площадок NFT в мире) наряду с Ethereum и Klaytn. Согласно рейтингу сайта, вот Топ-5 лучших NFT на Polygon:



Похоже, что ZED RUN - безоговорочный лидер, когда дело доходит до Polygon NFT. Итак, что такое ZED? Это доказуемо честная цифровая игра о скачках, построенная на блокчейне. Идея состоит в том, чтобы собрать как можно больше скаковых лошадей, чтобы создать высококачественную конюшню.


NEAR NFT
В настоящее время на NEAR есть несколько платформ NFT, таких как Mintbase. Mintbase была запущена в 2018 году Нейтом Гейером и Калорин Венд и привлекла 1 миллион долларов в результате начального финансирования в 2020 году. Платформа позволяет пользователям создавать и продавать активы, поддерживаемые NFT. Кроме того, пользователи могут создавать различные цифровые активы как NFT. Эти активы могут варьироваться от билетов на мероприятия до крипто-искусства.



Что интересно, Mintabase должна была запускаться на Ethereum. Однако они не смогли это сделать из-за высокой платы за газ и медленной скорости. Поэтому вместо этого Mintbase рассматривала NEAR как лучшую платформу, чем Ethereum, со значительно более низкой платой за газ благодаря более эффективной модели исполнения контрактов.
Вывод
За последний год Polygon приобрел большую популярность, при этом уровень 2 стал более популярным чем ранее. Кроме того, из-за его тесных отношений с сообществом Ethereum, он быстро получил распространение. С другой стороны, NEAR показал большие перспективы, решив проблемы масштабируемости с помощью сегментирования. Кроме того, грант разработчика в размере 800 миллионов долларов принесет в сеть значительный объем услуг. Оба протокола - Polygon и NEAR - предоставляют разработчикам идеальную платформу для построения масштабируемой и эффективной децентрализованной экономики.

### Что такое токеномика? Экспресс гайд

Одним из основных принципов децентрализованной сети является ее токеномика. Чтобы помочь проектам лучше понять нюансы своих токенов, Learn Near Club помог запустить новую практическую площадку для токеномики в NEAR Testnet - LNC | TokenHub. Однако прежде чем мы углубимся в детали, давайте узнаем, что означает токеномика.
Что такое токеномика?
Изначально токен был просто еще одним термином для «криптовалюты» или «крипто активов». Однако в последнее время мы использовали термин «токен» для крипто активов, выпущенных поверх блокчейна.

Термин «токеномика» - это сочетание слов «токен» и «экономика», и этот термин используется для описания, как вы уже догадались, экономики токена.

Если вы хотите оценить токеномику сети, вам нужно рассмотреть следующие аспекты:

 	Какое общее количество токенов и сколько их одновременно поступает в систему?
 	Сколько токенов будет создано в будущем?
 	Как токены распределяются между пользователями?
 	Какова точная роль токена в сети?
 	Нужен ли сети токен для работы?

В целом цель состоит в том, чтобы создать четкую связь между платформой и активом.
Элементы определенные в токеномике
Токеномику можно разделить на управление поставками и полезностью. Давайте посмотрим на каждый из этих элементов.
# 1 Управление поставками
Сколько токенов протокола фактически будет в обращении. Какая часть поставок контролируется базовым контрактом? Давайте рассмотрим следующие термины.

Премайнинг

Фактически, сколько токенов уже находится в экосистеме на момент запуска. Обычно токены периодически добываются специализированными пользователями, называемыми «майнерами». Однако определенные протоколы часто делают определенный % своего общего предложения доступным во время запуска для распределения токенов и доступа к ликвидности. Обратите внимание, что предварительный майнинг большого количества токенов может привести к проблемам централизации.

Распределение токенов

 Как токены распределяются между командой проекта? Раздается ли огромное количество токенов, что приводит к проблемам централизации? Какая часть токенов передается в казну для будущей разработки протокола?

Переход токенов

Большинство проектов получают финансирование от венчурных фондов или других инвесторов, которые получают токены в обмен на свои инвестиции. К сожалению, чаще всего венчурные фонды стремятся немедленно продать свои токены , чтобы получить быструю прибыль, что плохо для протокола. Вы можете заблокировать переход определенного токена на определенный период времени, чтобы предотвратить массовую распродажу.

Переход токенов имеет решающее значение для вселения доверия инвесторов, поскольку это говорит им о том, что команда и инвесторы серьезно относятся к проекту, и не ждут быстрой отдачи. Переход - это простой способ уменьшить рыночные манипуляции и гарантировать успешность инвестиций.

Сжигание токенов

Еще одна простая тактика, которую используют многие проекты для управления оборотным предложением - это сжигание токенов. Идея проста - периодически сжигать определенное количество токенов безвозвратно. Большинство проектов делают это, отправляя токены в мертвый кошелек. Такие проекты, как Ethereum и Binance, используют сжигание токенов для управления поставкой собственных токенов.
# 2 Полезность токена
Какие роли могут выполнять ваши токены? Давайте кратко рассмотрим некоторые из них:

 	Токены можно использовать для оплаты внутри или вне среды протокола.
 	Токены можно использовать для участия в протоколе, и участия в управлении.
 	Хранение токена протокола требуется для доступа к различным приложениям (DeFi и NFT) в системе.

Управление токеномикой
Инструмент токеномики Learn Near позволяет определить различные свойства вашего токена и опробовать их в тестовой сети.

Эти свойства:

 	Название токена
 	Начальное количество
 	Значок
 	Казначейство
 	Первоначальная поставка
 	Время начала размещения
 	Срок действия
 	Десятичные точки
 	Интервал перехода

Управление этими значениями поможет вам понять, как токеномика вашего протокола контролирует изготовление токенов. Хотите поэкспериментировать с этими инструментами? Проверьте LNC TokenHub! 

### Que sont les DAO ? Regard sur Spoutnik DAO.

L'une des choses les plus excitantes qui ont gagné en popularité ces derniers temps est le concept de DAO ou «  Decentralized Autonomous Organization -organisation autonome décentralisée- ». L'idée est de créer une entreprise native d'Internet détenue et gérée collectivement par ses membres. Il n'y a pas de PDG contrôlant le flux de l'entreprise, pas de CMO (Chief Marketing Officer - directeur du marketing), pas de CFO (Chief Financial Officer -directeur financier), pas de conseil d'administration centralisé. Au lieu de cela, la logique et l'exécution de l’entreprise sont intégrées aux contrats intelligents pour assurer un déploiement rationalisé.

Exemples hypothétiques de DAO :

 	Association caritative : Tout le monde peut devenir membre et tout le monde peut faire un don. Le groupe décide comment dépenser les dons.
 	Réseau d'indépendants : Réseau d'entrepreneurs qui mettent en commun leurs fonds pour des outils liés aux indépendants.
 	Ventures et subventions : un fonds spéculatif décentralisé où les membres peuvent mettre leurs fonds en commun et voter sur différentes propositions.

En quoi les DAO sont-ils différents ?
Les DAOs exécutent certaines règles qui sont enregistrées sur le contrat intelligent et conservées sur la blockchain. Un contrat intelligent peut être considéré comme un accord automatisé entre deux ou plusieurs parties. En raison de la nature transparente de la blockchain, il est impossible de changer le code régissant le contrat intelligent sans que l'ensemble du réseau en soit informé. C'est ce qui rend DAO plus flexible et robuste que les organisations typiques.

 	Les DAO sont une organisation démocratisée dans laquelle chaque membre doit voter pour tous les changements qui doivent être mis en œuvre. DAO utilise une gouvernance communautaire plutôt qu'une exécutive.
 	Les DAO sont globales et complètement transparentes.

Pourquoi les organisations hiérarchiques ne sont pas assez bonnes
Une structure organisationnelle hiérarchique et verticale est une façon courante d'organiser une entreprise. L'idée est simple : chaque personne au sein de l'organisation (sauf celle au sommet) est subordonnée à une autre personne ou entité. Ainsi, ceux qui ont le plus de puissance sont en haut du graphique. Dans le même temps, ceux qui ont le moins de pouvoir apparaissent en bas. Cependant, en raison de sa structure inhérente, il présente plusieurs lacunes par rapport aux DAO.




DAOs
Hierarchical


Structure
Plat et démocratisé
Hierarchical


Vote
Chaque changement dans le système nécessite le vote des membres.
Le fait qu'un système nécessite un vote ou non dépend de la structure et des règles définies par le système.


Intermédiaire
Les votes sont comptés et le résultat mis en œuvre sans intermédiaire de confiance.
Si le vote est autorisé, ils doivent être comptabilisés par un intermédiaire.


Automatisation
Les questions liées à la gouvernance sont traitées automatiquement de manière décentralisée.
Nécessite une manipulation humaine et centralisée. Par conséquent, ils sont vulnérables à la manipulation.


Visibilité
Entièrement public et transparent.
Privé et surtout opaque.



Modèles d'adhésion dans DAO
Alors, comment fonctionne exactement un modèle d'adhésion DAO ? Ceci est assez important car devenir membre est la clé du modèle opérationnel d'un DAO.

D'accord, il existe donc deux modèles d'adhésion :

 	Basé sur des tokens.
 	Basé sur le partage.

Basé sur des Tokens
La plupart des protocoles ont un token de gouvernance qui peut être échangé dans divers échanges centralisés et décentralisés. On peut soit gagner des tokens en participant à un algorithme de consensus ou en fournissant des liquidités. Comme son nom l'indique, posséder ces tokens vous donne accès aux droits de vote au sein du protocole. Plus vous détenez de tokens, plus votre pouvoir de vote est important. MakerDAO et ses tokens de gouvernance – MKR en sont un exemple. Tout le monde peut participer à la gouvernance de MakerDAO en achetant les jetons MKR.
Basé sur le partage
Par rapport aux DAO basés sur des tokens, les DAO basés sur des partages sont plus autorisés. Les membres potentiels doivent soumettre une proposition pour rejoindre le DAO. La proposition accompagne un hommage sous forme de token ou de travaux. La part du participant représente son droit de vote direct. Ils peuvent sortir à tout moment avec une part proportionnelle de la trésorerie. MolochDAO – un protocole responsable du financement de projets basés sur Ethereum - C'est un exemple de DAO basé sur le partage. Vous ne pouvez pas acheter de tokens de gouvernance sur le marché libre pour accéder au DAO. Pour en faire partie, vous avez besoin de l'expertise et du capital nécessaires pour aider à soutenir les projets potentiels.
Apprendre des erreurs - Le hack DAO
Bien sûr, il est essentiel de se renseigner sur le hack DAO qui a divisé Ethereum en Ethereum et Ethereum Classic. En 2016, l'Ethereum DAO a été créé pour être le changeur des règles du jeu et repenser complètement le fonctionnement des fonds de capital-risque. L'idée était que les détenteurs de tokens DAO votent sur diverses propositions de projets. Si une proposition obtient un vote de 20% de la communauté, elle obtiendra les fonds nécessaires pour démarrer.

Le DAO avait également un « Split mechanism - mécanisme de division ». Fondamentalement, si les membres ne sont pas satisfaits des projets mis en liste blanche, ils pourraient se séparer du DAO pour créer leur propre « Child DAO - Enfant DAO ». Quoi qu'il en soit, le DAO a été un énorme succès et a accumulé plus de 150 millions de dollars d'éther dans une vente publique. Pour des raisons de perspective, cela représentait 14% de tous les tokens d'éther émis à ce jour.

Cependant, le DAO présentait une vulnérabilité de code importante. Le 17 juin 2016, un attaquant a exploité cette vulnérabilité pour réintégrer continuellement le système et siphonner 50 millions de dollars d'ETH. La plupart des membres de la communauté ont décidé de revenir en arrière sur cet incident via un hard fork. Cependant, une partie de la communauté était contre cette décision. Cela a finalement conduit à un hard fork qui a divisé le protocole Ethereum en Ethereum et Ethereum Classic.
Near Protocol et Spoutnik DAO
Le cofondateur de Near Protocol, Illia Polosukhin, a annoncé le Sputnik DAO dans cet article. Il a expliqué le DAO comme «un moyen pour les communautés et les organisations nouvelles et existantes du monde entier d'avoir une représentation en chaîne de leur groupe, de gérer leur activité en chaîne, de régir leur prise de décision et (surtout !) D'interagir avec d'autres DAO. . "

Spoutnik s'est inspiré des inspirations suivantes pour former la « First wave - première vague » d'expérimentation DAO :

 	La manière dont la communauté contrôle la gouvernance ne dépend pas du nombre de personnes impliquées. De nombreux DAOs ont échoué pour diverses raisons, allant de problèmes techniques au manque d'intérêt des membres pour le vote ou à l'absence d'un facteur unificateur et moteur.
 	Il est impossible d'avoir un système DAO complètement heureux, les intérêts vont dériver et les opinions des gens sur une proposition peuvent changer. La minorité du groupe pourrait potentiellement bifurquer ou diverger du groupe pour suivre un nouveau système DAO.
 	Une communauté ou une organisation a besoin de leadership. Une communauté idéale doit avoir des membres dévoués qui sont responsables de la coordination, potentiellement de la modération.
 	Même si la communauté est sans permission et pseudonyme, il devrait y avoir des membres connus du public qui créeront le noyau de la communauté.
 	Plus une communauté décentralisée est axée sur le « produit », plus le leadership doit être ciblé.
 	La pondération purement basée sur les (staking-enjeux) échoue toujours car la plupart des parties prenantes ne sont pas capables ou ne veulent pas être des participants actifs.

L'interface Spoutnik
Au moment où vous accédez à la page d'accueil de Spoutnik, vous verrez l'écran suivant.



Lorsque vous cliquez sur "NEAR Forum", vous verrez les différents fils de conversation soigneusement et correctement classés.



Dans la page d'accueil, si vous cliquez sur « Launch App», vous aurez accès aux différents DAO répertoriés dans spoutnik.



Laissez-nous vous donner un exemple de quelque chose qui frappe plus près de chez nous. Vérifions toutes les propositions dans le Learn NEAR DAO.



Ainsi, comme vous pouvez le voir, vous avez diverses propositions répertoriées ici, ainsi que leurs paiements respectifs (en NEAR). Si une proposition est approuvée ou rejetée, elle sera marquée comme telle. Par exemple, dans l'ID de proposition 22, quelqu'un a traduit avec succès la page d'accueil et le pied de page en « vietnamien », c'est pourquoi vous pouvez voir ce « 1 » à côté d'Approuver et le badge « Succès ».


Comment nous utilisons Sputnik DAO au LeanNEAR.Club
Il existe DEUX niveaux de DAO utilisés :

Mère DAO et les suivants sont les sous-DAO :

https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near

https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near.

Regardez la mère DAO en tant que client/bailleur de fonds, les sous-DAO en tant qu'entrepreneur et les membres des sous-DAO en tant que sous-traitant.

Jetons un coup d'œil à son fonctionnement pour la traduction communautaire. Un guide des 3 meilleurs projets NFT sur le protocole NEAR doit être traduit en vietnamien.

Les membres du SubDAO soumettent des propositions de traduction et de révision.



Ensuite, l'un d'eux a soumis une proposition consolidée à la mère DAO avec subDAO comme bénéficiaire des fonds



Une fois que le travail est accepté et que le guide traduit est publié, les membres de la sous-DAO répartissent les fonds reçus selon les propositions soumises précédemment.

Pour d'éventuelles résolutions de conflits, le membre Mother DAO agit également en tant que membre votant dans TOUS les subDAOs.
Conclusion
Alors, voilà. Les DAO sont incroyablement perturbateurs. Cependant, il faut le mettre en œuvre correctement pour vraiment en récolter les fruits. Il semble que Near Protocol ait effectivement déchiffré le code avec Spoutnik !

### Cómo desarrollar un juego "Play To Earn" en NEAR Protocol

Revisión profunda del prototipo actual - BerryClub



Esta guía está destinada a permitirle comprender la dinámica básica que le permitirá crear un juego "Play To Earn" en Near Protocol.
No queremos hacer millonarios ni a ti ni a tus jugadores, pero la mecánica de Near funciona de tal manera que las transacciones pequeñas son muy útiles en una interfaz de usuario HTML5 simple y crean un juego de farming simple y divertido.
Analizaremos un contrato inteligente y los archivos js/rust detrás de un juego de farming existente, berryclub.  Si aplicas la misma lógica a tus ideas de juego, ¡Puedes obtener resultados aún más divertidos!
Para poder continuar por el lado técnico de este tutorial, recomendamos encarecidamente verificar el figment Near Pathway para construir una transacción y construir su primer contrato inteligente en Near, los conceptos presentes en esas guías no están incluidos en este tutorial.  Será mucho más fácil para usted seguir este tutorial si mantiene una pestaña abierta con el archivo fuente vinculado mientras lee la explicación, porque a gran parte del código mencionado se le hace referencia con números de línea pero no se muestra en esta guía .  El repositorio original de BerryClub se bifurcó para este tutorial con el fin de mantener este esfuerzo válido en la medida en que el código todavía funcione en la cadena de bloques;  Como verá en la siguiente sección, el juego en sí mismo ha evolucionado durante todo el tiempo y volverá a evolucionar, quisimos dejar su estado en este momento.

La interfaz de Berryclub
Berryclub está construido con React, por lo que a lo primero que entraremos es el archivo app.js ubicado en la carpeta src del repositorio de github, esto nos ahorrará tiempo al analizar el contrato, permitiéndonos enfocarnos en lo que necesitamos extrapolar, la lógica fuera del juego real (qué, por cierto, es divertido y jugado por una gran comunidad).

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
Después de importar react, la primera biblioteca necesaria es bn.js, una herramienta simple para administrar números enteros o no decimales, muchas características pueden llegar a su interfaz con esta biblioteca, en primer lugar aquí se usa para administrar las transacciones:

const PixelPrice = new BN(“10000000000000000000000”);
El juego berryclub se basa en la economía inmobiliaria, hay un tablero administrado por una parte del contrato llamado board.rs, está subdividido en píxeles y cada píxel tiene un precio que hay que pagar para poder dibujar en él.  La mecánica de la acción de "dibujar" es el núcleo de las habilidades de Farming y de autoabastecimiento del juego y se analizará en profundidad cuando lleguemos al contrato inteligente.
Como puede ver aquí, el precio de un solo píxel se declara como una constante al comienzo de nuestra aplicación, y puede modificarse utilizando las herramientas frontend y la biblioteca bn.j.  La segunda importación es el near sdk que nos permite interactuar con la cadena de bloques de Near cómo se explica en la ruta de Figment near.  El primer uso de la near api es para declarar las variables de contrato utilizadas y asegurarse de que se utilice la red principal cuando se ejecute el código desde la url de berryclub:

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Luego importamos las utilidades react UI para construir nuestra interfaz y permitir que la gente dibuje, react-color, react-switch y react-compound-timer.  La primera de estas utilidades que se usa es el temporizador, se usa para establecer un tiempo de espera para actualizar el tablero en la línea 62.
La "actualización" del tablero la realiza la interfaz para mostrar el estado actualizado de la placa mediante una llamada RPC al contrato inteligente.

const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
Lo que vemos aquí son dos constantes más de las necesarias para actualizar, las dos últimas de hecho se utilizan para farmear los píxeles después de dibujarlos, y establecen un intervalo de tiempo de un día para calcular las recompensas.  También se declaran otras constantes para gestionar el tablero de acuerdo con el contrato inteligente, y aquí, por primera vez, cruzamos el concepto de líneas, que será muy importante para comprender la gestión del tablero y es el elemento más reutilizable de toda la interfaz:

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
Como puede ver, después de subdividir la placa 50 × 50, le decimos a nuestra interfaz que busque solo las líneas que siguen la instrucción RefreshBoardTimeout y que considere la longitud de cada línea como BoardWidth multiplicado por 12, el tamaño de una sola celda.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Los píxeles se consideran por lotes, no de forma independiente, tanto cuando se llama a la acción de dibujo como cuando se actualiza la interfaz.
Por último, pero no menos importante, nuestras importaciones incluyen un componente de UI personalizado, llamado Weapons.js: este componente se ha desarrollado más tarde en la historia de la comunidad de berryclub, para que cada usuario pueda cargar y dibujar una imagen completa en el tablero, y generarlo en el mercado NFT de berrycards.

Mecánicas DeFi
Las líneas entre 27 y 51 son una referencia útil de cómo este Dapp construye sus habilidades de Farming sobre algunas mecánicas básicas de DeFi que se analizarán en las últimas partes de este tutorial.  A estas alturas, solo mencionamos brevemente que para dibujar / comprar un píxel, berryclub lo canaliza a través de un par de operaciones DeFi en ref.finance utilizando sus propios Tokens específicos, aguacates para comprar píxeles y plátanos obtenidos de los píxeles que compró.







Hay un clon simple de uniswap creado para intercambiar bananas / aguacates que funcionó en el mismo contrato inteligente construido para los otros tokens de este juego / prototipo. También hay un token de farming creado para el juego, llamado pepino, que permite a las personas ganar una parte de los tokens que toda la comunidad de jugadores paga por gas para pintar en el tablero.







La cuenta o cómo los usuarios ganan dinero
Este es el primer paso que damos en el código rust del contrato inteligente, pero sentí la necesidad de recordarte que la mecánica DeFi no es la única forma en que Berryclub te permite ganar tokens. La cuenta tiene un archivo particular en el contrato inteligente de berryclub, pero no necesitamos entrar en eso de inmediato, lo que necesitamos saber es que se recopila cierta información en el objeto de la cuenta que es crucial para la mecánica farming y de ingresos:


 	accountID
 	accountIndex (para la lista (vector) de cuentas que tocaron el tablero de píxeles por última vez)
 	balance(vector para varios tokens propios)
 	number of pixels
 	claimed timestamp (nanosegundos, de cuando la cuenta dada reclamó recompensas por última vez)
 	farming preferences (plátanos o pepinos)

Los dos últimos datos son para calcular las recompensas en un momento dado, por ejemplo, si posee 5 píxeles durante un día, adquiere 5 plátanos. Si le compras a otra persona sus ganancias disminuyen porque la cantidad de píxeles que poseen disminuye, por lo que se calcula la cantidad de ganancias y se renueva la marca de tiempo que relaciona la nueva cantidad de píxeles que posee. Como veremos, las recompensas se calculan en función de estas dos variables. La operación que se aplica a la cuenta del propietario anterior cuando se dibuja un píxel se llama "touch (toque)" y puede encontrarlo en el archivo rust account.rs. La propiedad de la unidad de un solo píxel es la base para ganar en Berryclub y, de esta manera, esta mecánica es prácticamente la misma que podría usar una interfaz de bloqueo (staking)  NFT, recompensando la propiedad de NFT.

pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
Para despejar cualquier duda, el propietario inicial de la placa es 0, el contrato en sí mismo, y si no es posible encontrar un propietario anterior, el contrato se utiliza como el propietario anterior. Finalmente para iniciar el juego se han almacenado algunos tokens en la cuenta del contrato y siempre se incrementan utilizando el precio del gas establecido para que las personas compren aguacates y plátanos, de manera que la “bóveda” del juego siempre se llene de algunos tokens para que los usuarios ganen. Ahora volvamos a nuestra interfaz.

Números a colores y de vuelta






Las líneas entre 67 y 82 en app.js se utilizan para decodificar números en colores y viceversa, para que los elementos de la interfaz de usuario interactúen con el tablero, se definen dos variables constantes, intToColor y rgbaToInt. Lo que podemos notar aquí es que para transformar un número entero en una cadena de colores se utilizan métodos para dividir los 3 números para rojo, verde y azul:

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
Para invertir la cadena de color en un entero, simplemente aplicamos una función math.round() y usamos el entero resultante.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
Las líneas debajo de estas se refieren a cargar e imprimir imágenes en el tablero usando el componente weapon y no nos ocuparemos de ellas en profundidad: imgColorToInt e int2hsv transforman los números en dos tipos diferentes de escalas de color, luego se define transparentColor y una gamma para la imagen que se imprimirá con generateGamma. En decodeLine transformamos el búfer en una matriz de píxeles para ser impresos en el tablero usando los colores anteriores, iterando a través de ellos con for.

Primer constructor de React
En las siguientes líneas de app.js definimos un constructor que definirá los estados que usaremos más adelante en nuestra interfaz de usuario para interactuar con la blockchain.

class App extends React.Component {
  constructor(props) {
    super(props);
Usar constructor y super nos permitirá usar esto en el constructor.  Los estados definidos aquí son el color y la paleta de colores seleccionados por defecto:







const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
Y para el temporizador que refresca el tablero:

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Luego, se definen los estados de la cuenta de usuario en uso, lo más importante es si el usuario ha iniciado sesión, si hay transacciones pendientes (definidas como pendingPixels), el estado boardLoaded cargará el tablero para dibujar, los estados selectedCell alpha y pickerColor definen los estados de los componentes interactivos para agregar colores al tablero, junto con pickingColor para elegir el color del tablero y gammaColors es útil para imprimir imágenes en el tablero junto con los estados armsOn y armsCodePosition.
Estos otros estados son útiles para que la cuenta gane en el juego, basado en píxeles, y, basado en DeFi.

owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
Mientras que los últimos tres estados configuran el temporizador para su uso posterior:

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
La siguiente lista (líneas 203-215) define objetos y acciones que interactuarán con los estados, haciendo referencia a un elemento DOM por primera vez, el tablero de lienzo.

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Por último, definimos algunos de los estados después de que se realiza el inicio de sesión:

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Interacciones básicas
Ahora comenzamos a describir las interacciones en el tablero / lienzo conectándolas a los estados previamente definidos.  Para estas interacciones usamos funciones.  El primero usará nuestra referencia previa al elemento canvas para crearlo e instruirlo con detalles sobre el tipo de movimiento del mouse que permitimos a nuestros usuarios.  En el primer clic habilitamos el modo de reloj para que se inicie nuestro temporizador:

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
Y modo de renderizado de imágenes si el usuario quiere imprimir una imagen en el tablero:

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
La siguiente es la parte importante, definimos cómo la interfaz lee el movimiento del mouse y del tacto sobre el tablero:

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
El código utilizado toma cuidadosamente en consideración a los usuarios móviles, construyendo una función ad-hoc para calcular la posición y agregando un oyente al lienzo / tablero para eventos táctiles: canvas.addEventListener (“touchmove”, mouseMove);  Luego, estas interacciones se utilizan para establecer el estado selectedCell y rastrear el inicio y el final de la acción del mouse / toque en el lienzo junto con su movimiento en cada celda:

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
La interacción aquí funciona en los estados previamente definidos, como por ejemplo, el selector de color nos permite elegir colores del tablero y usarlos para dibujar.  La tecla que usa el selector de color es la tecla alt y podemos cargar e imprimir imágenes en el tablero solo si el selector de color está deshabilitado, porque entonces activaremos la función generateGamma.  De esta manera, la función pickColor(), referenciada a la celda, se podrá utilizar para establecer un solo píxel o, en su lugar, todo el tablero para representar una imagen:

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
Ahora, llegamos al núcleo, así que prepárense para comenzar a bucear en el contrato inteligente. Sabemos cómo dibujar el píxel en la interfaz, pero necesitamos adjuntar las transacciones para que nuestra interfaz sea realmente un juego Play To Earn.  Por lo tanto, preste mucha atención a lo que voy a decir, porque incluso si su juego se ve completamente diferente a éste en términos de interfaz de usuario, la mecánica de ganancias puede ser adecuada para cualquier otro tipo de juego y te lo explicaré aquí de la manera más simple que pueda.






El contrato inteligente de Berryclub
Líneas
Hemos encontrado líneas por primera vez al comienzo de este artículo, mientras consideramos las definiciones de estados de la interfaz de usuario.  Las líneas son un concepto importante de la interfaz de Berryclub, son las filas por las que se subdivide el tablero / lienzo y cada píxel en ellas es una pieza de metadatos.  Son parte de la interfaz de usuario que interactúa con el contrato inteligente y son el objeto más reutilizable del juego (por ejemplo, para crear niveles en un juego más articulado), por lo que dedicaremos un poco de tiempo a analizar cómo son utilizadas para almacenar datos del tablero y evaluadas mientras los usuarios juegan el juego.
En primer lugar, en el archivo board.rs, encontramos una definición de PixelLine justo después de la definición de Pixel:
pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
Un vector (arreglo/array) de datos de cadena subdivididos por el ancho del tablero.
Y luego definimos en PixelBoard como un vector de PixelLines de esta manera:

pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
Por lo tanto, cada línea se almacena en el tablero como un solo registro con un campo de metadatos llamado line_versions que se incrementa cada vez que se modifica una línea.  Entonces, cada vez que nuestra interfaz busca el tablero, obtiene 50 líneas, pero también metadatos para cada línea que representan cuántas veces se actualizó la línea, y al obtener estos metadatos, la interfaz sabe cuál es la cantidad de veces que se cambió la línea, si la línea se ha cambiado desde la recuperación anterior, entonces recupera los datos para cada píxel, si no, simplemente no lo hace.

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
Esta es una forma inteligente de almacenar y obtener datos de la interfaz que pueden ser útiles para usar en su próximo juego "play to earn" en Near.







Transacciones
Regresemos a nuestra interfaz de usuario en app.js por un momento para asegurarnos de que entendemos cómo se administran las transacciones desde la interfaz. Primero necesitamos una función para verificar la cuenta por si algo sale mal y esta es:

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Entonces, ¿Recuerdas los arreglos/arrays _queue y _pendingPixels que definimos en nuestro constructor? Definitivamente es hora de usarlos, ya que las transacciones se administran según los píxeles que hayas dibujado en el tablero:

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Espera, no estaba listo para este montón de código… ¡Sí, lo estás! Pero veámoslo detenidamente, creamos un objeto de píxeles (vector), modificamos nuestro objeto _queue para que se ajuste a los píxeles y asignamos su valor al objeto _pendingPixel en una función asíncrona.
¿Y entonces qué? Simplemente dibujamos en un objeto de contrato que se llama desde el near sdk, y la acción para dibujar (una parte de las acciones que definimos para el usuario) se define en el archivo rust lib.rs.

pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
Para el contrato inteligente, los píxeles son un color y una id de cuenta (el propietario místico), y es un juego basado en bienes raíces: por lo que tenemos un antiguo propietario que dibujó el píxel antes y un nuevo propietario que quiere dibujarlo ahora. Con la acción de dibujar obtenemos el valor old_owner y lo reemplazamos con la nueva cuenta de propietario cambiando el valor de color de todos los píxeles dentro del vector PixelRequest, luego enviamos recompensas al propietario anterior mientras cargamos el nuevo. Las marcas de tiempo de las recompensas se restablecen y el recuento comienza de nuevo desde cero con un píxel menos para el antiguo propietario y uno más para el nuevo. La acción setPixelRequest está definida en el archivo board.rs de nuestro contrato, pero volvamos a nuestro libs.rs.
¿Qué aspecto tiene la función maybe_send_rewards()? Aquí está en todo su esplendor:

impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
Por favor, no seas perezoso, si no puedes esperar para saber más, puedes ver este video del autor del juego. ¡Las explicaciones que voy a usar también están tomadas de ese video!
La función verifica el tiempo en la blockchain (no estamos usando el temporizador en la interfaz aquí, ¡porque queremos estar seguros!) Y usa las capacidades de farming del contrato en una marca de tiempo global con la función get_next_reward_timestamp() y last_reward_timestamp() luego finalmente llama a get_expected_reward() para calcular las recompensas adeudadas a la cuenta.

pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
Así que tomamos el saldo actual de la cuenta de Berryclub (¿Recuerdas que tenemos un campo de saldo en la cuenta?), el uso y los costos actuales de almacenamiento y un umbral de seguridad de 50 aguacates. Si el saldo es seguro para su uso fuera del costo de almacenamiento, lo dividimos en una porción de recompensa de 24 (horas) * 60 (minutos), lo que significa que básicamente obtiene exactamente el mismo saldo que tiene una vez si lo llama cada minuto, puede encontrarlo definido al comienzo del archivo lib.rs:

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
Apuesto a que piensan que el proceso de recompensa ha terminado. Incorrecto.
De hecho, necesitamos volver a nuestra función maybe_send_reward() para ver que llama al nuevo contrato de farming de berryclub para distribuir las recompensas de participación, que son ... pepinos, el token de participación en berryclub
const FARM_CONTRACT_ID_PREFIX: &str = "farm";
En realidad, esa no es la única fuente de distribución de ingresos con esta función, sino que también nivela los costos de gas que paga la gente para comprar aguacates e intercambiar plátanos ¡Para recompensar a toda la comunidad!.
¿Cómo es esto posible? Lo primero es lo primero, GAS_BASE_COMPUTE se define en el archivo token.rs, es en donde se establece la cantidad de gas para el contrato inteligente. Sí, ¡tienes razón! El precio del gas es bajo en NEAR y ¡se puede utilizar para recompensar a los usuarios que interactúen con tu videojuego!
Para comprender mejor cómo funcionan las tarifas de GAS en Near, por favor consulta esta documentación detallada.
Este tutorial es traído a ti por jilt.near y su proyecto NFT Gaming, ¡Apoyala comprando NFTs!

### Tích hợp với Giao thức NEAR

Bài viết về hành trình đến với NEAR của chúng tôi




Cùng bắt đầu với 3 trụ cột của NEAR Protocol:


 	Proof of Stake (Bằng chứng cổ phần)
 	Sharded (Khả năng phân mảnh của mạng lưới) 
 	WASM Smart Contracts (Hợp đồng thông minh WebAssembly ) 

Với việc sử dụng cơ chế đồng thuận bằng chứng cổ phần (PoS), sự đồng thuận của blockchain NEAR đạt được bằng cách stake (đặt cược) chứ không phải mining (đào) dẫn tới thời gian tạo khối cực nhanh 1s và thời gian hoàn thành (finality) ngắn. 

Blockchain NEAR được phân đoạn (sharded), nghĩa là những lời gọi giữa các hợp đồng diễn ra bất đồng bộ (không giống như Ethereum hay Solana). Lập trình smart contract NEAR bạn cần suy nghĩ theo actor model (hoặc là làm việc với các microservice - mỗi shard làm một việc rồi tương tác với nhau).

Việc xử lý bất đồng bộ là cần thiết để cho các shard có thể được xử lý song song dẫn đến thông lượng giao dịch lớn hơn nhiều. Những blockchain mà smart contract không được phân đoạn sẽ dễ dàng gặp phải vấn đề về khả năng mở rộng, việc giảm tải qua GPU hoặc máy ASIC trong khi vẫn sử dụng cơ chế đồng bộ chỉ có thể cải thiện vấn đề này  theo kiểu mở rộng quy mô ngang (horizontally scaling), nhưng sẽ không thể giúp việc mở rộng quy mô theo cấp số nhân.

Smart contract của NEAR tương thích với WebAssembly (WASM code), nên bạn có thể lập trình trên bất kỳ ngôn ngữ nào miễn là có thể biên dịch được sang WASM. Hiện tại có hai ngôn ngữ được sử dụng để phát triển smart contract trên NEAR là  AssemblyScript (ngôn ngữ tương tự như TypeScript) và RUST - được hỗ trợ nhiều nhất với nhiều tool chains.

KHUYẾN CÁO: Việc này sẽ khiến bạn mất ÍT NHẤT 30 phút nếu bạn có thể lập trình bằng TypeScript.

Xây dựng một WebApp trên giao thức NEAR tương đối đơn giản nếu so với các blockchain khác.
Hãy clone ví dụ về app counter sau: https://github.com/near-examples/counter.






git clone https://github.com/near-examples/counter
yarn












Ta chỉ cần quan tâm tới 2 folder và 1 file:assembly/ là folder chứa code smart contract sẽ được biên dịch sang WASM. src/ là nơi chứa code của frontend tương tác với smart contract. 

package.json là nơi khai báo các JS dependency.


















Phần cốt lõi của smart contract này là lưu trữ trên chuỗi, log nhật ký cho các biên nhận đã tạo và export các public function để call sau này. Những function thiết lập storage phải được gọi (call function), nếu không chúng chỉ có thể được xem (view function) kể cả không dùng tài khoản NEAR.

NEAR hỗ trợ nhiều loại collections ở trong near-sdk-as












https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collectionsNhững thứ bạn sẽ cần:

 	storage.getPrimitive — get/set
 	persistentMap — set/get
 	persistentUnorderedMap — set/get/query/length

Tôi không đưa vào persistentVector vì bạn nên tránh sử dụng nó. Lý do là persistentVector rất tốn gas với mỗi thao tác lặp, bạn nên cố gắng sử dụng sets khi có thể thay vì dùng persistentVector.

Bạn cần thêm dấu ! vào sau method ‘get’ để lấy giá trị mặc định cho dữ liệu dạng persistentMap collection.


let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log sẽ log ranhật ký trên receipt (biên nhận) của bạn mỗi khi gọi hàm, việc này cho phép rà soát những giao dịch đã diễn ra, đặc biệt là khi các smart contract này trở nên phức tạp hơn. Ví dụ như một hợp đồng đúc tiền (minting contract) có thể log ra thông tin như sau: “alice.near đã mint 5.0 ZOD từ zod.near” 

Để deploy contract này, ta cần sử dụng near-cli: 






npm install near-cli -g
Để deploy một contract, ta có thể tạo một tài khoản testnet tạm. Tài khoản chính là contract và bạn chỉ có thể có 1 hợp đồng cho mỗi 1 tài khoản. 

Để tạo nhiều hợp đồng, bạn cần sử dụng các tài khoản phụ, kiểu như contract1.me.near, contract2.me.near.

Deploy và gọi tới hàm getCounter: 
yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: (.*), node.*/1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
Kết quả: 

View call: dev-1623290109414-64922580028342.getCounter({})
0
Tăng giá trị của biến counter lên 1: 

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
xem kết quả ở block testnet explorer: https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342

Tuyệt zời chưa :)) 

Để xem function, ta có thể sử dụng lệnh curl nhưng lại cần phải bóc tách dữ liệu, nên đơn giản hơn là ta sẽ viết một đoạn script, view function không cần phải dùng tài khoản NEAR:






node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
Phần code sau sử dụng RPC API tại https://docs.near.org/docs/api/rpc để truy vấn trạng thái của contract mint zodtv.near:

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
NEAR sử dụng đến đơn vị yocto, 1 yoctoNEAR = 1/10^24 NEAR nên 

3_000_000_000_000__000_000_000_000 yoctor NEAR 

sẽ bằng 3 NEAR 

Kết thúc bài đầu tiên trong loạt bài tích hợp giao thức NEAR vào ứng dụng web ở đây, phần tiếp theo chúng ta sẽ làm việc với web frontend và thực hiện lấy số dư, state và nhiều hơn nữa.

### NEAR Sputnik DAO : Autonomiser les Communautés

Les Open Web et Web3 viennent de l'idée que la prochaine génération d'Internet sera conçue et gouvernée par les personnes. NEAR a même codifié cela dans notre mission : permettre à tous de contrôler leur propre argent, leurs données et leur pouvoir de gouvernance.



	

	
	
		
			
				Selon vous, quel devrait être l'objectif principal d'un DAO ?
			
		

		
					

		
			
			
			
			Coordination des activités de la communauté 

		
			
			Faciliter le Mécanisme de Gouvernance
		
			
			Reproduire la structure de l'entreprise
		
			
			Faciliter la tokenomique
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Un très ancien article de blog (2014) du fondateur d'Ethereum, Vitalik Buterin, a décrit une nouvelle façon de penser l'action collective, où au lieu d'une entreprise avec des actionnaires, des dirigeants et des employés, il pourrait y avoir une organisation autonome décentralisée, ou DAO, où les membres possèdent une partie de l'organisation, contribuent ce qu'ils peuvent à son succès et sont récompensés proportionnellement à leur contribution. Il n'y a pas de patrons, pas de hiérarchie, et les participants sont unis par un objectif commun.

Je me souviens avoir été inspiré lorsque j'ai lu le message de Vitalik pour la première fois, imaginant un avenir véritablement communautaire où n'importe qui, n'importe où, pourrait formaliser un groupe et ses actions indépendamment des frontières, des lois ou des banques - un peu comme Web3 alimenté par la blockchain le fait pour le individuel, les DAO pourraient faire pour les communautés. Les entreprises finiraient par être remplacées par des DAO, qui présentent toujours de nombreuses fonctionnalités similaires à celles d'une entreprise, mais avec une plus grande flexibilité à la fois lors de leur création et au fil du temps, à mesure que les demandes et les priorités des personnes impliquées changent.

Cette vision est même antérieure à mon intérêt pour le Web3 et la blockchain. J'ai quitté l'Ukraine parce que je ne me suis jamais senti en sécurité pour créer une entreprise là-bas. Je ne pense pas qu'on puisse faire confiance à une banque ukrainienne pour stocker mon argent en toute sécurité. Le gouvernement a modifié les règles concernant la détention de devises américaines à plusieurs reprises au cours des dix dernières années (comme la nécessité d'en vendre la moitié à la réception de la monnaie locale). Il y a aussi beaucoup de corruption et une structure rigide autour de la façon dont les entreprises peuvent opérer en Ukraine. Dans de nombreux pays, la création d'une entreprise entraîne des frais généraux supplémentaires en raison de la corruption du gouvernement, de l'absence d'état de droit et des banques peu fiables qui peuvent disparaître.

C'est vrai partout, dans une certaine mesure : avant la blockchain, si les gens voulaient s'organiser en groupe formel, ils devaient demander une licence au gouvernement (par exemple créer une entreprise), surtout s'ils avaient besoin d'un compte bancaire et voulaient participer dans l'économie en tant que groupe. Ce processus est long, coûteux, complexe et l'organisation qui en résulte est soumise à des règles restrictives une fois qu'elle se forme.

Même la coordination communautaire informelle nécessite des règles et de la modération. Imaginez qu'un groupe d'étudiants en anime souhaite coordonner un événement international de fans, ou qu'un collectif d'artistes à succès du monde entier souhaite se réunir pour soutenir les artistes débutants. La coordination de la communauté pourrait inclure tout, d'une façon de publier de quelle manière les membres se penchent sur une question, de créer de l'art ou un produit ensemble, de lancer une application, d'investir dans des actifs numériques ou même de copropriétaire d'un canal social comme un compte Twitter. Tous ces éléments sont des exemples concrets de coordination qui nécessitent une certaine forme de gouvernance.

Pendant longtemps, j'ai cru en une myriade de petites équipes travaillant ensemble au lieu de grandes entreprises qui créent un monopole et se battent ensuite pour le préserver. En fait, il y a une dizaine d'années, des amis et moi avons créé l'entreprise ProstoKSI, qui était composée de développeurs travaillant ensemble sur des projets open source.

Web3 rend cette vision possible d'une manière que Web2 ne peut pas, en raison des garanties fournies avec la cryptographie. Imaginez-vous construire sur un fournisseur de cloud ou utiliser une banque qui est juste dirigée par un groupe de 20 personnes sans affiliation formelle et sans garantie que l'organisation fonctionnera toujours dans un an - il y a des limites à ce que vous pouvez construire dessus . Mais en crypto, l'infrastructure et les applications décentralisées sont fiables car elles sont open source, open state et viennent avec des garanties fiables. Les applications construites de cette manière fournissent des protocoles communs pour interagir les uns avec les autres, sur lesquels les autres développeurs, entreprises et utilisateurs peuvent s'appuyer.

Les DAO font partie de ces protocoles communs dans le nouveau monde. Au cours des sept années écoulées depuis que Vitalik a écrit ce message de très haut niveau, des milliers de membres ont expérimenté les DAO sur Ethereum et d'autres réseaux – certains des plus connus incluent Maker, Moloch DAO, MetaCartel, The LAO et Flamingo DAO. J'ai tiré quelques enseignements clés de la première vague d'expérimentation DAO qui ont éclairé la vision des DAO sur NEAR.

 	Il est généralement clair que les moyens simples pour une communauté de contrôler la gouvernance ne s'adaptent pas au nombre de personnes impliquées. Des milliers de personnes ne peuvent pas développer ou contrôler efficacement quoi que ce soit sans l'introduction de règles, de lois ou de hiérarchies. Nous avons également vu un certain nombre d'expérimentations dans l'espace blockchain autour de la gouvernance des protocoles et des fonds d'investissement. Beaucoup d'entre eux ont échoué pour diverses raisons, allant de problèmes techniques au manque d'intérêt des membres pour le vote ou à l'absence d'un facteur fédérateur et moteur.
 	On ne peut pas s'attendre à ce que chaque membre soit toujours heureux. Les intérêts dérivent et les opinions des gens évoluent ; des majorités et des minorités finissent par émerger autour d'un problème. Même si dans la plupart des cas, tout le monde tombera dans un consensus grâce à une gouvernance de base comme le vote, la minorité de la communauté devrait être en mesure de bifurquer ou de s'écarter du groupe d'origine pour suivre un nouvel ensemble de règles, à tout moment s'ils ne sont pas d'accord avec la majorité et en ont assez de leur propre volonté.
 	Toute communauté ou organisation a besoin de leadership. Même s'il s'agit d'un groupe de personnes très dévouées - s'ils ne travaillent pas à plein temps sur la cause commune, ils sont probablement trop occupés pour être actifs tout le temps et participer à chaque discussion ou décision. Les communautés ont généralement des membres dédiés qui sont responsables de la coordination, potentiellement de la modération.
 	Si une communauté est sans permission et pseudonyme, il est toujours utile d'avoir des membres publiquement connus pour être impliqués et créer le « noyau » de la communauté. La communauté écoutera les points de vue et les opinions de ces membres avant tout autre, car ils sont connus pour être les plus investis et les plus informés.
 	Plus une communauté décentralisée est axée sur le « produit », plus le leadership doit être ciblé, car le développement de produits nécessite généralement beaucoup plus de contexte que n'importe quel participant de la communauté. Par exemple, une communauté essayant de construire ensemble une blockchain ou un échange décentralisé.
 	La pondération purement basée sur les (staking) enjeux échoue toujours, soit parce que la majorité des parties prenantes ne sont pas capables ou ne veulent pas être des participants actifs, soit parce qu'elle ouvre des moyens faciles d'attaquer le processus de gouvernance.




	

	
	
		
			
				Le Sputnik DAO est-il créé spécifiquement pour les communautés techniques ?
			
		

		
					

		
			
			
			
			Oui
		
			
			Non
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ainsi, un DAO est une communauté unie autour d'un objectif commun, nécessitant des règles de coordination et de gouvernance, avec la flexibilité d'évoluer au fil du temps à mesure que les intérêts et les objectifs de la communauté évoluent, et la capacité d'effectuer des transactions et de gagner de l'argent en tant qu'unité avec un minimum de frais généraux. Avec tous ces apprentissages à l'esprit, nous avons décidé de créer un protocole DAO sur NEAR qui permettrait à toutes sortes de communautés - et pas seulement à celles gérées par des ingénieurs - d'avoir un cadre flexible et robuste pour travailler et évoluer ensemble.



	

	
	
		
			
				Laquelle des affirmations suivantes est/sont vraies à propos du leadership communautaire ?
			
		

		
					

		
			
			
			
			un véritable leadership garantit que chaque membre de la communauté est toujours heureux
		
			
			Les dirigeants communautaires ne sont pas obligés de travailler à temps plein pour la communauté
		
			
			même dans une communauté sans permission, il est important d'avoir des membres/leaders principaux
		
			
			les dirigeants de la communauté gouvernent la communauté en créant des règles
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Le protocole résultant, Sputnik DAO, offre un moyen pour les communautés et les organisations nouvelles et existantes du monde entier d'avoir une représentation en chaîne de leur groupe, de gérer leur activité en chaîne, de régir leur propre prise de décision et (surtout !) D'interagir avec d'autres DAO. Il existe actuellement environ 100 DAO Sputnik depuis le lancement initial en février 2021, avec ~ 500 000 $ alloués et ~ 500 000 $ contenus dans les trésoreries collectives (voir les statistiques ici).

Consultez spoutnik.fund et dites-nous ce que vous en pensez. La semaine prochaine, nous partagerons une version bêta V2 avec une nouvelle UX, de nouvelles fonctionnalités et un autre article avec des détails sur la façon dont Sputnik résout de manière unique les défis clés de l'organisation des communautés. Assurez-vous de suivre notre Medium pour être informé de la V2.

Merci au premier groupe communautaire de Sputnik pour ses idées pour la v2 ; Équipe NEAR

Tara Tan, Julia Lipton pour leurs commentaires et suggestions et

Mally Anderson pour l'édition lourde.
Article original sur Medium.

### NEAR Protocole et Polygone

Polygon a beaucoup gagné en popularité au cours des derniers mois. L'évolutivité étant à la mode dans la communauté Ethereum, il est logique que les solutions de couche 2 comme Polygon aient gagné un si grand nombre d'adeptes. Cependant, NEAR Protocol offre non seulement une plate-forme hautement évolutive sur la couche de base, mais il fournit également une expérience de couche-2 qui est EVM compatible ainsi . Aujourd'hui, comparons ces deux projets.
Qu'est-ce que le polygone ?
Donc, pour comprendre Polygon, examinons d'abord la couche-2. Dans le réseau Ethereum, la blockchain de base Ethereum est connue sous le nom de « couche 1 ». Les réseaux décentralisés donnent la priorité à la sécurité et à la vivacité, ce qui compromet inévitablement la vitesse. La solution ici est de construire un réseau supplémentaire au-dessus de la blockchain principale appelée couche-2. La blockchain délègue des calculs complexes à la couche 2, ce qui accélère de manière exponentielle le débit global. Polygon est un exemple de solution de couche 2.

Le jeton natif de l'écosystème Polygon est MATIC. Les principaux utilitaires de jetons de MATIC sont :

 	Fins de paiement et de règlement entre les participants.
 	Jalonnement et gouvernance. Plus vous misez MATIC, plus votre pouvoir de vote est important.
 	Payer les frais de transaction.
 	Récompensez les utilisateurs pour la fourniture de ressources et de services de calcul.

MATIC a une limite supérieure stricte de 10 milliards.
Mécanique des polygones
Polygon dispose d'un écosystème à plusieurs niveaux qui utilise des chaînes latérales compatibles EVM. Le but de ces chaînes latérales est de déboucher la chaîne principale. Les chaînes latérales sont des chaînes de blocs latérales qui sont liées à la chaîne principale via un ancrage bidirectionnel. La sidechain peut avoir ses propres règles et écosystème uniques. Périodiquement, les sidechains sont censés engager des données dans la blockchain principale pour assurer des opérations transparentes.

Les développeurs créent leurs propres chaînes latérales pour faire évoluer leurs applications en utilisant la pile Polygon SDK. Polygon a gagné en popularité principalement parce qu'il est beaucoup moins cher à utiliser que le réseau principal Ethereum et est beaucoup plus rapide.

Polygon utilise un mécanisme de preuve de participation (PoS), et n'importe qui peut devenir un validateur en jalonnant ses jetons MATIC. Les validateurs ont les rôles suivants dans l'écosystème :

 	Valider les transactions en approuvant et en confirmant les échanges dans les sidechains.
 	Les validateurs de réseau peuvent s'occuper de la gouvernance en votant sur diverses améliorations.
 	Responsable de la sélection des producteurs de blocs pour chaque point de contrôle (plus de détails dans un instant).

Les chaînes latérales polygonales sont une section des écosystèmes Ethereum dans laquelle les utilisateurs peuvent exécuter rapidement leurs projets sans se soucier des prix du gaz gonflés et de la lenteur du débit.

Comment Polygon assure la vitesse et la décentralisation

Le PoS de Polygon est principalement utilisé pour le « point de contrôle ». Cela signifie qu'une équipe de producteurs de blocs est nommée pour chaque point de contrôle, et ces producteurs sont chargés de maintenir et d'assurer le consensus. Avoir un nombre limité de producteurs permet à Polygon de former des blocs beaucoup plus rapidement qu'Ethereum (taux de bloc de 1 seconde au lieu de 20 secondes).

En plus de cela, Polygon assure la décentralisation en déléguant périodiquement des points de contrôle PoS à la chaîne principale d'Ethereum. Chaque bloc créé par le producteur de blocs doit être validé via une preuve de bloc engagée dans la chaîne Ethereum.

Comment interagir avec Polygon ?

Voici ce que vous devez faire pour interagir avec un projet basé sur la chaîne latérale Polygon :

 	Identifiez le contrat sur le réseau Ethereum et déclarez le nombre de tokens que vous souhaitez envoyer à la sidechain Polygon.
 	Un contrat intelligent spécial appelé "RootChainManager" active un autre contrat appelé "ChildChainManager". Ces deux contrats fonctionnent en tandem pour garantir que le nombre de jetons que vous bloquez dans le réseau Ethereum est transféré de manière transparente vers le réseau principal Mainnet.
 	L'utilisateur peut désormais passer au réseau Polygon et accepter ses jetons.

Bon, et l'inverse ? Et si vous vouliez quitter l'écosystème Polygon et retourner sur Ethereum ? Voici les étapes que vous devrez suivre :

 	Vous devez brûler vos jetons sur Polygon.
 	La vérification de cette brûlure doit être envoyée à la chaîne principale Ethereum.
 	Une fois vérifiées, vos ressources vous seront réaffectées dans votre portefeuille.

Qu'est-ce que le protocole NEAR ?
À l'été 2018, Illia Polosukhin et Alexander Skidanov ont créé le protocole NEAR en tant que plate-forme de développement idéale pour les applications décentralisées. La plupart des autres plates-formes souffrent de faibles vitesses, d'un faible débit et d'une mauvaise compatibilité avec les autres chaînes.

Le protocole NEAR est construit à partir de zéro et possède les fonctionnalités suivantes pour permettre une bonne évolutivité et une bonne sécurité :

 	NEAR utilise un mécanisme de génération de blocs appelé "Doomslug". Doomslug permet une finalité pratique ou "Doomslug", garantissant que les blocs reçoivent la finalité en quelques secondes.
 	NEAR est un système partitionné qui permet une évolutivité infinie. Il adopte une approche unique pour passer à des milliards de transactions de manière complètement décentralisée au lieu de dépendre de processus centralisés comme d'autres protocoles.

Qu'est-ce que le Sharding ?

En poursuivant avec le dernier point, comprenons ce qu'est le sharding. Le partitionnement est une technique utilisée dans les bases de données pour gérer des données volumineuses. Le partitionnement décompose l'ensemble de la base de données en morceaux gérables appelés « shards ». Ces fragments peuvent être traités en parallèle pour un calcul rapide.

Maintenant, que se passe-t-il exactement dans une blockchain pendant le sharding ? Nous allons jeter un coup d'oeil:

 	L'ensemble de l'état de la blockchain est divisé en fragments plus petits.
 	Chaque compte appartient à une partition unique et ils ne peuvent interagir qu'avec les comptes appartenant à la même partition.

Le problème avec le sharding normal est qu'il nécessite que les nœuds s'exécutent sur un matériel de plus en plus complexe, ce qui permet de réduire les barrières à l'entrée. Le sharding de NEAR permet aux petits nœuds de s'exécuter sur de simples instances hébergées dans le cloud.

Qu'est-ce qu'Aurora ?

Aurora fournit une expérience de couche 2 compatible avec Ethereum en plus de NEAR et se compose du pont Aurora et du moteur Aurora. Les développeurs d'Ethereum peuvent exécuter leurs applications dans Aurora pour profiter des nombreuses fonctionnalités positives de NEAR, telles que les frais d'essence et le sharding. Dans l'ensemble, voici les améliorations apportées par Aurora :

 	Les applications peuvent traiter des multiples de milliers de transactions par seconde. Il s'agit d'une amélioration exponentielle par rapport à Ethereum.
 	Aurora est extrêmement rapide car il a un temps de blocage de 2 secondes par rapport aux 15 d'Ethereum.
 	Le sharding de NEAR permet à l'écosystème d'évoluer horizontalement.
 	Les frais sur Aurora sont 1000 fois inférieurs à ceux sur Ethereum.
 	Entièrement compatible avec Ethereum via le protocole NEAR.

DeFi sur NEAR et polygone
DéFi de polygone
Polygon vous permet d'utiliser la plupart des applications DeFi populaires répandues sur Ethereum, comme Curve Finance, 1inch Exchange et Beefy Finance. Selon DappRadar, les 5 meilleures applications par les utilisateurs au cours des dernières 24 heures sont les suivantes :



Sushi semble être, de loin, l'application la plus populaire.

L'écosystème DeFi de plus en plus enragé de Polygon est un spectacle à voir. L'image suivante vous montre la valeur totale verrouillée (TVL) dans Polygon, qui est actuellement d'environ 5,19 milliards de dollars.



Le TVL a atteint un sommet de 10,54 milliards de dollars le 15 juin 2021. De plus, en ce qui concerne la valeur réelle verrouillée, Aave est – de loin – le plus grand protocole, représentant 40 % du total des TVL.
NEAR DeFi
Comparé à Polygon, NEAR DeFi a encore un très jeune écosystème qui n'a cessé de croître au cours des trois derniers mois. À l'heure actuelle, le TVL n'est que d'environ 141,72 millions de dollars.



L'application DeFi la plus dominante qui représente plus de 80% de la TVL globale est Ref Finance.

Ref Finance a quelques similitudes avec Uniswap V2, en plus il prend en charge plus de types de pool, des frais configurables, et il appartient entièrement à la communauté. Ref se trouve également être la première plate-forme DeFi sur NEAR. L'objectif principal de Ref est de rassembler DEX, protocoles de prêt, émetteur d'actifs synthétiques et plus encore sous un même toit.

NEAR a récemment lancé un énorme fonds de subventions de 800 millions de dollars qui vise spécifiquement à créer un écosystème DeFi plus grand et plus sain. Le fonds a des exigences majeures, parmi lesquelles :

 	100 millions de dollars pour les startups
 	Fonds régional de 100 millions de dollars
 	250 millions de dollars de subventions écosystémiques à répartir sur quatre ans

NFT sur NEAR et polygone
NFT polygone
Polygon est l'une des trois blockchains actuellement disponibles sur Opensea (l'un des plus grands marchés NFT au monde) avec Ethereum et Klaytn. Selon le classement du site, voici les 5 meilleurs NFT sur Polygon :



Il semble que ZED RUN soit le leader incontesté en matière de NFT de polygone.

Alors, qu'est-ce que ZED ? Il s'agit d'un jeu de course de chevaux numérique dont l'équité est prouvée et qui repose sur la blockchain. L'idée est que vous rassembliez autant de chevaux de course que possible pour créer une écurie de haute qualité.


NEAR NFT
Actuellement, il existe plusieurs plates-formes NFT sur NEAR comme Mintbase. Mintbase a été lancée en 2018 par Nate Geier et Calorine Wend et a levé 1 million de dollars lors d'un cycle de financement de démarrage en 2020. La plate-forme permet aux utilisateurs de créer et de vendre des actifs adossés à des NFT. De plus, les utilisateurs peuvent créer différents actifs numériques en tant que NFT. Ces actifs peuvent aller des billets d'événement à l'art cryptographique et tout le reste.



Chose intéressante, Mintabase était censé se lancer sur Ethereum. Cependant, les tarifs élevés du gaz et la congestion croissante les ont empêchés de le faire. Au lieu de cela, Mintbase considérait NEAR comme une meilleure plate-forme qu'Ethereum, avec des frais de gaz nettement inférieurs grâce à un modèle d'exécution de contrat plus efficace.
Conclusion
Polygon a beaucoup gagné en popularité au cours de la dernière année, la couche 2 devenant plus chaude que jamais. De plus, en raison de sa relation étroite avec la communauté Ethereum, il a connu un taux d'adoption rapide.

D'un autre côté, NEAR s'est montré très prometteur en résolvant les problèmes d'évolutivité avec le sharding. De plus, la subvention aux développeurs de 800 millions de dollars apportera une quantité importante de services publics au réseau. Les deux protocoles - Polygon et NEAR - fournissent une plate-forme parfaite aux développeurs pour construire une économie décentralisée évolutive et efficace.

### Exemple de Dapplet × NEAR

L'exemple Dapplet × NEAR est un Dapplet (une application d'augmentation) qui peut analyser les publications Twitter et les stocker dans le contrat NEAR. Il peut également afficher vos tweets enregistrés sur la page de superposition.
1. Introduction
Dapplets - applications qui interagissent avec les pages Web, les augmentent en insérant différents widgets, analysent les données des pages et ajoutent de nouvelles fonctionnalités. Ils peuvent améliorer l'expérience utilisateur lors de l'utilisation des médias sociaux, des services vidéo et d'autres sources.

Les dapplets utilisent l'extension que nous créons. Cette extension donne une API simple pour les développeurs de dapplets et de grandes capacités pour la communauté dapplets. Notre plateforme est décentralisée. Nous utilisons les réseaux NEAR et Ethereum pour nos registres et nos contrats. Nous utilisons également des stockages décentralisés, comme Swarm, IPFS et SIA pour héberger le code des dapplets et le multimédia.

Pour utiliser notre plate-forme dans un premier temps, vous devez installer l'extension Dapplets. Actuellement, il est au stade alpha et n'est pas publié sur Google Chrome ni sur aucun autre magasin. Pour l'installer, suivez ces étapes :

 	Ouvrez l'un des navigateurs suivants : Google Chrome, Firefox, Brave, Tor.

Les étapes suivantes sont décrites pour Google Chrome. Les étapes peuvent différer dans d'autres navigateurs.

 	Téléchargez l'extension de navigateur Dapplets.
 	Ouvrez chrome://extensions dans un nouvel onglet.
 	Activez le mode développeur et appuyez sur F5 pour actualiser la page.
 	Faites glisser et déposez le fichier téléchargé dans la page des extensions. L'extension s'installera automatiquement.Si vous utilisez Ubuntu ou éventuellement un autre système d'exploitation Linux, l'extension Dapplets peut disparaître des extensions Chrome après le redémarrage du PC. Pour éviter cela, décompressez l'archive et utilisez le bouton Load unpacked pour ajouter l'extension.
 	Cliquez sur l'icône d'extension Dapplets dans la barre d'extension. Essayez Dapplet × NEAR exemple dapplet.

2. Tutoriel
Étudions comment fonctionne ce dapplet et pourquoi Dapplet est une plate-forme NEAR conviviale.

Le but de cet exemple est de montrer l'interaction entre NEAR et Dapplet. S'il s'agit de votre première rencontre avec les Dapplet, nous vous recommandons d'essayer d'abord notre documentation. Il contient plusieurs exercices qui expliquent comment créer des dapplets et des adaptateurs, des plus simples aux plus complexes. Nous vous recommandons fortement de parcourir les exemples ex01 et ex04 qui décrivent comment créer les dapplets et les dapplets les plus basiques avec une superposition. Les connaissances que vous obtiendrez faciliteront la compréhension de l'exemple actuel.

Le code initial de cet exemple se trouve dans une branche distincte : exercice

Vous pouvez cloner ce dépôt. Cela ne fonctionnera pas directement. Essayez les étapes suivantes pour le démarrer.

Regardons la structure. Il y a trois composants : dapplet, overlay et contract.

Dapplet est le point d'entrée de l'application. Il utilise des adaptateurs pour l'interaction avec les pages Web, définissant des contextes à augmenter et des widgets à insérer. Vous pouvez trouver les fonctions de base de l'extension à l'intérieur d'un dapplet. Nous utilisons TypeScript dans notre projet.

Nous définissons Overlay comme un endroit où un utilisateur peut faire quelque chose avec des données analysées, se connecter aux fonctions principales de dapplet via le pont de dapplet et gérer les paramètres d'augmentation. Il s'agit d'une partie importante de l'application, mais elle s'exécute dans un autre environnement et est publiée en tant qu'ensemble séparé. Dans la plupart des cas, nous utilisons React comme l'un des frameworks les plus populaires. Mais vous pouvez utiliser un framework que vous préférez ou du pur JavaScript ou TypeScript.

Le contrat ne se connecte pas directement avec d'autres modules et peut être situé à l'extérieur du dapplet. Cependant, ce simple contrat NEAR est créé spécifiquement pour ce dapplet. C'est pourquoi il est pratique de le placer dans la structure de l'application.

Regardons chaque module.
2.1. Dapplet
Regardez le fichier /dapplet/src/index.ts.

Au début, nous créons une classe injectable avec le décorateur @Injectable et utilisons @Inject pour ajouter l'adaptateur Twitter en tant que variable de classe d'adaptateur. Créez également une méthode d'activation. Il s'exécute lorsque l'adaptateur sélectionné trouve un contexte spécifique et se charge. Il contiendra toute la logique principale.



Ajoutez le bouton à chaque tweet. Mettez ce code pour activer :



Regardez le code. Nous obtenons le bouton widget de l'adaptateur. Ensuite, exécutez la méthode de l'adaptateur attachConfig. Il reçoit un objet avec les noms de contextes, qui seront utilisés, comme clés. Les valeurs sont des fonctions qui reçoivent le contexte analysé comme seul argument et renvoient un widget ou un tableau de widgets. Vous pouvez également retourner null, false ou undefined.

Widget est une fonction qui reçoit un objet composé d'états de widget. Les paramètres d'état sont décrits dans la documentation des adaptateurs. Vous pouvez trouver la documentation de l'adaptateur Twitter ici. Dans notre cas, nous ajoutons une image au bouton et à l'info-bulle. exec est une fonction qui s'exécute lorsque vous cliquez dessus. Maintenant, nous montrons simplement le contexte analysé dans la console.

Exécutez le dapplet :


⚠️ Étant donné que le navigateur bloque les pages contenant des certificats de sécurité problématiques, accédez à https://localhost:3001/dapplet.json lorsque l'application est en cours d'exécution et acceptez de l'exécuter en mode non sécurisé.
Ouvrez l'extension. Accédez à l'onglet Développeur et activez le serveur de développement : https://localhost:3001/dapplet.json.



Activez l'onglet Dapplets. Vous verrez le badge de développement NEAR de notre dapplet. Allume ça.



Vous pouvez maintenant voir des boutons supplémentaires sur nos tweets. Cliquez sur le bouton et ouvrez la console. Vous verrez le contexte analysé du tweet.



Vous l'avez fait ! Toutes nos félicitations!!! Revenez au code.

Nous voulons montrer les données analysées non pas dans la console mais aux utilisateurs. Nous utiliserons une superposition pour cela. Mais avant d'implémenter la superposition, ajoutez la logique d'interaction entre le dapplet et la superposition au dapplet.

Modifions notre code. Ajoutez une variable de classe privée _overlay de type any. Dans l'activation, ajoutez le code suivant :



La fonction principale Core.overlay (les problèmes de frappe seront bientôt corrigés) reçoit un objet avec un nom de l'overlay et un titre d'overlay et renvoie l'objet Overlay que nous sauvegardons dans la variable _overlay.

Ajoutons la méthode openOverlay à la classe :



Dans cet exemple, nous appelons la méthode send the overlay. Il prend deux arguments : le nom de ces données et les données à envoyer à l'overlay.

Ajoutez openOverlay à la fonction exec et transmettez le contexte analysé à la superposition. Voici le code actuel du dapplet :



Ouvrez le manifeste ./dapplet/dapplet.json.


⚠️ Étant donné que le navigateur bloque les pages contenant des certificats de sécurité problématiques, accédez à https://localhost:3000 lorsque l'application est en cours d'exécution et acceptez de l'exécuter en mode non sécurisé.
Ici, nous voyons l'URL de l'overlay nommé 'overlay' qui sera utilisé en mode développeurs. Lors de la publication du dapplet dans le registre, la superposition sera publiée dans le stockage décentralisé.

Nous voyons également l'adaptateur Twitter dans les dépendances. Nous utilisons la version 0.9.0 dans l'exemple.

Passons à l' overlay.
2.2. Overlay
Comme nous l'avons mentionné précédemment, la superposition peut être créée comme vous le souhaitez. Nous utilisons React dans la plupart de nos projets. Nous n'analyserons pas l'intégralité du code d'overlay, mais uniquement les points importants pour nos aspects architecturaux.

Pour interagir avec le dapplet, installez le package npm @dapplet/dapplet-overlay-bridge :



Pour obtenir les données du dapplet, nous avons besoin de la classe Bridge dans la partie overlay. Regardez le module ./overlay/src/dappletBridge.ts. Voici la méthode onData où nous souscrivons à l'événement 'data', que nous avons décrit dans le dapplet.



Ensuite, nous l'utilisons dans le module App.tsx.



Enregistrez maintenant les modifications et rechargez la page Twitter. Lorsque vous cliquez sur le bouton, vous verrez la superposition avec les données de tweet sélectionnées.



C'est super! Mais notre objectif est de sauvegarder ces données dans la chaîne NEAR et de les récupérer. Voyons donc le contrat.
2.3. NEAR smart contract
Regardez le e module ./contrat. Il existe un simple contrat intelligent NEAR écrit en AssemblyScript avec create-near-app.

Dans ./contract/assembly/index.ts, nous voyons un PersistentUnorderedMap nommé tweetsByNearId. Il stocke un tableau de données de tweets sérialisés avec l'ID utilisateur actuel. Il a des méthodes pour enregistrer, supprimer et récupérer les tweets enregistrés.

Vous pouvez trouver toutes les données nécessaires sur la façon d'écrire, de tester et de déployer des contrats intelligents NEAR dans la documentation officielle et les cours et guides Learn NEAR.

Voyons comment se connecter au contrat intelligent et utiliser ses méthodes dans le dapplet.

Ajoutez le code suivant à la méthode activate du module ./dapplet/src/index.ts :



Il existe une méthode Core.contract qui reçoit 3 paramètres : le nom du réseau ("near" ou "etherium"), le nom du contrat et l'objet avec les méthodes de visualisation et de modification.

Nous allons maintenant rendre les méthodes de contrat disponibles dans la superposition. Afin de transmettre les méthodes via le pont dapplets, ajoutez une fonction d'écoute à l'appel de superposition. N'ayez pas peur, copiez et collez simplement ce code:)



Les trois dernières fonctions asynchronies passent nos méthodes de contrat à l'overlay. Les quatre premières fonctions doivent associer le portefeuille au dapplet. Pour obtenir l'objet Wallet, nous utilisons la méthode Core.wallet, avec des paramètres nommés name (near ou ethereum) et network. Le portefeuille a les méthodes isConnected, connect, disconnect et paramètre accountId.

L'étape suivante consiste à modifier ./overlay/src/dappletBridge.ts. Nous devons rendre les fonctions décrites dans le dapplet, disponibles dans l'overlay. Copiez le code suivant dans la classe Bridge :



Nous pouvons maintenant utiliser des méthodes de contrat dans les modules de superposition. Nous pouvons autoriser le dapplet avec le portefeuille NEAR testnet et enregistrer les données des tweets sélectionnés dans le contrat intelligent. Nous pouvons également voir nos données enregistrées dans la superposition.

Désengagez tout le code validé dans le fichier ./overlay/src/App.tsx. Enregistrez les modifications et rechargez la page Twitter.



Une cerise sur le gâteau sera l'ajout de la possibilité d'afficher les tweets enregistrés sans en analyser les nouveaux. Pour ce faire, il suffit d'ajouter la méthode Core.onAction à l'activate dans ./dapplet/src/index.ts et de lui passer la fonction d'ouverture de l'overlay.



Vous verrez maintenant l'icône d'accueil près du nom des dapplets.



Un clic sur le bouton ouvre une superposition avec les tweets enregistrés.



Félicitations à tous ceux qui sont arrivés à la fin du tutoriel ! Nous espérons qu'il a été couronné de succès.

Voici le résultat : dapplets-near-example

Si quelque chose n'a pas fonctionné pour vous, ou si vous avez encore des questions, vous êtes les bienvenus sur nos chats dans Discord et Telegram.

Merci pour votre temps. Nous espérons que ces nouvelles connaissances seront utiles et que vous continuerez à développer des applications impressionnantes et réussies sur la plate-forme Dapplet en utilisant les capacités du protocole NEAR 🚀✨
Contacts:
Web: dapplets.org
Docs: docs.dapplets.org
GitHub: github.com/dapplets
Discord: discord.gg/YcxbkcyjMV
Telegram: t.me/dapplets
Twitter: @dappletsproject

### Update - December 21, 2021

Brief Summary:

 	December nLEARNs Redeem to NEAR Window was the BIGGEST in 2021!

Results:

 	💸 Ⓝ700 sent to 350 (L)Earners, including some Sybil attackers ;(
We are working on improving Sybil attacks resistance, any feedback on this is more then WELCOMED!
Congrats and happy (L)Earning!
 	🤑There are about Ⓝ30 unclaimed  at Tip with NEAR for Twitter. So please check if some of them are waring for you.

Instructions are here https://github.com/dapplets/tipping-dapplet 
Tweet a cool twit tagging  @LearnNEAR and @dappletsproject   and get tips in $NEAR


 	📒 What Is Tokenomics? Express Guide + Create your OWN token on NEAR Testnet
 	🦧You can use NEAR NFTs as LNC Profile Picture:


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC Barrel - NEAR Fortified Developer invite-only accelerator is coming soon!

### NEAR Live Révision des contrats | Partie 4 : Berry Farm

Introduction
C'est Eugene , et aujourd'hui nous allons parler du contrat Berry Farm qui est le supplément de Berry Club qui vous permet de convertir vos bananes en concombres, et de cultiver NEAR. Faisons d'abord un examen rapide de la Berry Farm. Le référentiel peut être trouvé sur mon Github. Voici la vidéo originale sur laquelle ce guide est basé :


UI


 

Berry farm est une application très bien conçue avec du texte volumineux et de nombreux emojis. La façon dont cela fonctionne est qu'il affiche vos soldes une fois que vous êtes connecté. Il les extrait de deux contrats différents ainsi que de votre compte. Il les combine à partir de plusieurs sources. L'avocat et les bananes proviennent du contrat Berry Club, les concombres sont locaux pour ce contrat et NEAR provient du solde de votre compte. Si vous avez formé quelque chose, vous obtenez des récompenses lorsque les récompenses sont distribuées. Il semble que quelqu'un ait récemment acheté beaucoup d'avocats et que les récompenses aient en fait augmenté. Il a également des statistiques mondiales, ce qui signifie que 2 500 NEAR ont été transférés de Berry Club à Berry Farm. J'ai gagné 116,9 NEAR et ma récompense sera de 0,014332 NEAR en fonction de la quantité de concombres que j'ai par rapport au nombre total de concombres.



Le nombre total de concombres est de 54116.4. Je reçois une part de 3% de cette récompense à chaque fois qu'il y a une récompense. Ainsi, lorsque je clique sur Actualiser, j'actualise essentiellement les statistiques de plusieurs comptes et je peux réclamer NEAR qu'elles soient transférées du contrat vers mon compte. Je peux aussi troquer des bananes contre des concombres et je fais appel au contrat Berry Club.





Je vais transfer_with_vault qui utilise la nouvelle norme, et cela nécessite une petite quantité de NEAR, et je pense que c'est comme 1 yocto NEAR pour confirmer que je ne fais pas cela via une clé d'accès. Je ne peux pas effectuer de virement via une clé d'accès afin d'éviter un retrait automatique, et ce n'est qu'un dispositif de sécurité. Si, par exemple, vous autorisez Berry Club à partir d'une autre application qui essaie de vider toutes vos bananes, cela échouera, car il ne pourra pas appeler transfer_raw ou transfer_with_vault. Pour clarifier, transfer_raw est le nouveau nom pour transférer sans contrat afin que vous puissiez simplement déposer avec le compte de quelqu'un qui existe, et dans transfer_with_vault le coffre-fort appelle le destinataire pour retirer des jetons.



J'ai dépensé 10 bananes pour obtenir plus de concombres, et je peux à nouveau rafraîchir la balance pour voir si quelqu'un a retiré quelque chose. C'est ainsi que fonctionne l'interface utilisateur, mais il y a plus de fonctionnalités que cela. Le contrat prend en charge les concombres en tant que jeton fongible, ainsi que les bananes. Vous pouvez potentiellement créer une autre application qui transfère des concombres et il y en a une autre qui est Banana Swap que Vlad Garchina a construite.



Il s'agit d'un uniswap simplifié avec un seul pool où vous pouvez acheter et vendre des bananes. En fait, je ne l'ai pas essayé avant. Je veux obtenir 1 NEAR valeur de bananes que je dois vendre pour 6 bananes. Voyons si cela fonctionne.





Il appelle les transferts du Berry Club qui est à nouveau en cause, mais vers un contrat différent. Nous n'affichons actuellement pas d'arguments, mais nous finirons par le faire.



Cela dit que j'ai transféré, et j'en ai eu 1 NEAR sur lequel j'ai dépensé 6 bananes. Plutôt cool.



Vous ne pouvez pas augmenter la liquidité et il faut une réduction de 10 %. Voici donc l'interface utilisateur.
Vérification de contrat
Berry Club
Permettez-moi de présenter le contrat. Nous allons donc commencer par le contrat Banana Farm, mais vous devrez probablement jeter un œil au contrat de jeton de pixelboard, au contrat de Berry Club, ainsi qu'à celui qui envoie des jetons.



Berry club a un contrat codé en dur appelé farm contract id.



Lorsque vous dessinez, il vérifie que vous ne dessinez pas de pixels vides, sinon vous pouvez simplement déclencher une récompense sans dépenser d'avocat.



Ensuite, il appelle may_send_reward qui obtient l'heure actuelle de la blockchain et vérifie que next_reward_timestamp est inférieur à l'heure actuelle.



La récompense suivante est soit le début du temps d'agriculture qui était un horodatage global qui activait à l'origine un compte à rebours de 26 heures ou last_reward_timestamp lorsque nous l'avons déclenché pour la dernière fois plus 60 secondes.



Donc, s'il est temps d'envoyer la prochaine récompense, il se souvient de l'heure actuelle et calcule la récompense en fonction de cette logique. Il prend donc le solde actuel de Berry Club, prend le stockage actuel, calcule le stockage en fonction du coût de stockage plus une barre de sécurité marge de sécurité, qui est de 50 NEAR.



Il garde toujours 15 NEAR pour les soldes futurs. Ensuite, cela dit si le solde est disponible, si notre solde est supérieur au montant dont nous avons besoin pour le stockage plus la sécurité, alors nous calculons le solde liquide et nous le divisons par la portion de récompense que nous donnerons à chaque fois, soit 24 fois 68. Si vous l'appeliez toutes les minutes, vous videriez la majorité du compte, mais il diminue toujours en quelque sorte sur lui-même, car le solde diminue sur lui-même, mais il donne principalement tout le solde en une journée si vous l'appeliez toutes les minutes. . Tout d'abord, vous ne pouvez pas produire un bloc horodaté plus tôt, puis vous ne pouvez pas produire un bloc au-delà de votre slot, vous avez un slot dédié lorsque vous devez produire un morceau. Donc, tout ce que vous pouvez faire est de produire une partie du bloc final à la dernière milliseconde de votre emplacement, ce qui est une seconde d'avance. Vous ne pouvez pas vraiment le faire avancer, sinon tous les autres nœuds casseront également le protocole, ils sont donc limités par leur compréhension du temps et de la barre qu'ils utilisent pour décider d'accepter ou non un bloc, donc vous ne pouvez pas accélérer vraiment le temps, à moins que tous les validateurs ne veuillent le faire. Cela signifierait que nous aurons les validateurs qui cesseront essentiellement de suivre le protocole. Ils doivent coordonner leur temps.



Donc, à la fin, il a obtenu la récompense, il dit que je vais distribuer cette récompense, et ce qu'il fait, c'est qu'il appelle le contrat de ferme et appelle take_my_near et il ne passe tout simplement aucun argument et passe sa récompense et son gaz. Juste une quantité minimale de gaz nécessaire pour ajouter les soldes. C'est ainsi que Berry Club a été mis à jour pour commencer à distribuer des récompenses après chaque tirage potentiellement. Il en faut un peu plus. Il utilise du gaz qui a été dépensé pour le tirage pour réellement distribuer la récompense de temps en temps, ce qui nécessite environ 10 téra de gaz pour cela.
Berry Farm
Allons à Berry Farm et commençons par ce contrat. La façon dont fonctionne la ferme de baies doit, en temps constant, pouvoir distribuer des récompenses en fonction du nombre total de concombres, ce qui n'est pas une tâche triviale, c'est un peu similaire au pool de jalonnement et à la façon dont le pool de jalonnement distribue les récompenses. Le pool de jalonnement crée un tas d'actions pour chaque dépôt que vous effectuez et l'action a un prix mondial actuel qui dit : « Hé, j'ai acheté ou émis plus d'actions, et maintenant mes actions peuvent être échangées contre un nombre donné de jetons NEAR ». Le cours de l'action commence à partir de 1 yocto NEAR par action, puis plus vous accumulez de récompenses, plus le prix des actions augmente. Lorsque vous utilisez un jalonnage, vous vendez des actions au prix actuel, et vous récupérez NEAR, et ce n'est pas jalonné, et il arrondit à la baisse. Le défi, c'est que lorsque vous misez des concombres, le prix d'un concombre est de zéro, et lorsque vous les misez pour la première fois, vous ne pouvez pas vraiment acheter d'actions et d'actions de menthe, car leur prix est de zéro. La logique des actions ne fonctionne pas très bien pour cela, donc pour cette chose, j'avais besoin de créer quelque chose de différent pour faire la comptabilité. Entrons dans les exemples. Disons que Mike est la première personne à avoir déposé 10 concombres sur le contrat, puis disons que 100 NEAR ont été distribués. Mike prendra toutes les récompenses car il est le seul, il contrôle désormais 100% des parts de la Berry Farm. Mike était hors ligne par exemple, et ne les a pas réclamés, nous ne pouvons donc pas vraiment mettre à jour son compte, car cela doit être fait en temps constant. Nous ne pouvons pas parcourir tous les comptes, mais nous devons d'une manière ou d'une autre nous rappeler que Mike a tout NEAR pour ses concombres. Supposons maintenant que Josh entre et mise 10 concombres supplémentaires, maintenant que la part de Mike est de 50 % et la part de Josh de 50 %, mais Josh a misé les concombres après que ces 100 NEAR initiaux aient déjà été distribués. Il n'a droit à rien de tout cela maintenant 100 autres NEAR drops. Mike doit maintenant en obtenir 50 de plus, car il détient 50% du capital et Josh en obtient 50 NEAR. Lorsque Mike revient en ligne, nous devons pouvoir afficher son solde à 150 NEAR qu'il a gagné en temps constant. C'est donc le défi que nous devions relever avec ce contrat, et la façon dont il a été résolu est d'avoir un ratio global appelé near par concombre qui indique combien NEAR est reçu par un solde de concombre donné lorsqu'un compte est créé, ou touché de quelque manière que ce soit. On se souvient de la dernière valeur de cette fraction.



Ensuite, nous avons un solde NEAR, donc si la dernière fraction était inférieure à la fraction actuelle, cela signifie que nous pouvons multiplier les concombres du compte donné par la différence entre 2 fractions, et calculer à combien NEAR j'ai droit. Lorsque le compte de Mike a été créé, la fraction était de 0 divisée par un et lorsque 100 NEAR ont été déposés là où le nombre total de concombres était de 10, cette fraction est devenue égale à 10. Puis, une fois que Josh a rejoint et a laissé tomber 10 autres concombres au total, et encore 100 NEAR ont été distribués, cette fraction a été augmentée de 5, car il y avait un total de 20 concombres et 100 NEAR. Donc 100 NEAR divisé par 20, cela signifie 5 NEAR par concombre donc cela est devenu 15. Maintenant, quand Mike revient, il regarde son solde de concombre qui est de 10 near par concombre sur un contrat global est de 15 sa dernière valeur mémorisée est zéro donc il prend juste la différence qui est 15 multipliée par 10 et réclame ce solde dans NEAR, et ce 1 est ramené à 15. Lorsque Josh revient, il obtient cette valeur qui était à 10, et il a 10 concombres et la valeur actuelle est 15. La différence est de 5 multiplié par le solde du concombre de 10 donc il obtient 50 NEAR. C'est ainsi que nous gérons le solde NEAR et que nous nous approprions les récompenses reçues des personnes en utilisant un temps constant pour le recalculer. Donc au lieu de garder une fraction entière en mémoire donc on utilise un dénominateur global qui est fixe et je l'ai utilisé à 10 puissance 18 qui est la même que la précision des concombres, bananes et avocats. C'est l'arrière-plan de la façon dont tout est calculé.



Regardons la structure main du contrat, un contrat appelé ferme. Il dispose d'une carte de recherche de comptes et utilise des hachages courts similaires aux jetons fongibles avec des coffres. Il a l'identifiant du compte du jeton banane qui peut également être codé en dur, mais il a été utilisé à partir du contrat car nous pouvons le transmettre, car ce compte a été déployé après et je ne voulais pas mettre à niveau l'état du contrat Banane Berry Club. Je ne voulais plus modifier l'état par évolutivité, j'ai donc codé en dur la valeur dans le contrat précédent. Près du concombre, la fraction que j'ai expliquée plus tôt, est le numérateur et le solde total du concombre est nécessaire comme dénominateur. Les coffres et le vote suivant sont utilisés pour les transferts ; en fait, ils n'ont probablement jamais fini par s'habituer à transférer des concombres, sauf peut-être une fois pour un test.



C'est ce que nous avons vu auparavant, c'est encore une fois un hachage de l'identifiant du compte.



La structure du compte est la dernière valeur avant que le compte ne soit touché avec cette fraction. Le near_balance est le solde non réclamé. Chaque fois que vous touchez un compte soit en déposant plus de concombres, soit en réclamant NEAR, il met à jour la dernière valeur et déplace tous les NEAR non réclamés vers votre solde local de la différence, et le solde de concombre est votre solde en concombres. Le near_claimed correspond aux statistiques, qui indiquent simplement le montant de la récompense que vous avez déjà réclamée. Ce n'est pas nécessaire pour la logique du contrat.



Il y a deux structures d'assistance juste pour le front-end. Le HumanAccount renvoie les valeurs d'une manière plus lisible et HumanStats est des statistiques globales pour la consommation. Allons dans la fonction take_my_near pour voir comment cela fonctionne.



La première chose que nous faisons est de vérifier qu'il y a suffisamment de concombres là-bas, car nous l'utilisons comme dénominateur. Nous voulons juste qu'un concombre déclenche cela, et ce n'est qu'une précaution. Vous n'aimez pas déclencher ce genre de choses. Explorons cette valeur. Ce qui se passe, c'est que vous obtenez le montant de NEAR, et yocto NEAR, et vous le multipliez par le dénominateur global. Vous résolvez donc une fraction qui est NEAR par concombre divisé par le dénominateur plus le solde attaché divisé par le solde total de concombre. Voici la formule : near_per_cucumber / denom + attachment_deposit / total_cucumber_balance. Ainsi, new_near_per_cucumber est en fait le numérateur avec attach_deposit et le dénominateur ensuite divisé par le dénominateur. Voici la formule : new_near_per_cucumber = (near_per-concumber_numer +denom + dépôt attaché) / denom. C'est la formule que nous utilisons pour calculer le new_near_per_concombre. Chaque fois que vous touchez un compte, votre solde actuel non réclamé devient toujours un nombre fixe, puis vous pouvez modifier n'importe laquelle des valeurs sans rompre la logique. Cette méthode tactile est appelée par chaque getter et chaque méthode de changement. Avant de modifier le compte, il appelle toujours toucher sur le compte



Par exemple, dans get_near_balance, nous obtenons le compte interne. Si le compte existe alors nous le touchons localement. Ensuite, nous devrions obtenir le near_balance



Si vous obtenez le compte que nous touchons avant, obtenez votre quasi_balance, votre cucumber_balance et votre solde de réclamation. Ce sont des fonctions d'affichage qui changent les choses, mais elles ne les enregistrent pas, elles modifient donc temporairement la valeur du compte et ne la sauvegardent pas. Il fait juste une touche qui est une sorte de recalcul avec la dernière valeur



Il l'enregistre lorsque vous effectuez un appel de modification, par exemple, appelez à claim_near. Nous obtenons votre compte et get_mut_account touche réellement le compte. Vous obtenez le compte qui est déjà mis à jour et near_balance est le solde réel. Cela met le Near_balance à zéro, cela veut dire que vous avez réclamé tout cela, et cela sauve votre compte. Ensuite, si vous réclamez une valeur positive, nous vous la transférerons à partir de votre compte. Il renvoie combien NEAR vous avez réclamé. La beauté de cette méthode tactile est qu'elle peut être appelée à tout moment. Il n'a pas besoin d'être appelé à un moment donné, il vous donnera donc toujours le même résultat, que vous l'ayez appelé deux fois au milieu ou une fois. C'est juste pour rendre à l'utilisateur combien il a. Il vous indique simplement combien NEAR vous avez gagné en calculant à partir de l'état actuel. Au Berry Club, nous faisons les mêmes choses que nous avons également touchées, et cela est nécessaire, car disons que vous voulez savoir combien de bananes vous avez cultivées. Puisque nous savons la dernière fois que vous avez touché votre compte, quand vous avez dessiné quelque chose pour la dernière fois, nous savons combien de pixels vous avez. Nous pouvons calculer à partir d'un instant donné jusqu'à l'instant précédent multiplié par le nombre de pixels que vous aviez combien de bananes vous devriez avoir en ce moment, et le frontal fait exactement la même chose. Le frontal le simule, il obtient les mêmes informations à l'exception des dernières, puis il crée simplement une minuterie qui la calcule. En théorie, la méthode get_near_balance n'a pas à renvoyer votre valeur NEAR qui est à jour, vous pouvez simplement dire que voici le total NEAR par concombre et votre dernier total NEAR par concombre et également votre dernier NEAR solde, mais à la place, cela se fait sur le niveau du contrat. Disons que nous n'avions pas de méthodes d'affichage pour lesquelles vous ne payez pas et ne renvoyez et récupérez qu'un état, alors vous devriez faire cette logique sur le front-end au lieu de le faire ici en mémoire.
Token.rs
La dernière logique que nous devons faire est en fait de savoir comment vous recevez vos concombres de Berry Club, et cela se fait en utilisant transfer_with_vault de Berry Club. Nous avons discuté précédemment du fonctionnement de la carte 122.



Vous transmettez le receiver_id, le montant et la charge utile. Il a un chèque assert_paid qui vérifie simplement que le dépôt est positif. Cela dit, vous avez besoin d'au moins 1 yocto NEAR pour empêcher les appels de touches d'accès aux fonctions afin d'éviter qu'une interface utilisateur Berry Club malveillante ne draine toutes vos bananes. Il récupère le gaz, puis lance un appel qui met des bananes dans un coffre-fort. Il initie également un appel vers le récepteur. Dans ce cas, nous l'appelons un contrat à la ferme et il transmet à l'identifiant de l'expéditeur une quantité de bananes, un identifiant de coffre qui est juste un u64 sans JSON et une charge utile qui est une chaîne. Dans l'exemple précédent, lorsque nous parlions de la carte 122, la charge utile était un binaire de vec q8 en base64, car il s'agissait d'une charge utile sérialisée borsh. Au cours de la discussion, j'ai noté que si vous examiniez cet argument dans un portefeuille, vous ne pourrez pas voir la charge utile que vous souhaitez faire. Par conséquent, dans cette implémentation de contrat, nous utilisons en fait JSON pour la charge utile afin d'insérer le JSON du charge utile de chaîne. C'est une énumération avec une seule option appelée deposit_and_stake.



Maintenant, lorsque vous effectuez un appel de fonction à partir de l'interface utilisateur de la ferme qui ira au portefeuille dans les arguments, la charge utile sera comme une chaîne adjacente dans une chaîne indiquant le dépôt et la mise au lieu d'être un zéro encodé comme base, au lieu d'être un borsh version sérialisée, c'est une version lisible par l'homme. Ce contrat a des types de charge utile différents de ceux d'Uniswap, par exemple, il aura une charge utile indiquant combien NEAR vous souhaitez recevoir au maximum ou recevoir au moins. L'interface utilisateur malveillante d'Uniswap peut simplement remplacer cette valeur, et si vous ne l'avez pas vérifiée du côté du portefeuille, vous pouvez en fait tomber sous la tendance avant. Nous avons obtenu le compte en utilisant get_mut_account qui obtient soit un compte existant, soit crée un nouveau compte où il définit tous les soldes sur 0, mais le dernier numérateur proche par concombre est le numérateur global actuel. Cela signifie que vous n'avez rien cultivé et que votre solde de concombre est nul. Il touche de toute façon même s'il n'en a pas besoin, nous aurions pu l'éviter si nous avions mappé, puis il renvoie le hachage et le compte. Le compte est déjà à jour. Ce que nous faisons, c'est d'abord augmenter le solde total du concombre, puis le sauvegarder dans l'état du compte et nous augmentons également le solde global du concombre du nombre de concombres déposés. Ensuite, nous ne vérifions pas vraiment que le coffre-fort contenait des concombres, nous pensons donc que l'appelant précédent, qui est un contrat de banane, a effectivement mis les bananes dans le coffre-fort, et nous retournons la promesse en dehors de cette méthode. C'est une correspondance étrange avec une seule entrée car la charge utile ne peut être qu'un seul type pour le moment. Nous appelons remove_from_vault, nous indiquons le montant que nous voulons retirer, qui est le montant total, puis nous le rappelons à l'identifiant du compte du jeton banane qui est un contrat Berry Club. Même ainsi, ce contrat n'a pas encore reçu de bananes, il s'en moque car il n'utilise de toute façon pas de bananes. Il n'a pas besoin de bananes avant de pouvoir continuer, donc peu importe combien de temps il va y planter des concombres, et le coffre-fort est déjà verrouillé. Il augmente le solde total du concombre en diluant les parts. Désormais, lorsque take_my_near arrivera, il utilisera le nouveau solde total de concombre. Maintenant, je vais répartir le nombre d'actions entre tous les participants.
Conclusion
C'est l'aperçu des contrats Berry Club, Berry Farm et token.rs. Merci d'avoir lu et bonne chance dans vos futurs projets avec NEAR.

### TokenHub Beta test

Requirements

Test duration: Dec 16 - Dec 19

Note: for easier testing, when you do A. Create token, you should leave Vesting start time as default so that you can claim the initial release right away.

A. Create token

 	Login with NEAR testnet account to https://tokenhub.haiyenvinhomes.com/
 	Go to Create Token, fill the options as your wish and click Create. It will cost you 8 Near for token issuance. The process should finish in < 1 min.
 	Go to My Token to confirm you have it in the list.
 	Screenshot My Token page at this link.
 	Make a tweet about your activity. Include the text: I’ve created my own token at https://tokenhub.haiyenvinhomes.com/ - a project from @LearnNear portfolio

B. Claim the initial release

 	Login with NEAR testnet account to https://tokenhub.haiyenvinhomes.com/
 	If you do as per instructions in Note, you can do the claim right away.
 	Go to My Token page to claim your token. As this is the first claim, you need 0.0125 NEAR for the token storage deposit first. After that, you can claim normally.
 	Check your wallet to see if your claim succeeded.

C. Claim the recurrent release

 	Do this action on the next day since the vesting interval is 1 day
 	Login with NEAR testnet account to https://tokenhub.haiyenvinhomes.com/
 	Go to My Token page to claim your next release of this vesting interval.
 	Check your wallet to see if your claim succeeded.
 	You can claim at most one time per vesting interval until you get all your allocation. Since the vesting interval is 1 day, you will need to wait until next day to get the next release.
 	Finally, fill the feedback form.

The top 20 beta testers will get 2NEAR, the best feedback submitter will get 10 NEAR. Please make sure your testnet and mainnet account MATCH exactly. - eg. john.testnet and john.near.

Happy testing!

### What Is Tokenomics? Express Guide

One of the core tenets of a decentralized network is its tokenomics. To help projects better understand the nuances of their tokens, Learn Near Club helped to launch a new hands-on tokenomics playground on NEAR Testnet - LNC|TokenHub. However, before we get into the details, let’s know what tokenomics means.
What Is Tokenomics?
Token was initially just another term for a “cryptocurrency” or “cryptoasset.” However, lately, we have used the term “token” to explain a crypto asset that’s issued on top of a blockchain. The term “tokenomics” is a portmanteau of “token” and “economics,” and it’s a term used to describe, you guessed it, the economics of a token.

When you want to gauge the tokenomics of the network, you need to ask yourself these questions:

 	What is the total supply of the tokens, and how many of them are entering the system at once?
 	How many tokens will be created in the future?
 	How are the tokens being distributed among the users?
 	What is the exact role of the token in the network?
 	Does the network need a token to function?

Overall, the purpose is to establish a clear link between the platform and the asset.
Elements Defined In Tokenomics
Tokenomics can be broadly differentiated between supply control and utility. Let’s look at each of these elements.
#1 Supply Control
How much of the protocol tokens are actually going to be in circulation. How much of the supply is being controlled by the base contract? In this aspect, we must understand certain terms.

Premining

Basically, how many tokens are already floating around in the ecosystem at the launch time. Usually, tokens are mined out periodically by specialized users called “miners.” However, specific protocols often make a certain % of their overall supply available during launch for token distribution and access to liquidity. However, do note that premining a large number of tokens could lead to centralization concerns. 

Token Allocation

How are the tokens allocated to the project team? Do they calculate a vast amount of tokens, leading to centralization issues? How much of the tokens are allocated to the treasury for future protocol development?

Token Vesting

Most projects receive funding from VCs or other investors, who get a token allocation in return for their investment. Unfortunately, more often than not, the VCs tend to dump their allocation immediately to make a quick profit, which inevitably damages the protocol. You can lock up a particular token allocation for a specified time period with token vesting to prevent a massive sell-off.

Token vesting is crucial in inspiring investor confidence since it tells them that the team and investors are serious about the project and not looking for a quick payoff.  Vesting is an easy way to lower market manipulations and guarantee value for investment.

Token Burning

Another simple tactic that many projects utilize to control circulating supply is token burning. The idea is simple – periodically remove a certain amount of tokens from circulation permanently. Most projects do this by sending the tokens to a dead wallet. Projects like Ethereum and Binance use token burning to control the supply of their native tokens.
#2 Token Utility
What are the different roles that your tokens can take up? Let’s take a quick look at some of the different roles.

 	Tokens can be used for pure utility and payment inside or outside the protocol environment.
 	Tokens can be used to stake in the protocol and participate in governance.
 	Holding the protocol token is required to access the different apps (DeFi and NFT) within the system.

Playing With Tokenomics
Learn Near’s tokenomics tool lets you map out your token's different components and play with them on testnet.

These components are:

 	Token Name
 	Initial Release
 	Symbol
 	Treasury
 	Initial Supply
 	Vesting Start Time
 	Vesting Duration
 	Decimal Points
 	Vesting Interval

Playing with these different values will help you understand the supply control of your protocol’s tokenomics. Do you want to experiment with this tool? Check out LNC TokenHub!

### ¿Cómo desarrollar en NEAR? Guía de inicio

Prerrequisitos

 	Leer "¿Qué es NEAR?"
 	Experiencia en desarrollo de JavaScript

Los desarrolladores son el elemento vital del ecosistema blockchain. Para que la tecnología blockchain obtenga la adopción generalizada, debe reducir las barreras de entrada para los desarrolladores y permitirles crear aplicaciones divertidas y sofisticadas para que disfruten las personas normales. Es por esta misma razón que los contratos inteligentes de NEAR se escriben usando AssemblyScript debido a su similitud con JavaScript.

Por lo tanto, si estás interesado en desarrollar en NEAR, puedes usar las siguientes herramientas

 	JavaScript SDK. Conecta, firma, realiza transacciones y despliega en cualquier red NEAR desde cualquier contexto JS.
 	Rust Contract SDK. Crea contratos seguros y protegidos que gestionen activos de alto valor.
 	AssemblyScript Contract SDK. Aprende y crea prototipos sin dificultad utilizando la sintaxis JS.
 	JSON RPC API. Todas las comunicaciones con la plataforma pasan por esta API incluida la nuestra.
 	CLI o Interfaz de línea de comandos. Kit de herramientas de línea de comandos con todas las funciones para desarrolladores y validadores.
 	Explorador NEAR. Una herramienta de búsqueda en la blockchain que permite a los desarrolladores ver detalles de transacciones, cuentas, detalles de bloques y más.
 	NEAR Wallet. Cree cuentas, administre claves de acceso y más con nuestra interfaz de usuario fácil de usar.
 	nearup. Despliega localmente y únete a cualquier red pública o privada.
 	Bridge(Puente). Interoperabilidad rápida y segura.
 	EVM. Máquina virtual compatible con Ethereum.

Muy bien, demos los primeros pasos.
Un breve repaso
Las aplicaciones en NEAR tienen dos partes distintas: un back-end y un front-end.

 	Contratos Inteligentes (back-end): Almacenan y modifican datos en la cadena. Los contratos deben exponer métodos que permitan a los clientes "ver" y "cambiar" el estado.
 	Interacciones con los Contratos Inteligentes (front-end): Puedes interactuar con tus contratos o contratos implementados por otras personas. Para ello, utiliza Inicio rápido near-api-js y fragmentos de código en tu aplicación.




	

	
	
		
			
				Las aplicaciones en NEAR tienen dos partes distintas: un back-end y un front-end. El backend es el… ..
			
		

		
					

		
			
			
			
			Mainnet (Red Principal)
		
			
			Testnet (Red de Pruebas)
		
			
			Contratos inteligentes
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Cómo crear y llamar a contratos inteligentes

NEAR actualmente admite:

 	Rust - near-sdk-rs: Un contenedor que proporciona seguridad mejorada para el lenguaje de programación Rust para contratos de alto valor.
 	AssemblyScript near-sdk-as: una colección de ayudas que hacen que sus Contratos Inteligentes se vean similares a TypeScript mientras se compilan en Wasm para su ejecución.

NOTA: Actualmente AssemblyScript no se recomienda para aplicaciones financieras  debido a la novedad del lenguaje y las herramientas de compilación disponibles.

Muy bien, pongámonos serios.
Configuración de Testnet
La forma más sencilla de crear una cuenta en NEAR es con NEAR Wallet.  NEAR tiene varias redes de desarrollo que operan de forma independiente entre sí con sus propios ID de cuenta.  Ve, sigue los pasos para crear una billetera.  Asegúrate de haber seguido los pasos requeridos para tu copia de seguridad.

NOTA: Crear una cuenta en mainnet es casi idéntico a testnet pero requerirá fondos iniciales para la cuenta.  Aquí hay una guía para la creación de cuentas de mainnet.

No importa si la aplicación está escrita en Rust o en AssemblyScript. Todo el código del contrato se compila en WebAssembly y se implementa en la red para ejecutarse dentro de una máquina virtual compatible con Wasm. Utilizarás un comando como “yarn dev” para la mayoría de las aplicaciones, pero puedes implementar una aplicación con la misma facilidad usando NEAR CLI con “near dev-deploy” para TestNet (o “near deploy” si ya has creado una cuenta).




	

	
	
		
			
				Todo el código de contrato se compila en WebAssembly y se implementa en la red para ejecutarse dentro de un _______
			
		

		
					

		
			
			
			
			Sandbox (Entorno de pruebas)
		
			
			Máquina virtual compatible con Wasm
		
			
			EVM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Ahora, haga lo siguiente para empezar:

 	Busca en NEAR Explorer.  Aquí puedes buscar todas las transacciones y bloques producidos en NEAR. Intenta buscar la cuenta que acabas de crear y ve las transacciones que has creado.
 	Ahora instale near-cli. Esta es una interfaz de línea de comandos que le permite interactuar sin problemas con NEAR. Este NEAR docs tiene todos los comandos near-cli con ejemplos.
 	Intente ejecutar su primer comando: near login.  Esto lo redireccionará a su NEAR Wallet y guardará las claves de su cuenta de testnet localmente.

Después de comprobar la red de prueba, puedes sentirte libre de ejecutar tu nodo local.  Sin embargo, si solo quieres jugar con los códigos, te sugerimos que te atengas a la red de prueba.
¿Cómo ejecutar un nodo?
Al igual que con cualquier ecosistema basado en blockchain, NEAR Protocol se ejecuta en una colección de computadoras (o "nodos") mantenidos públicamente.

Puedes decidir ejecutar un nodo propio por algunas razones:

 	Para desarrollar e implementar contratos en un nodo conectado a MainNet, TestNet o BetaNet
 	Para desarrollar e implementar contratos en un nodo local (independiente y aislado) (a veces llamado “LocalNet”).
 	Para unirte a una red como validador ejecutando un "nodo validador".

Puedes iniciar NEAR nodos betanet y testnet instalando nearup. Puedes hacerlo siguiendo las instrucciones en https://github.com/near/nearup




	

	
	
		
			
				Al igual que con cualquier ecosistema basado en blockchain, el protocolo NEAR se ejecuta en una colección de computadoras mantenidas públicamente llamadas _______
			
		

		
					

		
			
			
			
			Nodos
		
			
			Blockchain
		
			
			Near Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ejecutando un nodo oficial usando Docker
De forma predeterminada, NEAR usa Docker para ejecutar el cliente.  Entonces, lo primero que debes hacer es instalar Docker y nearup.  Ahora, ejecuta tu sistema con esto:
nearup betanet
(Si prefieres usar TestNet, simplemente reemplaza betanet con testnet en el comando anterior)
A continuación, se le pedirá una ID de cuenta. Puedes dejar esto vacío si solo deseas ejecutar un nodo. Los validadores deben usar el ID de la cuenta con la que deseas hacer staking. Después de eso, debes ingresar este código:
Ingresa tu ID de cuenta (déjelo en blanco si no va a ser un validador)
Ahora, su nodo comenzará en segundo plano con Docker.  Para verificar los registros dentro de Docker, “run docker logs –follow nearcore”.

Creando un código simple en NEAR
NEAR tiene una lista de programas útiles o códigos de ejemplo que puedes consultar con facilidad. Entonces, el código que estaremos revisando es el Guest Book (Libro de visitas). Usar el programa te permite iniciar sesión con NEAR y agregar un mensaje al libro de visitas. Una aplicación de inicio construida con un backend de AssemblyScript y un frontend de React.

Mirando en el código del libro de visitas
Para ejecutar este proyecto localmente, debes asegurarte de lo siguiente.


 	Asegúrate de tener Node.js ≥ 12 instalado (https://nodejs.org), luego úsalo para instalar yarn: npm install –global yarn (o simplemente npm i -g yarn)
 	Instalar dependencias: yarn install (o solo yarn)
 	Ejecuta el servidor de desarrollo local: yarn dev (consulta package.json para obtener una lista completa de los scripts que puedes ejecutar con yarn)

¡Ahora tendrás un entorno de desarrollo local respaldado por NEAR TestNet!  Ejecutar yarn dev le dirá la URL que puede visitar en su navegador para ver la aplicación.
Ah, y asegúrate de tener abierta la página de GitHub.
Este video también puede resultarte útil.
https://youtu.be/B6Gc_OQjX9E

Explorando el código
Como puedes ver, hay dos lados del código: backend y frontend:


 	El código de backend vive en la carpeta /assembly.  Este código se implementa en la cadena de bloques NEAR cuando ejecuta yarn deploy:contract. Este es un contrato inteligente de NEAR.
 	El código de la interfaz se encuentra en la carpeta /src. /src/index.html es un excelente lugar para comenzar a explorar. Ten en cuenta que se carga en /src/index.js, donde puedes aprender cómo la interfaz se conecta a la blockchain NEAR.

Código de backend
#1 Modelo de Datos del Contrato: assembly/model.ts

[code lang="js"]import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");[/code]

Análisis

@nearBindgen marca la clase como serializable. Serializable es una interfaz de marcador que se utiliza para "marcar" clases de modo que los objetos de estas clases puedan obtener cierta capacidad.

La clase "PostedMessage" tiene tres características:

 	premium para marcar mensajes con tokens NEAR adjuntos
 	sender para rastrear al firmante del mensaje del libro de visitas
 	text para guardar el mensaje del libro de visitas

Finalmente, "messages" es una colección de mensajes del libro de visitas almacenados como “PersistentVector” con objetos de “PostedMessage”.
#2 Comportamiento del Contrato: assembly/main.ts

[code lang="js"]import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}[/code]

Analysis

MESSAGE_LIMIT se usa para evitar llamadas ilimitadas (es decir, potencialmente costosas) para recuperar los mensajes del libro de visitas del almacenamiento

También estamos usando dos funciones públicas diferentes en este contrato: addMessage() y getMessages()
Código frontend
#1 Conexión de Red: src/config.js

[code lang="js"]const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;[/code]

Análisis

El código anterior define los datos y los puntos finales necesarios para conectarse a la red NEAR. La información de conexión definida aquí se incluye para MainNet, TestNet y BetaNet, así como la configuración predeterminada de LocalNet.
#2 Configuración: src/index.js

[code lang="js"]import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });[/code]

Análisis

Esto es lo más básico y esencial de la sección de frontend, cuando configuras la conexión a la red NEAR. Puedes configurar la interfaz del contrato inyectando la conexión de la billetera y conectando ambos métodos de contrato.
Implementar un contrato inteligente
Cada contrato inteligente en NEAR tiene su propia cuenta asociada. Cuando ejecutas “yarn dev”, tus contratos inteligentes se implementan en NEAR TestNet con una cuenta temporal. Si ahora deseas que sea permanente, esto es lo que debes hacer.
Paso 0: Instalar near-cli
Así es como se instala near-cli a nivel global
npm install --global near-cli
Esto te dará la herramienta NEAR CLI. Asegúrate de que esté instalada con:
near --version
Paso 1: Crea una cuenta para el contrato
Visita NEAR Wallet y crea una nueva cuenta. Implementarás estos contratos inteligentes en esta nueva cuenta.

Ahora autoriza a NEAR CLI para esta nueva cuenta y sigue las instrucciones que te da:
near login
Paso 2: Establece el nombre del contrato en el código
Modifica la línea en src/config.js que establece el nombre de cuenta del contrato.  Configúralo con la identificación de la cuenta que utilizaste anteriormente.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Paso 3: Cambie la URL remota si clonaste este repositorio
Si forkeas/copias el repositorio, deberás cambiar la URL remota a un repositorio al que tengas acceso para hacer "commit".  Esto permitirá la implementación automática en Github Pages desde la línea de comandos.

 	Ve a GitHub y crea un nuevo repositorio para este proyecto.
 	 Abre tu terminal y en la raíz de este proyecto ingresa lo siguiente:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`
Paso 4: ¡Desplegar!
Solo necesita el siguiente comando para implementar su contrato inteligente:
yarn deploy
Este comando hace dos cosas:

 	Crea e implementa contratos inteligentes en NEAR TestNet
 	 Construye e implementa código de contrato frontend en GitHub usando gh-pages.  Esto sólo funcionará si el proyecto ya tiene un repositorio configurado en GitHub.  Siéntase libre de modificar el script de implementación en package.json para implementarlo en otro lugar.




	

	
	
		
			
				Cada contrato inteligente en NEAR tiene su propio ____ asociado
			
		

		
					

		
			
			
			
			Token
		
			
			Billetera
		
			
			Cuenta
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





¿Qué sigue?
Muy bien, ahora que sabes cómo ejecutar un código básico, es posible que desees profundizar en NEAR. Para eso, consulte los documentos para desarrolladores de NEAR.

### Ejemplo Dapplets × NEAR

El ejemplo Dapplets × NEAR es un Dapplet (una aplicación de aumento) que puede analizar publicaciones de Twitter y almacenarlas en el contrato NEAR. También puede mostrar sus tweets guardados en una página superpuesta.
1. Introducción
Dapplets: aplicaciones que interactúan con páginas web, aumentandolas insertando diferentes widgets, analizan los datos de las páginas y agregan algunas funcionalidades nuevas. Pueden mejorar la experiencia del usuario cuando utiliza redes sociales, servicios de video y otras fuentes.

Los Dapplets usan la extensión que estamos creando. Esta extensión ofrece una API simple para desarrolladores de dapplets y grandes habilidades para la comunidad de dapplets. Nuestra plataforma es descentralizada. Usamos las redes NEAR y Ethereum para nuestros registros y contratos. También utilizamos almacenamientos descentralizados, como Swarm, IPFS y SIA para alojar código dapplets y archivos multimedia.

Para utilizar nuestra plataforma en primer lugar debes instalar la Extensión Dapplets.  Actualmente se encuentra en la etapa alfa y no está publicada en Google Chrome ni en ninguna otra tienda. Para instalarla sigue estos pasos:

 	Abra uno de los siguientes navegadores: Google Chrome, Firefox, Brave, Tor.

Los siguientes pasos se describen para Google Chrome. Los pasos pueden ser diferentes en otros navegadores.

 	Descargue la Extensión Dapplets para navegador.
 	Abra chrome://extensions en una nueva pestaña.
 	Active el modo de Desarrollador y presione F5 para actualizar la página.
 	Arrastre y suelte el archivo descargado en la página de extensiones.  La extensión se instalará automáticamente.Si estás utilizando Ubuntu o posiblemente otro sistema operativo Linux la extensión Dapplets puede desaparecer de las Extensiones de Chrome después de reiniciar la PC. Para evitar esto, descomprima el archivo y use el botón Cargar extensión sin empaquetar para agregar la extensión.
 	Haz clic en el icono de la extensión Dapplets en la barra de extensiones. Prueba la dapplet: Dapplets × NEAR ejemplo.

2. Tutorial
Estudiemos cómo funciona este dapplet y por qué Dapplets es una plataforma NEAR amigable.

El objetivo de este ejemplo es mostrar la interacción entre NEAR y Dapplets. Si este es tu primer encuentro con Dapplets, te recomendamos que primero pruebes nuestra documentación. Contiene varios ejercicios que explican cómo crear dapplets y adaptadores, desde simples hasta complejos. Recomendamos encarecidamente revisar los ejemplos ex01 y ex04 que describen cómo crear los dapplets y dapplets más básicos con una superposición. El conocimiento que obtendrás te facilitará la comprensión del ejemplo actual.

El código inicial para este ejemplo está en una rama separada: ejercicio.

Puedes clonar este repositorio. Pero no funcionará directamente. Intenta seguir los siguientes pasos para iniciarlo.

Veamos la estructura. Hay tres componentes: dapplet, overlay y contract.

Dapplet es el punto de entrada de la aplicación. Utiliza adaptadores para la interacción con páginas web, definiendo contextos para aumentar y widgets para insertar. Puedes encontrar las funciones principales de la extensión dentro de un dapplet. Usamos TypeScript en nuestro proyecto.

Definimos Overlay como un lugar donde un usuario puede hacer algo con datos analizados, conectarse a las funciones principales de dapplet a través del puente dapplet y administrar los parámetros de aumento. Es una parte importante de la aplicación, pero se ejecuta en otro entorno y se publica como un paquete separado. En la mayoría de los casos usamos React por ser uno de los frameworks más populares.  Pero puedes usar el framework que prefieras o JavaScript puro o TypeScript.

El contrato no se conecta directamente con otros módulos y puede estar ubicado fuera del dapplet. Sin embargo, este simple contrato NEAR se crea específicamente para este dapplet. Por eso es conveniente colocarlo en la estructura de la aplicación.

Veamos cada módulo.
2.1. Dapplet
Mire el /dapplet/src/index.ts.

Al principio creamos una clase inyectable con el decorador @Injectable y usamos @Inject para agregar el Adaptador de Twitter como la variable de clase del adaptador. También crea el método activate. Se ejecuta cuando el adaptador seleccionado encuentra un contexto específico y se está cargando. Contendrá toda la lógica principal.



Agrega el botón a cada tweet. Pon este código en activate:



Mira el código. Obtenemos button del widget del adaptador. Luego, ejecuta el método attachConfig del adaptador. Recibe un objeto con los nombres de los contextos, que se utilizarán como claves. Los valores son funciones que reciben contexto analizado como único argumento y devuelven un widget o un arreglo de widgets. También puede devolver null, false o undefined.

Widget es una función que recibe un objeto que consiste de estados de widget. Los parámetros de estado se describen en la documentación de los adaptadores. Puedes encontrar la documentación del Adaptador de Twitter aquí. En nuestro caso agregamos una imagen al botón y la información sobre herramientas. exec es una función que se ejecuta cuando se hace clic en ella.  Ahora solo mostramos el contexto analizado en la consola.

Ejecute el dapplet:


⚠️ Dado que el navegador está bloqueando páginas con certificados de seguridad problemáticos, ve a https://localhost:3001/dapplet.json cuando la aplicación se esté ejecutando y acepta ejecutarla en modo inseguro.
Abre la extensión. Ve a la pestaña Desarrollador y enciende el servidor de desarrollo: https://localhost:3001/dapplet.json.



Enciende la pestaña Dapplets. Verás la insignia de desarrollador cerca de nuestro dapplet. Enciéndelo.



Ahora puedes ver botones adicionales en nuestros tweets. Haz clic en el botón y abre la consola. Verás el contexto analizado del tweet.



¡Lo has hecho! ¡¡¡Felicidades!!! Vuelve al código.

Queremos mostrar datos analizados, pero no en la consola sino a los usuarios. Usaremos una superposición para esto. Pero antes de implementar la superposición, agrega la lógica de interacción entre la dapplet y la superposición a la dapplet.

Cambiemos nuestro código. Agrega la variable de clase privada _overlay de tipo any. En la activación agrega el siguiente código:



La función principal Core.overlay (los problemas de escritura se solucionarán pronto) recibe un objeto con un nombre de la superposición y un título de superposición y devuelve el objeto Overlay que guardamos en la variable  _overlay.

Agreguemos el método openOverlay a la clase:



En este ejemplo, llamamos al método send de la superposición. Se necesitan dos argumentos: el nombre de estos datos y los datos para enviar a la superposición.

Agrega openOverlay a la función exec y pasa el contexto analizado a la superposición. Este es el código actual del dapplet:



Abre el manifiesto ./dapplet/dapplet.json.


⚠️ Dado que el navegador está bloqueando páginas con certificados de seguridad problemáticos, vaya a https://localhost:3000 cuando la aplicación se esté ejecutando y acepte ejecutarla en modo inseguro.
Aquí vemos la URL de la superposición denominada 'overlay' que se utilizará en el modo de desarrolladores. Durante la publicación del dapplet en el registro, la superposición se publicará en el almacenamiento descentralizado.

También vemos el Adaptador de Twitter en las dependencias. Estamos usando la versión 0.9.0 en el ejemplo.

Vayamos a la superposición.
2.2. Overlay
Como mencionamos anteriormente, la superposición se puede crear de la forma que desees. Usamos React en la mayoría de nuestros proyectos. No analizaremos todo el código de superposición, sino solo los puntos importantes para nuestros aspectos arquitectónicos.

Para interactuar con dapplet, instale el paquete npm @dapplets/dapplet-overlay-bridge:



Para obtener los datos del dapplet necesitamos la clase Bridge en la parte de superposición. Mira el módulo ./overlay/src/dappletBridge.ts. Aquí está el método onData donde nos suscribimos al evento 'data' que describimos en el dapplet.



Luego lo usamos en el módulo App.tsx.



Ahora guarda los cambios y vuelve a cargar la página de Twitter. Al hacer clic en el botón, verás la superposición con los datos del tweet seleccionado.



¡Eso es genial! Pero nuestro objetivo es guardar estos datos en NEAR y recuperarlos. Así que veamos el contrato.
2.3. Contrato inteligente NEAR
Mira el módulo ./contract. Hay un contrato inteligente NEAR simple escrito en AssemblyScript con create-near-app.

En ./contract/assembly/index.ts vemos un PersistentUnorderedMap llamado tweetsByNearId. Almacena una serie de datos de tweets serializados con el ID de usuario actual. Tiene métodos para guardar, eliminar y recuperar tweets guardados.

Puede encontrar todos los datos necesarios sobre cómo escribir, probar e implementar contratos inteligentes en la documentación oficial y en los cursos y guías de Learn NEAR.

Veamos cómo conectarnos al contrato inteligente y usar sus métodos en el dapplet.

Agregue el siguiente código al método activate del módulo ./dapplet/src/index.ts:



Existe un método Core.contract que recibe 3 parámetros: nombre de la red ("near" o "etherium"), nombre del contrato y objeto con métodos de visualización y cambio.

Ahora haremos que los métodos de contrato estén disponibles en la superposición. Para pasar los métodos a través del puente dapplets, agregue una función listen a la llamada de superposición. No tengas miedo, simplemente copia y pega este código.



Las últimas tres funciones asincrónicas pasan nuestros métodos de contrato a la superposición. Las primeras cuatro funciones deben emparejar la billetera con el dapplet. Para obtener el objeto Wallet usamos el método Core.wallet con el nombre de los parámetros name (near o ethereum) y network. La billetera tiene métodos isConnected, connect, disconnect y parámetro accountId.

El siguiente paso es cambiar ./overlay/src/dappletBridge.ts. Tenemos que hacer que las funciones que se describieron en el dapplet estén disponibles en la superposición. Copia el siguiente código en la clase Bridge:



Ahora podemos usar métodos de contrato en los módulos de superposición. Podemos autorizar el dapplet con la billetera NEAR testnet y guardar los datos de los tweets seleccionados en el contrato inteligente. También podemos ver nuestros datos guardados en la superposición.

Descomprime todo el código comprimido en ./overlay/src/App.tsx. Guarda los cambios y vuelve a cargar la página de Twitter.



Para terminar tendremos la adición de la capacidad de ver los tweets guardados sin analizar los nuevos. Para hacer esto, basta con agregar el método Core.onAction al activate en ./dapplet/src/index.ts y pasarle la función de abrir la superposición.



Ahora verás el icono de inicio cerca del nombre de los dapplets.



Un clic en el botón abre una superposición con los tweets guardados.



¡Felicitaciones a todos los que llegaron al final del tutorial! Esperamos que hayas tenido éxito.

Aquí está el resultado: dapplets-near-example

Si algo no funcionó para ti, o aún tienes algunas preguntas, eres bienvenido a nuestros chats en Discord y Telegram.

Gracias por tu tiempo. Esperamos que este nuevo conocimiento te sea útil, y continues desarrollando aplicaciones impresionantes y exitosas en la plataforma Dapplets utilizando las capacidades de NEAR Protocol.🚀✨
Contacto:
Web: dapplets.org
Docs: docs.dapplets.org
GitHub: github.com/dapplets
Discord: discord.gg/YcxbkcyjMV
Telegram: t.me/dapplets
Twitter: @dappletsproject

### Update - December 9, 2021

Brief Summary:

 	NEAR Certified Developer Demo November Day was HUGE Success!

Results:

 	Ⓝ610 sent to 12 projects NEAR Certified Developer Demo November Day participants. Check projects repos at LNC GitHub.

Congrats and happy (L)Earning!
 	The funniest project at LNC NEAR Certified Developer November Demo Day by
 @chestedos got a special award -@NEARMisfits #258



 	Tipping with NEAR is LIVE on Mainnet.

Instructions are here https://github.com/dapplets/tipping-dapplet 
Tweet a cool twit tagging
@LearnNEAR and @dappletsproject   and get tips in $NEAR
 	LNC NEAR watcher Telegram bot got major improvement:
now you can click on account name and get info about account holdings:


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC Barrel - NEAR Fortified Developer invite-only accelerator is coming soon!

### Ứng Dụng Dapplets × NEAR

Dapplets × NEAR là một Dapplet (một Ứng dụng tăng cường) có thể phân tích cú pháp các bài đăng trên Twitter và lưu trữ chúng trong hợp đồng NEAR. Nó cũng có thể hiển thị các tweet đã lưu của bạn trên trang.
1. Giới Thiệu
Dapplets — là các ứng dụng tương tác với các trang web, tăng cường chúng bằng cách chèn các tiện ích con khác nhau, phân tích cú pháp dữ liệu của các trang và thêm một số chức năng mới. Họ có thể cải thiện trải nghiệm người dùng khi sử dụng mạng xã hội, dịch vụ video và các nguồn khác.
Dapplets sử dụng tiện ích mở rộng mà chúng tôi đang tạo. Tiện ích mở rộng này cung cấp một API đơn giản cho các nhà phát triển dapplets và có khả năng lớn cho cộng đồng dapplets. Nền tảng của chúng tôi là phi tập trung. Chúng tôi sử dụng mạng NEAR và Ethereum cho các đăng ký và hợp đồng của mình. Chúng tôi cũng sử dụng các kho lưu trữ phi tập trung, như Swarm, IPFS và SIA để lưu trữ code dapplets và đa phương tiện.
Để sử dụng nền tảng của chúng tôi, trước tiên bạn cần cài đặt Dapplets Extension. Hiện nó đang ở giai đoạn alpha và chưa được xuất bản lên Google Chrome hoặc bất kỳ cửa hàng nào khác. Để cài đặt nó, hãy làm theo các bước sau:


 	Mở một trong các trình duyệt sau: Google Chrome, Firefox, Brave, Tor. (Các bước sau đây được mô tả cho Google Chrome. Các bước có thể khác nhau ở các trình duyệt khác.)

The following steps are described for Google Chrome. The steps may differ in other browsers.

 	Tải xuống Tiện ích mở rộng trình duyệt Dapplets.
 	Mở chrome://extensions trong một tab mới.
 	Bật chế độ Nhà phát triển và nhấn F5 để làm mới trang.
 	Kéo và Thả tệp đã tải xuống vào trang tiện ích mở rộng. Phần mở rộng sẽ tự động cài đặt.Nếu bạn đang sử dụng Ubuntu hoặc có thể là hệ điều hành Linux OS khác, tiện ích mở rộng có thể biến mất khỏi Chrome Extensions sau khi khởi động lại PC. Để tránh điều này, hãy giải nén kho lưu trữ và sử dụng nút Tải giải nén để thêm tiện ích mở rộng.
 	 Nhấp vào biểu tượng tiện ích mở rộng Dapplets trên thanh tiện ích mở rộng. Hãy thử ứng dụng Dapplets × NEAR.

2. Hướng Dẫn
Hãy cùng nghiên cứu cách thức hoạt động của Dapplet này và tại sao Dapplet lại là một nền tảng NEAR miễn phí.
Mục tiêu của ví dụ này là thể hiện sự tương tác giữa NEAR và Dapplets. Nếu đây là lần đầu tiên bạn gặp Dapplets, chúng tôi khuyên bạn nên xem thử tài liệu của chúng tôi trước. Nó bao gồm một số bài tập giải thích cách tạo dapplet và bộ điều hợp, từ những cái đơn giản đến phức tạp. Chúng tôi thực sự khuyên bạn nên xem qua các ví dụ ex01 và ex04 mô tả cách tạo các dapplet và dapplet cơ bản nhất. Kiến thức bạn nhận được sẽ giúp bạn hiểu các ví dụ dễ dàng hơn.
Đoạn code mở đầu cho ví dụ này nằm trong một bài riêng: bài tập.
Bạn có thể sao chép repo này. Nó sẽ không hoạt động trực tiếp. Hãy thử các bước sau để bắt đầu nó.
Hãy xem cấu trúc. Có ba thành phần: dapplet, overlay và contract.
Dapplet là điểm vào của ứng dụng. Nó sử dụng bộ điều hợp để tương tác với các trang web, xác định bối cảnh để tăng cường và các tiện ích con để chèn. Bạn có thể tìm thấy các chức năng cốt lõi của tiện ích mở rộng bên trong dapplet. Chúng tôi sử dụng TypeScript trong dự án của mình.
Overlay được định nghĩa theo cách của chúng tôi là một nơi mà người dùng có thể làm điều gì đó với dữ liệu đã được phân tích cú pháp, kết nối với các chức năng của dapplet cốt lõi thông qua dapplet bridge và quản lý các tham số tăng cường. Nó là một phần bất lực của ứng dụng, nhưng nó chạy trong môi trường khác và được xuất bản dưới dạng một gói riêng biệt. Trong hầu hết các trường hợp, chúng tôi sử dụng React như một trong những framework phổ biến nhất. Nhưng bạn có thể sử dụng một khuôn khổ mà bạn thích hoặc JavaScript hoặc TypeScript thuần túy.
Contract không kết nối trực tiếp với các mô-đun khác và có thể nằm bên ngoài dapplet. Tuy nhiên, hợp đồng NEAR đơn giản này được tạo riêng cho dapplet này. Đây là lý do tại sao rất tiện lợi khi đặt nó vào cấu trúc ứng dụng.
Chúng ta hãy xem xét từng mô-đun.
2.1. Dapplet

Nhìn vào ./dapplet/src/index.ts

Đầu tiên, chúng tôi tạo lớp injectable với trình trang trí @Injectable và sử dụng @Inject để thêm Twitter Adapter làm biến dưới dạng lớp adapter. Đồng thời tạo phương thức activate. Khi chạy adapter đã chọn nó tìm thấy ngữ cảnh cụ thể và đang tải. Nó sẽ chứa tất cả logic chính.



Thêm button vào mỗi tweet. Đưa code này vào để activate:


Nhìn vào code. Chúng tôi nhận được button tiện ích từ adapter. Sau đó, chạy phương thức attachConfig. Nó nhận một đối tượng với tên của contexts, sẽ được sử dụng làm khóa. Giá trị là các hàm nhận ngữ cảnh được phân tích cú pháp làm đối số duy nhất và trả về một tiện ích con hoặc một mảng tiện ích con. Bạn cũng có thể trả về null, false hoặc undefined.
Widget là một hàm nhận một đối tượng bao gồm các trạng thái của widget. Các thông số trạng thái được mô tả trong tài liệu về adapters. Bạn có thể tìm thấy tài liệu về Twitter Adapter tại đây. Trong trường hợp của chúng tôi, chúng tôi thêm một hình ảnh vào button và tooltip. Thực thi là một hàm chạy khi được nhấp vào. Bây giờ chúng tôi chỉ hiển thị ngữ cảnh được phân tích cú pháp trong bảng điều khiển.
Chạy dapplet:

⚠️Vì trình duyệt đang chặn các trang có chứng chỉ bảo mật có vấn đề, hãy truy cập https: // localhost: 3001 / dapplet.json khi ứng dụng đang chạy và đồng ý chạy ở chế độ không an toàn
Mở tiện ích mở rộng. Chuyển đến tab Developer và bật máy chủ phát triển: https: // localhost: 3001 / dapplet.json.



Chuyển đến tab Dapplets. Bạn sẽ thấy huy hiệu nhà phát triển của Dapplets x NEAR. Bật nó lên.



Bây giờ bạn có thể thấy các button bổ sung trên các tweet của chúng tôi. Nhấp vào button và mở bảng điều khiển. Bạn sẽ thấy ngữ cảnh được phân tích cú pháp của tweet.


Bạn đã hoàn thành nó! Xin chúc mừng!!! Quay trở lại code.
Chúng tôi muốn hiển thị dữ liệu đã phân tích cú pháp không phải trong bảng điều khiển mà là cho người dùng. Chúng tôi sẽ sử dụng một overlay cho việc này. Nhưng trước khi triển khai overlay, hãy thêm logic tương tác giữa dapplet và overlay vào dapplet.
Hãy thay đổi code của chúng tôi. Thêm biến lớp variable _overlay kiểu bất kỳ. Trong activate, hãy thêm đoạn code sau:

Hàm cốt lõi Core.overlay (các vấn đề về đánh máy sẽ sớm được khắc phục) nhận một đối tượng có name overlay và title overlay và trả về đối tượng Overlay mà chúng ta lưu trong biến _overlay.
Hãy thêm phương thức openOverlay vào lớp:

Trong ví dụ này, chúng tôi gọi phương thức send overlay. Gồm có hai đối số: tên của dữ liệu và dữ liệu để send overlay.
Thêm openOverlay vào function và pass đã phân tích cú pháp vào overlay. Đây là đoạn code hiện tại của dapplet:


Mở tệp manifest ../dapplet/dapplet.json


⚠️ Vì trình duyệt đang chặn các trang có chứng chỉ bảo mật có vấn đề, hãy truy cập https: // localhost: 3000 khi ứng dụng đang chạy và đồng ý chạy ở chế độ không an toàn.
Ở đây, chúng tôi thấy URL của overlay có tên ‘overlay’ sẽ được sử dụng trong chế độ nhà phát triển. Trong quá trình xuất bản dapplet cho cơ quan đăng ký, overlay sẽ được xuất bản lên bộ lưu trữ phi tập trung (decentralized storage).
Chúng tôi cũng thấy Twitter Adapter trong phần phụ lục. Chúng tôi đang sử dụng phiên bản 0.9.0 trong ví dụ.
Hãy chuyển sang overlay.

2.2. Overlay
Như chúng tôi đã đề cập trước đây, overlay có thể được tạo theo bất kỳ cách nào bạn muốn. Chúng tôi sử dụng React trong hầu hết các dự án của mình. Chúng tôi sẽ không phân tích toàn bộ mã overlay, mà chỉ phân tích những điểm quan trọng cho các khía cạnh kiến trúc của chúng tôi.
Để tương tác với dapplet, hãy cài đặt gói npm @dapplets/dapplet-overlay-bridge:


Để lấy dữ liệu từ dapplet, chúng ta cần lớp Bridge trong phần overlay. Nhìn vào mô-đun ./overlay/src/dappletBridge.ts. Đây là phương thức onData nơi chúng tôi đăng ký sự kiện ‘data’ mà chúng tôi đã mô tả trong dapplet.



Sau đó, chúng tôi sử dụng nó trong mô-đun App.tsx.



Bây giờ hãy lưu các thay đổi và tải lại trang Twitter. Khi bạn nhấp vào nút, bạn sẽ thấy lớp phủ với dữ liệu tweet đã chọn.



Thật tuyệt! Nhưng mục tiêu của chúng tôi là lưu dữ liệu này vào chuỗi NEAR và lấy lại. Vì vậy, chúng ta hãy xem hợp đồng.
2.3. NEAR smart contract
Nhìn vào mô-đun ./contract. Có một hợp đồng thông minh NEAR đơn giản được viết bằng AssemblyScript với create-near-app .
Trong ./contract/assembly/index.ts chúng tôi thấy một PersistentUnorderedMap có tên tweetsByNearId. Nó lưu trữ một loạt dữ liệu tweet được tuần tự hóa với ID người dùng hiện tại. Nó có các phương pháp để lưu, loại bỏ và truy xuất các tweet đã lưu.
Bạn có thể tìm thấy tất cả dữ liệu cần thiết về cách viết, kiểm tra và triển khai NEAR hợp đồng thông minh trong tài liệu chính thức và Learn NEAR khóa học và hướng dẫn.
Hãy xem cách kết nối với hợp đồng thông minh và sử dụng các phương pháp của nó trong dapplet.
Thêm đoạn code sau vào phương thức activate của mô-đun : ./dapplet/src/index.ts


Bây giờ, chúng ta sẽ cung cấp các phương thức hợp đồng trong overlay. Để chuyển các phương thức thông qua dapplets bridge, hãy thêm một hàm listen vào lệnh overlay. Đừng sợ, chỉ cần sao chép và dán đoạn code này 🙂


Ba hàm asynchronius cuối cùng chuyển các phương thức hợp đồng của chúng tôi đến overlay. Bốn hàm đầu tiên cần phải ghép nối ví với dapplet. Để lấy đối tượng Wallet, chúng tôi sử dụng phương thức Core.wallet, với tên tham số (near hoặc ethereum) và mạng. Ví có các phương thức isConnected, connect, disconnect và tham số accountId .
Bước tiếp theo là thay đổi ./overlay/src/dappletBridge.ts. Chúng ta phải tạo các hàm đã được mô tả trong dapplet, có sẵn trong overlay. Sao chép đoạn code sau vào lớp Bridge .

Bây giờ chúng ta có thể sử dụng các phương thức hợp đồng trong các mô-đun overlay. Chúng tôi có thể ủy quyền cho dapplet với ví NEAR testnet và lưu dữ liệu của các tweet đã chọn vào hợp đồng thông minh. Chúng tôi cũng có thể xem dữ liệu đã lưu của mình trong lớp overlay.
Không giới hạn tất cả mã đã cam kết trong ./overlay/src/App.tsx. Lưu các thay đổi và tải lại trang Twitter.


Một quả cherry ở trên cùng sẽ là sự bổ sung của khả năng xem các tweet đã lưu mà không cần phân tích cú pháp mới. Để làm điều này, chỉ cần thêm phương thức Core.onAction vào activate trong ./dapplet/src/index.ts và các chức năng opening cho overlay của nó.



Bây giờ bạn sẽ thấy biểu tượng trang chủ gần tên dapplets.



Một cú nhấp chuột vào nút sẽ mở ra một lớp phủ với các tweet đã lưu.


Xin chúc mừng tất cả những người đã hoàn thành phần cuối của hướng dẫn! Chúng tôi hy vọng nó đã thành công.
Đây là kết quả: dapplets-near-example
Nếu điều gì đó không hiệu quả với bạn hoặc bạn vẫn có một số câu hỏi, bạn có thể tham gia các cuộc trò chuyện của chúng tôi trong Discord và Telegram.
Cảm ơn bạn đã dành thời gian học các khóa học về NEAR. Chúng tôi hy vọng kiến thức mới này sẽ hữu ích và bạn sẽ tiếp tục phát triển các ứng dụng ấn tượng và thành công trên nền tảng Dapplets bằng cách sử dụng các khả năng của giao thức NEAR 🚀✨

Contacts:
Web: dapplets.org
Docs: docs.dapplets.org
GitHub: github.com/dapplets
Discord: discord.gg/YcxbkcyjMV
Telegram: t.me/dapplets
Twitter: @dappletsproject

### Cuenta NEAR - Guia Express

Introducción a la cuenta NEAR

 	NEAR usa identificadores de cuentas que son legibles por humanos en el formato nombre.near. Por ejemplo, maria.near o jane.near.
 	El sistema de cuenta de NEAR es similar al sistema de los dominios de sitios web, en el sentido de que una cuenta puede crear tantas subcuentas como necesite. Por ejemplo. una cuenta con el nombre maria.near puede crear una subcuenta como sub.maria.near, y esa a su vez puede crear la cuenta primera.sub.maria.near y asi sucesivamente.
 	La Near Wallet (https://wallet.near.org/) (Cartera del protocolo NEAR), NEAR Faucet (https://faucet.paras.id/) (un faucet para usuarios de Ethereum y Metamask) o near-cli (https://github.com/near/near-cli) (interfaz de lineas de comando que entrega funcionalidad para integración en NEAR) pueden ser todos usados para crear una cuenta. 
 	En NEAR usted puede crear una cuenta y enviarla a un amigo o suscriptor como un regalo con la ayuda del servicio https://nearnames.com/.
 	Puede revisar la información de las cuentas en el explorador de NEAR https://explorer.near.org/ asi mismo como en la NEAR Wallet.
 	Además de las cuentas visibles (del tipo nombre.near), el ecosistema de NEAR también soporta la creación de cuentas invisibles con la ayuda de near-cli (se ven como algo similar a las cuentas de Bitcoin y Ethereum). Puede encontrar una guia detallada aquí.
 	Cada cuenta en el sistema puede tener solo 1 contrato inteligente. Para aplicaciones que requieren que el usuario use múltiples contratos inteligentes, se pueden usar cuentas hijo, por ejemplo contract_1.maria.near, contract_2.maria.mear, etc.
 	Tambien existen las cuentas de desarrollador (https://docs.near.org/docs/concepts/account#dev-accounts) en el ecosistema NEAR. Su especialidad se basa en el hecho de que son creadas para pruebas y depuración de contratos inteligentes.

CUENTA NEAR - Llaves

 	NEAR como casi todas las otras blockchains, se basa en criptografía con una llave abierta. Se basa en en un par de llaves las cuales consisten cada una de una llave abierta (llave pública) relacionada con una llave cerrada (llave privada).
 	NEAR usa la llave abierta para identificación y la llave cerrada para firmar transacciones (confirmación de la pertenencia de una cuenta durante el proceso de transacción).
 	En NEAR existen tres tipos de llaves. La Llave de acceso es para firmar transacciones desde la cuenta, llave para validar la cual permite operaciones relacionadas con validación de red, llaves nodo (nodos de red) permiten comunicación de bajo nivel entre nodos de la red.
 	Las llaves pueden ser almacenadas en tres tipos de almacenamiento. InMemoryKeyStore - almacenamiento en memoria, usada para escenarios temporales. BrowserLocalStorageKeyStore - almacenamiento de explorador desencriptado, usado para trabajar con aplicaciones de explorador. UnencryptedFileSystemKeyStore - almacenamiento desencriptado en el sistema de archivos, se usa cuando se trabaja con near-cli.
 	Una cuenta puede tener múltiples llaves de acceso o ninguna.
 	Las llaves pueden tener diferentes niveles de acceso - FullAccess (acceso completo) o FunctionCall (sólo con la habilidad de llamar métodos de contratos).
 	Todas las llaves son únicas dentro de una cuenta, pero las llaves públicas pueden ser asignadas a diferentes cuentas con diferentes niveles de acceso. El nivel de acceso determina qué acciones en esa cuenta pueden ser realizadas con esa llave.
 	Para el nivel de FullAccess (Acceso completo), todas los 8 tipos de acciones están disponibles: CreateAccountAction (crear una cuenta), DeployContractAction (desplegar un contrato), FunctionCallAction (llamar un metodo de contrato), TransferAction (enviar tokens a otra cuenta), StakeAction (bloquear tokens), AddKeyAction (agregar una llave a una cuenta), DeleteKeyAction (Elementar la llave de una cuenta), DeleteAccountAction (Eliminar una cuenta).
 	Para el nivel de FunctionCall, sólo las acciones métodos de llamada de contratos están disponibles. Además, para esas llaves, puede especificar qué métodos de llamadas de contratos puede ejecutar.

### NEAR Live Révision des contrats | Partie 2 : Contrat de pool de Staking

Introduction
C'est la deuxième partie de la série d'examens de contrats en direct et aujourd'hui, nous allons examiner le contrat de pool de staking, qui est utilisé en ce moment pour sécuriser le protocole NEAR.système de preuve de mise. Fondamentalement, tous les validateurs qui fonctionnent actuellement sur le protocole NEAR fonctionnent au nom de ce contrat. Ils ne contrôlent pas eux-mêmes le compte qui mise le montant de jetons NEAR requis pour la preuve de mise, mais à la place, le contrat mise ce montant, et ils fournissent simplement un pool de mise et exécutent leurs nœuds. Aujourd'hui, nous allons creuser dans ce contrat. Dans les contrats de base, nous avons un contrat de pool de jalonnement et c'est un peu plus compliqué que le contrat précédent que nous avons examiné (le contrat de vote). Donc, aujourd'hui, nous allons nous concentrer davantage sur la logique et moins sur les éléments spécifiques de near_bindgen et Rust, mais cela impliquera probablement un peu plus de connaissances sur le protocole NEAR. Voici le contrat de pool de staking sur le NEAR Github. Vous trouverez ci-dessous la vidéo originale sur laquelle ce guide est basé.


lib.rs
Structure du constructeur


Comme auparavant, le contrat commence à partir de la structure principale. Dans ce cas, il s'agit d'une structure de contrat de jalonnement. Comme vous pouvez le voir, il y a near_bindgen, et BorshSerialize et BorshDeserialize. La structure a maintenant beaucoup plus de champs que la précédente, et il y a quelques commentaires sur eux, la plupart d'entre eux sont probablement à jour. La logique du contrat de pool de staking nous permet de faire ce qui suit : fondamentalement, n'importe qui peut déposer une certaine quantité de jetons NEAR dans le pool de staking et les déléguer au pool de staking en les mettant dans le pool. Cela nous permet de regrouper les soldes de plusieurs personnes (nous les appelons comptes ici) en un seul gros enjeu, et de cette façon, ce grand État peut en fait se qualifier pour des sièges de validateur. NEAR Protocol a actuellement un nombre limité de sièges pour un seul fragment, il y a au plus 100 sièges de validateur. Vous pouvez penser aux sièges de la manière suivante : si vous prenez le montant total de jetons mis en jeu et que vous le divisez par 100, le résultat sera le nombre minimum de jetons requis pour un seul siège, sauf que c'est un peu plus compliqué d'impliquer le retrait les enjeux qui ne sont pas qualifiés pour contenir ce montant minimum, etc. Ce contrat est essentiellement un contrat autonome sans aucune clé d'accès qui est contrôlé par le propriétaire. Dans ce cas, le propriétaire est fourni dans la méthode d'initialisation. Ce contrat est essentiellement un contrat autonome sans clé d'accès qui est contrôlé par le propriétaire. Dans ce cas, le propriétaire est fourni dans la méthode d'initialisation. Ce contrat est essentiellement un contrat autonome sans clé d'accès qui est contrôlé par le propriétaire. Dans ce cas, le propriétaire est fourni dans la méthode d'initialisation. 
Méthode d'initialisation


Passons donc à la méthode d'initialisation. Il a trois arguments et le premier est le owner_id qui est l'identifiant du compte du propriétaire. Le propriétaire a un tas d'autorisations sur ce contrat qui permettent au contrat d'effectuer des actions qui ne sont pas disponibles pour le reste des comptes. L'une de ces méthodes consistait à voter au nom du pool de jalonnement sur le contrat de vote dont nous avons discuté la dernière fois. Ainsi, le propriétaire peut appeler la méthode de vote. 





Nous vérifions ensuite que le prédécesseur est égal au propriétaire puisque cette méthode ne peut être appelée que par le propriétaire.



Donc, ce que fait la méthode de vote, c'est qu'elle vérifie que la méthode n'a été appelée que par le propriétaire, puis elle vérifie une certaine logique, mais ce n'est pas important pour le moment. 



Le contrat est donc le propriétaire, et ce propriétaire peut faire certaines choses, il a les autorisations supplémentaires. Ensuite, cela prend quelques champs supplémentaires : cela prend la clé_public_enjeu. Lorsque vous misez sur le protocole NEAR, vous devez fournir une clé publique qui sera utilisée par votre nœud de validation pour signer des messages au nom du nœud de validation. Cette clé publique peut être différente de n'importe quelle clé d'accès, et idéalement, elle devrait être différente de toute clé d'accès, car votre nœud peut être exécuté dans un centre de données susceptible d'être vulnérable à certaines attaques. Dans ce cas, le mieux qu'ils puissent faire est de faire quelque chose de mal au réseau, mais pas à votre compte. Ils ne peuvent pas voler vos fonds et vous pouvez facilement remplacer cette clé par rapport à la façon dont vous devez remplacer la mauvaise clé d'accès. Enfin, le troisième argument pris en charge par le contrat est la fraction_frais_récompense initiale. Il s'agit de la commission que le propriétaire du pool de jalonnement prend pour exécuter le nœud de validation. 



Il s'agit d'une fraction qui a un numérateur et un dénominateur, et elle vous permet essentiellement de dire "Je prends 1% des récompenses pour l'exécution de ce pool particulier", par exemple. Disons que vous avez 1 000 000 de jetons, ils ont acquis une récompense, disons qu'il y a une récompense de 10 000 jetons, alors le propriétaire en retirera 1%, soit 100 jetons. Les flotteurs ont un comportement imprévisible lorsque vous les multipliez. Par exemple, avec des fractions, vous pouvez utiliser des mathématiques avec un plus grand nombre de bits. Ainsi, la façon dont vous faites la division, par exemple, consiste à multiplier d'abord le montant qui est u128 par un numérateur (cela peut déjà déborder dans u128), mais c'est pourquoi nous le faisons dans u256. Ensuite, vous le divisez par le dénominateur qui devrait le ramener en dessous de u128. Cela vous donne une précision plus élevée que float64 qui ne peut pas fonctionner avec une précision u128 bits, il y aura donc des erreurs d'arrondi ou des erreurs de précision lorsque vous faites le calcul. Donc, vous avez besoin de flotteurs de plus haute précision, qui ne sont pas vraiment différents des mathématiques où nous simulons cela avec u256. À l'origine, Solidity ne prenait pas en charge les flottants, et nous ne l'avons pas fait non plus à l'origine, mais cela pose des problèmes de formatage des chaînes dans Rust pour le débogage. Le plus gros problème avec les flotteurs était le comportement indéfini autour de certaines valeurs de charges. Par exemple, ce que contiennent les autres bits lorsque vous avez un flottant infini. Nous avons standardisé cela, et maintenant ils sont indépendants de la plate-forme équivalente. Il est donc possible d'utiliser des flottants maintenant dans notre environnement vm. qui ne sont pas vraiment différents des maths où nous simulons cela avec u256. À l'origine, Solidity ne prenait pas en charge les flottants, et nous ne l'avons pas fait non plus à l'origine, mais cela pose des problèmes de formatage des chaînes dans Rust pour le débogage. Le plus gros problème avec les flotteurs était le comportement indéfini autour de certaines valeurs de charges. Par exemple, ce que contiennent les autres bits lorsque vous avez un flottant infini. Nous avons standardisé cela, et maintenant ils sont indépendants de la plate-forme équivalente. Il est donc possible d'utiliser des flottants maintenant dans notre environnement vm. qui ne sont pas vraiment différents des maths où nous simulons cela avec u256. À l'origine, Solidity ne prenait pas en charge les flottants, et nous ne l'avons pas fait non plus à l'origine, mais cela pose des problèmes de formatage des chaînes dans Rust pour le débogage. Le plus gros problème avec les flotteurs était le comportement indéfini autour de certaines valeurs de charges. Par exemple, ce que contiennent les autres bits lorsque vous avez un flottant infini. Nous avons standardisé cela, et maintenant ils sont indépendants de la plate-forme équivalente. Il est donc possible d'utiliser des flottants maintenant dans notre environnement vm. nous avons donc décidé qu'il n'y avait aucun mal à prendre en charge les flotteurs, d'autant plus que nous standardisons cela du côté vm. Le plus gros problème avec les flotteurs était le comportement indéfini autour de certaines valeurs de charges. Par exemple, ce que contiennent les autres bits lorsque vous avez un flottant infini. Nous avons standardisé cela, et maintenant ils sont indépendants de la plate-forme équivalente. Il est donc possible d'utiliser des flottants maintenant dans notre environnement vm. nous avons donc décidé qu'il n'y avait aucun mal à prendre en charge les flotteurs, d'autant plus que nous standardisons cela du côté vm. Le plus gros problème avec les flotteurs était le comportement indéfini autour de certaines valeurs de charges. Par exemple, ce que contiennent les autres bits lorsque vous avez un flottant infini. Nous avons standardisé cela, et maintenant ils sont indépendants de la plate-forme équivalente. Il est donc possible d'utiliser des flottants maintenant dans notre environnement vm. 



La pratique standard avec init est que nous vérifions d'abord que l'état n'existe pas. Ensuite, nous vérifions l'entrée. La première chose que nous faisons est de vérifier que la fraction est valide et de vérifier que le dénominateur n'est pas zéro. Ensuite, nous avons une instruction else qui vérifie que le numérateur est inférieur ou égal au dénominateur, ce qui signifie que la fraction est inférieure ou égale à 1. Ceci est important pour éviter certaines erreurs de logique. La prochaine chose que nous faisons est de vérifier que le compte est valide. Ce contrat a été rédigé avant certaines des métriques d'aide qui existent maintenant. Par exemple, nous avons l'identifiant de compte valide dans les types JSON qui effectue cette vérification automatiquement lors de la désérialisation, s'il n'est pas valide, il ne fera que paniquer. Après cela, nous tirons le solde du compte courantdu contrat de jalonnement. Ce solde est généralement assez important car il doit payer pour le stockage de ce contrat particulier, puis nous disons que nous allons allouer des jetons pour le STAKE_SHARE_PRICE_GUARANTEE_FUND. Le pool de jalonnement a certaines garanties qui sont importantes pour les contrats locaux. Les garanties garantissent que lorsque vous déposez dans le pool de jalonnement, vous devriez pouvoir retirer au moins le même nombre de jetons, et vous ne pouvez pas perdre de jetons même pour 1 000 000 000 000 yocto NEAR sur ce contrat en déposant et en retirant de les piscines de jalonnement. Le fonds STAKE_SHARE_PRICE_GUARANTEE_FUND est d'environ 1 000 milliards de yocto NEAR, alors que nous consommons généralement environ 1 ou 2 000 milliards de yocto NEAR pour les erreurs d'arrondi. Enfin on se rappelle quel est le solde que l'on va miser au nom de ce contrat. Ceci est nécessaire pour établir une base de référence afin de limiter les différences d'arrondi. Ensuite, nous vérifions que le compte n'a pas déjà jalonné. Cela pourrait briser une certaine logique. Nous ne voulons pas que cela se produise, nous voulons donc initialiser le contrat avant qu'il ne mette quoi que ce soit. Enfin, nous initialisons la structure, mais nous ne la retournons pas immédiatement. Nous venons de créer la structure StakingContract ici.



Ensuite, nous émettons une transaction de reprise. Ceci est important, car nous devons nous assurer que cette clé de jalonnement qui a été fournie est une clé restreinte ristretto valide, par exemple, une clé valide 5 119. Certaines clés sur la courbe sont des clés valides, mais ne sont pas spécifiques à un ristretto, et les clés de validation ne peuvent être spécifiques qu'à un ristretto. C'est une chose spécifique au protocole NEAR, et ce qui se passe, c'est qu'il effectue une transaction de jalonnement avec la clé donnée. Une fois cette transaction créée à partir du contrat, nous validons cette transaction à sa sortie. Si la clé n'est pas valide, elle générera une erreur et toute l'initialisation de ce pool de jalonnement échouera. Si vous transmettez une clé publique_enjeu invalide en entrée, la consolidation et le déploiement de votre contrat, et toutqui se produit dans cette transaction par lot sera annulée. Ceci est important pour que le pool n'ait pas de clé invalide, car cela pourrait vous permettre de bloquer la mise d'autres personnes. Dans le cadre des garanties, nous disons que si vous annulez votre mise, vos jetons seront rendus en 4 époques. Ils seront éligibles au retrait, et c'est important pour pouvoir les remettre en détention. 



Je pense que c'est trop de détails avant d'expliquer la vue d'ensemble de haut niveau sur le fonctionnement des contrats et le fonctionnement des soldes. Expliquons le concept de la façon dont nous pouvons réellement distribuer des récompenses aux propriétaires de compte en temps constant lorsqu'une époque passe. Ceci est important pour la plupart des contrats intelligents. Ils veulent agir en temps constant pour chaque méthode au lieu d'un temps linéaire pour le nombre d'utilisateurs, car si le nombre d'utilisateurs augmente, la quantité de gaz nécessaire pour faire fonctionner une échelle linéaire augmentera également, et elle finira par manquer de gaz. C'est pourquoi tous les contrats intelligents doivent agir en temps constant. 
Structure du compte


La façon dont cela fonctionne pour chaque utilisateur, nous gardons la structure appelée compte. Chaque utilisateur qui a délégué à ce pool de jalonnement aura une structure appelée compte qui ales champs suivants : unstaked est le solde dans yocto NEAR qui n'est pas jalonné donc c'est juste le solde de l'utilisateur. Ensuite, stake_shares est en fait un solde, mais pas en NEAR, mais plutôt en nombre de parts de jeu. Stake_shares est un concept qui a été ajouté à ce pool de jalonnement particulier. La façon dont cela fonctionne est que lorsque vous misez, vous achetez essentiellement de nouvelles actions au prix actuel en convertissant votre solde de mise en jeu en actions. Le prix d'une part de participation est à l'origine 1, mais au fil du temps, il augmente avec les récompenses, et lorsque le compte reçoit des récompenses, son solde de participation totale augmente, mais le montant total des actions de participation ne change pas. Essentiellement, lorsqu'un compte reçoit des récompenses de validation ou d'autres dépôts directement sur le solde, cela augmente le montant que vous pouvez recevoir pour chaque part de participation. Disons, par exemple, vous aviez à l'origine 1 million NEAR qui a été déposé sur ce compte. Disons que vous obtenez 1 million de parts (en ignorant le yocto NEAR pour l'instant), si le staking pool a reçu 10 000 NEAR en récompenses, vous avez toujours 1 million de parts, mais le 1 million de parts correspond désormais à 1 010 000 NEAR. Maintenant, si quelqu'un d'autre veut participer à ce moment-là, il achètera des parts de participation en interne dans le cadre du contrat.au prix de 1,001 NEAR, parce que chaque action en vaut la peine maintenant. Lorsque vous recevez une autre récompense, vous n'avez pas besoin d'acheter plus d'actions malgré le solde total, et dans le temps constant , tout le monde partage la récompense proportionnellement au nombre d'actions qu'il possède. Maintenant, lorsque vous annulez votre participation, vous vendez essentiellement ces actions ou les brûlez en utilisant le concept de jetons fongibles en faveur du solde non jalonné. Ainsi, vous vendez au prix actuel, vous diminuez le montant total de la mise ainsi que le montant total des actions, et lorsque vous achetez, vous augmentez le solde total de la mise et le total des actions tout en maintenant le prix constant. Lorsque vous misez ou désengagez, vous ne changez pas le prix, lorsque vous recevez les récompenses, vous augmentez le prix.



Le prix ne peut que monter, et cela peut conduire à des erreurs d'arrondi lorsque votre yocto NEAR et votre solde ne peuvent pas correspondre précisément. C'est pourquoi nous avons ce fonds de garantie de 1 000 milliards de yocto NEAR qui jettera plusieurs fois un yocta NEAR supplémentaire dans le mélange. Enfin, la dernière partie est là, parce que le protocole NEAR ne débloque pas et ne restitue pas le solde immédiatement, il doit attendre trois époques jusqu'à ce que votre solde soit débloqué et retourné sur le compte. Si vous annulez votre mise, vous ne pouvez pas retirer ce solde immédiatement du pool de mise, vous devez attendre trois époques. Ensuite, vous vous souvenez à quelle hauteur d'époque vous avez appelé la dernière action de désengagement, et après trois époques, votre équilibre sera déverrouillé et vous devriez être en mesure de vous retirer du désengagement. Cependant, il y a une mise en garde : si vous annulez la mise au dernier bloc de l'époque, la promesse réelle qui fait le dépouillement arrivera pour la prochaine époque. Il arrivera au premier bloc de l'époque suivante, et cela retardera le déblocage de votre solde verrouillé à quatre époques au lieu de trois. C'est parce que nous avons enregistré l'époque dans le précédentbloc, mais la transaction réelle s'est produite dans le bloc suivant, à l'époque suivante. Pour s'assurer que cela n'arrive pas, nous bloquons l'équilibre par quatre époques au lieu de trois époques pour tenir compte de ce cas limite. C'est ce qui constitue un compte. L'idée des actions n'est pas si nouvelle, car sur Ethereumla majorité des fournisseurs de liquidité et des teneurs de marché automatisés utilisent ce concept similaire. Lorsque vous effectuez, par exemple, un dépôt dans le pool de liquidités, vous obtenez une sorte de jeton de ce pool au lieu du montant réel qui y est représenté. Lorsque vous vous retirez du pool de liquidités, vous brûlez ce jeton et obtenez les jetons réellement représentés. L'idée est très similaire au fait de les appeler actions, car elles ont un prix correspondant, et nous aurions pu les appeler différemment. C'était presque depuis le début de ce contrat de pool de jalonnement. Nous avons exploré comment nous pouvons le faire correctement, et l'une des solutions consistait à limiter le nombre de comptes pouvant être déposés sur un compte de pool donné pour cette mise à jour particulière. Nous avons finalement atterri sur le temps de complexité constant et c'était en fait un modèle plus simple.
Types de contrat
Passons en revue ce contrat. Ce n'est pas aussi bien structuré qu'un contrat de lock-up par exemple, car le lock-up est encore plus compliqué. Les types sont toujours regroupés dans le même contrat. Il existe de nombreux types de types, par exemple, reward_fee_fraction est un type distinct. 



Le compte est un type distinct et il existe également un compte lisible par l'homme qui est également un type qui n'est utilisé que pour les appels de vue, il n'est donc pas utilisé pour la logique en interne.



Ensuite, après avoir terminé avec tous les types, nous avons des appels de contrats croisés utilisant une interface de haut niveau.



Il y en a deux. La façon dont cela fonctionne est que vous avez une macro de near_bindgen appelée ext_contract (pour contrat externe). Vous pouvez lui donner un nom court qu'il générera et que vous pourrez utiliser. Ensuite, vous avez une description de trait décrivant l'interface du contrat externe que vous souhaitez utiliser. Cela décrit le fait que vous pouvez appeler une méthode de vote sur un contrat distant et passer un argument. L'argument is_vote qui est un booléen vrai ou faux. Vous pourrez désormais créer une promesse lorsque vous en aurez besoin et passer un argument positionnel au lieu d'un argument sérialisé JSON. La macro en fera une promesse de bas niveau dans les coulisses. La deuxième interface est pour un rappel sur nous-mêmes, c'est assez courant, vous pouvez l'appeler ext_self. Lorsque vous devez effectuer un rappel, et faire quelque chose sur le résultat de la promesse asynchrone que vous pouvez avoir ce type d'interface. Ce que nous faisons, c'est vérifier si l'action de jalonnement a réussi. Enfin, nous avons cette structure de mise en œuvre principale  organe de mise en œuvre du pool de jalonnement. 
Structure de fichier de contrat
Ce contrat est divisé en plusieurs modules. 



Vous avez libs.rs qui est l'entrée principale, et vous avez également un module interne. Le module interne a l'implémentation sans la macro near_bindgen, donc aucune de ces méthodes ne sera visible pour être appelée par un contrat par quelqu'un d'autre sur la chaîne. Ils ne peuvent être appelés qu'au sein de ce contrat en interne afin qu'ils ne génèrent pas de formats JSON et ne désérialisent pas l'état. Ils agissent tous comme des méthodes de rouille régulières. Le fonctionnement de ce contrat de haut niveau est que lorsqu'une époque passe, vous pouvez acquérir certaines récompenses en tant que validateur. 
Méthodes importantes du contrat


Nous avons une méthode ping qui ping le contrat. La méthode ping vérifie si une époque est passée et nous devons ensuite distribuer des récompenses. Si l'époque a changé, elle sera également relancée, car il pourrait y avoir un changement dans le montant de la mise totale que le contrat doit miser. Le prochain est le dépôt.



La méthode de dépôt est payable, ce qui signifie qu'elle peut accepter un dépôt joint. Ceci est similaire au décorateur Ethereum qui vous permet de recevoir des fonds uniquement aux méthodes qui les attendent. Ainsi, par défaut, near_bindgen paniquera si vous essayez d'appeler une méthode, par exemple ping, et attachez un dépôt à cette méthode. Par conséquent, payable nous permet de joindre des acomptes. Dans chaque méthode, il y a un ping interne pour s'assurer que nous avons distribué les récompenses précédentes avant de changer de logique. La structure commune est que si nous devons refaire, nous faisons d'abord une logique, puis nous reprenons. 



La méthode suivante est deposit_and_stake. Il s'agit d'une combinaison entre deux méthodes. Tout d'abord, vous déposez le solde sur le solde de mise de votre compte et vous souhaitez également miser le même montant immédiatement au lieu de faire deux transactions. Il est également payable car il accepte également un acompte.



Le suivant est remove_all. Il essaie de retirer la totalité du solde non engagé du compte qui l'a appelé. Lorsque vous interagissez avec le pool de jalonnement, vous devez interagir avec le compte qui détient le solde. Dans ce cas, il s'agit du prédécesseur_account_id et nous vérifions essentiellement le compte, puis nous retirons le montant non misé si nous le pouvons. S'il n'est pas retiré, alors il paniquera. Par exemple, s'il est toujours verrouillé en raison d'un dépilage il y a moins de 4 époques. 



Le retrait vous permet de ne retirer que le solde partiel. 



Ensuite, stake_all met tout le solde non mis en jeu, et il est assez rare d'utiliser cette méthode, car vous utilisez généralement la mise de dépôt, et il a déjà tout le solde de la mise.



Ensuite, dans la méthode de mise, vous misez simplement un certain montant du solde de la mise. Le portefeuille Moonlight utilise un coût séparé pour déposer en mise, mais ils utilisent une transaction par lots pour ce faire. 



Enfin, vous avez unstake_all qui dépouille essentiellement toutes vos parts de participation en les convertissant en yocto NEAR. Il existe une méthode d'aide qui dit de convertir mon nombre d'actions en un montant de yocto NEAR et d'arrondir à l'inférieur, car nous ne pouvons pas vous donner un supplément pour votre action multipliée par le prix. C'est ainsi que nous obtenons le montant, puis nous appelons unstake pour le montant donné. 



La logique staked_amount_from_num_shares_ rounded_down utilise u256, car les soldes fonctionnent sur u128. Pour éviter les débordements, nous multiplions le total_staked_balance par le nombre de partages dans u256. Le prix est le quotient arrondi à l'inférieur. 



La version arrondie staked_amount_from_num_shares_rounded_up est très similaire sauf que nous effectuons une vérification qui nous permet d'arrondir. À la fin des deux, nous l'avons renvoyé à u128.

Ensuite, nous avons une action de désengagement qui est très similaire à unstake_all, sauf que vous passez le montant.


Méthodes Getter/View
Après cela, il existe un tas de méthodes getter qui sont des appels de vue qui vous renvoient des montants. Vous pouvez obtenir le solde non jalonné du compte, le solde jalonné du compte, le solde total du compte, vérifier si vous pouvez retirer, le solde total de l'enjeu, qui est le montant total que le pool de jalonnement a en jeu actif.



Ensuite, vous pouvez savoir qui est le propriétaire du pool de jalonnement, vous pouvez obtenir les frais de récompense ou la commission actuels du pool de jalonnement, obtenir la clé de jalonnement actuelle, et il y a une chose distincte qui vérifie si le propriétaire a suspendu le pool de jalonnement.



Supposons que le propriétaire effectue une migration sur le pool de jalonnement sur le nœud. Ils doivent complètement débloquer, donc par exemple, ils peuvent mettre en pause le pool de staking qui enverra une transaction d'état au protocole NEAR, puis ne reprendra pas jusqu'à ce qu'ils reprennent le pool de staking. Cependant, vous pouvez toujours retirer vos soldes, mais vous cesserez d'acquérir des récompenses après son expiration. 



Enfin, vous pouvez obtenir un compte lisible par l'homme qui vous donne le nombre de jetons que vous avez réellement pour le nombre d'actions au prix actuel, et enfin il indique si vous pouvez retirer ou non.



Ensuite, il vous donne le nombre de comptes qui est le nombre de délégants à ce pool de jalonnement, et vous pouvez également récupérer plusieurs délégants à la fois. Il s'agit de la pagination sur un grand nombre de comptes au sein de la carte non ordonnée. Une façon de le faire est d'utiliser l'assistant que nous appelons keys_as a_vector à partir de la carte non ordonnée. Il vous donne une collection persistante de clés de la carte, puis vous pouvez utiliser un itérateur pour demander des comptes à partir de ces clés. Ce n'est pas le moyen le plus efficace, mais cela vous permet d'implémenter la pagination sur des cartes non ordonnées. 
Méthodes du propriétaire


Il existe un tas de méthodes de propriétaire. Une méthode propriétaire est une méthode qui ne peut être appelée que par le propriétaire. Le propriétaire peut mettre à jour la clé de jalonnement. Disons qu'ils ont un nœud différent et que le propriétaire doit utiliser une clé différente. Toutes ces méthodes vérifient d'abord que seul le propriétaire peut l'appeler.



C'est la méthode qui modifie la commission sur le pool de jalonnement. Le propriétaire peut modifier immédiatement la commission qui sera active à cette époque à partir de cette époque, mais toutes les commissions précédentes seront calculées en utilisant les frais précédents.



Ensuite, c'est la méthode de vote qui nous a permis de passer à la phase deux du réseau principal.

Viennent ensuite les deux méthodes que j'ai déjà décrites qui permettent de suspendre le jalonnement et de reprendre le jalonnement. 



Le reste ne sont que des tests. La plupart de la logique se passe dans les internes.
Test de simulation
Nous avons aussi essentiellement des tests de simulation pour une piscine particulière. Ce test de simulation montre comment le réseau va réellement fonctionner. Nous avons d'abord initialisé le pool. 



Bob est le délégant. Bob a appelé la méthode de dépôt de pool qui est le deposit_amount en utilisant la méthode de dépôt. Ensuite, Bob peut vérifier que le solde non jalonné fonctionne correctement. Ensuite, Bob mise le montant. Ensuite, nous vérifions le montant de la mise maintenant. Nous avons vérifié que Bob a misé le même montant. 



Bob appelle la méthode ping. Il n'y a pas de récompenses, mais dans les simulations, les récompenses ne fonctionnent pas de toute façon, vous devez donc le faire manuellement. Nous allons vérifier une fois de plus que le montant de Bob est toujours le même. Puis la piscine reprend. Nous vérifions que le pool a repris, puis verrouillons à zéro. Ensuite, nous simulons que le pool a acquis des récompenses (1 NEAR) et bob ping le pool. Ensuite, nous vérifions que le montant que Bob a reçu est positif. C'est un cas de simulation très simple qui dit que Bob a d'abord déposé dans le pool qui vérifie que la pause et la reprise fonctionnent, ou simule que cela fonctionne et s'assure que le pool ne joue pas pendant la pause. Puis lorsqu'elle est reprise, la piscine mise réellement. Donc, ce test vérifie non seulement cela, mais aussi que Bob a acquis la récompense et s'est fait distribuer la récompense. Il y a un autre test qui vérifie certainslogique mais c'est plus compliqué. Il y a des tests unitaires au bas de celui-ci qui sont censés vérifier certaines choses. 



Certains de ces tests ne sont pas idéaux, mais ils vérifient certaines choses qui étaient assez bonnes pour s'assurer que les mathématiques s'additionnent.
internal.rs
Méthode de ping internal


Passons à internal_ping. C'est la méthode que n'importe qui peut appeler via ping pour s'assurer que les récompenses sont distribuées. À l'heure actuelle, nous avons des pools de jalonnement actifs et il y a un compte parrainé par l'un des membres de NEAR qui envoie un ping à chaque mise du pool toutes les 15 minutes pour s'assurer qu'ils ont distribué les récompenses à afficher sur le solde. De cette façon, la distribution des récompenses fonctionne. Nous vérifions d'abord la hauteur de l'époque actuelle, donc si la hauteur de l'époque est la même, alors l'époque n'a pas changé, nous renvoyons false afin que vous n'ayez pas besoin de refaire. Si l'époque a changé alors nousrappelez-vous que l'époque actuelle (hauteur de l'époque) existe, nous obtenons le nouveau solde total du compte. Le ping peut être appelé lorsque certains jetons ont été déposés via des bulletins de dépôt, et ils font déjà partie du compte_balance, et comme le ping a été appelé avant, nous devons soustraire ce solde avant de distribuer les récompenses. Nous obtenons le montant total du compte, y compris le solde bloqué et le solde débloqué. Le solde verrouillé est un montant misé qui acquiert des récompenses, et le solde déverrouillé peut également avoir des récompenses dans certains scénarios où vous diminuez votre mise, mais vos récompenses seront toujours reflétées pour les deux prochaines époques. Après cela, ils viendront au montant non misé. Nous vérifions en utilisant assert! que le solde total est supérieur au solde total précédent. C'est un invariant que requiert le pool de jalonnement. Il y avait un tas de trucs sur le testnet qui ont échoué à cet invariant parce que les gens avaient toujours des clés d'accès sur le même pool de jalonnement, et quand vous l'avez, vous dépensez le solde pour l'essence, et vous pouvez diminuer votre solde total sans acquérir la récompense . Enfin, nous calculons le montant des récompenses que le pool de staking a reçu. Il s'agit du solde total moins le solde total connu précédent, le solde de l'époque précédente. Si les récompenses sont positives, nous le solde de l'époque précédente. Si les récompenses sont positives, nous le solde de l'époque précédente. Si les récompenses sont positives, nousles distribuer. La première chose que nous faisons est de calculer la récompense que le propriétaire prend pour lui-même sous forme de commission. 



Nous multiplions la reward_fee_fraction par la récompense totale reçue et celle-ci est arrondie de la même manière avec le numérateur en u256 multiplié par la valeur divisée par le dénominateur en u256.



Le owner_fee est le montant en yocto NEAR que le propriétaire gardera pour lui-même. Le restant_reward correspond aux récompenses restantes qui doivent être réinvesties. Ensuite, il est refait. Le propriétaire a reçu les récompenses dans yocta NEAR, pas en actions, mais parce que toute la logique doit être en actions, le propriétaire du pool de jalonnement achète des actions au prix des distributions post-récompenses au reste des délégants. Donc, num_shares est le nombre d'actions que le propriétaire recevra en compensation pour la gestion du pool de jalonnement. S'il est positif, nous augmentons le nombre d'actions et économisons le compte du propriétaire, et nous augmentons également le montant total de la participation en actions. Si, pour une raison quelconque, lors de l'arrondissement, ce solde devenait nul, la récompense était très faible et le prix par action était très élevé, et le pool ne recevait que zéro récompense. Dans ce cas, ce solde ira simplement au prix par action au lieu d'indemniser le propriétaire. Ensuite, nous mettons des données de journalisation totales indiquant que l'époque actuelle existe, que nous avons reçu les récompenses en un nombre de parts de jalonnement ou de jetons, que le solde total de la participation du pool est quelque chose, et nous enregistrons le nombre de parts. La seule façon d'exposer le nombre de partages au monde extérieur est à travers les journaux. Ensuite, si le propriétaire a reçu des récompenses, cela signifie que la récompense totale était autant d'actions. Enfin, on se souvient juste du nouveau solde total et c'est tout. Nous avons distribué toutes les récompenses en temps constant et nous n'avons mis à jour qu'un seul compte (compte du propriétaire) pour la commission, et uniquement si la commission était positive. nous mettons des données de journalisation totales qui indiquent que l'époque actuelle existe, que nous avons reçu les récompenses en un nombre d'actions de jalonnement ou de jetons, que le solde total de la mise du pool est quelque chose, et nous enregistrons le nombre d'actions. La seule façon d'exposer le nombre de partages au monde extérieur est à travers les journaux. Ensuite, si le propriétaire a reçu des récompenses, cela signifie que la récompense totale était autant d'actions. Enfin, on se souvient juste du nouveau solde total et c'est tout. Nous avons distribué toutes les récompenses en temps constant et nous n'avons mis à jour qu'un seul compte (compte du propriétaire) pour la commission, et uniquement si la commission était positive. nous mettons des données de journalisation totales qui indiquent que l'époque actuelle existe, que nous avons reçu les récompenses en un nombre d'actions de jalonnement ou de jetons, que le solde total de la mise du pool est quelque chose, et nous enregistrons le nombre d'actions. La seule façon d'exposer le nombre de partages au monde extérieur est à travers les journaux. Ensuite, si le propriétaire a reçu des récompenses, cela signifie que la récompense totale était autant d'actions. Enfin, on se souvient juste du nouveau solde total et c'est tout. Nous avons distribué toutes les récompenses en temps constant et nous n'avons mis à jour qu'un seul compte (compte du propriétaire) pour la commission, et uniquement si la commission était positive. La seule façon d'exposer le nombre de partages au monde extérieur est à travers les journaux. Ensuite, si le propriétaire a reçu des récompenses, cela signifie que la récompense totale était autant d'actions. Enfin, on se souvient juste du nouveau solde total et c'est tout. Nous avons distribué toutes les récompenses en temps constant et nous n'avons mis à jour qu'un seul compte (compte du propriétaire) pour la commission, et uniquement si la commission était positive. La seule façon d'exposer le nombre de partages au monde extérieur est à travers les journaux. Ensuite, si le propriétaire a reçu des récompenses, cela signifie que la récompense totale était autant d'actions. Enfin, on se souvient juste du nouveau solde total et c'est tout. Nous avons distribué toutes les récompenses en temps constant et nous n'avons mis à jour qu'un seul compte (compte du propriétaire) pour la commission, et uniquement si la commission était positive. 
Méthode de internal stake


L'internal_stake est l'endroit où nous mettons en œuvre le fonds de garantie des prix. Disons que le prédécesseur, dans ce cas, nous allons l'appeler account_id veut miser un nombre de jetons. Balance n'est en fait pas un type JSON, car il s'agit d'une méthode interne, nous n'avons donc pas besoin de JSON ici. Nous calculons combien d'actions sont arrondies à l'inférieur qui sont nécessaires pour miser le montant donné, c'est donc le nombre d'actions que le propriétaire recevra. Il doit être positif. Ensuite, nous vérifions le montant que le propriétaire doit payer pour les actions, encore une fois arrondi à l'inférieur. C'est pour garantir que lorsque le propriétaire a acheté des actions et les a reconverties sans récompenses, il n'a jamais perdu le 1 yocto NEAR, car cela pourrait rompre la garantie. Enfin, nous affirmons que le compte a assez pour payer le montant facturé, et nous diminuons le solde interne non mis en jeu, et augmenter le solde interne du nombre d'actions du compte. Ensuite, nous arrondissons le staked_amount_from_num_shares_rounded_up vers le haut afin que le nombre d'actions soit réellement arrondi. Ce 1 penny supplémentaire ou 1 yocto supplémentaire NEAR proviendra du fonds garanti lors de l'arrondi des actions. Nous avons facturé moins à l'utilisateur, mais nous avons contribué davantage au montant de ce 1 000 milliards de yocto NEAR que nous avions initialement désigné pour cela. Cette différence n'est généralement que de 1 yocto NEAR qui peut provenir de l'arrondi vers le haut ou vers le bas. Après cela, il y a le montant de total_staked_balance et total_stake_shares. Ensuite, nous créons de nouvelles actions avec eux. Enfin, nous mettons un journal et retournons le résultat. Ce 1 penny supplémentaire ou 1 yocto supplémentaire NEAR proviendra du fonds garanti lors de l'arrondi des actions. Nous avons facturé moins à l'utilisateur, mais nous avons contribué davantage au montant de ce 1 000 milliards de yocto NEAR que nous avions initialement désigné pour cela. Cette différence n'est généralement que de 1 yocto NEAR qui peut provenir de l'arrondi vers le haut ou vers le bas. Après cela, il y a le montant de total_staked_balance et total_stake_shares. Ensuite, nous créons de nouvelles actions avec eux. Enfin, nous mettons un journal et retournons le résultat. Ce 1 penny supplémentaire ou 1 yocto supplémentaire NEAR proviendra du fonds garanti lors de l'arrondi des actions. Nous avons facturé moins à l'utilisateur, mais nous avons contribué davantage au montant de ce 1 000 milliards de yocto NEAR que nous avions initialement désigné pour cela. Cette différence n'est généralement que de 1 yocto NEAR qui peut provenir de l'arrondi vers le haut ou vers le bas. Après cela, il y a le montant de total_staked_balance et total_stake_shares. Ensuite, nous créons de nouvelles actions avec eux. Enfin, nous mettons un journal et retournons le résultat. Après cela, il y a le montant de total_staked_balance et total_stake_shares. Ensuite, nous créons de nouvelles actions avec eux. Enfin, nous mettons un journal et retournons le résultat. Après cela, il y a le montant de total_staked_balance et total_stake_shares. Ensuite, nous créons de nouvelles actions avec eux. Enfin, nous mettons un journal et retournons le résultat.



Unstaking fonctionne de manière très similaire. Vous arrondissez au montant d'actions que vous devez payer. Ensuite, nous calculons le montant que vous recevez, en arrondissant à nouveau pour vous surpayer pour cela. Celle-ci provient également d'un fonds de garantie. Ensuite, nous diminuons les parts pour augmenter le montant et indiquons quand vous pouvez débloquer le solde entre quatre époques. Le unstake_amount est arrondi à l'inférieur afin que nous déposions un peu moins pour garantir le prix des autres participants de la cagnotte. C'est à peu près comme ça que fonctionne le pool de jalonnement et que les mathématiques fonctionnent. Nous compensons les erreurs d'arrondi à partir des fonds que nous avons alloués.
Conclusion
Nous avons mis à jour les clés ristretto lors de la conception de ce contrat et il était surprenant que nous devions en tenir compte. Dans le STAKE_SHARE_PRICE_GUARANTEE_FUND, 1 000 milliards de yocto NEAR devraient suffire pour 500 milliards de transactions, ce qui devrait être assez long pour le pool de staking afin qu'il ne puisse pas être rechargé car les récompenses seront immédiatement redistribuées au total_stake_balance au prochain ping.  Nous avons consacré beaucoup de temps et d'efforts à ce contrat, car nous avons effectué des tonnes d' examens de sécurité, y compris en interne et en externe, en particulier autour de ces mathématiques. C'était compliqué, et certaines choses ont été découvertes comme la clé ristretto qui est apparue lors des examens. Nousmarqué le journal des modifications de ce contrat, ainsi que dans le fichier readme, il y a un tas de choses qui sont apparues pendant le développement et les tests sur le système en direct, mais la version originale a pris environ une semaine à écrire. Plus tard, nous l'avons nettoyé, testé et amélioré. Ensuite, nous avons fait un tas de révisions. La mise en pause et la reprise ont été demandées par le pool, car sinon le propriétaire n'avait pas la possibilité de déjouer si son nœud tombe en panne. Ils attaqueront le réseau. Essentiellement, cet enjeu actif demanderait la validation et ne ferait pas fonctionner le réseau. Avant, nous n'avions pas de coupe. Ce n'était tout simplement pas un problème pour les participants, mais c'était un problème pour le réseau lui-même. De cette façon, le propriétaire peut suspendre le jalonnement s'il ne veut pas gérer le pool qu'ilmigrer dans le pool, et communiquer le plus possible avant cela. Ensuite, nous avons mis à jour l'interface de vote pour qu'elle corresponde au contrat de vote final de la phase deux. Nous avons ajouté des méthodes d'affichage d'assistance pour pouvoir interroger les comptes de manière lisible par l'homme. Enfin, il y a eu quelques améliorations autour des méthodes de traitement par lots ensemble, donc deposit_and_stake, stake_all, unstake_all et remove_all au lieu d'avoir d'abord à faire un appel de vue, à obtenir le montant et à mettre le montant pour appeler la mise. Voici la façon dont nous l'avons corrigé. 



Lorsque vous stake, non seulement vous misez le montant, mais nous joignons également une promesse de vérifier si la mise a réussi. C'est nécessaire pour deux choses : vous si vous essayez de parier avec une clé invalide (pas une clé spécifique à ristretto), alors la promesse échouera avant l'exécution. La validation échoueraavant de l'envoyer, et cela fera en sorte que vous n'avez pas besoin de le vérifier dans le contrat. Il renverra le dernier appel, et tout ira bien. Nous avons également introduit la mise minimale au niveau du protocole. La mise minimale est d'un dixième du montant du prix du dernier siège, et si votre contrat essaie de miser moins que cela, l'action échouera et vous n'enverrez pas la promesse. Supposons que vous souhaitiez retirer une somme et que votre solde soit inférieur au dixième de la mise. L'action de jalonnement peut échouer, et vous n'allez pas dépiquer, alors que vous en avez besoin pour garantir que le dépouillement doit avoir lieu. Dans ce cas, nous avons ce rappel qui vérifie que l'action de staking s'est terminée avec succès. Ce rappel vérifie essentiellement que s'il échoue, et que le solde est positif, nous devons déjouer. Il appellera donc unstake pour une action où le montant de la mise est de zéro pour s'assurer que tout le solde est libéré. Vous pouvez vous retirer en 4 époques lors du test de ces contrats que nous avons fait sur le testnet beta 9 avant la maintenance. Le contrat était prêtpeut-être vers l'heure d'été, donc le test de cette itération a probablement pris entre 2 et 4 mois en raison de la complexité que cela implique pour interagir avec le protocole. Il y a eu beaucoup d'apprentissage de la pagination aux méthodes d'aide, et du regroupement de certaines choses. Une chose qui serait vraiment bien d'avoir une mise ou un dépôt et une mise sur un contrat de blocage. À l'heure actuelle, vous devez indiquer manuellement combien vous voulez miser sur un contrat de verrouillage, mais ce serait formidable si vous n'aviez pas besoin de penser à votre yocto NEAR et à combien il est verrouillé pour le stockage. Vous voulez juste tout mettre en jeu depuis votre verrouillage, mais comme il était déjà déployé, il était trop tard pour y penser. Il y a aussi du gaz qui est codé en dur, et avec le commundiminution des frais, ces numéros ne peuvent pas être modifiés car ils sont déjà sur la chaîne.



Donc le vote n'est pas important mais la méthode ON_STAKE_ACTION_GAS vous oblige à avoir un grand nombre pour chaque mise et vous ne pouvez pas le diminuer. Prendre des risques à chaque appel sur ce contrat nous obligera à avoir une grande quantité de gaz et le problème est que c'est du gaspillage. Disons que nous sommes d'accord pour brûler tout le gaz, ce gaz sera toujours brûlé et gaspillé et cela limite le nombre de transactions que vous pouvez mettre dans un bloc si nous restreignons le gaz en fonction de ce cas. Il y a eu beaucoup d'itérations sur les tests du contrat en utilisant le cadre de test de simulation que nous avons beaucoup amélioré. Si nous arrivons finalement aux contrats de verrouillage, vous pouvez voir comment la structure des contrats de verrouillage s'est améliorée par rapport à celui-ci.

### NEAR Protocol và Polygon

Nền tảng Polygon là tâm điểm trong vài tháng vừa qua. Với mục đích giải quyết vấn đề mở rộng mạng lưới (scalability) của Ethereum, giải pháp layer-2 như Polygon đã thu hút được một lượng lớn sự theo dõi từ cộng đồng. . NEAR Protocol không chỉ là một blockchain layer-1 có khả năng mở rộng cao, nó còn cung cấp trải nghiệm  layer 2 tương thích với máy ảo Ethereum  EVM khá giống với Polygon. Ở bài viết này, chúng ta sẽ cùng so sánh 2 dự án này.
Polygon là gì?
Để hiểu về Polygon, chúng ta cần hiểu thế nào là layer-2. Trong mạng lưới Ethereum, blockchain Ethereum được xem như là “layer-1”. Mạng lưới phi tập trung ưu tiên về tính bảo mật và tính chân thật , mà để đảm bảo hai yếu tố này thì chúng ta phải hy sinh tốc độ giao dịch của mạng lưới. Có một hướng giải quyết vấn đề này là xây dựng thêm 1 một mạng lưới phía trên blockchain gốc và giải pháp này có tên là layer-2. Blockchain ủy thác các phép tính phức tạp cho layer phía trên, giúp tăng tốc độ tổng thể theo cấp số nhân. Polygon là một ví dụ về giải pháp layer 2.

Đồng native token của hệ sinh thái Polygon là MATIC. Công dụng chính của đồng MATIC là:

 	Thanh toán và giao dịch giữa 2 bên
 	Cổ phần (staking) và quản trị (governance). Số lượng MATIC bạn có ảnh hưởng đến quyền bỏ phiếu của bạn.
 	Trả các phí giao dịch.
 	Thưởng cho người dùng cung cấp các tài nguyên và dịch vụ tính toán

Matic có tổng cung lên đến 10 tỷ đồng.
Cơ chế hoạt động của Polygon
Polygon có một hệ sinh thái đa cấp sử dụng các sidechains tương thích với EVM. Mục đích của các sidechains này là để mở blockchain chính. Sidechains là các blockchain phụ được liên kết với chuỗi chính thông qua chốt hai chiều (two-way peg). Sidechain có thể có các quy tắc và hệ sinh thái độc nhất của riêng nó. Định kỳ, các sidechains phải cam kết gửi dữ liệu về blockchain chính để đảm bảo các hoạt động được diễn ra liền mạch.

Các nhà phát triển tạo các sidechains của riêng họ để mở rộng quy mô ứng dụng của họ bằng cách sử dụng Polygon SDK.  Polygon trở nên phổ biến trong cộng đồng Ethereum do phí giao dịch rẻ hơn và tốc độ cũng cao hơn.

Polygon sử dụng cơ chế proof-of-stake (PoS), mọi người đều có thể trở thành Validator bằng cách stake MATIC. Validator có thể đảm nhiệm các vai trò sau trong hệ sinh thái:

 	Xác thực các giao dịch bằng cách phê duyệt và xác nhận các giao dịch trong sidechains.
 	Validator có thể đảm nhận việc quản trị bằng cách bỏ phiếu cho các bản nâng cấp khác nhau.
 	Chịu trách nhiệm lựa chọn các block producer cho mỗi điểm kiểm tra. (chúng ta sẽ nói kỹ hơn về vai trò này ở phần sau)

Polygon sidechain là một phần của hệ sinh thái Ethereum trong đó người dùng có thể nhanh chóng thực thi các dự án của họ mà không phải lo lắng về phí gas tăng cao hay số giao dịch được xử lý có phần hạn chế như trên mainnet của Ethereum.

Cách Polygon đảm bảo tốc độ và sự phi tập trung

Cơ chế PoS của Polygon chủ yếu được sử dụng cho nhiệm vụ checkpointing. Điều này có nghĩa là một nhóm các node tạo khối được chỉ định cho mỗi điểm kiểm tra và các block producer này chịu trách nhiệm duy trì và đảm bảo sự đồng thuận. Việc có một số lượng hạn chế các block producer cho phép Polygon tạo khối nhanh hơn rất nhiều so với Ethereum (tạo một khối mất khoảng 1 giây thay vì 20 giây).

Trên hết, Polygon đảm bảo tính phi tập trung bằng cách ủy quyền cho các điểm kiểm tra một cách định kỳ cho blockchain chính là Ethereum. Mọi khối đơn lẻ được tạo bởi block producer phải được xác thực thông qua cơ chế bằng chứng về khối (Proof of Block) đã cam kết với blockchain layer-1 Ethereum.

Tương tác với Polygon như thế nào?

Đây là những gì bạn cần làm để tương tác với các dự án xây dựng trên Polygon Sidechain:

 	Xác định hợp đồng trên mạng Ethereum và khai báo số lượng Token bạn muốn gửi đến Polygon sidechain.
 	Một Smart Contract đặc biệt có tên “RootChainManager” sẽ kích hoạt một hợp đồng khác có tên là “ChildChainManager”. Hai hợp đồng này hoạt động song song với nhau để đảm bảo rằng số lượng token bạn khóa trong mạng Ethereum được chuyển liên tục sang mạng chính.
 	Giờ đây, người dùng có thể chuyển sang mạng Polygon và chấp nhận Token của họ.

Ngược lại, muốn chuyển từ Polygon sang Ethereum thì làm cách nào? Hãy làm theo các bước sau:

 	Bạn phải đốt Token của mình trên Polygon.
 	Việc xác minh việc đốt Token này cần phải được gửi đến mạng Ethereum.
 	Sau khi được xác minh, Token của bạn sẽ được phân bổ lại cho bạn trong ví của bạn.

NEAR Protocol là gì?
Mùa hè năm 2018, Illia Polosukhin và Alexander Skidanov đã tạo ra NEAR Protocol làm nền tảng phát triển lý tưởng cho các ứng dụng phi tập trung. Hầu hết các nền tảng khác có tốc độ thấp, băng thông thấp và khả năng tương thích kém với các blockchain khác.

NEAR Protocol được tạo dựng từ đầu và có các tính năng sau để cho phép khả năng mở rộng và bảo mật tốt:

 	NEAR sử dụng cơ chế tạo khối được gọi là “Doomslug”. Doomslug đảm bảo thời gian tạo khối trong khoảng 1 giây. 
 	NEAR là một hệ thống được chia nhỏ cho phép khả năng mở rộng vô hạn. NEAR dùng một phương thức tiếp cận độc nhất để mở rộng quy mô lên đến hàng tỷ giao dịch theo cách hoàn toàn phi tập trung thay vì phụ thuộc vào các quy trình tập trung như các giao thức khác.

Sharding là gì?

Sharding là một kỹ thuật được dùng trong database (cơ sở dữ liệu) để xử lý những khối dữ liệu cồng kềnh. Sharding phân tách database thành các phần nhỏ gọi là “shards” (mảnh nhỏ). Các shards có thể được xử lý song song nhằm tăng tốc độ tính toán của mạng lưới.

Vậy chính xác những việc gì xảy ra đối với blockchain trong quá trình Sharding? Hãy cùng xem

 	Toàn bộ trạng thái blockchain được chia thành các shards.
 	Mỗi tài khoản đều thuộc về một shard duy nhất và chúng chỉ có thể tương tác với các tài khoản thuộc cùng một shard đó.

Vấn đề với kỹ thuật sharding thông thường là nó yêu cầu các node phải chạy trên phần cứng ngày càng phức tạp, đây là rào cản lớn để một node có thể tham gia vào blockchain. Kỹ thuật sharding của NEAR cho phép các node nhỏ chạy trên các phiên bản đơn giản được lưu trữ trên đám mây.

Aurora là gì?

Aurora cung cấp trải nghiệm layer 2 tương thích với Ethereum trên NEAR và bao gồm Aurora Bridge và Aurora Engine. Các nhà phát triển Ethereum có thể chạy ứng dụng của họ trên Aurora để tận dụng những ưu điểm của NEAR, chẳng hạn như phí gas thấp và sharding. Dưới đây là những cải tiến mà Aurora đang mang lại:

 	Các App có thể xử lý hàng nghìn giao dịch mỗi giây. Đây là một cải tiến theo cấp số mũ so với Ethereum.
 	Aurora cực kỳ nhanh vì nó có thời gian tạo khối là 2 giây so với 15 giây trên Ethereum.
 	Công nghệ sharding của NEAR cho phép hệ sinh thái mở rộng quy mô theo chiều ngang.
 	Phí gas trên Aurora thấp hơn 1000 lần so với phí trên Ethereum.
 	Hoàn toàn tương thích với Ethereum.

DeFi trong hệ sinh thái của NEAR và Polygon
Polygon DeFi
Polygon cho phép bạn sử dụng hầu hết các ứng dụng DeFi phổ biến trên Ethereum, như Curve Finance, 1inch Exchange và Beefy Finance. Theo DappRadar, 5 ứng dụng hàng đầu của người dùng trong 24 giờ qua như sau:



Sushi có vẻ là dapp phổ biến nhất.

Hệ sinh thái DeFi ngày càng phát triển của Polygon đã thu hút nhiều sự chú ý. Hình ảnh sau đây cho bạn thấy tổng giá trị bị khóa (TVL) trong Polygon, hiện là khoảng 5,19 tỷ đô.



TVL đạt mức cao nhất là 10,54 tỷ đô la vào ngày 15 tháng 6 năm 2021. Ngoài ra, khi nói đến giá trị thực tế, Aave là Protocol có TVL lớn nhất, chiếm 40% tổng số TVL.
NEAR DeFi
So sánh với Polygon, NEAR vẫn là một hệ sinh thái mới và đang phát triển nhanh chóng trong 3 tháng qua. Và hiện tại thì TVL chỉ có 141.72 tỷ đô.



Ref Finance là ứng dụng Defi chiếm ưu thế nhất với 80% total value lock.

Ref Finance có một số điểm tương đồng với Uniswap V2, ngoài ra nó hỗ trợ nhiều loại pool hơn, tùy chỉnh phí và nó hoàn toàn thuộc sở hữu của cộng đồng. Ref cũng là nền tảng DeFi đầu tiên trên NEAR. Mục đích chính của Ref là kết hợp DEX, Lending protocol, phát hành tài sản tổng hợp và nhiều hơn nữa.

NEAR mới đây đã công bố một quỹ tài trợ khổng lồ trị giá 800 triệu đô nhằm mục đích cụ thể là tạo ra một hệ sinh thái DeFi lớn hơn và lành mạnh hơn. Quỹ có một số yêu cầu chính, bao gồm những điều sau:

 	100 triệu đô la cho các công ty khởi nghiệp
 	Quỹ 100 triệu đô la theo từng khu vực
 	250 triệu đô tài trợ hệ sinh thái sẽ được phân phối trong bốn năm.

NFT trên NEAR và Polygon
Polygon NFT
Polygon là một trong ba blockchain hiện có trên Opensea (một trong những chợ NFT lớn nhất trên thế giới) cùng với Ethereum và Klaytn. Theo xếp hạng của trang web, đây là 5 NFT hàng đầu trên Polygon:



Có vẻ như ZED RUN đang là NFT đứng đầu trong hệ sinh thái của Polygon.

Vậy ZED là gì? Đây là ứng dụng đua ngựa được xây dựng trên blockchain. Bạn sẽ thu thập các chiến mã càng nhiều càng tốt để kiếm về lợi nhuận đều đặn.


NEAR NFT
Hiện tại, có một số nền tảng NFT trên NEAR như Mintbase. Mintbase được bắt đầu xây dựng vào năm 2018 bởi Nate Geier và Calorine Wend, dự án cũng đã huy động được 1 triệu đô la từ vòng tài trợ hạt giống vào năm 2020. Nền tảng này cho phép người dùng tạo và bán tài sản được hỗ trợ bởi NFT. Ngoài ra, người dùng có thể đúc các tài sản kỹ thuật số khác nhau dưới dạng NFT. Những tài sản này có thể bao gồm từ vé sự kiện đến nghệ thuật tiền điện tử.



Điều thú vị là Mintabase từng dự định sẽ khởi chạy trên Ethereum. Tuy nhiên, phí gas cao và tình trạng tắc nghẽn ngày càng gia tăng đã khiến họ không thể làm được điều đó. Vì vậy, Mintbase coi NEAR là một nền tảng tốt hơn Ethereum, với phí gas thấp hơn đáng kể nhờ vào mô hình thực thi hợp đồng hiệu quả hơn.
Kết luận
Polygon là giải pháp layer-2 đã thu hút được nhiều sự chú ý trong năm qua. Ngoài ra, do có mối quan hệ chặt chẽ với cộng đồng Ethereum, dự án này đã trở nên khá phổ biến với cộng đồng .

Mặt khác, NEAR đã cho thấy rất nhiều hứa hẹn bằng cách giải quyết các vấn đề về khả năng mở rộng với công nghệ sharding. Thêm vào đó, khoản tài trợ dành cho các nhà phát triển trị giá 800 triệu đô la sẽ mang lại một lượng đáng kể các ứng dụng tiện ích cho hệ sinh thái của NEAR. Cả hai giao thức - Polygon và NEAR - đều cung cấp một nền tảng hoàn hảo cho các nhà phát triển để xây dựng một nền kinh tế phi tập trung có khả năng mở rộng và hiệu quả cao.

### Update - November 22, 2021

Brief Summary:

 	LNC family reached 26,000 (L)Earners!


Results:

 	November Redeem to NEAR window was the biggest so far
Over 200 genuine (L)Earners got 2 NEAR! Congrats and happy (L)Earning!
 	Many thanks to LNC beta-testers for your feedback on our NCDL2 project "TokenHub".



 	New Guide NEAR Protocol and Polygon


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC updated website is coming LIVE gradually!

### Cómo funciona el NEAR Rainbow Bridge

Article by Matt Henderson of Aurora 

El NEAR Rainbow Bridge es único en criptografía como el único puente sin permisos y sin confianza hacia Ethereum. En este artículo, vamos a desmitificar cómo funciona.

El protocolo NEAR creó el Rainbow Bridge, algo que es único y valioso en el espacio criptográfico, un puente completamente "sin confianza" para transferir tokens entre Ethereum y NEAR, y en última instancia, Aurora. Si bien existen descripciones técnicas del puente, este artículo explicará cómo funciona de una manera que, con suerte, sea comprensible para cualquier persona con una familiaridad básica con las criptomonedas.

El concepto

Comencemos imaginando que quiero transferir 20 DAI de Ethereum a NEAR. Dado que la transferencia física de tokens no es posible entre redes, esto significa que debemos sacar 20 DAI de circulación en Ethereum y poner 20 DAI en circulación en NEAR, para que el suministro global de DAI no cambie.

Así es como podría hacer eso de una manera sin confianza y sin permiso:

 	Le digo a la red Ethereum que quiero transferir 20 DAI a otro lugar.
 	La red Ethereum bloquea mis 20 DAI en una bóveda (un contrato inteligente), para que se retiren de circulación.
 	Una vez que estoy seguro de que esos 20 DAI se han bloqueado en Ethereum, le digo a NEAR que cree 20 nuevos DAI para mí allí.
 	NEAR no confía en mí, por supuesto, por lo que me pide que demuestre que he bloqueado 20 DAI en Ethereum.
 	Proporciono a NEAR pruebas de que he bloqueado esos DAI en Ethereum.
 	NEAR verifica de forma independiente mi prueba y luego crea 20 DAI nuevos para que los use en NEAR.

Más tarde, si deseo mover mi DAI de NEAR a Ethereum, simplemente invierto el procedimiento anterior. Limpio, ¿eh?
Los actores
Así que ahora veamos cómo sucede todo eso en la práctica, usando el Puente Arcoíris. La historia involucrará una serie de componentes técnicos que conforman el puente:

La interfaz de usuario de Rainbow Bridge: este es el sitio web donde usted, como usuario, interactúa con el puente para transferir sus activos entre redes.

LiteNode: es como un nodo de cadena de bloques, excepto que solo almacena encabezados de bloque, lo que reduce drásticamente el espacio de almacenamiento necesario. El LiteNode se implementa como un contrato inteligente, y tenemos dos de ellos: uno implementado en la red Ethereum, que almacena NEAR encabezados de bloque, y otro implementado en NEAR, que almacena encabezados de bloque Ethereum.

(Solo para su información, el LiteNode en realidad se conoce como el "cliente ligero" en otros artículos, por razones históricas. Si me pregunta, "¿Qué almacena datos de blockchain?", Mi primer pensamiento es "un nodo", y así en este artículo, para ayudar con los modelos mentales, lo llamo LiteNode).

Relayers: dado que los LiteNodes son contratos inteligentes, no pueden ejecutarse ni actualizarse por sí mismos. Los retransmisores son scripts que se ejecutan en servidores tradicionales, que leen bloques periódicamente de una cadena de bloques y los comunican al LiteNode que se ejecuta en la otra. Entonces, los retransmisores mantienen los LiteNodes actualizados.

Dado que hay un costo de transacción, es decir. tarifas de gas: cada vez que un retransmisor actualiza un LiteNode, el de NEAR (que contiene los bloques de Ethereum) se actualiza en cada bloque de Ethereum (ya que las tarifas de gas de NEAR son baratas), mientras que la frecuencia de actualización en Ethereum (que contiene los bloques de NEAR) es configurable y determinado por un presupuesto económico (actualmente alrededor de 12 a 16 horas).

Conectores: los conectores son contratos inteligentes responsables de toda la lógica asociada con la gestión de cadenas cruzadas de un tipo de activo determinado. Al igual que los LiteNodes, existen en pares: uno que se ejecuta en Ethereum y otro que se ejecuta en NEAR. Por ejemplo, hay un par de "conectores ETH" responsables de transferir ETH entre las dos redes. Y hay un par de "Conector ERC-20" responsable de transferir tokens ERC-20. Alguien podría escribir un conector “NFT”, un conector de “Predicción de resultados de mercado” o un conector de “Resultados de votación DAO” si lo deseara. ¡Cualquier activo o dato se puede transferir a través de Rainbow Bridge, si existen conectores relevantes!
Poniendo las piezas juntas
Para comprender cómo todos estos elementos funcionan juntos para permitirme transferir tokens sin permiso y sin confianza entre Ethereum y NEAR, repasemos nuestro ejemplo original nuevamente:

 	Usando la interfaz de usuario de Rainbow Bridge, comienzo una transferencia de 20 DAI de Ethereum a NEAR.
 	Cuando confirmo la primera de las dos transacciones en MetaMask, Rainbow Bridge se comunica con el conector ERC-20 en Ethereum (ya que DAI es un token ERC-20), que transfiere y bloquea 20 DAI en su bóveda. Estos DAI ya no están en circulación en la red Ethereum.
 	Según los datos del encabezado en mi bloque de transacciones, la interfaz de usuario de Rainbow Bridge calcula una "prueba" criptográfica de que realmente bloqueé 20 DAI.
 	Dado que a continuación vamos a pedirle a la red NEAR que cree un DAI basado en lo que acaba de suceder en Ethereum, primero esperamos a que el Relayer envíe alrededor de 20 encabezados de bloques Ethereum al LiteNode que se ejecuta en NEAR. Esto es por seguridad, de la misma manera que su intercambio de criptomonedas lo hace esperar algunas confirmaciones antes de usar sus fondos depositados.
 	Después de esta espera, la interfaz de usuario de Rainbow Bridge nos permite dar el paso dos en el proceso: pedirle al conector ERC-20 en NEAR que cree 20 DAI nuevos para nosotros en la red NEAR.
 	Cuando hacemos esta solicitud al conector ERC-20, proporcionamos nuestra prueba criptográfica que recibimos anteriormente, "probando" que bloqueamos 20 DAI en Ethereum.
 	El conector ERC-20 en NEAR buscará nuestro encabezado de bloque Ethereum en el LiteNode que se ejecuta en NEAR y hará su propio cálculo independiente de la prueba criptográfica.
 	Si la prueba que proporcionamos coincide con la prueba que calcula el conector ERC-20, entonces sabe que esos 20 DAI están bloqueados de forma segura en Ethereum, ¡y que fui yo quien lo bloqueó! CERCA y las entrega a mi billetera.

Cuando queremos transferir DAI de NEAR de nuevo a Ethereum, el proceso ocurre a la inversa, es decir, en lugar de bloquear 20 DAI en NEAR, los destruimos, lo que se conoce como "quema", y luego proporcionamos la "prueba" de esa quema al Conector que se ejecuta en Ethereum. Al tener acceso a los bloques NEAR en el LiteNode que se ejecuta en Ethereum, valida nuestra prueba, libera 20 DAI de su bóveda y los envía a nuestra billetera.

¡Y así, en pocas palabras, es cómo funciona el Puente Arcoíris! Actualmente, es el único puente Ethereum en criptografía que funciona de esta manera, lo que le permite transferir activos sin permiso entre Ethereum, NEAR, y pronto, Aurora, sin tener que confiar en terceros. ¡Muy genial!
Otros pedazos y piezas
Here's some interesting notes to go along with that overview:

 	

 	Aquí hay algunas notas interesantes que acompañan a esa descripción general:
 	Dado que NEAR-to-Ethereum Relayer solo envía NEAR encabezados de bloque al Ethereum LiteNode cada 16 horas, hay un retraso de 16 horas entre los pasos uno y dos cuando se mueven los tokens en esa dirección. (Recuerde, esto se debe a que las tarifas de gas de Ethereum hacen que sea prohibitivamente costoso para el Relayer actualizar el LiteNode en cada bloque). Hay una serie de enfoques que nos permitirían reducir este retraso, y el equipo está trabajando activamente en eso.
 	En NEAR, LiteNode almacena todos los encabezados de bloques de Ethereum anteriores. Para que el espacio de almacenamiento no se salga de control, LiteNode "poda" (elimina) los bloques que tengan más de dos semanas. Esto significa que si inicia una transferencia de Ethereum a NEAR y se va de vacaciones durante tres semanas entre los pasos uno y dos, no podrá completar su transferencia, porque los datos de Ethereum almacenados CERCA de la necesidad de verificar su "prueba" han sido eliminados!
 	Una propiedad interesante del diseño de encabezado de bloque NEAR es que con un solo encabezado de bloque, podemos calcular el historial de bloques pasados ​​durante un período bastante largo. Entonces, en teoría, LiteNode en Ethereum solo necesita un bloque NEAR; sin embargo, los conservamos porque los costos de gas necesarios para realizar la poda serían básicamente un desperdicio de recursos.
 	El equipo que creó el Puente Arcoíris es el mismo que creó Aurora, el NEAR EVM. Dado que ese equipo se ha convertido en su propia entidad, el Puente Arcoíris pasará a estar bajo su administración para operaciones, mantenimiento y evolución futura.
 	El equipo de Aurora está trabajando en la "finalización automática" del Rainbow Bridge, por lo que ya no tendrá que iniciar manualmente el paso dos de estas transferencias. Esto será muy conveniente para los usuarios (y significa que puede comenzar su transferencia de Ethereum a CERCA y luego irse de vacaciones).
 	Las transferencias entre Ethereum y Aurora las realiza el Puente Aurora, que utiliza la misma tecnología central que el Puente Arcoíris, pero aumentada para manejar el paso oculto NEAR / Aurora en las transferencias.
 	La interfaz de usuario y la experiencia de Aurora Bridge son diferentes a las de Rainbow Bridge y, en algún momento en el futuro, se armonizarán.



Aunque se han simplificado algunos detalles técnicos, ¡ahora tiene una comprensión fundamental de cómo funciona el Puente Arcoíris!

Para obtener una descripción detallada del Puente Arcoíris, puede leer este artículo y, para mantenerse al día con todo lo relacionado con Aurora, ¡asegúrese de seguir a Aurora en Twitter!

 

### NEAR Live Contract Review | Phần 3: Whitelist và Staking Pool Factory

Giới thiệu
Xin chào, hôm nay chúng ta sẽ review 2 contract thay vì chỉ 1. Bao gồm những contract liên quan tới cross-contract calls (gọi contract chéo), promise và cách chúng hoạt động trên NEAR. Nếu bạn muốn tìm hiểu thêm về cách kết hợp các kiến thức về NEAR-SDK thì đây là một sự khởi đầu tốt. Contract đầu tiên chúng ta cùng review có tên là whitelist contract, và nó được sử dụng trên mainnet để whitelist các staking pool. Việc này quan trọng vì nó giúp quá trình phân phối token được thực hiện thông qua các smart contract. Chúng ta sử dụng các lockup contract (contract khóa) sẽ được review ở serie này, contract khóa này là một smart contract độc lập, lưu trữ và khóa các token, đồng thời release chúng trong các khoảng thời gian nhất định. Ví dụ các token được phát hành trong hơn 2 năm và được phân bổ tuyến tính mỗi block. Những gì ta muốn làm là cung cấp khả năng stake token, bao gồm cả những token chưa được release. Điều này có nghĩa là bạn sẽ có thể delegate (ủy quyền) tất cả token mà bạn đã lock trong 2 năm (ví dụ thế) và bắt đầu kiếm được phần thưởng từ việc này. Tất cả được thực hiện thông qua smart contract, lockup contract sẽ gọi tới staking pool contract (đã review trước đây), và sau đó chuyển token từ contract này tới contract khác.

Các token từ lockup contract rút ra khỏi một account và chuyển tới account của staking pool. Nếu một staking pool không đảm bảo được những yêu cầu về việc bảo vệ tài sản, chẳng hạn như khả năng trả lại token, thì sẽ có những vấn đề nảy sinh. Giả sử ta xây dựng một staking pool không chỉ cho phép stake token mà còn cho phép rút luôn token đã stake tới bất kỳ account nào. Hành động này cho phép bạn rút tài sản về ví trước khi thời gian release token của staking pool kết thúc và đây là một hành vi nguy hiểm.

 

Đây là lý do whitelist contract ra đời, nơi các triển khai tùy chỉnh của staking pool được NEAR Foundation phê duyệt, có thể được sử dụng bởi các lockup contract. Đồng thời, ta cũng muốn có khả năng tạo mới các staking pool được chấp thuận bởi bất kỳ ai mà không cần thông qua NEAR Foundation. Điều này cho phép ai cũng tạo được một staking pool thông qua staking pool factory (đây là contract thứ 2 chúng ta sẽ review hôm nay). Cách hoạt động của nó là khi một lockup contract muốn được ủy quyền, trước khi có thể chuyển token sang contract này, người dùng cần chọn một staking pool trước. Khi chọn staking pool rồi, lockup contract sẽ đưa ra một transaction để kiểm tra account id có trong whitelist contract không, nếu có thì account id đó được whitelist, sau đó lockup contract có thể tiếp tục với quá trình ủy quyền. Nó cho phép lockup contract thực sự chuyển tài sản sang contract whitelist. Staking pool contract có tính bảo mật cao hơn và cung cấp những API mà local contract yêu cầu, cụ thể sẽ không xảy ra trường hợp token của lockup contract bị đánh cắp hay token của chủ sở hữu bị khóa. 

Việc này cũng rất quan trọng đối với lịch trình đầu tư của những nhân viên trong đội ngũ phát triển NEAR. Nó nằm trong lịch trình đầu tư 4 năm và điều đó cho phép NEAR Foundation phát hành transaction cụ thể cho người đó để unstake tất cả khỏi staking pool và trả lại số tiền đã đầu tư trở lại NEAR Foundation trong trường hợp nhân viên đó rời đi hoặc bị đuổi việc. Trên đây là những thông tin cơ bản về lockup và whitelist contract.

Mã nguồn của các contract này có thể tìm thấy trên Github của NEAR. Bài viết này dựa trên video gốc sau (khuyến khích bạn xem video này):


Whitelist Contract 
Main Structure
Bây giờ chúng ta cùng phân tích whitelist contract. Đây là contract khá đơn giản và không có quá nhiều logic, chúng ta đã biết phần lớn nội dung chính của nó từ những bài review trước của series:



Contract này sử dụng NEAR API LookupSet. Tương tự như một unordered set. Nó là một persistent collection, nhưng không có iterator (đối tượng lặp), nên bạn không thể lặp (iterate) qua các key của những element trong set. Bạn chỉ có thể check nếu một phần tử đã cho có hay không, và bạn có thể thêm phần tử đó vào trong set. Bạn không thể xem những phần tử nào hiện diện trong tập hợp này. Bằng cách này sẽ cải thiện hiệu quả của việc lưu trữ và truy cập từ nhiều lần đọc đến một vài lần đọc. contract chứa một vài trường. 

Contract có một số trường dữ liệu. Đầu tiên là foundation_account_id - Đây là account ID kiểm soát hành động whitelist các staking pool mới. Tài khoản này có thể đưa 1 staking pool hoặc các staking pool factory vào whitelist.

Factory là một contract có thể tạo ra một instance mới của struct staking pool. Cách nó hoạt động là khi bạn phát hành một giao dịch với staking factory đã được contract này đưa vào whitelist từ trước, nó sẽ tạo một account mới làm tài khoản phụ của factory. Trong trường hợp của chúng ta trên mainnet, tài khoản này được gọi là poolv1.near, là một staking pool factory mà NEAR Foundation sử dụng. Nó tạo ra một contract, ví dụ bisontrails.poolv1.near, trên đó triển khai code whitelist staking pool trong whitelist mà factory có thể tạo ra, (chúng ta sẽ đi vào phần staking pool factory sau) nhưng đồng thời nó cũng có thể liệt kê whitelist cho staking pool này. Đây là cách nó hoạt động. Hàm khởi tạo (constructor) chỉ nhận một tham số là foundation_account_id. Tài khoản của foundation có quyền cao hơn đối với contract:


Getters
Có rất nhiều getter ở đây 



Bạn có thể check nếu một staking pool account được whitelist. Đây là cách mà lockup contract kiểm tra nếu một pool được whitelist. Cơ bản là chỉ check nếu một phần tử tồn tại trong set. Cách thứ hai có thể check là nếu factory được whitelist, trong case này việc này không cần thiết và không ai gọi tới contract này.
Add Staking Pool Method


Đây là một method có được thể call bởi cả factory lẫn NEAR Foundation. Những gì ta làm ở đây là kiểm tra staking method này có thêm staking_pool_account_id  vào whitelist hay không. Nó kiểm tra xem id tài khoản có hợp lệ không, sau đó nếu pass,ta sẽ kiểm tra xem đây có phải là factory hay không. Ta check trong set nếu caller của method này có trong whitelist của các factory. Nếu nó được call staking pool factory thì oke. Nếu không thì nó phải là account id của foundation, nếu không contract sẽ fail và method trả về lỗi panic.

Nếu ta vượt qua bài check về permission thì ta chỉ cần thêm staking pool này vào whitelist. Hiện tại,ta chỉ có một triển khai cho staking pool (Implementation for staking pool) , nhưng về lý thuyết, ta có thể sửa đổi việc triển khai này khi ta giới thiệu method khác, ví dụ như slashing, và staking pool phải có sự cho phép cần thiết. Nó cần phải duy trì một số token tối thiểu. Có một số thay đổi khác mà ta cần sửa đổi các verified contract trong thời gian đầu tư của mọi người là 4 năm. Rất nhiều thứ có thể xảy ra xung quanh mạng và chúng ta cần có khả năng thay đổi các staking pool. Ví dụ, nếu logic staking pool thay đổi. Nó cho phép tạo ra một factory mới là một phiên bản tốt hơn hoặc hỗ trợ một cái gì đó mà trước đây không được hỗ trợ. Nó không cho phép thay đổi phí thưởng ngay lập tức, mà chỉ cho phép nó thay đổi sau khoảng thời gian chờ 7 ngày, hoặc một số ý tưởng sửa đổi khác.



Tiếp theo remove_staking_pool chỉ có thể được call bởi foundation account nên một staking pool chỉ có thể bị hủy bởi foundation account. 

Ngoài ra, add_factory cũng chỉ có thể được call bởi foundation account. Cơ bản là nó chỉ thêm vào whitelist của các factory account.



Cuối cùng, method remove_factory cũng chỉ có thể được gọi bởi foundation account và được dùng để xóa factory_account_id. Giả sử factory đầu tiên bị hết hạn, về cơ bản, foundation account có thể xóa factory đó khỏi whitelist cũng như xóa tất cả các pool trước đó khỏi whitelist. Bây giờ, bạn sẽ không thể chọn staking pool trước từ lockup contract, và cuối cùng check lại là lệnh được call từ foundation.

Đây là contract rất đơn giản và nó chỉ hoạt động trên internal set và method true duy nhất có thể nhìn thấy bên ngoài là is_whitelisted. Nó khá đơn giản, chỉ bao gồm một số các setter và getter.
Tính bất biến (immutability) của Smart Contracts
Cách các smart contract thường hoạt động trên Ethereum và trên các blockchain nền tảng khác là chúng không tự thay đổi (immutable). Trên Ethereum, mọi contract là bất biến, các developer sử dụng proxy contract (contract ủy quyền) cho phép nâng cấp endpoint cho một số contract nhất định, việc nâng cấp endpoint này là rất quan trọng với các token. Các contract cốt lõi (core contracts) là hoàn toàn bất biến, ta sẽ triển khai một lần và có khả năng sau này không thể thay đổi được, bởi vì nếu muốn thay đổi, bạn sẽ phải thực hiện hard fork và phải thuyết phục tất cả các validator thực hiện code migration.

Điều này quan trọng vì việc kiểm soát được thực hiện ở tự động bởi smart contract thay vì bởi một số thực thể tập trung. Ví dụ: trong khi nền tảng vẫn duy trì quyền kiểm soát lớn đối với các staking pool bằng cách có khả năng xóa staking pool, nó không có quyền kiểm soát đưa vào blacklist một thực thể cụ thể trong thế giới thực khỏi việc triển khai staking pool.

Họ vẫn có thể tạo một nhóm staking pool mới với mức độ ẩn danh nhiều nhất có thể và tạo một staking pool mà không cần cấp phép để trở thành validator trên mainnet.

Một số thứ đến từ sự phân quyền, thứ khác đến từ sự hạn chế trong việc kiểm soát.

Mặc dù Foundation được cho là để hỗ trợ mạng lưới nhưng trong một số trường hợp, Foundation có thể bị buộc phải làm điều gì đó không tốt cho mạng. Giả sử chính phủ vào cuộc và cố gắng ép buộc. Nếu ta có ít khả năng thực hiện việc này hơn thì sẽ có khả năng bảo mật cao hơn trên mạng. Khi thiết kế contract, chúng tôi nghĩ "Giá trị trong contract này là bao nhiêu?" hoặc “Khả năng ảnh hưởng của nó đối với mạng nói chung là gì?”. Nếu đó là giá trị nhỏ thì bạn có thể giữ uy tín miễn là được cộng đồng tin tưởng, nếu đó là giá trị lớn thì không ổn tí nào.

Khi chúng ta thực sự đi sâu vào lockup contract, và cách nó được thiết kế, ví dụ: vesting, được thiết kế nhằm cho phép foundation rút số tiền vốn còn lại, nhưng đồng thời ngăn chặn foundation rút các khoản tiền đã được vested. Đây là một cách hoạt động hợp pháp ngoại trừ việc nó được mã hóa vào hợp đồng thông minh. Whitelist là một hợp đồng rất quan trọng, bởi vì trước khi các quỹ bị khóa, phần lớn các quỹ đều kiểm soát mạng lưới thông qua các local contract trong các staking pool thông qua whitelist cụ thể này, vì vậy điều quan trọng là phải thiết kế nó theo cách giữ được sự phân quyền và bảo mật mạng lưới mà không cần trao quyền kiểm soát cho foundation.

Giả sử có điều gì đó đã xảy ra và foundation bắt đầu có những hoạt động xấu nhưng bạn đã có thể tạo một nhóm staking pool mới thông qua factory và ủy quyền cho staking pool đó, lúc này foundation không thể ngăn bạn ủy quyền cho staking pool đó.
Staking Pool Factory Contract
Include Bytes Macro


Contract staking_pool_factory là một hợp đồng mà bên trong nó lại chứa mã nguồn của staking pool contract. Trong Rust, bạn có thể làm việc này thông qua macro include_bytes. Cơ bản là nó lấy một file cục bộ và nhúng file vào trong tệp nhị phân dưới dạng vector. Dẫn đến trong binary của WebAssembly này, ta có thể có một phần trong allocated memory, đại diện cho staking pool cụ thể này (staking_pool.wasm)
Structure 
Đây là cấu trúc:



Một số thông tin về gas, ta sẽ quay lại vấn đề này sau: 



Có  reward_fee_fraction vừa được chép từ contract của staking pool mà ta đã review từ trước.


External Contracts
Có những tham số của staking pool mà contract cần, đây là những trait và những external contract, nên đây là high level interface ta sử dụng để gọi những external contracts.
/// External interface for the callbacks to self.



Ta có hai trait, trait đầu tiên gọi là ExtSelf, bởi vì nó đại diện cho contract của chúng ta và chứa callback tới method on_staking_pool_create. 

Trait thứ 2 cho whitelist contract, nó có method add_staking_pool và được whitelist contract gọi tới:



Trait trong Rust giống khái niệm interface trong Java. Bên trên ta đã định nghĩa một interface của một remote contract. 
Initialization


Cùng xem qua kịch bản: Khi một factory được tạo, ta xác minh rằng nó chưa được khởi chạy (init) và ta xác minh staking_pool_whitelist_account_id, account id của whitelist contract, trong quá trình khởi tạo StakingPoolFactory. Ta cần biết staking_pool_whitelist_account_id. Đây là nơi whitelist contract được deploy để đưa vào whitelist staking pool vừa mới tạo. Sau đó tạo một set của những account đã tạo ở cuối snippet này. 
Main Method


Giờ thì staking pool factory đã được tạo, ví dụ là poolv1.near chẳng hạn, và foundation đã whitelist factory trên whitelist contract bằng cách tạo một transaction khác. Bây giờ staking pool factory được whitelist, nghĩa là nó có quyền whitelist các staking pool mà nó tạo ra. Vậy nên giờ tới phần Validator, họ muốn tạo staking pool cho riêng họ. Cách làm là họ gọi create_staking_pool, nó cần một loạt các tham số. Đầu tiên là prefix. Giả sử đó là bisontrails, không có sufix của account id hiện tại, và nó đến từ account trên NEAR. 

Một account chỉ có thể tạo các sub account, nên staking pool factory tạo sub account dưới quyền của chính nó - sẽ là bisontrails.poolv1.near chẳng hạn owner_id là account id của chủ sở hữu của staking pool đã thảo luận trước đây. Cả ba mục này về cơ bản là các tham số mà bạn sẽ chuyển đến một staking pool khi lần đầu khởi tạo. Đó là một argument mà bạn có thể đặt ủy quyền với staking pool. Ví dụ, staking_pool_id có thể là bisontrails.near. stake_public_key có thể stake key từ những validator node đang chạy, và reward_fee_fraction có thể là 10%. Lưu ý rằng method này là payable , nghĩa là nó cần một khoản phí gửi đính kèm (attached deposit), vì việc đầu tiên nó sẽ check là “Bạn đã gửi đủ tiền chưa?” Khoản deposit bạn cần gắn vào là 30 NEAR, và cái này có rất nhiều số 0, vì nó ở dạng đơn vị là yoctorNEAR. Bạn cần gắn 30NEAR là chính vì cần phải cover state cho contract trên mỗi lần tạo staking pool mới. Hợp đồng này khá lớn, tốn 250 kb và cần ít nhất là 25 NEAR, nhưng cũng phải mất thêm một tí phí nữa để đảm bảo tránh trượt giá. Đây là một trong những case bạn phải có một khoản phí gửi kèm theo, vì bạn không thể gắn lượng gas nhiều như này vào trong transaction này. Ngoài ra, ta cũng không thể chuyển gas sang NEAR trong contract, vì vậy lý tưởng nhất là giữ nguyên gas cho việc tính toán như là read/write, cross contract calls. Số balance được sử dụng để lưu trữ và dùng để transfer. Trong trường hợp này, nó sẽ tạo một account mới, tạo account trên NEAR yêu cầu bạn phải trả phí lưu trữ account. Bộ nhớ trong trường hợp này sẽ không chỉ là account đó mà còn là contract của account.Và trong trường hợp này, đây là code của staking pool contract.



Tiếp theo là xác minh prefix không chứa dấu chấm (.), nghĩa là bản thân account đó ko phải là một account phụ. Sau đó ta tạo mới staking_pool_account_id bằng cách nối id tài khoản với dấu (.) , qua đó xác minh rằng account id của staking pool là hợp lệ. Cơ bản là nếu tất cả các assert check này bị fail, NEAR sẽ refund lại số token. Nếu một transaction có attached deposit bị fail, số tiền đó sẽ trở lại cho sender hoặc predecessor, bởi vì chỉ predecessor có thể attach balance. Việc thực hiện một loạt các asserts check ở đây giúp an toàn hơn. Tiếp theo, ta xác minh rằng owner_id của staking pool là hợp lệ. Về cơ bản, đây là một loạt các helper cũng được xác minh trên staking pool, giúp đảm bảo rằng nếu bạn không truyền đủ tham số, hoặc truyền hơi sai một tí thì bạn sẽ nhận được báo lỗi trước khi transaction được thực hiện để tránh bị đốt gas và tránh bị lock token.

Cuối cùng, ta kiểm tra sử dụng insert để đảm bảo rằng staking pool không tồn tại. Cơ bản insert sẽ trả về true nếu đó là một element mới  duy nhất và trả về false nếu nó đã tồn tại trong set. Đây là cách Rust hashset hoạt động giống như cách hoạt động của ordered set. Vì vậy, nếu tên pool đã tồn tại, ta sẽ không thêm staking pool hoặc cố gắng tạo lại account này. Insert thực hiện hai việc, nó element vào trong storage, cũng như trả về true nếu phần tử là duy nhất và không tồn tại trước đó hoặc trả về false nếu phần tử đã tồn tại. Nếu set không có giá trị này thì true được trả về, nếu set có element này thì trả về false.



Cuối cùng, ta dùng medium level API, không sử dụng raw cost method cũng không dùng high level interface. Cách hoạt động là ta tạo một promise mới, promise sẽ tạo một temp struct ở trong NEAR SDK, và nó nhớ được receiver của promise này. Có thể nghĩ rằng như kiểu contract sẽ đưa ra giao dịch đối với account id đó. Ta sẽ gọi là staking pool account id không tồn tại. Tất nhiên đó không phải là một transaction, mà là một receipt thì hơn. Tiếp theo là hành động đầu tiên cho promise này. Ta bắt đầu thực hiện chuỗi các hành động theo promise này. Đầu tiên là create_account - tạo một account mới hoặc fail nếu account đã tồn tại. Sau đó, deposit balance vào, gửi toàn bộ số đã chuyển mình vì ta không giữ nó trong factory, số tiền đó sẽ đi kèm với một receipt trên remote account. Như đã giải thích trước đó, include_bytes là một macro tạo một static slide đổi thành một vector sẽ được chuyển cho một hành động deploy. Nó sẽ giúp deploy code trên remote account. Bạn chỉ có thể deploy code trên những account bạn kiểm soát, create_account cho bạn quyền như thể bạn là owner của account chỉ transaction cụ thể này. Bạn có thể sử dụng method deploy_contract, có thể stake và làm một số việc khác thay mặt cho contract này trong transaction đầu tiên. Cuối cùng, ta khởi tạo contract staking pool sử dụng serda API. Ta sử dụng struct này và serialize nó sang dạng JSON, method tên là new. Tham số đầu tiên là attached deposit tới function call. Ta không cần nó. Tiếp theo là lượng gas bạn có thể lấy từ số gas hiện tại của mình và ngay lập tức lấy ra sau khi gas đó đi  tới promise. Ví dụ method call hết 100 tera gas (tera gas là đơn vị gần như con người có thể hiểu được) 



Bạn có 100 tera gas ban đầu, và ta truyền 25 terra gas ( ở const BASE ), con số này x2. Ngay lập tức truyền 50 terra gas tới function call của method này, truyền 50 terra gas nghĩa là mình chỉ còn ít hơn 50 terra gas, bởi vì ta đã đốt mất một ít từ những lần xử lý logic trước đó. Cộng thêm mỗi hành động đưa vào promise sẽ lại tốn thêm ít gas. Ví dụ, action deploy tốn phí để chuyển các bytes từ account này sang cái khác. Sau đó, tương tự như cách js hoạt động, nó gắn dependency vào promise trước. Đây là promise đầu tiên, và ta nói sau đó khi nó hoàn thành, hãy thực hiện tiếp promise thứ hai. Cách nó hoạt động như kiểu: bisontrails.near đã call contract này (poolv1.near) để tạo bisontrails.poolv1.near. 

Đầu tiên ta tạo một promise tới bisontrails.poolv1.near và sau đó ta đính kèm một callback cho api này, điều này không tốt về mặt sử dụng các argument cho hai thứ khác nhau. Dù sao thì nó cũng call lại account id hiện tại. Vì vậy, sẽ gọi poolv1.near sau khi promise đầu tiên được thực thi. Cấu trúc: bisontrails.near gọi poolv1.near tạo một staking pool promise.Bây giờ tạo một promise cho bisontrails.poolv1.near và nó cũng tạo một promise cho chính nó trên method on_staking_pool.



Nó cần kết quả của method trước khi method bắt đầu, và nó chuyển ba đối số ở đây, bao gồm staking_pool_account_id, attached_deposit và predecessor_account_id. Vì vậy, nó là caller id, account nào được tạo và có bao nhiêu token attached trong trường hợp ta cần hoàn lại tiền. Bây giờ nếu bisontrails.poolv1.near thực thi thành công thì on_staking_pool_create sẽ nhận được kết quả thực thi. Giả sử có một số cấu hình sai khiến phương thức này cũng sẽ được gọi, nhưng sẽ nhận được một callback lại cho biết lệnh thất bại.Ta đã trả lại main promise ngay sau đó, có nghĩa là ta đã trả lại on_staing_pool_create trước. Quan trọng là vì kết quả của phương thức create_staking_pool phụ thuộc vào kết quả của promise on_staking_pool_create. Transaction không hoàn toàn bắt đầu song song, thay vào đó giờ đây nó phụ thuộc vào việc thực hiện method cụ thể này.
Callback
Xem phần callback nào:



Việc đầu tiên chúng ta làm là đảm bảo rằng promise này chỉ có thể được gọi bởi contract hiện tại bằng cách sử dụng assert_self.



Tiếp theo là sử dụng một utility helper method cho biết nếu dependency, việc tạo staking pool là thành công hay thất bại.



Ta làm điều này theo cách sau: Sử dụng 2 method, đầu tiên là check xem kết quả trả về là 1 - điều này là bất biến vì ta biết rằng không ai được phép gọi hai lần, method 2 là nếu kết quả trả về thành công. Method thực thi thành công thì trả về true, nếu không thì là false. Vì vậy biết được là staking pool đã được tạo ra hay chưa. Một lần nữa, ta cũng đã để 50 terra gas vào callback nên bây giờ ta lại đang ở trong callback này nên chỉ còn khoảng 50 terra gas.



Nếu thành công thì ta sẽ log lại rằng pool đã được tạo, sau đó cho nó vào whitelist. Sau đó ta gọi một promise khác từ callback, và gắn vào 25 terra gas. Giờ ta gọi tới staking_pool_whitelist_account_id(whitelist contract). Giờ ta có thể đưa vào whitelist staking pool vừa mới tạo, bởi vì ta đã truyền tham số này vào trong callback. Sau đó ta trả về một promise để tiếp tục quá trình, vì ta chỉ muốn hoàn thành toàn bộ giao dịch sau khi whitelist đã hoàn tất. Rust không có keyword return bởi vì nếu value cuối không có dấu chấm phẩy (;) thì nó sẽ hiểu đây là giá trị trả về. Nếu tạo không thành công, thì chỉ có một lý do, khoản tiền gửi chuyển vào staking pool để tạo sẽ được hoàn lại cho ta thay vì cho predecessor (người tiền nhiệm). Ta có 30 NEAR trên contact này và ta cần trả lại chúng cho sender, tránh bị lock. Đầu tiên ta làm là xóa nó khỏi list các staking pool đã được tạo, vì tạo bị thất bại. Ta nói rằng quá trình tạo đã fail và ta sẽ refund lại số tiền đã được đính kèm ( attached deposit). Bây giờ nó không phải là một khoản được đính kèm thực sự, bởi vì callback không nhận được số tiền đó.

Contract chuyển qua một refund receipt riêng, thường đến trước callback, nó lấy predecessor_account_id. Trong trường hợp này, nếu ta gọi predecessor_account_id, nó có nghĩa là hàm callback. Ta cần biết ai sẽ được trả lại lượng token đó, cách ta làm điều đó là tạo một promise sử dụng predecessor_account_id mới, và trả lại lượng token đã được gắn vào. Như có thể thấy, ta không return một promise, ta không quan tâm nếu nó thành công hay bị fail, việc trả về giá trị là false nghĩa là pool không được tạo. Thứ xảy ra bây giờ là transaction tiếp tục được thực hiện nhưng giá trị sẽ được trả lại cho frontend - NEAR CLI, nên bạn sẽ biết ngay lập tức là transaction đã bị failed. Bạn sẽ chưa lấy lại được tiền ngay, bạn sẽ cần đợi khoản tiền hoàn lại cụ thể này được thực thi trong block tiếp theo nhưng bạn biết rằng pool chưa được tạo nên bạn vẫn có thể tiếp tục. Đây là một ví dụ về cách bạn có thể thực hiện parallel promise (promise chạy song song).

Đây là cách hoạt động của staking pool factory. Đây là một getter kiểm tra xem có bao nhiêu staking pool đã được tạo ra có thể được gọi trên NEAR CLI: 


Tổng kết
Tới đây là kết thúc buổi NEAR Live Conrtact Review | Phần 3: Whitelist và Staking Pool Factory.

Cảm ơn bạn đã dành thời gian để học về NEAR, sắp tới sẽ có nhiều nội dung khác trong series này!

### NEAR Live Contract Review | Phần 2: Staking Pool Contract

Giới thiệu
Chào mọi người, tôi là Eugene và hôm nay chúng ta sẽ tiếp tục series review hợp đồng thông minh với staking pool contract. Đây là contract được NEAR Protocol sử dụng ngay thời điểm hiện tại để vận hành hệ thống Proof of stake. Tất cả các validators đang chạy trên NEAR Protocol đều đang hoạt động dựa theo contract này. Các validator không kiểm soát những tài khoản đang stake NEAR token để thực hiện cơ chế proof of stake, chúng chỉ cung cấp các pool để stake và chạy các node, nhiệm vụ stake NEAR token được thực thi bởi hợp đồng thông minh mà chúng ta sẽ review ngày hôm nay. Contract staking này nằm trong danh sách các core contract của NEAR Protocol và nó cũng phức tạp hơn so với voting contract mà chúng ta đã xem xét ở phần 1 của series này. Hôm nay chúng ta cũng sẽ không đi sâu vào phần near_bindgen hay ngôn ngữ Rust như phần trước mà sẽ tập trung hơn vào việc phân tích logic và kiến thức liên quan tới NEAR Protocol. Các bạn có thể xem mã nguồn của staking pool contract tại github của NEAR Protocol. 

Bạn cũng có thể xem video gốc review contract này trên youtube: 


lib.rs
Struct chính của contract (Constructor Structure)


Giống như ở phần review trước, chúng ta cũng sẽ xem xét struct chính của contract staking này - StakingContract. Bạn có thể thấy các macro quen thuộc của NEAR SDK như near_bindgen, BorshSerialize và BorshDeserialize. Struct này cũng có nhiều trường dữ liệu hơn so với VotingContract mà chúng ta review ở bài trước, bên cạnh đó là một số phần comment để giải thích ý nghĩa của mỗi trường dữ liệu. Logic của hợp đồng này cho phép bất cứ ai cũng có thể nạp và stake một số lượng NEAR token vào staking pool. Từ đó chúng ta có thể gom số dư từ nhiều người (chúng ta sẽ sử dụng thuật ngữ account thay cho người stake NEAR token) thành một lượng lớn cổ phần (stake) và nếu số lượng token gom lại đủ lớn chúng có thể thỏa mãn điều kiện để trở thành một validator trên mạng lưới của NEAR Protocol. Hiện tại, NEAR Protocol đang cung cấp một số lượng hữu hạn suất để trở thành một validator trên một shard, cụ thể là có tối đa 100 suất. Bạn có thể hiểu điều kiện có một suất để trở thành validator như sau: nếu bạn lấy tổng tất cả lượng token NEAR đã được stake và chia cho 100 thì kết quả nhận được sẽ là lượng token tối thiểu để thỏa mãn một suất trên một shard. Hợp đồng này là một hợp đồng độc lập không có bất kỳ khóa truy cập nào do chủ sở hữu của pool kiểm soát. Trong trường hợp này, id của chủ sở hữu của pool được cung cấp trong phương thức khởi tạo.
Phương thức khởi tạo (Initialization method)


Phương thức khởi tạo nhận vào 3 tham số. Tham số đầu tiên là owner_id, đại diện cho account id của chủ sở hữu account. Chủ sở hữu sẽ có một số quyền hạn đối với hợp đồng này mà tất cả các tài khoản khác không có. Một trong số đó là quyền được bỏ phiếu cho các quyết định của staking pool hay cụ thể là quyền gọi tới phương thức vote của hợp đồng VotingContract mà chúng ta đã review ở bài viết trước. 





Trong phương thức vote() trên, đầu tiên chúng ta phải gọi tới phương thức assert_owner(). Ở phương thức này chúng ta xác nhận account ID của contract được gọi trước đó trong chuỗi các lần call contract có phải chính là account ID của chủ sở hữu đang chạy validator node hay không, vì chỉ có chủ sở hữu staking pool mới có thể gọi tới phương thức vote(). Mã nguồn của phương thức assert_owner() như sau:



Sau khi xác thực chủ sở hữu của staking pool, phương thức vote() sẽ thực hiện một số logic khác (chúng ta sẽ bàn kỹ hơn về logic này ở phần sau).

Quay trở lại với mã nguồn của phương thức khởi tạo:



Bên cạnh tham số owner_id thì phương thức khởi tạo còn có một tham số khác là stake_public_key. Khi bạn thực hiện hành động stake trên NEAR Protocol, bạn cần cung cấp public key (khóa công khai) mà validator node sẽ dùng để ký trên các thông điệp (message). Public key này nên khác với các access key khác vì validator node của bạn có thể sẽ chạy ở một trung tâm dữ liệu dễ bị tấn công và nếu trường hợp này xảy ra đi chăng nữa thì tài khoản của bạn vẫn sẽ an toàn, chỉ có mạng lưới các node là chịu tấn công mà thôi. Kẻ tấn công sẽ không thể lấy cắp tài sản của bạn và bạn cũng sẽ dễ dàng thay đổi public key so với việc sử dụng một access key không tốt. Và tham số cuối cùng của phương thức khởi tạo là reward_fee_fraction. Đây chính là khoản hoa hồng từ phần thưởng staking của những người stake NEAR token vào pool mà chủ sở hữu của staking pool sẽ nhận được khi họ vận hành validator.

Sau đây chúng ta sẽ phân tích kỹ hơn struct RewardFeeFraction.



Cấu trúc dữ liệu này bao gồm hai thành phần là tử số và mẫu số đại diện cho khoản hoa hồng mà chủ sở hữu staking pool sẽ nhận được, cấu trúc này giúp chúng ta thực hiện được một việc dạng như “tôi sẽ nhận 1% tiền thưởng của bạn vì tôi đã vận hành staking pool này”. Ví dụ, bạn stake 1 000 000 token NEAR và nhận được phần thưởng staking là 10 000 token, khi đó chủ sở hữu của staking pool sẽ nhận được 1% của 10 000 token này là 100 token NEAR. 

Một lưu ý ở đây là khi bạn thực hiện các phép nhân thì kiểu dữ liệu float có thể sẽ cho ra một số kết quả không lường trước được. Ví dụ, với trường hợp của phân số, bạn có thể sử dụng nhiều bit hơn để tính toán. Khi thực hiện phép chia với phân số, đầu tiên bạn nhân một số có kiểu dữ liệu u128 với tử số (phép nhân này có thể dẫn đến hiện tượng overflow kiểu dữ liệu u128 vì thế nên chúng ta sẽ thực hiện phép nhân trong phạm vi của kiểu dữ liệu u256). Sau đó chia kết quả vừa nhận được cho mẫu số và nhận được một kết quả mới thuộc phạm vi kiểu dữ liệu u128. Điều này có thể dẫn tới sai sót trong quá trình làm tròn số khi bạn tính toán. Vì vậy bạn không cần sử dụng kiểu dữ liệu float với nhiều chữ số thập phân hơn, vì chúng cho ra kết quả không khác mấy so với việc sử dụng kiểu dữ liệu u256. Ngôn ngữ Solidity ban đầu cũng không hỗ trợ kiểu dữ liệu float và NEAR SDK ban đầu cũng vậy, nhưng việc này lại gây ra một số vấn đề trong việc debug với kiểu dữ liệu String trong  Rust. Vì vậy, chúng tôi vẫn quyết định sẽ hỗ trợ kiểu dữ liệu float trong SDK và đặc biệt là việc chúng tôi đã chuẩn hóa nó ở phía máy ảo. Vấn đề lớn nhất với kiểu dữ liệu float là các hành vi không xác định trước xung quanh một số giá trị nhất định. Ví dụ, khi bạn có một số thực(float) có vô hạn chữ số sau dấu phẩy thì các bit của kiểu dữ liệu float sẽ lưu các giá trị gì? Tuy nhiên, chúng tôi đã chuẩn hóa vấn đề này nên bạn có thể sử dụng kiểu dữ liệu float, nên vẫn oke khi sử dụng kiểu float ở phía máy ảo(vm).



Có một thói quen tốt khi code phương thức khởi tạo là chúng ta cần kiểm tra xem state có tồn tại không. Sau đó, chúng ta kiểm tra các trường dữ liệu đầu vào. Cụ thể với phương thức assert_valid() của cấu trúc dữ liệu RewardFeeFraction, chúng ta kiểm tra xem trường dữ liệu mẫu số có khác 0 hay không, tiếp theo chúng ta thấy câu lệnh điều kiện else để kiểm tra xem trường dữ liệu tử số có giá trị nhỏ hơn hoặc bằng giá trị của mẫu số hay không (tức kiểm tra xem giá trị của phân số có nhỏ hơn hoặc bằng 1 hay không). Điều này rất quan trọng để tránh các lỗi logic sau này. Tiếp theo, chúng ta kiểm tra xem account có hợp lệ không. Contract này được viết trước khi chúng tôi có một số tiêu chuẩn hỗ trợ đánh giá như hiện tại. Ví dụ, chúng tôi có một account ID thuộc kiểu dữ liệu JSON giúp tự động kiểm tra trong quá trình deserialization, nếu như account ID không hợp lệ, nó sẽ panic. Sau đó, chúng ta sẽ lấy được số dư trong tài khoản hiện tại của hợp đồng staking. Số dư này thường đủ lớn để trả khoản phí lưu trữ hợp đồng trên blockchain. Tiếp theo, chúng ta phân bổ một số lượng token cho STAKE_SHARE_PRICE_GUARANTEE_FUND. Staking pool đảm bảo một số việc cho các local contract. Cụ thể là khi bạn stake vào staking pool thì bạn vẫn có thể rút về ví với số lượng token ít nhất bằng với số token mà bạn đã stake, và các thao tác rút tiền hoặc nạp tiền của hợp đồng này cũng chỉ tốn phí không quá 1000 000 000 000 yocto NEAR. 

Quỹ STAKE_SHARE_PRICE_GUARANTEE_FUND có khoảng 1 nghìn tỷ yocto NEAR và chúng ta thường tiêu tốn khoảng 1 đến 2 nghìn tỷ yocto NEAR cho các lỗi làm tròn số. Chúng ta cũng cần ghi lại số dư đã stake cho contract này. Đây là điều cần thiết để hạn chế sự khác biệt khi thực hiện làm tròn số. Tiếp theo, chúng ta xác minh tài khoản đã stake hay chưa vì nếu chưa stake thì các logic phía sau có thể không hoạt động, do đó cần phải khởi tạo contract này trước khi stake. Cuối cùng, chúng ta khởi tạo struct, nhưng không trả về giá trị của struct này ngay lập tức, chúng ta chỉ dừng lại ở việc tạo ra một cấu trúc StakingContract.



Sau khi khởi tạo struct, chúng ta sẽ phát hành một restaking transaction. Điều này rất quan trọng vì chúng ta cần chắc chắn rằng staking key đã được cung cấp bởi người dùng là một khóa ràng buộc nhằm tạo ra một staking transaction. Một khi transaction này được tạo ra từ contract, chúng ta sẽ tiến hành xác thực staking key, nếu nó không hợp lệ thì sẽ xuất hiện lỗi và tất cả quá trình khởi tạo staking pool sẽ thất bại. Nếu như bạn truyền vào một giá trị không hợp lệ cho tham số stake_public_key của phương thức khởi tạo thì việc hợp nhất và triển khai contract cùng với mọi thứ xảy ra trong một lô các giao dịch sẽ được hoàn nguyên. Điều này cũng rất quan trọng vì nếu cho phép sử dụng khóa không hợp lệ thì một ai đó có thể chặn việc stake của bạn. Khi unstake, bạn sẽ nhận lại được token của mình trong vòng 4 epochs.



Tôi nghĩ là đến thời điểm này, tôi đã giải thích khá nhiều chi tiết trước khi bắt đầu nói một cách tổng quan về cách hoạt động của staking contract và các số dư.

Hãy cùng tìm hiểu các khái niệm về cách mà chúng ta có thể phân phối phần thưởng cho các tài khoản đã stake trong thời gian cố định (constant time) khi mỗi epoch trôi qua. Đây là một vấn đề quan trọng đối với hầu hết các smart contract. Các hợp đồng muốn thực hiện các phương thức trong thời gian cố định thay vì trong thời gian tuyến tính theo lượng người dùng. Lý do là nếu thực hiện trong lượng thời gian tuyến tính thì khi lượng người dùng tăng, lượng gas cần thiết để vận hành hệ thống cũng sẽ tăng lên tuyến tính và rất có thể chúng ta sẽ hết gas.
Account Structure


Mỗi người dùng ủy quyền (delegated) token vào staking pool được biểu diễn bởi một cấu trúc dữ liệu gồm các trường dữ liệu sau: ‘unstaked’ là số dư trong ví người dùng mà họ đã không (chưa) stake vào pool (tính theo yocto NEAR). Trường dữ liệu tiếp theo là ‘stake_shares’, đại diện cho số dư nhưng không phải tính bằng NEAR mà bằng số lượng stake shares (cổ phiếu cổ phần). Có thể hiểu là khi bạn stake, về cơ bản là bạn mua cổ phiếu mới ở mức giá hiện tại bằng cách chuyển đổi số dư chưa được stake trong tài khoản thành stake shares. Giá của một stake share ban đầu là 1, nhưng theo thời gian nó sẽ tăng lên cùng với phần thưởng và khi tài khoản nhận được phần thưởng, tổng số dư cổ phần của nó sẽ tăng lên, nhưng tổng số lượng cổ phần không thay đổi. Về cơ bản, khi một tài khoản nhận được phần thưởng hoặc một số khoản tiền khác gửi thẳng vào số dư, điều đó sẽ làm tăng số tiền mà bạn có thể nhận được cho mỗi cổ phần được stake. Ví dụ, ban đầu bạn có 1 triệu token NEAR trong tài khoản, giả sử bạn nhận được 1 triệu cổ phiếu (chúng ta tạm không sử dụng đơn vị yocto NEAR ở đây), nếu staking pool nhận về phần thưởng là 10 000 NEAR thì bạn vẫn có 1 triệu cổ phiếu, nhưng lượng cổ phiếu này bây giờ tương đương với 1 010 000 NEAR. Bây giờ nếu một người nào khác muốn stake, họ sẽ mua cổ phiếu nội bộ của hợp đồng với giá của mỗi cổ phiếu là 1.01 NEAR. Khi bạn nhận được một số giải thưởng khác, bạn sẽ không cần phải mua thêm cổ phần mặc dù trong thời gian không đổi thì mọi người chia sẻ phần thưởng tỉ lệ với số lượng cổ phần họ có. Bây giờ, nếu bạn unstake thì về cơ bản bạn đang bán đi cổ phần của mình hoặc đốt chúng bằng cách sử dụng khái niệm token có thể thay thế (fungible token). Bạn bán đi cổ phần với giá hiện tại của nó thì số lượng cổ phần cũng như cổ phiếu của bạn cũng sẽ giảm đi, hoặc bạn mua thêm thì tổng số dư cổ phần và tổng số cổ phần sẽ tăng trong khi giá không đổi. Khi bạn stake hoặc unstake, bạn không làm thay đổi giá, chỉ khi bạn nhận về phần thưởng thì giá mới tăng.



Giá chỉ có thể tăng lên và điều này có thể dẫn đến lỗi làm tròn khi lượng yocto NEAR và số dư của bạn không bằng nhau. Đó cũng là lý do chúng ta cần có quỹ bảo lãnh 1 nghìn tỷ yocto NEAR. Một điều cần chú ý là khi bạn thực hiện hành động unstake, bạn sẽ không thể rút tiền ngay lập tức từ staking pool về ví của mình mà phải đợi thêm 3 epochs (3 x 12 giờ). Một trường dữ liệu nữa là ‘unstake_available_epoch_height’ sẽ lưu epoch height khi bạn gọi phương thức unstake. Tuy nhiên có một lưu ý: nếu bạn gọi tới phương thức unstake ở block cuối cùng của một epoch, thì việc unstake sẽ được thực hiện ở epoch tiếp theo, tức là bạn sẽ phải đợi 4 epochs thay vì 3 epochs. Lý do cho việc này là blockchain đã record lại epoch ở block ngay phía trước, nhưng transaction stake thực sự lại được xác thực ở block tiếp theo (thuộc về epoch tiếp theo do block phía trước là block cuối cùng của epoch trước đó). Để giải quyết trường hợp này, chúng ta cần khóa số token được unstake trong 4 epochs thay vì 3 epochs. Như vậy là chúng ta đã lược qua các thành phần chính cấu tạo nên một tài khoản. 

Khái niệm về cổ phiếu không phải là mới vì trên Ethereum, phần lớn các nhà cung cấp thanh khoản (liquidity provider) và các nhà tạo lập thị trường tự động (AMM) đều đã sử dụng khái niệm này. Ví dụ bạn nạp tiền vào một pool thanh khoản, bạn sẽ nhận lại một loại token từ pool này thay vì số token thực tế được thể hiện ở trên pool. Khi bạn rút tiền từ pool về, bạn sẽ đốt lượng token này và nhận về lượng token thật sự mà trước đó bạn đã nạp vào. Ý tưởng này rất giống với khái niệm cổ phiếu, vì chúng có giá trị tương ứng và chúng ta có thể gọi chúng với một tên gọi khác. 

Đã có một số khám phá về cách mà chúng ta có thể thực hiện đúng logic của contract staking pool và một trong số đó là giới hạn số lượng tài khoản có thể nạp tiền vào một tài khoản pool. Cuối cùng team chúng tôi cũng đã xây dựng được một mô hình staking đơn giản với độ phức tạp thời gian tính toán là hằng số.
Contract Types
So với lockup contract thì contract này không được cấu trúc tốt lắm, và thực tế thì lockup contract phức tạp hơn contract mà chúng ta đang review nhiều. Các kiểu dữ liệu do lập trình viên tự định nghĩa vẫn được đóng gói luôn ở trong contract. Có khá nhiều kiểu dữ liệu tự định nghĩa trong hợp đồng này, ví dụ như kiểu RewardFeeFraction dưới đây:



Ngoài ra còn có một số kiểu dữ liệu tự định nghĩa khác như Account, hay HumanReadableAccount, kiểu dữ liệu này chỉ được dùng cho view call, không thay đổi state của blockchain nên không được dùng trong logic của contract.



Và bên cạnh những kiểu dữ liệu tự định nghĩa trên, chúng ta còn định nghĩa cross contract call (gọi chéo tới method của contract khác) sử dụng interface bậc cao sau:



Ở trên, chúng ta định nghĩa 2 trait. Nó hoạt động bằng cách sử dụng một macro của near_bindgen là ext_contract (viết tắt của external contract - hợp đồng bên ngoài). Bạn có thể dùng tên gọi ngắn gọn cho external contract (ví dụ như ext_voting) và macro của near_bindgen sẽ tự động sinh ra tương ứng để bạn call sau này. Tiếp theo bạn mô tả giao diện của external contract mà bạn muốn sử dụng. Như ví dụ method vote ở trong trait VoteContract bên trên, bạn có thể gọi phương thức vote của external contract và phương thức này nhận vào một tham số có kiểu dữ liệu boolean là ‘is_vote’. 

Sau khi mô tả interface của external contract xong, bạn có thể tạo một Promise khi bạn cần, và truyền vào một positional argument thay vì truyền vào một biến JSON đã được serialize. Macro của near_bindgen sẽ tự động biến tham số đó thành low-level Promise APIs.

Interface thứ hai mà chúng ta mô tả được dùng để tạo callback tới chính contract của chúng ta, và thường loại interface này sẽ được đặt tên là ‘ext_self’. Bạn sẽ cần kiểu interface này khi muốn tạo một callback hoặc thực hiện tính toán trên kết quả trả về của một async Promise. Phương thức ‘on_stake_action’ có mục đích kiểm tra xem hành động staking đã thành công hay chưa. 
Contract File Structure
Contract này được chia làm nhiều module nhỏ.



Như ta thấy ở phần file explorer trong ảnh, contract gồm có module chính là lib.rs và module internal.rs. Trong module internal.rs, chúng ta không sử dụng macro near_bindgen, điều này có nghĩa là các method được định nghĩa trong module internal này sẽ không thể được gọi bởi một ai khác. Những method trong file internal.rs chỉ có thể được gọi nội bộ trong module lib.rs và sẽ không sinh ra file dạng JSON, đồng thời không deserialize state của blockchain. Chúng sẽ hoạt động giống với các method bình thường của ngôn ngữ Rust.

Một cách tổng quan thì contract của chúng ta hoạt động như sau: khi một epoch trôi qua thì validator sẽ nhận được một phần thưởng nhất định.
Một số method quan trọng trong Contract


Phương thức ping có nhiệm vụ phân phối phần thưởng cho các validator và thực hiện restake nếu cần thiết. Đầu tiên nó kiểm tra xem đã trôi qua một epoch hay chưa, nếu như một epoch đã trôi qua thì nó sẽ thực hiện restake vì có thể có sự thay đổi của tổng số token được stake.

Phương thức tiếp theo là deposit:



Phương thức ‘deposit’ là phương thức dạng payable, tức là bạn có thể đính kèm một khoản tiền khi thực hiện call method này. Macro #[payable] giống với decorator payable trong Ethereum, cho phép bạn nhận được tiền chỉ khi method có kèm theo macro này mong đợi điều đó. Nếu như bạn đính kèm một khoản token khi call một method mà method đó không có macro payable thì near_bindgen sẽ báo lỗi. Trong tất cả các method của contract này, chúng ta đều gọi tới method ‘internal_ping’ để đảm bảo rằng đã phân phối phần thưởng trước khi thực hiện một thay đổi logic nào đó. Cấu trúc code mà chúng ta thường gặp trong trường hợp này đó là trước khi thực hiện restake, cần thực hiện một số xử lý logic trước.



Phương thức tiếp theo là ‘deposit_and_stake’. Đây là method kết hợp của hai method phía trên. Đầu tiên, bạn nạp token vào tài khoản mà bạn muốn stake, và bạn cũng muốn thực hiện stake lượng token đó ngay lập tức thay vì phải thực hiện hai transaction. Phương thức này cũng là ‘payable’ vì nó có nhận tiền đính kèm khi call phương thức ‘internal_deposit’.



Phương thức tiếp theo là ‘withdraw_all’. Phương thức này giúp chúng ta rút toàn bộ số token chưa được stake từ account gọi đến nó. Khi bạn tương tác với staking pool, bạn cần tương tác với tài khoản sở hữu số dư. Ở trong phương thức này, tài khoản đó được đại diện bởi predecessor_account_id và nhờ biến toàn cục này, chúng ta kiểm tra được tài khoản và rút token chưa được stake nếu được. Nếu như không rút được token về thì method sẽ báo lỗi, chẳng hạn như trường hợp bạn unstake token nhưng chưa quá 4 epoch thì bạn sẽ không thể rút token về tài khoản của mình.



Phương thức ‘withdraw’ cho phép chúng ta rút một phần số dư về ví thay vì rút toàn bộ như phương thức ‘withdraw_all’.



Phương thức ‘stake_all’ cho phép bạn stake toàn bộ số token của mình. Hiếm khi nào chúng ta gọi tới phương thức này vì chúng ta có thể sử dụng phương thức ‘stake’ bên dưới và nó cho phép chúng ta chọn số lượng token một cách linh hoạt hơn.



Với phương thức ‘stake’ bạn có thể lựa chọn số lượng token mình muốn stake. Ví Moonlight sử dụng một khoản chi phí riêng để stake nhưng họ dùng transaction theo lô để thực hiện việc này.



Tiếp theo là method ‘unstake_all’ giúp bạn unstake tất cả lượng token bạn đã stake bằng cách chuyển chúng sang dạng yocto NEAR. Ở trong method này, chúng ta cũng sử dụng một phương thức hỗ trợ(helper method) chuyển đổi lượng token bạn đã stake sang dạng yocto NEAR và làm tròn xuống giá trị đó. Lý do cần có việc này là vì bạn sẽ không nhận được lượng token bằng kết quả của phép nhân giữa lượng token bạn stake và giá của NEAR. Sau khi tính ra được lượng token, chúng ta sẽ gọi tới phương thức ‘unstake’ ở trên cùng với tham số là số lượng token vừa tìm được. 



Phương thức hỗ trợ ‘staked_amount_from_num_shares_rounded_down’ tương tác với kiểu dữ liệu u256 vì các số dư có kiểu dữ liệu u128. Để tránh hiện tượng tràn số thì chúng ta sẽ nhân số lượng cổ phiếu với total_stake_shares sau khi đã ép kiểu sang dạng u256. Kết quả trả về là thương số được làm tròn xuống.



Phiên bản làm tròn lên: staked_amount_from_num_shares_rounded_up cũng tương tự, ngoại trừ việc chúng ta làm tròn lên thương số. Và ở cuối của mỗi method chúng ta đều thực hiện ép kiểu giá trị nhận được về kiểu u128.

Và cuối cùng chúng ta có method ‘unstake’ có chức năng tương tự ‘unstake_all’ chỉ khác là bạn có thể truyền vào tham số là số lượng token bạn muốn unstake. 


Các phương thức Getter/View
Ở phần này chúng ta sẽ phân tích qua các getter method, các method này trả về một số giá trị để chúng ta thực hiện các view call tới smart contract. Với các method này, chúng ta có thể lấy được giá trị của số token đã được stake hoặc chưa được stake của một tài khoản, tổng số dư của một tài khoản, kiểm tra xem có thể rút token về ví không, …



Với những phương thức dưới đây thì bạn cũng có thể lấy được account_id của chủ sở hữu staking pool, phần thưởng và hoa hồng hiện tại của pool, key hiện tại của staking pool hay kiểm tra xem chủ pool có đang dừng pool hay không.



Giả sử, chủ pool thực hiện chuyển staking pool lên một node thì họ cần hoàn tất việc unstake. Họ có thể làm như sau: tạm dừng staking pool - điều này sẽ gửi một transaction làm thay đổi state tới NEAR, sau đó chủ pool sẽ tiếp tục stake khi họ mở lại pool. Nếu chủ pool dừng staking pool lại thì bạn vẫn có thể rút token về ví, chỉ có điều bạn sẽ không nhận được phần thưởng staking nữa.



Phương thức ‘get_account’ ở trên giúp chúng ta lấy ra tên tài khoản ở format mà con người có thể đọc được (ví dụ alex.near), đồng thời bạn cũng lấy được các thông tin như số lượng token bạn đang có tương ứng với số lượng cổ phiếu mà bạn sở hữu ở giá hiện tại, hay thông tin về việc bạn có thể rút số token đó về ví hay không.



Bên cạnh đó còn có các phương thức giúp bạn lấy được thông tin về số lượng delegator (số người ủy quyền) trên staking pool, lấy được một danh sách các tài khoản cùng một lúc thay vì thông tin về chỉ một tài khoản. Ở trong phương thức ‘get_accounts’, chúng ta lấy ra một danh sách các tài khoản bằng cách sử dụng method ‘keys_as_vector’ của kiểu dữ liệu unordered map được định nghĩa trong NEAR-SDK. Phương thức ‘keys_as_vector’ trả về tập hợp các key từ một ánh xạ, sau đó chúng ta có thể dùng một iterator để lặp qua và lấy thông tin các tài khoản từ danh sách các key này. Đây không hẳn là cách làm hiệu quả nhất nhưng nó cho phép bạn thực hiện thao tác pagination(phân trang) trên kiểu dữ liệu unordered map.
Owner Methods


Owner method - phương thức mà chỉ chủ sở hữu của pool mới có thể call. Ví dụ, chủ của pool có thể cập nhật lại key của staking pool khi họ muốn chuyển pool lên một node khác. Các phương thức của chủ pool đều phải kiểm tra xem người gọi tới phương thức có phải chủ pool không trước khi thực hiện các logic khác (self.assert_owner()).



Trên đây là phương thức giúp chủ pool thay đổi hoa hồng của pool. Hoa hồng phần thưởng của pool sau khi được chủ pool cập nhật sẽ được áp dụng ngay lập tức cho epoch hiện tại, nhưng tất cả hoa hồng phần thưởng trước đó sẽ được tính phí khi chưa cập nhật.



Phương thức ‘vote’ bên trên chính là phương thức mà chúng ta đã review ở bài trước trong series, với mục đích bỏ phiếu cho việc chuyển sang giai đoạn tiếp theo của mainnet.

Tiếp theo là hai method mà tôi cũng đã đề cập tới, hai phương thức này cho phép dừng/tiếp tục chạy staking pool.



Phần mã nguồn còn lại là code kiểm thử của contract. Phần lớn logic của hợp đồng này được định nghĩa trong module internal.rs.
Simulation Test
Chúng ta cũng sẽ có một số simulation test cho một pool cụ thể. Ở đây ta mô phỏng lại cách mà mạng lưới sẽ hoạt động. Đầu tiên, chúng ta khởi tạo pool.



Giả sử Bob là người ủy quyền(delegator) cho staking pool. Bob gọi tới phương thức nạp token ‘deposit_amount’, sau đó Bob có thể kiểm tra xem số dư chưa được stake có đúng không, nếu đúng thì Bob có thể stake số lượng token mà anh muốn. Tiếp theo, chúng ta kiểm tra tổng số lượng token được stake và xác nhận lại Bob có stake cùng lượng token đó không.



Bob gọi tới method ping. Trong simulation test thì không có phần thưởng nào cho việc staking nên bạn cần phải thực hiện nó một cách thủ công. Chúng ta sẽ xác nhận lại một lần nữa là tài khoản của Bob không thay đổi, sau đó tiếp tục chạy staking pool. Ở dòng 11, ta xác nhận lại là pool có đang chạy không, sau đó lock về 0. Tiếp theo, chúng ta mô phỏng rằng pool nhận được phần thưởng là 1 NEAR và Bob ping tới pool. Dòng 23, chúng ta kiểm tra xem lượng token mà Bob nhận được có phải số dương không. Đây là một mô phỏng đơn giản để kiểm tra cách mà pool được dừng hoặc được tiếp tục có hoạt động đúng như dự tính không, pool có dừng việc stake lại khi đang bị dừng không. Sau đó ta để pool tiếp tục stake và pool thực sự đã stake token. Vì vậy simulation test này còn kiểm tra được rằng Bob đã thực sự nhận được phần thưởng staking và chức năng phân phối phần thưởng đã hoạt động. Bên cạnh đó còn có một module test nữa, tuy nhiên nó hơi phức tạp. Phía dưới đây là một số unit test để kiểm thử một số logic của contract:



Những unit test này không hẳn là những best practice để viết unit test nhưng chúng đủ tốt để đảm bảo logic của smart contract hoạt động như mong muốn.
internal.rs
Internal Ping Method


Bây giờ chúng ta cùng phân tích method ‘internal_ping’ ở trong module internal.rs.

Đây là method mà ai cũng có thể call nhằm xác nhận phần thưởng staking đã được phân phối. Ngay bây giờ, chúng ta có những staking pool đang hoạt động và có một tài khoản NEAR ping tới pool mỗi 15 phút nhằm đảm bảo rằng pool đã phân phối phần thưởng và phần thưởng đó được hiển thị trong phần số dư.

Đầu tiên, chúng ta kiểm tra block height hiện tại, nếu như block height không thay đổi tức là vẫn trong cùng một epoch thì trả về false, không thực hiện việc restake token. Còn nếu như đã chuyển sang epoch mới, chúng ta sẽ tính lại tổng số dư trong tài khoản. Method ping có thể được gọi khi một số token được gửi thông qua các lá phiếu nạp token và chúng đã là một phần của số dư trong tài khoản. Chúng ta nhận về tổng số lượng token của account bao gồm cả số dư bị lock và không bị lock. Số dư bị khóa là lượng token đã stake để nhận thưởng, còn số dư chưa bị khóa cũng có thể có phần thưởng trong một số trường hợp nếu như bạn giảm bớt lượng token stake của mình, tuy nhiên bạn vẫn nhận được phần thưởng trong 2 epoch tiếp theo. Chúng ta sử dụng macro assert! để kiểm tra xem tổng số dư có tăng lên hay không. Số dư phải tăng lên là một điều kiện mà staking pool yêu cầu phải có. Đã có một số thứ xảy ra trong quá trình testnet khiến cho điều kiện trên không được đáp ứng ví dụ như mọi người có khóa kết nối tới cùng staking pool và khi bạn có nó, bạn tiêu số dư đó để trả phí gas, kết quả là bạn có thể bị giảm số dư mà không nhận được phần thưởng staking. Cuối cùng chúng ta tính ra tổng số phần thưởng mà staking pool nhận được là kết quả của việc lấy tổng số dư hiện tại trừ đi tổng số dư của epoch cũ. Nếu phần thưởng là một số dương, ta sẽ phân phối nó tới các tài khoản đã stake token. Chúng ta cũng sẽ tính phần hoa hồng dành cho chủ pool.



Chúng ta nhân giá trị reward_fee_fraction (hoa hồng) với tổng số phần thưởng nhận được. Việc này được thực hiện ở kiểu dữ liệu u256, tương tự như cách làm tròn xuống ở trên.



‘owner_fee’ là lượng yocto NEAR mà chủ pool giữ cho riêng họ. Biến ‘remaining_reward’ lưu giá trị của lượng phần thưởng sẽ được dùng để tiếp tục stake. Chủ sở hữu pool nhận về phần thưởng ở đơn vị là yocto NEAR chứ không phải dưới dạng cổ phiếu, tuy nhiên tất cả các logic của contract được tính bằng cổ phiếu nên chủ pool sẽ mua cổ phiếu với giá của phần thưởng sau khi phân phối cho những người ủy quyền trong pool. Biến ‘num_shares’ là số lượng cổ phiếu mà chủ pool sẽ nhận được như là một khoản phí cho việc vận hành staking pool. Nếu ‘num_shares’ là số dương, chúng ta sẽ tăng lượng cổ phiếu và lưu lại tài khoản của chủ pool, đồng thời chúng ta cũng tăng số lượng cổ phiếu staked (dòng 36 và 39). Nếu vì một lý do nào đó mà trong quá trình làm tròn xuống, số dư trở thành 0, phần thưởng sẽ rất nhỏ và giá của mỗi cổ phiếu lại lớn và phần thưởng nhận được là 0. Trong trường hợp này, số dư sẽ chỉ chuyển sang giá của mỗi cổ phiếu thay vì bù cho chủ pool. Tiếp theo, chúng ta log ra một số thông tin như epoch hiện tại, phần thưởng nhận được, … (dòng 45 tới dòng 51). Cách duy nhất để chúng ta hiển thị số lượng cổ phiếu ra bên ngoài là sử dụng log(nhật ký). Tiếp theo, nếu chủ pool nhận được phần thưởng, đồng nghĩa với việc có rất nhiều cổ phiếu. Chúng ta đã phân phối tất cả phần thưởng trong thời gian liên tục và chúng ta chỉ cập nhật một tài khoản (tài khoản của chủ pool) để nhận hoa hồng và chỉ khi hoa hồng là số dương.
Internal Stake Method


Phương thức ‘internal_stake’ là nơi chúng ta implement price guarantee fund - quỹ đảm bảo giá. Giả sử người tiền nhiệm (predecessor) - trong trường hợp này được đại diện bởi account_id - muốn stake một lượng token. Số dư thực tế không thuộc kiểu JSON, vì đây là một phương thức nội bộ nên chúng ta không cần kiểu JSON. Ta tính toán có bao nhiêu cổ phiếu được làm tròn xuống được yêu cầu để stake một số tiền nhất định, và đây cũng là số lượng cổ phiếu mà người sở hữu pool sẽ nhận được. Và số lượng cổ phiếu này phải là số dương. Sau đó, chúng ta kiểm tra số tiền mà chủ pool phải trả cho cổ phiếu (một lần nữa được làm tròn xuống). Điều này nhằm đảm bảo rằng khi chủ sở hữu mua cổ phiếu và chuyển đổi chúng trở lại mà không có phần thưởng sẽ không bị 1 yocto NEAR. Cuối cùng, chúng ta kiểm tra rằng tài khoản có đủ để thanh toán cho số tiền được tính và chúng ta giảm số dư chưa thanh toán và tăng số lượng cổ phiếu trong tài khoản. Tiếp theo chúng ta sử dụng phương thức hỗ trợ ‘staked_amount_from_num_shares_rounded_up’ để làm tròn lên số lượng cổ phiếu. 1 xu hay 1 yocto NEAR được thêm vào khi làm tròn lên này tới từ quỹ đảm bảo. Chúng tôi tính phí người dùng ít hơn, nhưng chúng tôi đã đóng góp nhiều hơn vào số tiền 1 nghìn tỷ yocto NEAR này đã chỉ định ban đầu. Sự khác biệt khi làm tròn thường chỉ là 1 yocto NEAR. Tiếp theo chúng ta đúc thêm cổ phiếu mới nhờ total_staked_balance và total_stake_shares. Cuối cùng chúng ta log ra giá trị của hai biến trên và trả về kết quả.



Phương thức ‘internal_unstake’ hoạt động tương tự như ‘internal_stake’.  Bạn cần làm tròn lên số lượng cổ phiếu bạn cần trả. Sau đó, tính toán số tiền bạn nhận được, một lần nữa làm tròn số tiền bạn phải trả cho việc này. Việc làm tròn này cũng được hoàn thành nhờ một quỹ bảo lãnh. Sau đó, giảm cổ phiếu để tăng số lượng và state khi bạn có thể unlock số dư trong khoảng thời gian 4 epoch. Giá trị của ‘unstake_amount’ được làm tròn xuống và nhờ đó chúng ta bỏ ra ít hơn một chút để đảm bảo giá của những người khác cũng tham gia pool. NEAR cũng sẽ bồi thường cho các lỗi làm tròn từ các quỹ mà NEAR phân bổ. 

Trên đây là những gì mà tôi muốn phân tích với các bạn về Staking smart contract. 
Conclusion
Chúng tôi đã cập nhật các ristretto keys trong quá trình thiết kế hợp đồng này và thật ngạc nhiên là chúng tôi cần tính đến điều này. 

Trong STAKE_SHARE_PRICE_GUARANTEE_FUND 1 nghìn tỷ yocto NEAR phải đủ cho 500 tỷ giao dịch, đủ dài cho staking pool để không cần nạp lại vì phần thưởng sẽ được phân phối lại ngay lập tức cho total_stake_balance trong lần ping tiếp theo. Chúng tôi đã dành khá nhiều thời gian và nỗ lực cho hợp đồng này, bởi vì chúng tôi đã thực hiện rất nhiều đánh giá bảo mật bao gồm cả bên trong lẫn bên ngoài, đặc biệt là với việc phát triển quỹ bảo lãnh để thực hiện việc làm tròn. Điều đó thật phức tạp và một số thứ thú vị đã được phát hiện trong quá trình đánh giá như ristretto key. Chúng tôi đã đánh dấu nhật ký thay đổi của hợp đồng này, cũng như trong readme có một loạt nội dung ghi chú trong quá trình phát triển và thử nghiệm trên hệ thống thật, nhưng phiên bản gốc mất khoảng một tuần để viết. Sau đó, chúng tôi đã kiểm tra và cải thiện nó. Sau đó, chúng tôi đã thực hiện một loạt các sửa đổi. Nhóm yêu cầu tạm dừng và tiếp tục, bởi vì nếu không, chủ staking pool sẽ không có khả năng hủy đăng ký nếu node của họ gặp sự cố. Họ sẽ bị tấn công mạng. Về cơ bản, cổ phần đang hoạt động này sẽ yêu cầu xác thực và không chạy mạng. Đây không chỉ là vấn đề của những người tham gia mà còn là vấn đề của chính mạng lưới. Bằng cách đó, chủ sở hữu pool có thể tạm dừng việc staking nếu họ không muốn điều hành pool mà họ di chuyển vào pool và giao tiếp càng nhiều càng tốt trước khi thực hiện điều này. Tiếp theo, chúng tôi cập nhật giao diện bình chọn để phù hợp với hợp đồng bình chọn giai đoạn hai. Chúng tôi đã thêm các view method để có thể truy vấn tài khoản theo cách mà con người có thể đọc được. Cuối cùng, đã có một số cải tiến xung quanh các phương pháp batching, do đó, deposit_and_stake, stake_all, unstake_all  và withdraw_all thay vì phải thực hiện một cuộc gọi xem trước, sẽ lấy số tiền và đặt số tiền để gọi tiền đặt cược. Đây là cách chúng tôi đã cải thiện mã nguồn.



Khi bạn stake, không chỉ bạn đặt số tiền, chúng tôi còn đính kèm một Promise sẽ kiểm tra xem việc stake có thành công hay không. Điều này là cần thiết vì hai lý do: nếu bạn đang cố gắng stake bằng một key không hợp lệ (không phải ristretto key cụ thể) thì Promise sẽ thất bại trước khi thực hiện. Nó sẽ không xác thực trước khi gửi và điều đó sẽ giúp bạn không cần phải kiểm tra trong hợp đồng. Nó sẽ hoàn nguyên lần call contract gần nhất và mọi chuyện sẽ tốt đẹp. Chúng tôi cũng đã giới thiệu mức stake tối thiểu trên cấp độ giao thức. Số tiền stake tối thiểu là một phần mười số tiền của last seat (giá ghế cuối cùng) và nếu hợp đồng của bạn cố gắng stake ít hơn mức này thì hành động sẽ thất bại và bạn sẽ không thể gửi Promise. Giả sử bạn muốn bỏ một số tiền và bạn đã giảm số dư của mình xuống dưới một phần mười số tiền đã stake. Hành động stake có thể thất bại, và bạn sẽ không thể hủy bỏ lệnh giao dịch, do bạn cần nó để đảm bảo rằng việc unstake phải xảy ra. Trong trường hợp này, chúng tôi có lệnh callback này để kiểm tra xem hành động stake đã hoàn tất thành công hay chưa. Callback về cơ bản sẽ kiểm tra xem nếu nó không thành công và số dư là số dương, chúng ta cần phải unstake. Vì vậy, nó sẽ gọi method unstake với tham số amount bằng 0 để đảm bảo rằng số dư đã được giải phóng. Bạn có thể rút tiền sau 4 epoch trong quá trình thử nghiệm các hợp đồng này mà chúng tôi đã thực hiện trên testnet bản beta 9 trước khi bảo trì. Hợp đồng đã sẵn sàng vào khoảng mùa hè, vì vậy việc thử nghiệm lần lặp lại này có thể mất khoảng 2-4 tháng do sự phức tạp mà nó liên quan đến việc tương tác với giao thức. Có khá nhiều kinh nghiệm mà chúng tôi tích lũy được từ kỹ thuật pagination đến các method hỗ trợ và kết hợp các logic với nhau. Bây giờ, bạn phải thực hiện stake một lượng token vào lockup contract một cách thủ công, nhưng sẽ thật tuyệt nếu bạn không cần phải suy nghĩ về số yocto NEAR phải trả cho chi phí lưu trữ. Bạn chỉ muốn stake mọi thứ từ khóa của mình, nhưng vì nó đã được triển khai thực tế nên đã quá muộn để nghĩ về điều này. Ngoài ra còn có một số gas được hard code và không thể thay đổi vì chúng đã được lưu trên NEAR blockchain.



Vì vậy, vote không quan trọng nhưng method ON_STAKE_ACTION_GAS yêu cầu bạn phải có một số lượng lớn cho mỗi cổ phần và bạn không thể yêu cầu ít hơn. Các hành động rủi ro đối với mọi contract call này sẽ yêu cầu chúng tai phải có một lượng lớn gas và vấn đề là nó gây lãng phí. Giả sử chúng ta đồng ý về việc đốt tất cả gas, lượng gas này sẽ luôn bị đốt cháy và bị lãng phí cộng với việc nó giới hạn số lượng giao dịch bạn có thể đưa vào một block nếu ta đang hạn chế gas theo case này. 

Có rất nhiều lần lặp lại việc kiểm tra hợp đồng bằng cách sử dụng framework simulation test mà chúng tôi đã cải thiện rất nhiều. Ở trong các bài review sau, khi chúng ta review lockup contract, bạn sẽ thấy mã nguồn của lockup contract có khá nhiều điểm cải thiện so với contract này.

### NEAR Protocol and Polygon

Polygon has gained a lot of traction over the last few months. With scalability being all the rage in the Ethereum community, it makes sense why layer-2 solutions like Polygon have gained such a large following. However, NEAR Protocol not only offers a highly scalable platform on the base layer, but it also provides a layer-2 experience that’s EVM compatible as well. Today, let’s compare both of these projects.
What Is Polygon?
So, to understand Polygon, let’s first look into layer-2. In the Ethereum network, the base Ethereum blockchain is known as “layer-1.” Decentralized networks prioritize security and liveness, which inevitably compromises the speed. The solution here is to build an additional network above the core blockchain called layer-2. The blockchain delegates complex calculations to layer-2, which exponentially speeds up overall throughput. Polygon is an example of a layer-2 solution.

The native token of the Polygon ecosystem is MATIC. MATIC’s main token utilities are:

 	Payment and settlement purposes between participants.
 	Staking and governance. More MATIC you stake, the more your voting power.
 	Pay transaction fees.
 	Reward users for providing computational resources and services.

MATIC has a hard upper cap limit of 10 billion.
Polygon Mechanics
Polygon has a multi-level ecosystem that utilizes EVM-compatible sidechains. The purpose of these sidechains is to unclog the main chain. Sidechains are side blockchains that are linked to the main chain via a two-way peg. The sidechain can have its own unique rules and ecosystem. Periodically, the sidechains are supposed to commit data to the main blockchain to ensure seamless operations.

Developers create their own sidechains to scale up their apps by utilizing the Polygon SDK stack. Polygon has gained in popularity mainly because it’s a lot cheaper to use than the Ethereum mainnet and is a lot faster.

Polygon uses a proof-of-stake (PoS) mechanism, and anyone can become a validator by staking their MATIC tokens. Validators have the following roles in the ecosystem:

 	Validating transactions by approving and confirming exchanges in the sidechains.
 	Network validators can take care of governance by voting on various upgrades.
 	Responsible for selecting block producers for each checkpoint (more on this in a bit).

Polygon sidechains are a section of the Ethereum ecosystems wherein users can quickly execute their projects without worrying about inflated gas prices and slow throughput.

How Polygon Ensures Speed And Decentralization

Polygon’s PoS is mostly used for “checkpointing.” This means that a team of block producers is appointed for each checkpoint, and these producers are in charge of maintaining and ensuring consensus. Having a limited number of producers allows Polygon to form blocks a lot faster than Ethereum (1 second block rate instead of 20 sec).

On top of that, Polygon ensures decentralization by delegating PoS checkpoints periodically to the Ethereum main chain. Every single block created by the block producer has to be validated via a proof of block committed to the Ethereum chain.

How To Interact With Polygon?

This is what you need to do to interact with a project based on the Polygon sidechain:

 	Identify the contract on the Ethereum network and declare the number of tokens you want to send to the Polygon sidechain.
 	A special smart contract called “RootChainManager” activates another contract called “ChildChainManager.” These two contracts work in tandem to ensure that the number of tokens you lockdown in the Ethereum network gets carried over seamlessly to the mainnet.
 	Now the user can move over to the Polygon network and accept their tokens.

Alright, how about the other way round? What if you want to leave the Polygon ecosystem and go back to Ethereum? These are the steps you will need to follow:

 	You must burn your tokens on Polygon.
 	The verification of this burn needs to be sent to the Ethereum mainchain.
 	Once verified, your resources will be re-allocated to you in your wallet.

What Is NEAR Protocol?
In the summer of 2018, Illia Polosukhin and Alexander Skidanov created the NEAR Protocol as the ideal dev platform for decentralized applications. Most other platforms suffer from low speeds, low throughput, and poor compatibility with other chains. 

NEAR Protocol is built from scratch and has the following features to enable good scalability and security:

 	NEAR uses a block generation mechanism called “Doomslug.” Doomslug allows practical or “Doomslug” finality, ensuring that the blocks receive finality in seconds.
 	NEAR is a sharded system that allows for infinite scalability. It takes a unique approach to scale up to billions of transactions in a completely decentralized way instead of depending on centralized processes like other protocols.

What Is Sharding? 

Continuing from the last point, let’s understand what sharding is. Sharding is a technique used in databases to handle bulky data. Sharding breaks down the whole database into manageable chunks called “shards.” These shards can be processed in parallel for fast computation.

Now, what exactly happens in a blockchain during sharding? Let’s take a look:

 	The entire blockchain state gets broken up into smaller shards.
 	Every single account belongs to one unique shard, and they can interact only with the accounts belonging to the same shard.

The problem with normal sharding is that it requires nodes to run on increasingly complex hardware, greeting cutting down the barriers to entry. NEAR’s sharding allows for small nodes to run on simple cloud-hosted instances.

What is Aurora?

Aurora provides an Ethereum-compatible layer-2 experience on top of NEAR and consists of the Aurora Bridge and the Aurora Engine. Ethereum devs can run their apps in Aurora to take advantage of NEAR’s several positive features, such as gas fees and sharding. Overall, these are the enhancements that Aurora is bringing along:

 	Apps can process multiples of thousands of transactions per second. This is an exponential improvement over Ethereum.
 	Aurora is extremely fast since it has a block time of 2 seconds compared to Ethereum’s 15.
 	NEAR’s sharding allows the ecosystem to scale horizontally.
 	Fees on Aurora are 1000x times lower than those on Ethereum. 
 	Completely compatible with Ethereum over the NEAR Protocol. 

DeFi On NEAR and Polygon
Polygon DeFi
Polygon allows you to use most of the popular DeFi apps prevalent on Ethereum, like Curve Finance, 1inch Exchange, and Beefy Finance. As per DappRadar, the top 5 apps by users in the last 24 hours are as follows:



Sushi seems to be, far and away, the most popular app.

Polygon’s increasingly rabid DeFi ecosystem has been a sight to behold. The following image shows you the total value locked (TVL) up in Polygon, which is currently around $5.19 billion.



The TVL reached a peak of $10.54 billion on June 15, 2021. Plus, when it comes to actual value locked in, Aave is - far and away - the biggest protocol, accounting for a staggering 40% of the total TVL.
NEAR DeFi
Compared to Polygon, NEAR DeFi still has a very young ecosystem that’s been growing steadily over the last three months. As of now, the TVL is only around $141.72 million.



The most dominant DeFi app that accounts for over 80% of the overall TVL is Ref Finance.

Ref Finance has some similarities with Uniswap V2, plus it supports more pool types, configurable fees, and it’s completely community-owned. Ref also happens to be the first DeFi platform on NEAR. The main aim of Ref is to bring together DEX, lending protocols, synthetic asset issuer, and more under one umbrella.

NEAR has recently launched a humongous $800 million grant fund that has been specifically aimed at creating a larger and healthier DeFi ecosystem. The fund has some major requirements, which include the following:

 	$100 million for startups
 	$100 million regional fund
 	$250 million ecosystem grants to be distributed over four years.

NFT On NEAR And Polygon
Polygon NFT
Polygon is one of the three blockchains that is currently available on Opensea (one of the biggest NFT marketplaces in the world) along with Ethereum and Klaytn. As per the site’s rankings, here are the top 5 NFTs on Polygon:



It seems like ZED RUN is the runaway leader when it comes to Polygon NFTs. 

So, what is ZED? It’s a provably fair digital horse racing game that’s built on the blockchain. The idea is for you to collect as many racehorses as possible to create a high-quality stable.


NEAR NFT
Currently, there are several NFT platforms on NEAR like Mintbase. Mintbase was started in 2018 by Nate Geier and Calorine Wend and raised $1 million from a seed funding round in 2020. The platform allows users to create and sell assets backed by NFTs. In addition, users can mint different digital assets as NFTs. These assets could range from event tickets to crypto art and everything in between. 



Interestingly enough, Mintabase was supposed to launch on Ethereum. However, the high gas fees and increasing congestion prevented them from doing so. So instead, Mintbase saw NEAR as a better platform than Ethereum, with significantly lower gas fees thanks to a more efficient contract execution model.
Conclusion
Polygon has gained much traction over the last year, with layer-2 getting hotter than ever before. In addition, because of its close relationship with the Ethereum community, it has experienced a swift adoption rate.

On the other hand, NEAR has shown a lot of promise by solving scalability issues with sharding. Plus, the $800 million developer grant will bring in a significant amount of utility into the network. Both the protocols – Polygon and NEAR – provide a perfect platform for developers to build a scalable and efficient decentralized economy.

### Los 3 mejores proyectos de NFT en el protocolo NEAR

El crecimiento de las finanzas descentralizadas (DeFi) ha puesto a las NFT en el foco principal, y el crecimiento de las NFT también ha puesto de relieve varios problemas. Ethereum tiene el monopolio de este sector, con muchas NFT creadas en la cadena de bloques Ethereum. Entonces, ¿cuál es el problema de crear NFT en una de las plataformas más populares del mundo? El problema se encuentra en las altas tarifas del gas. Ethereum tiene un gran obstáculo en cuanto a las tarifas de la red, que potencialmente pueden cruzar cientos de dólares, lo que lo hace muy poco práctico.

Entonces, ¿cuáles son las opciones cuando se trata de tokens no fungibles y proyectos NFT? ¿Qué otras opciones tienen? El Protocolo NEAR tiene varios proyectos importantes en su plataforma y, a menudo, se promociona como el asesino de Ethereum. El protocolo NEAR es una cadena de bloques escalable que simplifica y acelera el desarrollo de dApps. Por el momento, hay 19 plataformas descentralizadas para el intercambio de las NFT en la cadena de bloques NEAR. El protocolo NEAR tiene una ventaja significativa sobre Ethereum, ya que es significativamente más rápido que Ethereum y las transacciones cuestan casi nada, lo que lo convierte en una plataforma ideal para el comercio de NFT.
¿Qué es el protocolo de NEAR?
El Protocolo NEAR es una plataforma de desarrollo descentralizada que se creó en 2018. Fue diseñado para crear un entorno que fuera perfecto para aplicaciones descentralizadas a la vez que dirigía los esfuerzos en resolver las aparentes deficiencias de otras plataformas en el espacio. NEAR opera con el protocolo NEAR, una cadena de bloques de prueba de participación (PoS) que reduce los costos y mejora la escalabilidad mediante la implementación de varias funciones.

NEAR también adopta un enfoque diferente utilizando el Sharding al introducir un nuevo mecanismo de generación de bloques, "Doomslug". Doomslug se propuso en 2019 e introduce la finalidad práctica o "Doomslug", lo que permite que los bloques sean confirmados en cuestión de segundos.

NEAR funciona con la misma tecnología que impulsa a Bitcoin y es la red más accesible para desarrolladores y usuarios finales. A diferencia de NEAR, la mayoría de las cadenas de bloques centralizan el procesamiento y lo limitan al hardware de alta gama. Gracias al diseño de NEAR, la plataforma puede escalar linealmente hasta miles de millones de transacciones de una manera completamente descentralizada.
¿Cuáles son algunos de los aspectos más importantes de NEAR?
NEAR es desarrollado por una pequeña comunidad de desarrolladores e investigadores conocida como NEAR Collective. Algunas de las características esenciales son:

 	NEAR es un protocolo fácil de usar que permite a los desarrolladores crear aplicaciones de forma rápida y sencilla.
 	NEAR permite una escalabilidad ilimitada.
 	Contrariamente a lo que se cree, NEAR no es una cadena lateral sino un protocolo de primera capa (Layer 1).
 	Todas las dApps creadas en NEAR se ejecutan en la capa NEAR subyacente.

El Colectivo de NEAR
Como se mencionó anteriormente, NEAR es desarrollado por una comunidad de desarrolladores e investigadores. Estos son parte del NEAR Collective o colectivo NEAR, que está formado por organizaciones y contribuyentes individuales que trabajan continuamente para garantizar el funcionamiento diario del Protocolo NEAR y mejorarlo constantemente.

El colectivo NEAR escribe el código inicial y la implementación para la red NEAR. Mientras que el colectivo garantiza el funcionamiento del protocolo, NEAR está completamente descentralizado y funciona de forma independiente. No puede ser cerrado ni siquiera por el equipo que lo desarrolló.

El Colectivo NEAR está formado por la Fundación NEAR; una organización sin fines de lucro enfocada en crear un ecosistema vibrante alrededor de la cadena de bloques NEAR. El Protocolo NEAR es solo uno de varios proyectos del Colectivo NEAR.
El protocolo de NEAR y las NFT
El protocolo NEAR es la plataforma perfecta para las NFT, ya que tiene muchas ventajas sobre Ethereum. El protocolo es significativamente más rápido que Ethereum, el cual tiene además unas tarifas de gas sustancialmente más altas, mientras que NEAR permite que las transacciones se procesen por una tarifa insignificante. Estos factores hacen que NEAR sea ideal para comprar y vender NFT.

Como se mencionó anteriormente, ya hay varios proyectos NFT que se han creado en la cadena de bloques NEAR. Sin embargo, antes de echar un vistazo a los proyectos, comprendamos brevemente el concepto de NFT.
El significado de No-Fungible
Un activo fungible es un activo que se puede intercambiar por otro activo idéntico. Bitcoin es un excelente ejemplo de activo fungible, lo que significa que se puede intercambiar un bitcoin por otro bitcoin sin ningún problema. Los activos no fungibles, por otro lado, son activos únicos que no pueden negociarse. Un ejemplo de un activo no fungible puede ser una pintura única o una colección de edición limitada.

Un activo no fungible tiene una propiedad o propiedades distintas que lo distinguen de otros activos. Los tokens no fungibles se basan en activos no fungibles y son activos digitales únicos que utilizan la tecnología blockchain.
¿Qué es un NFT?
as NFT son activos digitales únicos que tienen su información de identificación registrada en un contrato inteligente. La información sobre el contrato inteligente es lo que hace que una NFT sea única. Los activos fungibles como Bitcoin se pueden intercambiar, lo que significa que puede enviar o recibir bitcoins sin problemas. Los activos fungibles también son divisibles, lo que le permite enviar cantidades más pequeñas. Los activos no fungibles no son divisibles. Por ejemplo, no puede enviarle a alguien una parte de una pintura o un boleto.

Los NFT son certificados digitales de propiedad de activos digitales. Un NFT es un contrato inteligente que se utiliza para asegurar un activo digital. Una vez escrito, se publica en un token (ERC-721) en la cadena de bloques. Cualquier cosa se puede convertir en una NFT, siendo los más populares videos, GIF o JPEG.




	

	
	
		
			
				¿Cuál de los siguientes es un NFT?
			
		

		
					

		
			
			
			
			Bitcoin
		
			
			Moneda Fiduciaria
		
			
			Un coleccionable digital
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proyectos NFT en el protocolo de NEAR
Actualmente, hay varias plataformas NFT en NEAR, así que veamos algunos de los proyectos más populares en la plataforma.
Mintbase
Mintbase comenzó en 2018 y fue creado por Nate Geier y Calorine Wend. Nate Geier es el director ejecutivo de la empresa, mientras que Caroline es la directora de operaciones, utilizando su experiencia en gestión y desarrollo empresarial. Mintbase logró recaudar $1 millón de una ronda de financiación inicial en 2020. Sino Global lideró la ronda y también estaba formada por otros Venture Capital  como Block Oracle Capital, D1 Ventures y otros inversores ángeles.

Fish Woman (mujer pez) de From my Dream

Se trata de una plataforma de cadena de bloques digital que se utiliza para emitir e intercambiar tokens no fungibles, los tokens en Mintbase son diferentes de otros tokens que generalmente son tokens de arte digital. La plataforma Mintbase permite a los usuarios crear y vender activos respaldados por NFT. Los usuarios pueden acuñar diferentes activos digitales como NFT. Estos activos pueden variar desde entradas para eventos hasta arte criptográfico y todo lo demás.

Mintbase permite que prácticamente cualquier persona con acceso a Internet haga un NFT y lo ponga a la venta en su mercado o en mercados NFT como OpenSea. Los “minters” pueden crear un contrato inteligente y limitar la transferibilidad de los tokens acuñados, lo que ayuda a prevenir el fraude o la transferencia ilegal de artículos únicos. Mintbase se centra en crear una experiencia de creación de NFT que sea única, por lo que, como se mencionó anteriormente, admite diferentes activos digitales. Esto es contrario a las plataformas de la competencia que se centran en una categoría específica de NFT.
¿Por qué Mintbase cambio a NEAR?
Entonces, ¿por qué cambiar de Ethereum a NEAR? La respuesta está en las tarifas del gas. Las tarifas de Gas en ETHEREUM habían comenzado a volverse ridículamente caras. Para acuñar NFT en Mintbase, un usuario debe crear una tienda digital. Esto implica que el usuario cree un contrato inteligente y pague a Ethereum una tarifa de gas. Inicialmente, la tarifa era baja y los usuarios podían implementar la tienda rápidamente. Sin embargo, con el aumento de la congestión en la red Ethereum, las tarifas comenzaron a subir cada vez más, y la creación de tiendas costaba cientos de dólares. El costo se volvió tan alto que Mintbase tuvo que decirles a sus usuarios que esperaran a que bajaran los precios del gas antes de implementar una tienda. Ethereum rápidamente se volvió insostenible para comprar, vender o crear NFT.

Mintbase vio a NEAR como una mejor plataforma en comparación con Ethereum, con tarifas de gas significativamente más bajas gracias a un modelo de ejecución de contratos más eficiente. También utiliza Nightshade, un enfoque dinámico para Sharding. Sin embargo, hay varias otras razones por las que Mintbase cambió a NEAR.

 	El uso de Rust o AssemblyScript para contratos inteligentes en la plataforma NEAR facilita a los desarrolladores la escritura de código.
 	NEAR presenta direcciones legibles por humanos tanto para contratos como para cuentas.
 	Los desarrolladores pueden incorporar usuarios rápidamente, gracias a NEAR Drops. 
 	Los desarrolladores y los usuarios pueden mover activos rápidamente gracias al puente Rainbow ETH-NEAR.
 	Otras plataformas DeFi como Aave y Balancer también están en NEAR, lo que facilitará cualquier integración futura.




	

	
	
		
			
				¿Por qué Mintbase cambio a NEAR?
			
		

		
					

		
			
			
			
			Altas comisiones en Gas en Ethereum
		
			
			NEAR es una plataforma más avanzada
		
			
			Los desarrolladores pueden mover los activos rápidamente
		
			
			Todas las anteriores
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras se creó con la visión de proporcionar la solución al envejecimiento de las tarjetas coleccionables tradicionales. La plataforma válida la propiedad a través de la cadena de bloques a través de transacciones rápidas y económicas. La plataforma se centra en la creación de colecciones cripto-nativas que se pueden diversificar aún más en medios más destacados.

PunkyPoN#0006 de monztre.near

Paras es un mercado de tarjetas de arte digital todo en uno construido sobre NEAR. La plataforma puede validar la propiedad y dar acceso a cada compra y venta a los usuarios. Ofrece transacciones rápidas y económicas, y se diferencia de otros mercados al ofrecer colecciones en lugar de lanzamientos únicos. La plataforma se diferencia de la siguiente manera.

 	Paras reduce la carga de mantenimiento de los recolectores al garantizar que sus objetos de colección no se desgasten con el tiempo. La plataforma elimina barreras y brinda a los artistas y coleccionistas un fácil acceso al mercado de coleccionables digitales. Gracias al Protocolo NEAR, Paras puede reducir los costes en que incurren los artistas para vender sus tarjetas.
 	Paras está desarrollando el arte de la tarjeta digital para futuros artistas, jugadores y creativos, y permite a los artistas crear una colección que se vincule a un tema o tradición. A través de este método, las tarjetas de arte digital en Paras son ricas en historias y trasfondos.

Paras puede adoptar un enfoque curado y crear una comunidad y una experiencia NFT. Paras garantiza la coherencia y la calidad mediante la selección de artistas y formatos. Los artistas pueden crear nuevas tarjetas en Paras solo después de haber sido aprobados, y la cantidad de nuevos artistas aprobados está limitada a 30 artistas por semana. Los artistas también deben cumplir con la relación de aspecto estándar de 64:89.




	

	
	
		
			
				¿Qué es Paras?
			
		

		
					

		
			
			
			
			Un mercado todo en uno de arte de tarjetas digitales
		
			
			Una plataforma de contratos inteligentes
		
			
			Un lenguaje de programación

		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Desde el lanzamiento de la plataforma, los artistas de Paras ya han ganado más de $25,000, y la plataforma puede facilitar un volumen de operaciones de más de $35,000 a partir de más de 700 transacciones. La plataforma cuenta con más de 80 coleccionistas activos y más de 70 artistas. Las bajas tarifas de acuñación mantienen baja la barrera de entrada para los artistas digitales, y los artistas pueden acuñar tarjetas sin preocuparse por el costo de acuñación.
¿Por qué NEAR es ideal para Paras?
Debido a que la demanda de espacio en Ethereum está aumentando los costos en la plataforma, los creadores de NFT más nuevos están buscando alternativas y soluciones. NEAR está trabajando con Ethereum en una solución interoperable. Las transacciones en NEAR cuestan solo unos centavos y, a veces, incluso menos. La billetera NEAR es altamente eficiente y las transacciones se completan casi instantáneamente. El puente Rainbow asegura que NEAR será interoperable con activos basados ​​en Ethereum.
Hip Hop Heads (Cabezas de hip hop)
Hip Hop Heads marca la entrada de un pilar de la cultura estadounidense en el espacio criptográfico. La serie de arte colaborativo presenta el trabajo de Andre LeRoy Davis, el creador de la icónica “The Last Word” en The Source Magazine, y también presenta la animación de fondo de uno de los copropietarios de The Source Magazine, Ed Young.

Hip Hop Heads nació de una colaboración entre el Universal Hip Hop Museum, The NEAR Protocol y Ed Young. Juntos decidieron crear una colección NFT que contó con artistas desde los años 70 hasta la actualidad. La colección, llamada NFT.HipHop Heads, contará con 47 de los artistas de rap más importantes y honrará no solo a los artistas, sino que también marcará el año 47 de la era del Hip Hop. El proyecto vuelve a conectar con las raíces del rap utilizando los últimos avances tecnológicos.

HipHopHead 10.292.22166

Cada ilustración existirá como una colección de 47, lo que significa 47 años de la era del Hip Hop. La primera edición de cada Hip Hop Head se nombra según el lugar del artista en la historia del Hip Hop. La importancia de cada artista se demuestra a través de una ilustración creada por Andre LeRoy Davis. El código de animación de fondo es el resultado de los números más significativos en la historia del Hip Hop que demuestran el paso de la era del Hip Hop a lo largo de 47 años. La colección NFT se subastará todos los días en su sitio web hasta el 24 de julio.
¿Por qué Hip-Hop Heads escogió a NEAR?
El protocolo NEAR permite que la colección Hip Hop Heads sea más accesible para la población en general. Como se mencionó anteriormente, la colección se subastará diariamente hasta el 24 de agosto y se podrá comprar con tarjeta de crédito. Esto permite que NEAR haga más viable el proyecto. El mercado de subastas también pone de relieve las características del protocolo NEAR, como una interfaz familiar y amigable similar a web-2, acuñación de NFT fácil y relativamente económico con accesibilidad para el usuario final.

Debido a que los usuarios pueden comprar las NFT con una tarjeta de crédito, el mercado ofrece una forma sencilla de comprar dichos NFT sin pasos complicados que hagan que los usuarios pasen por alto. Las regalías de NFT en el Protocolo NEAR están escritas en el código NFT, lo que permite a los creadores obtener regalías de las ventas secundarias, incluso si la NFT se traslada a otro mercado. Esto es posible gracias al estándar NFT a nivel de contrato de NEAR. NEAR les da a los artistas y creadores el control de su NFT, lo que les permite beneficiarse de su trabajo.
Conclusión
NEAR está haciendo que la construcción e implementación de dApps sea más fácil, rápida y económica que cualquier otro protocolo de cadena de bloques y es uno de los proyectos más prometedores en el espacio criptográfico. Aborda varios problemas que enfrentan los proyectos en Ethereum, como las altas tarifas de gas y las velocidades de procesamiento lentas. También tiene varias ventajas sobre la cadena de bloques Ethereum gracias a su solución fragmentada.

El protocolo NEAR se muestra prometedor, utilizando Sharding para resolver los problemas que enfrentan otras cadenas de bloques. Gracias a este enfoque, NEAR puede aumentar el rendimiento sin comprometer la seguridad. Inclusive, NEAR Collective garantiza que los ingenieros y desarrolladores trabajen constantemente en el protocolo.

### NEAR Sputnik DAO: empoderamiento de las comunidades

La mensajería Open Web y Web3 se deriva de la idea de que la próxima generación de Internet será construida y gobernada por la gente. NEAR incluso ha codificado esto en nuestra misión: empoderar a todas las personas para que controlen su propio dinero, datos y poder de gobierno.



	

	
	
		
			
				¿Cuál, según usted, debería ser el propósito central de un DAO?
			
		

		
					

		
			
			
			
			Coordinando actividades comunitarias
		
			
			Facilitar el mecanismo de gobernanza
		
			
			Replicar la estructura corporativa
		
			
			Facilitar la tokenómica
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Una publicación de blog muy antigua (2014) del fundador de Ethereum, Vitalik Buterin, pintó una nueva forma de pensar sobre la acción colectiva, donde en lugar de una empresa con accionistas, ejecutivos y empleados, podría haber una organización autónoma descentralizada, o DAO, donde los miembros poseen una parte de la organización, contribuyen lo que pueden a su éxito y son recompensados ​​proporcionalmente a su contribución. No hay jefes, no hay jerarquías y los participantes están unidos por un propósito común.

Recuerdo que me sentí inspirado cuando leí por primera vez la publicación de Vitalik, imaginando un futuro verdaderamente propiedad de la comunidad donde cualquier persona, en cualquier lugar, podría formalizar un grupo y sus acciones independientemente de los límites de las fronteras, las leyes o los bancos, al igual que lo hace Web3 con tecnología blockchain para el individual, los DAO podrían hacer por las comunidades. Eventualmente, las empresas serían reemplazadas por DAO, que todavía tienen muchas características similares a las de una empresa, pero con mayor flexibilidad tanto en su fundación como con el tiempo, a medida que cambian las demandas y prioridades de las personas involucradas.

Esta visión incluso es anterior a mi interés en Web3 y blockchain. Dejé Ucrania porque nunca me sentí seguro al iniciar una empresa allí. No creo que se pueda confiar en ningún banco ucraniano para almacenar mi dinero de forma segura. El gobierno ha cambiado las reglas sobre la tenencia de moneda estadounidense varias veces en los últimos diez años (como la necesidad de vender la mitad a la recepción de la moneda local). También hay mucha corrupción y una estructura rígida en torno a cómo las empresas pueden operar en Ucrania. En muchos países, la formación de una empresa conlleva gastos generales adicionales debido a la corrupción del gobierno, la falta de estado de derecho y los bancos poco confiables que pueden desaparecer.

Esto es cierto en todas partes, hasta cierto punto: antes de blockchain, si las personas querían organizarse en un grupo formal, tendrían que solicitar una licencia del gobierno (por ejemplo, crear una empresa), especialmente si necesitaban una cuenta bancaria y querían participar. en la economía como grupo. Este proceso requiere mucho tiempo, es caro, complejo y la organización resultante está sujeta a reglas restrictivas una vez que se forma.

Incluso la coordinación comunitaria informal requiere reglas y moderación. Imagina que un grupo de estudiantes de anime quiere coordinar un evento internacional de fans, o un colectivo de artistas exitosos de todo el mundo quiere unirse para apoyar a artistas novatos. La coordinación de la comunidad podría incluir todo, desde una forma de publicar de qué manera los miembros se apoyan en alguna pregunta, crear arte o un producto juntos, lanzar una aplicación, invertir en algunos activos digitales o incluso ser copropietarios de un canal social como una cuenta de Twitter. Todos estos son ejemplos de coordinación del mundo real que requieren algún tipo de gobernanza.

Durante mucho tiempo, he creído en una miríada de pequeños equipos que trabajan juntos en lugar de grandes empresas que crean un monopolio y luego luchan por preservarlo. De hecho, hace unos diez años, unos amigos y yo creamos ProstoKSI, que no era una empresa, estaba formada por desarrolladores que trabajaban juntos en proyectos de código abierto.

Web3 hace posible esta visión de una manera que Web2 no puede, debido a las garantías que vienen con las criptomonedas. Imagínese construir sobre un proveedor en la nube o usar un banco que solo está dirigido por un grupo de 20 personas sin afiliación formal y sin garantías de que la organización seguirá funcionando en un año; hay límites a lo que puede construir sobre él. . Pero en criptografía, la infraestructura y las aplicaciones descentralizadas son confiables porque son de código abierto, de estado abierto y vienen con garantías confiables. Las aplicaciones creadas de esta manera proporcionan protocolos comunes para interactuar entre sí, en los que otros desarrolladores, empresas y usuarios pueden confiar.

Los DAO son parte de estos protocolos comunes en el nuevo mundo. En los siete años desde que Vitalik escribió esta publicación de muy alto nivel, miles de miembros han experimentado con DAO en Ethereum y otras redes; algunas de las más conocidas incluyen Maker, Moloch DAO, MetaCartel, The LAO y Flamingo DAO. Tomé algunos aprendizajes clave de la primera ola de experimentación con DAO que informó la visión de los DAO en NEAR.

 	En general, está claro que las formas sencillas para que una comunidad controle la gobernanza no se adaptan al número de personas involucradas. Miles de personas no pueden desarrollar o controlar nada de manera efectiva sin la introducción de reglas, leyes o jerarquías. También hemos visto una serie de experimentos en el espacio blockchain en torno a la gobernanza de protocolos y fondos de inversión. Muchos de ellos han fracasado por diversas razones, desde problemas técnicos hasta la falta de interés en votar de los miembros o la falta de un factor unificador y motor.
 	No se puede esperar que todos los miembros estén siempre felices. Los intereses se desvían y las opiniones de las personas evolucionan; eventualmente surgirán mayorías y minorías en torno a algún tema. Aunque en la mayoría de los casos todos llegarán a un consenso a través de la gobernanza básica como la votación, la minoría de la comunidad debería poder bifurcarse o divergir del grupo original para seguir un nuevo conjunto de reglas, en cualquier momento si no están de acuerdo. con la mayoría y tienen bastante de su propia voluntad.
 	Cualquier comunidad u organización requiere liderazgo. Incluso si se trata de un grupo de personas muy dedicado, si no están trabajando a tiempo completo en la causa compartida, probablemente estén demasiado ocupados para estar activos todo el tiempo y participar en cada discusión o decisión. Las comunidades suelen tener miembros dedicados que son responsables de la coordinación, posiblemente la moderación.
 	Si una comunidad no tiene permiso y tiene un seudónimo, sigue siendo valioso tener miembros que se sepa públicamente que están involucrados y crean el "núcleo" de la comunidad. La comunidad escuchará las perspectivas y opiniones de estos miembros por encima de cualquier otro porque se sabe que son los más interesados ​​e informados.
 	Cuanto más centrada en el "producto" esté una comunidad tan descentralizada, más centrado debe estar el liderazgo, ya que el desarrollo de productos normalmente requiere mucho más contexto del que tendría cualquier participante de la comunidad. Por ejemplo, una comunidad que intenta construir una cadena de bloques o un intercambio descentralizado juntos.
 	La ponderación pura basada en la participación siempre falla, ya sea porque la mayoría de las partes interesadas no pueden o no quieren ser participantes activos, o porque abre formas fáciles de atacar el proceso de gobernanza.




	

	
	
		
			
				¿El Sputnik DAO se creó específicamente para comunidades técnicas?
			
		

		
					

		
			
			
			
			Sí
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Entonces, un DAO es una comunidad unida en torno a un propósito común, que requiere algunas reglas para la coordinación y la gobernanza, con la flexibilidad de evolucionar con el tiempo a medida que cambian los intereses y objetivos de la comunidad, y la capacidad de realizar transacciones y ganar dinero como una unidad con un mínimo gastos generales. Con todos estos aprendizajes en mente, nos propusimos crear un protocolo DAO en NEAR que empoderaría a todo tipo de comunidades, no solo a las técnicas dirigidas por ingenieros, con un marco flexible y robusto para trabajar y evolucionar juntos.



	

	
	
		
			
				¿Cuáles de las siguientes afirmaciones son verdaderas sobre el liderazgo comunitario?
			
		

		
					

		
			
			
			
			El verdadero liderazgo garantiza que todos los miembros de la comunidad estén siempre felices
		
			
			Los líderes comunitarios no están obligados a trabajar a tiempo completo para la comunidad.
		
			
			Incluso en una comunidad sin permiso, es importante tener miembros / líderes centrales
		
			
			Los líderes de la comunidad gobiernan la comunidad creando reglas
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El protocolo resultante, Sputnik DAO, ofrece una forma para que las comunidades y organizaciones nuevas y existentes de todo el mundo tengan una representación en cadena de su grupo, administren su actividad en cadena, gobiernen su propia toma de decisiones e (¡lo que es más importante!) Interactúen. con otros DAO. Actualmente hay alrededor de 100 DAO de Sputnik desde el lanzamiento inicial en febrero de 2021, con ~ $ 500k asignados y ~ $ 500k contenidos en las tesorerías colectivas (ver estadísticas aquí).

Consulte sputnik.fund y díganos lo que piensa. La próxima semana compartiremos una versión beta de V2 con una experiencia de usuario fresca, nuevas funciones y otro artículo con detalles sobre cómo Sputnik está resolviendo de manera única los desafíos clave de la organización de comunidades. Asegúrese de seguir nuestro medio para recibir notificaciones sobre V2.

Gracias al grupo de la comunidad inicial de Sputnik por las ideas para la v2; CERCA del equipo,

### Comment créer un jeu Play To Earn sur NEAR Protocol

Examen approfondi du prototype actuel — BerryClub



Ce guide est destiné à vous permettre de comprendre la dynamique de base qui vous permettra de créer un jeu pour gagner un jeu sur Near Protocol.
Nous ne voulons pas vous rendre riches, vous ou vos joueurs, mais les mécanismes de Near fonctionnent de manière à ce que les petites transactions soient très utiles sur une simple interface utilisateur HTML5 et créent un jeu agricole simple et amusant.
Nous analyserons un contrat intelligent et les fichiers js/rust derrière un jeu agricole existant, berryclub. Si vous appliquez la même logique à vos idées de jeu, vous obtiendrez peut-être des résultats encore plus amusants !
Pour suivre le côté technique de ce didacticiel, nous vous recommandons fortement de vérifier la figure Near Pathway pour créer une transaction et créer votre premier contrat intelligent sur Near, les concepts présents dans ces guides ne sont pas inclus dans ce didacticiel. Il vous sera beaucoup plus facile de suivre ce tutoriel si vous gardez un onglet ouvert sur le fichier source lié pendant la lecture de l’explication, car une grande partie du code mentionné est référencée avec des numéros de ligne mais n’est pas reproduite ici. Le dépôt original de BerryClub a été fork pour ce tutoriel afin de garder cet effort valide dans la mesure où le code fonctionne toujours sur la blockchain; comme vous le verrez dans la section suivante, le jeu lui-même a évolué au fil du temps et évoluera à nouveau, nous voulions faire un point sur son état maintenant.

L’interface du Berryclub
Berryclub est construit avec React, donc la toute première chose que nous allons aborder dans le fichier app.js situé dans le dossier src du référentiel github, cela nous fera gagner du temps dans l’analyse du contrat nous permettant de nous concentrer sur ce que nous devons extrapoler la logique en dehors du jeu réel (qui est amusant et joué par une grande communauté d’ailleurs).

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
Après l’import de React la première librairie nécessaire est bn.js un simple utilitaire pour gérer des entiers ou des nombres non décimaux, de nombreuses fonctionnalités peuvent venir sur votre interface avec cette librairie, tout d’abord ici elle est utilisée pour gérer les transactions :

const PixelPrice = new BN(“10000000000000000000000”);
Le jeu berryclub est basé sur l’économie immobilière, il y a un plateau géré par une partie du contrat appelé board.rs, il est subdivisé en pixels, et chaque pixel a un prix qu’il faut payer pour pouvoir puiser dessus. Les mécanismes de l’action « tirer » sont au cœur des capacités d’agriculture et d’auto-entretien du jeu et seront analysés en profondeur lorsque nous arriverons au contrat intelligent.
Comme vous pouvez le voir ici, le prix du pixel unique est déclaré comme une constante au tout début de notre application, et peut être modifié à l’aide des outils frontend et de la bibliothèque bn.j. La deuxième importation est le near sdk qui nous permet d’interagir avec la blockchain Near comme expliqué dans le Near pathway de Figment. La première utilisation de l’API NEAR est de déclarer les variables de contrat utilisées et de s’assurer que le réseau principal est utilisé lorsque le code est exécuté à partir de l’url du berryclub :

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Ensuite, nous importons les utilitaires d’interface utilisateur de réaction pour créer notre interface et permettre aux utilisateurs de dessiner, de réagir en couleur, de réagir en commutateur et de réagir en composé-timer. Le premier de ces utilitaires utilisé est le timer, il est utilisé pour définir un délai d’attente pour rafraîchir la carte sur la ligne 62.
Le « rafraîchissement » de la carte est effectué par le frontend pour afficher l’état mis à jour de la carte à l’aide d’un appel RPC au contrat intelligent.

const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
Ce que nous voyons ici, ce sont deux const de plus que celles nécessaires au rafraîchissement, les deux derniers sont en fait utilisés pour Farmer les pixels après les avoir dessinés, et définissent un créneau horaire d’une journée pour calculer les récompenses. D’autres const sont également déclarés pour gérer le Conseil en conséquence avec le contrat Smart, et ici, pour la première fois, nous croisons le concept de lignes, qui sera très important pour comprendre la gestion du Conseil et est l’élément le plus réutilisable de toute l’interface :

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
Comme vous pouvez le voir, après avoir subdivisé le tableau 50×50, nous disons à notre interface de récupérer uniquement les lignes suivant l’instruction RefreshBoardTimeout et de considérer la longueur de chaque ligne comme la largeur du tableau multipliée par 12, la taille d’une seule cellule.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Les pixels sont considérés par lots, et non indépendamment, à la fois lorsque l’action de dessin est appelée et lorsque l’interface est actualisée.
Enfin, nos importations incluent un composant d’interface utilisateur personnalisé, appelé Weapons,js : ce composant a été développé plus tard dans l’histoire de la communauté berryclub, afin que chaque utilisateur puisse télécharger et dessiner une image entière sur le tableau, et lancez-le sur le marché berrycards NFT.

Mécanique DeFi
Les lignes entre 27 et 51 sont une référence utile sur la façon dont cette Dapp construit ses capacités d’agriculture sur certains mécanismes DeFi de base qui seront analysés dans les dernières parties de ce didacticiel. À présent, nous mentionnons brièvement que pour dessiner/acheter un pixel, berryclub vous fait passer par quelques opérations DeFi sur ref.finance en utilisant ses propres jetons spécifiques, des avocats pour acheter des pixels et des bananes gagnées avec les pixels que vous avez achetés.







Il existe un simple clone uniswap créé pour échanger à proximité des bananes/avocats qui fonctionnaient sur le même contrat intelligent construit pour les autres jetons de ce jeu/prototype. Il existe également un jeton agricole créé pour le jeu, appelé concombre, il permet aux gens de gagner une partie des jetons que toute la communauté qui joue au jeu paie pour l’essence à puiser sur le plateau.







Le compte ou comment les utilisateurs gagnent de l’argent
C’est la toute première étape que nous faisons dans le code de rouille du contrat intelligent, mais j’ai ressenti le besoin de vous rappeler que la mécanique DeFi n’est pas la seule façon dont Berryclub vous permet de gagner des jetons. Le compte a un fichier particulier dans le contrat intelligent berryclub, nous n’avons pas besoin d’y entrer immédiatement, ce que nous devons savoir, c’est que certaines informations sont collectées dans l’objet de compte qui sont cruciales pour la mécanique agricole et de revenus :


 	identifiant de compte
 	accountIndex pour la liste (vecteur) des comptes qui ont touché le tableau de pixels pour la dernière fois
 	solde (vecteur pour plusieurs jetons possédés)
 	nombre de pixels
 	horodatage réclamé (nanosecondes, lorsque le compte donné a réclamé des récompenses pour la dernière fois)
 	préférences agricoles (bananes ou concombres)

Les deux dernières infos sont de calculer les récompenses à un moment donné, par exemple si vous possédez 5 pixels pour un jour vous acquérez 5 bananes. Si vous achetez auprès de quelqu’un d’autre, leurs revenus diminuent car le nombre de pixels qu’ils possèdent diminue, de sorte que le montant des revenus est calculé et l’horodatage renouvelé concernant le nouveau nombre de pixels possédés. Comme nous allons le voir, les récompenses sont calculées en fonction de ces deux variables. L’opération appliquée au compte du propriétaire précédent lorsqu’un pixel est dessiné s’appelle « toucher » et vous pouvez la trouver dans le fichier rouille account.rs. La propriété de l’unité de pixel unique est la base pour gagner sur berryclub, et de cette façon, cette mécanique est à peu près la même qu’une interface de jalonnement NFT pourrait utiliser, récompensant la propriété NFT.

pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
Pour dissiper tout doute, le propriétaire initial de la planche est 0, le contrat lui-même, et s’il n’est pas possible de trouver un propriétaire précédent, le contrat est utilisé comme propriétaire précédent. Enfin, pour démarrer le jeu, des jetons ont été stockés dans le compte du contrat et ils sont toujours augmentés en utilisant le prix du gaz établi pour que les gens achètent des avocats et des bananes, de sorte que le “coffre” du jeu soit toujours rempli de quelques jetons pour le utilisateurs à gagner. Revenons maintenant à notre interface.

Numéros aux couleurs et retour






Les lignes entre 67 et 82 sur app.js sont utilisées pour décoder les nombres en couleurs et inversement, afin que les éléments de l’interface utilisateur interagissent avec le tableau, deux variables constantes sont définies, intToColor et rgbaToInt. Ce que nous pouvons remarquer ici, c’est que pour transformer un nombre entier en une chaîne de couleurs, des méthodes sont utilisées pour diviser les 3 nombres pour le rouge vert et le bleu :

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
Pour inverser la chaîne de couleur en entier, nous appliquons simplement une fonction math.round() et utilisons l’entier résultant.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
Les lignes ci-dessous concernent le téléchargement et l’impression d’images sur le tableau à l’aide du composant d’arme et nous ne nous en occuperons pas en profondeur : imgColorToInt et int2hsv transforment les nombres en deux types d’échelles de couleurs, puis transparentColor est défini et un gamma pour le image à imprimer avec generateGamma. Dans decodeLine, nous transformons le tampon en un tableau de pixels à imprimer sur le tableau en utilisant les couleurs ci-dessus, en les parcourant avec for.

Premier constructeur React
Dans les lignes suivantes de app.js, nous définissons un constructeur qui définira les états que nous utiliserons plus tard dans notre interface utilisateur pour interagir avec la blockchain.

class App extends React.Component {
  constructor(props) {
    super(props);
L’utilisation de constructeur et de super nous permettra de l’utiliser. dans le constructeur. Les états définis ici sont la couleur et la palette de couleurs sélectionnées par défaut :







const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
Et pour le timer qui rafraichit le tableau :

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Ensuite, les états du compte d'utilisateur en cours d'utilisation sont définis, surtout si l'utilisateur s'est connecté, s'il y a des transactions en attente (définies comme en attente de Pixels), l'état boardLoaded chargera le canevas pour dessiner les états alpha et pickerColor sélectionnés. états des composants interactifs pour ajouter des couleurs au tableau, ainsi que pickingColor pour choisir la couleur du tableau et gammaColors est utile pour l'impression d'images sur le tableau avec les états WeaponsOn et WeaponsCodePosition.
Ces autres états sont utiles pour que le compte gagne sur le jeu, basé sur les pixels et basé sur DeFi :

owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
Alors que les trois derniers états configurent la minuterie pour une utilisation ultérieure :

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
La liste suivante (lignes 203-215) définit les objets et les actions qui vont interagir avec les états, faisant référence pour la première fois à un élément du DOM, le canvas.

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Enfin, nous définissons certains des états une fois la connexion terminée :

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Interactions de base
Nous commençons maintenant à décrire les interactions sur le tableau/la toile les reliant aux états précédemment définis. Pour ces interactions, nous utilisons des fonctions. Le premier utilisera notre référence précédente à l'élément canvas pour le créer et l'instruira avec des détails sur le type de mouvement de souris que nous autorisons à nos utilisateurs. Au premier clic, nous activons le mode veille pour que notre minuteur démarre :

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
Et le mode rendu d'image si l'utilisateur veut imprimer une image sur le plateau :

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
Le suivant est la partie importante, nous définissons comment l'interface lit le mouvement de la souris et du toucher sur le tableau :

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
Le code utilisé prend soigneusement en considération les utilisateurs mobiles à la fois, en créant une fonction ad hoc pour calculer la position et en ajoutant un écouteur au canevas/au tableau pour les événements tactiles : canvas.addEventListener(“touchmove”, mouseMove); Ensuite, ces interactions sont utilisées pour définir l'état de la cellule sélectionnée et suivre à la fois le début et la fin de l'action de la souris/du toucher sur le canevas ainsi que son mouvement sur chaque cellule :

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
L'interaction fonctionne ici sur les états précédemment définis, comme par exemple le sélecteur de couleurs nous permet de choisir des couleurs sur le tableau et de les utiliser ensuite pour dessiner. La clé utilisée par le sélecteur de couleurs est la touche alt et nous ne pouvons télécharger et imprimer des images sur le tableau que si le sélecteur de couleurs est désactivé, car nous déclencherons alors la fonction generategamma. De cette façon, la fonction pickcolor(), référencée à la cellule sera utilisable pour définir un seul pixel ou à la place l'ensemble du tableau pour restituer une image :

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
Maintenant, les gars, nous arrivons à l'essentiel, alors soyez prêt à commencer à plonger sur le contrat Smart. Nous savons comment dessiner le pixel dans l'interface, mais nous devons leur attacher les transactions pour que notre interface soit un véritable jeu à gagner. Alors s'il vous plaît faites très attention à ce que je m'apprête à dire, car même si votre jeu est complètement différent de celui-ci en termes d'interface utilisateur, les mécanismes de gain peuvent très bien convenir à tout autre type de jeu et seront expliqués ici de la manière la plus simple façon que je peux.




Smart Contract du Berryclub
Lignes :
Nous avons rencontré des lignes pour la première fois au début de cet article, tout en considérant les définitions des États de l'interface utilisateur. Les lignes sont un concept important de l'interface berryclub, ce sont les lignes par lesquelles le tableau/la toile est subdivisée et chaque pixel est un morceau de métadonnées. Ils font partie de l'interface utilisateur qui interagit avec le contrat intelligent et ils sont l'objet le plus réutilisable du jeu (par exemple pour créer des niveaux dans un jeu plus articulé), nous allons donc passer un peu de temps à analyser comment ils sont utilisé pour stocker les données du tableau et évalué pendant que les utilisateurs jouent au jeu.
Tout d'abord dans le fichier board.rs, nous trouvons une définition de PixelLine juste après la définition de Pixel :

pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
Un vecteur (array) de données de chaîne subdivisé par la largeur du tableau.
Et puis nous définissons dans le PixelBoard comme un vecteur des PixelLines de cette façon :

pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
Ainsi, chaque ligne est stockée dans le tableau en tant qu'enregistrement unique avec un champ de métadonnées appelé line_versions incrémenté à chaque fois que vous modifiez une ligne. Ainsi, chaque fois que notre interface récupère le tableau, vous obtenez 50 lignes mais également une métadonnée pour chaque ligne qui représente le nombre de fois que la ligne a été mise à jour, et en récupérant ces métadonnées, l'interface sait quel est le nombre de fois que la ligne a été modifiée, si la ligne a été modifié par rapport à la récupération précédente, vous récupérez les données pour chaque pixel, sinon vous ne le faites pas.

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
Il s'agit d'un moyen intelligent de stocker et de récupérer des données de l'interface qui peuvent être utiles à utiliser lors de votre prochaine partie pour gagner une partie near.







Les Transactions
Revenons un instant dans notre interface utilisateur dans app.js pour être sûr de comprendre comment les transactions sont gérées depuis le frontend. Nous avons d’abord besoin d’une fonction pour vérifier le compte si quelque chose ne va pas et c’est tout :

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Alors vous souvenez-vous des tableaux _queue et _pendingPixels que nous avons définis dans notre constructeur ? Il est définitivement temps de les utiliser car les transactions sont gérées en fonction des pixels que vous avez dessinés sur le tableau :

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Attendez, je n’étais pas prêt pour ce tas de code… Oui, vous l’êtes ! Mais regardons-le attentivement, nous créons un objet pixels (vecteur), nous modifions notre objet _queue pour ajuster les pixels et nous affectons sa valeur à l’objet _pendingPixel dans une fonction asynchrone.
Et maintenant quoi? wNous dessinons simplement sur un objet contrat qui est appelé depuis le sdk proche, et l’action pour dessiner (une partie des actions que nous avons définies pour l’utilisateur) est définie dans le fichier lib.rs rust.

pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
Pour le contrat intelligent, les pixels sont une couleur et un identifiant de compte (le propriétaire mystique), et c’est un jeu basé sur l’immobilier : nous avons donc un ancien propriétaire qui a dessiné le pixel avant et un nouveau propriétaire qui veut le dessiner maintenant. Avec l’action de tirage, nous obtenons le old_owner et le remplaçons par le nouveau compte propriétaire en changeant la valeur de couleur de tous les pixels à l’intérieur du vecteur PixelRequest, puis nous envoyons des récompenses à l’ancien propriétaire tout en chargeant le nouveau. Les horodatages des récompenses sont réinitialisés et le décompte recommence à zéro avec un pixel de moins pour l’ancien propriétaire et un de plus pour le nouveau. L’action setPixelRequest est définie dans le fichier board.rs de notre contrat, mais revenons à notre libs.rs.
À quoi ressemble la fonction may_send_rewards() ? Le voici dans toute sa splendeur :

impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
S’il vous plaît, ne soyez pas paresseux, si vous ne pouvez pas vous en empêcher, vous pouvez y revenir plus tard avec cette vidéo de l’auteur du jeu. Les explications que je vais utiliser sont également tirées de cette vidéo !
La fonction vérifie l’heure sur la blockchain (nous n’utilisons pas la minuterie sur l’interface ici, parce que nous voulons être sûrs !) puis appelle enfin get_expected_reward() pour calculer les récompenses dues au compte.

pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
Nous prenons donc le solde actuel du compte berryclub (rappelez-vous que nous avons un champ de solde sur le compte?), l’utilisation et les coûts de stockage actuels et un seuil de sécurité de 50 avocats. Si le solde est sûr pour une utilisation en dehors des coûts de stockage, nous le divisons en 24 (heures) * 60 (minutes) portion de récompense, ce qui signifie que vous obtenez fondamentalement exactement le même solde que vous avez une fois si vous l’appelez toutes les minutes, vous pouvez le trouver défini au début du fichier lib.rs :

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
Je parie que vous pensez que le processus de récompense est terminé. Tort.
Nous devons en fait revenir à notre fonction may_send_reward() pour voir qu’elle appelle le nouveau contrat de ferme berryclub pour distribuer les récompenses de jalonnement, qui sont… des concombres, le jeton de jalonnement sur berryclub 🙂

const FARM_CONTRACT_ID_PREFIX: &str = "farm";
Ce n’est en fait pas la seule source de revenus distribués avec cette fonction, elle tire également parti des coûts de gaz payés par les gens pour acheter des avocats et échanger des bananes afin de récompenser toute la communauté !
Comment est-ce possible? Tout d’abord, le GAS_BASE_COMPUTE est défini dans le fichier token.rs où la quantité de gaz pour le contrat intelligent est définie. Oui tu as raison! Le prix de l’essence est bas à proximité et il peut être utilisé pour récompenser les utilisateurs qui interagissent avec votre jeu vidéo !!!
Pour mieux comprendre le fonctionnement des frais GAS sur Near, veuillez vous référer à cette documentation détaillée !
Ce tutoriel vous est présenté par jilt.near et son projet NFT Gaming, soutenez-la dans l’achat de NFT !

### Dapplets × NEAR example

Dapplets × NEAR example is a Dapplet (an Augmentation App) that can parse Twitter posts and store them in the NEAR contract. It can also display your saved tweets on the overlay page.
1. Introduction
Dapplets - applications that interact with web-pages, augment them by inserting different widgets, parse the pages’ data and add some new functionalities. They can improve the user experience when using social media, video services and other sources.

Dapplets use the extension we are creating. This extension gives a simple API for dapplets developers and big abilities for the dapplets community. Our platform is decentralized. We use NEAR and Ethereum networks for our registries and contracts. We also use decentralized storages, like Swarm, IPFS and SIA for hosting dapplets code and multimedia.

To use our platform at first you need to install the Dapplets Extension . Currently it’s in the alpha-stage and is not published to Google Chrome or any other store. To install it follow this steps:

 	Open one of the following browsers: Google Chrome, Firefox, Brave, Tor.

The following steps are described for Google Chrome. The steps may differ in other browsers.

 	Download the Dapplets Browser Extension.
 	Open chrome://extensions in a new tab.
 	Switch the Developer mode on and press F5 to refresh the page.
 	Drag and drop the downloaded file into the extensions page. The extension will install automatically.If you are using Ubuntu or possibly another Linux OS the Dapplets extension can disappear from the Chrome Extensions after restarting the PC. To avoid this unzip the archive and use the Load unpacked button to add the extension.
 	Click to the Dapplets extension icon in extension bar. Try Dapplets × NEAR example dapplet.

2. Tutorial
Let's study how this dapplet works and why Dapplets is a NEAR frendly platform.

The goal of this example is to show the interaction between NEAR and Dapplets. If this is your first encounter with Dapplets we recommend trying our documentation first. It contains several exercises that explain how to create dapplets and adapters, from simple to complex ones. We highly recommend going through the ex01 and ex04 examples that describe how to create the most basic dapplets and dapplets with an overlay. The knowledge you will get will make it easier to understand the current example.

The initial code for this example is in a separate branch: exercise

You can clone this repo. It won't work directly. Try following steps to start it.

Let's look at the structure. There are three components: dapplet, overlay and contract.

Dapplet is the entry point of the application. It uses adapters for interaction with web-pages, defining contexts to augment and widgets to insert. You can find the core functions of the extension inside a dapplet. We use TypeScript in our project.

We define Overlay as a place where a user can do something with parsed data, connect to core dapplet's functions through the dapplet bridge and manage augmentation parameters. It is an impotrant part of the application, but it runs in another environment and is published as a separate bundle. In most cases we use React as one of the most popular frameworks. But you can use a framework that you prefer or pure JavaScript or TypeScript.

Contract does not connect directly with other modules and may be located outside of the dapplet. However, this simple NEAR contract is created specifically for this dapplet. This is why it's convenient to place it in the application structure.

Let'a look at the each module.
2.1. Dapplet
Look at the /dapplet/src/index.ts.

At first we create injectable class with decorator @Injectable and use @Inject to add the Twitter Adapter as the adapter class variable. Also create activate method. It runs when the selected adapter finds specific context and is loading. It will contain all the main logic.



Add the button to every tweet. Put this code to the activate:



Look at the code. We get widget button from the adapter. Then run adapter's method attachConfig. It receives an object with the names of contexts, that will be used, as keys. Values are functions that receive parsed context as the only argument and return a widget or an array of widgets. You may also return null, false or undefined.

Widget is a function that receives an object consisting of widget states. State parameters are described in the adapters documentation. You can find Twitter Adapter documentation here. In our case we add an image to the button and tooltip. exec is a function that runs when clicked. Now we just show the parsed context in the console.

Run the dapplet:


⚠️ Since the browser is blocking pages with problematic security certificates, go to https://localhost:3001/dapplet.json when the application is running and agree to run in insecure mode
Open the extension. Go to Developer tab and turn on the development server: https://localhost:3001/dapplet.json.



Turn on the Dapplets tab. You will see the dev badge near our dapplet. Turn it on.



Now you can see additional buttons on our tweets. Click on the button and open the console. You will see the parsed context of the tweet.



You've done it! Congratulations!!! Go back to the code.

We want to show parsed data not in the console but to the users. We will use an overlay for this. But before implementing the overlay, add the interaction logic between the dapplet and the overlay to the dapplet.

Let's change our code. Add private class variable _overlay of type any. In the activate add the following code:



Core function Core.overlay (typing problems will be fixed soon) receives an object with a name of the overlay and an overlay title and returns the Overlay object which we save in the _overlay variable.

Let's add openOverlay method to the class:



In this example we call the method send the overlay. It takes two arguments: the name of this data and the data to send to the overlay.

Add openOverlay to exec function and pass the parsed context to the overlay. This is the current code of the dapplet:



Open the manifest ./dapplet/dapplet.json.


⚠️ Since the browser is blocking pages with problematic security certificates, go to https://localhost:3000 when the application is running and agree to run in insecure mode.
Here we see the URL of the overlay named 'overlay' that will be used in developers mode. During the publication of the dapplet to the registry the overlay will be published to the decentralized storage.

We also see the Twitter Adapter in the dependencies. We are using the 0.9.0 version in the example.

Let's go to the overlay.
2.2. Overlay
As we previously mentioned, the overlay can be created in any way you want. We use React in most of our projects. We will not be analyzing the entire overlay code, but only the important points for our architectural aspects.

For interaction with the dapplet install the npm package @dapplets/dapplet-overlay-bridge:



To get the data from the dapplet we need the class Bridge in the overlay part. Look at the module ./overlay/src/dappletBridge.ts. Here is the onData method where we subscribe on the 'data' event, which we've described in the dapplet.



Then we use it in the App.tsx module.



Now save the changes and reload the Twitter page. When you click on the button you will see the overlay with the selected tweet data.



That's cool! But our goal is to save this data to NEAR chain and get it back. So let's see the contract.
2.3. NEAR smart contract
Look at the th module ./contract. There is a simple NEAR smart contract written in AssemblyScript with create-near-app.

In ./contract/assembly/index.ts we see one PersistentUnorderedMap named tweetsByNearId. It stores an array of serialized tweets data with the current user ID. It has methods for saving, removing and retrieving saved tweets.

You can find all the nessesary data about how to write, test and deploy NEAR smart contracts in the official documentation and Learn NEAR courses and guides.

Let's see how to connect to the smart contract and use its methods in the dapplet.

Add the following code to the activate method of the ./dapplet/src/index.ts module:



There is a Core.contract method that receives 3 parameters: name of the network ('near' or 'etherium'), contract name and object with view and change methods.

Now we will make the contract methods available in the overlay. In order to pass the methods through the dapplets bridge, add a listen function to the overlay call. Don't be afraid, just copy and paste this code :)



The last three asynchronius functions pass our contract methods to the overlay. The first four functions need to pair the wallet to the dapplet. To get the Wallet object we use the Core.wallet method, with named parameters name (near or ethereum) and network. The wallet has methods isConnected, connect, disconnect and parameter accountId.

The next step is to change ./overlay/src/dappletBridge.ts. We have to make functions that were described in the dapplet, available in the overlay. Copy the following code to the Bridge class:



Now we can use contract methods in the overlay modules. We can authorize the dapplet with the NEAR testnet wallet and save the data of the selected tweets to the smart contract. We can also see our saved data in the overlay.

Uncommit all the commited code in the ./overlay/src/App.tsx. Save changes and reload the Twitter page.



A cherry on top will be the addition of the ability to view saved tweets without parsing new ones. To do this, it is enough to add the Core.onAction method to the activate in ./dapplet/src/index.ts and pass the function of opening the overlay to it.



Now you will see the home icon near the dapplets name.



A click on the button opens an overlay with saved tweets.



Congratulations to everyone who made it to the end of the tutorial! We hope it was successful.

Here is the result: dapplets-near-example

If something didn't work out for you, or you still have some questions, you are welcome to our chats in Discord and Telegram.

Thank you for your time. We hope this new knowledge will be useful, and you will go on to develop impressive and successful applications on the Dapplets platform using the capabilities of NEAR protocol 🚀✨
Contacts:
Web: dapplets.org
Docs: docs.dapplets.org
GitHub: github.com/dapplets
Discord: discord.gg/YcxbkcyjMV
Telegram: t.me/dapplets
Twitter: @dappletsproject

### Update - November 2, 2021

Brief Summary:

 	UPtober was a BLAST for LNC


Results:

 	October Redeem to NEAR window was the biggest so far
Over 150 genuine (L)Earners got 4 NEAR! Congrats and happy (L)Eanring!
 	October NEAR Certified Developer Live Demo session brought us 5 projects.
Check the LNC GitHub repo to explore the code - https://github.com/search?q=topic%3Ancdl1+org%3ALearn-NEAR-Club+fork%3Atrue

 	Added 6 NCDL1 projects to LNC GitHub - kudos to hard working Chinese community!
 	Get yourself  NEATAR on Testnet https://learnnear.club/neatar/
Members with default profile pic may be not be able to participate in Redeem Window


 	Those who are interest in Rust - check these SUPER eye opening Guides by ek.near
NEAR Live Contract Reviews

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC updated website is coming!

### NEAR Live Contract Review | Part 4: Berry Farm

Introduction
This is Eugene, and today we're going to talk about the Berry Farm contract which is the supplement of Berry Club that allows you to convert your bananas to cucumbers, and farm NEAR. Let's first do a quick review of the Berry Farm. The repository can be found on my Github. Here is the original video which this guide is based on:


UI


 

Berry farm is a very well designed app with large text, and lots of emojis. The way it works is that it displays your balances once you're logged in. It pulls it from two different contracts as well as your account. It combines them from multiple sources. Avocado and bananas come from the Berry Club contract, cucumbers are local for that contract, and NEAR comes from your account balance. If you formed anything then you get rewards when rewards are distributed. It seems that someone made a lot of avocado purchases recently, and the rewards actually increased. It also has global stats which means 2 500 NEAR was transferred from Berry Club to Berry Farm. I earned 116.9 NEAR and my reward is going to be 0.014332 NEAR based on the amount of cucumbers I have compared to the total number of cucumbers. 



The total number of cucumbers is 54116.4. I get a 3% share of this reward every time there's a reward. So when I click refresh I basically refresh stats from multiple accounts, and I can claim NEAR which it transfers from from the contract to my account. I can also swap bananas to cucumbers and I'm doing a call to the Berry Club contract.





I'm going to transfer_with_vault which is using the new standard, and it requires a small amount of NEAR, and I think it's like 1 yocto NEAR to confirm that I'm not doing this through an access key.  I cannot make a transfer through an access key in oreder to avoid automatic withdrawing, and this is just a safety guard. If you would, for example, authorize Berry Club from some other app that tries to drain all of your bananas it would fail, because it will not be able to call transfer_raw or transfer_with_vault. To clarify, transfer_raw is the new name for transferring without a contract so you can just deposit with someone’s account that exists, and in transfer_with_vault vault is calling the receiver to withdraw tokens. 



I spent 10 bananas to get more cucumbers, and I can refresh the balance again to see if someone withdrew something. That's how the UI works, but there's more functionality to this than just this. The contract supports cucumbers as a fungible token, also bananas. You can potentially build another app that transfers cucumbers and there's one more which is Banana Swap that Vlad Garchina built.



It is a simplified uniswap with a single pool where you can buy and sell bananas. I actually haven't tried it before. I want to get 1 NEAR worth of bananas which I need to sell for 6 bananas. Let's see if it works.





It calls Berry Club transfers which is once again involved, but to a different contract. We currently don't display arguments, but eventually we will.



It's saying I transferred, and I got 1 NEAR which I spent 6 bananas on. Pretty cool.



You cannot add to liquidity and it takes a 10% cut. So this is the UI.
Contract Review
Berry Club
Let me present the contract. So we'll start with the Banana Farm contract, but you will probably need to take a look at the token contract from pixelboard, the contract from Berry Club, as well as the one that sends tokens. 



Berry club has a hard-coded contract called farm contract id.



When you draw, it verifies that you don't draw empty pixels otherwise you can just trigger a reward without spending avocado. 



Then it calls maybe_send_reward which gets the current time from the blockchain, and checks that the next_reward_timestamp is less than the current time.



The next reward is either the beginning of farming time which was a global timestamp that originally enabled a 26 hour countdown or last_reward_timestamp when we last triggered it plus 60 seconds. 



So if it's time to send the next reward it remembers the current time, and it calculates the reward based on this logic so it takes the current balance of Berry Club, it takes the current storage, computes storage by the storage cost plus some safety bar safety margin, which is 50 NEAR. 



It always keeps 15 NEAR for the future balances. Then it's saying if balance is available, if our balance is higher than the amount we need for storage plus safety, then we calculate liquid balance, and we divide it by the portion of reward that we will give every time which is 24 times 68. If you would call it every minute then you will drain the majority of the account, but it is always kind of decreasing on itself, because the balance decreases on itself, but it mostly gives all balance within a day if you would call it every minute. First of all, you cannot produce a block that is timestamped earlier, and then you cannot produce a block beyond your slot, you have a dedicated slot when you need to produce a chunk. So the most you can do is produce a chunk of the final block at the final millisecond of your slot, which is one second ahead. You cannot really move it way forward otherwise all the other nodes will break the protocol as well, so they are limited by their understanding of the time plus the bar that they use to decide whether to accept a block or not, so you can't really make a time run faster unless all validators want to do this. This would mean we have the validators which will essentially stop following the protocol. They need to coordinate their time. 



So at the end it got the reward it's saying I'm going to distribute this reward, and what it does is it calls the farm contract, and calls take_my_near and it just doesn't pass any arguments and passes its reward and gas. Just a minimal amount of gas needed to add the balances. That's how Berry Club was updated to start distributing rewards after every drawing potentially. It takes slightly more. It uses gas that was spent on drawing to actually distribute the reward occasionally which needs about 10 tera gas for this. 
Berry Farm
Let's go to Berry Farm and start with this contract.  The way that berry farm works it needs to, in constant time, be able to distribute rewards based on the total number of cucumbers which is not a trivial task, it's somewhat similar to the staking pool, and how the staking pool distributes rewards. The staking pool creates a bunch of shares for every deposit you make and the share has a current global price that's saying, “Hey I purchased or minted more shares, and now my shares can be redeemed towards a given number of NEAR tokens.” The share price is starting from 1 yocto NEAR per share, and then the more rewards you accumulate the more the price of shares goes up. When you use unstake, you sell shares at the current price, and you get NEAR back, and it's unstaked, and it  rounds down. The challenge there is when you stake cucumbers the price of a cucumber is zero, and when you first stake them  you cannot really buy shares and mint shares, because the price of them is zero. The logic of shares doesn't work very well for this so for this thing I needed to create something different to do the accounting. Let's go into examples. Let's say Mike is the first person who deposited 10 cucumbers to the contract, and then let's say 100 NEAR was distributed. Mike will take all the rewards because he is the only one, he controls 100% of the share on the Berry Farm now. Mike was offline for example, and didn't claim them, so we cannot really update his account, because it has to be done in constant time. We cannot iterate through all of the accounts, but we somehow need to remember that Mike got all NEAR for his cucumbers. Now let's say Josh comes in and stakes another 10 cucumbers now Mike's share is 50% and Josh's share is 50%, but Josh staked the cucumbers after this initial 100 NEAR was distributed already. He is not entitled to any of this now another 100 NEAR drops Mike now needs to get 50 more, because he has 50% stake and Josh gets 50 NEAR. When Mike comes back online we need to be able to display his balance at 150 NEAR that he earned in constant time. So this is the challenge that we needed to address with this contract, and the way it was solved is by having a global ratio called near per cucumber which is saying how much NEAR is received by a given cucumber balance when an account is created, or touched in any way. We remember the last value of this fraction. 



Then we have a NEAR balance, so if the last fraction was lower than the current fraction, it means we can multiply cucumbers of the given account by the difference between 2 fractions, and calculate how much NEAR I'm entitled to. When mike's account was created the fraction was 0 divided by one and when 100 NEAR was deposited where the total cucumber count was 10, this fraction became equal to 10. Then once Josh joined and dropped another 10 cucumbers to the total, and another 100 NEAR were distributed, this fraction was increased by 5, because there was a total of 20 cucumbers and 100 NEAR. So 100 NEAR divided by 20 it means 5 NEAR per cucumber so this became 15. Now when Mike comes back he looks at his cucumber balance which is 10 near per cucumber on a global contract is 15 his last remembered value is zero so he just takes the difference which is 15 multiplied by 10 and claims this balance into NEAR, and this 1 is set back to 15. When Josh comes back, he gets this value which was at 10, and he has 10 cucumbers and the current value is 15. The difference is 5 multiplied by the cucumber balance of 10 so he gets 50 NEAR. That's how we manage the NEAR balance, and appropriate the rewards received from people using constant time to recalculate it. So instead of keeping an entire fraction in memory so we use a global denominator which is fixed and I used it to 10 to the power of 18 which is the same as the precision of cucumbers, bananas and avocados. That's the background of  how it's all computed.



Let's look at the main structure of the contract, a contract called farm. It has a lookup map of accounts, and it uses short hashes similar to fungible tokens with vaults. It has the banana token account id which can be hardcoded as well, but it was used from the contract because we can actually pass it, because this account was deployed after and I didn't want to upgrade the banana Berry Club contract state. I didn't want to modify the state again through upgradeability so instead I hardcoded the value in the previous contract. Near per cucumber, the fraction that I explained earlier, is the numerator and total cucumber balance is needed as a denominator. Vaults and next vote are used for transfers; they actually probably never ended up getting used to transfer cucumbers except maybe once for a test. 



This is what we saw before this is once again a hash of the account id.



The account structure is the last value before the account was touched with this fraction. The near_balance is the unclaimed balance. Whenever you touch an account either by depositing more cucumbers, or claiming NEAR it updates last value and moves all of the unclaimed NEAR to your local balance out of the difference, and cucumber balance is your balance in cucumbers. The near_claimed is the statistics, that is just saying how much reward you already claimed. It's not needed for contract logic. 



There's two helper structures just for the front end. The HumanAccount returns values in a more readable way and HumanStats is global statistics for consumption. Let's go into the take_my_near function to actually take a look at how it works.



The first thing we do is check that there's enough cucumbers there, because we use it as a denominator. We just want 1 cucumber to actually trigger this, and this is just a precaution. You don't like to trigger this type of stuff. Let’s explore this value. What happens is you get the amount of NEAR, and yocto NEAR, and you multiply it by the denominator global. So you're solving a fraction which is NEAR per cucumber divided by the denominator plus attached balance divided by total cucumber balance. Here is the formula: near_per_cucumber / denom + attached_deposit / total_cucumber_balance. So new_near_per_cucumber is actually the numerator with attached_deposit and the denominator then divided by the denominator. Here is the formula: new_near_per_cucumber = (near_per-cucumber_numer +denom + attached deposit) / denom. This is the formula we use to calculate the new_near_per_cucumber. Whenever you touch an account it always makes your current unclaimed balance into a fixed number, and then you can modify any of the values without breaking the logic. This touch method is called by every getter and every change method. Before you modify the account, it always calls touch on the account.



For example, in get_near_balance we get the internal account. If the account exists then we touch it locally. Then we should get the near_balance



If you get the account we touch it before then get your near_balance, cucumber_balance and claim balance. Those are view functions that are changing things, but it doesn't save it so it just temporarily changes the account value, and doesn't save it back. It just makes a touch which is a kind of  recompute with the latest value. 



It saves it when you actually do any change call, so for example call to claim_near. We get your account and get_mut_account actually touches the account. You get the account that is already updated, and near_balance is the actual balance. It takes the near_balance to zero, it's saying you claimed all of this, and it saves your account. Then if you claim positive value then we will transfer it to you out of your account. It returns how much NEAR you claimed. The beauty of this touch method is that it can be called at any point. It doesn't have to be called at the given point, so it is always gonna give you the same result no matter whether you called it twice in the middle or called it once. This is just for returning to the user like how much they've got. It just tells you how much NEAR you earned by calculating from the current state. In Berry Club we do the same stuff we have touch as well, and this is needed, because let's say you want to know how many bananas you farmed. Since we know the last time you touched your account, when you last drew something, we know how many pixels you have. We can calculate from a given time to the previous time multiplied by the number of pixels you had how many bananas you should have right now, and the front end just does the same thing. The front end simulates it, it gets the same info except the latest, and then it just creates a timer going forward that calculates it. In theory the get_near_balance method doesn't have to return your NEAR value that is up to date it, can just say here's the total NEAR per cucumber and your last total NEAR per cucumber and also your last NEAR balance, but instead it's done on the contract level. Let's say we didn't have view methods for which you don't pay and only return and retrieve a state, then you would have to do this logic on the front end instead of doing it here in memory. 
Token.rs
The final logic that we need to do is actually how you receive your cucumbers from Berry Club, and this is done by using transfer_with_vault from Berry Club. We previously discussed how map 122 works. 



You pass the receiver_id, amount,  and payload. It has an assert_paid check which just checks that the deposit is positive. It's saying oh you need at least 1 yocto NEAR to prevent function access key calls to avoid a malicious Berry Club UI draining all your bananas. It gets the gas and then it initiates a call that  puts bananas into a vault. It also initiates a call to the receiver. In this case we call it an on-farm contract and it passes the sender id  an amount of bananas, a vault id which is just a u64 without JSON, and a payload which is a string. In the previous example, when we were talking about map 122 the payload was a binary of vec q8 in base64, because it was a borsh serialized payload. During the discussion I noted that if you would review this argument in a wallet you will not be able to see the payload that you want to do, so in this contract implementation we actually use JSON for the payload so that we insert the JSON from the string payload.  It's an enum with a single option called deposit_and_stake.



Now when you do a function call from the farm UI that will go to the wallet in the arguments the payload will be like an adjacent string within a string saying deposit and stake instead of being some zero encoded as a base, instead of being a borsh serialized version, it's a human readable one. This contract has different payload types than Uniswap, for example, it will have a payload saying how much NEAR you want to receive at most or receive at least. The malicious Uniswap UI can just actually replace this value, and if you didn't verify it on the wallet side then you may actually get dropped under the front trend.  We got the account using get_mut_account which gets either an existing account,  or creates a new account where it sets all balances to 0, but the last near per cucumber numerator to be the current global one. This means you didn't farm anything and you have zero cucumber balance. It does touch anyway even if it doesn't need to, we could have avoided it if we did map,  and then it returns the hash and account. The account is already up to date. What we do is we first increase the total cucumber balance and then we save it back to the state of the account and we also increase the global cucumber balance by the amount of cucumbers deposited. Then we don't really verify that the vault contained cucumbers so we trust that the previous caller, which is a banana contract, actually put the bananas into the vault, and we return the promise out of this method. It's a weird match with a single entry because payload can be only one type right now. We call withdraw_from_vault, we state the amount we want to withdraw which is the full amount, and then we call it back to the banana token account id which is a Berry Club contract. Even so, this contract didn't receive bananas yet, it doesn't care because it doesn't use bananas anyway. It doesn't need bananas before it can proceed, so no matter how long it's going to stake cucumbers on there, and the vault is already locked. It increases the total cucumber balance by diluting the shares. Now when take_my_near arrives it will use the new total cucumber balance. Now I will split the number of shares across all participants. 
Conclusion
That’s the overview of the Berry Club, Berry Farm and token.rs contracts. Thank you for reading and good luck in your future endeavors with NEAR.

### Ce que vous pouvez faire sur le protocole NEAR

Dans l’espace crypto, Ethereum domine en tant que plate-forme de référence en matière de contrats intelligents, d’applications décentralisées et de finance décentralisée. Cependant, Ethereum n’est pas le seul protocole dans l’espace des contrats intelligents et des applications décentralisées, avec plusieurs autres protocoles dans l’image. Même si Ethereum est la plate-forme numéro un dans l’espace, elle présente de nombreux défauts, tels que des frais de gaz extrêmement élevés et des problèmes d’évolutivité importants.
NEAR Protocol est l’une des blockchains qui peuvent rivaliser avec Ethereum en allant directement à la lacune la plus flagrante du protocole, son manque d’évolutivité, en utilisant ce que l’on appelle le sharding. Cela permet à NEAR d’augmenter son évolutivité de manière exponentielle. Le protocole a également levé des fonds importants et compte le fonds a16z d’Andreessen Horowitz parmi ses bailleurs de fonds.

Un examen plus approfondi du protocole Near
Le protocole NEAR est une plate-forme de développement décentralisée fondée en 2018. NEAR crée l’environnement parfait pour les applications décentralisées et les contrats intelligents en se concentrant sur les lacunes des autres protocoles dans le même espace. Nous avons déjà mentionné les lacunes précédemment. NEAR utilise le protocole NEAR, une blockchain Proof-of-Stake connue pour être publique, conviviale pour les développeurs et fragmentée. Le protocole est une plate-forme peu coûteuse et hautement évolutive que les développeurs peuvent utiliser pour créer des applications décentralisées (dApps). Les autres fonctionnalités que les développeurs peuvent utiliser incluent les applications de portefeuille et les composants d’interopérabilité qui permettent aux développeurs d’utiliser facilement l’ écosystème NEAR et de créer des applications.
NEAR présente Doomslug, un mécanisme de génération de blocs qui a été proposé en 2019. Il permet une finalité pratique ; les blocs de sens peuvent atteindre la finalité en quelques secondes. NEAR fonctionne sur la même technologie qui alimente des technologies comme Bitcoin et la combine avec des fonctionnalités telles que le sharding de base de données. D’autres blockchains centralisent le traitement ce qui signifie qu’il se limite à du matériel très haut de gamme. Cette approche ne fournit qu’une augmentation temporaire du débit. D’autre part, NEAR évolue de manière linéaire et peut prendre en charge même des milliards de transactions de manière complètement décentralisée.

Caractéristiques importantes de NEAR
Le protocole NEAR est développé par le collectif NEAR. Certaines des caractéristiques du protocole sont les suivantes.


 	NEAR en tant que protocole est simple à utiliser et les développeurs peuvent facilement et rapidement créer des applications dessus
 	NEAR permet une évolutivité presque infinie grâce à l’utilisation du sharding
 	Near est un protocole de couche 1.

Comprendre le collectif NEAR
Le collectif NEAR, communauté de chercheurs et de développeurs, est à l’origine du développement du protocole NEAR. Le collectif travaille en permanence au développement et à l’amélioration du protocole NEAR et a également travaillé sur des projets tels que l’écriture du code initial du protocole et la mise en œuvre du réseau NEAR. Le protocole NEAR fonctionne de manière totalement indépendante et décentralisée, et même les développeurs et les chercheurs qui l’ont construit ne peuvent pas le fermer.
Le Collectif NEAR est composé de la Fondation NEAR, qui est une organisation à but non lucratif créant un écosystème autour du protocole NEAR. Le collectif NEAR contribue aux activités de développement et de gouvernance du protocole. Le protocole NEAR n’est qu’un des nombreux projets du collectif.

Que pouvez-vous faire sur le protocole NEAR
Le Near Protocol permet aux utilisateurs d’accéder à plusieurs projets et protocoles allant des NFTs aux DAO et DeFi. NEAR a développé un écosystème natif dynamique avec plusieurs projets qui sont déjà opérationnels sur le protocole, tandis que d’autres projets sont en cours.

Premiers pas avec NEAR
Pour commencer avec NEAR, la première chose dont vous avez besoin est un compte NEAR . Vous pouvez apprendre comment créer un compte NEAR ici. Une fois que vous avez créé votre compte NEAR, vous pouvez le connecter à votre portefeuille NEAR, ce qui vous permet de passer des appels contractuels à la blockchain, d’envoyer ou de recevoir des fonds et de configurer les nœuds locaux. Pour créer un compte NEAR, vous devez disposer d’au moins 0,2 NEAR ou 0,62 USD pour pouvoir conserver votre place sur le réseau NEAR.

Le jeton NEAR
Il existe deux manières d’obtenir des jetons NEAR ; vous pouvez soit les gagner, soit les acheter directement. Les jetons NEAR peuvent être gagnés en participant au réseau, en participant à des primes de développement ou en exécutant des nœuds communautaires qui peuvent permettre aux membres de la communauté de s’appuyer sur NEAR. Vous pouvez également acheter des jetons NEAR disponibles sur tous les principaux échanges de crypto-monnaie.

Que pouvez-vous faire avec les jetons NEAR
Le jeton NEAR vous permet d’effectuer plusieurs tâches ; vous pouvez transférer des jetons NEAR entre les comptes et suivre les transactions sur l’explorateur de blocs. Les frais de transaction sur NEAR sont extrêmement bas, ce qui vous permet de déplacer facilement des jetons. Vous pouvez également envoyer NEAR à toute personne ayant besoin de créer un compte NEAR en utilisant NEAR Drops. Les jetons NEAR vous permettent également d’accéder à un nombre croissant d’applications construites sur NEAR. Ils peuvent également acheter, publier ou échanger des NFTs et de l’art numérique sur NEAR ou créer des créations artistiques collectives .

Staking
La communauté NEAR peut soutenir les validateurs via le Staking. Les validateurs sont les utilisateurs qui exploitent des nœuds qui aident à faire fonctionner le réseau NEAR. Les validateurs sont tenus de maintenir un montant minimum misé afin qu’ils puissent rester en tant que validateurs. Les détenteurs de jetons sur NEAR peuvent miser avec un validateur de leur choix et gagner une récompense grâce aux jetons générés par le réseau. Les utilisateurs peuvent miser en suivant les étapes suivantes


 	
Sélectionnez Staking dans la barre de navigation et choisissez un validateur

 	
Confirmez les options que vous avez sélectionnées, puis sélectionnez « Stake with Validator »

 	
Choisissez le nombre de jetons NEAR que vous souhaitez miser et cliquez sur « Soumettre ».


Ce que vous pouvez faire sur l’écosystème NEAR
NFTs 
Les NFTs ont gagné en importance dans le grand public. Bien qu’Ethereum soit le principal acteur en ce qui concerne les NFT, leur entrée dans le grand public a également mis en évidence les frais de gaz élevés d’Ethereum, ce qui les rend assez peu pratiques. Le protocole NEAR est une alternative viable et a déjà plusieurs projets en cours sur sa plate-forme. L’évolutivité du protocole garantit que le développement des dApps est rapide et facile. Actuellement, il existe 19 plates-formes décentralisées pour l’échange NFT sur la plate-forme NEAR. NEAR est également nettement plus rapide que les autres acteurs de l’espace NFT et a des coûts de transaction extrêmement bas.
Le protocole NEAR peut être décrit comme la plate-forme parfaite pour les NFTs et présente plusieurs avantages par rapport aux autres plates-formes NFTs dans l’espace et même à Ethereum. Le protocole NEAR peut traiter les transactions beaucoup plus rapidement qu’Ethereum et, contrairement à Ethereum, il ne souffre pas de frais de gaz élevés ni de congestion du réseau. Les transactions sur NEAR sont traitées presque instantanément avec un coût négligeable. Tous ces facteurs rendent NEAR idéal pour acheter et vendre des NFTs et incitent différents projets à construire leurs NFTs sur NEAR. Il existe déjà plusieurs projets NFT en cours d’exécution sur NEAR, tels que Mintbase et Paras .

Créez et vendez des NFTs via Mintbase
Les utilisateurs du protocole NEAR peuvent utiliser plusieurs des projets NFT pour acheter, vendre ou créer des NFTs. L’un de ces projets, Mintbase, permet aux utilisateurs de créer un NFT et de le rendre disponible à la vente sur des marchés tels que OpenSea. Les utilisateurs peuvent créer des contrats intelligents pour limiter la transférabilité des jetons, ce qui aide à prévenir la fraude et le transfert illégal d’actifs.
Mintbase est passé de la blockchain Ethereum au protocole NEAR en raison des frais de gaz élevés de la première. Initialement, les frais de gaz sur Ethereum étaient faibles et les utilisateurs pouvaient se déployer rapidement, mais avec l’augmentation de l’utilisation et de la congestion sur Ethereum, les coûts du gaz ont commencé à devenir incontrôlables. Il y a plusieurs autres raisons pour lesquelles Mintbase a choisi NEAR Protocol.


 	NEAR utilise Rust ou AssemblyScript pour coder des contrats intelligents, permettant aux développeurs d’écrire du code facilement.
 	NEAR a des adresses lisibles par l’homme pour les contrats et les comptes intelligents.
 	Les développeurs peuvent utiliser les gouttes NEAR et les utilisateurs embarqués facilement et rapidement. Ils peuvent également payer leurs comptes NEAR et envoyer ou recevoir des jetons NEAR.
 	Les développeurs peuvent utiliser le rainbow bridge ETH-NEAR et déplacer rapidement leurs actifs.

Créez, trader et collectionnez des cartes d’art numérique
Paras est un marché de cartes numériques basé sur le protocole NEAR qui fournit aux utilisateurs une solution pour le vieillissement des cartes de collection traditionnelles. Il valide la propriété via la blockchain grâce à des transactions rapides et peu coûteuses. Il se différencie également en proposant des collections au lieu de versions autonomes. Paras est bénéfique pour les collectionneurs car il réduit considérablement le fardeau des collectionneurs en garantissant que leurs objets de collection ne s’usent pas. Les artistes et les collectionneurs peuvent facilement accéder au marché des objets de collection.
Depuis le lancement de Paras, nous avons vu des artistes gagner plus de 25 000 $, la plate-forme pouvant traiter plus de 700 transactions, ce qui lui a permis de faciliter un volume de transactions de plus de 35 000 $. Actuellement, la plateforme compte plus de 70 artistes et 80 collectionneurs. Le protocole NEAR et Paras conviennent parfaitement, car les créateurs de NFT recherchent des alternatives à Ethereum avec ses frais de gaz élevés. Les transactions sur NEAR ne coûtent presque rien et peuvent être effectuées en quelques secondes, tandis que le Rainbow Bridge assure l’interopérabilité entre Ethereum et NEAR.

Explorez et vendez aux enchères des collections NFT
Hip-Hop Heads est le résultat d’une collaboration entre le NEAR Protocol, Ed Young et le Universal Hip-Hop Museum. La collection NFT présente des artistes des années 70 à nos jours et comprend 47 des plus grands artistes du genre rap. La collection honore à la fois les artistes et marque également la 47e année de l’ère Hip-Hop.
NEAR permet à la collection d’être plus accessible à la communauté, et la vente aux enchères présente de nouvelles éditions des 103 têtes de hip-hop. Les membres de la communauté peuvent facilement acheter les NFT via une carte de crédit sans système d’intégration compliqué.
Les utilisateurs du protocole peuvent accéder à plusieurs autres projets NFT sur NEAR, tels que Metamon, WebAssembly Music, Snark.Art, etc. Metamon crée un univers de monstres que les utilisateurs peuvent capturer, évoluer et jouer avec. Les monstres sont classés comme des créatures en voie de disparition et en édition limitée qu’un groupe sélectionné de collectionneurs NFT peut adopter. Les collectionneurs peuvent combiner deux du même type de Metamon et le regarder évoluer vers un Metamon plus rare et plus puissant.
WebAssembly Music est la première musique stockée sur la blockchain en tant que NFT. La musique est créée par Peter Salomonsen et est publiée sur le protocole NEAR. Le morceau de musique a été parmi les premiers morceaux de musique à être rendus sur un binaire WebAssembly exécutable. Les utilisateurs peuvent exécuter le fichier binaire WASM et obtenir les données audio brutes via un runtime WebAssembly.



	

	
	
		
			
				NEAR uses the following to code smart contracts:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust or AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi On NEAR 
Comprenons d’abord que DeFi, DeFi ou Decentralized Finance fait référence à un système financier complètement décentralisé qui utilise des blockchains comme Ethereum. Il se compose d’actifs tels que des applications décentralisées, des protocoles DeFi et des contrats intelligents. L’objectif derrière DeFi est de créer un système financier open source, sans autorisation et décentralisé qui fonctionne indépendamment de la juridiction de tout tiers ou autorité centrale. DeFi donne aux utilisateurs un accès facile aux services financiers et est particulièrement avantageux pour les personnes qui n’ont pas accès aux services bancaires.
NEAR apporte DeFi aux masses avec plusieurs projets en direct sur le protocole, avec des projets allant des projets DeFi, DEX, Oracles, etc. Voyons comment vous pouvez utiliser certains des projets sur NEAR.

Accédez à presque toutes les chaînes compatibles avec Rainbow Bridge
Le Rainbow Bridge agit comme un pont entre NEAR et Ethereum et est un protocole sans permission et sans confiance qui connecte deux blockchains différentes. Les utilisateurs peuvent facilement déployer un nouveau pont ou rejoindre un pont existant sans avoir besoin de l’approbation d’un tiers. Le Rainbow Bridge permet à toute information pouvant être utilisée sur NEAR d’être utilisée dans les contrats intelligents Ethereum et vice versa. Cela permet également aux utilisateurs de voter avec ETH sur un DAO basé sur NEAR sans passer par Ethereum.
Le Rainbow Bridge est facilement accessible pour les utilisateurs, grâce à une conception intuitive, et directement intégré via MetaMask. Le Rainbow Bridge peut également être réutilisé et se connecter NEAR avec presque toutes les chaînes compatibles Ethereum. Le Rainbow Bridge cherche également à prendre en charge les chaînes non EVM telles que Bitcoin.

SputnikDAO 
Les DAO sont extrêmement importants lorsqu’il s’agit de la stratégie de gouvernance d’un protocole. SputnikDAO permet aux communautés et aux individus qui composent l’écosystème NEAR, agissant comme infrastructure pour les DAO sur le protocole NEAR et permet aux individus et à d’autres projets de lancer des DAO, de mettre à niveau les contrats intelligents de protocole et de configurer facilement la gouvernance pour la gestion de trésorerie. SputnikDAO permet également aux projets de mettre en place une gouvernance à signatures multiples ou d’émettre des jetons de gouvernance ou de combiner les deux et de les utiliser ensemble
Sortir et Mint Audio NFT avec DAOrecords
DAOrecords prévoit de devenir le premier label de disques décentralisé au monde et utilise actuellement un modèle hybride. Le projet a continuellement expérimenté les NFT audio, le projet ayant publié 350 NFT et travaillé avec plus de 60 artistes jusqu’à présent. DAOrecords veut contrôler la musique des artistes qui l’ont créée et changer la façon dont ils interagissent avec leurs fans.
Les artistes indépendants peuvent sortir de la nouvelle musique en utilisant les NFT audio et les services de streaming de DAOrecord. Ils peuvent également créer leurs NFT audio. DAOrecords a déjà publié un NFT audio interactif appelé « MintTape Vol 1 ».

Accéder aux prêts via Aave
Aave met en œuvre une stratégie de prêt basée sur un pool au lieu d’une stratégie décentralisée peer-to-peer. Les prêts sur Aave ne sont pas appariés individuellement. Au lieu de cela, ils s’appuient sur des fonds communs et sur les garanties ainsi que sur les montants empruntés. Aave a été lancé en novembre 2017 en tant que plate-forme de prêt peer-to-peer et rebaptisé Aave en septembre 2018. Le protocole a été mis en ligne sur le réseau principal et compte près de 6 milliards de dollars bloqués dans des contrats intelligents et figure dans le top 3 des projets de la DeFi. espacer.
Aave propose des prêts flash, qui sont essentiellement des prêts non garantis qui sont empruntés et remboursés en une seule transaction, ce qui signifie que les utilisateurs n’ont besoin d’aucune garantie pour le prêt, tandis que l’emprunteur rembourse le montant initial emprunté et une somme modique. Aave a introduit les prêts flash, où n’importe qui peut emprunter des liquidités, les utiliser avec d’autres protocoles et les rembourser en une seule transaction. Les prêts flash sont essentiels dans l’espace DeFi car ils permettent aux particuliers d’accéder à des liquidités sans avoir besoin de garanties.

Accédez aux flux de données avec Chainlink
Chainlink a été développé en tant que réseau Oracle décentralisé qui permet aux contrats intelligents de transférer des données entre les chaînes de blocs et les systèmes hors chaîne de manière fiable et sécurisée. Il utilise un réseau décentralisé d’oracles indépendants pour récupérer des données à partir de plusieurs ressources différentes, agréger les données, puis fournir les données validées au contrat intelligent, ce qui déclenche l’exécution du contrat.
Le protocole Chainlink fournit également une sécurité multicouche pour garantir une confiance totale dans le réseau Oracle. Il permet la création et l’exploitation de réseaux Oracle, permettant aux utilisateurs de se connecter à des réseaux Oracle personnalisés sans avoir à dépendre d’autres réseaux Oracle.


 	
Signature des données — Les données d’entrée des oracles Chainlink sont signées à l’aide d’une signature cartographique unique qui permet aux utilisateurs de prouver que les données proviennent d’un nœud Oracle spécifique.

 	
Données de haute qualité — Chainlink fournira des contrats intelligents avec des données provenant de sources externes telles que des fournisseurs de données externes.

 	
Blockchain Agnostic — Chainlink est capable de s’exécuter nativement sur n’importe quelle blockchain, prenant en charge les blockchains publiques, les blockchains d’entreprise, etc.





	

	
	
		
			
				DAOrecords allows you to mint:
			
		

		
					

		
			
			
			
			Digital art
		
			
			Digital cats
		
			
			Audio NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora – An Ethereum Layer-2 Experience
Aurora sur le protocole NEAR offre une expérience Ethereum Layer-2. Les développeurs peuvent l’utiliser pour atteindre des marchés supplémentaires tout en profitant des fonctionnalités du protocole NEAR telles que la rémunération des frais de gaz et le sharding. Il fonctionne sur deux composants critiques, le pont Aurora et le moteur Aurora. Voici quelques fonctionnalités apportées par Aurora :

 	
La capacité de traiter des milliers de transactions par seconde, une augmentation de 50 fois par rapport à Ethereum.

 	
Un temps de finalité de bloc de 2 secondes, par rapport au temps de confirmation de bloc unique de 13 secondes sur Ethereum

 	
Permet à EVM d’évoluer horizontalement avec l’approche de partitionnement de NEAR.

 	
Les frais sur Aurora sont 1000 fois inférieurs à ceux sur Ethereum.

 	
Aurora offre une compatibilité sans compromis avec Ethereum via le protocole NEAR.


Pensées de clôture
NEAR crée un écosystème où les utilisateurs peuvent facilement accéder aux dApps, NFTs et DeFi. Le protocole est plus rapide et moins cher que les autres acteurs de l’espace crypto. NEAR propose des solutions à des problèmes tels que les vitesses de traitement lentes, la congestion du réseau et les frais de gaz élevés en utilisant le sharding, donnant à la plate-forme une évolutivité significative sans compromettre la sécurité du protocole.




	

	
	
		
			
				This protocol allows NEAR users to access Ethereum on layer-2:
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			Plasma
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Protocol y Solana

Hoy le echaremos un ojo a dos de las plataformas de contratos inteligentes más prometedoras del mundo – Near Protocol y Solana. Aunque actualmente Ethereum domina el mercado, es una realidad que su falta de escalabilidad y altas tarifas han obligado a la mayoría de los desarrolladores a buscar alternativas viables. Near y Solana han emergido como las principales opciones.
¿Qué es Solana?
Solana fue fundada en 2017 por Anatoly Yakovenko, quien anteriormente había trabajado en DropBox. Yakovenko, junto con Eric Williams y el CTO Greg Fritzgerald, crearon Solana para resolver los problemas existentes en Bitcoin y Ethereum. El proyecto ha atraído inversiones de Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures y más.



Características de la Blockchain de Solana

 	50,000 transacciones por segundo y 0,4 segundos por bloque
 	El sistema puede procesar 28,4 millones de transacciones por segundo en una red de 40 gigabits
 	Solana utiliza el algoritmo de consenso Proof-of-History (Prueba de Historia).

¿Cómo funciona Proof-of-History (PoH)?

El consenso es esencial, especialmente en una red descentralizada que se extiende sobre un espacio inmenso . Bitcoin utiliza el consenso de prueba de trabajo (PoW) para realizar el consenso. Si bien el método es muy seguro, es difícil no ignorar su problema más importante – la falta de escalabilidad. Bitcoin solo puede procesar 7 transacciones por segundo..

Solana utiliza la prueba de historia (PoH), en la que crea registros históricos para demostrar que un evento ocurre durante un momento específico en el tiempo. Aquí hay algunos puntos que se deben tener en cuenta:

 	El algoritmo utiliza una función de retardo verificable de alta frecuencia que requiere un cierto número de pasos secuenciales para finalizar.
 	Las transacciones o eventos cronometrados dentro de la red son designados con un hash único un recuento, que se puede verificar públicamente.
 	El recuento permite a la red saber exactamente cuándo ocurrió la transacción o el evento.
 	Cada nodo tiene un reloj criptográfico que ayuda a rastrear la hora de la red y el orden de los eventos.

Debido a PoH, la red Solana admite 50.000 transacciones por segundo mientras se ejecuta con GPU. 

¿Qué es un Clúster en Solana?

Un clúster es un conjunto de computadoras de propiedad independiente que trabajan juntas y pueden verse como un sistema singular. Las principales características del Clúster son las siguientes:

 	Ayudan a verificar el resultado de programas enviados por usuarios que no son de confianza
 	Mantiene un registro de cualquier transacción o evento que realice un usuario.
 	Realiza un seguimiento de las computadoras que realizaron un trabajo significativo para mantener la red en funcionamiento.
 	Realiza un seguimiento de la posesión de activos del mundo real.




	

	
	
		
			
				¿Cuál de los siguientes utiliza Sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			Ambos
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Programando en Solana

Los Contratos Inteligentes en Solana son escritos en Rust o C y compilados en el código de bytes de Berkeley Packet Filter (BPF). Dado que hay más herramientas disponibles, se recomienda que codifique en Rust. Los principiantes deben codificar sus programas utilizando el Anchor framework, que simplifica la ejecución.

Solana has a unique account model that is similar to files in the Linux operating system. They can hold any arbitrary data and also contain metadata about how they can be accessed. Keep in mind though, that the accounts have a fixed size and cannot be resized. 

Solana’s current programming model may force you to move application logic off-chain or modify the functionality to be inefficient and limited by the fixed account size. 




	

	
	
		
			
				¿Cuál de los siguientes es una parte integral de Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Collective
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Ejemplo de contrato
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
¿Qué está pasando en el contrato?

 	Todas las cuentas a ser accesadas son anotadas en estructura para cada llamada con # [derive(Accounts)]. 
 	La función ayuda a inicializar la data de la cuenta para el dueño inicial y la compra. Esto permite que cualquiera pueda comprarla por más tokens. 
 	Data temporal es transferida a los parámetros de la función. Esto también incluye el contexto que la cuenta requiere para la transacción.
 	El estado de contrato luego se localiza en la estructura de ContentRecord. Ésto es luego anotado con #[account] para indicar que representa la capa de data de una cuenta.

¿Qué es Protocolo NEAR?
Llegando a existir en verano del 2018, el protocolo fue diseñado para crear el ambiente perfecto para aplicaciones descentralizadas proporcionando velocidades más altas, un mayor rendimiento y una mejor compatibilidad con otras cadenas. NEAR tiene una técnica de fragmentación o “Sharding” e introduce un mecanismo de generación de bloques llamado “Doomslug” propuesto en 2019. Doomslug permite finalidad práctica o finalidad “doomslug”, asegurando que los bloques reciban finalidad en segundos.

El protocolo NEAR es desarrollado por el colectivo NEAR, una comunidad de desarrolladores e investigadores colaborando en construir el proyecto. Algunas características críticas son:

 	NEAR es un sistema fragmentado que permite escalabilidad infinita
 	Un protocolo fácil de usar, NEAR permite a los desarrolladores construir aplicaciones fácil y rápido.
 	NEAR no es una cadena paralela sino un protocolo de primera capa.
 	 Las dApps creadas usando NEAR corren encima de la capa de NEAR subyacente.

¿Qué es el colectivo NEAR?

El colectivo NEAR incluye organizaciones independientes y otros contribuyentes que están constantemente trabajando en mejorar el protocolo NEAR. El colectivo trabaja en proyectos tales como escribir el código inicial y la implementación de la red NEAR. Es completamente descentralizado, operando independientemente, y no puede ser apagado o manipulado incluso por aquellos quienes lo crearon.

Es una organización sin fines de lucro enfocada en crear un ecosistema vibrante alrededor de la blockchain de NEAR. Ayuda en la coordinación de actividades de gobierno y desarrollo. El colectivo NEAR tiene varios proyectos, con la blockchain de NEAR uno de cada tantos proyectos está bajo la tutela del colectivo.

Mecanismo de consenso de NEAR

El mecanismo de consenso implementado en NEAR se llama Nightshade. Nightshade modela el sistema como una única blockchain. La lista de todas las transacciones en cada bloque se divide en pedazos físicos. Un pedazo por fragmento. Todos los pedazos se acumulan en un bloque. Nótese que los pedazos pueden ser validados solo por nodos que mantienen el estado de los fragmentos.

Hablando de validación, un componente clave de NEAR son los validadores. Éstos validadores son responsables por mantener el consenso dentro del protocolo. Los validadores son nodos especializados que mantienen sus servidores en línea el 100% del tiempo mientras mantienen sus sistemas continuamente actualizados.

A continuación veremos algunos puntos que debe tener en mente sobre los validadores de la red.

 	NEAR verifica los validadores de su red en cada nuevo epoch, eligiendolos en base a su participación.
 	Los validadores elegidos son re-inscritos por una re-participación automática de sus token más las recompensas precisas.
 	Los validadores potenciales deben mantener su participación por encima de un nivel determinado de forma dinámica.
 	Existen dos metodos que los validadores pueden usar para fortalecer su participación. Comprando los tokens por sí mismos o prestarlos a través de delegación de tokens
 	La recompensa que recibe es directamente proporcional a su participación, mientras más tokens tenga mayor será la recompensa.

El consenso se basa en el consenso más pesado de la cadena. Esto significa que una vez que un productor de bloques publica un bloque, ellos recolectan las firmas de los nodos validadores. El peso del bloque es entonces una participación acumulativa de todos los participantes que firman dentro del bloque. El peso de la cadena es entonces la suma del peso de todos los bloques. Adicionalmente, el consenso utiliza un dispositivo de finalidad que produce condiciones de cortes adicionales para mayor seguridad de la cadena.




	

	
	
		
			
				¿Doomslug es un mecanismo generador de bloque de qué protocolo?
			
		

		
					

		
			
			
			
			Protocolo NEAR
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Aurora y el protocolo NEAR

Aurora también fue lanzada en el protocolo NEAR, proveyendo una experiencia de segunda capa en Ethereum. Algunas de las formas como aurora mejora a NEAR son:

 	Ayuda a aumentar el rendimiento a miles de transacciones por segundo.
 	Una finalidad de bloque de 2 segundos.
 	Crecimiento del ecosistema garantizada a futuro.
 	Bajas comisiones de transacción, que son 1000x veces menores que en Ethereum.
 	Compatibilidad sin riesgos con ethereum.

Ejemplo de contrato
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

¿Qué está ocurriendo en el contrato?

Entonces, ¿qué está ocurriendo en el contrato? tomemos un vistazo más cercano

 	El contrato es definido por #[near_bindgen] en el rastreador de contenido, es similar a un constructor en Solidity y se llama o ejecuta cuando el contrato es desplegado.
 	La funcion de compra es anotada con #[payable].
 	El contrato incluye llamadas asíncronas en lineas cuyo formato es Promise::new(…).transfer(…); 
 	La estructura de datos LookupMap<String, ContentRecord> maneja la busqueda de los valores de llaves, los cuales acceden al almacenamiento. Esto es igual al “mapping” o mapeo en Solidity.

Conclusión

Tanto Solana como NEAR son plataformas brillantes de contratos inteligentes que han construido una comunidad altamente activa. Ambos nos brindan caracteristicas especiales que ayudan a combatir el problema más grande que está plagando la velocidad del mundo descentralizado. Ambas plataformas están aún creciendo y tienen mucho que prometer.

### NEAR Live Contract Review | Phần 1: Voting Contracts

Giới thiệu
Xin chào, tôi là Eugene và tôi ở đây với NEAR, hôm nay chúng ta sẽ thử một thứ mới. Chúng ta sẽ cùng tìm hiểu quá trình phát triển hợp đồng thông minh bằng ngôn ngữ Rust. Đây là buổi đầu tiên, hãy để tôi giới thiệu bản thân mình. Tôi làm việc tại NEAR, xử lý phần runtime (thời gian chạy) và contracts (hợp đồng). Ngày hôm nay chúng ta sẽ thảo luận về hợp đồng bỏ phiếu và đây là contract đã được sử dụng trên mainnet để bỏ phiếu cho việc NEAR Protocol chuyển từ phase 1 sang phase 2.

Những Validator phải bỏ phiếu để cho phép việc chuyển đổi diễn ra, đây là điều cần thiết để giúp mạng lưới hoàn toàn phi tập trung.

Đây là video gốc mà bài viết này dựa theo.


Tổng quan về cấu trúc
Tôi sử dụng CLI trên Rust vì đây là một trong những công cụ tuyệt vời nhất để làm việc trên rust và bên tay trái, bạn có thể thấy kho lưu trữ (repo) cho những core contracts (hợp đồng cốt lõi). Bạn có thể tìm thấy mã nguồn của dự án này trên GitHub chính thức của chúng tôi, có rất nhiều hợp đồng, và contract mà chúng ta sẽ tìm hiểu trong bài viết này là voting contract (Hợp đồng bỏ phiếu).

Đầu tiên, tôi sẽ giới thiệu khái quát cấu trúc của repo này. Trong Rust, bạn có src và lib, lib.rs là file chính, nó là một file thư viện (library) vì chúng ta sẽ không biên dịch một file binary mà là biên dịch một thư viện thành một file định dạng WebAssembly.



Đây là file Cargo.toml: đây là nơi chúng ta mô tả các dependency (các thư viện, package có sẵn mà chúng ta muốn tái sử dụng trong một dự án Rust). Chúng ta sẽ sử dụng NEAR SDK phiên bản 2.0 để xây dựng nên hợp đồng bỏ phiếu. Bên cạnh đó, các bạn có thể thấy trong file Cargo.toml này có cấu hình một số flags (dưới phần khai báo [profile.release])  như ‘panic’, ‘debug’ nhằm tối ưu hóa file kết quả sau khi biên dịch.



Có một loạt các tối ưu hóa nhằm giảm kích thước của mã nguồn sau khi biên dịch. Trong phần [profile.release], flag ‘debug’ được gán giá trị ‘false’, cùng với đó việc gán giá trị flag ‘panic’ bằng ‘abort’ đồng nghĩa với việc khi gặp trường hợp ngoại lệ trình biên dịch sẽ không mất thêm thời gian để truy ngược lại lỗi, việc này rất quan trọng đối với WebAssembly.

Cuối cùng chúng ta để overflow-checks là true (bật kiểm tra tràn), có nghĩa là khi xảy ra hiện tượng tràn số nguyên bạn có thể trừ đi một số. Giả sử bạn lấy 2-1 và là số âm và nếu số nguyên thuộc dạng unsigned, trình biên dịch của Rust sẽ panic (tương tự như throw error trong các ngôn ngữ lập trình khác). Việc này thường âm thầm xảy ra trong C++, nhưng trong Rust bạn có thể kích hoạt flag (overflow-checks=true) để trình biên dịch panic khi overflow hoặc nếu code bị vượt qua giới hạn của số nguyên theo cả hai hướng. Vì vậy nếu code bạn vượt qua giới hạn lưu trữ của kiểu dữ liệu u32 sẽ gây ra code panic. Khi bạn phát triển hợp đồng thông minh cho bất kỳ nền tảng nào, thường thì overflow và silent overflows không phải là điều mà bạn mong muốn và lỗi này có thể bị các hacker lợi dụng, nên lý tưởng nhất là contract của bạn phải panic ngay để báo cho bạn xử lý nó. Điều này cũng nhằm đảm bảo tính an toàn cho contract.
Lib.rs
Chúng ta có nhiều file khác nhau và sẽ xem chúng sau, đầu tiên, hãy bắt đầu với contract chính. 

Đây là một file khá đơn giản, nhưng đồng thời cũng có vài thứ thú vị. Các contracts trên NEAR Protocol được viết bằng ngôn ngữ Rust có một cấu trúc dữ liệu gọi là struct chính (có thể có thêm một số struct phụ khác trong mã nguồn). Trong trường hợp được xét đến trong bài viết này thì hợp đồng của chúng ta có một struct tên là VotingContract, cấu trúc dữ liệu struct tương tự như khái niệm class trong một số ngôn ngữ khác. Bên cạnh đó chúng ta cũng sử dụng một số macros trong mã nguồn sau đây.



near_bindgen là một macro từ NEAR SDK biến struct thành thứ mà chúng ta sử dụng cho các contract, tôi sẽ giải thích kỹ phần này ở phía sau. BorshDeserialize và BorshSerialize là hai macro cho phép struct này và tất cả các fields trong nó được serialize thành định dạng nhị phân, được gọi là borsh và cũng dùng để deserialized (giải mã hóa). 

Điều này là cần thiết để có thể lưu trữ toàn bộ contract trong một state của blockchain.

Cách thức hoạt động của các contract là chúng có một số persistent state (trạng thái liên tục) mà từ đó chúng có thể đọc thông tin về mọi lệnh gọi của hợp đồng và chúng cũng có bộ nhớ cục bộ chỉ khả dụng khi hợp đồng đã được triển khai lên blockchain NEAR. Tôi cũng sẽ giải thích kỹ hơn khi chúng ta đi đến phần phía sau. Đến đây, chúng ta có một struct là VotingContract và trong ngôn ngữ Rust, chúng ta có khái niệm implementation của struct - tương tự như việc định nghĩa các method cho một class trong các ngôn ngữ hướng đối tượng khác.
Constructor


Một trong số các method của struct VotingContract được implement là new, trong Rust thì method này được gọi là một constructor. Method này không có tham số và giá trị trả về có kiểu Self. Ở đây, Self tương đương với một voting contract, hiểu theo các ngôn ngữ hướng đối tượng khác thì phương thức new này sẽ trả về một instance của class VotingContract. Chúng ta có một decorator macro tên là init và init macro này cho phép khởi tạo state của contract mà không cần có state trước đó. Cách mà các contract thường được triển khai trên NEAR Protocol là bạn deploy code của contract. Về cơ bản, bạn đã deploy một class sau đó bạn cần khởi tạo một instance bằng cách gọi tới constructor. Việc này sẽ lưu một state, cụ thể là struct này vào persistent storage của contract. Vậy nên phương thức này sẽ luôn có sẵn mỗi khi bạn gọi tới contract.

Khi bạn lần đầu tiên khởi tạo một voting contract, voting contract không cần bất kỳ tham số nào vì nó chưa cần biết thông tin gì. Nó sẽ chỉ dựa vào current context (bối cảnh hiện tại) của blockchain và thông tin về bối cảnh này được lấy từ module tên là env (viết tắt của environment) trong NEAR SDK.




	

	
	
		
			
				Macro nào được sử dụng để serialize mọi thứ thành dạng nhị phân? 
			
		

		
					

		
			
			
			
			SerializeSelf
		
			
			BorshSerialize
		
			
			BorshDeserialize
		
			
			DeserializeSelf
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








Đây là nơi chúng ta sẽ cần thông tin và sử dụng những tham số mà các contracts hay người dùng khác có thể gọi tới. Có hai thứ xảy ra trong constructor. Đầu tiên, chúng ta kiểm tra xem state đã tồn tại chưa (hợp đồng đã được khởi tạo chưa)



init macro cho phép contract có thể được gọi nhiều lần, vì vậy nó không cần kiểm tra xem state hiện tại đã có hay chưa, nó cho phép chúng ta làm vậy. Chúng tôi đang làm việc để thêm một macro khác gọi là init_once sẽ cho phép chỉ cần khởi tạo contract một lần và nó sẽ thực hiện việc kiểm tra này tự động. 

Ở dòng code thứ năm ta thấy macro assert sau: (assert!(!env::state_exists)), tương tự như một unit test, nó xác minh rằng biểu thức đã cho là true, nếu không sẽ raise panic làm function call bị dừng, và sẽ báo lỗi: “the contract is already initialized”. Ở đây chúng ta kiểm tra xem state đã được khởi tạo hay chưa, nếu rồi thì chúng ta sẽ không thể khởi tạo lại nó. Nếu chúng ta không check cái này thì chúng ta có thể ghi đè bất kỳ thứ gì trong contract bằng cách khởi tạo một state mới.

Bạn có thể tham khảo thêm về việc kiểm tra này qua documentation của NEAR-SDK-RS (SDK của NEAR viết bằng ngôn ngữ Rust). Mỗi khi một phương thức không phải là constructor được gọi, ví dụ như phương thức ping dưới đây, phương thức đó sẽ lấy đối số có thể thay đổi và nó sinh ra code cụ thể từ contract này thực hiện một loạt các hoạt động bằng cách sử dụng decorator near_bindgen trước khi tham gia vào execution phase.


Nếu bạn dùng mutable self hoặc self thì một trong những thao tác đầu tiên nó sẽ thử là deserialize state hiện tại dựa trên một api cấp thấp là nhận tham số đầu vào là một state key. Key này là key lưu trữ dữ liệu của struct chính (VotingContract).



Giả sử chúng ta xây dựng state trong một constructor thì về cơ bản đây là địa chỉ trả về của giá trị cuối.



Phương thức khởi tạo này trả về một struct VotingContract mới, tiếp theo, struct VotingContract mới này sẽ được serialized thành định dạng nhị phân borsh bởi near_bindgen macro và sau đó được ghi vào persistent storage sử dụng một key state. 

Giá trị được lưu trữ sẽ là giá trị hiện tại của VotingContract struct, nên lần tới khi method như ping được gọi, đầu tiên nó sẽ đọc phần nhị phân từ storage của blockchain, deserialize nó để tạo lại struct VotingContract.



Sau khi tạo lại struct VotingContract từ storage, method ping sẽ được chạy. Phương thức state_exists() tới từ NEAR SDK. Phương thức này là một dạng wrapper có tác dụng kiểm tra xem bộ nhớ đã cho có một key cụ thể hay không, nếu có thì nó sẽ biết rằng state này đã tồn tại.



Vậy thì init thực sự làm gì? init chờ bạn trả về một class hoặc một instance mới, sau đó nó sẽ ghi vào storage.



Tóm lại, phương thức new() không nhận vào tham số nào, khi được gọi tới thì nó ghi một state mới vào storage của blockchain NEAR. Chúng ta cũng có thể viết các phương thức mặc định cho contract của mình. Chúng ta không muốn việc này xảy ra nên struct VotingContract cần được khởi tạo trước. Vì vậy nó sẽ bị lỗi và code panic. NEAR SDK sẽ cố gắng đọc state từ storage từ một state key trước, và nếu nó không tồn tại, SDK sẽ call default method. Nếu method tồn tại, SDK sẽ không cần phải gọi hàm mặc định nữa.
 Interface của Contract 
Hãy xem interface của contact trước. Chúng ta có vài methods và Rust có pub decorator có nghĩa là hàm public, nếu không có pub thì hàm là private.



Vậy NEAR decorators sẽ chỉ biến các method public sang những method bạn có thể gọi được trong conrtact. Nghĩa là check_result sẽ không thể gọi được bởi người khác, trong khi những method khác có thể được gọi tới bởi bất kỳ ai. Điều quan trọng nữa về NEAR SDK là sự khác biệt trong các tham số bạn truyền vào. Nếu bạn truyền tham số mut self, nghĩa là method sẽ được cho phép sửa state. Chúng ta gọi kiểu method này là gọi hàm bình thường(regular function call), chúng chỉ có thể tới thông qua giao dịch(transaction).

Nếu self là mutable, chúng gọi là change method. Ngược lại với không có mut self, state của cấu trúc sẽ trở thành immutable (bất biến). Tham số self thông thường tạo một trạng thái chỉ đọc (read-only state),không thể chỉnh sửa. Loại phương thức này có thể được gọi sử dụng hàm view call và chúng sẽ không chỉnh sửa state. 

Nếu bạn không để mut self thì nó sẽ không thử write vào state. 

Phần quan trọng là chúng ta nên coi chúng là phương thức không thể thay đổi để chúng không chỉnh sửa state. Trước khi đi sâu vào các method cụ thể nào thì hãy nhìn vào method vote, nó có một tham số  thêm vào trong state. Theo mặc định near_bingen chờ các tham số được chuyển tới dưới dạng  JSON. Bộ giải mã mặc định của tham số là JSON, vì vậy phần thân của method chờ được gọi với dạng kiểu: ‘{“is_vote”: true}’. Tên method sẽ là vote và tham số sẽ là JSON is_vote bằng true.  Việc này quan trọng vì bạn không thể truyền các tham số bằng cách sử dụng lệnh gọi vị trí(positional arguments) vào contract nhưng trong ví dụ này, chúng ta có thể gọi vote với positional arguments. Và trong các unit test, chúng ta có thể sử dụng các positional argument.

Nhưng nếu bạn đang gọi contract từ unit test hoặc trên blockchain thì bạn đang gọi tới contract WebAssembly được biên dịch trước đó, và hợp đồng sẽ mong đợi tham số ở dạng JSON. Raw WebAssembly không biết bất kỳ loại input đầu vào nào và phân tích cú pháp input hoàn toàn khác biệt.



Các loại kết quả trả về sau khi mở rộng conrtact macro near_bingen cũng là JSON. Loại này là dạng u64 tùy chỉnh từ NEAR SDK JSON. Đó là một cấu trúc có kiểu u64 nhưng khi JSON được deserialization hay serialization được gọi trên nó, nó sẽ biến thành một chuỗi(string). Lý do cho điều này là JSON specs không hỗ trợ tất cả các loại u64. Giới hạn là 2 ^ 53 vì đây chính là giới hạn số ban đầu của javascript. Chuẩn JSON mặc định của frontend sẽ không thể serialize số lớn u64 sang một con số chính xác. Thay vào đó, chúng ta bọc u64 interger và u128 interger vào dưới dạng string để cho method trả về một JSON. Ví dụ như chuỗi “1000” lại thực ra là một số, hoặc nếu kết quả không tồn tại, sẽ trả về null.

Đây là tổng quan của NEAR SDK




	

	
	
		
			
				Mut selft  nghĩa là method có thể sửa đổi state? Đúng hay sai? 
			
		

		
					

		
			
			
			
			Đúng
		
			
			Sai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Voting Call
Bây giờ chúng ta đi sâu vào một trong các method. Method chính mà ta có trong contract này là một voting call. Khi bạn là  một Validator đang hoạt động, bạn có một tài khoản có tối thiểu một vị trí trong NEAR Protocol, bạn phải stake số NEAR khá lớn để trở thành validator. Sau đó, bạn có thể gọi method này trước giai đoạn hai để tiến hành vote.



Nếu is_vote là true có nghĩa rằng bạn muốn vote cho bước chuyển sang giai đoạn hai, nếu false, có nghĩa là bạn rút lại phiếu bầu của mình. 

Giả sử lần đầu tiên bạn kiểm tra phiếu bầu của mình, và sau đó lại muốn hủy bỏ phiếu bầu vì một lí do nào đó, chẳng hạn như bạn cảm thấy bạn không hiểu rõ gì đó nên muốn rút lại. Hãy xem cách nó hoạt động. Vote là một method thay đổi và nó tự động nhận mối số tham số được deserialize bởi near_binden. Như chúng ta đã nói trước đây, mặc dù mong đợi định dajg JSON, bên trong nó chỉ là một biến boolean mà bạn có thể dùng như bình thường trên Rust. Method này không nói về cách state bị thay đổi hoặc những action bạn đã thực hiện, cho nên bạn không cần phải lưu state theo cách thủ công. Nó sẽ tự động được lưu một cách tự động nếu method hoàn tất.  Vì vậy điều đầu tiên nó làm là gọi method ping. Chúng ta sẽ quay lại method đấy sau, nhưng nó cập nhật internal state bằng cách kiểm tra nếu epoch đã thay đổi và Validator đang hoạt động là ai để cập nhật dữ liệu.

Sau đó, vote method kiểu tra nếu chúng ta đã đạt được tới kết quả vote chưa: if self.result.is_some() 

Trong trường hợp này, kết quả là một field cho biết nếu chúng ta đã đạt tỉ lệ ⅔ số Validators, chỉ cần một dấu timestamp để bắt đầu mỗi giai đoạn.



Timestamp tính bằng nano giây vì đây là cách chúng ta hiển thị timestamp bên trong context. Option nghĩa là nó có thể tồn tại hoặc nó không tồn tại, nếu tồn tại, nó sẽ trả về timestamp. Tức là là quá trình bỏ phiếu đã xảy ra, và chúng ta đã đạt tới giai đoạn 2 ở timestamp nhất định nào đó, đơn vị nano giây, nếu không có thì nghĩa là quá trình bỏ phiếu không đạt được. Vậy nên chỉ cần kiểm tra xem nếu chúng ta đã đạt được một phiếu hay chưa. Nếu quá trình vote đã đạt được tới giai đoạn 2 thì chúng ta coi như hoàn thành, phiếu vote của bạn không còn quan trọng nữa vì ta đã tới được giai đoạn 2 và timestamp đã có sẵn ở đấy. 

Rust không có null mà thay vào đó, nó có các tùy chọn có thể trả về giá trị hoặc không, bạn phải xử lý chúng thật rõ ràng. Khi nó được mã hóa để gửi ra ngoài, nó sẽ phải gửi và lưu dưới dạng JSON, chẳng hạn như nó đang được lưu trữ và gửi dưới dạng null.

Tiếp theo là truy vấn, ngữ cảnh của NEAR SDK, nơi chúng ta kiểm tra được ai là người gọi hàm.



Có 3 loại tài khoản khả dụng cho context, một trong số đó là predecessor (tài khoản tiền nhiệm) - đây là account id của người tiền nhiệm trực tiếp(immediate predecessor) của người gọi vote. 

NEAR là môi trường đồng bộ và bạn có thể có một chuỗi các cross-contract call.

Ví dụ Alice gọi contract của Bob, Bob gọi contract của Cheryl và trong trường hợp này, Bob là predecessor. Thông qua contract của Cheryl, predessor sẽ là tài khoản vừa gọi hàm xong, trong case này là Bob. 

Ngược lại, cũng có tài khoản là signer account id (tài khoản người ký). Đây là tài khoản đã sign transaction ban đầu. Giả sử Alice là người đã gọi contract của Bob và sau đó, signer account id sẽ là Alice. Tài khoản hiện tại là tài khoản của contract, trong trường hợp này, là Cheryl, tài khoản nắm giữ hợp đồng. 

Trên NEAR, contract đó luôn thuộc về một số tài khoản mà ở đó có trạng thái(state) và balance(số dư) , và đã được deploy code lên. Ví lý do bảo mật, điều rất quan trọng là không nên dựa vào người ký giao dịch, mà cần dựa vào người predecessor ngay trước đó.

Ví dụ Bob có một contract độc hại và nếu anh ta dựa vào signer account, Bob có thể call một contract chuyển token và rút số dư từ Alice vào tài khoản của mình bằng cách thay mặt Alice. Nếu Bob thử làm như vậy thì token contract sẽ lấy predecessor, chính là Bob, nên contract của Bob chỉ có thể tiêu token của chính mình. Nó có một số hạn chế nhưng điều này đảm bảo rằng nếu bạn gọi contract thì contract không thể thay mặt bạn xử lý transaction, contract chỉ có thể tương tác với chính nó.



Việc tiếp theo chúng ta làm là kiểm tra tham số được truyền vào. Nếu đó là phiếu bầu thì có nghĩa là chúng ta muốn thêm số từ caller vào một tập hợp những validator đang hoạt động đã bỏ phiếu cho giai đoạn hai, vì vậy nếu không thì giá trị bằng không. Nó có nghĩa là chúng ta muốn đặt stake bằng 0, vì vậy ta gọi một phương thức đặc biệt: validator_stake trên môi trường là phương thức đóng một hàm máy chủ lưu trữ trong runtime của NEAR Protocol lấy được số active stake đang hoạt động từ epoch của id tài khoản đã cho.

Nó trả về số lượng stake từ một validator nhất định và sẽ được thực hiện ngay lập tức.

Nên assert!(stake>0, ‘ {} is not a validator’, account_id); là một lệnh gọi đồng bộ khi chúng ta xác minh rằng số stake bằng 0 hoặc lớn hơn 0 để chắc chắn rằng ta không gây rối cho state với các validator không hoạt động. Bằng cách này, chúng ta có thể giới hạn số lượng validator có thể đưa vào trong state, vì chúng ta chỉ có 100 chỗ khi contract được sử dụng.

Có nghĩa rằng bạn có thể giới hạn số lượng validator vào trong state này là 100. Về cơ bản, nếu assert kích hoạt điều khoản stake bằng 0 thì ta sẽ trả về lỗi panic và mọi thứ đã thực hiện trước đây sẽ được chuyển sang state. Nó sẽ được rollback (quay trở lại) tới phần đầu của function call chỉ cho hợp đồng này. Vì vậy, quay lại với ví dụ về Alice, Bob và Cheryl, chỉ contract state của Cheryl sẽ được hoàn nguyên, trạng thái của Bob thì không vì là môi trường đồng bộ. 

Tiếp theo, chúng ta kiểm tra xem mình đã vote chưa. Những votes là dạng hashmap.
Hashmaps


HashMap nằm trong memory map, nghĩa rằng nó được mã hóa, hoặc sau khi giải mã, tất cả giá trị phải được mã hóa trở lại thành một phần, và lại được giải mã trở lại. 

Mỗi khi chúng ta gọi một method trong contract này, nó sẽ  giải mã tất cả các field của HashMap, vì vậy cả hàng trăm tài khoản sẽ được giải mã hóa cùng một lúc, nhưng nó sẽ thực hiện việc này trong một lần đọc bộ nhớ thay vì hàng trăm lần. Mặc dù kích thước tổng thể lớn vì mỗi tài khoản có thể có tối đa 64 ký tự và số dư là 16 byte, nhưng kích thước tổng thể không quá lớn, cỡ bằng 100 x 80 nên tương đương 8 kilobyte.



Những gì chúng ta cần cho method ping là lặp lại mỗi lần trên mỗi vote để cập nhật số stake của validator. Ví dụ, cho một ordered map thì chúng ta cần làm gì đó theo thứ tự 100 lần đọc, và trong trường hợp này, chúng ta cần ghi đè chúng, nghĩa là cần 100 lần đọc và 100 lần ghi trong trường hợp này, đắt hơn nhiều so với việc làm một lần cho 100 tài khoản, vì ta biết được cấu trúc bị giới hạn tới 100 tài khoản. Bạn không cần dùng phân trang mà có thể bạn sẽ cần như khi dùng persistent map. Do bản thử đã được lưu trữ trong storage, nó được lưu giữ như một bản thử và việc này khiến việc đọc nhiều lần trở nên tốn kém. Vì vậy, trong trường hợp này, sẽ có lợi nếu có một map để có thể lặp lại quá trình kiểm tra.

Hướng dẫn ở đây sẽ là nếu bạn cần lặp lại trên mỗi key và với tối đa là 100, bạn nên dùng hashmap hoặc vector.

Nếu NEAR tiến tới sharded, thì cái này cần sửa đổi với một persistent map hoặc có thể bạn có thể làm với sharded map. Hiện tại thì chưa, nó sẽ không phải dạng bulk map. Nó sẽ là dạng persistent map với bulk objects, bởi vì bạn vẫn cần lặp qua tất cả.

Có thể bạn sẽ cần chia account sang 20 buckets riêng, và đối với mỗi bucket sẽ có một vector, nhưng bạn sẽ cần lưu trữ chúng riêng thành một continuous map để khi cần trả lại, bạn sẽ chỉ cần đọc 20 key hoặc bạn có thể làm một phương thức phân trang cho hàm ping.

Hiện tại vấn đề lưu trữ storage có lẽ là vấn đề tốn kém nhất mà chúng ta cần phải đối mặt, và nếu bạn thích ghi đè lên mọi thứ thì nó sẽ có khả năng còn đắt hơn sử dụng hashmap.

Đó là lý do sử dụng hashmap và nó thực sự không quá tệ. Nhưng để an toàn, chúng ta có thể ước tính 100 feet vào trong gas limit, và nó trở thành một lựa chọn tốt cho trường hợp này.
Voting Call (phần tiếp)


Ở phần vote_stake, chúng ta xóa bỏ phần stake cũ đi, đây là một bước kiểm tra an toàn. Nó là bất biến, có nghĩa là nó không có khả năng kích hoạt trong môi trường thực tế. Sau đó, nó xác minh rằng số stake hiện tại nhỏ hơn tổng số stake, sau đó ta trừ số stake cũ là ra một khoản stake mới. 

Tôi đồng ý rằng một thứ tự tốt hơn sẽ là trước tiên trừ đi số stake cũ và sau đó đưa ra số stake mới để tránh bị overflow. Mặc dù với giới hạn về tổng cung, nó sẽ không bị overflow, nhưng cẩn thận không thừa.

Nếu đây là một cuộc bỏ phiếu tích cực, nó không phải là một cuộc rút phiếu thì ta đưa kết quả vào storage.

Cuối cùng, ta sẽ kiểm tra kết quả một lần nữa cho chắc.



Hãy đến với check_result trước. Chúng ta xác minh rằng khi check_result được gọi thì kiểm tra rằng kết quả không phải là một tổng. Đó là một cách khác để kiểm tra, và nó cho chúng ta biết nó bất biến.

Ta thấy được tổng số stake của validator là bao nhiêu. total_stake là một phương thức khác được trả về từ context, nó nói chúng ta có tổng stake là 100 triệu. Sau đó, bên trong total_voted_stake là số stake đang hoạt động bao gồm tất cả những validator đã vote.

Giả sử nếu số stake đang hoạt động được làm tròn hơn hai phần ba tổng số stake, thì chúng ta sẽ đạt được kết quả và đó là phần cuối của contract này. 

Vậy là đã hoàn thành việc bỏ phiếu, đây là một phương pháp khá đơn giản.




	

	
	
		
			
				Có bao nhiêu validator bỏ phiếu trong quá trình chuyển sang phase 2? 
			
		

		
					

		
			
			
			
			50
		
			
			150
		
			
			200
		
			
			100
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ping 


Giờ chúng ta chuyển qua method ping. Method này xảy ra ở ranh giới của mỗi epoch. Mỗi khi chuyển đổi epoch có nghĩa là một tập hợp các validator đã hoạt động trong epoch trên NEAR Protocol. Validators thì không thay đổi, vì vậy kể cả khi ai đó bị kick ra ngoài thì họ không hoạt động trong các epoch tiếp theo. Chúng ta xác minh rằng hàm không có kết quả qua self.result.is_none(). Sau đó, chúng ta lấy chiều dài của epoch hiện tại, method tạo số nguyên luôn tăng, và sau đó chúng ta xác thực nó không khớp với chiều dài của epoch trước đó. Vì vậy, ta bắt đầu với chiều dài epoch bằng 0, mỗi lần ping được gọi, nó lại update vào epoch. Vậy nên mỗi khi epoch được đổi, nó có thể qua một hoặc 5 epoch không thành vấn đề. Tất cả những gì chúng ta sẽ làm là kiểm tra tất cả những phiếu trước đó đã vote cho phase 2. Bạn reset tổng stake bằng 0, và đây là cách cuối cùng của việc lấy tất cả data ra khỏi một map mới và đặt nó về mặc định. Vì vậy về cơ bản chúng ta đã có một bản copy của map từ cấu trúc bên trong và bây giờ nó chứa một hashmap rỗng. Đây là một thứ mới được giới thiệu gần đây trên Rust, được gọi là default hashmap, đơn giản là chứa một map trống. Nó cung cấp cho ta dữ liệu từ cấu trúc và giờ cấu trúc của contract chứa một map trống. Việc này giúp chúng ta có thể sửa đổi map hiện tại hoặc map mới dựa trên data có sẵn của map cũ trong một lần. Cơ bản là ta chỉ cần gọi tới account_id, vì không cần phải biết số stake trước đó là bao nhiêu. Vì vậy tiếp theo ta sẽ kiểm tra nếu có người đã bị xóa khỏi map (Line 9) hoặc bị xóa khỏi active validators. Ta lấy số stake nếu stake của validator là dương, cộng vào total stake và giữ vote của họ, nếu như họ bị kick ra thì họ sẽ phải vote lại. Cơ bản là ta update total stake bằng cách tính toán lại số total stake mới. 

Sau đó ta lưu tất cả kết quả trở lại vào contract stake, cuối cùng ta làm 2 việc.

Check kết quả sau khi chuyển đổi epoch, nếu các validators có được nhiều stake hơn hoặc total stake bị giảm xuống thì kết quả có thể đã xảy ra. Chúng ta nhớ được đã thực hiện việc này ở epoch nào nên lần tới khi có người gọi tới ping hoặc vote, ta không cần phải thực hiện lại nữa nếu epoch chưa bị chuyển.
Phần cuối


Đây là voting contract. Mỗi khi ai đó gọi hàm vote, đầu tiên chúng ta sẽ cập nhật data từ các validator, sau đó ghi vào cấu trúc nội bộ (internal structure). Quan trọng nhất, ta update total_voted_stake sau đó call check_result hai lần trong một lần gọi. Quan trọng là dù ta có thể gọi ping như một method, nhưng ta có thể gọi trực tiếp ping qua transaction. Không cần phải reload, chỉ cần call ping.



Có một loạt các view call ở đây, hàm đầu tiên chỉ đơn giản là trả về kết quả, hàm thứ 2 trả về lượng stake trong pool, hàm thứ 3 thì trả về tổng số votes. Cơ bản là lặp qua map rồi sau đó kết hợp nó lại thành kết quả mong muốn. Ngoài ra còn có unit test trong code, đây chỉ là cách thực hiện trong Rust và unit test còn có thể xác thực lại logic trong contract bằng cách giả mạo các ngữ cảnh (mocking context) và làm các thứ khác nữa.

### DeFi sur le protocole NEAR

NEAR Protocol est une plate-forme de contrat intelligent, qui se concentre sur le développeur et la convivialité. Il fournit une plate-forme évolutive pour exécuter des applications. NEAR a été fondée à l’été 2018 par Alex Skidanov et Illia Polosukhin. Aujourd’hui, dans cet article, nous examinerons les applications DeFi sur le protocole NEAR.
La montée de DeFi
DeFi ou Decentralized Finance sont des instruments financiers basés sur la blockchain. Alors que les instruments financiers centralisés sont enlisés par le manque d’interopérabilité et la bureaucratie, les applications DeFi sont comme des blocs Lego que les utilisateurs peuvent réunir pour créer de nouveaux instruments. En conséquence, l’écosystème DeFi est passé de 7,40 milliards de dollars le 22 juin 2020 à 97,7 milliards de dollars le 7 septembre 2021. C’est une augmentation de valeur d’environ 1220% en un peu plus d’un an !



À l’heure actuelle, la valeur totale bloquée dans DeFi est d’environ 83,86 milliards de dollars.
La vraie signification de DeFi
Il ne suffit pas de parler de la valeur totale verrouillée pour comprendre la véritable signification de DeFi. C’est un élément crucial dans la construction du Web ouvert et a été à lui seul responsable de l’afflux de talents qu’Ethereum a connu au cours des deux dernières années. Si vous y réfléchissez, cela a un sens absolu en raison de la nature révolutionnaire et composable de DeFi. Des actions qui pouvaient prendre des semaines dans le monde de la finance traditionnelle ne prennent désormais que quelques secondes.
Cependant, il y a aussi un revers à cette équation. En raison de la hausse de la demande, DeFi est responsable de la congestion du réseau et de la hausse des prix du gaz. En tant que tel, la barrière à l’entrée pour Ethereum est devenue considérablement plus élevée pour les développeurs et créateurs débutants.
NEAR Protocol fournit une alternative viable, plus rapide et moins chère à Ethereum.
DeFi sur le protocole NEAR


Passons en revue certains des projets DeFi les plus prometteurs sur NEAR.
Rainbow Bridge

Le Rainbow Bridge existe entre NEAR et Ethereum. Tous les actifs provenant d’Ethereum sont désormais entièrement utilisables dans NEAR. Depuis son lancement, plus d’un million de dollars d’ETH, de DAI et d’autres jetons ont traversé le pont. L’infrastructure Bridge peut être facilement réutilisée et assurer les connexions entre NEAR et toutes les chaînes compatibles EVM, comme Polygon, BSC, Avalanche, Optimism, Arbitrum, etc. L’équipe travaille actuellement à étendre cette infrastructure pour prendre en charge les chaînes non EVM comme Bitcoin, Cosmos, etc.
Voici certaines choses que vous devez savoir sur le Rainbow Bridge :


 	Les utilisateurs peuvent être intégrés à Rainbow Bridge directement via MetaMask.
 	Les transactions NEAR sont confirmées en moins de 2 secondes et coûtent moins de 1 cent de frais d’essence.

Voici à quoi ressemble une transaction de pont NEAR<>Ethereum :


 	Les actifs allant d’Ethereum à NEAR prennent environ 6 minutes (environ 20 blocs).
 	Les transactions ERC20 coûtent environ 10 $ en moyenne.
 	L’envoi d’actifs de NEAR vers Ethereum prend un maximum de 16 heures (en raison des délais de finalité d’Ethereum). Ce processus coûte également environ 60 $ en raison des coûts du gaz ETH.

Le Rainbow Bridge est une innovation importante car il s’agit d’une première étape essentielle dans la feuille de route d’interopérabilité de NEAR. De plus, étant donné que NEAR offre des transactions plus rapides et moins chères, il peut être avantageux pour les utilisateurs d’autres chaînes d’interagir avec les actifs Ethereum sur NEAR plutôt que de se connecter directement à Ethereum.

Ref Finance

Ref Finance a été la première plateforme DeFi sur NEAR. La première version de Ref présentait certaines similitudes avec Uniswap V2, ainsi que la prise en charge de plus de types de pools, de frais configurables, et elle appartient entièrement à la communauté. Son objectif principal est de rassembler les composants essentiels de DeFi tels que l’échange décentralisé (DEX), le protocole de prêt, l’émetteur d’actifs synthétiques, etc.
Ref Finance dispose d’une trésorerie de 35 millions de dollars REF dont 10 % sont alloués à un amusement de développement pour les projets à venir et 25 % pour les futures activités, événements et partenariats communautaires.
Caractéristiques de Ref Finance


 	L’AMM DEX de Ref permet des échanges sans autorisation et automatisés entre n’importe quel jeton NEAR ou ponté natif.
 	Les fournisseurs de liquidités peuvent gagner des jetons REF ou NEP-141 en jalonnant des jetons LP.
 	Les utilisateurs peuvent miser des jetons $REF pour gagner plus de $REF au fil du temps.

Ref est un projet communautaire et est maintenu par un DAO. Le Ref DAO a deux rôles — le conseil et le conseil communautaire.


 	Conseil : Le Conseil élabore des propositions et les vote. Une proposition ne passe que si la majorité du conseil la confirme. Le Conseil sera modifié une fois que le DAO sera pleinement actif.
 	Conseil communautaire : le Conseil communautaire vote ou rejette également une proposition. La plupart du temps, le conseil s’en remet à la décision du conseil communautaire.

OIN Finance

OIN est une plate-forme d’émission de stablecoin décentralisée qui permet aux projets d’émettre leur propre stablecoin de marque. Au lieu d’avoir à mettre en liste blanche leurs garanties sur d’autres plateformes, OIN lancera un stablecoin NEAR-collateralized pour débloquer des liquidités sans vendre leurs jetons NEAR. Les cas d’utilisation d’OIN sont — échanger contre d’autres pièces stables traditionnelles, ajouter un effet de levier, une couverture, des prêts et une pléthore d’utilitaires spécifiques à l’écosystème.
Actuellement, la principale gamme de produits sur OIN est l’OINDAO. Il permet aux projets qui se joignent de créer leur propre pool de garantie pour frapper leurs propres pièces stables étiquetées de marque. OIN établit un processus de validation rapide pour chaque transaction initiée sur la blockchain via le système de preuve Merkle. Pour ce faire, ils placent de petits morceaux d’informations menant à une « transaction racine » sur le grand livre et les utilisent pour valider une plus grande base de données d’informations.
Certaines caractéristiques intéressantes d’OIN sont les suivantes :


 	Il est facile et rapide de frapper des pièces stables une fois que le projet de cotation a défini les paramètres.
 	Les contrats intelligents d’OIN ont tous été minutieusement audités.
 	Support technique pour configurer les paramètres de risque clés pour les contrats intelligents.
 	Support technique pour vous aider à échanger votre stablecoin de marque avec des stablecoins grand public sur Curve et Balancer pour débloquer la liquidité de votre actif.

Skyward Finance 


Skyward Finance est une rampe de lancement open source et sans autorisation que les projets peuvent utiliser pour lancer leurs jetons sans aucune liquidité. Skyward possède potentiellement l’un des meilleurs mécanismes de découverte de prix résistant aux attaques sybil et aux attaques de bots. La plate-forme cherche à permettre la découverte des prix et la distribution de jetons pour les projets basés sur le protocole NEAR. Pour ce faire, il utilise des enchères basées sur le temps en streaming auxquelles la communauté en général peut accéder de manière décentralisée. Ces enchères seront également résistantes à la manipulation des prix, à la course frontale et aux attaques sybil. Skyward Finance émettra des jetons à la communauté, leur permettant de faire partie de la plate-forme et de générer des revenus.
Quels sont certains des avantages de Skyward Finance ?
Skyward Finance présente plusieurs avantages, dont certains sont les suivants.


 	Les projets peuvent lancer leurs jetons sans liquidité.
 	Le mécanisme de découverte des prix de Skyward Finance est résistant aux attaques de bots et de sybil. Il ne peut pas non plus être manipulé.
 	Les projets peuvent collecter des fonds dans n’importe quel jeton et peuvent également lancer plusieurs ventes de jetons comprenant différents jetons.
 	En raison de l’immuabilité de Skyward Finance à tout type de manipulation des prix, les projets et leurs fondateurs peuvent maximiser leur capital en fonction de la valeur marchande.
 	Les projets ne nécessitent pas le jeton $SKYWARD pour participer ou créer une vente.
 	Skyward Finance est open source et sans autorisation, ce qui signifie que les contrats intelligents sur la plate-forme sont entièrement indépendants.
 	Parce que Skyward Finance fonctionne sur NEAR, il est en mesure de tirer parti de l’évolutivité de NEAR et des transactions moins chères.




	

	
	
		
			
				Which of the following is a stablecoin issuance platform?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool

Meta Pool est un protocole de jalonnement liquide basé sur le protocole NEAR. Les particuliers peuvent facilement miser leurs jetons NEAR en utilisant Meta Pool et ses stratégies de mise automatique. En retour, ils reçoivent des jetons “Staked NEAR” qu’ils peuvent utiliser dans le DeFi NEARverse. Les jetons peuvent également être remplacés par les jetons NEAR d’origine à tout moment.
Meta Pool est devenu un élément essentiel de l’écosystème DeFi de NEAR en introduisant le premier jeton de jalonnement liquide de NEAR, le stNEAR. Le jeton stNEAR peut accumuler des récompenses de staking et également représenter des positions de staking sur NEAR. Meta Pool offre aux détenteurs de jetons NEAR une plate-forme facile à utiliser et générant des rendements tout en créant un réseau décentralisé. Meta Pool fonctionnera sur un DAO sur Sputnik V2, la plate-forme native de NEAR pour gérer les organisations autonomes décentralisées.
Lorsque les détenteurs de jetons misent sur Meta Pool, ils obtiennent des jetons $META à chaque époque. Chaque époque est de 12 heures. Ceux-ci sont reçus en plus des récompenses du protocole NEAR, qui sont de 10,2% APY.

Cheddar 

Cheddar crée un réseau de fidélisation pour NEAR et son écosystème d’applications décentralisées. Il y parvient grâce à l’établissement de partenariats stratégiques qui promeuvent activement l’utilisation du protocole NEAR lors de la récompense des utilisateurs. Il a été prouvé que les réseaux de fidélité motivent les utilisateurs à effectuer des actions bénéfiques pour les entreprises. Grâce à Cheddar, les jetons communautaires peuvent être amorcés, ce qui permet aux applications d’augmenter la fidélité des utilisateurs et d’ajouter de nouvelles sources de revenus à l’aide de mécanismes d’agriculture.
Le cheddar est différent des autres fermes Yield car il offre des avantages à long terme aux utilisateurs HODL grâce à des powerUPs. Il favorise également l’utilisation d’applications croisées dans NEARVerse, permettant aux utilisateurs de cultiver du cheddar via farming de rendement, les pools de liquidité ou les dApps.

Comment le cheddar profite-t-il au protocole NEAR

 	Connectivité dApp — Cheddar crée un lien commun entre les applications au-delà des jetons individuels, créant ainsi un écosystème fidèle pour les dApps sur NEAR.
 	Engagement des utilisateurs — Cheddar crée un engagement des utilisateurs à long terme grâce à diverses incitations et à la fidélisation grâce à des partenariats stratégiques.
 	Sauts inter-chaînes — Le cheddar crée une interconnectivité inter-chaînes et maintient les utilisateurs sur NEAR actifs et engagés, garantissant que la valeur totale verrouillée est préservée.




	

	
	
		
			
				Which of the following is creating a loyalty program on NEAR?
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 

Berry Club permet aux utilisateurs de créer des pixel art partagés tout en cultivant des récompenses en jetons. Le Berry Club avait commencé comme une preuve de concept DeFi, mais est depuis devenu un projet communautaire extrêmement populaire sur le protocole NEAR. Berry Club fait un excellent usage de plusieurs des fonctionnalités de NEAR Protocol, telles que les paiements automatiques aux créateurs de contrats intelligents, qui ne se trouvent sur aucune autre blockchain.
Grâce à la conception unique de NEAR, Berry Club et Berry Farm peuvent profiter à la fois aux utilisateurs et aux créateurs de contrats intelligents, qui sont payés sous forme de récompenses de contrats intelligents aux détenteurs de jetons et aux créateurs. Ces avantages découlent de l’utilisation accrue de l’application (Berry Club). Ce type de distribution de récompenses n’est pas possible sur des plateformes comme Ethereum, du moins pas dans sa mise en œuvre actuelle. C’est une autre raison pour laquelle les utilisateurs et les développeurs devraient expérimenter NEAR.



	

	
	
		
			
				The bridge between Ethereum and NEAR is called:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
NEAR Protocol est possède déjà un écosystème DeFi très excitant et il ne fera que croître. Dans l’état actuel des choses, NEAR fournit une alternative puissante et efficace à Ethereum.

### NEAR Live Contract Review | Part 3: Whitelist and Staking Pool Factory

Introduction
Hello, everyone. Today we're going to review 2 contracts instead of 1. We will include contracts that involve cross contract calls, and talk about promises, and how they work at NEAR. If you want to learn more about how composability works this is a good session to read. The first contract that we're going to take a look at is called a whitelist contract, and it is used on the mainnet to whitelist staking pools. This is important because the distribution of tokens is done through smart contracts. We use lockup contracts which we'll eventually review in this series, but the way it works is that the lockup is a standalone contract that holds tokens that are supposed to be released over a period of time. Let's say the tokens are released over 2 years, and are linearly getting allocated every block. What we wanted to do is to give the ability to stake these tokens including the tokens that are not released yet. This means you should be able to delegate all of the tokens that you have locked for 2 years for example, and start earning rewards on them. This is done on a smart contract, and a lockup contract is essentially calling the staking pool contract that we reviewed before and transferring tokens from one contract to another. The tokens from the lockup contract leave the account, and go to the account of the staking pool. If a staking pool doesn't provide the guarantees that are required, such as the ability to return these tokens, then it means there will be problems. Let's say that I build a custom staking pool that allows me not only to stake tokens, but also withdraw them to any account. This type of operation will allow you to get liquid assets before the release period ends. So you will be able to withdraw, and this is not the desired behavior. 

That's why we introduced the whitelist where custom implementations of the staking pools that are approved by the NEAR Foundation can be used by lockup contracts. At the same time we wanted to give the ability to create new staking pools that are already approved by anyone without going through approval from the NEAR Foundation. This allows anyone to create a new staking pool through a staking pool factory. The staking pool factory is the second contract that we'll review today. The way it works is when a lockup contract wants to delegate, before they can transfer funds out to this contract they first need to select a staking pool. When you select staking pool, lockup issues a transaction to check if a given account id is whitelisted in a whitelist contract, and if it returns true, which means the account is whitelisted, then the lock-up contract can continue with delegation. It allows the lock-up to actually transfer to this contract. It means that the staking pool contract has some guarantees and APIs that the local contract expects, and it's not going to lock the  owner’s tokens, or steal tokens from the lockup contract. This also was important for the investing schedules of NEAR employees. It was on a four-year investing schedule, and that allows the foundation to issue a specific transaction to the lockup of that person in order to unstake everything from the staking pool and return the invested amount back to the NEAR foundation in case an employee leaves the job or was terminated. That's the background about lockups and the whitelist contract.

The original repository for these contracts can be found on the NEAR Github. Here is the original video on which this guide is based on:


Whitelist Contract 
Main Structure
Let's look at the whitelist contract. It's actually a fairly simple contract, and it doesn't really have a lot of logic, we already know the majority of stuff. 



It uses a NEAR API that’s called LookupSet. It’s similar to an unordered set. It's a persistent collection, but it doesn't have iterators, so you cannot iterate over the keys of the elements of the set. You can only check if a given element is present, or not present, and you can add it to the set. You cannot check what elements are present in this set. By doing this it improves the efficiency of storage, and access from multiple reads to a few reads. The contract contains a few fields. The first is the foundation_account_id. This is the account id that controls the whitelist. It means that this account can whitelist staking pools by 1, and it can also whitelist staking pool factories. The factory is a contract that can create a new staking pool instance. The way it works is when you issue a transaction towards the staking factory that is whitelisted by this contract, it creates a new account as a sub account of the factory. In our case on the mainnet it's called poolv1.near which is the staking pool factory that we use. It creates a contract, for example bisontrails.poolv1.near, on which it deploys whitelisted staking pool code that this factory can produce. We'll go into the staking pool factory later, but at the same time it also can white list this given staking pool. Here's how it works. The contract initialization only takes a foundation_account_id argument. A foundation account has higher permissions on this contract.


Getters
There are a bunch of getters.



You can check if a given stake input is whitelisted. This is how a lockup contract checks if the pool is whitelisted. It basically just checks if an element is present in a set. The second way it also can check is  if the factory is white listed, so this is not really needed, and no one calls it.
Add Staking Pool Method


This is a method that can be called both by a factory and the foundation. What we do here is check that this staking method adds a new staking_pool_account_id to a whitelist. It checks if the account id is valid, then if it passes we check if this is a factory. We check in a set that the caller of this method is present in the whitelist of the factories. If it's called by the staking pool factory, then it's okay. If not then it has to be a foundation account id otherwise the contract will fail, and this method will panic. If we pass the permission check then we just add this staking pool to the whitelist. Right now we have only one implementation for the staking pool, but in theory we can modify this implementation when we introduce slashing for example, and a staking pool has to have the necessary permission. It needs to maintain some minimum balance. There's some other change where we need to modify a validated contract over everyone’s investing period is 4 years. A lot of stuff can happen around the network and we need to have an ability to potentially change the staking pools. If the logic of staking pool changes for example. It allows the creation of a new factory that is a better version or  supports something that was not supported before. It does not allow to change a reward fee instantly, but only allows it to change after a 7 day waiting period, or some other idea for a modification that will be a different factor.



Next remove_staking_pool can only be called by the foundation so that a staking pool can only be killed by the foundation.

Also, add_factory can also be only called by the foundation. It’s basic, it just adds to a white list of the factory accounts.



Finally, remove_factory can also only be called by the foundation, and removes the factory_account_id. Let's say the first factory expires, then the foundation can basically remove the factory from whitelist as well as remove all the previous pools from the whitelist. Now, you will not be able to select one of the previous staking polls from a lockup contract, and finally there’s a check that this is called by foundation which is a comparison. This is a very simple contract, and it just operates on internal sets and the only true method that is visible by outside is is_whitelisted. It's fairly simple, it’s just a bunch of setters and getters.
Immutability of Smart Contracts
The way smart contracts usually behave which is true on Ethereum, and on other platforms is they are immutable on themselves.  On Ethereum every contract interior is immutable, but they use a proxy contract that allows them to upgrade the endpoint for certain contracts that are very critical to tokens. In this case our core contracts are essentially completely immutable, and we think about them as if we will deploy them once, and likely not be able to change them, because otherwise you'll have to do a hard fork, and convince all validators to do some type of code migration. It is important, because the control over them has to be done on the contract level instead of on some centralized entities. For example, while the foundation still maintains large control over the staking pools by having the ability to remove staking pools here, it doesn't have the control to blacklist a particular entity in the real world from deploying a staking pool. They still can create a staking pool with as much anonymity as possible, and create a staking pool without asking for the permission to become a validator on the mainnet. Some things come from decentralization, the other comes from limitation over the control. While the foundation is supposed to support the network it's possible that in some scenarios the foundation can be forced to do something bad for the network. Let's say the government comes in and tries to force them. If they have less ability to do this, then there’s higher security over the network. When we design a contract we think, “What is the amount of value in this contract?” or “What is the ability of this contract to influence the network in general?”. If it's a small value, then it's okay to keep the credibility as long as the community trusted, if it's a large value, then it's not okay. When we’re actually going to get to the lockup contract, and the way it's designed you can see how, vesting for example, was designed to on one end allow the foundation to withdraw the remaining funds, but at the same time prevent the foundation from withdrawing the vested funds. It's a legal way of doing things, except it’s written into the code. Whitelist is a very critical contract, because before the funds are locked, the majority of funds are kind of controlling the network through local contracts in staking pools through this particular white list so it was important to design it in such a way that it keeps decentralization, and security of the network without giving control to the foundation. Let's say something happened, and the foundation started acting maliciously. Let's say you were able to create a new staking pool through a factory and delegate to the staking pool, now the foundation cannot really prevent you from delegating to this staking pool.
Staking Pool Factory Contract
Include Bytes Macro


The staking_pool_factory contract is a contract that internally has the code of a staking pool contract. In Rust you can do this by using the include_bytes macro. It basically takes a local file and embeds it into the binary as a vector. What happens there is within this WebAssembly binary we can have some piece of memory allocated which represents a binary of this particular staking pool. Let's get back to the top. 
Structure 
Once again this is the structure.



There was some information about the gas, we'll come back to this later.



There's a reward_fee_fraction that's just copied from the staking pool contract that we reviewed before.


External Contracts
There are the arguments of the staking pool that it takes, and there's traits, and external contracts so this is the high level interface that we use to call certain contracts.



We have two of them, the first can be any name. We call it ExtSelf, because it represents our own contract and contains a callback to a method on_staking_pool_create. The second trait is for the whitelist contract that we just saw called add_staking_pool. Here it is.



It’s exactly the same interface except the traits in Rust are like interfaces in java, for example. We just define the interface of a remote contract.
Initialization


Let's go first through the scenario. When a factory is created we verify that it was not initialized and we verify the staking_pool_whitelist_account_id, the account id of the whitelist contract,  during the initialization of the StakingPoolFactory. We need to know the staking_pool_whitelist_account_id. This is where the whitelist contract is deployed in order to whitelist our newly created staking pool instances. We remember this, and also create a set of already created accounts at the end of this snippet.
Main Method


Now that the staking pool factory is created, it's called poolv1.near for example, and the foundation has whitelisted the factory on a whitelist contract by issuing another transaction. Now that this staking pool factory is whitelisted it means it has the permission to white list the new staking pools that it creates. So now a validator comes in, and they want to create a staking pool for themselves. The way it works is they call create_staking_pool, and it takes a bunch of arguments. The first argument is a prefix. Let's say it's bisontrails without the suffix of this current account id, and this comes from NEAR account names.  An account can only create a subaccount, or very long account, so the staking pool factory creates a sub account under itself which will be bisontrails.poolv1.near. The owner_id is the account id of the owner of the staking pool as we discussed before. All of these three items are essentially arguments that you would pass to a staking pool when you first create it. It's an argument that you can proxy towards the staking pool. For example, staking_pool_id can be bisontrails.near. The stake_public_key can be the staking key from running a validator node, and reward_fee_fraction can be 10% for example. Note that this method is also payable it means it takes an incoming attached deposit, and the first thing it asks is,  “Did you attach enough deposit?” The deposit that you need to attach is 30 NEAR, and this has a lot of zeros, but this is because it's in yocto NEAR. You need to attach 30 NEAR mostly because you need to cover the state for the contract itself on a newly created staking pool. The contract is fairly large, it's 250 kilobytes and you need at least 25 NEAR for this, but it also takes some extra money to cover the price guarantee fund. This is one of those cases where you do have to have an attached deposit, because you cannot attach this much gas to this transaction. Also we cannot convert gas to NEAR within a contract, so ideally gas separation stays the same it's only used for computation, some read/write operations, and cross contract calls. Balance is used for state storage and transfers. So in our case this will create a new account, and creating a new account on NEAR requires you to pay for the storage of this account. Storage in our case is not only going to be the account itself but also the contract of this account. In our case this is the code of the staking pool contract.



The next thing we do is verify that the prefix doesn't have a dot meaning that it's not a sub account itself. Then we create a new staking_pool_account_id by concatenating our account id dot (.)  this new prefix. We verify that the new staking pool account id is valid. Basically if any of these asserts fail the NEAR Protocol will refund the tokens. If a transaction fails with an attached deposit, the attached deposit will go back to the sender or predecessor, because only the predecessor can attach a balance. It's safe to do like a bunch of asserts here. Next we verify that the owner_id of the staking pool is valid. This is basically just a bunch of extra helpers that are also verified on the staking pool. This is to make sure that if you don’t pass the correct arguments, or slightly incorrect arguments you better fail early before everything executes in order to avoid burning gas, and locking the tokens that you spent. Finally we check using insert that the staking pool doesn't exist. Basically insert will return true if it's a  new unique element, and return false if the element already exists in a set. This is how the Rust hashset works in the same way an ordered set works. So if the pool name already exists, we will not add this staking pool or try to create this account again. Insert does two things it adds this element to the storage, as well as returns true if the element is unique and didn't exist before or returns false if the element is already present. If the set did not have this value present true is returned, if this set did have this value present false it returned. 



Finally we use a medium level API, we don't use our raw cost methods, but at the same time we don't use a high level interface. The way it works is we create a new promise, which creates a temporary structure in our NEAR SDK, and it remembers the receiver of this promise. You can think about this as if the contract will issue the transaction towards that given account id. We will call a non-existing staking pool account id. Of course it's not a transaction but a receipt, but it's a technical detail. The next thing  is the first action on top of this promise. We start batching actions into this promise. The first action is the create_account. This action will create a new account or it will fail if the account already exists. Then we deposit the attached balance. We deposit the entire deposit that was passed to us, so that we don't keep it in this factory, and it will go with the same receipt on the remote account. Next we deploy a contract. As explained before, include_bytes is a macro that creates a static slice which we convert to a vector that will pass to a deploy action. This will deploy code on the remote account. You can only deploy code on the account you control, but create_account gives you permission to act like you're the owner of this account only for this particular transaction. You can use the deploy_contract method, you can stake and do some other stuff on behalf of this contract in the first transaction that you do. Finally we initialize the staking pool contract using the serda API. We take this structure, and we serialize this into JSON, the method is called new. The first argument is the attached deposit to this function call. We don't need it, because it doesn't expect it. The next is the amount of gas that you take from your current amount of gas, and immediately take it out after which it goes to the promise. Let’s say our method was called 100 tera gas, tera gas is a kind of unit that is roughly human understandable. 



You have 100 tera gas when you enter and we say we’re going to pass base (25 tera gas) multiplied by 2. We will immediately pass 50 tera gas to the function call of this method, so this 50 tera gas means we are only left with less than 50 tera gas, because we already burned some in the logic before. Plus every action that you include into this promise will also cost you some gas. For example, a deploy action will cost you in order to transfer the bytes from 1 account to another. Finally we use then. Then is similar to how javascript works, it attaches the dependency on the previous promise. This is the first promise, and we say then once it completes do the second promise. The way it works is you called let's say bisontrails.near called this contract (poolv1.near)  to create bisontrails.poolv1.near. We first create a promise to bisontrails.poolv1.near and then we attach a callback to this api which is not great in terms of using positional arguments for two different things. Either way it calls back the current account id. So it will call poolv1.near after the first promise has executed. Here is the structure: bisontrails.near calls poolv1.near creating a staking pool promise. Now this creates a promise to bisontrails.poolv1.near, and it also creates a promise to itself on the on_staking_pool method. 



It needs the result of this method before this method starts and it passes three arguments here. It passes the staking_pool_account_id, the attached_deposit and the predecessor_account_id. So that’s who called us, which account tried to be created, and how many tokens were attached in case we need to do a refund. Now if bisontrails.poolv1.near is successfully executed then on_staking_pool_create will receive the result of execution. Let’s say there was some misconfiguration that this method will also be called, but will receive a callback saying it failed .We returned the main promise after, then it means we returned on_staing_pool_create first. It's important, because the create_staking_pool method's result depends on the result of on_staking_pool_create promise. The transaction doesn't completely start in parallel, instead it now depends on the execution of this particular method.
Callback
Let's look at the callback. 



The first thing we do is we say that it can only be called by the current contract using assert_self which means no one else can call this promise.



The next thing we do is use another utility helper method which says if the dependency, the creation of the staking pool, succeeded or failed.



We do this the following way: we use two end methods first to check that the number of results is 1. This is an invariant because we already know that no one can call this twice, and the second is if the result is success. If the method executed successfully, then we return true if the promise failed, then it will be false. So now we know if the staking pool was created or not. Again, we also attached 50 tera gas to the callback so now we are in the callback which means we only have 50 tera gas.



If we succeed then we'll log that the pool was successfully created, then whitelist it. Then we call another promise from a callback, and attach 25 tera gas. So now we call staking_pool_whitelist_account_id, the whitelist contract. Now, we can whitelist the staking pool that we just created, because we passed this argument in towards the callback. We return this promise so that we don't stop the execution yet, because we only want to complete the entire transaction once the white listing completes. Rust doesn't have return, because if the last value without a semicolon is given then it's a return value. If the creation fails, it can fail for only one reason: if you put invalid ristretto key as we discussed briefly before. If there’s some weird curve that you created your staking key in, then it will fail. The reason why it fails is it means that the deposit that you passed to the staking pool for creation will be refunded to us, not to the predecessor. We have 30 NEAR on this contract, and we need to return them back to the sender so that we are not locking them up. The first thing we do is remove it from the list of staking pools that were created, because this was not successful. So we're saying that creation failed, and we're going to refund you the attached deposit. Now it's not a real attached deposit, because the callback doesn't receive the attached deposit. It flies through a separate refund receipt that usually arrives before the callback, and it also takes the predecessor_account_id. In our case if we call the predecessor_account_id, it will be us because this is a callback. We need to know who we should return tokens to, and the way we do this is create a promise using the new predecessor_account_id, and we return the tokens that were attached before. As you can see we do not return this promise we just say that's it, we don't care if it succeeds or fails the basic return of value false is saying the pool failed to be created. What happens now the transaction continues to be executed but the value will be returned to the front end. The front end is the NEAR CLI. You'll immediately know that the transaction has failed. You may not get your money back yet, so you're still waiting for this particular refund to execute in the next block but you already know that the pool was not created so that you can continue. This is an example of how you can do a parallel promise. This is how a staking pool factor works. Here is a getter which checks how many staking pools were created that can be called on the NEAR CLI. 


Conclusion
Тhis concludes the NEAR Live Contract Review | Part 3: Whitelist and Staking Pool Factory. Thank you for taking the time to learn NEAR, there’s more content coming soon in this series.

### Une introduction rapide au réseau DeBio

La solution biomédicale décentralisée sur le réseau Octopus
Le système biomédical actuel est en panne. Le statut quo empêche les patients d’accéder librement à leurs données et les prestataires de soins de santé ne peuvent garantir la sécurité des données de leurs patients. Le réseau DeBio vise à changer cela.
Qu’est-ce que le réseau DeBio ?
DeBio Network est une plate-forme décentralisée anonyme pour la médecine et la bioinformatique spécialisée dans les tests génomiques. DeBio vise à révolutionner l’industrie biomédicale actuelle en donnant aux patients la pleine souveraineté sur leurs données en utilisant les technologies de blockchain les plus avancées.
L’introduction de la blockchain dans l’écosystème technologique actuel joue un rôle important dans la poursuite d’une finance mondiale décentralisée, mais les cas d’utilisation offerts par la blockchain dépassent la simple finance. DeBio estime que l’avenir des données médicales repose en partie sur l’utilisation de la blockchain, notamment dans la spécialisation des cas d’utilisation de la technologie ainsi que l’interopérabilité.

Les tests génétiques centralisés sont un risque pour la vie privée
Au cours des dernières années, les tests génétiques ont explosé en popularité . En conséquence, les plateformes de tests génétiques directes aux consommateurs telles que 23andMe et AncestryDNA ont vu une augmentation du nombre de consommateurs. Mais ce que beaucoup de gens ne réalisent pas, c’est le risque implicite de confidentialité lié à l’utilisation de ces plateformes.
Les plates-formes de tests génétiques grand public directement destinées aux consommateurs sont centralisées, ce qui en fait une cible facile pour les violations de données. En 2020, il y a eu 1001 violations de données rien qu’aux États-Unis ; le secteur de la santé en pâtissant, a rapporté Govtech .
Ce qui est encore plus inquiétant, c’est que les données génétiques ne sont pas uniques à un individu mais uniques à l’arbre généalogique de l’individu. En utilisant un service de bio-informatique centralisé, vous mettez en danger non seulement votre vie privée mais aussi celle de vos parents éloignés.
Le préjudice en est sans ambiguïté car il est possible que vos parents éloignés, par exemple un cousin germain, soient affectés par votre décision. Ce qui est inquiétant, c’est l’idée qu’un parent éloigné dont vous ne connaissez même pas l’existence, passe un test génétique et que ses données génétiques soient retracées jusqu’à vous .
Les données génétiques peuvent être retracées jusqu’à vous même avec une petite quantité d’informations démographiques, telles que leur âge et leur état. Ce type d’informations peut être utilisé contre vous par les compagnies d’assurance, pour tirer le meilleur parti de leurs clients.

Le concept de réseau DeBio
Le concept principal derrière DeBio est basé sur la notion de vouloir augmenter les tests biomédicaux et génétiques pour les consommateurs sans perdre leur vie privée. Mais DeBio souhaite également encourager la recherche génétique en proposant des collaborations entre laboratoires souverains.
Un pont physique-numérique pour les tests anonymes
Les consommateurs peuvent sélectionner une large gamme de produits et de recommandations de laboratoire sur le marché des tests génétiques de DeBio. Une fois que le consommateur a choisi un produit, il lui suffit de prélever deux échantillons d’ADN via la méthode d’écouvillonnage buccal ou de prélever des échantillons de cellules orales avec des cotons-tiges.
Le consommateur envoie ensuite l’échantillon d’ADN au laboratoire dans une enveloppe avec la seule information identifiable écrite sur l’enveloppe est l’ID de suivi génétique de l’échantillon. Les laboratoires ne peuvent pas identifier les échantillons sans identifiant de suivi car, à des fins d’anonymat, DeBio ne collectera aucune information personnellement identifiable de quelque nature que ce soit, rendant les échantillons d’ADN introuvables jusqu’au consommateur.
Les résultats (par exemple, test et génome) sont ensuite cryptés avec la clé publique du consommateur récupérée à partir de la blockchain DeBio et stockés puis téléchargés sur un stockage décentralisé. Cela permet aux consommateurs de conserver une souveraineté totale sur leurs données cryptées — les consommateurs doivent posséder leurs clés privées pour décrypter les résultats.
L’équipe du réseau DeBio étend ce concept de «pont physique au numérique» pour utiliser des cas en dehors du marché des tests génétiques, qui peuvent inclure des tests de laboratoire pour les maladies et d’autres données de dossiers médicaux électroniques ou des informations personnelles sur la santé.

Sovereign Lab Collaboration pour offrir des produits communs intégrant les services de plusieurs laboratoires
Une fois que le consommateur a envoyé l’échantillon d’ADN au laboratoire, celui-ci en sera informé. Lorsque l’échantillon arrivera, le laboratoire commencera à séquencer les échantillons physiques ou commencera tous les tests de biomarqueurs. Après avoir terminé les tests suivants, le laboratoire chiffrera les résultats à l’aide de la clé publique du consommateur et les téléchargera sur un stockage décentralisé.
Les résultats ne peuvent pas être déchiffrés sans l’utilisation de la clé privée du consommateur, ainsi la souveraineté du consommateur sur les résultats de ses tests biomédicaux est sécurisée. Cependant, pour inciter davantage aux tests génétiques, les consommateurs ont le choix de mettre leurs données de tests génétiques en jeu pour qu’elles soient utilisées par d’autres laboratoires.
L’objectif d’avoir des laboratoires souverains est d’augmenter la disponibilité des produits et de permettre des produits communs en intégrant les services de plusieurs laboratoires. Cela permet également à DeBio d’évoluer car les laboratoires n’ont pas besoin d’être centralisés, ce qui permet à plusieurs installations de génétique autonomes de participer.



	

	
	
		
			
				Quiz: What problem does the DeBio Network intend to solve?
			
		

		
					

		
			
			
			
			Privacy concerns among online genetic testing platforms
		
			
			Obstacles in sovereign labs to do their work
		
			
			The lack of research in genomics
		
			
			Expensive healthcare
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





La pile technologique du réseau DeBio
La bioinformatique et les écosystèmes biomédicaux ont tous deux des exigences uniques quant à la manière dont ils doivent tous deux être accessibles aux professionnels menant les études, mais également suffisamment sécurisés pour protéger la vie privée et la souveraineté du patient. Ainsi, pour garantir la souveraineté du patient sur ses données, l’ensemble de la pile technologique se compose de solutions décentralisées allant de l’authentification décentralisée au stockage de fichiers décentralisé.

L’image est prise de DeBio Deck

DeBio a intégré une multitude de technologies de pointe dans la solution, y compris, mais sans s’y limiter :

 	Substrate
 	KILT Protocol
 	The Octopus Network
 	The InterPlanetary File System (IPFS)
 	Ocean Protocol

Substrate
La première technologie notable incorporée est le substrat. Le substrat est le cadre derrière le jeton Polkadot, permettant aux développeurs de créer des blockchains utiles. Les services de base seront construits à l’aide de Substrat, ce qui en fait les éléments de base de la solution. DeBio a choisi Substrat pour les deux raisons suivantes :

 	Interopérabilité blockchain (essentiellement pouvoir communiquer entre différentes blockchains).
 	Sécurité de la chaîne de relais (en appliquant des normes de sécurité plus strictes de la chaîne de relais hôte).

En plus de permettre aux chaînes de blocs de communiquer entre elles, la fonction d’interopérabilité applique également une norme de sécurité qui sera héritée par chaque chaîne para connectée à la chaîne de relais principale. En conséquence, la sécurité de la blockchain DeBio est améliorée en suivant les normes de la chaîne de relais correspondante.
Protocole KILT
La prochaine mention notable serait le protocole KILT . KILT est un protocole permettant de créer, d’attester et de vérifier des identités de manière anonyme sur Web3. Pour s’authentifier, chaque utilisateur doit créer une réclamation, qui serait ensuite envoyée à un certificateur de confiance.
Un certificateur a la responsabilité de certifier la réclamation d’un utilisateur, qui se transformera ensuite en un hachage à enregistrer sur la blockchain KILT. La revendication d’un utilisateur contient parfois des données sensibles concernant l’utilisateur, mais comme le hachage ne peut pas être retransformé en une revendication d’utilisateur, la confidentialité de l’utilisateur est garantie.
Après avoir reçu le certificat de l’attestateur de confiance, l’utilisateur peut désormais utiliser ses revendications sur les applications qui utilisent KILT et fait confiance à l’attestateur susmentionné. KILT, c’est la confidentialité dès la conception. Les applications qui vérifieront la réclamation n’ont pas besoin de passer par l’attestateur et compareront directement la réclamation à celle stockée dans la blockchain KILT, coupant l’attestateur du processus de vérification et le rendant entièrement décentralisé.
Le protocole KILT fournit une solution qui empêche les données d’être concentrées dans une entité. Il permet la souveraineté des données pour les personnes soucieuses de leur vie privée. DeBio s’est associé à KILT pour mettre en œuvre un système d’authentification décentralisé, car il correspond parfaitement au cas d’utilisation anonyme de DeBio .

The Octopus Network
Octopus est un réseau crypto permettant de lancer et d’exécuter des blockchains spécifiques aux applications Web3 à une fraction du coût. L’une des considérations liées à l’utilisation d’Octopus est que, par rapport à Polkadot, ils offrent un bail de sécurité nettement moins cher et des capacités inter-chaînes comparables. Octopus est soutenu par le protocole NEAR , NEAR est une blockchain hautes performances destinée à résoudre le problème de l’évolutivité et à augmenter la productivité des développeurs en simplifiant le processus de développement et en créant un environnement convivial pour les développeurs.
DeBio est déjà partenaire d’Octopus et sera l’une des cinq premières blockchains spécifiques aux applications (chaînes d’applications) lancées sur le réseau Octopus. DeBio fait également déjà partie d’ Octopus Guild , une communauté de développeurs et de chaînes d’applications sur Octopus Network.

The InterPlanetary File System (IPFS)
Le système de fichiers interplanétaire (IPFS) est un protocole conçu pour le partage et le stockage de données peer-to-peer entièrement décentralisés. IPFS a été créé comme une solution pour les projets décentralisés qui souhaitent stocker une quantité de données trop importante pour être stockée dans la blockchain elle-même. IPFS crée des adresses de contenu uniques en hachant le contenu lui-même. Chaque contenu unique aura une adresse différente pointant vers son emplacement. DeBio ajoute IPFS pour stocker des données biomédicales telles que des génomes humains cryptés et des dossiers médicaux électroniques cryptés.
Ocean Protocol
Ocean Protocol est conçu pour la consommation d’actifs de données de manière sécurisée et préservant la confidentialité. Il le fait avec la fonction Compute-to-Data et permet la monétisation des données sans jamais avoir à quitter les locaux du propriétaire. Le marché de données open source du Protocole Ocean appelé Ocean Market est forkable; l’équipe du réseau DeBio utilisera Ocean pour le jalonnement des données biomédicales.
Informatique de confidentialité
Pour stake les données biomédicales, DeBio hébergera des données biomédicales anonymes dans leur magasin de données privé. Ce processus n’implique pas l’IPFS susmentionné car le magasin de données sera complètement séparé de l’IPFS. Les utilisateurs qui souhaitent mettre en jeu leurs données devront déchiffrer et télécharger leurs données biomédicales dans leur magasin de données privé. Tout en transférant des données biomédicales déchiffrées vers une banque de données privée semble étrange, DeBio mettra en œuvre des concepts informatiques de confidentialité dans la banque de données pour protéger votre vie privée.

Image récupérée du livre blanc DeBio
Ce n’est qu’après le consentement de l’utilisateur que les ensembles de données sont agrégés via le proxy de calcul à données d’Ocean, et le tiers sera en mesure de créer des analyses et de traiter les données tout en restant sur site.
En incitant les utilisateurs à mettre en jeu leurs données génomiques/biomédicales, et en espérant que cela encouragerait davantage la recherche dans le domaine. De plus, le magasin de données privé ne recueillera pas d’informations personnellement identifiables, il n’y a donc pas lieu de s’inquiéter de la traçabilité de vos échantillons.
Pandu Sastrowardoyo, PDG de DeBio, a déclaré que l’une des raisons pour lesquelles elle a créé DeBio est d’aider la recherche génétique à prospérer en créant un marché de données génétiques entièrement anonyme. « DeBio est un tout nouveau système économique pour la génomique — permettant la souveraineté génétique, assurant la participation de petits laboratoires tout en dynamisant la recherche génétique. Le tout sur un modèle de type DeFi entièrement décentralisé », a déclaré Pandu.



	

	
	
		
			
				Quiz: Where does DeBio store the staked data?
			
		

		
					

		
			
			
			
			Inside the DeBio blockchain
		
			
			Inside the data tokens
		
			
			On a private-held data store
		
			
			On IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Couches d’architecture technique
Notre architecture technique se compose de quatre couches, l’infrastructure principale de la blockchain, la couche de logique métier de transport et générique, et enfin la couche de logique métier de premier niveau.

Architecture technique proposée par DeBio, image extraite du livre blanc DeBio
Layer 1: The Blockchain Infrastructure
La première couche contiendra les services de base. Les services de base sont construits sur Substrat, Octopus et IPFS. Le substrat est la pierre angulaire du service blockchain. Pour enregistrer des fichiers volumineux, DeBio utilisera IPFS et enregistrera l’adresse de contenu dans le substrat à la place. Enfin, toute la chaîne d’applications sera connectée à la chaîne de relais Octopus.
Couche 2 & 3 : La couche de transport et de logique métier générique
Les deuxième et troisième couches contiennent le transport et la logique métier générique. Ces couches sont chargées de fournir les données directement aux utilisateurs. Chaque palette contient la logique métier de base pour les interactions avec la blockchain et servira de couche d’abstraction à partir de la quatrième couche pour communiquer avec les services de substrat sur la première couche.
Couche 4 : La couche logique métier de niveau supérieur
La quatrième couche comprendrait l’interface utilisateur DeBio et Metamask. Toutes les interactions entre les utilisateurs et la blockchain se feront à partir de la quatrième couche. Toutes les requêtes seront également définies à partir du niveau supérieur, et seront ensuite traitées sur toutes les couches mentionnées précédemment. Pour financer chaque transaction, les utilisateurs peuvent utiliser Metamask pour payer en utilisant une pièce stable ERC20. Dans ce cas, DeBio utilisera le DAI comme pièce stable de choix.
Le modèle de jeton
Image récupérée du livre blanc DeBio

L’équipe DeBio Network a l’intention de libérer six jetons :

 	Récompenses de transaction Mainnet et jeton de validation ($DBIO)
 	Le jeton de gouvernance ($GBIO)
 	Le jeton de données génomiques ($GENE, via Ocean Protocol)
 	Le jeton de données Biomed ($MED, via le protocole océanique)
 	Le jeton de données des dossiers médicaux électroniques (EMR, via le protocole océanique)

Mainnet Coin (stable coin, etc)
La pièce du réseau principal sera adossée à une pièce stable. DeBio a décidé d’utiliser une pièce stable car elle doit être utilisée comme un échange stable pour les transactions et les frais liés au travail effectué par les laboratoires correspondants. DeBio va utiliser $DAI comme jeton stable.
Jeton de gouvernance ($GBIO)
Les jetons de gouvernance seront principalement utilisés pour le vote des laboratoires enregistrés. DeBio Network est une organisation décentralisée, il doit donc y avoir un système de gouvernance en place pour voter sur le marché DAOGenics. Alternativement, le jeton de gouvernance peut également servir de méthode d’intégration au laboratoire.
Les jetons de données ($GENE, $MED et $EMR)
Ces jetons sont utilisés comme méthode de transaction sur le marché des données. Lorsqu’ils jalonneront des données biomédicales sur le marché Ocean, les consommateurs seront récompensés par des jetons de données pouvant être convertis en $ OCEAN.
Validateur et récompenses de transaction ($DBIO)
Le jeton de validation est utilisé pour inciter les propriétaires de nœuds à valider les transactions et à sécuriser la dApp contre les utilisateurs non autorisés. Les incitations prévues pour les validateurs sont les récompenses LP et les jetons de gouvernance.
Transactions des consommateurs dans le réseau DeBio
$DAI est la pièce stable du réseau principal utilisée pour les transactions sur la plate-forme DeBio. Les consommateurs peuvent utiliser la pièce du réseau principal pour payer les produits et les frais de service. Les produits qui seront disponibles sur le marché comprennent des produits de tests génomiques, des produits de tests biomédicaux et un service souverain de stockage de dossiers médicaux électroniques (DME).

Image récupérée du livre blanc DeBio
Récompenses transactionnelles
Chaque transaction engagée par le consommateur sera récompensée par un jeton validateur, plus précisément un jeton $DBIO. Le prix d’un seul jeton $DBIO est déterminé par le marché de données DeBio Network qui héberge les données génomiques des consommateurs disponibles pour le jalonnement.
Staking de données dans le réseau DeBio
Après avoir acheté un produit sur le marché, les consommateurs peuvent choisir de miser leurs résultats sur l’Ocean Marketplace. Les données jalonnées par les consommateurs seront classées en jetons de données, appelés respectivement $GENE, $MED et $EMR pour les données génomiques, les données biomédicales et les dossiers médicaux électroniques (EMR). Les jetons de données seront conservés dans le réseau DeBio et agrégés sur le marché des données via Ocean Protocol en tant que jeton ERC20. Étant donné que les données génomiques, les données biomédicales ou le DME lui-même sont trop volumineux pour être enregistrés dans les jetons de données ERC20, les jetons de données serviront principalement de pointeur/lien vers les données correspondantes.
Les consommateurs qui jalonnent leurs jetons de données auront un rôle de « fournisseur de données » sur le marché des données. Toutes les transactions sur le marché des données Ocean utiliseront des jetons $ OCEAN. Ainsi, si la transaction aboutit, l’acheteur échangera des tokens $OCEAN contre des tokens de données ($GENE ou $EMR ou $MED). Alors que le « fournisseur de données » recevra les jetons $OCEAN suivants.


Image récupérée du livre blanc DeBio

Si l’acheteur de données souhaite accéder aux données liées dans le token de données, il doit au préalable envoyer le token de données au fournisseur de données. En conséquence, le fournisseur de données disposera à la fois du token $OCEAN et des tokens de données tandis que l’acheteur de données recevra les données liées par le token de données.

Image récupérée du livre blanc DeBio
A l’inverse, les tokens de données ($GENE ou $MED ou $EMR) reçus par la Fondation DAOGenics seront convertis en tokens $OCEAN. Après une certaine période, le jeton $OCEAN reçu par la Fondation DAOGenics sera converti en un jeton $ DBIO via un contrat intelligent sans autorisation.
En conséquence, la Fondation DAOGenics rachètera toujours le jeton $DBIO via un contrat intelligent sans autorisation basé sur le volume de transactions effectuées sur le marché des données. Plus de transactions sur le marché des données augmenteront la demande pour le jeton $DBIO.



	

	
	
		
			
				Quiz: When you stake data on the DeBio Network data marketplace, what do you earn?
			
		

		
					

		
			
			
			
			The mainnet coin ($DAI)
		
			
			Governance tokens ($GBIO)
		
			
			Transaction reward token ($DBIO)
		
			
			Ocean token ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
Les tests génétiques présentent de nombreux avantages. Pour la première fois dans l’histoire de l’humanité, les gens ont pu déterminer leur mode de vie pour poursuivre la longévité ; l’avantage d’une telle connaissance est stupéfiant. Mais si les tests génétiques ont leurs merveilleux avantages sans réglementations et normes appropriées, ils ont aussi leurs défauts. Sans la garantie d’avoir vos données génétiques privées et sécurisées, cela pourrait causer des problèmes à l’avenir.
DeBio vise à résoudre le problème avant qu’il ne soit trop tard. DeBio construit une plate-forme décentralisée pour vos besoins médicaux personnels, à commencer par la génétique. Notre concept permet une synergie entre les laboratoires de toutes les échelles tout en garantissant l’anonymat et la souveraineté des utilisateurs à chaque étape du flux de travail de la science des données génomiques — de la collecte d’échantillons, le stockage de données, à la génération de rapports.
Certaines personnes pourraient dire que notre ADN est la chose la plus privée que nous ayons , et nous prenons cela très au sérieux. Les tests génétiques axés sur l’anonymat devraient être l’objectif numéro un pour toutes les entreprises.
L’avenir est là, DeBio crée des solutions pour révolutionner l’industrie de la santé et des tests génétiques. Êtes-vous prêt à changer le monde avec nous ?

Adapted from the original article on Medium.

 

### DeFi trên NEAR

Giao thức NEAR là một nền tảng hợp đồng thông minh với đặc điểm thân thiện với người dùng và các nhà phát triển. NEAR cung cấp một nền tảng blockchain có khả năng mở rộng tốt nhằm dễ dàng triển khai các ứng dụng phi tập trung. NEAR bắt đầu được phát triển từ mùa hè năm 2018 bởi Alex Skidanov và Illia Polosukhin. Trong bài viết này, chúng ta sẽ cùng tìm hiểu về các ứng dụng DeFi trên NEAR.
Sự phát triển của DeFi
DeFi hay Tài chính phi tập trung là các công cụ tài chính được phát triển dựa trên công nghệ blockchain. Trong khi các công cụ tài chính tập trung đang gặp một số vấn đề như khả năng tương tác với người dùng hay nạn quan liêu thì các ứng dụng của DeFi lại giống như những mảnh ghép Lego mà người dùng có thể kết hợp chúng lại với nhau để tạo nên những công cụ tài chính hoàn toàn mới. Tổng vốn hóa của hệ sinh thái DeFi đã tăng vọt từ 7.40 tỷ đô la vào ngày 22 tháng 6 năm 2020 lên 97.7 tỷ đô la vào ngày 7 tháng 9 năm 2021. Điều đó có nghĩa là giá trị vốn hóa của DeFi đã tăng gần 1220% chỉ trong vòng một năm!



Tính đến thời điểm hiện tại thì tổng giá trị tài sản được khóa (Total Value Locked -TVL) lại trong lĩnh vực DeFi vào khoảng 83.86 tỷ đô la.
Tầm quan trọng thực sự của DeFi
Chỉ xét tới tổng giá trị được khóa trong DeFi thì ta sẽ không thấy được đầy đủ giá trị và ý nghĩa thực sự của nó. DeFi là một mảnh ghép quan trọng trong việc xây dựng nên Open Web và cũng chính DeFi đã đưa nhiều nhân tài tới với hệ sinh thái của Ethereum trong vòng 2 năm trở lại đây. Các hành động vốn phải mất hàng tuần để hoàn thành trong thế giới tài chính truyền thống thì với DeFi chúng ta chỉ mất vài giây.

Tuy nhiên, việc DeFi mang tới sự chú ý lớn tới hệ sinh thái Ethereum cũng đã tạo nên một nhược điểm cho hệ sinh thái này. Do nhu cầu sử dụng tăng đột biến, DeFi chính là nguyên nhân gây nghẽn mạng và phí giao dịch tăng trên Ethereum. Từ đó cũng làm tăng thêm các rào cản cho các nhà phát triển hay những người sáng tạo khi họ muốn tham gia vào hệ sinh thái của Ethereum.

Giao thức NEAR cung cấp một giải pháp khả thi, vừa nhanh hơn lại vừa rẻ hơn so với Ethereum.
DeFi On NEAR Protocol


Bây giờ, chúng ta hãy cùng điểm qua một số dự án DeFi tiềm năng trên hệ sinh thái NEAR.
Rainbow Bridge


Rainbow Bridge là cầu nối giữa NEAR và Ethereum. Nhờ Rainbow Bridge, hầu như tất cả tài sản có nguồn gốc từ Ethereum hiện tại đều có thể sử dụng được trên NEAR. Kể từ khi ra mắt, dự án đã được sử dụng để chuyển đổi hơn 1 triệu đô la giá trị ETH, DAI và các token khác. Cơ sở hạ tầng của Rainbow Bridge có thể dễ dàng thay thế và đảm bảo kết nối giữa NEAR và tất cả các blockchain tương thích với máy ảo EVM như Polygon, BSC, Avalanche, Optimism, Arbitrum, v.v. Đội ngũ phát triển của Rainbow Bridge đang làm việc để mở rộng cơ sở hạ tầng này nhằm hỗ trợ việc tương tác với các blockchain không tương thích với EVM như Bitcoin, Cosmos, v.v.

Một số điểm đáng chú ý về Rainbow Bridge:

 	Người dùng có thể sử dụng Rainbow Bridge trực tiếp thông qua Metamask.
 	Các giao dịch trên NEAR được xác nhận trong vòng chưa tới 2 giây với phí gas rẻ hơn 1 xu.

Cách mà một giao dịch được thực hiện trên cầu nối giữa NEAR<>Ethereum như sau:

 	Tài sản từ Ethereum chuyển tới NEAR mất khoảng 6 phút (tức khoảng 20 blocks)
 	Phí giao dịch ERC20 trung bình khoảng 10 đô la
 	Gửi tài sản từ NEAR trở lại Ethereum mất tối đa 16 tiếng (phụ thuộc vào thời gian xác nhận giao dịch trên Ethereum). Quá trình này tiêu tốn khoảng 60 đô la và phụ thuộc vào phí gas trên Ethereum.

Dự án Rainbow Bridge là một bước tiến quan trọng giúp tăng khả năng tương tác của NEAR với các blockchain khác. Hơn nữa, do giao dịch trên NEAR nhanh hơn và phí cũng rẻ hơn, người dùng của các blockchain khác có thể sẽ thuận lợi hơn trong việc tương tác với các tài sản Ethereum hơn là sử dụng cầu nối trực tiếp từ blockchain đó sang Ethereum.
Ref Finance


Ref Finance là nền tảng DeFi đầu tiên trên NEAR. Phiên bản đầu tiên của Ref có một số điểm tương đồng với Uniswap V2, cùng với việc hỗ trợ nhiều pool hơn, chủ pool có thể tự tùy chỉnh phí giao dịch cho pool và dự án này hoàn toàn thuộc sở hữu của cộng đồng. Mục đích chính của Ref Finance là tập hợp lại các thành phần cốt lõi của DeFi như sàn giao dịch phi tập trung (DEX), các giao thức cho vay, phát hành tài sản phái sinh, v.v.

Ref Finance có ngân quỹ là 35 triệu token REF, trong đó 10% được phân bổ cho quỹ phát triển các dự án sắp tới và 25% cho các hoạt động, sự kiện và quan hệ đối tác liên quan đến cộng đồng trong tương lai.

Các tính năng của Ref Finance:

 	Sàn giao dịch phi tập trung cùng với giao thức tạo lập thị trường tự động (AMM) cho phép việc giao dịch tự động hay swap giữa các token thuộc hệ sinh thái NEAR và các loại token được chuyển đến từ các blockchain khác.
 	Các nhà cung cấp thanh khoản có thể nhận về token REF hoặc một loại token NEP-141 bằng cách stake token thanh khoản.
 	Người dùng cũng có thể stake token REF để nhận thêm REF nếu như họ có ý định giữ REF dài hạn.

Ref là một dự án cộng đồng và đứng sau dự án này là một DAO (tổ chức tự trị phi tập trung). Trong Ref DAO có hai vai trò: hội đồng và ban cộng đồng:

 	Hội đồng: tạo ra các đề xuất và bỏ phiếu cho các đề xuất này. Đề xuất chỉ được thông qua nếu đa số hội đồng đồng ý. Hội đồng sẽ được thay đổi sau khi DAO hoàn toàn đi vào hoạt động.
 	Ban cộng đồng: Ban cộng đồng cũng bỏ phiếu tán thành hoặc từ chối một đề xuất. Hầu hết trường hợp thì hội đồng sẽ tuân theo quyết định của ban cộng đồng.

OIN Finance


OIN là một nền tảng phát hành stablecoin phi tập trung cho phép các dự án phát hành stablecoin mang thương hiệu của riêng họ. Thay vì phải đưa vào whitelist các tài sản thế chấp của họ trên các nền tảng khác, OIN sẽ tạo ra một stablecoin được thế chấp trên NEAR để mở khóa thanh khoản mà không cần bán token NEAR của họ. Các trường hợp sử dụng của OIN là: swap lấy các loại stablecoin chính thống khác, thêm đòn bẩy, bảo hiểm rủi ro, cho vay và rất nhiều tiện ích dành riêng cho hệ sinh thái.

Hiện tại, dòng sản phẩm chính trên OIN là OINDAO. Nó cho phép các dự án tham gia tạo ra nhóm tài sản thế chấp của họ để đúc ra các stablecoin được gắn nhãn thương hiệu của riêng họ. OIN thiết lập quy trình xác thực nhanh chóng cho mỗi giao dịch được khởi tạo trên blockchain thông qua hệ thống bằng chứng Merkle. Họ làm như vậy bằng cách đưa một phần thông tin dẫn tới “giao dịch gốc” trên sổ cái và sử dụng nó để xác thực cơ sở dữ liệu thông tin lớn hơn.

Một số tính năng nổi bật của OIN:

 	Chỉ cần dự án niêm yết quyết định các thông số thì việc đúc stablecoin rất dễ dàng và nhanh chóng
 	Tất cả các hợp đồng thông minh của OIN đều đã được thẩm định kỹ lưỡng
 	Được hỗ trợ về mặt công nghệ khi thiết lập các thông số liên quan tới rủi ro của các hợp đồng thông minh
 	Bạn cũng sẽ được hỗ trợ về mặt công nghệ để swap stablecoin mang thương hiệu của riêng bạn với các stablecoin chính trên Curve và Balancer để mở khóa thanh khoản cho tài sản của bạn

Skyward Finance 


Skyward Finance là một dự án launchpad mã nguồn mở mà các dự án có thể sử dụng để đưa ra thị trường token của họ khi mà token đó chưa có tính thanh khoản. Skyward có một trong những cơ chế định giá tốt nhất, giúp chống lại các cuộc tấn công sybil và các cuộc tấn công bởi các bot. Nền tảng này cho phép định giá tự động và phân phối token cho các dự án được xây dựng trên Giao thức NEAR. Nó thực hiện điều này bằng cách sử dụng phương thức đấu giá phi tập trung mà bất kỳ ai cũng có thể tham gia hoặc rút vốn vào bất kỳ thời điểm nào của cuộc đấu giá. Cách thức đấu giá này cũng giúp chống lại việc thao túng giá, hiện tượng front-run và tấn công sybil. Skyward Finance sẽ phát hành token cho cộng đồng, cho phép người sở hữu loại token này trở thành một phần của nền tảng và kiếm lợi nhuận.
Một số ưu điểm của Skyward Finance
Skyward Finance có một số ưu điểm sau:

 	Các dự án có thể launch token khi chưa có thanh khoản.
 	Cơ chế định giá của Skyward Finance có khả năng chống lại các cuộc tấn công bot và tấn công sybil. Nó cũng giúp ngăn chặn việc thao túng giá.
 	Các dự án có thể gây quỹ bằng bất kỳ token nào và cũng có thể khởi chạy nhiều đợt bán token bao gồm các token khác nhau.
 	Do cơ chế đấu giá của Skyward Finance không bị ảnh hưởng bất kỳ hình thức thao túng giá nào, các dự án và những người sáng lập của họ có thể tối đa hóa vốn dựa trên giá trị thị trường.
 	Các dự án không nhất thiết phải sở hữu token $SKYWARD để tham gia hoặc tạo các cuộc đấu giá.
 	Skyward Finance là dự án mã nguồn mở và permissionless, có nghĩa là các hợp đồng thông minh trên nền tảng này hoàn toàn độc lập.
 	Vì Skyward Finance chạy trên NEAR, nó có thể tận dụng khả năng mở rộng của NEAR và phí giao dịch cũng rẻ hơn so với việc chạy trên các nền tảng blockchain khác.




	

	
	
		
			
				Câu hỏi: Đâu là nền tảng giúp phát hành stablecoin?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool là một giao thức staking thanh khoản được xây dựng trên Giao thức NEAR. Các cá nhân có thể dễ dàng stake token NEAR của họ bằng cách sử dụng Meta Pool với các chiến lược stake tự động. Đổi lại, họ sẽ nhận được token “Staked NEAR” mà họ có thể sử dụng trong DeFi NEARverse. Các token stNEAR này cũng có thể được swap trở lại token NEAR ban đầu bất kỳ lúc nào.

Meta Pool đã trở thành một phần thiết yếu trong hệ sinh thái DeFi của NEAR khi nó giới thiệu liquid staking token đầu tiên của NEAR là stNEAR. Mã thông báo stNEAR có thể tích lũy phần thưởng stake và cũng đại diện cho các vị trí stake trên NEAR. Meta Pool cung cấp cho chủ sở hữu token NEAR một nền tảng dễ sử dụng và tạo ra lợi nhuận trong khi tạo ra một mạng lưới phi tập trung. Meta Pool sẽ chạy trên một DAO trên Sputnik V2 - một nền tảng được xây dựng trên NEAR để quản lý các Tổ chức tự trị phi tập trung.

Khi chủ sở hữu token stake NEAR vào Meta Pool, họ cũng sẽ nhận được một số token $META sau mỗi epoch. Mỗi epoch là 12 giờ. Số lượng token $META mà người dùng nhận được dựa trên APY staking trên NEAR (cụ thể là khoảng 10.2% một năm).
Cheddar 


Cheddar là dự án giúp tạo ra một mạng lưới khách hàng thân thiết cho NEAR và hệ sinh thái các ứng dụng phi tập trung của nó. Cheddar thiết lập các quan hệ đối tác chiến lược tích cực thúc đẩy việc sử dụng Giao thức NEAR khi thưởng cho người dùng. Mạng lưới khách hàng thân thiết đã được chứng minh là có thể thúc đẩy người dùng thực hiện các hành động có lợi cho doanh nghiệp. Thông qua Cheddar, token cộng đồng có thể được launch, từ đó cho phép các ứng dụng tăng lòng trung thành của người dùng và thêm nguồn doanh thu mới bằng cách sử dụng cơ chế farming.

Cheddar khác với các nền tảng yield farming khác vì nó cung cấp lợi ích lâu dài cho các HODL-ers thông qua powerUP. Nó cũng thúc đẩy việc sử dụng ứng dụng chéo trong toàn bộ hệ sinh thái NEAR, cho phép người dùng farm ra Cheddar thông qua việc yield farming, cung cấp thanh khoản hoặc sử dụng các dApps.
Cheddar mang tới những lợi ích gì cho hệ sinh thái NEAR

 	Kết nối các dApp - Cheddar tạo ra một liên kết chung giữa các ứng dụng ngoài các token riêng lẻ, từ đó tạo ra một hệ sinh thái trung thành với các dApp trên NEAR.
 	Sự tham gia của người dùng - Cheddar tạo ra sự tương tác lâu dài của người dùng thông qua các biện pháp khuyến khích khác nhau và xây dựng lòng trung thành thông qua các quan hệ đối tác chiến lược.

Nhảy xuyên chuỗi - Cheddar tạo ra sự liên kết giữa các chuỗi và giữ cho người dùng NEAR hoạt động và tương tác tích cực, đảm bảo rằng TVL trên NEAR được giữ nguyên.




	

	
	
		
			
				Câu hỏi: Đâu là nền tảng giúp xây dựng chương trình khách hàng thân thiết trên NEAR?
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Berry Club cho phép người dùng tạo các tác phẩm nghệ thuật kiểu pixel có thể chia sẻ được trong khi vẫn có thể thực hiện farming để lấy các token phần thưởng. Berry Club ban đầu là một sản phẩm PoC - Proof of Concept về DeFi nhưng kể từ khi được triển khai nó đã phát triển thành một dự án cộng đồng được rất nhiều người biết đến trên NEAR. Berry Club áp dụng một cách xuất sắc những tính năng của Giao thức NEAR, chẳng hạn như việc thanh toán tự động cho người tạo ra hợp đồng thông minh - điều mà chưa có trên bất kỳ blockchain nào khác.

Nhờ thiết kế độc nhất của NEAR, Berry Club và Berry Farm có thể mang lại lợi ích cho cả người dùng và người tạo hợp đồng thông minh, được thanh toán dưới dạng phần thưởng hợp đồng thông minh cho cả chủ sở hữu và người tạo token. Những lợi ích này phát sinh từ việc tăng cường sử dụng ứng dụng (Berry Club). Cách thức phân phối phần thưởng này không thể thực hiện được trên các nền tảng như Ethereum, ít nhất thì điều này không được áp dụng trong cách triển khai hiện tại của Ethereum. Đây là một lý do khác tại sao người dùng và các nhà phát triển nên thử nghiệm với NEAR.




	

	
	
		
			
				Câu hỏi: Tên gọi của cầu nối giữa NEAR và Ethereum
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kết luận
NEAR đang sở hữu một hệ sinh thái DeFi vô cùng thú vị và hứa hẹn còn phát triển hơn nữa trong tương lai gần. Và chúng ta cũng có thể thấy NEAR cung cấp một giải pháp vô cùng mạnh mẽ và hiệu quả, có thể thay thế cho Ethereum.

### Weekly Update - October 3, 2021

Brief Summary:

 	LNC weekly testing sprint was 🔥🔥🔥

Results:

 	Weekly LNC Beta Testing Results - 10 LNC Beta testers received 5$NEAR, abhish.near got 10 $NEAR for the best feedback! Way to go!


 	You may try NEATAR on Testnet https://neatar.github.io/
It is already integrated into NEAR Messaging System - NMS - app (Alpha version) https://nms.kiemtienonline360.com/  works best with our Telegram bot https://t.me/LNC_testenet_watcher_bot
 	Check new Guide NEAR Live Contract Review | Part 2: Staking Pool Contract


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC projects portfolio is coming!

### DeFi on NEAR Protocol

NEAR Protocol is a smart contract platform, which focuses on developer and user-friendliness. It provides a scalable platform for running applications. NEAR was founded in the summer of 2018 by Alex Skidanov and Illia Polosukhin. Today, in this article, we will be looking at DeFi applications on the NEAR Protocol.
The Rise Of DeFi
DeFi or Decentralized Finance are blockchain-based financial instruments. While centralized financial instruments are bogged down by lack of interoperability and red tape, DeFi apps are like Lego blocks that users can join together to create new instruments. As a result, the DeFi ecosystem has ballooned from $7.40 billion on June 22, 2020, to $250 billion on December 1, 2021. That’s a 3278%% rise in value in a little over a year!



 

As of now, the total value locked up in DeFi is around $209.42 billion.
The True Significance Of DeFi
Just talking about total value locked isn’t enough to understand the true significance of DeFi. It is a crucial element in building the Open Web and has been single handedly responsible for the influx of talent that Ethereum has experienced over the last two years. If you think about it, this makes absolute sense due to the revolutionary and composable nature of DeFi. Actions that could take weeks in the traditional finance world now take just seconds.

However, there is a flip side to this equation as well. Due to the spike in demand, DeFi has been responsible for causing network congestion and rising gas prices. As such, the barrier to entry for Ethereum has become significantly higher for newbie developers and creators.

NEAR Protocol provides a viable, faster, and cheaper alternative to Ethereum.
DeFi On NEAR Protocol


Let’s go through some of the most promising DeFi projects on NEAR.
Rainbow Bridge


The Rainbow Bridge exists between NEAR and Ethereum. All assets originating on Ethereum are now completely usable in NEAR. Since its launch, over $1 million worth of ETH, DAI, and other tokens have crossed the bridge. The Bridge infrastructure can be easily repurposed and ensure connections between NEAR and all EVM-compatible chains, like Polygon, BSC, Avalanche, Optimism, Arbitrum, etc. The team is currently working to extend this infrastructure to support non-EVM chains like Bitcoin, Cosmos, etc.

Here are some things you need to know about the Rainbow Bridge:

 	Users can be onboarded to Rainbow Bridge directly through MetaMask.
 	NEAR transactions get confirmed in under 2 seconds costs <1 cent in gas fees.

Here is what a NEAR<>Ethereum bridge transaction looks like:

 	Assets going from Ethereum to NEAR take about 6 mins (around 20 blocks).
 	ERC20 transactions cost about $10 on average.
 	Sending assets from NEAR back to Ethereum takes a maximum of 16 hours (due to Ethereum finality times). This process also costs around $60 due to ETH gas costs.

The Rainbow Bridge is an important innovation since it’s an essential first step in NEAR’s interoperability roadmap. Furthermore, since NEAR offers faster and cheaper transactions, it may be favorable for users of other chains to interact with Ethereum assets on NEAR rather than bridging directly to Ethereum.
Ref Finance


Ref Finance was the first DeFi platform on NEAR. The first version of Ref had some similarities with Uniswap V2, along with support for more pool types, configurable fees, and it is entirely community-owned. Its main aim is to bring together core components of DeFi like decentralized exchange (DEX), lending protocol, synthetic asset issuer, etc.

Ref Finance has a treasury of 35 million $REF of which 10% is allocated to a development fun for upcoming projects and 25% for future community-related activities, events, and partnerships.

Features of Ref Finance

 	Ref’s AMM DEX allows permissionless and automated trading between any native NEAR or bridged token.
 	 Liquidity providers can earn $REF or NEP-141 tokens by staking LP tokens.
 	Users can stake $REF tokens to earn more $REF over time.

Ref is a community project and is maintained by a DAO. The Ref DAO has two roles – council and the community board. 

 	Council: The Council creates proposals and vote on them. A proposal passes only if the majority of the council confirms them. The Council will be changed once the DAO is fully active.
 	Community Board: The Community Board also votes on or rejects a proposal. Mostly, the council will defer to the community board’s decision.

Burrow


Burrow is a non-custodial, decentralized, pool-based interest rates platform. It allows users to supply assets, earn interest, and then borrow against them to unlock liquidity. Burrow is quite similar to other pool-based protocols such as Aave and Compound and runs natively on the NEAR blockchain, with the protocol’s smart contracts written in Rust. The protocol unlocks liquidity for interest-bearing assets, particularly layer-1 staking derivatives like stNEAR (staked NEAR) and stETH (staked ETH). For example, Burrow users can deposit stNEAR as collateral and then borrow NEAR, creating a leveraged staking position. They can also create a self-repaying position by borrowing a stablecoin.

The Burrow ecosystem is powered by the BRRR token, the protocol’s native governance token. Most of the token’s supply will be distributed amongst active community members and Burrow users. The BRRR token has a total supply of 1,000,000,000 BRRR, with 50% allocated to the community, 20% to the DAO Treasury, 20% to the core team, and 10% to strategic investors in the project.
A NEAR-Native Interest Rate Market
Burrow differentiates itself from other platforms that supply assets to platforms by enabling users to utilize interest-bearing assets, which are at the core of the project’s value proposition. Interest-bearing assets are staking derivatives of fungible assets held in investment funds. In crypto, interest-bearing assets are staked derivatives such as stNEAR, stETH, etc. Burrow uses interest-bearing assets of base layers, unlocking yields from the base layer. Staking directly on the base layer provides the extra security of the main chain while also having the highest returns and the most risk-free rates.

Burrow also allows self-paying loans. Self-paying loans are unique because they repay themselves with yields generated from interest-bearing assets. When a user is supplying assets to Burrow, they can lock some of their assets as collateral, and users can borrow from the platform with their interest-bearing assets acting as collateral. Depending on the assets supplied and the interest generated, the loan can be paid off from the interest generated from the interest-bearing assets.

Burrow leverages the Aurora Rainbow Bridge to offer secure interoperability with other Layer-1 chains. Users can then access their assets on other interoperable chains with zero hassles, and supply them to Burrow, unlocking yields or as collateral for a loan. Currently, Burrow supports six assets for supply and borrowing; these are DAI, USDT, USDC, NEAR (wrapped), ETH (wrapped), stNEAR, and stSOL. The protocol also plans on adding bLUNA soon.

By building on NEAR, Burrow can leverage perhaps the most advanced Layer-1 technologies that are found only on NEAR, the Rainbow Bridge and Nightshade. Thanks to Proof-of-Stake and sharding in Nightshade, NEAR has been able to solve scalability issues that have been plaguing Layer-1 chains. This allows Burrow to operate with

 	Low Latency
 	A fully decentralized chain
 	Infinitely scalable chain
 	Low user fees

Aurora


Aurora on NEAR enables the execution of Ethereum contracts in a more performant environment. The project can be divided into two primary components: the Aurora Engine, an Ethereum Virtual Machine (EVM), and the Aurora Bridge, which provides trustless transfers of ERC-20 tokens between Aurora and Ethereum. The Ethereum Virtual Machine (EVM) is built on NEAR and allows developers to deploy their applications on an Ethereum-compatible, high-throughput, scalable, and future-safe platform that also features low transaction costs. The project has significant backing from several top VCs, including Electric Capital, Dragonfly Capital, Pantera Capital, Three Arrow capital, and Alameda Research. 

Thanks to Aurora, developers can enjoy the familiarity of Ethereum tooling while working with Solidity smart contracts on Aurora. Aurora also uses ETH as its base fee, enabling developers to experience a smooth experience for dApp users. Coupled with the unique features of the NEAR Protocol, Aurora is able to achieve an unprecedented level of scale and transaction speeds in an Ethereum-compatible environment. Aurora is 100% compatible with the Ethereum blockchain and offers a block time of 1 second and confirmation of transactions in 2 seconds.
Key Enhancements 
Aurora provides developers with a host of enhancements. Let’s delve a little deeper. 

 	Aurora offers fees that are up to 1000x lower than Ethereum fees. Transferring an ERC-20 token is lower than $0.01, while on Ethereum, the fee is around $5.40. 
 	Aurora can easily host thousands of transactions per second. This is a 50x increase compared to Ethereum. 
 	Aurora offers future-proof growth for ecosystems, with NEAR Protocol’s sharding offering horizontal EVM scaling and asynchronous communication between different Aurora shards. 

The platform’s native token, the $AURORA, has a fixed supply of 1 billion. The token has several use cases such as staking, voting, Rainbow Bridge transfer finalization fees, Aurora contract execution fees, and more. 
Bastion Protocol


Bastion protocol is an algorithmic, decentralized lending and borrowing protocol. The project is built on Aurora, NEAR’s EVM-Compatible and Gas-less layer. Bastion focuses on tokenomics, composability, UX, and algorithmic risk optimization. Thanks to NEAR, the project is able to achieve capital efficiency, high transaction speeds, low transaction costs, and highly precise liquidations. 

Thanks to projects such as Aave and Compound, money markets have become the biggest DeFi primitive on Ethereum. There is also the resounding success of chain-native lending protocols such as the likes of Solend on Solana and Benqi on Avalanche. Bastion has brought the next DeFi primitive to NEAR, enabling users to increase the productivity of their assets through lending or leverage without borrowing. 

Bastion gives users the ability to 

 	Put assets up as collateral
 	Supply assets and earn interest 
 	Leverage long
 	Short assets 
 	Borrow assets 

The protocol’s native token is the BSTN token, and it has two primary use cases. The token is at the center of the development of the Bastion Protocol. It allows token holders to vote on key project metrics such as protocol-owned liquidity, fee models, gauges, and staking. It also is key in aligning incentives between different stakeholders on Bastion. 

Building on Aurora has allowed Bastion to create an autonomous interest-rate engine that offers significantly greater capital efficiency, quick transactions combined with ultra-low transaction speeds, and precise liquidations. 
OIN Finance


OIN is a decentralized stablecoin issuance platform that allows projects to issue their own branded stablecoin. Instead of having to whitelist their collateral on other platforms, OIN will launch a NEAR-collateralized stablecoin to unlock liquidity without selling their NEAR tokens. OIN’s uses cases are – swapping for other mainstream stablecoins, adding leverage, hedging, lending, and a plethora of ecosystem-specific utilities.

Currently, the main product line on OIN is the OINDAO. It allows projects that join to create their own collateralization pool to mint their own brand labelled stablecoins. OIN establishes a quick validation process for each transaction initiated on the blockchain through the Merkle proof system. They do so by putting up small chunks of information leading up to a “root transaction” on the ledger and use it to validate a larger database of information.

Some interesting features of OIN are as follows:

 	It is easy and fast to mint stablecoins once the listing project decides the parameters.
 	OIN’s smart contracts have all been thoroughly audited.
 	Tech support to set up key risk parameters for the smart contracts.
 	Tech support to help you swap your branded stablecoin with mainstream stablecoins on Curve and Balancer to unlock the liquidity of your asset.

Skyward Finance 


Skyward Finance is a permissionless and open-source launchpad that projects can utilize to launch their tokens without any liquidity. Skyward has potentially one of the best price discovery mechanisms resistant to sybil attacks and bot attacks. The platform looks to enable price discovery and token distribution for projects that are built on NEAR Protocol. It does this by utilizing streaming time-based auctions that can be accessed by the general community in a decentralized manner. These auctions will also be resistant to price manipulation, front running, and sybil attacks. Skyward Finance will issue tokens to the community, allowing them to become a part of the platform and earn revenue. 
What Are Some Of The Advantages Of Skyward Finance?
Skyward Finance has several advantages, some of which are as follows.

 	Projects can launch their tokens without liquidity. 
 	Skyward Finance’s price discovery mechanism is resistant to bot and sybil attacks. It also cannot be manipulated. 
 	Projects can raise funds in any token and can also launch multiple token sales comprising of different tokens. 
 	Because of Skyward Finance’s immutability to any type of price manipulation, projects and their founders can maximize their capital based on market value. 
 	Projects do not require the $SKYWARD token to participate in or create a sale. 
 	Skyward Finance is open-source and permissionless, which means that the smart contracts on the platform are entirely independent. 
 	Because Skyward Finance runs on NEAR, it is able to take advantage of NEAR’s scalability and cheaper transactions. 




	

	
	
		
			
				Which of the following is a stablecoin issuance platform?
			
		

		
					

		
			
			
			
			OIN
		
			
			Ref Finance
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Meta Pool


Meta Pool is a liquid staking protocol that is built on the NEAR Protocol. Individuals can easily stake their NEAR tokens using Meta Pool and its automatic staking strategies. In return, they receive “Staked NEAR” tokens that they can utilize in the DeFi NEARverse. The tokens can also be swapped back to the original NEAR tokens at any point in time. 

Meta Pool has become an essential part of NEAR’s DeFi ecosystem as it introduces NEAR’s first liquid staking token, the stNEAR. The stNEAR token can accrue staking rewards and also represent staking positions on NEAR. Meta Pool offers NEAR token holders a platform that is easy to use and generates yields while creating a decentralized network. Meta Pool will run on a DAO on Sputnik V2, NEAR’s native platform to manage Decentralized Autonomous Organizations. 

When token holders stake on Meta Pool, they get $META tokens every epoch. Each epoch is 12 hours. These are received on top of the NEAR Protocol rewards, which are 10.2% APY. 
Cheddar 


Cheddar is creating a loyalty network for NEAR and its ecosystem of decentralized applications. It is accomplishing this through the establishment of strategic partnerships that actively promote using NEAR Protocol when rewarding users. Loyalty networks have been proven to successfully motivate users to perform actions that are beneficial to businesses. Through Cheddar, community tokens can be bootstrapped, enabling applications to increase user loyalty and add new revenue streams using farming mechanisms. 

Cheddar is different from other Yield farms as it provides long-term benefits to HODL-ers through powerUPs. It also promotes cross-application use throughout the NEARVerse, enabling users to farm Cheddar through Yield farming, Liquidity pools, or dApps. 
How Does Cheddar Benefit The NEAR Protocol 

 	dApp connectivity - Cheddar creates a common link between apps beyond just individual tokens, thereby creating a loyal ecosystem for dApps on NEAR. 
 	User engagement - Cheddar creates long-term user engagement through various incentives and building loyalty through strategic partnerships. 
 	Cross-chain hopping - Cheddar creates cross-chain interconnectivity and keeps users on NEAR active and engaged, ensuring that the Total Locked Value is preserved. 




	

	
	
		
			
				Which of the following is creating a loyalty program on NEAR?
			
		

		
					

		
			
			
			
			Cheddar
		
			
			OIN
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Berry Club 


Berry Club allows users to create shared pixel art while also farming token rewards. The Berry Club had started as a DeFi proof of concept but has since grown into an extremely popular community project on the NEAR Protocol. Berry Club makes excellent use of several of NEAR Protocol’s features, such as automatic payments to smart contract creators, which are not found on any other blockchain. 

Thanks to NEAR’s unique design, Berry Club and Berry Farm can benefit both users, and smart contract creators, which are paid out in the form of smart contract rewards to both token holders and creators. These benefits arise from the increased use of the application (Berry Club). This type of distribution of rewards is not possible on platforms such as Ethereum, at least not in its current implementation. This is another reason why users and developers should experiment with NEAR.




	

	
	
		
			
				The bridge between Ethereum and NEAR is called:
			
		

		
					

		
			
			
			
			Berry Club
		
			
			Rainbow Bridge
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Proximity Labs
A research and development firm targeting DeFi on the NEAR ecosystem.
Conclusion
NEAR Protocol already has a very exciting DeFi ecosystem and it is only going to grow further. As things stand, NEAR provides a powerful and efficient alternative to Ethereum.

### NEATAR Beta Test

Requirements 

 	Login with NEAR Testnet account to NEATAR  https://neatar.github.io/
 	Create NEATAR.
You can burn and mint another one, and repeat this process until you like your NEATAR - colors, colors combination, etc.
 	Make screenshot of your NEATAR at your testnet wallet https://wallet.testnet.near.org/?tab=collectibles

 	 Send a twit with a picture of your NEATAR and include this text:
I just minted my #NEATAR at https://neatar.github.io/ - a project from @learnnear portfolio
 	Fill the Feedback form.

The top 20 beta testers will get 5 NEAR, the best feedback submitter will get 10 NEAR. Please make sure that your testnet and main account MATCH exactly - eg. john.testnet and john.near.

Happy Testing!

### LearnNEAR.Club LNC Weekly Update - September 26, 2021

Brief Summary:

 	LNC NEAR Certified Developer L1 September day was the RECORD one!

Results:

 	September Demo Day  – 12 demo projects – check repositories at https://github.com/Learn-NEAR-Club
$NEAR470 were sent to demo projects developers - Huge congrats to all winners!
https://youtu.be/WBIoYUAR5ZM

Winners and Awards!
   


tinnguyen.near
20


nguyenpikachu.near
50


ngo-sy-truong.near
20


neutrino.near
50


thucdv.near
50


harrynguyen.near
100


tlgkien.near
20


tranxuanquy.near
20


quanle191.near
20


zefost.near
20


cryptovaibhav.near
100


AWARDS TOTAL:
470




 	Weekly LNC Beta Test sprint is running - https://learnnear.club/beta-test-feedback/

 	"NEAR Live Contract Review | Part 1: Voting Contracts" by @ekuzyakov  now available to (L)Earn

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC Pro is coming!

### NEAR Live Contract Review | Part 2: Staking Pool Contract

Introduction
Hey, I'm Eugene and this is the second part of the live contract review series and today we're going to review the staking pool contract, which is used right now to secure the NEAR Protocol proof of stake system. Basically all of the validators that  are currently running on NEAR Protocol are running on behalf of this contract. They don't control the account that stakes the amount of NEAR tokens required for proof of stake themselves, but instead the contract stakes this amount, and they just provide a staking pool and run their nodes. Today we're gonna dig into this contract. In the core contracts we have a staking pool contract and it's a little more complicated than the previous contract that we reviewed (the voting contract). So today we're going to focus more on the logic and less on the near_bindgen and Rust specific stuff, but it will probably involve a little more of NEAR Protocol knowledge. Here is the staking pool contract on the NEAR Github. Below is the original video which this guide is based on.


lib.rs
Constructor Structure


As before, the contract starts from the main structure. In this case it's a staking contract structure. As you can see there's near_bindgen, and BorshSerialize and BorshDeserialize. The structure now has way more fields than the past one, and there are some comments on them, most of them are probably up to date. The logic of the staking pool contract allows us to do the following: basically anyone can deposit some amount of NEAR tokens to the staking pool, and delegate them to the staking pool by staking them in the pool. That allows us to bundle together balances from multiple people (we call them accounts here) into one large stake, and this way this large state may actually qualify for validator seats. NEAR Protocol has a limited amount of seats for a single shard right now, there's at most 100 validator seats. You can think about the seats in the following way: if you take the total amount of token staked and divide it by 100 the result will be the minimum amount of tokens required for a single seat, except it's a little bit more complicated to involve removing the stakes that are not qualified to contain this minimum amount, etc. This contract basically is a standalone contract without any access key on it that is controlled by the owner. In this case the owner is provided in the initialization method. 
Initialization Method


So let's go to the initialization method. It has three arguments and first is the owner_id which is the account id of the owner account. The owner has a bunch of permissions on this contract that allow the contract to perform actions that are not available for the rest of the accounts. One of these methods was to vote on behalf of the staking pool to the voting contract that we discussed last time. So the owner can call the vote method. 





We then verify that the predecessor is equal to the owner since this method can only be called by the owner.



So what the vote method does is that it verifies that the method was only called by the owner and then it verifies some logic, but that's not important right now. 



So the contract is the owner, and this owner can do certain things, it has the extra permissions. Then it takes a few more fields: it's taking the stake_public_key. When you stake on the NEAR Protocol you need to provide a public key that will be used by your validator node to sign messages on behalf of the validator node. This public key can be different from any access key, and ideally it should be different from any access key because your node may be run in a data center that may be vulnerable to some attacks. In this case the most they can do is actually do something bad to the network, but not to your account. They cannot steal your funds, and you can easily replace this key when compared to how you need to replace the bad access key. Finally, the third argument that the contract takes is the initial reward_fee_fraction. This is the commission that the owner of the staking pool takes for running the validator node. 



This is a fraction that has a numerator and denominator, and it allows you to basically say "I take 1% of the rewards for running this particular pool", for example. Let's say you have a 1 000 000 tokens they acquired some reward, let's say there is a 10 000 token reward, then the owner will take 1% out of this which is 100 tokens. Floats have an unpredictable behavior when you multiply them. For example, with fractions, you can use math with a  larger number of bits. So the way you do division, for example, is you first multiply the amount which is u128 by a numerator (this can already overflow in u128), but that's why we do this in u256. Then you divide it by the denominator which should bring it below u128 again. This gives you higher precision than float64 which cannot operate with u128 bit precision, so it will have some rounding errors or precision errors when you do the math. So you either need higher precision floats, which are not really different from the math where we simulate this with u256. Solidity originally didn’t support floats, and we also originally did not, but that cast some issues around string formatting in Rust  for debugging, so we decided that there is no harm in supporting floats especially as we standardize this on the vm side. The biggest issue with floats was the undefined behavior around certain values of loads. For example, what other bits contain when you have an infinite float. We standardized this, and now they are equivalent platform independent. So, it's okay to use floats now in our vm environment. 



The standard practice with init is that we first check that the state doesn't exist. Then we verify the input. The first thing we do is verify that the fraction is valid and check that the denominator is not zero. Next, we have an else statement that checks that the numerator is less than or equal to the denominator, which means that the fraction is less than or equal to 1. This is important to avoid some logic mistakes. The next thing we do is verify that the account is valid. This contract was written before some of the helper metrics that exist now. For example, we have the valid account id in JSON types that does this check automatically during deserialization, if it's invalid it will just panic. After that we pull current account balance of the staking contract. This balance is usually large enough because it has to pay for the storage of this particular contract, and then we say that we’re going to allocate some tokens for the STAKE_SHARE_PRICE_GUARANTEE_FUND. The staking pool has certain guarantees that are important for local contracts. Guarantees ensure that when you deposit to the staking pool, you should be able to withdraw at least the same amount of tokens, and you cannot lose tokens even for as much as 1 000 000 000 000 yocto NEAR on this contract by depositing and withdrawing from the staking pools. The STAKE_SHARE_PRICE_GUARANTEE_FUND fund is around 1 trillion yocto NEAR, while we usually consume around 1 or 2 trillion yocto NEAR for rounding errors. Finally we remember what the balance that we're going to stake on behalf of this contract is. This is required to establish some baseline to limit the rounding differences. Next, we verify that the account has not staked already. This might break some logic. We don't want this to happen, so we want to initialize the contract before it stakes anything. Finally we initialize the structure, but we don't return it immediately. We just created the :StakingContract structure here.



Then we issue a restaking transaction. This is important, because we need to make sure that this staking key that was provided is a valid  ristretto restricted key, for example, a 5 119 valid key. There are some keys on the curve that are valid keys, but are not ristretto specific, and validator keys can only be ristretto specific. This is a NEAR Protocol specific thing, and what happens is it makes a staking transaction with the given key. Once this transaction is created from the contract, we validate this transaction when it leaves. If the key is invalid, then it will throw an error, and the entire initialization of this staking pool will fail. If you pass an invalid stake_public_key as an input then your contract consolidation and deployment, and everything that happens in this one batch transaction will be reverted. This is important so that the pool doesn't have an invalid key, because that might be allowing you to block the stake of other people. As a part of the guarantees we're saying that if you unstake, your tokens will be returned in 4 epochs. They will be eligible for withdrawal, and this is important to be able to return them to lockups. 



I think this is too many details before I explain the high level overview of how contracts work and how balances work. Let’s explain the concept of how we actually can distribute rewards to account owners in constant time when an epoch passes. This is important for most smart contracts. They want to act in constant time for every method instead of linear time for the amount of users, because if the amount of users grows then the amount of gas required to operate a linear scale will grow as well, and it will eventually run out of gas. That's why all smart contracts have to act in constant time. 
Account Structure


The way it works for every user we keep the structure called account. Every user that has delegated to this staking pool will have a structure called account that has the following fields: unstaked is the balance in yocto NEAR that is not staked so it's just the balance of the user. Then stake_shares is actually a balance, but not in NEAR, but instead in the number of stake shares. Stake_shares is a concept that was added to this particular staking pool. The way it works is when you stake, you essentially buy new shares at the current price by converting your unstake balance into stake shares. A stake share price is originally 1, but over time it grows with the rewards, and when the account receives rewards its total stake balance increases, but the amount of total stake shares doesn't change. Essentially when an account receives validation rewards, or some other deposits straight to the balance, it increases the amount that you can receive for every stake share. Let's say, for example, you originally had 1 million NEAR that was deposited to this account. Let's say you get 1 million shares (ignoring the yocto NEAR for now), if the staking pool received 10 000 NEAR in rewards, you still have 1 million shares, but the 1 million shares now corresponds to 1 010 000 NEAR. Now if someone else wants to stake at this time, they will purchase stake shares internally within the contract at the price of 1.001 NEAR, because every share is worth that now. When you receive another reward, you don't need to buy more shares despite the total balance, and in the constant time everybody shares the reward proportionally to the number of shares they have. Now, when you unstake, you're essentially selling these shares, or burning them using the concept of fungible tokens in favor of unstaked balance. So you sell at the current price, you decrease the total amount of stake as well as the total amount of shares, and when you purchase you increase the total stake balance, and the total stake shares while keeping the price at constant. When you stake or unstake you don't change the price, when you receive the rewards you increase the price. 



The price can only go up, and this may lead to the rounding errors when your yocto NEAR and your balance cannot correspond precisely. That's why we have this guarantee fund of 1 trillion yocto NEAR that will throw one extra yocta NEAR into the mix a few times. Finally, the final part is there, because the NEAR Protocol does not unstake and return the balance immediately, it has to wait three epochs until your balance will become unstaked and returned to the account. If you unstake you cannot withdraw this balance immediately from the staking pool, you need to wait three epochs. Then you remember at which epoch height you called the last unstake action, and after three epochs your balance will become unlocked, and you should be able to withdraw from unstaked. However, there's one caveat: if you call unstake at the last block of the epoch, the actual promise that does unstaking will arrive for the next epoch. It will arrive at the first block of the next epoch, and that will delay your locked balance in becoming unlocked to four epochs instead of three. This is because we recorded the epoch in the previous block, but the actual transaction happened in the next block, in the next epoch. To make sure that doesn't happen we lock the balance by four epochs instead of three epochs to account for this border case. That's what constitutes an account. The idea of shares is not that new, because on Ethereum the majority of liquidity providers, and automated market makers use this similar concept. When you, for example, deposit to the liquidity pool you get some kind of token from this pool instead of the actual amount that is represented there. When you withdraw from the liquidity pool then you burn this token, and get the actual represented tokens.  The idea is very similar to calling them shares, because they have a corresponding price, and we could have called them differently. This was from almost the beginning of this staking pool contract. There was exploration around how we can do this properly, and one way was that we would limit the number of accounts that can deposit to a given pool account for this particular update. We eventually landed on the constant complexity time and it was actually a simpler model. Then the math of the stake_shares structure became somewhat reasonable even so there's some involved as well there.
Contract Types
Let’s go through this contract. It's not as well structured as a lockup contract for example, because lockup is even more complicated. The types are still bundled in the same contract. There are a bunch of types of types, for example reward_fee_fraction is a separate type. 



Account is a separate type and there's also a human readable account which is also a type that is only used for view calls, so it's not used for logic internally.



Then after we finish with all of the types, we have cross contract calls using a high level interface.



There's two of them. The way it works is that you have a macro from near_bindgen called ext_contract (standing for external contract). You can give it a short name that it will generate that you will be able to use. Then you have a trait description describing the interface of the external contract that you want to use. This describes the fact that you can call a vote method on a remote contract, and pass one argument in. The argument is_vote  which is a true or false boolean. Now you will be able to create a promise when you need it, and pass a positional argument instead of a JSON serialized argument. The macro will make it into low-level promise apis behind the scenes. The second interface is for a callback on our self, this is fairly common, you can call it ext_self. When you need to do a callback, and do something on the result of the asynchronous promise you can have this type of interface. What we do is we check if the staking action succeeded. Finally, we have this main implementation structure  implementation body of the staking pool. 
Contract File Structure
This contract is split into multiple modules. 



You have libs.rs which is the main input, and you also have an internal module. The internal module has the implementation without the near_bindgen macro, so none of these methods will be visible to be called by a contract by someone else on the chain. They can only be called within this contract internally so that they don't generate JSON formats, and don't deserialize state. They all act as regular rust methods. How this contract works high level is that when an epoch passes you may acquire certain rewards as a validator. 
Important Methods of the Contract


We have a ping method which pings the contract. The ping method checks if an epoch has passed and then we need to distribute rewards. If the epoch changed then it will also restake, because there might be some change in the amount of total stake the contract has to stake. The next is deposit.



The deposit method is a payable which means it can accept an attached deposit. This is similar to the Ethereum decorator that allows you to receive funds only to the methods that expect them. So near_bindgen by default will panic if you try to call a method, for example ping, and attach a deposit to this method. Consequently, payable allows us to attach deposits. In every method there's an internal ping to make sure that we distributed previous rewards before changing any logic. The common structure is that if we need to restake, then we first do some logic, and then restake. 



The next method is deposit_and_stake.  This is a combination between two methods. First, you deposit the balance to the stake balance of your account, and you also want to stake the same amount immediately instead of doing two transactions. It's also payable because it also accepts a deposit.



The next is withdraw_all. It tries to withdraw the entire unstake balance from the account that called it. When you interact with the staking pool you need to interact with the account that owns the balance. In this case this is is the predecessor_account_id and we basically check the account, and then we withdraw the unstaked amount if we can. If it's not withdrawn, then it will panic. For example, if it's still locked due to unstaking less than 4 epochs ago. 



Withdraw allows you to withdraw only partial balance. 



Then stake_all stakes all unstaked balance, and it's pretty rare to use this method, because you usually use deposit stake, and it already has all the stake balance.



Then in the stake method you just stake some amount of stake balance. Moonlight wallet uses a separate cost to deposit in stake, but they use a batched transaction to do this. 



Finally you have unstake_all which basically unstakes all your stake shares by converting them to yocto NEAR. There is a helper method which says convert my number of shares to an amount of yocto NEAR and round down, because we cannot give you extra for your share multiplied by price. That's how we get the amount and then we call unstake for the given amount. 



The staked_amount_from_num_shares_ rounded_down logic uses u256, because balances operate on u128. To avoid overflow, we multiply the total_staked_balance by the number of shares in u256. The price is the quotient rounded down. 



The round up version staked_amount_from_num_shares_rounded_up is very similar except, we do a check that allows us to round up. At the end of both we cast it back to u128. 

Then we have an unstake action which is very similar to unstake_all, except you pass the amount.


Getter/View Methods
After that there's a bunch of getter methods that are view calls that return you some amounts. You can get the account unstaked balance, account staked balance, account total balance, check if you can withdraw, total stake balance, which is the total amount the staking pool has in active stake.



Then you can get who the owner of the staking pool is, you can get the current reward fee or commission of the staking pool, get the current staking key, and there's a separate thing that checks if the owner paused the staking pool.



Let's say the owner does a migration on the staking pool on the node. They need to completely unstake, so for example, they can pause the staking pool which will send a state transaction to the NEAR Protocol, and then will not restake until they resume the staking pool. However, you can still withdraw your balances, but you will stop acquiring rewards after it's passed. 



Finally you can get a human readable account which gives you how many tokens you actually have for the number of shares at the current price, and finally it says whether you can withdraw or not.



Then it gives you the number of accounts which is the number of delegators to this staking pool, and you can also retrieve multiple delegators at once.  This is pagination on a large number of accounts within the unordered map. One way of doing this is you use the helper that we call keys_as a_vector from the unordered map. It gives you a persistent collection of keys from the map, and then you can use an iterator to request accounts from these keys. That's not the most efficient way, but it allows you to implement pagination on unordered maps. 
Owner Methods


There are a bunch of owner methods. An owner method is a method that can only be called by the owner. The owner can update the staking key. Let's say they have a different node, and the owner need to use a different key. All of these methods first check that only the owner could call it.



This is the method that changes the commission on the staking pool. The owner can change the commission that will be active at this epoch starting from this epoch immediately, but all of the previous commissions will be calculated using the previous fee. 



Then this was the vote method that allowed us to transition to phase two of the mainnet.

Next are the two methods that I already described which allow to pause staking and to resume staking. 



The rest are just tests. Most of the logic is happening in the internals. 
Simulation Test
We also basically have simulation tests for a particular pool. This simulation test is how the network is actually going to work. We first initialized the pool. 



Bob is the delegator. Bob called the pool deposit method which is the deposit_amount using the deposit method. Then Bob can verify that the unstaked balance is working correctly. Then bob stakes the amount. Then we check the amount of stake now. We verified that Bob has staked the same amount. 



Bob calls the ping method. There's no rewards, but in simulations the rewards are not working anyway so you need to manually do this. We'll verify once more that Bob's amount is still the same. Then the pool resumes. We verify that the pool has resumed, then lock to zero. Then we simulate that the pool has acquired some rewards (1 NEAR) and bob pings the pool. Then we verify that the amount that Bob received is positive. That's a very simple simulation case which is saying that Bob first deposited to the pool which verifies that the pause and resume works, or simulates that it works and makes sure that the pool doesn't stake while being paused. Then when resumed, the pool actually stakes. So this test verifies not only this, but also that Bob has acquired the reward, and got distributed the reward. There's another test that verifies some logic but that's more complicated. There are some unit tests on the bottom of this that are supposed to verify certain stuff. 



Some of these tests are not ideal but they verify certain stuff that was good enough to make sure that math adds up.
internal.rs
Internal Ping Method


Let’s move onto internal_ping. It is the method that anyone can call through ping to make sure rewards are distributed. Right now we have active staking pools and there's an account sponsored by one of the NEAR folks that basically pings every stake in the pool every 15 minutes to make sure they have distributed the rewards to display on the balance. That way the reward distribution works. We first check the current epoch height, so if epoch height is the same then the epoch hasn't changed, we return false so you don't need to restake. If the epoch has changed then we remember that the current epoch (epoch height) exists, we get the new total balance of the account. Ping may be called when some tokens were deposited through deposit ballots, and they are already part of the account_balance, and since ping was called before we need to subtract this balance before we distribute the rewards. We get the total amount that the account has including both locked balance and unlocked balance. Locked balance is a staked amount that acquires rewards, and unlocked balance also may have rewards in certain scenarios where you decrease your stake, but your rewards will still be reflected for the next two epochs. After that they will come to the unstaked amount. We verify using assert! that the total balance is more than the previous total balance. This is an invariant that the staking pool requires. There was a bunch of stuff on the testnet that happened to fail this invariant because people still had access keys on the same staking pool,  and when you have it you spend the balance for gas, and you may decrease your total balance without acquiring the reward. Finally we calculate the amount of rewards that the staking pool received. This is the total balance minus the previous known total balance, the balance from the previous epoch. If the rewards are positive we distribute them. The first thing we do is calculate the reward that the owner takes for themselves as a commission. 



We multiply the reward_fee_fraction by the total reward received and this is similarly rounded down with the numerator in u256 multiplied by value divided by denominator in u256. 



The owners_fee is the amount in yocto NEAR that the owner will keep for themselves. The remaining_reward is the remaining rewards that have to restaked. Then it goes on to be restaked. The owner received the rewards in yocta NEAR, not in shares, but because all of the logic has to be in shares the owner of the staking pool purchases shares at the price of the post reward distributions to the rest of the delegators. So num_shares is the number of shares that the owner will receive as compensation for running the staking pool. If it's positive we increase the amount of shares, and save the owner account back, and we also increase the total amount of stake in shares. If for some reason during rounding down this balance became zero, the reward was very small, and the price per share was very large, and the pool only received zero rewards. In that case this balance will just go to the price per share instead of compensating the owner. Next, we put some total logging data that says that the current epoch exists,  that we received the rewards in an amount of staking shares or tokens, that the total stake balance of the pool is something, and we log the number of shares. The only way we expose the number of shares to the external world is through the logs. Next, if the owner received rewards, it is saying that the total reward was so many shares. Lastly, we just remember the new total balance and that's it. We have distributed all rewards in constant time and we only updated one account (owner's account) for commission, and only if the commission was positive. 
Internal Stake Method


The internal_stake is where we implement the price guarantee fund. Let's say the predecessor, in this case we're going to call it account_id wants to stake an amount of tokens. Balance is actually not a JSON type, because it's an internal method so we don't need JSON here. We calculate how many shares are rounded down that are required to stake the given amount, so this is how many shares the owner will receive. It has to be positive. Then we check the amount the owner should pay for the shares, again rounded down. This is to guarantee that when the owner purchased shares, and converted them back without rewards never lost the 1 yocto NEAR, because it might break the guarantee. Finally, we assert that the account has enough to pay for the amount charged, and we decrease the internal unstaked balance, and increase the internal number of shares balance of the account. Next we round the staked_amount_from_num_shares_rounded_up up so that the number of shares is actually rounded up. This 1 extra penny or 1 extra yocto NEAR will come from the guaranteed fund during the rounding up of the shares. We charged the user less, but we contributed more to the amount from this 1 trillion yocto NEAR that we had originally designated for this. This difference usually is just 1 yocto NEAR that may come from rounded up or down. After that there is the amount of total_staked_balance and total_stake_shares. Next we mint new shares with them. Finally we put a log and return the result. 



Unstaking works very similarly. You round up to the amount of shares you need to pay. Then we calculate the amount you receive, again rounding up to be overpaying you for this. This also comes from a guarantee fund. Then we decrease the shares to increase the amount and state when you can unlock the balance between four epochs. The unstake_amount is rounded down so that we unstake slightly less to guarantee the price of other participants of the pool. That's pretty much how the staking pool works and how the math works. We compensate for rounding errors from the funds that we allocated. 
Conclusion
We updated the ristretto keys during the design of this contract and it was surprising that we needed to account for this. In the STAKE_SHARE_PRICE_GUARANTEE_FUND 1 trillion yocto NEAR should be enough for 500 billion transactions which should be long enough for the staking pool so that it cannot be refilled because the rewards will be immediately redistributed to the total_stake_balance on the next ping.  We spent quite a bit of time, and effort on this contract, because we did tons of security reviews including internally and externally, especially around this math. That was complicated, and some stuff was discovered like the ristretto key that popped up during the reviews. We marked the change log of this contract, as well in the readme there's a bunch of stuff that popped up during the development, and testing on the live system, but the original version took about a week to write. Later we cleaned it up, tested it and improved it. Then we did a bunch of revisions. Pausing, and resuming was asked for by the pool, because otherwise the owner had no ability to unstake if their node goes down. They will be attacking the network. Essentially this active stake would be requesting the validation and not running the network. We used to not have slashing. This was just not an issue for the participants, but it was an issue for the network itself. That way the owner can pause the staking  if they don't want to run the pool they migrate into the pool, and communicate as much as possible before this. Next we updated the vote interface to match the final phase two voting contract. We added helper view methods to be able to query accounts in a human readable way. Finally, there were some improvements around batching methods together so deposit_and_stake, stake_all, unstake_all and withdraw_all instead of having to make a view call first, get the amount, and put the amount to call the stake. Here is the way we fixed it. 



When you stake, not only do you stake the amount, we also attach a promise to check if the stake was successful. It’s needed for two things: you if you're trying to stake with an invalid key (not ristretto specific key) then the promise will fail before execution. It will fail validation before sending it, and that will make it so you don't need to check it within the contract. It will revert the last call, and it's all going to be good. We also introduced the minimum stake on the protocol level. The minimum stake is one tenth of the amount of the last seat price, and if your contract tries to stake less than this then the action will fail, and you will not send the promise. Let's say you want to unstake some amount and you dropped your balance below one tenth of the stake. The staking action may fail, and you will not unstake, while you need it to guarantee that unstaking has to happen. In this case we have this callback that checks that the staking action has successfully completed. This callback basically checks that if it fails, and the balance is positive we need to unstake. So it will call unstake for an action where the stake amount is zero to make sure that all balance is released. You can withdraw in 4 epochs during the testing of these contracts that we did on the beta 9 testnet before maintenance .The contract was ready maybe around the summer time so the testing of this iteration of this took probably like 2-4 months due to the complexity that it involves in interacting with the protocol. There was quite a lot of  learning from pagination to helper methods, and batching together some stuff. One thing that would be really nice to have stake or deposit and stake all on a lock-up contract. Right now you have to manually issue how much you want to stake on a lockup contract, but it would be great if you didn't need to think about your yocto NEAR, and how much it's locked for storage. You just want to stake everything from your lockup, but because it was already deployed it was too late to think about this. There's also some gas that is hardcoded, and with the common decrease in fee these numbers cannot be changed because they're already on chain. 



So vote is not important but the ON_STAKE_ACTION_GAS method requires you to have a large number for every stake and you cannot decrease it. Risk taking actions on every call on this contract will require us to have a large amount of gas and the problem is that that's wasteful. Let's say we agree on burning all the gas, this gas will be always burned, and wasted plus it limits the number of transactions you can put into one block if we are restricting  gas based on this case. There was lots of iteration on the testing of the contract using the simulation test framework that we improved on a lot. If we get to the lockup contracts eventually you can see how the structure of lockup contracts improved over this one.

### LearnNEAR.Club LNC Weekly Update - September 19, 2021

Brief Summary:

 	🤑 LNC nLEARNs redeem to NEAR September campaign was HU-U-U-GE!

Results:

 	September LNC nLEARNs Redeem was the biggest yet!
364 $NEAR were sent to genuine (L)earners
 	Sybil attack detected at LNC! More details here

 	How to use NEAR in a game - mini course
 	NEAR Ecosystem projects started adding jobs:


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC projects portfolio is coming!

### Comment fonctionne le NEAR Rainbow Bridge

Article par Matt Henderson  d'Aurora 
Le NEAR Rainbow Bridge est unique en crypto en tant que seul pont sans autorisation et sans confiance vers Ethereum. Dans cet article, nous allons démystifier son fonctionnement !
Le protocole NEAR a créé le Rainbow Bridge — quelque chose à la fois unique et précieux dans l’espace crypto, un pont entièrement « sans confiance » pour le transfert de jetons entre Ethereum et NEAR — et finalement, Aurora. Bien qu’il existe des descriptions techniques du pont, cet article expliquera son fonctionnement d’une manière, espérons-le, compréhensible par toute personne ayant une connaissance de base de la cryptographie.

Le concept:
Commençons par imaginer que je veux transférer 20 DAI d’Ethereum vers NEAR. Étant donné que le transfert physique de jetons n’est pas possible entre les réseaux, cela signifie que nous devons retirer 20 DAI de la circulation sur Ethereum et mettre 20 DAI en circulation sur NEAR, afin que l’offre mondiale de DAI ne change pas.
Voici comment je pourrais le faire d’une manière sans confiance et sans autorisation :


 	Je dis au réseau Ethereum que je souhaite transférer 20 DAI ailleurs.
 	Le réseau Ethereum verrouille mes 20 DAI dans un coffre-fort (un contrat intelligent), afin qu’ils soient retirés de la circulation.
 	Une fois que je suis certain que ces 20 DAI ont été verrouillés sur Ethereum, je dis alors à NEAR de créer 20 nouveaux DAI pour moi là-bas.
 	NEAR ne me fait pas confiance, bien sûr, et il me demande donc de prouver que j’ai verrouillé 20 DAI sur Ethereum.
 	Je fournis à NEAR la preuve que j’ai verrouillé ces DAI sur Ethereum.
 	NEAR vérifie indépendamment ma preuve, puis crée 20 nouveaux DAI que je peux utiliser sur NEAR.

Plus tard, si et quand je souhaite déplacer mon DAI de NEAR vers Ethereum, j’inverse simplement la procédure ci-dessus. Bien, hein ?

Les acteurs:
Voyons maintenant comment tout cela se passe dans la pratique, en utilisant le Rainbow Bridge. L’histoire va impliquer un certain nombre de composants techniques qui composent le pont :
L’interface utilisateur de Rainbow Bridge — c’est le site Web où vous, en tant qu’utilisateur, interagissez avec le pont pour transférer vos actifs entre les réseaux.
Le LiteNode — C’est comme un nœud blockchain, sauf qu’il ne stocke que les en-têtes de bloc, ce qui réduit considérablement l’espace de stockage nécessaire. Le LiteNode est implémenté en tant que contrat intelligent, et nous en avons deux : un déployé sur le réseau Ethereum, qui stocke les en-têtes de bloc NEAR, et un déployé sur NEAR qui stocke les en-têtes de bloc Ethereum.
(Juste pour info, le LiteNode est en fait appelé le « client léger » dans d’autres articles, pour des raisons historiques. Si vous me demandez « Qu’est-ce qui stocke les données de la blockchain ? », ma première pensée est « un nœud », et ainsi de suite cet article, pour aider avec les modèles mentaux, je l’appelle le LiteNode.)
Relayers — Étant donné que les LiteNodes sont des contrats intelligents, ils ne peuvent pas s’exécuter et se mettre à jour eux-mêmes. Les relais sont des scripts exécutés sur des serveurs traditionnels, qui lisent périodiquement les blocs d’une blockchain et les communiquent au LiteNode exécuté sur l’autre. Ainsi, les relais maintiennent les LiteNodes à jour.
Puisqu’il y a un coût de transaction, c’est-à-dire frais de gaz — chaque fois qu’un relais met à jour un LiteNode, celui sur NEAR (contenant les blocs Ethereum) est mis à jour sur chaque bloc Ethereum (puisque les frais de gaz NEAR sont bon marché), tandis que la fréquence de mise à jour sur Ethereum (contenant les blocs NEAR) est configurable et déterminé par un budget économique (actuellement environ 12 à 16 heures).
Connecteurs — Les connecteurs sont des contrats intelligents responsables de toute la logique associée à la gestion inter-chaînes d’un type d’actif donné. Comme LiteNodes, ils existent par paires, l’un fonctionnant sur Ethereum et l’autre sur NEAR. Par exemple, il existe une paire de « connecteurs ETH » chargés de transférer l’ETH entre les deux réseaux. Et il existe une paire “ERC-20 Connector” responsable du transfert des jetons ERC-20. Quelqu’un pourrait écrire un connecteur “NFT”, “Prediction Market Outcomes” ou “DAO Vote Results” s’il le souhaite. N’importe quel actif ou donnée peut être transféré à travers le Rainbow Bridge, s’il existe des connecteurs pertinents !
Connectors — Connectors are smart contracts responsible for all of the logic associated with the cross-chain management of a given asset type. Like LiteNodes, they exist in pairs—one running on Ethereum, and one running on NEAR. For example, there is a pair of "ETH Connectors" responsible for transferring ETH between the two networks. And there's an "ERC-20 Connector" pair responsible for transferring ERC-20 tokens. Someone could write an "NFT" Connector, "Prediction Market Outcomes" Connector or "DAO Vote Results" Connector if they wished. Any asset or data can be transferred across the Rainbow Bridge, if relevant Connectors exist!
Rassembler les pièces :
Pour comprendre comment tous ces éléments fonctionnent ensemble pour me permettre de transférer sans autorisation et sans confiance des jetons entre Ethereum et NEAR, reprenons notre exemple d’origine :


 	À l’aide de l’interface utilisateur de Rainbow Bridge, je lance un transfert de 20 DAI d’Ethereum vers NEAR.
 	Lorsque je confirme la première des deux transactions dans MetaMask, le Rainbow Bridge communique avec le connecteur ERC-20 sur Ethereum (puisque DAI est un jeton ERC-20), qui transfère et verrouille 20 DAI dans son coffre-fort. Ces DAI ne sont alors plus en circulation sur le réseau Ethereum.
 	Sur la base des données d’en-tête de mon bloc de transaction, l’interface utilisateur de Rainbow Bridge calcule une “preuve” cryptographique que j’ai vraiment verrouillé 20 DAI.
 	Puisque nous allons ensuite demander au réseau NEAR de créer un DAI basé sur ce qui vient de se passer sur Ethereum, nous attendons d’abord que le Relayer envoie environ 20 en-têtes de bloc Ethereum au LiteNode s’exécutant sur NEAR. C’est pour la sécurité, de la même manière que votre échange crypto vous fait attendre quelques confirmations avant d’utiliser vos fonds déposés.
 	Après cette attente, l’interface utilisateur de Rainbow Bridge nous permet ensuite de passer à la deuxième étape du processus : demander au connecteur ERC-20 sur NEAR de créer 20 nouveaux DAI pour nous sur le réseau NEAR.
 	Lorsque nous faisons cette demande au connecteur ERC-20, nous fournissons notre preuve cryptographique que nous avons reçue plus tôt, “prouvant” que nous avons verrouillé 20 DAI sur Ethereum.
 	Le connecteur ERC-20 sur NEAR recherchera ensuite notre en-tête de bloc Ethereum dans le LiteNode exécuté sur NEAR et effectuera son propre calcul indépendant de la preuve cryptographique.
 	Si la preuve que nous avons fournie correspond à la preuve que le connecteur ERC-20 calcule, alors il sait que ces 20 DAI sont verrouillés en toute sécurité sur Ethereum — et que c’est moi qui l’ai verrouillé ! NEAR et les livre à mon portefeuille.

Lorsque nous voulons transférer le DAI de NEAR vers Ethereum, le processus se déroule à l’envers, c’est-à-dire qu’au lieu de verrouiller 20 DAI dans NEAR, nous les détruisons — ce qu’on appelle “graver” — puis nous fournissons la “preuve” de cette brûlure au Connecteur fonctionnant sur Ethereum. Ayant accès aux blocs NEAR dans le LiteNode fonctionnant sur Ethereum, il valide notre preuve, libère 20 DAI de son coffre-fort et les envoie à notre portefeuille !
Et voilà, en un mot, comment fonctionne le Rainbow Bridge ! C’est le seul pont Ethereum en crypto qui fonctionne de cette façon, actuellement — vous permettant de transférer sans autorisation des actifs entre Ethereum, NEAR — et bientôt, Aurora — sans avoir à faire confiance à des tiers. Très cool!

D’autres pièces :
Here's some interesting notes to go along with that overview:

Voici quelques notes intéressantes pour accompagner cet aperçu :

 	Étant donné que le relais NEAR-to-Ethereum n’envoie les en-têtes de bloc NEAR au Ethereum LiteNode que toutes les 16 heures, il y a un délai de 16 heures entre les étapes un et deux lors du déplacement des jetons dans cette direction. (Rappelez-vous, c’est parce que les frais de gaz Ethereum rendent prohibitif pour le Relayer la mise à jour du LiteNode sur chaque bloc.) Il existe un certain nombre d’approches qui nous permettraient de réduire ce délai, et l’équipe y travaille activement.
 	Sur NEAR, le LiteNode stocke tous les en-têtes de bloc Ethereum passés. Afin que l’espace de stockage ne devienne pas incontrôlable, le LiteNode “prune” (supprime) les blocs de plus de deux semaines environ. Cela signifie que si vous démarrez un transfert d’Ethereum vers NEAR et partez en vacances pendant trois semaines entre les étapes un et deux, vous ne pourrez pas terminer votre transfert, car les données Ethereum stockées NEAR nécessaires pour vérifier votre « preuve » seraient ont été supprimés !
 	Une propriété intéressante de la conception d’en-tête de bloc NEAR est qu’avec un seul en-tête de bloc, nous pouvons calculer l’historique des blocs passés sur une période assez longue. Donc, en théorie, le LiteNode sur Ethereum n’a besoin que d’un seul bloc NEAR ; cependant, nous les gardons car les coûts de gaz nécessaires pour effectuer l’élagage seraient fondamentalement un gaspillage de ressources.
 	L’équipe qui a créé le Rainbow Bridge est la même qui a créé Aurora, le NEAR EVM. Étant donné que cette équipe s’est transformée en sa propre entité, le Rainbow Bridge relèvera de sa gestion pour l’exploitation, la maintenance et l’évolution future.
 	L’équipe Aurora travaille sur la « finalisation automatique » pour le pont Rainbow, afin que vous n’ayez plus à lancer manuellement la deuxième étape de ces transferts. Ce sera très pratique pour les utilisateurs (et cela signifie que vous pouvez commencer votre transfert Ethereum vers NEAR puis partir en vacances !)
 	Les transferts entre Ethereum et Aurora sont effectués par Aurora Bridge, qui utilise la même technologie de base que le Rainbow Bridge, mais augmentée pour gérer l’étape cachée NEAR/Aurora dans les transferts.
 	L’interface utilisateur et l’expérience du pont Aurora sont différentes de celles du pont arc-en-ciel et, à un moment donné, elles seront harmonisées.
 	Bien que certains détails techniques aient été simplifiés, vous avez maintenant une compréhension fondamentale du fonctionnement du Rainbow Bridge !

Although some technical details have been simplified, you now have a fundamental understanding of how the Rainbow Bridge works!

For a in-depth description of the Rainbow Bridge, you can read this article, and to keep up with everything related to Aurora, be sure to follow Aurora on Twitter!

 

### Top 3 projets NFT sur le protocole NEAR

La croissance de DeFi a mis les NFT au centre de l’attention, et la croissance des NFT a également mis en évidence plusieurs problèmes. Ethereum a le monopole de ce secteur, avec de nombreux NFT créés sur la blockchain Ethereum. Alors, quel est le problème avec la création de NFT sur l’une des plateformes les plus populaires au monde ? La question des frais de gaz élevés. Ethereum a un gros problème en ce qui concerne les frais qui peuvent potentiellement dépasser des centaines de dollars, ce qui le rend très peu pratique.
Alors, quelles sont les options en matière de NFT et de projets NFT ? Quels autres choix ont-ils ? Le protocole NEAR a plusieurs projets importants sur sa plate-forme et est souvent présenté comme le tueur d’Ethereum. Le protocole NEAR est une blockchain évolutive qui simplifie et accélère le développement des dApps. À l’heure actuelle, il existe 19 plateformes décentralisées pour l’échange de NFT sur la blockchain NEAR. Le protocole NEAR présente un avantage significatif par rapport à Ethereum, car il est nettement plus rapide qu’Ethereum et les transactions ne coûtent presque rien, ce qui en fait une plate-forme idéale pour le trading de NFT.

Qu’est-ce que le protocole NEAR ?
Le protocole NEAR est une plate-forme de développement décentralisée qui a été créée en 2018. Il a été conçu pour créer un environnement parfait pour les applications décentralisées tout en se concentrant sur les lacunes apparentes des autres plates-formes de l’espace. NEAR fonctionne sur le protocole NEAR, une blockchain Proof-of-Stake (PoS) qui réduit les coûts et améliore l’évolutivité en mettant en œuvre plusieurs fonctionnalités,
NEAR adopte également une approche différente du partage en introduisant un nouveau mécanisme de génération de blocs, “Doomslug”. Doomslug a été proposé en 2019 et introduit la finalité pratique ou « Doomslug », permettant aux blocs de recevoir la finalité en quelques secondes seulement.
NEAR fonctionne sur la même technologie qui alimente Bitcoin et est le réseau le plus accessible pour les développeurs et les utilisateurs finaux. Contrairement à NEAR, la plupart des blockchains centralisent le traitement et le limitent au matériel haut de gamme. Grâce à NEAR, la plate-forme peut évoluer linéairement jusqu’à des milliards de transactions de manière complètement décentralisée.

Quelles sont les caractéristiques importantes de NEAR ?
NEAR est développé par une petite communauté de développeurs et de chercheurs connue sous le nom de NEAR Collective. Certaines des caractéristiques essentielles sont :


 	NEAR est un protocole facile à utiliser qui permet aux développeurs de créer des applications rapidement et facilement.
 	NEAR permet une évolutivité illimitée.
 	Contrairement à la croyance, NEAR n’est pas une chaîne latérale mais un protocole de couche 1.
 	Toutes les dApps créées sur NEAR s’exécutent sur la couche NEAR sous-jacente.

Le Collectif NEAR
Comme mentionné précédemment, NEAR est développé par une communauté de développeurs et de chercheurs. Ceux-ci font partie du collectif NEAR. Le collectif NEAR se compose d’organisations et de contributeurs individuels qui travaillent en permanence pour assurer le fonctionnement quotidien du protocole NEAR et l’améliorer constamment.
Le collectif NEAR écrit le code initial et la mise en œuvre pour le réseau NEAR. Alors que le collectif assure le fonctionnement du protocole, NEAR est entièrement décentralisé et fonctionne de manière autonome. Il ne peut pas être fermé, même par l’équipe qui l’a développé.
Le Collectif NEAR se compose de la Fondation NEAR ; une organisation à but non lucratif axée sur la création d’un écosystème dynamique autour de la blockchain NEAR. Le protocole NEAR n’est qu’un des nombreux projets du collectif NEAR.

NEAR Protocole et NFTs
Le protocole NEAR est la plate-forme idéale pour les NFTs car il présente de nombreux avantages par rapport à Ethereum. Le protocole est nettement plus rapide qu’Ethereum. Ethereum a également des frais de gaz nettement plus élevés, tandis que NEAR permet le traitement des transactions pour un prix négligeable. Ces facteurs rendent NEAR idéal pour acheter et vendre des NFTs.
Comme mentionné précédemment, il existe déjà plusieurs projets NFT qui ont été créés sur la blockchain NEAR. Cependant, avant d’aborder les projets, comprenons brièvement le concept de NFTs.

La signification de non fongible
Un actif fongible est un actif qui peut être échangé contre un autre actif identique. Bitcoin est un excellent exemple d’actif fongible, ce qui signifie que vous pouvez échanger un bitcoin contre un autre bitcoin sans aucun problème. Les actifs non fongibles, en revanche, sont des actifs uniques qui ne peuvent pas être échangés. Un exemple d’actif non fongible peut être une peinture unique ou des objets de collection en édition limitée.
Un actif non fongible a une propriété ou des propriétés distinctes qui le distinguent des autres actifs. Les jetons non fongibles sont basés sur des actifs non fongibles et sont des actifs numériques uniques qui utilisent la technologie blockchain.

Qu’est-ce qu’un NFT ?
Les NFTs sont des actifs numériques uniques dont les informations d’identification sont enregistrées sur un contrat intelligent. Les informations sur le contrat intelligent sont ce qui rend un NFT unique. Les actifs fongibles comme Bitcoin peuvent être échangés, ce qui signifie que vous pouvez envoyer ou recevoir des bitcoins sans aucun problème. Les actifs fongibles sont également divisibles, ce qui vous permet d’envoyer des montants plus faibles. Les actifs non fongibles ne sont pas divisibles. Par exemple, vous ne pouvez pas envoyer à quelqu’un une partie d’un tableau ou un billet.
Les NFTs sont des certificats de propriété numériques pour les actifs numériques. Un NFT est un contrat intelligent utilisé pour sécuriser un actif numérique. Une fois écrit, il est publié dans un token (ERC-721) sur la blockchain. Tout peut être transformé en NFT, les plus populaires étant les vidéos, les GIF ou les JPEG.



	

	
	
		
			
				Which of the following is an NFT? 
			
		

		
					

		
			
			
			
			Bitcoin 
		
			
			Fiat currency
		
			
			A digital collectible
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Projets NFT sur le protocole NEAR
Actuellement, il existe plusieurs plates-formes NFT sur NEAR, alors examinons certains des projets les plus populaires sur la plate-forme.
Mintbase
Mintbase a débuté en 2018 et a été créé par Nate Geier et Calorine Wend. Nate Geier est le PDG de l’entreprise, tandis que Caroline est la directrice de l’exploitation, utilisant son expertise en gestion et en développement commercial. Mintbase a réussi à lever 1 million de dollars lors d’un cycle de financement de démarrage en 2020. Sino Global a dirigé le cycle et se composait également d’autres VC tels que Block Oracle Capital, D1 Ventures et d’autres investisseurs providentiels.

Femme poisson par From my Dream
Plate-forme de blockchain numérique utilisée pour émettre et échanger des jetons non fongibles, les jetons sur Mintbase sont différents des autres jetons qui sont généralement des jetons d’art numérique. La plate-forme Mintbase permet aux utilisateurs de créer et de vendre des actifs adossés à des NFT. Les utilisateurs peuvent créer différents actifs numériques en tant que NFT. Ces actifs peuvent aller des billets d’événement à l’art cryptographique et tout le reste.
Mintbase permet à pratiquement toute personne ayant accès à Internet de créer un NFT et de le mettre en vente sur sa place de marché ou sur des places de marché NFT comme OpenSea. Les minters peuvent créer un contrat intelligent et limiter la transférabilité des jetons émis, aidant ainsi à prévenir la fraude ou le transfert illégal d’objets uniques. Mintbase se concentre sur la création d’une expérience de création NFT unique, c’est pourquoi, comme mentionné précédemment, il prend en charge différents actifs numériques. Ceci est contraire aux plates-formes concurrentes qui se concentrent sur une catégorie spécifique de NFT.

Pourquoi Mintbase est-il passé à NEAR ?
Alors pourquoi passer d’Ethereum à NEAR ? La réponse est les frais de gaz. Les frais d’Ethereum Gas avaient commencé à devenir ridiculement chers. Pour créer des NFT sur Mintbase, un utilisateur doit créer une boutique numérique. Cela implique que l’utilisateur crée un contrat intelligent et paie à Ethereum des frais de gaz. Initialement, les frais étaient bas et les utilisateurs ont pu déployer le magasin rapidement. Cependant, avec la congestion croissante du réseau Ethereum, les frais ont commencé à devenir de plus en plus élevés, la création de magasins coûtant des centaines de dollars. Le coût est devenu si élevé que Mintbase a dû dire à ses utilisateurs d’attendre que les prix du gaz baissent avant de déployer un magasin. Ethereum est rapidement devenu intenable pour acheter, vendre ou créer des NFT.
Mintbase considérait NEAR comme une meilleure plate-forme par rapport à Ethereum, avec des frais de gaz nettement inférieurs grâce à un modèle d’exécution de contrat plus efficace. Il utilise également Nightshade, une approche dynamique de Sharding. Cependant, il existe plusieurs autres raisons pour lesquelles Mintbase est passé à NEAR.


 	L’utilisation de Rust ou AssemblyScript pour les contrats intelligents sur la plate-forme NEAR permet aux développeurs d’écrire facilement du code.
 	NEAR propose des adresses lisibles par l’homme pour les contrats et les comptes.
 	Les développeurs peuvent intégrer les utilisateurs rapidement, grâce à NEAR Drops. Ils peuvent payer leurs comptes NEAR et envoyer des tokens NEAR.
 	Les développeurs et les utilisateurs peuvent déplacer des actifs rapidement grâce au pont ETH-NEAR Rainbow bridge.
 	D’autres plates-formes DeFi telles que Aave et Balancer sont également sur NEAR, ce qui facilitera toute intégration future.




	

	
	
		
			
				Why did Mintbase switch to NEAR? 
			
		

		
					

		
			
			
			
			High Gas fees
		
			
			NEAR is a better platform 
		
			
			Developers can move assets faster
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras a été créé avec une vision de fournir la solution au vieillissement des cartes de collection traditionnelles. La plate-forme valide la propriété via la blockchain grâce à des transactions rapides et peu coûteuses. La plate-forme se concentre sur la création de collections crypto-natives qui peuvent être davantage diversifiées dans des supports plus importants.

PunkyPoN#0006 par monztre.near
Paras est un marché de cartes d’art numérique tout-en-un basé sur NEAR. La plate-forme peut valider la propriété et donner accès à chaque achat et menthe aux utilisateurs. Il propose des transactions rapides et bon marché, et il se différencie des autres marchés en proposant des collections au lieu de sorties uniques. La plateforme se différencie de la manière suivante.


 	Paras réduit la charge d’entretien des collectionneurs en veillant à ce que leurs objets de collection ne s’usent pas avec le temps. La plate-forme supprime les barrières et donne aux artistes et aux collectionneurs un accès facile au marché des objets de collection numériques. Grâce au protocole NEAR, Paras peut réduire les coûts encourus par les artistes pour vendre leurs cartes.
 	Paras développe la verticale Digital Art Card pour les futurs artistes, joueurs et créatifs et permet aux artistes de créer une collection liée à un thème ou à une tradition. Grâce à cette méthode, les cartes d’art numérique de Paras sont riches en histoires et en arrière-plans.

Paras est capable d’adopter une approche organisée et de créer une communauté et une expérience NFT. Paras assure cohérence et qualité en sélectionnant des artistes et des formats. Les artistes ne peuvent créer de nouvelles cartes sur Paras qu’après avoir été approuvés, et le nombre de nouveaux artistes approuvés est limité à 30 artistes par semaine. Les artistes sont également tenus de se conformer au format standard 64:89.



	

	
	
		
			
				What is Paras? 
			
		

		
					

		
			
			
			
			An all-in-one digital art card marketplace
		
			
			A smart contract platform 
		
			
			A programming language 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Depuis le lancement de la plate-forme, les artistes sur Paras ont déjà gagné plus de 25 000 $, la plate-forme étant capable de faciliter un volume de transactions de plus de 35 000 $ à partir de plus de 700 transactions. La plateforme compte plus de 80 collectionneurs actifs et plus de 70 artistes. Les frais de frappe bas maintiennent la barrière d’entrée pour les artistes numériques assez basse, et les artistes peuvent frapper des cartes sans se soucier du coût de frappe.
Pourquoi NEAR convient-il parfaitement aux paras ?
Étant donné que la demande d’espace sur Ethereum augmente les coûts sur la plate-forme, les nouveaux créateurs de NFT recherchent des alternatives et des solutions. NEAR travaille avec Ethereum sur une solution interopérable. Les transactions sur NEAR ne coûtent que quelques centimes, et parfois même moins. Le portefeuille NEAR est très efficace et les transactions sont effectuées presque instantanément. Le pont Rainbow garantit que NEAR sera interopérable avec les actifs basés sur Ethereum.
Hip Hop Heads
Hip Hop Heads marque l’entrée d’un pilier de la culture américaine dans l’espace crypto. La série d’art collaboratif présente le travail d’Andre LeRoy Davis, le créateur de l’emblématique The Last Word de Source Magazine, ainsi que l’animation de fond de l’un des copropriétaires de The Source Magazine, Ed Young.
Hip Hop Heads est né d’une collaboration entre l’Universal Hip Hop Museum, The NEAR Protocol et Ed Young. Ensemble, ils ont décidé de créer une collection NFT mettant en vedette des artistes des années 70 à nos jours. La collection, appelée NFT.HipHop Heads, mettra en vedette 47 des plus grands artistes de rap et honorera non seulement les artistes, mais marquera également la 47e année de l’ère Hip Hop. Le projet renoue avec les racines du rap en utilisant les dernières avancées technologiques.









HipHopHead 10.292.22166

Chaque illustration existera sous la forme d’une collection de 47, représentant 47 ans de l’ère Hip Hop. La première édition de chaque Hip Hop Head est nommée en fonction de la place de l’artiste dans l’histoire du Hip Hop. L’importance de chaque artiste est démontrée à travers une illustration créée par Andre LeRoy Davis. Le code d’animation d’arrière-plan est le résultat des chiffres les plus significatifs de l’histoire du Hip Hop qui démontrent le passage de l’ère Hip Hop au cours de 47 ans. La collection NFT sera mise aux enchères tous les jours sur son site internet jusqu’au 24 juillet.
Pourquoi les Hip Hop Heads ont-elles choisi NEAR ?
Le protocole NEAR permet à la collection Hip Hop Heads d’être plus accessible au grand public. Comme mentionné précédemment, la collection sera mise aux enchères tous les jours jusqu’au 24 août et peut être achetée par carte de crédit. Cela permet à NEAR de rendre le projet plus viable. Le marché des enchères met également l’accent sur les fonctionnalités du protocole NEAR, telles qu’une interface familière et conviviale similaire à Web-2, une frappe NFT facile et relativement bon marché et l’accessibilité pour l’utilisateur final.
Étant donné que les utilisateurs peuvent acheter les NFT à l’aide d’une carte de crédit, le marché offre un moyen simple d’acheter des NFT sans aucune étape compliquée qui oblige les utilisateurs à sauter à travers les cerceaux. Les redevances NFT sur le protocole NEAR sont écrites dans le code NFT, permettant aux créateurs de percevoir des redevances sur les ventes secondaires, même si le NFT se déplace vers un autre marché. Ceci est possible grâce à la norme NFT au niveau du contrat de NEAR. NEAR donne aux artistes et créateurs le contrôle de leur TVN, leur permettant de bénéficier de leur travail.

Conclusion
NEAR rend la création et le déploiement de dApps plus faciles, plus rapides et moins chers que tout autre protocole blockchain et est l’un des projets les plus prometteurs dans l’espace crypto. Il résout plusieurs problèmes rencontrés par les projets sur Ethereum, tels que les frais de gaz élevés et les vitesses de traitement lentes. Il présente également plusieurs avantages par rapport à la blockchain Ethereum grâce à sa solution fragmentée.
Le protocole NEAR s’est révélé très prometteur, utilisant Sharding pour résoudre les problèmes rencontrés par d’autres blockchains. Grâce à cette approche, NEAR est capable d’augmenter le débit sans compromettre la sécurité. Le collectif NEAR garantit que les ingénieurs et les développeurs travaillent en permanence sur le protocole.

### Comment développer sur NEAR ? Guide de démarrage

Les développeurs sont la pierre angulaire de l’écosystème blockchain. Pour que la technologie blockchain soit adoptée par le grand public, elle doit abaisser les barrières à l’entrée pour les développeurs et leur permettre de créer des applications amusantes et sophistiquées pour le plaisir des gens ordinaires. C’est pour cette raison même que les contrats intelligents de NEAR sont écrits en utilisant AssemblyScript en raison de sa similitude avec JavaScript.
Donc, si vous êtes désireux de construire sur NEAR, vous pouvez utiliser les outils suivants :


 	SDK JavaScript. Connectez-vous, signez, effectuez des transactions et déployez sur n’importe quel réseau NEAR à partir de n’importe quel contexte JS
 	Kit de développement logiciel antirouille. Construisez des contrats sûrs et sécurisés qui gèrent des actifs de grande valeur
 	Kit de développement logiciel de contrat AssemblyScript. Apprenez et prototypez sans friction en utilisant la syntaxe JS
 	API RPC JSON. Toutes les communications avec la plateforme passent par cette API y compris la nôtre
 	Interface de ligne de commande. Boîte à outils de ligne de commande complète pour les développeurs et les validateurs
 	NEAR de l’explorateur. Un outil de recherche blockchain permettant aux développeurs d’afficher les détails des transactions, les comptes, les détails des blocs et plus encore
 	NEAR Portefeuille. Créez des comptes, gérez les clés d’accès et plus encore avec notre interface utilisateur conviviale
 	nearup. Gérez les déploiements localement et rejoignez n’importe quel réseau public ou privé
 	Pont. Interopérabilité rapide et sécurisée
 	EVM. Machine virtuelle compatible Ethereum.

Bon, faisons les premiers pas.

Un bref aperçu
Les applications sur NEAR comportent deux parties distinctes : un back-end et un front-end.


 	Smart Contract (back-end) : Stockage et modification des données sur la chaîne. Les contrats doivent exposer des méthodes qui permettent aux clients de « visualiser » et de « modifier » l’état.
 	Interactions avec Smart Contract (front-end) : Vous pouvez interagir avec vos contrats ou les contrats déployés par d’autres personnes. Pour ce faire, utilisez le démarrage rapide et les extraits de code near-api-js dans votre application.




	

	
	
		
			
				Applications on NEAR have two distinct parts – a back-end and front-end.
The backend is the…..


			
		

		
					

		
			
			
			
			Mainnet
		
			
			Testnet
		
			
			Smart contracts
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Comment créer et appeler des contrats intelligents
NEAR prend actuellement en charge :


 	Rust — near-sdk-rs : un wrapper qui améliore la sécurité du langage de programmation Rust pour les contrats de grande valeur.
 	AssemblyScript near-sdk-as : Une collection d’aides qui font que vos SmartContracts ressemblent à TypeScript lors de la compilation vers Wasm pour l’exécution.

REMARQUE : AssemblyScript n’est actuellement pas recommandé pour les applications financières de production en raison de la nouveauté du langage et des outils de compilation disponibles.
Bon, soyons sérieux.

Configuration de Testnet
Le moyen le plus simple de créer un compte sur NEAR est avec NEAR Wallet. NEAR dispose de plusieurs réseaux de développement fonctionnant indépendamment les uns des autres avec leurs propres identifiants de compte. Allez, suivez les étapes pour créer un portefeuille. Assurez-vous d’avoir suivi les étapes requises pour votre sauvegarde de sécurité.
REMARQUE : La création d’un compte sur le réseau principal est presque identique à celle de testnet, mais nécessitera un financement initial pour le compte. Voici un guide de création de compte sur le réseau principal.
Peu importe, lors du déploiement, que l’application soit écrite en Rust ou en AssemblyScript. Tout le code du contrat est compilé dans WebAssembly et déployé sur le réseau pour être exécuté dans une machine virtuelle compatible Wasm. Vous utiliserez une commande telle que fil dev pour la plupart des applications, mais vous pouvez tout aussi facilement déployer une application à l’aide de NEAR CLI avec Near dev-deploy pour TestNet (ou Near deploy si vous avez déjà créé un compte).



	

	
	
		
			
				All contract code is compiled to WebAssembly and deployed to the network to be run inside a _______
			
		

		
					

		
			
			
			
			Sandbox
		
			
			Wasm-compatible virtual machine
		
			
			EVM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Maintenant, procédez comme suit pour vous réchauffer :

 	Regardez autour de vous dans NEAR Explorer. Ici, vous pouvez rechercher toutes les transactions et tous les blocs produits sur NEAR. Essayez de rechercher le compte que vous venez de créer et de voir les transactions que vous avez créées. 
 	Installez maintenant near-cli. Il s’agit d’une interface en ligne de commande qui vous permet d’interagir de manière transparente avec NEAR. Cette documentation NEAR contient toutes les commandes near-cli avec des exemples.
 	Essayez d’exécuter votre première commande : near login. Cela vous redirigera vers votre portefeuille NEAR et enregistrera vos clés de compte testnet localement.

Après avoir consulté le testnet, vous pouvez vous sentir libre d’exécuter votre nœud local. Cependant, si vous voulez juste jouer avec les codes, nous vous suggérons de vous en tenir au testnet.
Comment exécuter un nœud ?
Comme pour tout écosystème basé sur la blockchain, le protocole NEAR s’exécute sur un ensemble d’ordinateurs publics (ou « nœuds »).
Vous pouvez décider d’exécuter votre propre nœud pour plusieurs raisons:


 	Pour développer et déployer des contrats sur un nœud connecté à MainNet, TestNet ou BetaNet
 	Développer et déployer des contrats sur un nœud local (indépendant et isolé) (parfois appelé « LocalNet »).
 	Pour rejoindre un réseau en tant que validateur exécutant un « nœud de validation »

Vous pouvez lancer NEAR betanet et testnet nodes en installant Nearup. Vous pouvez le faire en suivant les instructions sur
https://github.com/near/nearup




	

	
	
		
			
				As with any blockchain-based ecosystem, NEAR Protocol runs on a collection of publicly maintained computers called _______
			
		

		
					

		
			
			
			
			Nodes
		
			
			Blockchain
		
			
			Near Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Exécuter un nœud officiel à l’aide de Docker
Par défaut, NEAR utilise Docker pour exécuter le client. Donc, la première chose à faire est d’installer Docker et à proximité. Maintenant, lancez votre système avec ceci :

nearup betanet
(Si vous préférez utiliser TestNet, remplacez simplement betanet par testnet dans la commande ci-dessus)
Vous serez alors invité à entrer un identifiant de compte. Vous pouvez laisser ce champ vide si vous souhaitez simplement exécuter un nœud. Les validateurs doivent utiliser l’ID de compte du compte avec lequel vous souhaitez jouer. Ensuite, vous devez entrer ce code :
Entrez votre identifiant de compte (laissez vide si vous ne voulez pas être un validateur)
Maintenant, votre nœud démarrera alors en arrière-plan avec Docker. Pour vérifier les journaux dans Docker, exécutez docker logs — suivez nearcore.

Créer un code simple sur NEAR
NEAR propose une liste de programmes utiles ou d’exemples de codes que vous pouvez consulter facilement. Le code que nous allons vérifier est donc le GuestBook. L’utilisation du programme vous permet de vous connecter avec NEAR et d’ajouter un message au livre d’or ! Une application de démarrage construite avec un backend AssemblyScript et un frontend React.

Recherche dans le code du GuestBook
Pour exécuter ce projet localement, vous devez vous assurer des points suivants.


 	Assurez-vous que Node.js ≥ 12 est installé (https://nodejs.org), puis utilisez-le pour installer le fil : npm install –global fil (ou simplement npm i -g fil)
 	Dépendances d’installation : installation de fil (ou simplement fil)
 	Exécutez le serveur de développement local : fil dev (voir package.json pour une liste complète des scripts que vous pouvez exécuter avec fil)

Vous disposerez désormais d’un environnement de développement local soutenu par NEAR TestNet ! L’exécution de fil dev vous indiquera l’URL que vous pouvez visiter dans votre navigateur pour voir l’application.
Oh et assurez-vous que la page GitHub est ouverte.
Vous pouvez également trouver cette vidéo utile.
https://youtu.be/B6Gc_OQjX9E

Explorer le code
Comme vous pouvez le voir, il y a deux côtés au code — backend et frontend :


 	Le code backend réside dans le dossier /assembly. Ce code est déployé dans la blockchain NEAR lorsque vous exécutez fil deploy:contract. Il s’agit d’un contrat NEAR smart.
 	Le code frontal réside dans le dossier /src. /src/index.html est un excellent endroit pour commencer à explorer. Notez qu’il se charge dans /src/index.js, où vous pouvez apprendre comment le frontend se connecte à la blockchain NEAR.

Backend Code
#1 Contract Data Model :  assembly/model.ts

[code lang="js"]import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");[/code]

Analyses :
@nearBindgen marque la classe comme sérialisable. Serializable est une interface marqueur utilisée pour « marquer » les classes afin que les objets de ces classes puissent obtenir une certaine capacité.
La classe “PostedMessage” a trois fonctionnalités -


 	premium pour signaler les messages avec des jetons NEAR attachés
 	l’expéditeur pour suivre le signataire du message du livre d’or
 	texte pour tenir le message du livre d’or

Enfin, « messages » est une collection de messages du livre d’or stockés en tant que PersistentVector d’objets PostedMessage

#2 Contract Behavior :  assembly/main.ts

[code lang="js"]import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}[/code]

Analyses:

MESSAGE_LIMIT est utilisé pour éviter les appels illimités (c’est-à-dire potentiellement coûteux) pour récupérer les messages du livre d’or du stockage
Nous utilisons également deux fonctions publiques différentes dans ce contrat — addMessage () et getMessages ()
Frontend Code
#1 Network Connection :  src/config.js

[code lang="js"]const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;[/code]

Analyses

Les informations de connexion définies ici sont incluses pour MainNet, TestNet et BetaNet ainsi que la configuration LocalNet par défaut.
#2 Configuration :  src/index.js

[code lang="js"]import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });[/code]

Analyses:

C’est la viande et les pommes de terre de la section frontend, lorsque vous configurez la connexion au réseau NEAR. Vous pouvez configurer l’interface de contrat en injectant une connexion au portefeuille et en connectant les deux méthodes de contrat.
Déployer un contrat intelligent
Chaque contrat intelligent dans NEAR a son propre compte associé. Lorsque vous exécutez fil dev, vos contrats intelligents sont déployés sur le NEAR TestNet en direct avec un compte temporaire. Si vous souhaitez maintenant le rendre permanent, voici ce que vous devez faire.
Étape 0 : Installer near-cli
Voici comment vous installez globalement near-cli
npm install --global near-cli
Cela vous donnera l’outil CLI NEAR. Assurez-vous qu’il est installé avec :
near --version
Étape 1 : Créer un compte pour le contrat
Visitez NEAR Wallet et créez un nouveau compte. Vous allez commencer ces contrats intelligents sur ce nouveau compte.
Autorisez maintenant NEAR CLI pour ce nouveau compte et suivez les instructions qu’il vous donne :
near login
Étape 2 : Définir le nom du contrat dans le code
Modifiez la ligne dans src/config.js qui définit le nom de compte du contrat.

Définissez-le sur l’identifiant de compte que vous avez utilisé ci-dessus.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Étape 3 : modifiez l’URL distante si vous avez cloné ce dépôt
Si vous forkez le référentiel, vous devrez changer l’URL distante en un référentiel auquel vous avez un accès « commit ». Cela permettra le déploiement automatique sur les pages Github à partir de la ligne de commande.

 	Accédez à GitHub et créez un nouveau référentiel pour ce projet.
 	Ouvrez votre terminal et à la racine de ce projet entrez ce qui suit:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`
Étape 4 : Déployez!
Vous avez juste besoin de la commande suivante pour déployer votre contrat intelligent :
yarn deploy
Cette commande fait deux choses :

 	Construit et déploie des contrats intelligents sur NEAR TestNet
 	Construit et déploie le code du contrat frontal sur GitHub à l’aide de gh-pages. Cela ne fonctionnera que si le projet a déjà un référentiel configuré sur GitHub. N’hésitez pas à modifier le script de déploiement dans package.json pour le déployer ailleurs.




	

	
	
		
			
				 Every smart contract in NEAR has its own associated ____

			
		

		
					

		
			
			
			
			Token
		
			
			Wallet
		
			
			Account
		
			
			All of above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Et ensuite ?
D’accord, maintenant que vous savez comment exécuter un code de base, vous voudrez peut-être approfondir NEAR. Pour cela, consultez la documentation des développeurs de NEAR.

### NEAR Protocole et Solana

Aujourd’hui, examinons deux des plates-formes de contrats intelligents les plus prometteuses au monde — Near Protocol et Solana. Bien qu’Ethereum domine toujours ce marché, le fait est que son manque d’évolutivité et ses frais élevés ont contraint la plupart des développeurs à rechercher des alternatives viables. Near et Solana sont devenus les deux premiers.
Qu’est-ce que Solana ?
Solana a été fondée en 2017 par Anatoly Yakovenko, qui avait auparavant travaillé chez DropBox. Yakovenko, avec Eric Williams et CTO Greg Fritzgerald, a créé Solana pour résoudre les problèmes existants dans Bitcoin et Ethereum. Le projet a attiré des investissements de Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures, etc.



Caractéristiques de la blockchain Solana

 	50 000 transactions par seconde et 0,4 seconde de temps de bloc
 	Le système peut fournir 28,4 millions de transactions par seconde sur un réseau de 40 gigabits.
 	Solana utilise l’algorithme de consensus Proof-of-History.

Comment fonctionne la preuve d’histoire (PoH) ?

Dans un réseau décentralisé qui s’étend sur un vaste territoire, le consensus est essentiel. Bitcoin utilise le consensus de preuve de travail (PoW) pour prendre en charge le consensus. Bien que la méthode soit hautement sécurisée, il est difficile de ne pas ignorer son problème le plus important : le manque d’évolutivité. N’oubliez pas que Bitcoin ne peut effectuer que 7 transactions par seconde.
Solana utilise la preuve de l’histoire, dans laquelle il crée des enregistrements historiques pour prouver qu’un événement se produit à un moment précis. Voici quelques points que vous devez garder à l’esprit :

 	L’algorithme utilise une fonction de délai vérifiable à haute fréquence qui nécessite un certain nombre d’étapes séquentielles pour terminer.
 	Les transactions ou les événements cadencés au sein du réseau seront désignés par un compte de hachage unique, qui peut être vérifié publiquement.
 	Le comptage permet au réseau de savoir exactement quand la transaction ou l’événement a eu lieu.
 	Chaque nœud possède une horloge cryptographique qui permet de suivre l’heure du réseau et l’ordre des événements.

En raison de PoH, le réseau Solana prend en charge 50 000 transactions par seconde lors de l’exécution avec des GPU.
Qu’est-ce qu’un cluster Solana ?
Un cluster est un ensemble d’ordinateurs indépendants qui fonctionnent ensemble et peuvent être considérés comme un système singulier. Les principales caractéristiques du cluster sont les suivantes :

 	Ils aident à vérifier la sortie de programmes non fiables soumis par les utilisateurs.
 	Ils aident à vérifier la sortie de programmes non fiables soumis par les utilisateurs.
 	Il garde une trace des ordinateurs qui ont fait un travail significatif pour maintenir le réseau en marche.
 	Il garde une trace de la possession d’actifs du monde réel.




	

	
	
		
			
				Which of the following utilizes sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			Both
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Programmation en Solana
Les contrats intelligents dans Solana sont écrits en Rust ou C et compilés dans le bytecode Berkeley Packet Filter (BPF). Comme il y a plus d’outils disponibles, il est recommandé de coder en Rust. Les débutants doivent coder leurs programmes en utilisant le framework Anchor, ce qui simplifie l’exécution.
Solana a un modèle de compte unique qui est similaire aux fichiers du système d’exploitation Linux. Ils peuvent contenir des données arbitraires et contenir également des métadonnées sur la façon dont ils peuvent être consultés. Gardez cependant à l’esprit que les comptes ont une taille fixe et ne peuvent pas être redimensionnés.
Le modèle de programmation actuel de Solana peut vous obliger à déplacer la logique d’application hors chaîne ou à modifier la fonctionnalité pour qu’elle soit inefficace et limitée par la taille fixe du compte.




	

	
	
		
			
				Which of the following is an integral part of Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Collective
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Exemple de contrat
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
Que se passe-t-il dans le contrat ?

 	
Tous les comptes auxquels accéder sont annotés dans la structure pour chaque appel avec #[derive(Accounts)].

 	
Les fonctions aident à initialiser les données de compte pour le propriétaire initial et l’achat. Cela permet à n’importe qui de l’acheter pour plus de jetons.

 	
Les données temporaires sont passées dans les paramètres de la fonction. Ces paramètres sont à l’intérieur des fonctions d’initialisation et d’achat. Cela inclut également le contexte de tenue des comptes requis pour la transaction.

 	
L’état du contrat est situé dans la structure ContentRecord. Ceci est en outre annoté avec #[compte] pour indiquer qu’il représente la présentation des données pour un compte.


Qu’est-ce que le protocole NEAR ?
Créé à l’été 2018, le protocole a été conçu pour créer l’environnement parfait pour les applications décentralisées en offrant des vitesses plus élevées, un débit plus élevé et une meilleure compatibilité avec d’autres chaînes. NEAR a une technique de partage unique et introduit un mécanisme de génération de blocs appelé « Doomslug » proposé en 2019. Doomslug permet une finalité pratique ou « Doomslug », garantissant que les blocs reçoivent la finalité en quelques secondes.
Le protocole NEAR est développé par le NEAR Collective, une communauté de développeurs et de chercheurs collaborant à la construction du projet. Certaines caractéristiques essentielles de NEAR sont :

 	NEAR est un système partitionné qui permet une évolutivité infinie.
 	Un protocole facile à utiliser, NEAR permet aux développeurs de créer des applications facilement et rapidement.
 	NEAR n’est pas une chaîne latérale mais un protocole de couche 1.
 	Les dApps créées à l’aide de NEAR s’exécutent au-dessus de la couche NEAR sous-jacente.

Qu’est-ce que la collectivité NEAR ?

La collectivité NEAR comprend des organisations individuelles et d’autres contributeurs qui travaillent en permanence à l’amélioration du protocole NEAR. La collectivité travaille sur des projets tels que l’écriture du code initial et la mise en œuvre pour le réseau NEAR. NEAR est entièrement décentralisé, fonctionne de manière indépendante et ne peut pas être arrêté ou manipulé, même par ceux qui l’ont construit.
C’est une organisation à but non lucratif qui se concentre sur la création d’un écosystème dynamique autour de la blockchain NEAR. Il aide à la coordination des activités de gouvernance et de développement. La collectivité NEAR a plusieurs projets, la blockchain NEAR n’étant qu’un des nombreux projets sous l’égide de la collectivité.

Mécanisme de NEAR Consensus
Le mécanisme de consensus mis en place sur NEAR s’appelle Nightshade. Nightshade modélise le système comme une seule blockchain. La liste de toutes les transactions dans chaque bloc est divisée en morceaux physiques, un morceau par fragment. Tous les morceaux s’accumulent dans un bloc. Notez que les morceaux ne peuvent être validés que par des nœuds qui conservent l’état de cette partition.
En parlant de validation, un élément clé de NEAR sont les validateurs. Ces validateurs sont responsables du maintien du consensus au sein du protocole. Les validateurs sont des nœuds spécialisés qui doivent maintenir leurs serveurs en ligne à 100 % tout en maintenant leurs systèmes à jour en permanence.
Voici quelques points que vous devez garder à l’esprit concernant les validateurs de réseau.

 	
NEAR détermine ses validateurs de réseau à chaque nouvelle époque, en les élisant en fonction de leur enjeu.

 	
Les validateurs déjà élus sont réinscrits en rejouant automatiquement leurs jetons plus les récompenses accumulées.

 	
Les validateurs potentiels doivent avoir leur mise au-dessus d’un niveau déterminé dynamiquement.

 	
Un validateur peut utiliser deux méthodes pour renforcer sa participation : acheter les jetons lui-même ou emprunter via une délégation de participation.

 	
La récompense que vous recevez est directement proportionnelle à votre mise : plus votre mise, plus vos récompenses.


Le consensus est basé sur le consensus de la chaîne la plus lourde. Cela signifie qu’une fois qu’un producteur de bloc publie un bloc, il collecte les signatures des nœuds de validation. Le poids d’un bloc est alors la mise cumulée de tous les signataires dont les signatures sont incluses dans le bloc. Le poids d’une chaîne est la somme des poids des blocs. De plus, le consensus utilise un gadget de finalité qui introduit des conditions de réduction supplémentaires pour une sécurité de chaîne plus élevée.




	

	
	
		
			
				Doomslug” is a block generation mechanism of which protocol?
			
		

		
					

		
			
			
			
			NEAR protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Protocole Aurora et NEAR

Aurora a également lancé le protocole NEAR, offrant une expérience Ethereum Layer-2. Certaines des façons dont Aurora améliore NEAR sont :

 	Il aide à augmenter le débit à des milliers de transactions par seconde.
 	Un temps de finalité de bloc de 2 secondes.
 	Croissance de l’écosystème à l’épreuve du temps
 	Frais de transaction faibles, qui sont 1000 fois inférieurs à ceux d’Ethereum.
 	Compatibilité sans compromis avec Ethereum.

Exemple de contrat
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

Que se passe-t-il dans le contrat ?
Alors, que se passe-t-il ici dans le contrat? Regardons de plus près.


 	Le contrat est défini par #[near_bindgen] dans le ContentTracker, il est similaire à un constructeur dans Solidity et est appelé lorsque le contrat est déployé
 	La fonction d’achat est annotée avec #[payable].
 	Le contrat comprend des appels asynchrones sous forme de Promise::new(…).transfer(…); lignes.
 	La structure de données LookupMap<String, ContentRecord> gère la recherche clé-valeur, qui accède au stockage. Ceci est égal à la « cartographie » de Solidité.

Conclusion
Solana et NEAR Protocol sont tous deux de brillantes plateformes de contrats intelligents qui ont construit des communautés très actives. Les deux apportent des fonctionnalités spéciales qui aident à combattre le plus gros problème qui afflige le monde décentralisé — la vitesse. Les deux plates-formes sont encore en croissance et ont beaucoup de promesses.

### NEAR Live Contract Review | Part 1: Voting Contracts

Introduction
Hey, my name is Eugene and I'm here with NEAR and today we'll try something new. We'll go through one of our contracts in Rust and we will review how it's all done.  This is the first session, so let me introduce myself. I work at NEAR, I work on runtime and contracts. Today we're going to discuss a voting contract and this is the contract that was used by the mainnet to move from phase one to phase two. Validators had to vote to enable transfers which essentially made the network fully decentralized. Here is the original video that the guide is based on.


Structural Overview
I'm using the CLI on Rust as it is one of the greatest tools to work on rust and on the left you can see a repository for core contracts. This is open source on our page on GitHub and there are a bunch of contracts and this one in particular is the voting contract. So let me first go through the quick structure of how this all works. In Rust you have the src and lib. Lib is the main file, it's a library because we're not really compiling the binary but we’re compiling a library into WebAssembly. 



There is a cargo tunnel: this is the way to describe dependencies. So we're saying we're gonna build a voting contract and we will use the NEAR SDK version 2.0.0 and there's a bunch of flags that we use as instructions on how to compile with the release build. 



There are a bunch of optimizations that improve the size of the code. There is no debugging for any release and also panic is equal to abort, this is important for WebAssembly. Finally we have overflow checks equals true, this means when integer overflow happens you can subtract a number. So let's say you subtract 2-1 and this goes negative and if your integer is unsigned this will raise a panic. This operation in usually silently rolls over in C++  so on rust you can enable a flag that will make it panic on any overflow or if you exceed the limit of the integer in either direction. So if you go beyond u32 it will raise a panic.  When you develop contracts for any smart contract platform usually overflows and  silent overflows are not the intended behavior and can lead to abuse so ideally your contract will panic and you'll just handle it. So that's just for safety. 
Lib.rs
Then we have other files and we'll go there later, but first let's start with the main contract. This is a single file and it is fairly simple, yet at the same time it has some interesting stuff. The way contracts are done on NEAR Protocol in Rust is that we have a main structure. In this case we're using a structure called the voting contract structure which is similar to a class in other languages and we have a few macros here. 



So near_bindgen is a macro from NEAR SDK that turns the structure into something that we use for contracts and I'll go into the details later. BorshDeserialize and BorshSerialize are two macros that allow this structure and all fields in it to be serialized into our binary format called borsh and also to get deserialized. This is needed to be able to store this entire contract in a state. The way contracts work is they have some persistent state from which they can read information on every invocation of the contract and they also have the local memory which is only available when the contract has started. It is going to be better explained later. So we have a structure and in Rust we have the implementation of  structure which is just basically the methods of the class. 
Constructor


So one of the methods is new, this is a constructor. It doesn't take any arguments for this particular contract and it returns self. Self is the equivalent of a voting contract, basically it's saying that it constructs a new instance of this class. We have a decorator macro called init and this init macro allows us to initialize a state of the contract without having a previous state. The way in which contracts are usually deployed on NEAR Protocol is that you deploy the code of the contract. Essentially you deployed a class and then you need to initialize an instance by calling a constructor. That will write a state, in our case this particular structure, into the persistent storage of the contract. So it will be available every time you call this contract.  When you first initialize the voting contract it doesn't take any arguments because it doesn't need to know anything. It will only rely on the current context of the blockchain and this context comes from a module called env which is short for the environment which is from the NEAR SDK. 




	

	
	
		
			
				Which macro is used to serialize things into a  binary format?
			
		

		
					

		
			
			
			
			SerializeSelf
		
			
			BorshSerialize
		
			
			BorshDeserialize
		
			
			DeserializeSelf
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	








This is where we'll need information down the line and we'll use arguments that other contracts or users call in this contract. There's two things happening in the constructor. First, we check that the state doesn't exist, meaning that the contract has not yet been initialized. 



This init macro allows to for the contract to be called multiple times so it doesn't check if the existing state already, it allows us to do this. We are working to add another macro which is called init_once that will allow us to only initialize the contract once and it will do this check automatically. The third (assert!(!env::state_exists)); is similar to a unit test it just verifies that the given expression is true and if it's not true it then raises a panic which just stops the current function call and sends a “the contract is already initialized” message as an error. So it's saying if the state doesn't exist or if the state already exists, basically inverse of that, then the contract was already initialized and we cannot initialize it again. If we didn't have this then we would be able to override whatever was there with a new state. State_exists actually comes from NEAR Protocol and we probably need to look at how NEAR SDK works in Rust  to better explain it. Every time a method that is not a constructor is called, let’s use the ping method as an example,  it takes the mutable self argument and it creates specific code from this contract that does a bunch of operations by using the decorator near_bindgen before getting into the execution phase. 


One of the operations is if you take the mutable self or self it first tries to deserialize the current state. The way it works is on a low level api is that we have a state key. This is the key with which we store the data of the main structure. 



So let's say we constructed this state in the constructor basically this is the return address of the last value. 



You return this new structure which we initialized the way we wanted to and then the votingContract structure gets serialized into the borsh binary format by the near_bindgen macro and it is also getting written into the persistent storage under a key state. The value is going to be the current value of the votingContract structure so next time a method like the ping method  is called, it will first read the binary part out of storage, deserialize it and create the pub struct VotingContract structure. 



So then, only after that, the ping part will start getting executed. So the state_exists part comes from the NEAR SDK. It's basically a wrapper around all it does is it checks if the given storage has this particular key and if it has a key then it knows that the state already exists.



What does init actually do? Init expects that you return a new class or a new instance and it will write it to the storage.



It is basically just saying, “I don't expect any arguments but you will return me a new state that I will write into the storage”. We can also have a default method on the contract and we don't want our contract to be initialized with the default argument without calling the initialization. We would say if a default method is called (this happens when the state doesn't exist, it was not initialized) then this method is called by default. We don't want this to happen so we're saying VotingContract should be initialized first. So it basically just panics with an error. NEAR SDK basically tries to read the state from the storage from the state key first and if it doesn't exist then it will call default but if it exists then it's not going to call default.
 Interface of the Contract
Let's see the interface of the contract first. We have a few methods and Rust has a pub decorator which means visibility is public and if there is no visibility it means that it's private. 



So the NEAR bunch of decorators will only turn public methods into the methods that you can call on the contract. Which means the check_result method is not exposed to the contract it cannot be called by someone else, while all of the rest of these methods can be called by essentially anyone. One more important thing about the NEAR SDK is a difference in the arguments that you can pass. So if you pass the mut self argument, it means the method will be allowed to modify the state. We call this type of method a regular function call, and they can only come through a transaction. If self is mutable they can be called change methods. In contrast without the mut self the state of this structure will be immutable. The regular self argument basically creates a read only state, you cannot modify it. This type of method can be called using a view call and they are not going to modify the state. If you don't have mut self then it will not write a state attempt. The important part is that we should treat them as non-changeable methods so they are not modifying the state. Before we dive into any particular method let's look into the vote method, it has an argument in addition to state. So by default near_bingen expects arguments to be passed in JSON. The default deserializer of arguments is  JSON, so the body of the method expects a method to be called with something like the following: ‘{“is_vote”: true}’. So method name woould be vote and the argument is going to be the JSON informative is_vote equals true. This is important because you cannot pass arguments using a positional call into a contract but internally within this implementation we can call vote with positional arguments. And within unit tests we can also use positional arguments. If within Rust you are not calling the WebAssembly binary before the near_bingen and does its magic to turn it into a contract then you should use positional arguments. But if you are calling it either from simulation tests or on the blockchain then you are already calling that pre-compiled WebAssembly library binary contract and it will expect it in the JSON format. The raw WebAssembly doesn't know any type inputs and the parse inputs are completely different.



Finally, the return arguments. This view call returns an Option<WrappedTimestamp>. The return types after the near_bingen contract macro expansion are also JSON. This type is a specific custom u64 type which is coming from the NEAR SDK JSON types. It's a structure that has a raw u64 type but when the JSON deserialization or serialization is called on it it turns it into a string. The reason for this is that the JSON standard doesn't support all u64 types. The limit is 2^53 because javascript originally had this limitation on numbers. The default JSON standard that comes from the frontend will not serialize large u64 numbers into a proper number. Instead we wrap the u64 integers (unsigned 64 bits) u128 integers into strings so that method will return you a JSON. Something like a string if where the actual number is “1000”, for example, or if the result doesn't  exist it will return you null. This is a high level overview of the NEAR SDK.




	

	
	
		
			
				Mut self means the method will be able to modify the state, true or false?
			
		

		
					

		
			
			
			
			False
		
			
			True
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Voting Call
We can now get into one of the methods. The main method that we have in this contract is a voting call. When you're an active validator, you have an account that has at least one seat in the NEAR Protocol, so you must have a pretty large stake to be an active validator. Then, you can call this method before phase two in order to cast your vote.



If is_vote is true it means that you want to vote in the move to phase two, if you said is_vote is false it means you are withdrawing your vote. Let's say you first tested your vote, and then you want to cancel it for some reason, for example, you feel that you didn't know something and you want to retract it. Let's see how it works. Vote is a change method and it automatically gets an argument deserialized by near_bindgen. As we discussed before even though it was expecting the JSON format, internally it is just a boolean variable that you can normally use in Rust. The method is not about how the state has changed or actions you did, so you don't need to manually save the state. It will be automatically saved if the method completes. So the first thing it does is it calls the ping method. We'll go back to that method later, but it does update the internal state by checking if the epoch has changed and who the active validator is in order to update the data. Then the vote method checks if we have already reached a result: if self.result.is_some(). In our case the result is a field that says if we have already reached 2 thirds of the validators, just a timestamp at to start each phase. 



This timestamp is in nanoseconds because this is how we expose the timestamp within a context. Option means that it either exists or doesn't exist, if it exists, it's given a timestamp. It means that voting already happened and we reached the phase 2 at the given timestamp in nanoseconds, if it's none,  it doesn't exist. It means the voting was not reached. So we just checked if we had already reached a vote. If we reached phase 2 already then we don't need to do anything, your vote doesn't matter because it's already phase 2 and the timestamp is already there. Rust does not have null instead, it has option types which can return some value or none and you have to explicitly deal with it where it yells at you. But when it gets encoded for the outside world it is getting converted to JSON, for example it is getting stored and sent as null. Next is the query, the context of the NEAR SDK where we check who called us.



There's three types of accounts that are available for context, one of them is a predecessor this is the account id of immediate predecessor of who called vote. NEAR is a synchronous environment and you can have a chain of cross-contract calls, so let's say Alice calls Bob’s contract, Bob calls Cheryl's contract, and in this case the predecessor is going to be Bob. Via Cheryl’s contract, the predecessor will be the immediate account who called us in this case, Bob. In contrast, there are also signer account id’s. This is the account who signed the original transaction. Let's say it was Alice who called Bob's contract and then so the signer account id will be Alice. The current account id is the account of the contract so in this case it’s going to be Cheryl, the account that holds the contract. On NEAR that contract always belongs to some account in which it has a state and balance, and has code deployed. For security reasons it's very important to always not rely on the signer of the transaction, but on the immediate predecessor.  Let's say Bob has a malicious contract and if he were to rely on the signer Bob can call some token transfer contract and withdraw a balance from Alice to themselves or their owner by acting on Alice’s behalf. If Bob would try to do this then the token contract will get the predecessor who is Bob so the Bob's contract can only spend balance of their own. So it has some limitations but this guarantees that if you call in some contract this contract cannot really act on your behalf, except on itself.



The next thing we do is check the argument that was passed. If it is the vote then it means we want to add this our stake from the caller to a set of active validators who voted for phase two, so otherwise the value is zero. It means we want to set our stake to zero so we call a special method: validator_stake on the environment which is the close a host function on the NEAR Protocol runtime to get the active stake from the current epoch of the given account id. It will return how much stake they have for a given validator and it will be done immediately. So assert!(stake>0, ‘ {} is not a validator’, account_id); is a synchronous call where we verify that your stake is 0 or above 0 to make sure that we don't pollute the state with a non-active validator. This way we can limit how many validators can get into our state, because we only had 100 seats when this contract was used. It means you can limit the number of validators in the state of this contract to a hundred. So basically if an assert triggers the term of the take is zero then we throw a panic and everything we did before this all changes to the state. It will be rolled back to the beginning of the function call only for this contract. So in this case coming to the example of Alice, Bob and Cheryl, only the state of Cheryl's contract is going to be reverted but the state of Bob is not because of the synchronous environment. Next we check if we already voted before. Votes is a hashmap. 
Hashmaps


The hashmap is in the memory map, meaning every time it's serialized, or deserialize all values have to be serialized into one piece, and then deserialized back. Whenever we call a method on this contract it will deserialize all fields of the hashmap, so all hundred potential accounts will be deserialized at once, but it will do this in a single storage read instead of a hundred storage reads. Even though the overall size of this is large because each account can be up to 64 characters and the balance is 16 bytes, the overall size of this is not as large, so it's 100 times 80 so it's like 8 kilobytes. 



What we need in this ping method is to iterate on every single vote in order to update the stake of the validator, and if we would have to iterate on every single key from a persistent collection. For example, for an ordered map then we will have to do something in the order of 100 reads, and in this case we we actually need to override them, which means we need a 100 writes and 100 reads, which is much more expensive than one-time bulk rate of 100 accounts, because we know that the structure is limited to 100. You don't need to introduce the pagination that you might need to do with a persistent map. This is because the try was stored in the storage, it’s kept as a try, and this makes it expensive to do a lot of reads. So in this case it was beneficial to have one map to be able to iterate. So the guideline here would be if you need to iterate on every single key you probably want to have a hashmap or a vector but it's also that you know that it's bound to 100. If NEAR were fully sharded then this will need to be modified potentially with a potentially persistent map or maybe you can do something like a sharded map. We don't have it right now, it’s not like a bulk map. It will be a persistent map of bulk objects, because you still need to iterate on all of them. Maybe you can split your accounts into 20 buckets, and then every bucket will be a vector, but you will store them separately into a persistent map so when you need to return it, you only need to read 20 keys or you introduce pagination for the ping method. Currently our storage is probably one of the most expensive operations that we face by default, and if you do like overwriting things then it will potentially be more expensive than a hashmap. That's why we picked a hashmap but it's not dramatically worse. But to be safe we can pretty much estimate 100 feet into our current gas limits, and it makes it a good choice for this particular contract. 
Voting Call (continued)


So at let voted_stake we remove the old stake, this is just a safety check. It's an invariant, which means it's unlikely to trigger in a real environment. After that, it verifies that the current stake is less than the total stake, then we subtract the old stake and introduce a new stake. I would argue that a better order would be to first subtract the old stake and then introduce a new stake in order to avoid overflows. Even though with our limit on the total supply it's not possible to overflow, but you always want to be careful. Finally if this was an active vote if it was not a withdrawal then we introduce this into the storage. At the end we will check the result again. 



Let's go to check_result first. We verify that when check_result is called we check that the result is not a sum. That's another way of checking it, and it tells us it’s an invariant. We see what the total validator stake is. The let total_stake is another method that is returned from the context, and it's saying we have 100 million total stake. Then internally total_voted_stake is the active stake encompassing all validators who voted on this. Let's say if the active stake is more than two thirds rounded down of the total stake, then we reach the result and that's pretty much the end of this contract. So voting has completed, this is a fairly simple method.




	

	
	
		
			
				How many validators were present during the migration to phase 2?
			
		

		
					

		
			
			
			
			50
		
			
			150
		
			
			200
		
			
			100
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Ping 


Now we want to go to ping. This method happens on the boundary of epochs. After an epoch switches, it means a new set of validators became active within the epoch on NEAR Protocol. Validators do not change so even if someone got kicked out they will only be inactive in the next epoch. We verify that we didn't reach the result in the self.result.is_none(). Then we take the current epoch height, the method suggests an integer that always is increasing, and after that we verify that it doesn't match the previous epoch height. So we started with the epoch height 0 but every time a ping is called it can update the epoch. So if the epoch has switched, it can pass one epoch and five epochs, it doesn't matter; what we're going to do is we're gonna go through all previous active votes that voted for phase 2. You reset the total stake to 0, and this is the last way of taking all of the data out of a fresh map and setting it to default. So basically we got a copy of the map from the internal structure and now the internal structure contains an empty hashmap. It's a new thing that it was recently introduced in Rust. The it is called the default hashmap, which is just an empty map. It gave us data from our structure and now this contract structure contains an empty map. This is so that we can modify the current map or the new map based on the data from the old map in one go. We basically just need to call account_id, because we don't need to know what the previous stake was. So next we check if someone was removed from the map in line 9, or removed from the active validators. We get their stake if their stake is positive we add them to the total stake and we keep their vote but if they were kicked out they have to vote again. Basically we update the total stake by recomputing what the new total stake is. Then we store all the results back to our contract state and at the end we do two things. We check the result after epoch has switched, if validators acquired more take or the total stake decreased then the result might have happened already. We remember at which epoch we did so next time someone calls ping or vote we don't need to go through this if the epoch hasn't switched. 
Final Rundown


That's pretty much the voting contract. Basically every time someone calls a vote we first update data from the previous validators and write it into internal structure. Most importantly, we get the total_voted_stake updated and then we call check_result twice occasionally within the one call. What's important is even though we can call ping here from one method, but also we can call ping directly by a transaction. You don't need to reload, you can just call ping. 



There's a bunch of view calls. The first just returns the result, the second returns how many stakes go into the pool, and the third is a functional way of returning all the votes. It basically the iterates on the map and then wraps it into the specific type of the balance using into. There is also a unit test in the same code and this just the rust way of doing this and the unit test can validate some logic within a contract by faking context and other things.

### NEAR et Ethereum

Aujourd’hui, Ethereum est la plate-forme de contrats intelligents numéro un dans l’espace cryptographique, avec une majorité de contrats intelligents et d’applications décentralisées (dApps) basées sur sa blockchain. Comme Ethereum, il existe également plusieurs autres plates-formes de contrats intelligents sur le marché.
Cependant, ce n’est pas parce qu’Ethereum est la plate-forme numéro un en matière de contrats intelligents et de DeFi qu’il n’a pas de problèmes. Ethereum a un problème flagrant, à savoir des problèmes d’évolutivité importants. Il ne peut tout simplement pas faire évoluer son réseau.
C’est là que le protocole NEAR entre en jeu. L’USP de NEAR est qu’il utilise un mécanisme de consensus Proof-of-Stake qui utilise le sharding. Avant de plonger plus profondément, apprenons à connaître à la fois Ethereum et NEAR.

Qu’est-ce qu’Ethereum ?
Si vous regardez la définition d’Ethereum sur son site Web, elle est la suivante -‘’ Ethereum est une technologie qui abrite de la monnaie numérique, des paiements mondiaux et des applications. La communauté a construit une économie numérique en plein essor, de nouvelles façons audacieuses pour les créateurs de gagner de l’argent en ligne, et bien plus encore. Il est ouvert à tous, où que vous soyez dans le monde. ”
Fondé en 2015 par Vitalik Buterin, Ethereum s’est fermement établi comme la deuxième plus grande crypto-monnaie par capitalisation boursière, juste derrière Bitcoin. Ethereum s’appuie sur la blockchain de Bitcoin, ce qui en fait plus qu’une simple crypto-monnaie qui permet aux utilisateurs d’envoyer ou de recevoir de la valeur sans aucune intervention de tiers.
Ethereum assure la décentralisation en remplaçant les serveurs centraux par des milliers de nœuds, garantissant que la plate-forme est toujours en ligne et libre de toute influence de tiers. Les contrats intelligents font également partie intégrante de l’écosystème d’Ethereum, et parce que la plate-forme prend en charge à la fois les applications décentralisées et les contrats intelligents, elle est exceptionnellement attrayante pour les développeurs et les utilisateurs.
Ethereum passe maintenant à Ethereum 2.0 ou Serenity. La mise à niveau améliorera considérablement l’évolutivité, l’efficacité et la vitesse de la blockchain Ethereum. De plus, la mise à niveau permettra à Ethereum de réduire les coûts de gaz et de traiter plus de transactions, améliorant ainsi l’évolutivité de la blockchain sans compromettre la sécurité.
La mise à niveau verra également Ethereum passer à un mécanisme de consensus Proof-of-Stake. Les points de vente verront les validateurs choisis de manière algorithmique assurer la sécurité de la plate-forme. Les validateurs sécuriseront la plate-forme en verrouillant leur ETH. Tout validateur qui agit contre l’intérêt de la plateforme voit sa mise réduite, assurant la sécurité de la plateforme.

Qu’est-ce que le protocole NEAR ?
Le protocole NEAR a vu le jour à l’été 2018. Plate-forme de développement décentralisée, le protocole a été conçu pour créer l’environnement parfait pour les applications décentralisées, en se concentrant sur les lacunes des autres plates-formes du contrat intelligent et de l’espace dApp. Ces lacunes sont principalement des problèmes de faible vitesse, de faible débit et de mauvaise compatibilité avec d’autres chaînes.
NEAR fonctionne au-dessus du protocole NEAR, une blockchain de preuve de participation (PoS), intégrant plusieurs fonctionnalités et innovations pour réduire les coûts et améliorer l’évolutivité pour les utilisateurs et les développeurs. De plus, NEAR adopte une approche unique du « sharding ».
Il introduit également un mécanisme de génération de blocs appelé « Doomslug » qui a été proposé en 2019. Doomslug permet une finalité pratique ou « Doomslug », garantissant que les blocs reçoivent la finalité en quelques secondes.
Le protocole est basé sur la même technologie que Bitcoin, en la combinant avec des fonctionnalités telles que le sharding de base de données. NEAR Protocol est construit à partir de zéro et est le réseau le plus accessible pour les utilisateurs finaux et les développeurs, tout en garantissant l’évolutivité et la sécurité.
La plupart des blockchains évolutives centralisent le traitement, le limitant au matériel haut de gamme, ce qui augmente temporairement leur débit, NEAR permet à la plate-forme d’évoluer de manière linéaire, jusqu’à des milliards de transactions de manière complètement décentralisée.
NEAR est développé par le collectif NEAR, une communauté de développeurs et de chercheurs collaborant à la construction du projet. Certaines caractéristiques importantes de NEAR sont :
- NEAR est un système partitionné qui permet une évolutivité infinie.
- Un protocole facile à utiliser, NEAR permet aux développeurs de créer des applications facilement et rapidement.
- NEAR n’est pas une chaîne latérale mais un protocole de couche 1.
- Les dApps créées à l’aide de NEAR s’exécutent au-dessus de la couche NEAR sous-jacente.

Qu’est-ce que le collectif NEAR ?
NEAR Collective comprend des organisations individuelles et d’autres contributeurs qui travaillent en permanence à l’amélioration du protocole NEAR. Le collectif travaille sur des projets tels que l’écriture du code initial et la mise en œuvre pour le réseau NEAR. NEAR est complètement décentralisé, fonctionne de manière indépendante et ne peut pas être arrêté ou manipulé, même par ceux qui l’ont construit.
Le Collectif NEAR compte des membres tels que la Fondation NEAR. La Fondation NEAR est une organisation à but non lucratif qui se concentre sur la création d’un écosystème dynamique autour de la blockchain NEAR. Il aide à la coordination des activités de gouvernance et de développement. Le collectif NEAR a plusieurs projets, la blockchain NEAR n’étant qu’un des nombreux projets sous l’égide du collectif.

Pourquoi les blockchains comme NEAR sont-ils nécessaires ?
Pour comprendre cela, nous devons d’abord comprendre l’évolution de la technologie blockchain. La blockchain peut être divisée en trois étapes ou générations. Les blockchains de première génération ont été conçues pour être un simple mécanisme de paiement. Bitcoin est un exemple de blockchain de première génération qui s’est fermement établie dans l’espace crypto en tant que plate-forme numéro un. Cependant, les blockchains de première génération ont des limites lorsqu’il s’agit de transactions complexes.
Les plates-formes blockchain de deuxième génération sont apparues avec Ethereum et le concept de contrats intelligents, permettant aux développeurs de les utiliser et de programmer des transactions plus sophistiquées et de créer des dApps. Mais les blockchains de deuxième génération souffrent de graves problèmes d’évolutivité. Par exemple, Ethereum ne peut traiter qu’environ 25 transactions par seconde, comparez ce nombre avec les plateformes grand public comme Visa ou PayPal, et vous pouvez voir à quel point Ethereum est en retard.
Ethereum a essayé de résoudre ses problèmes d’évolutivité en implémentant des solutions de couche 2 comme le protocole plasma, créant une couche supplémentaire qui fonctionne en tandem avec la chaîne principale. Cependant, les solutions de couche 2 n’ont toujours pas suffisamment gagné en popularité.
Cela nous amène à NEAR, une blockchain de troisième génération. NEAR rejette l’idée que chaque nœud du réseau doit exécuter l’intégralité du code car l’équipe pense que tout ce qu’il fait est de créer des goulots d’étranglement. Au lieu de cela, la blockchain résout les problèmes d’évolutivité en utilisant une technique de partitionnement, permettant à la blockchain d’augmenter la capacité du réseau. Et contrairement aux blockchains de deuxième génération qui utilisent une solution Layer-2, le sharding est une solution Layer-1.

Qu’est-ce que le sharding ?
Avant d’aller de l’avant, comprenons le sharding. Parfois, les systèmes doivent traiter beaucoup de données. Cela affecte les performances du système, réduit le débit et affecte les performances du système. Le partitionnement surmonte ce problème en partitionnant les données horizontalement, ce qui les rend plus petites, gérables et, plus important encore, plus rapides à traiter.

NEAR et Ethereum : Comment fonctionnent NEAR et Ethereum ?
Ethereum
Ethereum fonctionne comme plus qu’une simple plate-forme financière effectuant des transactions; il prend également en charge les applications décentralisées et les contrats intelligents. Ethereum est basé sur la technologie blockchain et utilise un grand livre public où toutes les transactions vérifiées sont stockées. Les transactions sont accessibles à tous ceux qui souhaitent les consulter, garantissant une transparence totale tout en garantissant que les données stockées dans la blockchain ne peuvent pas être modifiées ou manipulées.
La blockchain d’Ethereum est similaire à la blockchain bitcoin et agit comme un grand livre public qui conserve un enregistrement de toutes les transactions et de l’historique des contrats intelligents. Les volontaires du monde entier stockent une copie de l’intégralité de la blockchain Ethereum, rendant la blockchain complètement décentralisée. Chaque fois qu’une action telle qu’une transaction ou un contrat intelligent a lieu sur la blockchain, tous les nœuds du monde la traitent, garantissant que les règles de la blockchain sont respectées.
Tous les nœuds sont connectés et suivent le même ensemble de règles concernant les contrats et les transactions intelligents. Les nœuds d’Ethereum gardent également une trace de l’état de toutes les applications, des soldes d’utilisateurs et du code de contrat intelligent, garantissant que toutes les informations sont toujours à jour.
Grâce à Solidity, les développeurs peuvent rédiger des contrats intelligents capables de gérer les transactions sur la blockchain et leurs résultats. Les contrats intelligents diffèrent des contrats traditionnels car ils garantissent que les termes du contrat sont respectés. De plus, ils exécutent automatiquement les transactions lorsqu’un ensemble de conditions prédéterminées sont remplies, éliminant ainsi tous les tiers impliqués dans toute transaction.

NEAR
NEAR utilise la technologie blockchain, tout comme d’autres blockchains telles que Ethereum et Cardano. NEAR agit comme la blockchain de base sur laquelle les applications peuvent être construites et déployées. Il utilise un mécanisme de consensus connu sous le nom de Nightshade qui l’aide à atteindre son débit élevé. Le mécanisme de consensus de NEAR suppose que les transactions de toutes les partitions se combinent pour former un bloc, c’est pourquoi chaque partition soumet un segment de chaque bloc. Ce segment est appelé un morceau.
Les validateurs sont choisis au hasard, puis traitent les transactions sur plusieurs chaînes de fragments, améliorant ainsi la capacité de transaction du protocole NEAR. Les morceaux sont traités puis stockés sur la blockchain, finalisant les transactions.
NEAR ne fonctionne pas sur l’idée que chaque nœud doit traiter l’intégralité du code. Au lieu de cela, il résout les problèmes d’évolutivité en utilisant le sharding. Grâce au sharding, les données sont partitionnées horizontalement, ce qui les rend plus faciles à gérer et plus rapides à traiter.

NEAR et Ethereum : mécanisme de consensus
Ethereum
Actuellement, Ethereum utilise un mécanisme de consensus Proof-of-Work, mais avec Ethereum 2.0 à l’horizon, la plate-forme passera à un mécanisme de consensus Proof-of-Stake. La preuve de participation sera mise en œuvre avec le protocole Casper, créant un écosystème sans confiance. Avant de passer complètement à un mécanisme de preuve de participation, Ethereum mettra en œuvre un mécanisme de consensus hybride PoW-PoS.
Voyons comment fonctionnent à la fois la preuve de travail et la preuve de participation. La preuve de travail exige que les mineurs se fassent concurrence, utilisant des quantités massives de puissance de calcul pour résoudre des problèmes mathématiques complexes afin de valider les transactions. Une fois la transaction validée, le mineur est récompensé. Ethereum passe à un mécanisme de preuve de participation car la preuve de travail présente plusieurs problèmes, tels qu’une consommation d’énergie élevée. Le changement est également en cours pour résoudre les problèmes d’évolutivité d’Ethereum.
Dans un mécanisme de consensus Proof-of-Stake, les validateurs mettent leur ETH, après quoi ils sont sélectionnés au hasard pour attester un bloc. Le validateur sélectionné propose un blocage, tandis que les autres validateurs doivent attester qu’ils ont vu le blocage. Une fois qu’ils ont validé le bloc, il est ajouté à la blockchain, et les validateurs sont récompensés. Ainsi, les validateurs sont récompensés à la fois pour avoir proposé et attesté le bloc.

NEAR
NEAR Protocol a implémenté Nightshade Sharding comme mécanisme de consensus de preuve de participation. Nous avons déjà discuté de ce qu’est le sharding, nous pouvons donc ignorer cela. Cependant, la méthode de partitionnement utilisée aujourd’hui a ses problèmes, tels que la règle de choix de fourche dans les chaînes de partition et de balise doit être construite et testée différemment.
Cependant, Nightshade traite le système comme une seule blockchain, et chaque bloc contient des transactions pour tous les fragments. Cependant, les participants n’ont pas besoin de télécharger l’état complet, mais de conserver uniquement l’état qui fait partie de la partition pour laquelle ils valident les transactions. Une liste de toutes les transactions dans chaque bloc est créée, qui est ensuite divisée en morceaux, chaque partition se voyant attribuer une partition.


 	Les validateurs sont un élément clé du protocole NEAR, maintenant le consensus sur le protocole. Par conséquent, ils doivent maintenir leurs systèmes à jour à tout moment tout en gardant leurs serveurs en ligne.
 	Les validateurs sont sélectionnés à chaque époque en fonction de leur enjeu.
 	Les validateurs peuvent être réinscrits en rejouant leurs jetons et leurs récompenses.
 	Les validateurs peuvent renforcer leur participation de deux manières, acheter un jeton ou les emprunter via une délégation de participation.

NEAR et Ethereum: les jetons-Missing Translation
Ethereum’s native token, Ether, incentivizes programmers to continue running the blockchain’s protocol since the hardware that powers Ethereum is expensive and consumes a significant amount of power. Thus, miners and programmers are both rewarded in Ether for utilizing their resources and keeping the Ethereum ecosystem secure and functioning.
Developers also use Ether to pay so that they can launch smart contracts or decentralized applications on the Ethereum blockchain. It is also used to access smart contracts.
NEAR’s native token, the NEAR token, is used to incentivize validators on the network. The token also drives transactions and smart contracts on the blockchain. Since NEAR is a community-governed platform, token holders play a significant role in the NEAR platform’s governance, voting on potential changes on the NEAR platform.

Projets sur Ethereum et le protocole NEAR
Ethereum est le leader en matière d’applications décentralisées et de finance décentralisée, avec plus de 3000 dApps fonctionnant sur sa blockchain. La plupart des projets d’Ethereum se concentrent sur DeFi, élargissant les utilisations des crypto-monnaies pour répondre à des utilisations financières plus complexes.
Certains des meilleurs projets sur la blockchain Ethereum sont :


 	Uniswap
 	MakerDAO
 	Chainlink
 	Aave

Même si le réseau principal de NEAR a été lancé il y a un peu plus d’un an, plusieurs plates-formes s’appuient dessus. Certains des projets du protocole NEAR sont :


 	Mintbase — Une plate-forme dédiée à la simplification de l’émission et de la vente de NFT tout en rendant l’ensemble du processus bon marché.
 	Flux — Flux est un protocole de marché ouvert décentralisé. Il a été lancé sur le protocole NEAR en 2020.
 	Paras — Paras est un marché NFT axé sur les œuvres créées par des artistes sélectionnés.

Le programme de subventions NEAR, actuellement géré par la Fondation NEAR, soutient des projets qui permettent la croissance de l’écosystème NEAR.

Aurora sur le protocole NEAR
Aurora a également lancé le protocole NEAR, offrant une expérience Ethereum Layer-2. Une solution qui permet aux développeurs d’atteindre des marchés supplémentaires, Aurora tire parti des fonctionnalités du protocole NEAR telles que la rémunération des frais de gaz et le sharding. Il fonctionne sur deux composants critiques, le pont Aurora et le moteur Aurora.
Certaines des améliorations apportées par Aurora sont :


 	La capacité de traiter des milliers de transactions par seconde, une augmentation de 50 fois par rapport à Ethereum.
 	Un temps de finalité de bloc de 2 secondes, par rapport au temps de confirmation de bloc unique de 13 secondes sur Ethereum. La finalité rapide réduit également les attaques de front.
 	Croissance de l’écosystème à l’épreuve du temps, l’approche de partitionnement du protocole NEAR permet une mise à l’échelle EVM horizontale et une communication asynchrone entre plusieurs partitions.
Les frais sur Aurora sont 1000 fois inférieurs à ceux sur Ethereum.
 	Pour prendre un exemple, le transfert d’un jeton ERC-20 sur Aurora coûte moins de 0,01 $, tandis que sur Ethereum, il coûte environ 5,40 $.
 	Aurora offre une compatibilité sans compromis avec Ethereum via le protocole NEAR.

Aurora fournit une solution aux défis rencontrés par l’écosystème Ethereum, tout en préservant à la fois les contrats intelligents et le code frontal.

Avantages du protocole NEAR
La solution fragmentée de NEAR lui confère un énorme avantage par rapport aux plates-formes comme Ethereum et Bitcoin, résolvant le problème de la faible évolutivité et des goulots d’étranglement fréquents sur le réseau Ethereum. En rendant leur protocole fragmenté, les fondateurs de NEAR divisent le code de la blockchain en morceaux exécutés sur des nœuds parallèles. Il en résulte que l’intégralité du code est traité rapidement et libère NEAR des problèmes d’évolutivité grâce à cette capacité à fragmenter le code.
Le protocole NEAR possède plusieurs caractéristiques uniques qui en font une proposition attrayante pour les utilisateurs et les validateurs.


 	Une UX flexible et un accès aux services qui s’exécutent sur la plate-forme NEAR présentent également un processus d’intégration facile.
 	Grâce au protocole fragmenté de NEAR, les validateurs peuvent rejoindre la plate-forme sans télécharger de logiciel complexe. Ils peuvent ensuite gagner des jetons en validant les transactions sur le réseau.
 	NEAR permet aux entreprises de personnaliser les autorisations pour leurs utilisateurs. Avec une croissance constante du marché, les développeurs ont également accès à une clientèle croissante.

La voie à suivre pour le protocole NEAR
Avec le lancement du pont Ethereum-to-NEAR, également appelé Rainbow Bridge, les utilisateurs peuvent relier leurs jetons Ethereum ERC-20 à NEAR et commencer à les utiliser dans l’écosystème d’applications décentralisé de NEAR. Ce développement est un grand pas vers la vision de l’équipe fondatrice de rendre la plateforme aussi accessible que possible.
NEAR travaille également à la mise en œuvre de la prise en charge de la machine virtuelle Ethereum (EVM). Une fois ce processus terminé, les développeurs peuvent redéployer leurs dApps sur NEAR avec un minimum de modifications et activer les lancements inter-chaînes.
Le protocole NEAR a annoncé un partenariat avec Chainlink, ainsi que le lancement de Rainbow Bridge, permettant l’interaction NEAR et Ethereum.

Conclusion    
Le protocole NEAR a montré beaucoup de promesses, utilisant le sharding pour résoudre les problèmes d’évolutivité des blockchains de deuxième génération. De plus, NEAR augmente considérablement le débit sans compromettre la sécurité de la plate-forme.
Grâce au collectif NEAR, des centaines d’ingénieurs et de développeurs blockchain travaillent à l’amélioration du protocole 24h/24 et 7j/7. NEAR a également lancé son réseau principal et le réseau est prêt à prendre en charge les dApps et d’autres services. En mettant l’accent sur la facilité d’utilisation de la plate-forme NEAR pour les validateurs, les utilisateurs finaux et les développeurs, NEAR est devenu une force dans l’espace des plates-formes de contrats intelligents.
Ethereum, en revanche, a conservé sa position sur le trône grâce à sa communauté de développeurs enviable et aux écosystèmes DeFi et NFT florissants. Ces deux protocoles fournissent une plate-forme brillante aux développeurs pour construire l’écosystème décentralisé du futur.

### 5 hướng phát triển mới của NFT

Giá trị thị trường NFT của các tác phẩm nghệ thuật đã tăng lên hơn 200 triệu đô la vào tháng 3 năm nay trên một số chợ NFT lớn, và từng giảm 50% vào tháng 4. Đối với những người gièm pha NFT thì đây là "sự kết thúc của NFT". Tuy nhiên, các tác phẩm nghệ thuật chỉ là phần nổi của tảng băng chìm và gần đây chúng ta đang thấy sự xuất hiện của các cách sử dụng NFT mới.
Chúng ta đang chuyển từ việc tạo ra các NFT sang việc sử dụng NFT
Các công cụ dành cho người sáng tạo đã trở nên ngày càng mạnh mẽ hơn. Điều mà hầu hết các nhà phát triển phải triển khai bây giờ là các tính năng trên các nền tảng đúc NFT. Các nền tảng hiện cung cấp giao diện cho người sáng tạo để xác định độ hiếm, cơ chế đấu giá và tỷ lệ tiền bản quyền từ các đợt bán thứ cấp trên Ethereum, Flow, Tezos, NEAR, v.v. Nguồn cung cấp NFT tăng do các công cụ sáng tạo dễ sử dụng.



Hiện tại, thay vì tập trung tìm những cách tốt hơn, dễ dàng hơn để tạo ra NFT thì mọi người đang có những cách thú vị để sử dụng NFT. Bài viết này có mục đích nêu ra 5 hướng mới trong việc sử dụng NFT.
1. Bằng chứng về sự bảo trợ
NFT là chìa khóa dẫn tới việc tạo ra những nội dung và cả cơ hội độc quyền.

Ngày nay, những người sáng tạo sử dụng NFT và các social token để trực tiếp kiếm tiền từ những người hâm mộ của họ. Các NFT và social token này cung cấp cho người hâm mộ quyền truy cập độc quyền vào nội dung, cơ hội và một cách trực tiếp để đầu tư vào những người sáng tạo yêu thích của họ. Trong tương lai, chúng ta sẽ thấy những thử nghiệm mà ở đó NFT và các social token tương tác và sự gia tăng của các dạng tiền điện tử giống như Patreon, Substack hay OnlyFans.

Những ví dụ cụ thể:

 	Thưởng cho những người ủng hộ sớm: Với dự án "Infinite Players", Jack Butcher đã tạo ra một NFT chia sẻ doanh thu của mình với tất cả những người đã ủng hộ cho những tác phẩm NFT trước đây của anh ấy.
 	Thưởng cho những người ủng hộ sớm bằng quyền truy cập độc quyền vào nội dung: 3LAU cung cấp cho người dùng của anh ấy quyền truy cập độc quyền vào các bài hát chưa phát hành hoặc cơ hội để tương tác với anh ấy. Để đủ điều kiện mua một số sản phẩm trong đợt giảm giá mới nhất của 3LAU, người dùng cần sở hữu 3LAU NFT trước đó. Tương tự, Aku, một nhân vật phi hành gia do Micah Johnson tạo ra, có những NFT mà chỉ những người từng là khách hàng quen của những lần drop NFT trước đó mới có thể truy cập được. Người sáng tạo sử dụng các cơ chế này để thưởng cho những người ủng hộ sớm và tạo ra tiện ích cho NFT của họ.

(Link tweet: https://twitter.com/Micah_Johnson3/status/1383842340700180480)



Những dự đoán cho các ứng dụng NFT trong tương lai gần:

 	Patreon phi tập trung: sẽ không giống Patreon ngày nay, nơi người hâm mộ đăng ký nội dung. Người sáng tạo sẽ sử dụng NFT và social token để tạo ra nền kinh tế xung quanh cộng đồng của họ. Người sáng tạo sử dụng các nền tảng mới sẽ liên tục (1) bán NFT, (2) bán quyền truy cập vào nội dung và hình ảnh dựa trên NFT hoặc quyền sở hữu social token, (3) cho phép thanh toán trực tuyến tới chính họ trong thời gian thực dựa trên các loại token mà người hâm mộ của họ sở hữu , (4) phân phối doanh thu từ việc bán NFT trở lại cộng đồng các thành viên đã tích cực ủng hộ họ. Chúng ta sẽ thấy nhiều thử nghiệm thú vị hơn trong đó NFT và các social token tương tác với người dùng, chẳng hạn như các sự kiện NFT drop chỉ có thể được mua bằng social token của người sáng tạo đó hoặc NFT cung cấp cho người hâm mộ quyền truy cập vào social token được airdrop sau này. Các nền tảng social token như Roll, các nền tảng quản lý cộng đồng dựa trên mã thông báo như Collab.Land và Mintgate, và các dịch vụ phát trực tuyến thanh toán như Unlock và Superfluid đều sẽ đóng một vai trò trong các ứng dụng theo kiểu Patreon phi tập trung mới.
 	Shopify cho NFT: Các nền tảng đúc NFT hiện tại vận hành theo mô hình của Amazon và chủ yếu làm nổi bật các sản phẩm, không phải người sáng tạo. Các nền tảng NFT mới có thể tuân theo mô hình hướng tới người sáng tạo cho phép người sáng tạo tạo các cửa hàng có thương hiệu của riêng họ để bán NFT. Một số nền tảng cho phép người sáng tạo tạo cửa hàng của riêng họ gần đây đã nổi lên như Mintbase và DAORecords.
 	NFT cho các thương hiệu lớn: Các thương hiệu lớn nhất hiện nay như Adidas và các nghệ sĩ như The Weeknd sử dụng các nền tảng đúc NFT như NiftyGateway để bán NFT của họ. Một khi NFT chiếm một phần lớn hơn trong chiến lược của họ, các doanh nghiệp và các nghệ sĩ sẽ muốn có những nền tảng NFT mang thương hiệu của riêng họ.

2. Đồng sáng tạo & Đồng sở hữu
Thay vì đón nhận và sử dụng những nội dung sáng tạo một cách thụ động, người hâm mộ giờ đây có thể tự tạo ra nội dung.

Ranh giới giữa người hâm mộ và người sáng tạo sẽ ngày càng mờ đi. Người hâm mộ sẽ tạo ra thế giới phong phú cho các nhân vật NFT và thay đổi NFT dựa trên những gì họ muốn nhìn thấy hoặc thông qua Tổ chức tự trị phi tập trung (DAO). Người hâm mộ sẽ không còn là người tiêu dùng thụ động. Những người hâm mộ lớn nhất sẽ là một phần của quá trình sáng tạo.

Những ví dụ cụ thể:

 	Cộng đồng xây dựng công cụ cho các bộ sưu tập NFT: Meebits là các nhân vật 3D có thể sưu tập được tạo bởi nhóm Cryptopunk và họ đã có các thành viên trong cộng đồng xây dựng nên những công cụ cho nó, ví dụ như các hướng dẫn về cách chuyển đổi Meebits thành avatar metaverse. Một số thành viên thậm chí còn thành lập các DAO như MeebitsDAO tạo ra các công cụ và hệ thống vận hành để cho phép Meebits làm hình đại diện kỹ thuật số trong metaverse. Tương tự, Axie Infinity đã tạo ra bộ sưu tập các nhân vật được gọi là Axies và cộng đồng có thể tạo các trò chơi của riêng họ tương tác được với các nhân vật này.
 	Những người sưu tập có thể thay đổi NFT mà họ sở hữu: AsyncArt là một nền tảng đúc NFT đã tạo ra các NFT có thể lập trình được và cả âm nhạc. Bằng cách sở hữu một đoạn hoặc một phần nhạc NFT, những người sưu tập có thể thay đổi để biến nó thành độc nhất của riêng họ.

(Link tweet: https://twitter.com/AsyncArt/status/1391124652433428481)



Các dự đoán:

 	NFT Remixing: Người hâm mộ có thể lấy nhạc, tác phẩm nghệ thuật, video, tiểu thuyết, v.v. và “phối lại” chúng để tạo ra những NFT mới đồng thời trả lại tiền bản quyền cho người sáng tạo ban đầu.
 	Thế giới do người hâm mộ tự sáng tạo: Những nhân vật nổi tiếng nhất sẽ trở thành NFT có thể được đưa vào môi trường do người hâm mộ tạo ra. Người hâm mộ sẽ có thể tạo trò chơi cho các nhân vật yêu thích của họ, bật hỗ trợ metaverse để họ có thể đi lại trong vai nhân vật của họ hoặc thậm chí đưa nhân vật vào các tác phẩm sáng tạo mới như phim, tiểu thuyết, âm nhạc, video, v.v. theo cách có thể mang lại thu nhập cho những người sáng tạo. Các nghệ sĩ đã và đang tạo ra NFT với ý tưởng là xây dựng một thế giới trong không gian NFT. Ví dụ, truyện tranh PUNKS đã tạo ra truyện tranh với các NFT Cryptopunks. Người nắm giữ NFT có thể đặt cược hoặc đốt NFT của họ để nhận được token $PUNKS đại diện cho một phần nhỏ của các Cryptopunks được sử dụng trong bộ truyện tranh này.
 	Người hâm mộ có thể thay đổi NFT: Người hâm mộ sẽ có thể độc lập (hoặc cùng nhau) quyết định xem các NFT sẽ trông như thế nào (hoặc nghe như thế nào). Ví dụ: người hâm mộ có thể sở hữu ảnh bìa album của Taylor Swift và thay đổi nền của bức ảnh. Khi NFT trở thành một phần của trò chơi, phim hoặc truyện tranh, người hâm mộ có thể bỏ phiếu về cốt truyện hoặc cách hành xử của một số nhân vật dựa trên NFT.
 	Giải quyết tranh chấp về quyền sở hữu & doanh thu: Các tranh chấp nội bộ sẽ phát sinh khi việc tạo NFT trở nên phổ biến và phức tạp hơn. Những người sáng tạo hợp tác với nhau để tạo ra NFT có thể sẽ tranh chấp việc phân phối doanh thu và tỷ lệ sở hữu. Một số người sáng tạo có thể tạo các NFT giống nhau trên nhiều nền tảng. Những người khác có thể thay đổi siêu dữ liệu trên NFT. Upshot là một nền tảng để thẩm định NFT và nhiều giao thức khác cũng sẽ được tạo ra để xác minh tính xác thực của NFT, điều tra gian lận đúc tiền và giải quyết các tranh chấp.

3. Danh tiếng & Định danh On-chain
NFT xác định các hành động và lòng trung thành trong quá khứ

Mọi người sẽ nhận được các NFT “không thể chuyển nhượng” dạng như "huy hiệu" dựa trên các hành động họ đã thực hiện. Các NFT mà mọi người sở hữu sẽ là một dấu vân tay duy nhất nhận dạng họ dựa trên các hoạt động trong quá khứ của họ. Lịch sử về danh tiếng này sẽ được sử dụng làm danh tính trên chuỗi để mở ra các cơ hội mới sau này.

Các ví dụ cụ thể:

 	Bằng chứng về hành động trong quá khứ (PoPA): Uniswap hiện cung cấp cho người dùng NFT để chứng minh địa vị của họ. Reality Cards là một thị trường dự đoán cho phép người giữ vị thế lớn nhất ở cả hai phía đặt cược sẽ nhận được kết quả là NFT, cho phép người dùng này xây dựng lịch sử cá cược. POAP là một giao thức cho phép những người tạo sự kiện có thể phân phát các huy hiệu "Bằng chứng tham dự". Các cuộc gọi từ cộng đồng của Bankless cũng đưa ra NFT để chứng minh sự tham dự. 
 	Bằng chứng về tư cách thành viên: Giao thức Orca cung cấp tư cách thành viên dựa trên NFT cho các nhóm làm việc như một ủy ban tài trợ cho một giao thức quản trị. Các NFT này có thể được sử dụng làm thông tin xác thực để mở khóa các quyền hoặc hoạt động trên chuỗi, giống như một loại ngân sách mà thành viên có thể yêu cầu tới quản trị viên

Các dự đoán:

 	Danh tiếng trên chuỗi: Các ứng dụng sẽ sử dụng quyền sở hữu NFT như một tín hiệu về chất lượng của người dùng. Người dùng sở hữu các NFT cụ thể sẽ được coi là có tín hiệu cao và sẽ có quyền truy cập sớm hoặc duy nhất vào các ứng dụng mới nhất. Ví dụ: việc người dùng sở hữu một số NFT Uniswap nhất định có thể cho biết họ là nhà cung cấp thanh khoản. Một số giao thức DeFi sẽ cho phép người dùng sở hữu một số NFT nhất định truy cập sớm hoặc giới hạn và họ cũng sẽ có quyền được chi tiêu cao hơn những người không sở hữu các NFT này.
 	Cộng đồng có thể nhận thưởng NFT dựa trên đóng góp: NFT có thể được trao cho các thành viên cộng đồng dựa trên đóng góp của họ. Ví dụ: các NFT có thể được trao cho thành viên tích cực nhất trong việc quản trị, những người đóng góp mã nguồn hàng đầu hoặc thành viên cộng đồng tích cực nhất trong việc góp ý cho các thành viên khác, v.v.
 	Các suất quản trị được quyết định bởi quyền sở hữu NFT: Người dùng chỉ có thể tham gia một ủy ban tài trợ nếu họ có NFT chứng minh rằng họ đã phân bổ tiền trong quá khứ hoặc họ đã hoạt động trong các giao thức quản trị. “Vai trò” trong các server trên Discord cũng có thể dựa trên quyền sở hữu NFT.
 	Điểm tín dụng dựa trên NFT: Nếu người dùng nhận được NFT vì là thành viên tốt trong giao thức cho vay, thì giao thức cho vay có thể mang lại cho họ lãi suất cho vay tốt hơn. Nếu người dùng là thành viên có những hành vi xấu, họ có thể bị gán nhãn tiêu cực. Quyền sở hữu NFT cũng có thể được sử dụng để xác định mức độ tín nhiệm.

4. Nền tảng khám phá & tuyển chọn
Nền tảng để tìm kiếm, khám phá và tổ chức các NFT.

Giống như các trang web vào những năm 1990 trước khi Google xuất hiện, NFT là một loại dữ liệu mới mà chúng ta không dễ dàng tìm kiếm và khám phá. Trong tương lai, sẽ có những nền tảng mạnh mẽ được tạo ra để quản lý, sắp xếp và đề xuất các NFT. Hơn nữa, vì NFTs cũng tạo nên danh tiếng và định danh trên chuỗi (như đã nói ở phần 3), chúng ta có thể tạo ra các mạng xã hội dựa trên quyền sở hữu NFT. Tín hiệu xã hội sẽ là một phần quan trọng trong các tính năng mà chúng ta sử dụng để tổ chức các NFT.

Các ví dụ cụ thể:

 	Mạng xã hội dựa trên quyền sở hữu NFT: Showtime là một nền tảng giống như Instagram dành cho chủ sở hữu và người sáng tạo NFT.
 	Nền tảng tìm kiếm và quản lý NFT: Các nền tảng web truyền thống như eBay hiện đang hỗ trợ NFT trên nền tảng của nó, điều này sẽ hình thành cách mà chúng ta tìm kiếm NFT. Nhiều chợ NFT tồn tại như một thị trường chung như Opensea hoặc được quản lý như Foundation. Có những chợ nằm ngoài hệ sinh thái Ethereum như hic et nunc, Mintbase và Paras.id. Bạn có thể tìm hiểu thêm từ những tài nguyên tuyệt vời liệt kê đầy đủ hơn về các chợ NFT như tài liệu này của Sean Bonner hoặc tài liệu này của Tech Optimist.

Các dự đoán:

 	LinkedIn của NFTs (ý tưởng: Cuy Sheffield): Khi chúng ta kiếm được "huy hiệu" NFT không thể chuyển nhượng thông qua các hành động trong quá khứ như tham dự sự kiện, bỏ phiếu trong DAO hoặc cung cấp tính thanh khoản trong DeFi, các nền tảng truyền thông xã hội sẽ được phát triển dựa trên các huy hiệu mà chúng ta tích lũy. Chúng ta có thể thấy LinkedIn của các NFT, nơi hồ sơ của chúng ta chỉ đơn giản là một nơi hiển thị tên tuổi một cách trực quan cho mọi người thấy được những đóng góp trong quá khứ. Mọi người có thể được xác định và tuyển dụng dựa trên NFT không thể chuyển nhượng của họ.
 	Công cụ tìm kiếm cho NFT (Amazon, Etsy, v.v.): Chúng ta có thể thấy nhiều công cụ tìm kiếm sản phẩm hơn cho NFT. Cả Amazon và Etsy đều đã có nhiều chủ cửa hàng bán đồ sưu tầm và trong tương lai các nền tảng này có thể hỗ trợ tìm kiếm sản phẩm NFT. Các chợ NFT hiện tại như các chợ được nêu ở phần trên cũng sẽ phát triển các tính năng tìm kiếm, khám phá và đề xuất phức tạp hơn nhằm tăng trải nghiệm người dùng.

5. Tài chính hóa NFT
NFTs cũng là một loại tài sản.

NFTs thể hiện quyền sở hữu đối với tài sản và vì thế chúng có thể được sử dụng trong các giao dịch tài chính. Có nhiều cơ chế mới cho NFT như “phân chia” doanh thu hoặc phân đoạn NFT nhằm làm cho NFT hữu ích hơn như một loại tài sản. Trong tương lai, chúng ta sẽ thấy NFT tăng trưởng theo cấp số nhân như một lại tài sản giống như vàng hoặc tiền pháp định.

Các ví dụ cụ thể:

 	Gây quỹ cho các tổ chức từ thiện và các loại hàng hóa: Người sáng tạo và nghệ sĩ có thể gây quỹ từ thiện thông qua đấu giá NFT. Các tổ chức liên kết với nhau để tạo ra các quỹ liên kết để tài trợ cho các loại hàng hóa trong thế giới thực. Người tạo ra NFT có thể cam kết một phần thu nhập từ đấu giá NFT của họ cho các quỹ và tiền thu được sẽ tự động được thanh toán khi NFT được bán. Giờ đây, khi những người sáng tạo NFT muốn huy động tiền vì một lý do nào đó, họ sẽ có đầy đủ sự minh bạch cho việc số tiền đó sẽ được dùng vào đâu, mục đích gì.



 	Các NFT có thể hoán đổi cho nhau thông qua phân đoạn: NFTX cho phép người dùng gửi NFT vào một nhóm và đúc một token theo chuẩn ERC20. B.20 là một "gói phân đoạn" tác phẩm NFT của tác giả Beeple. $WHALE là một token đại diện cho một nhóm phân đoạn gồm hơn 13.000 NFT ban đầu thuộc sở hữu của một nhà sưu tập có biệt danh là Whaleshark. Rats Vaults cho phép người dùng gửi bất kỳ NFT nào và nhận lại một token (có các vaults đặc biệt dành cho người sở hữu một mã social token cụ thể được gọi là $FWB). Việc đúc các token có-thể-hoán-đổi-cho-nhau với NFT là một chức năng mở khóa theo bước vì các token có thể được sử dụng để kiếm lợi nhuận với các giao thức DeFi, cải thiện khả năng khám phá giá cho các dự án NFT và làm tăng tính thanh khoản cho NFT vì chúng có thể được hoán đổi thông qua một nhà tạo lập thị trường tự động (AMM). Thành viên của các nhóm phân đoạn này có thể có các quyền đặc biệt như khả năng bỏ phiếu về việc mua và bán tài sản trong pool, khả năng thuê các NFT là một phần của pool, khả năng thu cổ tức trên các NFT tạo ra lợi nhuận trong pool, và hơn thế nữa…
 	Phát hành "cổ tức": Người thu thập có thể nhận được tài sản mới dựa trên NFTs mà họ sở hữu. “Cổ tức” này có thể được phát hành theo cách không chính thức. Ví dụ: một số nhà sưu tập nhận được các NFT mới, được airdrop từ các nghệ sĩ vì họ sở hữu các NFT được nhiều người biết tới và các nghệ sĩ muốn quảng bá tác phẩm của họ cho những nhà sưu tập này. “Cổ tức” cũng có thể dùng để yêu cầu sự tham gia tích cực, như khi Meebits thiết lập quy trình khai thác cho phép những người nắm giữ Cryptopunk đổi lấy các Meebits mới. "Cổ tức" cũng có thể được phát hành trực tiếp như là một loại doanh thu cho người sở hữu NFT. Ví dụ: Yieldguild là một tập hợp các DAO mua tài sản trong các trò chơi NFT (ví dụ: Axies trong Axie Infinity) và sau đó cho người chơi mượn để họ không cần phải mua tài sản trả trước và kiếm thu nhập từ việc chơi các trò chơi này. Các loại yield generating NFT đang được tạo ra nhiều hơn, chẳng hạn như Aito vừa công bố một loại NFT được tích hợp với Aave.
 	Các DAO mua NFT dưới dạng đầu tư: PleasrDAO gần đây đã mua Tor’s NFT với giá 500ETH. DAO này được tạo ra để mua những tác phẩm của nghệ sĩ pplpleasr. FlamingoDAO, Whaleshark và nhiều DAO khác cũng đang đầu tư vào NFT.

(Link tweet: https://twitter.com/withFND/status/1393295866769805313)

Các dự đoán:

 	Tạo ra dòng tiền với NFT: Chẳng bao lâu nữa, NFT có thể mang lại doanh thu cho chủ sở hữu của chúng. Một cách NFT có thể tạo ra doanh thu là thông qua tiền cho thuê quyền sử dụng đất. Ví dụ: chủ sở hữu đất ở các đảo lớn như Cryptovoxels có thể tính tiền thuê từ những người sử dụng đất của họ. Ngày nay, chủ sở hữu đất của Cryptovoxels có thể thêm các “cộng tác viên”, những người có thể xây dựng trên đất của họ, nhưng không sở hữu nó. Trong tương lai, sẽ có các hợp đồng thông minh mà chủ đất và người thuê có thể sử dụng để chỉ định tiền thuê, thời hạn thuê và các điều khoản khác. Một cách khác mà NFT có thể tạo ra doanh thu là thông qua quyền sở hữu bản quyền âm nhạc. Ví dụ: master của các bài hát có thể là NFT kiếm về thu nhập mỗi khi bài hát được phát trực tuyến. Cộng đồng người hâm mộ có thể nhóm lại với nhau và mua các bản nhạc của các nhạc sĩ họ yêu thích. Cách này thực tế đang được vận hành như sau: các cá nhân đang cho thuê các cryptopunk của họ, các nền tảng như reNFT đang thử nghiệm việc cho phép các cá nhân cho thuê NFT, Varda thì đang thử nghiệm với các quỹ đặt cược được sử dụng để mua NFT nhằm tạo ra lợi nhuận từ NFT, Charged Particle cho phép người dùng sử dụng một NFT để đại diện cho một tập các token ERC20 và kiếm tiền lãi từ chúng.
 	Các NFT được phân đoạn phù hợp với hệ sinh thái DeFi: Khi chúng ta phân đoạn các NFT thành các token fungible như ERC20, chúng ta có thể sử dụng các token này với các giao thức DeFi hiện nay. Các token này có thể được hoán đổi thông qua AMM, được đưa vào các pool cho vay, .... Ví dụ: người dùng có thể phân đoạn một bộ sưu tập những tác phẩm NFT bằng cách phát hành một token ERC20, sau đó hoán đổi các token đó thông qua Uniswap. Các giao thức DeFi có thể phát triển các tính năng để tối ưu hóa cho các NFT được phân đoạn, hoặc các giao thức defi mới có thể xuất hiện. Các nền tảng như NFTfi đã cho phép người dùng vay tiền với NFT làm tài sản thế chấp.
 	Tác động tới NFTs : Các nghệ sĩ có thể cung cấp phần trăm doanh thu từ NFTs của họ cho một số vấn đề có tính vô thời hạn, ngay cả sau khi họ chết! Người sáng tạo có thể tạo "NFT tác động" cụ thể để hỗ trợ các vấn đề về môi trường hoặc xã hội.
 	Gây quỹ trước khi có token: Các dự án chưa phát hành token quản trị có thể phát hành NFT để thưởng cho những người ủng hộ sớm. Sau khi token quản trị của họ ra mắt, họ có thể phát hành các token này cho những người đã nắm giữ NFT.

… Và nhiều giới hạn khác của NFT sẽ được khám phá

Những ý tưởng trên đây mới chỉ là bề nổi cho những gì mà NFT có thể được ứng dụng. Hai hướng phát triển chính trong tương lai gần sẽ tạo ra sự bùng nổ của các ứng dụng NFT mới mà chúng ta chưa từng thấy hoặc chưa hình dung:

 	Các loại tài sản mới được đại diện bởi NFT: Về nguyên tắc thì NFT là một cơ chế chung và có thể dùng để thể hiện quyền sở hữu đối với bất kỳ thứ gì. Cho đến nay, chúng ta chủ yếu sử dụng nó để đại diện cho hình ảnh trực quan và các tệp gif, trò chơi điện tử dựa trên tiền mã hóa và âm nhạc. Các loại nội dung mới sẽ tạo ra các trường hợp sử dụng mới cho NFT. Những nội dung này có thể bao gồm nội dung trò chơi từ các nhà phát triển trò chơi truyền thống, văn bản (đã được phát triển như dự án này của Mirror), phim và video, nhân vật thể thao, hàng hóa vật chất, bất động sản, nhân vật từ các thương hiệu nổi tiếng như Harry Potter hoặc Disney, các nhóm tài sản (đã nổi lên thông qua Charged Particles), và nhiều trường hợp khác.
 	 Chi phí giao dịch thấp: Các trường hợp sử dụng NFT ngày nay chủ yếu tồn tại trên Ethereum, vì vậy chúng đang bị hạn chế bởi chi phí giao dịch cao. Khi có thể tốn hơn $50 để đúc một NFT hoặc để giao dịch, các trường hợp sử dụng NFT có thể bị giới hạn. Do đó, ngày nay chúng ta thường coi NFT là sản phẩm nghệ thuật xa xỉ. Tuy nhiên, các blockchain layer 1 như NEAR, Tezos, v.v. giúp bạn có thể đúc và giao dịch với phí dưới một xu. Nhờ việc không bị ràng hạn chế bởi chi phí giao dịch cao, các nhà phát triển và người sáng tạo sẽ tạo ra các ứng dụng mới cho NFT mà chúng ta thậm chí còn chưa hình dung ra.

Nếu bạn đang nghiên cứu những cách mới để sử dụng NFT, tôi muốn nghe ý kiến của bạn và tham gia vào những gì bạn đang xây dựng!

--

Disclosure: Electric Capital is an investor in some of the protocols mentioned in this article.

Thank you to Aliaksander “Sasha” Hudzilin, Curtis Spencer, Cuy Sheffield, Julia Rosenberg, Julia Wu, Ken Deeter, Willie Maddox.

### How to build a Play To Earn game on NEAR Protocol

In depth review of the current prototype — BerryClub



This guide is meant to let you understand the basic dynamics that will enable you to create a play to earn game on Near Protocol.
We don’t mean to make you or your players rich, but the mechanics of Near work in such a way for small transactions to be very useful on a simple HTML5 UI and create a simple and fun farming game.
We will analyze a smart contract and the js/rust files behind an existing farming game, berryclub. If you apply the very same logic to your ideas of game you may get even funnier results!
To follow the technical side of this tutorial we highly recommend checking the figment Near Pathway to build a transaction and build your first smart contract on Near, the concepts present in that guides are not included in this tutorial. It will be far easier fo you to follow this tutorial if you keep a tab open on the linked source file while reading the explanation, because much of the mentioned code is referenced with line numbers but not reproduced here. The BerryClub original repo was forked for this tutorial in order to keep this effort valid as far as the code still works on the blockchain; as you will see in the next section the game itself has evolved thourgh time and will be evolving again, we wanted to make a point of it’s state right now.

The Berryclub frontend
Berryclub is built with React, so the very first thing we’ll step into in the app.js file located into the src folder of the github repo, this will save us time in analysing the contract letting us focus on what we need to extrapolate the logic outside of the actual game (which is fun and played by a big community btw).

import React from “react”;
import BN from “bn.js”;
import * as nearAPI from “near-api-js”;
import { AlphaPicker, HuePicker, GithubPicker } from “react-color”;
import Switch from “react-switch”;
import { Weapons } from “./Weapons”;
import Timer from “react-compound-timer”;
After importing react the first library needed is bn.js a simple utility to manage integers or non decimal numbers, many features can come to your interface with this library, first of all here it is used to manage the transactions:

const PixelPrice = new BN(“10000000000000000000000”);
The berryclub game is based on real estate economics, there is a board managed by a part of the contract called board.rs, it is subdivided in pixels, and each pixel has a price which has to be paid in order to draw on it. The machanics of the “draw” action are the core of the Farming and self substaining abilities of the game and will be analysed in depth when we get to the smart contract.
As you can see here the single pixel price is declared as a constant at the very start of our application, and may be modified using the frontend tools and the bn.j library. The second import is the near sdk which allows us to interact with the Near blockchain as explained in the Figment near pathway. The first usage of the near api is to declare the used contract variables and to ensure that the mainnet is used when code is run from the berryclub url:

const IsMainnet = window.location.hostname === "berryclub.io";
const TestNearConfig = {
  networkId: "testnet",
  nodeUrl: "https://rpc.testnet.near.org",
  contractName: "berryclub.testnet",
  walletUrl: "https://wallet.testnet.near.org",
};
const MainNearConfig = {
  networkId: "mainnet",
  nodeUrl: "https://rpc.mainnet.near.org",
  contractName: "berryclub.ek.near",
  walletUrl: "https://wallet.near.org",
};
const NearConfig = IsMainnet ? MainNearConfig : TestNearConfig;
Then we import the react UI utilities to build our interface and allow people to draw, react-color, react-switch and react-compound-timer. The first of these utlitities that’s used is the timer, it is used to set a timeout for refreshing the board on line 62.
The board “refreshing” is done by the frontend to display the updated board state using an RPC call to the smart contract.

const BatchTimeout = 500;
const RefreshBoardTimeout = 1000;
const MaxWorkTime = 10 * 60 * 1000;
const OneDayMs = 24 * 60 * 60 * 1000;
What we see here are two const more than the ones needed for refreshing, the last two in fact are used for Farming the pixels after drawing them, and set a time slot of one day to calculate the rewards. Other const are also declared to manage the Board accordingly with the Smart contract, and here, for the first time we cross the concept of lines, wich will be very important to understand the board management and is the most reusable item of the whole interface:

const BoardHeight = 50;
const BoardWidth = 50;
const NumLinesPerFetch = 50;
const ExpectedLineLength = 4 + 8 * BoardWidth;
As you can see, after subdividing the board 50x50 we tell our interface to fetch only the lines following the RefreshBoardTimeout instruction and to consider the lenght of each line as the Boardwidth multiplied for 12, the size of a single cell.

const CellWidth = 12;
const CellHeight = 12;
const MaxNumColors = 31;
const BatchOfPixels = 100;
Pixels are considered in batch, not independently, both when the draw action is called and when the interface is refreshed.
Last but not least our imports include a custom UI component, called Weapons,js: this component has been developed later in the history of the berryclub community, in order for each user to be able to upload and draw an entire image on the board, and mint it on the berrycards NFT marketplace.

DeFi mechanics
The lines between 27 and 51 are a useful reference to how this Dapp builds its Farming abilities over some basic DeFi mechanics that will be analysed in the last parts of this tutorial. By now we just briefly mention that in order to draw/buy a pixel berryclub funnels you through a couple of DeFi operations on ref.finance using it’s own specific Tokens, avocados for buying pixels and bananas earned from the pixels you bought.













There is a simple uniswap clone created to swap near for bananas/avocados that worked on the same smart contract built for the other tokens of this game/prototype. There is also a farming token created for the game, called cucumber, it allows people to earn a part of the tokens that the whole community that plays the game pays for gas to draw on the board.













The Account or how users make money
This is the very first step we make into the rust code of the smart contract, but I felt the need to remind you that DeFi mechanics aren’t the only way Berryclub let’s you earn tokens. The account has a particular file in the berryclub smart contract we don’t need to step into that immediately, what we need to know is that some informationinformations are collected in the account object that are crucial for the farming and earning mechanics:


 	accountID
 	accountIndex for the list(vector) of accounts that touched the pixel board for the last time
 	balance(vector for multiple tokens owned)
 	number of pixels
 	claimed timestamp (nanoseconds, when the given account claimed rewards for the last time)
 	farming preferences (either bananas or cucumbers)

Last two info are to calculate the rewards at a given moment, for example if you own 5 pixels for one day you acquire 5 bananas. If you buy from someone else their earning decreases because the number of pixels they own decreases so the amount of earning get calculated and the timestamp renewed relating the new amount of owned pixels. As we’re gonna see, the rewards are calculated based on these two variables. The operation applied to the previous owner account when a pixel is drawn is called “touch” and you can find it in the account.rs rust file. Ownership of the single pixel unity, is the base for earning on berryclub, and in this way this mechanics are pretty much the same an NFT staking interface could use, rewarding NFT ownership.

pub fn touch(&mut self) -> (Berry, Balance) {
        let block_timestamp = env::block_timestamp();
        let time_diff = block_timestamp - self.claim_timestamp;
        let farm_bonus = if self.farming_preference == Berry::Avocado {
            1
        } else {
            0
        };
        let farmed = Balance::from(self.num_pixels + farm_bonus)
            * Balance::from(time_diff)
            * REWARD_PER_PIXEL_PER_NANOSEC;
        self.claim_timestamp = block_timestamp;
        self.balances[self.farming_preference as usize] += farmed;
        (self.farming_preference, farmed)
    }
To clear any doubts the initial owner of the board is 0, the contract itself, and whether finding a previous owner is not possible, the contract is used as the previous owner. Finally to start up the game some tokens have been stored in the contract’s account and they are always increased using the gas price established for people to buy avocados and bananas, so that the “vault” of the game is always filled with some tokens for the users to gain. Now let’s get back to our interface.

Numbers to Colors and Back












The lines between 67 and 82 on app.js are used to decode numbers into colors and back, in order for the UI elements to interact with the board, two constant variables are definded, intToColor and rgbaToInt. What we can notice here is that to transform an integer number into a colour string methods are used to divide the 3 numbers for red green an blue:

const intToColor = (c) => `#${c.toString(16).padStart(6, "0")}`;
const intToColorWithAlpha = (c, a) =>
  `#${c.toString(16).padStart(6, "0")}${Math.round(255 * a)
    .toString(16)
    .padStart(2, "0")}`;
To reverse the color string into integer we simply apply a math.round() function and use the resulting integer.

const rgbaToInt = (cr, cg, cb, ca, bgColor) => {
  const bb = bgColor & 255;
  const bg = (bgColor >> 8) & 255;
  const br = (bgColor >> 16) & 255;  const r = Math.round(cr * ca + br * (1 - ca));
  const g = Math.round(cg * ca + bg * (1 - ca));
  const b = Math.round(cb * ca + bb * (1 - ca));
  return (r << 16) + (g << 8) + b;
};
Lines below these are about uploading and printing images on the board using the weapon component and we won’t take care of them in depth: imgColorToInt and int2hsv transform numbers into two different kinds of color scales, then transparentColor is defined and a gamma for the image to be printed into with generateGamma. In decodeLine we transform the buffer in an array of pixels to be printed on the board using the above colors, iterating through them with for.

First React constructor
In the next lines of the app.js we define a constructor that will define the states we will use later into our UI to interact with the blockchain.

class App extends React.Component {
  constructor(props) {
    super(props);
Using constructor and super will keep us able to use this. in the constructor. The states defined here are the default selected color and color palette:













const colors = [
      "#000000",
      "#666666",
      "#aaaaaa",
      "#FFFFFF",
      "#F44E3B",
      "#D33115",
      "#9F0500",
      "#FE9200",
      "#E27300",
      "#C45100",
      "#FCDC00",
      "#FCC400",
      "#FB9E00",
      "#DBDF00",
      "#B0BC00",
      "#808900",
      "#A4DD00",
      "#68BC00",
      "#194D33",
      "#68CCCA",
      "#16A5A5",
      "#0C797D",
      "#73D8FF",
      "#009CE0",
      "#0062B1",
      "#AEA1FF",
      "#7B64FF",
      "#653294",
      "#FDA1FF",
      "#FA28FF",
      "#AB149E",
    ].map((c) => c.toLowerCase());
    // const currentColor = parseInt(colors[Math.floor(Math.random() * colors.length)].substring(1), 16);
    const currentColor = parseInt(colors[0].substring(1), 16);
    const defaultAlpha = 0.25;
And for the timer that refresh the board:

const timeMs = new Date().getTime();
    const freeDrawingStartMsEstimated =
      timeMs -
      ((timeMs - new Date("2021-05-09")) % (7 * OneDayMs)) +
      OneDayMs * 6;
Then the states of the user account in use are defined, most importantly whether the user has signed in, if there are any pending transactions (defined as pendingPixels) the boardLoaded state will load the canvas board for drawing the selectedCell alpha and pickerColor states define the states of the interactive components to add colors to the board, along with pickingColor for picking the color from the board and gammaColors is useful for image printing on the board along with the weaponsOn and weaponsCodePosition states.
These other states states are useful for the account to earn on he game, pixel based and DeFi based:

owners: [],
      accounts: {},
      highlightedAccountIndex: -1,
      selectedOwnerIndex: false,
      farmingBanana: false,
While the last three states setup the timer for later usage:

freeDrawingStart: new Date(freeDrawingStartMsEstimated),
      freeDrawingEnd: new Date(freeDrawingStartMsEstimated + OneDayMs),
      watchMode: false,
The following list (lines 203-215) defines objects and actions that will interact with the states, referencing a DOM element for the first time, the canvas board.

this._buttonDown = false;
    this._oldCounts = {};
    this._numFailedTxs = 0;
    this._balanceRefreshTimer = null;
    this.canvasRef = React.createRef();
    this._context = false;
    this._lines = false;
    this._queue = [];
    this._pendingPixels = [];
    this._refreshBoardTimer = null;
    this._sendQueueTimer = null;
    this._stopRefreshTime = new Date().getTime() + MaxWorkTime;
    this._accounts = {};
Lastly we define some of the states after the login is done:

this._initNear().then(() => {
      this.setState(
        {
          connected: true,
          signedIn: !!this._accountId,
          accountId: this._accountId,
          ircAccountId: this._accountId.replace(".", "_"),
          freeDrawingStart: this._freeDrawingStart,
          freeDrawingEnd: this._freeDrawingEnd,
        },
        () => {
          if (window.location.hash.indexOf("watch") >= 0) {
            setTimeout(() => this.enableWatchMode(), 500);
          }
        }
      );
    });
Basic interactions
Now we start describing interactions on the board/canvas connecting them to the previously defined states. For these interactions we use functions. The first one will use our previous reference to the canvas element to create it and instruct it with details about the kind of mouse movement we allow to our users. On the first click we enable watchmode for our timer to start:

const click = async () => {
      if (this.state.watchMode) {
        return;
      }
And image rendering mode if the user wants to print an image on the board:

if (this.state.rendering) {
        await this.drawImg(this.state.selectedCell);
      } else if (this.state.pickingColor) {
        this.pickColor(this.state.selectedCell);
      } else {
        this.saveColor();
        await this.drawPixel(this.state.selectedCell);
      }
The next is the important part, we define how the interface reads the mouse and touch movement over the board:

if ("touches" in e) {
        if (e.touches.length > 1) {
          return true;
        } else {
          const rect = e.target.getBoundingClientRect();
          x = e.targetTouches[0].clientX - rect.left;
          y = e.targetTouches[0].clientY - rect.top;
        }
      } else {
        x = e.offsetX;
        y = e.offsetY;
      }
The used code takes carefully into consideration the mobile users both, building an ad-hoc function to calculate the position and adding a listener to the canvas/board for touch events: canvas.addEventListener("touchmove", mouseMove); Then these interactions are used to set the selectedCell state and track both start and end of the mouse/touch action on the canvas along with its movement on each cell:

const mouseDown = async (e) => {
      this._buttonDown = true;
      if (this.state.selectedCell !== null) {
        await click();
      }
    };    canvas.addEventListener("mousedown", mouseDown);
    canvas.addEventListener("touchstart", mouseDown);    const unselectCell = () => {
      this.setState(
        {
          selectedCell: null,
        },
        () => this.renderCanvas()
      );
    };    const mouseUp = async (e) => {
      this._buttonDown = false;
      if ("touches" in e) {
        unselectCell();
      }
    };    canvas.addEventListener("mouseup", mouseUp);
    canvas.addEventListener("touchend", mouseUp);    canvas.addEventListener("mouseleave", unselectCell);    canvas.addEventListener("mouseenter", (e) => {
      if (this._buttonDown) {
        if (!("touches" in e) && !(e.buttons & 1)) {
          this._buttonDown = false;
        }
      }
    });
The interaction here work on the previously defined states, as for instance the color picker allows us to pick colors from the board and use then to draw. The key used by the color picker is the alt key and we can upload and print images on the board only if the color picker is disabled, because we will then trigger the generategamma function. In this way the pickcolor() function, referenced to the cell will be usable to set a single pixel or instead the whole board to render an image:

pickColor(cell) {
    if (!this.state.signedIn || !this._lines || !this._lines[cell.y]) {
      return;
    }
    const color = this._lines[cell.y][cell.x].color;    this.setState(
      {
        currentColor: color,
        alpha: 1,
        pickerColor: intToColorWithAlpha(color, 1),
        gammaColors: generateGamma(int2hsv(color)[0]),
        pickingColor: false,
      },
      () => {
        this.renderCanvas();
      }
    );
  }
Now guys we get to the core, so be ready to start diving on the Smart contract. We know how to draw the pixel in the interface, but we need to attach the transactions to them in order for our interface to be a real play to earn. So please pay careful attention to what I’m about to say, because even if your game looks completely different from this in terms of UI the earn mechanics may very well be suitable for any other kind of game and will be explained here in the simplest way that I can.








The Berryclub Smart Contract
Lines
We’ve met lines for the first time at the start of this article, while considering the states’ definitions of the UI. Lines are an important concept of the berryclub interface, they are the rows by which the board/canvas is subdivided and each pixel in them is a piece of metadata. They are a part of the UI that interacts with the smart contract and they’re the most reusable object of the game (for example to create levels in a more articulated game), so we’ll spend a little time in analysing how they are used to store data from teh board and evaluated while the users play the game.
First of all into the board.rs file we find a definition of PixelLine right after the definition of Pixel:

pub struct PixelLine(pub Vec<Pixel>);impl Default for PixelLine {
    fn default() -> Self {
        Self(vec![Pixel::default(); BOARD_WIDTH as usize])
    }
}
A Vector (array) of string data subdivided by the width of the board.
And then we define in the PixelBoard as a vector of the PixelLines this way:

pub struct PixelBoard {
    pub lines: Vector<PixelLine>,
    pub line_versions: Vec<u32>,
}
So each line is stored in the board as a single record with a metadata field called line_versions incrementing each time you modify a line. So each time our interface fetch the board you get 50 lines but also a metadata for every line that represents how many times the line was updated, and fetching this metadata the interface knows what's the number of times the line was changed, if the line has been changed from the previous fetch then you fetch the data for each pixel if not you just don't.

impl Place {
    pub fn get_lines(&self, lines: Vec<u32>) -> Vec<Base64VecU8> {
        lines
            .into_iter()
            .map(|i| {
                let line = self.board.get_line(i);
                line.try_to_vec().unwrap().into()
            })
            .collect()
    }    pub fn get_line_versions(&self) -> Vec<u32> {
        self.board.line_versions.clone()
    }
}
This is a smart way to store and fetch data from the interface that may be useful to use in your next play to earn near game.













Transactions
Let’s step back into our UI in app.js for a moment to be sure we understand how the transactions are managed from the frontend. First we need a function to check the account if anything goes wrong and this is it:

async refreshAllowance() {
    alert(
      "You're out of access key allowance. Need sign in again to refresh it"
    );
    await this.logOut();
    await this.requestSignIn();
  }
Then do you remember the _queue and _pendingPixels arrays we defined in our constructor? It’s definitely time to use them as the transactions are managed depending on what pixels you have drawn on the board:

async _sendQueue() {
    const pixels = this._queue.slice(0, BatchOfPixels);
    this._queue = this._queue.slice(BatchOfPixels);
    this._pendingPixels = pixels;    try {
      await this._contract.draw(
        {
          pixels,
        },
        new BN("75000000000000")
      );
      this._numFailedTxs = 0;
    } catch (error) {
      const msg = error.toString();
      if (msg.indexOf("does not have enough balance") !== -1) {
        await this.refreshAllowance();
        return;
 }
      console.log("Failed to send a transaction", error);
      this._numFailedTxs += 1;
      if (this._numFailedTxs < 3) {
        this._queue = this._queue.concat(this._pendingPixels);
        this._pendingPixels = [];
      } else {
        this._pendingPixels = [];
        this._queue = [];
      }
    }
    try {
      await Promise.all([this.refreshBoard(true), this.refreshAccountStats()]);
    } catch (e) {
      // ignore
    }
    this._pendingPixels.forEach((p) => {
      if (this._pending[p.y][p.x] === p.color) {
        this._pending[p.y][p.x] = -1;
      }
    });
    this._pendingPixels = [];
  }
Wait, I was not ready for this bunch of code… Yes you are! But let’s look at it carefully, we create a pixels object (vector), we modify our _queue object to fit pixels and we assign its value to the _pendingPixel object into an async function.
And then what? wWe just draw on a contract object which is called from the near sdk, and the action for draw (a part from the actions that we defined for the user) is defined in the lib.rs rust file.

pub fn draw(&mut self, pixels: Vec<SetPixelRequest>) {
        if pixels.is_empty() {
            return;
        }
        let mut account = self.get_mut_account(env::predecessor_account_id());
        let new_pixels = pixels.len() as u32;
        if ms_time() < self.get_free_drawing_timestamp() {
            let cost = account.charge(Berry::Avocado, new_pixels);
            self.burned_balances[Berry::Avocado as usize] += cost;
        }
    let mut old_owners = self.board.set_pixels(account.account_index, &pixels);
        let replaced_pixels = old_owners.remove(&account.account_index).unwrap_or(0);
        account.num_pixels += new_pixels - replaced_pixels;
        self.save_account(account);        for (account_index, num_pixels) in old_owners {
            let mut account = self.get_internal_account_by_index(account_index).unwrap();
            self.touch(&mut account);
            account.num_pixels -= num_pixels;
            self.save_account(account);
        }        self.maybe_send_reward();
    }
For the smart contract pixels are a colour and an account id (the mystical Owner), and it’s a real estate based game: so we have an old owner that drew the pixel before and a new owner that wants to draw it now. With the draw action we get the old_owner and replace it with the new owner account changing the colour value of all pixels inside the PixelRequest vector, then we send rewards to the old owner while charging the new one. Timestamps for rewards are reset and the count starts again from zero with one pixel less for the old owner and one more for the new one. The setPixelRequest action is defined in the board.rs file of our contract, but let's get back to our libs.rs.
What does the maybe_send_rewards() function look like? Here it is in all its glory:

impl Place {
    fn maybe_send_reward(&mut self) {
        let current_time = env::block_timestamp();
        let next_reward_timestamp: u64 = self.get_next_reward_timestamp().into();
        if next_reward_timestamp > current_time {
            return;
        }
        self.last_reward_timestamp = current_time;
        let reward: Balance = self.get_expected_reward().into();
        env::log(format!("Distributed reward of {}", reward).as_bytes());
        Promise::new(format!(
            "{}.{}",
            FARM_CONTRACT_ID_PREFIX,
            env::current_account_id()
        ))
        .function_call(
            b"take_my_near".to_vec(),
            b"{}".to_vec(),
            reward,
            GAS_BASE_COMPUTE,
        );
    }
}
Please don’t get lazy, if you can’t help yourself you can come to this later with this video by the author of the game. The explanations I’m gonna use are taken from that video too!
The function verifies the time on the blockchain (we’re not using the timer on the interface here, because we wanna be sure!) and uses the farming capabilities of the contract on a global timestamp with the function get_next_reward_timestamp() and last_reward_timestamp() then finally calls get_expected_reward() to calculate the rewards owed to the account.

pub fn get_expected_reward(&self) -> U128 {
        let account_balance = env::account_balance();
        let storage_usage = env::storage_usage();
        let locked_for_storage = Balance::from(storage_usage) * STORAGE_PRICE_PER_BYTE + SAFETY_BAR;
        if account_balance <= locked_for_storage {
            return 0.into();
        }
        let liquid_balance = account_balance - locked_for_storage;
        let reward = liquid_balance / PORTION_OF_REWARDS;
        reward.into()
    }
So we take the current balance from the berryclub account (remember we have a balance field on the account?), the current storage usage and costs and a safety threshold of 50 avocado. If balance is safe for usage outside storage cost we divide it in 24 (hours) * 60 (minutes) portion of reward, which means you basically get exactly the same balance that you have once if you call it every minute, you can find it defined at the start of the lib.rs file:

const PORTION_OF_REWARDS: Balance = 24 * 60;
const SAFETY_BAR: Balance = 50_000000_000000_000000_000000;
I bet you guys think the reward process it’s over. Wrong.
We actually need to step back into our maybe_send_reward() function to see that it calls the new berryclub farm contract to distribute the staking rewards, which are... cucumbers, the staking token on berryclub :)

const FARM_CONTRACT_ID_PREFIX: &str = "farm";
That’s actually not the only source of distribute earning with this function, it also levearages the gas costs paid by people to buy avocados and to swap bananas in order to reward the whole community!
How is this possible? First things first, the GAS_BASE_COMPUTE is defined in the token.rs file where the amount of gas for the smart contract is set. Yes you’re right! The gas price is low on near and it can be used to reward users that interact with your videogame!!!
To better understand how GAS fees work on Near please refer to this detailed documentation!
This tutorial is brought to you by jilt.near and her NFT Gaming project, support her buying NFTs!

### LearnNEAR.Club LNC Weekly Update - September 5, 2021

Brief Summary:

 	LNC NEAR Certified Developer L1 Chinese community Demo Day was Hu-u-u-u-u-ge!

Results:

 	August Demo Day  – 9 demo projects – check these 9 repositories at https://github.com/Learn-NEAR-Club
$NEAR600 were sent to demo projects developers
  


digital-war
bim.near, teiteii.near


rhythm4nft
hiphop200x.near, paulwu.near, abort.near


picture nft
hiphop200x.near


near_contract_rust-did
lk2684753.near zcsl_zoe.near


near-tree-hole
alansh.near


nft-market
jiahong.near, wisarmy.near, csp.near


Nep-141 payment
sharkme.near, bhc8521.near


vote-demo
brefchan.near


phone_book
jialeieos333.near chenbaler.near




 	Weekly LNC Beta Testing Results - 13 LNC Beta testers received 5$NEAR, that83.near got 10 $NEAR for the best feedback! Way to go!


 	You may try NEAR Messaging System - NMS - app (Alpha version) https://nms.kiemtienonline360.com/  works best with our Telegram bot https://t.me/LNC_testenet_watcher_bot
 	Check new Guide What You Can Do On The NEAR Protocol?


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC projects portfolio is coming!

### GIỚI THIỆU SƠ LƯỢC VỀ DEBIO NETWORK

Giải pháp y sinh phi tập trung trên Octopus Network
Hệ thống y sinh hiện tại đang có vấn đề. Nó hạn chế bệnh nhân xem xét tình trạng của họ một cách tự do, và các nhà cung cấp dịch vụ healthcare không thể đảm bảo sự bảo mật về dữ liệu của bệnh nhân. Debio Network được sinh ra với  mục tiêu thay đổi điều đó.
DeBio Network là gì?
DeBio Network là nền tảng ẩn danh phi tập trung dành cho y tế và bioinformatic đầu tiên chuyên về kiểm tra bộ gen. DeBio đặt mục tiêu cách mạng hóa ngành y sinh hiện tại với việc cung cấp cho bệnh nhân toàn quyền đối với dữ liệu của họ bằng cách sử dụng công nghệ blockchain tiên tiến nhất.

Sự ra đời của blockchain trong hệ sinh thái của công nghệ hiện tại đóng một vai trò lớn trong việc tạo ra một nền tài chính phi tập trung toàn cầu, nhưng blockchain không chỉ được áp dụng trong lĩnh vực tài chính. DeBio tin rằng tương lai của dữ liệu y tế dựa một phần vào việc sử dụng blockchain, đặc biệt trong việc chuyên môn hóa các trường hợp sử dụng cũng như khả năng tương tác với công nghệ này.
Kiểm tra di truyền tập trung là một rủi ro về quyền riêng tư
Trong vài năm trở lại đây, xét nghiệm di truyền đã trở nên phổ biến. Kết quả là, các nền tảng xét nghiệm di truyền trực tiếp với người dùng như 23andMe và AncestryDNA đã chứng kiến ​​sự gia tăng người tiêu dùng. Tuy nhiên nhiều người không nhận ra rủi ro về quyền riêng tư tiềm ẩn khi sử dụng các nền tảng này.

Các nền tảng xét nghiệm di truyền trực tiếp người dùng chủ yếu được tập trung hóa, khiến chúng trở thành mục tiêu dễ dàng cho các vụ vi phạm dữ liệu. Theo Govtech, Vào năm 2020, chỉ riêng tại Hoa Kỳ đã có 1001 vụ vi phạm dữ liệu.

Điều đáng quan ngại hơn nữa là dữ liệu di truyền không phải là duy nhất cho một cá nhân mà còn có liên quan tới cả họ hàng của người đó. Với việc sử dụng các hệ thống y sinh tập trung, bạn không chỉ gặp rủi ro về quyền riêng tư của mình mà còn cả sự riêng tư của những người thân của bạn.

Tác hại của điều này là có khả năng họ hàng xa của bạn, chẳng hạn, người anh họ thứ hai có thể bị ảnh hưởng bởi quyết định của bạn. Đáng lo ngại là suy nghĩ về một người họ hàng xa mà bạn thậm chí không biết đang tồn tại, thực hiện một bài kiểm tra di truyền và dữ liệu di truyền của họ khi được truy vết thì lại là bạn.

Trường hợp truy vết ngược này có thể xảy ra ngay cả với một lượng nhỏ thông tin nhân khẩu học, chẳng hạn như tuổi và trạng thái của họ. Loại thông tin này có thể được sử dụng để chống lại bạn bởi các công ty bảo hiểm.
Ý tưởng của DeBio Network
Ý tưởng chính đằng sau DeBio dựa trên quan điểm muốn tăng cường thử nghiệm y sinh và di truyền cho người dùng mà không làm mất quyền riêng tư của họ. Nhưng DeBio cũng muốn khuyến khích nghiên cứu di truyền học bằng cách đề nghị sự hợp tác tới các phòng thí nghiệm.
Cầu nối từ thực tế tới kỹ thuật số cho thử nghiệm ẩn danh
Người tiêu dùng có thể tùy chọn nhiều loại sản phẩm và các đề xuất từ các phòng nghiên cứu trong DeBio’s genetic testing marketplace. Sau khi người dùng quyết định chọn sản phẩm, họ sẽ chỉ cần lấy hai mẫu DNA thông qua phương pháp tăm bông hoặc lấy mẫu tế bào miệng bằng tăm bông.

Sau đó, người tiêu dùng gửi mẫu DNA đến phòng thí nghiệm trong một phong bì với thông tin nhận dạng duy nhất được ghi trên phong bì là ID theo dõi di truyền của mẫu. Các phòng thí nghiệm không thể xác định các mẫu mà không có ID theo dõi bởi vì, với mục đích ẩn danh, DeBio sẽ không thu thập thông tin nhận dạng cá nhân dưới bất kỳ hình thức nào, khiến cho người tiêu dùng không thể truy xuất mẫu DNA.

Các kết quả (ví dụ: thử nghiệm và bộ gen) sau đó được mã hóa bằng khóa công khai của người tiêu dùng được truy xuất từ ​​blockchain DeBio và được lưu trữ sau đó bằng việc tải lên trên bộ nhớ phi tập trung. Điều này cho phép người dùng luôn có toàn quyền đối với dữ liệu được mã hóa của họ - người dùng phải sở hữu khóa riêng của họ để giải mã kết quả.

DeBio Network team đang mở rộng khái niệm “cầu nối thực tế - kỹ thuật số” này để sử dụng trong các trường hợp bên ngoài marketplace xét nghiệm di truyền - có thể bao gồm xét nghiệm bệnh trong phòng thí nghiệm và dữ liệu hồ sơ y tế điện tử khác hoặc thông tin sức khỏe cá nhân.
Hợp tác với các phòng thí nghiệm để cung cấp các dịch vụ tích hợp sản phẩm
Sau khi người dùng gửi mẫu DNA đến phòng thí nghiệm, phòng thí nghiệm sẽ được thông báo. Khi mẫu đến, phòng thí nghiệm sẽ bắt đầu giải trình các mẫu vật lý hoặc sẽ bắt đầu bất kỳ xét nghiệm dấu ấn sinh học nào. Sau khi kết thúc các thử nghiệm tiếp theo, phòng thí nghiệm sau đó sẽ mã hóa kết quả bằng khóa công khai của người dùng và tải chúng lên bộ nhớ phi tập trung.

Không thể giải mã kết quả nếu không sử dụng khóa cá nhân của người dùng, do đó, quyền sở hữu của người tiêu dùng đối với kết quả xét nghiệm y sinh của họ được bảo mật. Tuy nhiên, để khuyến khích hơn nữa việc kiểm tra di truyền, người tiêu dùng được lựa chọn đặt cược dữ liệu xét nghiệm di truyền của họ sẽ được sử dụng bởi các phòng thí nghiệm khác.

Mục tiêu của việc có các phòng thí nghiệm là để tăng tính khả dụng của các sản phẩm và tạo ra các sản phẩm chung bằng cách tích hợp các dịch vụ từ một số phòng thí nghiệm. Điều này cũng cho phép DeBio mở rộng quy mô vì các phòng thí nghiệm không cần phải tập trung cho phép nhiều cơ sở di truyền độc lập tham gia.




	

	
	
		
			
				Quiz: What problem does the DeBio Network intend to solve?
			
		

		
					

		
			
			
			
			Privacy concerns among online genetic testing platforms
		
			
			Obstacles in sovereign labs to do their work
		
			
			The lack of research in genomics
		
			
			Expensive healthcare
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The DeBio Network Techstack
Tin sinh học và hệ sinh thái y tế đều có những yêu cầu riêng về cách thức để các chuyên gia tiến hành nghiên cứu tiếp cận được với nhau nhưng cũng phải đủ an toàn để bảo vệ quyền riêng tư của bệnh nhân. Do đó, để đảm bảo quyền sở hữu của bệnh nhân đối với dữ liệu của họ, toàn bộ công nghệ bao gồm các giải pháp phi tập trung, từ xác thực phi tập trung đến lưu trữ tệp phi tập trung.



Ảnh từ DeBio Deck

DeBio đã kết hợp một loạt các giải pháp công nghệ tiên tiến, trong đó có:

 	

 	Substrate
 	KILT Protocol
 	The Octopus Network
 	The InterPlanetary File System (IPFS)
 	Ocean Protocol



Substrate
Công nghệ đáng chú ý đầu tiên được sử dụng là Substrate. Substrate là framework đằng sau Polkadot token, cho phép các nhà phát triển xây dựng các blockchain với mục đích khác nhau. Các dịch vụ cốt lõi sẽ được xây dựng bằng cách sử dụng Substrate. DeBio chọn Substrate vì hai lý do sau:

 	Blockchain interoperability (giao tiếp giữa các chuỗi khối khác nhau).
 	Relay chain security (áp dụng các tiêu chuẩn bảo mật nghiêm ngặt hơn của host relay chain).

Ngoài việc cho phép các blockchains giao tiếp với nhau, tính năng tương tác cũng thực thi một tiêu chuẩn bảo mật sẽ được kế thừa bởi mỗi parachain được kết nối với relay chain chính. Do đó, tính bảo mật của chuỗi khối DeBio được cải thiện bằng cách tuân theo các tiêu chuẩn của relay chain tương ứng.
KILT Protocol
Công nghệ đáng chú ý tiếp theo là KILT Protocol. KILT là một Protocol để sáng tạo, chứng thực và xác minh danh tính một cách ẩn danh trên Web3. Để tự xác thực, mỗi người dùng cần tạo một xác nhận quyền sở hữu, sau đó sẽ được gửi đến một người chứng thực đáng tin cậy.

Người chứng thực có trách nhiệm xác nhận yêu cầu của người dùng, sau đó sẽ chuyển đổi thành hàm băm để được lưu trên KILT Blockchain. Xác nhận quyền sở hữu của người dùng đôi khi chứa dữ liệu nhạy cảm liên quan đến người dùng, nhưng vì hàm băm có tính một chiều, nên quyền riêng tư của người dùng được đảm bảo.

Sau khi nhận được chứng chỉ từ người chứng thực đáng tin cậy, người dùng có thể sử dụng các yêu cầu của mình trên các ứng dụng sử dụng KILT và tin tưởng vào người chứng thực đã nói ở trên. Các ứng dụng sẽ xác minh xác nhận quyền sở hữu không cần phải thông qua người chứng thực và sẽ trực tiếp so sánh xác nhận quyền sở hữu với ứng dụng được lưu trữ trong chuỗi khối KILT, loại bỏ người chứng thực khỏi quy trình xác minh và làm cho nó hoàn toàn phi tập trung.

KILT Protocol cung cấp giải pháp ngăn không cho dữ liệu tập trung vào một thực thể. Nó cho phép chủ quyền dữ liệu cho những người có ý thức về quyền riêng tư. DeBio đã hợp tác với KILT để triển khai hệ thống xác thực phi tập trung vì nó hoàn toàn phù hợp với trường hợp sử dụng cho vấn đề ẩn danh của DeBio.
The Octopus Network
Octopus là crypto network để launch và run các blockchains dành riêng cho ứng dụng Web3 với chi phí thấp. Một trong những cân nhắc khi sử dụng Octopus, so sánh với Polkadot, họ cung cấp dịch vụ cho thuê bảo mật rẻ hơn đáng kể so với cross-chain capabilities. Octopus được hỗ trợ bởi NEAR Protocol, NEAR là một blockchain hiệu suất cao nhằm giải quyết vấn đề về khả năng mở rộng và tăng năng suất của nhà phát triển bằng cách đơn giản hóa quy trình phát triển và tạo ra một môi trường thân thiện với nhà phát triển.

DeBio đã hợp tác với Octopus và sẽ là một trong năm application-specific blockchains (app chains) đầu tiên được ra mắt trên Octopus Network. DeBio cũng đã là một phần của Octopus Guild, một cộng đồng các nhà phát triển và chuỗi ứng dụng trên Octopus Network.
The InterPlanetary File System (IPFS)
The InterPlanetary File System (IPFS) is a protocol made for fully decentralized, peer-to-peer data sharing and storage. IPFS was created as a solution for decentralized projects that want to store an amount of data that is too large to be stored in the blockchain itself. IPFS creates unique content addresses by hashing the content itself. Each unique content will have a different address pointing to its location. DeBio adds IPFS to store biomedical data such as encrypted human genomes and encrypted electronic medical records.
Ocean Protocol
The Ocean Protocol is built for the consumption of data assets in a secure, privacy-preserving fashion. It does this with the compute-to-data feature and enables the monetization of data without ever having to leave the owner’s premises. The Ocean Protocol’s open-source data marketplace called the Ocean Market is forkable; the DeBio Network team will use Ocean for biomedical data staking.
Privacy Computing
Để stake biomedical date, DeBio sẽ lưu trữ anonymous biomedical data trong kho dữ liệu riêng tư của họ. Quá trình này không liên quan đến IPFS đã nói ở trên vì kho lưu trữ dữ liệu sẽ hoàn toàn tách biệt với IPFS. Người dùng muốn stake dữ liệu của họ sẽ cần phải decrypt and upload their biomedical data của họ lên kho dữ liệu tư nhân của họ. Trong khi chuyển decrypted biomedical data sang một kho dữ liệu do tư nhân tổ chức nghe có vẻ kỳ lạ, DeBio sẽ triển khai các  privacy computing concepts về quyền riêng tư trong kho dữ liệu để bảo vệ quyền riêng tư của bạn.



Hình từ DeBio Whitepaper

Chỉ sau khi có sự đồng ý của người dùng, các tập data mới được tổng hợp thông qua  Ocean’s compute-to-data proxy và bên thứ 3 sẽ có thể tạo, phân tích và xử lý dữ liệu trong khi dữ liệu vẫn còn tại chỗ.

Bằng cách khuyến khích người dùng stake  genomic/biomedical data của họ và hy vọng rằng nó sẽ khuyến khích hơn nữa nghiên cứu trong lĩnh vực này. Hơn nữa,  the privately-held data store sẽ không thu thập thông tin cá nhân do đó không cần phải lo lắng về việc các mẫu vật của bạn bị truy ngược lại cho bạn.

Pandu Sastrowardoyo, Giám đốc điều hành của DeBio, nói rằng một trong những lý do cô tạo ra DeBio là để giúp nghiên cứu di truyền phát triển bằng cách tạo ra một marketplace dữ liệu di truyền hoàn toàn ẩn danh. “DeBio là một hệ thống kinh tế hoàn toàn mới về gen - cho phép chủ quyền di truyền, đảm bảo sự tham gia của các phòng thí nghiệm nhỏ hơn trong khi tăng cường nghiên cứu gen. Tất cả được thực hiện trên một mô hình giống DeFi được phân cấp hoàn toàn, ”Pandu nói.




	

	
	
		
			
				Quiz: Where does DeBio store the staked data?
			
		

		
					

		
			
			
			
			Inside the DeBio blockchain
		
			
			Inside the data tokens
		
			
			On a private-held data store
		
			
			On IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Technical Architecture Layers - lớp kiến trúc kỹ thuật
Kiến trúc kỹ thuật của chúng tôi bao gồm bốn lớp: cơ sở hạ tầng chính cho blockchain, tầng transport và logic business, và cuối cùng là tầng top-level business.



Mô hình cho Technical Architecture của DeBio, Hình ảnh từ Whitepaper của Debio
Layer 1: Cơ sở hạ tầng của Blockchain
Layer đầu tiên sẽ chứa các dịch vụ cốt lõi. Các dịch vụ cốt lõi được xây dựng dựa trên Substrate, Octopus và IPFS. Substrate là công nghệ xây dựng cốt lõi cho dịch vụ blockchain. Để lưu các tệp lớn, DeBio sẽ sử dụng IPFS và lưu địa chỉ nội dung bên trong Substrate. Cuối cùng, toàn bộ chuỗi ứng dụng sẽ được kết nối với Octopus relay chain.
Layer 2&3: The Transport and Generic Business Logic Layer - Lớp Logic Kinh doanh Chung và Vận chuyển
Layer thứ hai và thứ ba chứa logic nghiệp vụ vận tải và chung. Các layer này chịu trách nhiệm cung cấp dữ liệu trực tiếp cho người dùng. Mỗi pallet chứa logic nghiệp vụ cơ bản cho các tương tác với blockchain và sẽ đóng vai trò như một lớp trừu tượng từ layer thứ tư để giao tiếp với các dịch vụ của Substrate trên layer đầu tiên.
Layer 4: The Top-Level Business Logic Layer - Lớp logic kinh doanh cấp cao nhất
Layer thứ tư sẽ bao gồm DeBio UI và Metamask. Tất cả tương tác giữa người dùng và blockchain sẽ được thực hiện trên layer thứ tư. Tất cả các truy vấn cũng sẽ được xác định từ cấp cao nhất, và sau đó sẽ được xử lý trên tất cả các layer đã đề cập trước đó. Để nạp tiền cho mỗi giao dịch, người dùng có thể sử dụng Metamask để thanh toán bằng đồng tiền ổn định ERC20. Trong trường hợp này, DeBio sẽ sử dụng DAI làm stablecoin.
The Token Model - Mô hình Token


Hình ảnh lấy từ DeBio Whitepaper

Nhóm DeBio Network dự định phát hành sáu mã token:

 	Phần thưởng giao dịch trên Mainnet & token xác thực ($DBIO)
 	Token quản trị ($GBIO)
 	Token dữ liệu Genomics ($GENE, thông qua Ocean Protocol)
 	Token dữ liệu sinh học ($MED, thông qua Ocean Protocol)
 	Token dữ liệu hồ sơ y tế điện tử ($EMR, thông qua Ocean Protocol)

Mainnet Coin (stablecoin, v.v.)
Đồng tiền mainnet sẽ được hỗ trợ bởi một stablecoin. DeBio quyết định sử dụng đồng tiền ổn định vì nó cần được sử dụng như một sàn giao dịch ổn định cho các giao dịch và các khoản phí liên quan đến công việc đang được thực hiện bởi các phòng thí nghiệm tương ứng. DeBio sẽ sử dụng $DAI làm stablecoin.
Token quản trị ($GBIO)
Các Token quản trị sẽ được sử dụng chủ yếu để bỏ phiếu bởi các phòng thí nghiệm đã đăng ký. DeBio Network là một tổ chức phi tập trung, vì vậy cần phải có một kế hoạch quản trị để bỏ phiếu trong marketplace DAOGenics. Ngoài ra, Token quản trị cũng có thể dùng như một phương pháp để giới thiệu phòng thí nghiệm.
Token dữ liệu ($GENE, $MED và $EMR) - data token
Những Token này được sử dụng như một phương thức giao dịch trên marketplace dữ liệu. Khi lưu trữ dữ liệu y sinh trên marketplace Ocean, người dùng sẽ được thưởng bằng Token dữ liệu có thể chuyển đổi thành $OCEAN.
Validator & Phần thưởng giao dịch ($DBIO)
Token xác thực được sử dụng để khuyến khích chủ sở hữu nút xác thực giao dịch và bảo mật dApp khỏi người dùng trái phép. Các khuyến khích dự kiến ​​được cung cấp cho trình xác thực là phần thưởng LP và Token quản trị.
Giao dịch của người tiêu dùng trong Debio Network
$DAI là stablecoin của mainnet được sử dụng cho các giao dịch trên nền tảng DeBio. Người dùng có thể sử dụng đồng tiền mainnet để thanh toán các sản phẩm và phí dịch vụ. Các sản phẩm sẽ có mặt trên marketplace bao gồm sản phẩm thử nghiệm bộ gen, sản phẩm thử nghiệm y sinh và dịch vụ lưu trữ hồ sơ y tế điện tử có chủ quyền (EMR).



Image retrieved from DeBio Whitepaper
Phần thưởng giao dịch - transaction reward
Mỗi giao dịch do người dùng cam kết sẽ được thưởng bằng Token xác thực, cụ thể hơn là Token $DBIO. Giá của một Token $DBIO duy nhất được xác định bởi marketplace dữ liệu DeBio Network, nơi chứa dữ liệu bộ gen của người tiêu dùng có sẵn để đặt cược.
Staking dữ liệu trong Debio Network - data staking in DeBio Network
Sau khi mua một sản phẩm trên marketplace, người tiêu dùng có thể chọn stake kết quả của họ trên Ocean marketplace. Dữ liệu do người tiêu dùng đặt sẽ được phân loại thành Token dữ liệu, được gọi là $GENE, $MED và $EMR cho genomic data, biomedical data, và electronic medical records (EMR) tương ứng. Token dữ liệu sẽ được lưu giữ trong Mạng DeBio và được tổng hợp vào data marketplace thông qua Ocean Protocol dưới dạng ERC20 token. Vì genomic data, biomedical data, hoặc bản thân EMR quá lớn để được lưu bên trong dữ liệu ERC20 token, Token dữ liệu chủ yếu sẽ đóng vai trò như một con trỏ / liên kết đến dữ liệu tương ứng.

Người tiêu dùng đặt Token dữ liệu của họ sẽ có vai trò "Data Provider" trên marketplace dữ liệu. Tất cả các giao dịch trên marketplace dữ liệu Ocean sẽ sử dụng Token $OCEAN. Do đó, nếu giao dịch thành công, người mua sẽ đổi $OCEAN Token lấy Token dữ liệu ($GENE hoặc $EMR hoặc $MED). Trong khi “Data Provider” sẽ nhận được các $OCEAN Token tiếp theo.



Hình ảnh lấy từ DeBio Whitepaper

Nếu người mua dữ liệu muốn truy cập vào dữ liệu được liên kết trong data token, họ cần gửi trước data token cho Data Provider. Do đó, Data Provider sẽ có cả $OCEAN token và data token trong khi người mua dữ liệu sẽ được gửi dữ liệu được liên kết bởi data token.



Hình ảnh lấy từ DeBio Whitepaper

Ngược lại, data tokens ($GENE hoặc $MED hoặc $EMR) mà Quỹ DAOGenics nhận được sẽ được chuyển đổi thành $OCEAN token. Sau một khoảng thời gian nhất định, $OCEAN token mà Quỹ DAOGenics nhận được sẽ được chuyển đổi thành $DBIO token thông qua non-permission smart contract (hợp đồng thông minh không được cấp phép).

Do đó, Quỹ DAOGenics sẽ luôn mua lại mã thông báo $DBIO thông qua non-permission smart contract dựa trên khối lượng giao dịch được thực hiện trên data marketplace. Nhiều giao dịch hơn trên data marketplace sẽ làm tăng nhu cầu đối với $DBIO token.




	

	
	
		
			
				Quiz: When you stake data on the DeBio Network data marketplace, what do you earn?
			
		

		
					

		
			
			
			
			The mainnet coin ($DAI)
		
			
			Governance tokens ($GBIO)
		
			
			Transaction reward token ($DBIO)
		
			
			Ocean token ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Kết luận
Có rất nhiều lợi ích khi làm xét nghiệm di truyền. Lần đầu tiên trong lịch sử nhân loại, con người có thể xác định được lối sống của mình để theo đuổi tuổi thọ; lợi ích của việc xét nghiệm gen này thực sự đáng kinh ngạc. Tuy nhiên, bên cạnh những lợi ích tuyệt vời, nếu như không có các quy định và tiêu chuẩn thích hợp thì nó cũng có những thiếu sót. Nếu không có sự đảm bảo về việc dữ liệu di truyền của bạn được bảo mật và riêng tư, nó có thể gây ra các vấn đề trong tương lai.

DeBio đặt mục tiêu giải quyết vấn đề trước khi quá muộn. DeBio đang xây dựng một nền tảng phi tập trung cho nhu cầu y tế cá nhân của bạn, bắt đầu từ di truyền học. Ý tưởng của chúng tôi cho phép huy động sức mạnh tổng hợp của các phòng thí nghiệm ở mọi quy mô đồng thời đảm bảo sự ẩn danh và quyền sở hữu của người dùng ở mọi bước của quy trình khoa học dữ liệu bộ gen - từ thu thập mẫu, lưu trữ dữ liệu đến tạo báo cáo.

Một số người nói rằng DNA của chúng ta là thứ riêng tư nhất mà chúng ta có, và chúng tôi rất coi trọng điều đó. Thử nghiệm di truyền ưu tiên ẩn danh nên là trọng tâm số một đối với tất cả các công ty.

Tương lai là đây, DeBio đang tạo ra các giải pháp để cách mạng hóa ngành chăm sóc sức khỏe và xét nghiệm di truyền. Bạn đã sẵn sàng để thay đổi thế giới với chúng tôi?

 

### DAOs là gì? Cùng tìm hiểu về Sputnik DAO

Một trong những điều thú vị và thu hút nhiều sự chú ý gần đây là khái niệm DAO (Decentralized Autonomous Organization) hay “Tổ chức tự trị phi tập trung”. Ý tưởng ở đây là tạo ra một tổ chức trên internet mà các thành viên cùng sở hữu và quản lý.Không có bất kỳ cá nhân nào kiểm soát hoạt động của doanh nghiệp (CEO, CMO, CFO), cũng như không có hội động quản trị tập trung. Thay vào đó, logic nghiệp vụ và quá trình thực thi được đưa vào các hợp đồng thông minh để đảm bảo việc triển khai được sắp xếp một cách hợp lý.

Các ví dụ về DAO:

 	Từ thiện: Ai cũng có thể trở thành thành viên và ai cũng có thể quyên góp vào nhóm. Nhóm quyết định cách chi tiêu các khoản đóng góp.
 	Mạng lưới freelancer: Mạng lưới các nhà thầu tập hợp quỹ của họ lại cho các công cụ liên quan đến freelance.
 	Liên doanh và tài trợ: Một quỹ đầu cơ phi tập trung, nơi các thành viên có thể gộp quỹ của họ và bỏ phiếu cho các đề xuất khác nhau.

Điều gì khiến DAO trở nên khác biệt?
Các DAO thực thi những quy tắc nhất định được ghi lại trên hợp đồng thông minh và được lưu giữ trên blockchain. Hợp đồng thông minh có thể được coi là một thỏa thuận tự động giữa hai hoặc nhiều bên. Do tính chất minh bạch của blockchain, không thể thay đổi mã nguồn của hợp đồng thông minh mà toàn bộ mạng lưới không thể biết được. Đây là điều làm cho DAO linh hoạt và mạnh mẽ hơn các tổ chức điển hình.

 	DAO là một tổ chức dân chủ hóa, trong đó mỗi thành viên cần bỏ phiếu cho bất kỳ thay đổi nào cần được thực hiện. DAO sử dụng nguyên tắc quản trị dựa trên cộng đồng thay vì quản trị dựa trên sự điều hành.
 	DAO có tính toàn cầu và hoàn toàn minh bạch.

Tại sao các tổ chức dạng phân cấp không đủ tốt?
Cơ cấu tổ chức theo thứ bậc và theo chiều dọc là cách thức phổ biến để tổ chức một doanh nghiệp. Ý tưởng rất đơn giản, mọi người trong tổ chức (ngoại trừ người đứng đầu) đều là cấp dưới của một cá nhân hoặc tổ chức nào đó. Vì vậy, những người có nhiều quyền lực nhất đang đứng đầu bảng xếp hạng. Đồng thời, những người có ít sức mạnh nhất sẽ xuất hiện ở phía dưới. Tuy nhiên, do cấu trúc của nó, tổ chức dạng phân cấp có một số nhược điểm khi so sánh với DAO.




DAOs
Tổ chức dạng phân cấp


Cấu trúc
Ngang hàng và dân chủ
Phân cấp


Biểu quyết
Mọi thay đổi trong hệ thống đều cần có sự biểu quyết từ các thành viên
Hệ thống có yêu cầu biểu quyết hay không phụ thuộc vào cấu trúc và các quy tắc do hệ thống quy định


Trung gian
Phiếu bầu được kiểm tra và kết quả được thực hiện mà không cần một trung gian đáng tin cậy
Nếu việc bỏ phiếu được cho phép, chúng cần được kiểm tra bởi một bên trung gian


Tự động hóa
Các vấn đề liên quan đến quản trị được xử lý tự động và phi tập trung
Yêu cầu con người và xử lý tập trung. Do đó dễ bị thao túng.


Mức độ tiếp cận với mọi người
Hoàn toàn công khai và minh bạch
Riêng tư và hầu như là không minh bạch



Mô hình thành viên trong DAOs
Vậy, chính xác thì mô hình thành viên của DAO hoạt động như thế nào? Điều này khá quan trọng vì trở thành thành viên là chìa khóa cho mô hình hoạt động của DAO.

Có 2 mô hình thành viên:

 	Mô hình dựa trên Token (Token-based)
 	Mô hình dựa trên sự chia sẻ (Share-based)

Mô hình Token-based
Hầu hết các giao thức đều có token quản trị có thể được giao dịch trên các sàn giao dịch tập trung và phi tập trung khác nhau. Người ta có thể kiếm được những token này thông qua việc tham gia vào thuật toán đồng thuận hoặc cung cấp tính thanh khoản. Như cái tên của mô hình, sở hữu những token này cho phép bạn truy cập vào quyền biểu quyết trong giao thức. Bạn càng nắm giữ nhiều token, thì quyền biểu quyết của bạn càng lớn. Một ví dụ cho mô hình này là MakerDAO và token quản trị của nó - MKR. Bất kỳ ai cũng có thể tham gia quản trị MakerDAO bằng cách mua token MKR.
Mô hình Share-based
So với mô hình Token-based, mô hình Share-based được cấp phép nhiều hơn. Các thành viên tiềm năng phải gửi đề xuất tham gia DAO. Đề xuất đi kèm với một “cống phẩm” dưới dạng token hoặc một số công việc nào đó. Chia sẻ của người tham gia thể hiện quyền biểu quyết trực tiếp của họ. Họ có thể thoát ra bất kỳ lúc nào với một tỷ lệ tương xứng trong quỹ. MolochDAO - một giao thức chịu trách nhiệm cấp vốn cho các dự án dựa trên Ethereum - là một ví dụ về Share-based DAO. Bạn không thể mua token quản trị trên thị trường mở để có quyền truy cập vào DAO. Để tham gia, bạn cần có chuyên môn và vốn cần thiết để giúp hỗ trợ các dự án tiềm năng.
Học từ những sai lầm - DAO bị hack
Tất nhiên, điều quan trọng là phải tìm hiểu về vụ hack DAO đã chia Ethereum thành Ethereum và Ethereum Classic. Trở lại năm 2016, Ethereum DAO được tạo ra để trở thành một đột phá mới và khiến chúng ta phải suy nghĩ lại về cách thức hoạt động của các quỹ mạo hiểm. Ý tưởng là để những người nắm giữ token của DAO bỏ phiếu về các đề xuất dự án khác nhau. Nếu một đề xuất nhận được 20% phiếu bầu từ cộng đồng, họ sẽ nhận được số tiền cần thiết để bắt đầu.

DAO cũng có một “cơ chế phân chia”. Về cơ bản, nếu các thành viên không hài lòng với các dự án được đưa vào whitelist, họ có thể rời khỏi DAO để tạo “DAO con” của riêng mình. Dù sao, DAO đã là một thành công lớn và tích lũy được hơn 150 triệu đô la ether trong một đợt bán lẻ. Đây cũng là 14% của tất cả token ether được phát hành cho đến thời điểm tạo ra DAO đó.

Tuy nhiên, DAO có một lỗ hổng khá nguy hiểm. Vào ngày 17 tháng 6 năm 2016, một kẻ tấn công đã khai thác lỗ hổng này để liên tục vào lại hệ thống và lấy đi số ETH trị giá 50 triệu đô la. Hầu hết cộng đồng đã quyết định quay lại sự cố này thông qua một hard fork. Tuy nhiên, một số khác đã phản đối động thái này. Điều này cuối cùng đã dẫn đến một đợt hard fork chia tách giao thức Ethereum thành Ethereum và Ethereum Classic.
Giao thức NEAR và Sputnik DAO
Người đồng sáng lập Near Protocol, Illia Polosukhin đã công bố Sputnik DAO trong bài viết này. Ông giải thích DAO là “một cách để các cộng đồng và tổ chức mới và hiện tại trên toàn thế giới có đại diện trực tuyến cho nhóm của họ, quản lý hoạt động trên chuỗi của họ, điều chỉnh việc ra quyết định của họ và quan trọng là tương tác với các DAO khác.”

Sputnik đã lấy những nguồn cảm hứng sau đây để tạo thành "làn sóng đầu tiên" của thử nghiệm DAO:

 	Cách cộng đồng kiểm soát việc quản trị không mở rộng theo số lượng người tham gia. Nhiều DAO đã thất bại vì nhiều lý do khác nhau, từ các vấn đề kỹ thuật đến sự thiếu quan tâm đến việc bỏ phiếu từ các thành viên hoặc thiếu yếu tố thúc đẩy thống nhất.
 	Không thể có một hệ thống DAO hoàn toàn hạnh phúc, ý kiến của mọi người về một đề xuất có thể thay đổi. Phần thiểu số trong nhóm có khả năng tách khỏi nhóm để theo một hệ thống DAO mới.
 	Một cộng đồng hoặc tổ chức cần có sự lãnh đạo. Một cộng đồng lý tưởng phải có những thành viên tận tâm, có trách nhiệm điều phối, có khả năng điều tiết.
 	Ngay cả khi cộng đồng là phi tập trung, vẫn cần phải có một số thành viên được mọi người biết đến và tin tưởng như là cốt lõi của cộng đồng.
 	Một cộng đồng phi tập trung càng tập trung vào hiệu suất thì người lãnh đạo càng phải tập trung hơn.
 	Đánh giá dựa trên staking luôn không thành công vì hầu hết các bên liên quan không thể hoặc không muốn trở thành những người tham gia tích cực.

Giao diện của Sputnik
Hiện tại, khi bạn truy cập vào trang chủ của Sputnik, bạn sẽ thấy màn hình sau:



Khi bạn nhấp vào “NEAR Forum”, bạn sẽ thấy các chủ đề hội thoại khác nhau được phân loại gọn gàng và phù hợp.



Tại trang chủ, nếu bạn nhấp vào “Launch App”, bạn sẽ có quyền truy cập vào các DAO khác nhau được liệt kê trên Sputnik. 



Lấy một ví dụ nữa để giúp bạn dễ hiểu hơn, hãy cùng kiểm tra tất cả các đề xuất ở trong Learn NEAR DAO:



Có thể thấy có nhiều đề xuất khác nhau ở đây, cùng với các khoản thanh toán (Payout) khác nhau của từng đề xuất (đơn vị là NEAR). Nếu một đề xuất được chấp thuận hoặc bị từ chối, nó sẽ được đánh dấu tương ứng. Ví dụ với đề xuất có ID là 22, ai đó đã dịch thành công trang chủ và phần footer sang tiếng Việt, đó là lý do bạn thấy có số “1” ở bên cạnh chữ “Approve” và huy hiệu “Success” màu xanh lá cây.


Cách LearnNEAR.club sử dụng Sputnik DAO
Có hai cấp độ của một DAO đang được chúng tôi sử dụng:

Mother DAO và những subDAOs tương ứng:

 	https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near

Có thể coi MotherDAO với tư cách là khách hàng hoặc nhà tài trợ, còn subDAOs với tư cách là nhà thầu cùng với các thành viên của subDAOs với tư cách là những nhà thầu phụ.Hãy cùng xem cách hoạt động của hai loại DAO này trong việc dịch thuật từ cộng đồng. Ví dụ bài hướng dẫn “Top 3 NFT Projects On The NEAR Protocol” cần được dịch sang tiếng Việt. Các thành viên của subDAOs sẽ dịch và review lại bản dịch.



Sau đó, một trong số họ sẽ gửi một đề xuất hợp nhất lên MotherDAO với subDAO là người nhận tiền. 



Sau khi đề xuất được chấp nhận và bài hướng dẫn sau khi dịch được xuất bản, các thành viên subDAO sẽ chia số tiền nhận được theo các đề xuất được gửi trước đó.

Với những tình huống xảy ra xung đột, thành viên của MotherDAO cũng đóng vai trò là thành viên biểu quyết tại TẤT CẢ các subDAOs.
Kết luận
Như vậy là bạn đã nắm được cơ bản về DAO và Sputnik DAO. Cần phải sử dụng đúng cách thì DAO mới phát huy được những ưu điểm của mình. Và có vẻ như NEAR protocol đã giúp chúng ta tận dụng được sức mạnh của DAO.

### LearnNEAR.Club LNC Weekly Update - August 29, 2021

Brief Summary:

 	LNC NEAR Certified Developer L1 August Demo day was a success

Results:

 	August Demo Day  – 3 demo projects – check these 3 repositories at https://github.com/Learn-NEAR-Club
$NEAR300 were sent to demo projects developers - check the Demo Session recording



 	Some users were experiencing issues with Login with NEAR at http://learnnear.club, fixed
 	NEAR MetaBUIDL Hackathon is LIVE!
 	For seamless NEAR testnet account notification you can use LNC Telegram bot: https://t.me/LNC_testenet_watcher_bot


Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	LNC projects portfolio is coming!

### What You Can Do On NEAR Protocol

In the crypto space, Ethereum dominates as the go-to platform when it comes to smart contracts, decentralized applications, and Decentralized Finance. However, Ethereum isn’t the only protocol in the smart contract and decentralized applications space, with several other protocols in the picture. Even though Ethereum is the number one platform in the space, it has quite a few shortcomings, such as extremely high gas fees and significant scalability issues.

NEAR Protocol is one of the blockchains that can rival Ethereum by going straight for the protocol’s most glaring shortcoming, its lack of scalability, by using something known as sharding. This allows NEAR to scale up its scalability exponentially. The protocol has also raised significant funding and counts Andreessen Horowitz’s a16z fund as one of its backers.
A Closer Look At The NEAR Protocol 
The NEAR protocol is a decentralized development platform that was founded in 2018. NEAR creates the perfect environment for decentralized applications and smart contracts by focusing on the shortcomings of other protocols in the same space. We have already mentioned the shortcomings previously. NEAR utilizes the NEAR protocol, a Proof-of-Stake blockchain that is known for being public, developer-friendly, and sharded. The protocol is a low-cost and highly scalable platform that developers can utilize to create decentralized applications (dApps). Other features that developers can use include wallet applications and interoperability components that allow developers to easily utilize the NEAR ecosystem and build applications. 

NEAR introduces Doomslug, a block generation mechanism that was proposed in 2019. It allows practical finality; meaning blocks can achieve finality in seconds. NEAR functions on the same technology powering technologies like Bitcoin and combines it with features such as database sharding. Other blockchains centralize processing which means that it is limited to very high-end hardware. This approach only provides a temporary boost to throughput. On the other hand, NEAR scales linearly and can support even billions of transactions in a completely decentralized manner.
Important Features Of NEAR 
The NEAR protocol is developed by the NEAR Collective. Some of the protocol’s features are the following.               

 	NEAR as a protocol is simple to use, and developers can easily and quickly build apps on it


 	NEAR allows for almost infinite scalability thanks to the use of sharding


 	Near is a Layer-1 protocol. 

Understanding The NEAR Collective 
The NEAR Collective, a community of researchers and developers, is behind the development of the NEAR protocol. The collective is continuously working to develop and improve the NEAR protocol and has also worked on projects such as writing the initial code of the protocol and the implementation of the NEAR Network. The NEAR Protocol operates completely independently and decentralized, and even the developers and researchers who built it cannot shut it down.                                                

The NEAR Collective consists of the NEAR Foundation, which is a non-profit organization creating an ecosystem around the NEAR protocol. The NEAR Collective helps in the development and governance activities on the protocol. The NEAR Protocol is just one of the several projects under the collective.
What Can You Do On The NEAR Protocol 
The Near Protocol allows users to access several projects and protocols ranging from NFTs to DAOs and DeFi. NEAR has developed a vibrant native ecosystem has several projects that are already up and running on the protocol, while more projects are in the pipeline.
Getting Started With NEAR 
To get started with NEAR, the first thing that you need is a NEAR account. You can learn how to set up a NEAR account here. Once you have created your NEAR account, you can connect it to your NEAR wallet, which allows you to make contract calls to the blockchain, send or receive funds and set up the local nodes. To create a NEAR account, you need to have at least 0.2 NEAR or 0.62 USD so that you can hold your place on the NEAR network.
The NEAR Token 
There are two ways in which you can get NEAR tokens; you can either earn them or directly buy them. NEAR tokens can be earned by participating on the network, participating in developmental bounties, or running community nodes that can allow people in the community to build on NEAR. You can also buy NEAR tokens that are available on all major cryptocurrency exchanges.
What Can You Do With NEAR Tokens 
The NEAR token allows you to do several tasks; you can transfer NEAR tokens between accounts and keep track of transactions on the Block Explorer. Transaction fees on NEAR are extremely low, allowing you to move tokens easily. You can also send NEAR to anyone who needs to create a NEAR account using NEAR Drops. NEAR tokens also allow you to access a growing number of applications that are being built on NEAR. They can also purchase, publish or trade NFTs and digital art on NEAR or create collective art creations. 
Staking 
The NEAR community can support validators through Staking. Validators are those users that operate nodes that help to run the NEAR network. Validators are required to maintain a minimum amount staked so that they can stay on as validators. Token holders on NEAR can stake with a validator of their choice and earn a reward from the tokens generated by the network. Users can stake using the following steps 

 	Select Staking from the navigation bar, and choose a validator
 	Confirm the options you have selected, and then select “Stake with Validator” 
 	Choose the number of NEAR tokens that you want to stake and click on “Submit.”

What You Can Do On The NEAR Ecosystem 
NFTs 
NFTs have been gaining a significant amount of mainstream focus. While Ethereum is the primary player when it comes to NFTs, their move into the mainstream has also brought into focus Ethereum’s high gas fees, making it quite impractical. The NEAR Protocol is a viable alternative and already has several projects already running on its platform. The protocol’s scalability ensures that the development of dApps is made quick and easy. Currently, there are 19 decentralized platforms for NFT on NEAR platform. NEAR is also significantly faster than other players in the NFT space and has extremely low transaction costs.  

The NEAR Protocol can be described as the perfect platform for NFTs and has several advantages over other NFT platforms in the space and even Ethereum. The NEAR protocol can process transactions much faster than Ethereum, and unlike Ethereum, it does not suffer from high gas fees or network congestion. Transactions on NEAR are processed almost instantly with a negligible cost attached. All these factors make NEAR ideal for buying and selling NFTs and act as an incentive for different projects to build their NFTs on NEAR. There are several NFT projects already running on NEAR, such as Mintbase and Paras.
Mint and Trade NEAR Accounts as NFTs at NameSky





NameSky is an NFT project on the NEAR blockchain. It’s built with utilities to make buy & sell NEAR accounts easy and secure as NFTs.


Every NFT represents the ownership of the attached NEAR account, i.e. buying an NFT with account id awesome.near means buying the awesome.near NEAR account.





Create And Sell NFTs through Mintbase 
NEAR Protocol users can use several of the NFT projects to buy, sell or create NFTs. One such project, Mintbase, allows users to create an NFT and make it available for sale on marketplaces such as OpenSea. Users can create smart contracts to limit the transferability of the tokens, which helps prevent fraud and the illegal transfer of assets. 

Mintbase switched from the Ethereum blockchain to NEAR protocol due to the former’s high gas fees. Initially, gas fees on Ethereum were low, and users could deploy quickly, however with increasing usage and congestion on Ethereum, gas costs started spiraling out of control. There are several other reasons why Mintbase chose NEAR Protocol. 

 	NEAR uses Rust or AssemblyScript to code smart contracts, allowing developers to write code easily. 
 	NEAR has human-readable addresses for smart contracts and accounts. 
 	Developers can use NEAR drops and onboard users easily and quickly. They can also pay for their NEAR accounts and send or receive NEAR tokens. 
 	Developers can use the ETH-NEAR Rainbow Bridge and move their assets quickly. 
 	DeFi projects such as Balancer and Aave are also on NEAR, making any potential future integration easy. 

Create, Trade, And Collect Digital Art Cards 
Paras is a digital card marketplace built on the NEAR protocol that provides users a solution for aging traditional collectible cards. It validates ownership through the blockchain through quick and inexpensive transactions. It also differentiates itself by offering collections instead of standalone releases. Paras is beneficial for collectors as it significantly reduces the burden on collectors by ensuring that their collectibles do not wear out. Artists and collectors both can easily access the collectibles market. 

Since the launch of Paras, we have seen artists make more than $25,000, with the platform being able to process 700+ transactions that allowed it to facilitate a trading volume of over $35,000. Currently, the platform has over 70 artists and 80 collectors. The NEAR Protocol and Paras are a great fit because NFT creators are looking for alternatives to Ethereum with its high gas fees. Transactions on NEAR cost next to nothing and can be completed in seconds, while the Rainbow Bridge ensures interoperability between Ethereum and NEAR. 
Explore And Auction NFT Collections
Protocol users can access several other NFT projects on NEAR, such as Metamon, WebAssembly Music, Snark.Art etc. Metamon creates a universe of monsters that users can capture, evolve and play with. The monsters are classified as endangered, limited edition creatures that a select group of NFT collectors can adopt. Collectors can combine two of the same type of Metamon and watch it evolve into a rarer, more powerful Metamon. 

WebAssembly Music is the first music that has been stored on the blockchain as an NFT. The music is created by Peter Salomonsen and is published on the NEAR Protocol. The piece of music was among the first pieces of music that were rendered to an executable WebAssembly binary. Users can execute the WASM binary file and get the raw audio data through a WebAssembly runtime. 




	

	
	
		
			
				NEAR uses the following to code smart contracts:
			
		

		
					

		
			
			
			
			Solidity
		
			
			Rust or AssemblyScript
		
			
			C++
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





DeFi On NEAR 
Let’s first understand DeFi, DeFi, or Decentralized Finance refers to a completely decentralized financial system that utilizes blockchains like Ethereum. It consists of assets such as decentralized applications, DeFi protocols, and smart contracts. The goal behind DeFi is to create an open-source, permissionless, and decentralized financial system that operates independently from the jurisdiction of any third-party or central governing authority. DeFi gives users easy access to financial services and is especially beneficial to individuals who do not have access to banking services.

NEAR is bringing DeFi to the masses with several projects live on the protocol, with projects ranging from DeFi projects, DEXs, Oracles, etc. Let us look at how you can use some of the projects on NEAR. 
Access Almost All Compatible Chains With Rainbow Bridge 
The Rainbow Bridge acts as a bridge between NEAR and Ethereum and is a permissionless and trustless protocol that connects two different blockchains. Users can easily deploy a new bridge or join an existing bridge without needing approval from a third party. The Rainbow Bridge allows any information that can be used on NEAR to be utilized in Ethereum smart contracts and vice versa. This also enables users to vote with ETH on a DAO based on NEAR without going through Ethereum. 

The Rainbow Bridge is easily accessible for users, thanks to an intuitive design, and onboard directly through MetaMask. The Rainbow Bridge can also be repurposed and connect NEAR with almost all Ethereum-compatible chains. The Rainbow Bridge is also looking to support non-EVM chains such as Bitcoin. 
SputnikDAO 
DAOs are extremely important when it comes to a protocol’s governance strategy. SputnikDAO empowers communities and individuals that make up the NEAR ecosystem, acting as the infrastructure for DAOs on the NEAR protocol and allow individuals and other projects to launch DAOs, upgrade protocol smart contracts, and configure governance for treasury management easily. SputnikDAO also enables projects to set up multi-signature governance or issue governance tokens or combine the two and use them together. 
Release And Mint Audio NFTs With DAOrecords 
DAOrecords plans to become the world’s first decentralized Record label and currently employs a hybrid model. The project has been continuously experimenting with Audio NFTs, with the project having released 350 NFTs and worked with over 60 artists so far. DAOrecords wants to control music back to the artists who created them and change the way they interact with their fans. 

Independent artists can release new music using DAOrecord’s audio NFTs and streaming services. They can also mint their audio NFTs. DAOrecords has already published an interactive audio NFT called “MintTape Vol 1.”
Access Loans Through Aave 
Aave implements a pool-based lending strategy instead of a decentralized peer-to-peer strategy. Loans on Aave are not matched individually. Instead, they rely on pooled funds and on the collateral along with the amounts borrowed. Aave was launched in November 2017 as a peer-to-peer lending platform and renamed Aave in September 2018. The protocol went live on the Mainnet, and has almost $6 Billion locked in smart contracts, and is in the top 3 projects in the DeFi space. 

Aave offers flash loans, which are basically uncollateralized loans that are borrowed and repaid in a single transaction, which means that users do not require any collateral for the loan, while the borrower returns the original amount borrowed and a small fee. Aave introduced flash loans, where anyone can borrow liquidity, use it with other protocols, and repay it back in a single transaction. Flash loans are essential in the DeFi space as they give individuals access to liquidity without the need for collateral. 
Access Data Feeds With Chainlink 
Chainlink was developed as a decentralized oracle network that allows smart contracts to transfer data between blockchains and off-chain systems reliably and securely. It utilizes a decentralized network of independent oracles to retrieve data from multiple different resources, aggregate the data, and then deliver the validated data to the smart contract, which triggers the execution of the contract. 

The Chainlink protocol also provides multi-layer security to ensure complete trust in the oracle network. It allows for the building and running of oracle networks, allowing users to connect to customized oracle networks without having to depend on other oracle networks. 

 	Data Signing - Chainlink oracles input data is signed using a unique cartographic signature that allows users to prove that the data originated from a specific oracle node. 
 	High-Quality Data - Chainlink will provide smart contracts with data sourced from external sources such as external data providers. 
 	Blockchain Agnostic - Chainlink is able to natively run on any blockchain, supporting public blockchains, enterprise blockchains, etc. 




	

	
	
		
			
				DAOrecords allows you to mint:
			
		

		
					

		
			
			
			
			Digital art
		
			
			Digital cats
		
			
			Audio NFTs
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora – An Ethereum Layer-2 Experience
Aurora on NEAR Protocol provides an Ethereum Layer-2 experience. Developers can use this to reach out to additional markets while taking advantage of the NEAR Protocol features such as gas fee remuneration and sharding. It runs on two critical components, the Aurora Bridge and the Aurora Engine. Here are some features that Aurora brings in:

 	The ability to process thousands of transactions per second, a 50x increase over Ethereum. 
 	A block finality time of 2 seconds, as compared to the single block confirmation time of 13 seconds on Ethereum. 
 	Allows EVM to scale horizontally with NEAR's sharding approach.
 	Fees on Aurora are 1000x times lower than those on Ethereum. 
 	Aurora offers uncompromising compatibility with Ethereum over the NEAR Protocol. 

Closing Thoughts 
NEAR is creating an ecosystem where users can easily access dApps, NFTs, and DeFi. The protocol is faster and cheaper than other players in the crypto space. NEAR offers solutions for issues such as slow processing speeds, network congestion, and high gas fees by utilizing sharding, giving the platform a significant amount of scalability without compromising on the security of the protocol.




	

	
	
		
			
				This protocol allows NEAR users to access Ethereum on layer-2:
			
		

		
					

		
			
			
			
			Optimism
		
			
			Aurora
		
			
			Plasma
		
	
		

		
		
			
				Correct!
				Wrong!

### NEAR Sputnik DAO: 给社区赋能

Open Web和Web3都源于“大众将自己构建和管理下一代互联网”的理念。 NEAR 以此作为使命：赋予所有人控制自己 的钱，数据和治理权力。




	

	
	
		
			
				你认为DAO的核心目的是什么？
			
		

		
					

		
			
			
			
			协调社区活动
		
			
			促进管理机制
		
			
			复制企业架构
		
			
			促进代币经济化
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






以太坊创始人Vitalik Buterin在2014年发表的一篇非常古老的博客文章中描绘了一种思考集体行动的新方式：不是一家有股东，高管和员工的公司，而是一个去中心化的自治组织，简称为DAO。其成员就是组织的一部分，贡献他们的努力，并与他们的贡献成比例地获得奖励。DAO中没有老板，没有层次结构，并且参与者通过共同的目的组织在一起。

我记得当我第一次阅读Vitalik的文章时很有同感，想象一个未来真正自治的社区，任何地方的任何人都可以构建一个团体。它的行为不受地理界限、法规或银行体系的限制。- 就像区块链赋能的Web3给个体带来的改变，DAO同样改变了社区。最终公司会被DAO替代，仍然具有公司的特性，但在其成立之初以及随着相关大众的需求和优先事项的变化而具有的更大的灵活性。

这种愿景甚至先于我对Web3和区块链的兴趣。 我离开了乌克兰，因为在那里建立公司让我觉得不安全。 我不相信任何乌克兰银行可以安全可信的存钱。 政府在过去十年中多次改变了持有美国货币的规则（比如需要把一半的钱转为当地货币）。 在乌克兰运营公司，还有很多腐败和僵化的流程。在许多国家，政府腐败，缺乏法治和可能消失的不靠谱的银行，造成了公司的额外开销。

不止乌克兰，其他地方也类似。更进一步：如果人们想要构建一个正式组织，他们需要申请政府的许可（例如，创建公司），特别是如果他们需要开立银行账户并以组织的名义参与经济活动。此过程耗时，昂贵，复杂，组织一旦建立就面领着严格规则的约束。

即使是非正式社区协作也需要规则和审核。 想象一下，一个动漫学生组想要协调一个国际粉丝活动，或者世界各地的成功艺术家想要组成一个团体来帮助新手艺术家。社区协调可以包括所有内容，从发布成员对某个问题的看法、共同创作艺术或产品、推出应用程序、投资一些数字资产，甚至共同拥有一个社交渠道（如 Twitter 帐户）。所有这些都是需要某种治理进行协调的真实例子。

很长一段时间以来，我相信无数小团队一起工作，而不是大公司创造垄断，然后为维护垄断而奋斗。 事实上，大约十年前，我和一些朋友创建了非公司的Prostoksi，它由共同从事开源项目的开发人员组成。

由于密码学带来的保证，Web3 以 Web2 无法实现的方式实现了这一愿景。 想象一下，在云提供商的基础上构建，或者使用仅由 20 人运营的银行，没有正式的隶属关系，也不能保证该组织在一年内仍能正常运作——您可以在其上构建的内容是有限的 . 但在加密领域，基础设施和去中心化应用程序是可靠的，因为它们是开源的、开放的状态，并且具有可靠的保证。 以这种方式构建的应用程序提供了相互交互的通用协议，其他开发者、企业和用户可以依赖这些协议。

DAO 是新世界中此类通用协议的一部分。 自 Vitalik 撰写这篇非常高层次的帖子之后的七年里，成千上万的成员在以太坊和其他网络上试验了 DAO——其中一些最著名的包括 Maker、Moloch DAO、MetaCartel、The LAO 和 Flamingo DAO。 我从第一波 DAO 实验中汲取了一些关键经验，这些经验为 NEAR 上的 DAO 愿景提供了依据。

 	很明显，社区控制治理的简单方法不能随所涉及的人员数量而扩展。 如果没有规则、法律或等级制度的引入，成千上万的人就无法有效地开发或控制任何事物。 我们还在区块链领域看到了许多围绕协议和投资基金治理的实验。 其中许多都因各种原因而失败，从技术问题到成员对投票缺乏兴趣或缺乏统一的驱动因素。
 	不能指望每一个成员都会永远开心。 兴趣在变化，人们的意见也在变化； 多数派和少数派最终会围绕某些问题出现。 即使在大多数情况下，每个人都会通过投票等基本治理达成共识，但如果社区中的少数人不同意多数且形成了足够的自己的意愿后，他们应能随时分叉或偏离原先的群体并遵循一套新的规则。
 	任何社区或组织都需要领导。 即使这是一群高度专注的人——如果他们不是全职工作在共同的事业上，他们可能太忙了，无法一直积极参与每一个讨论或决定。 社区通常有专门的成员负责协调，潜在的缓和。
 	如果一个社区是无需许可且匿名的，那么让那些知名的成员参与并创建社区的“核心”仍然很有价值。 社区将首先听取这些成员的观点和意见，因为他们被认为是最投入和最了解情况的人。。
 	这种去中心化的社区越是以“产品”为核心，就越是需要专注的领导层。因为产品开发通常需要比任何社区参与者都多得多的背景。 例如，一个社区试图共同构建区块链或去中心化交易所。
 	纯粹基于权益的加权治理常常失败，要么是因为大多数利益相关者无法或不想成为积极的参与者，要么是因为它的治理过程容易招致攻击。




	

	
	
		
			
				Sputnik DAO是专门为技术社区而创建的吗?
			
		

		
					

		
			
			
			
			是
		
			
			不是
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






因此，DAO是围绕某种共同目的而团结起来的社区，需要一些协调和治理的规则，具有随着社区的利益和目标的变化而随时间发展的灵活性，以及以最小的开销作为一个单位进行交易和赚钱的能力。考虑到所有这些经验，我们开始在NEAR上创建一个DAO协议，它将赋予所有类型的社区——不仅仅是由工程师运行的技术社区——以一个灵活、健壮的框架来共同工作和发展。




	

	
	
		
			
				关于社区领导，下列哪项是正确的?
			
		

		
					

		
			
			
			
			真正的领导确保每个社区成员总是快乐的
		
			
			社区领导人不需要为社区全职工作。
		
			
			即使在一个没有权限的社区中，拥有核心成员/领导者也是很重要的。
		
			
			社区的领导人通过制定规则来管理社区。
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






由此产生的协议 Sputnik DAO 为世界各地的新的和现有的社区和组织提供了一种方式，在链上代表他们的群体，管理其链上活动和决策，以及（重要的是！）与其他 DAO交互。 自 2021 年 2 月首次启动以来，目前约有 100 个 Sputnik DAO，分配了约 50 万美元，各个国库中总共包含约 50 万美元（参见这里的统计数据 ）。

查看sputnik.fund 并告诉我们你的想法。下周我们将分享V2 beta测试版，含有新的UX和新功能。另一篇文章将详细介绍Sputnik 如何独特地解决组织社区的关键挑战。请务必关注我们的Medium 以获取关于V2的通知。

感谢Sputnik的早期社区组提供V2的想法; 以及NEAR团队。

感谢Tara Tan, Julia Lipton给予我们的意见和建议

感谢 Mally Anderson 的大量编辑

最初的文章在 Medium

P.S. 想为LearnNEAR.Club做贡献吗? 提交您的提案到 Learn NEAR DAO

原文链接：https://learnnear.club/near-sputnik-dao-empowering-communities/

### Что такое DAO? Рассмотрим Спутник DAO.

Одной из самых интересных вещей, которая в последнее время приобрела большую популярность, - это концепция DAO или «децентрализованной автономной организации». Идея заключается в том, чтобы создать интернет-ориентированный бизнес, которым коллективно владеют и управляют его участники. Нет ни CEO, контролирующего бизнес, ни директора по маркетингу, ни финансового директора, ни централизованного совета директоров. Вместо этого, вся бизнес-логика и ее реализация заложены в смарт-контракты, которые обеспечивают эффективность ее исполнения.

Гипотетические примеры DAO:

 	Благотворительность: любой может стать участником и сделать пожертвование, а группа совместно решает, как его потратить.
 	Сеть фрилансеров: Сеть исполнителей, которые объединяют свои усилия, чтобы зарабатывать на фрилансе.
 	Венчурные фонды и гранты: Децентрализованный хедж-фонд, члены которого могут объединять свои средства и голосовать по различным предложениям.

Чем отличаются DAO?
DAO выполняют определенные инструкции, которые записываются в смарт-контракт и хранятся в блокчейне. Смарт-контракт можно представить как автоматизированное соглашение между двумя или более сторонами. Благодаря прозрачности блокчейна, невозможно изменить код, управляющий смарт-контрактом, без того, чтобы об этом не узнала вся сеть. Именно это делает DAO более гибкой и надежной, чем обычные организации.

 	DAO - это демократичная организация, где каждый участник голосует за любые изменения, которые должны быть реализованы. В DAO в основе управление стоит сообщество, а не исполнительная власть.
 	DAO являются публичными и полностью прозрачными.

Недостатки иерархических организаций
Иерархическая вертикальная организационная структура - это распространенный способ построения бизнеса. Идея проста - каждый человек в организации (кроме того, кто находится на самом верху) подчиняется другому человеку или организации. Таким образом, те, кто обладает наибольшей властью, находятся на вершине этой вертикали. В то же время те, кто обладает наименьшей властью, оказываются внизу. Такая структура имеет ряд недостатков по сравнению с DAO.
 




DAO
Иерархическая Организация


Структура
Плоская и демократичная
Иерархическая


Голосование
Каждое изменение в системе требует голосования участников.
Требует система голосования или нет, зависит от структуры и правил, определенных системой.


Посредничество
Подсчет голосов и реализация решения осуществляется без доверенного посредника.
Если голосование разрешено, для подсчета нужен посредник.


Автоматизация
Вопросы, связанные с управлением, решаются автоматически в децентрализованном порядке.
Требует централизованной обработки человеком. Следовательно, уязвима для манипуляций.


Видимость
Полностью публичны и прозрачны.
Частные и в основном непрозрачные.



Модели членства в DAO
Итак, как именно работает модель членства в DAO? Это вопрос важен, поскольку членство является ключом к операционной модели DAO.

Есть две модели членства:

 	На основе токенов
 	На основе акций

На основе токенов
Большинство протоколов имеют токен управления, которым можно торговать на различных централизованных и децентрализованных биржах. Эти токены можно заработать, участвуя в алгоритме консенсуса или предоставляя ликвидность. Как следует из названия, владение этими токенами дает вам доступ к праву голоса в рамках протокола. Чем больше у вас токенов, тем больше у вас право голоса. Примером может служить MakerDAO и ее токены управления - MKR. Любой желающий может принять участие в управлении MakerDAO, купив токены MKR.
На основе акций
По сравнению с DAO, основанными на токенах, DAO, основанные на акциях, являются более эксклюзивными. Потенциальные члены должны подать предложение о вступлении в DAO. Предложение сопровождается взносом в виде токенов или какой-либо работы. Акции участника представляют собой его прямое право голоса. Он может выйти в любой момент, получив пропорциональную долю в казне. MolochDAO - протокол, отвечающий за финансирование проектов на базе Ethereum, - является примером DAO, основанного на акциях. Вы не можете купить токены управления на открытом рынке, для получения доступа к DAO. Чтобы присоединиться, вам нужно обладать необходимым опытом и капиталом, чтобы быть в состоянии помочь поддержать перспективные проекты.
Учимся на ошибках - взлом DAO
Для лучшего понимания, крайне важно знать о взломе DAO, который разделил Ethereum на Ethereum и Ethereum Classic.  Еще в 2016 году Ethereum DAO был создан для того, чтобы изменить правила игры и полностью переосмыслить принцип работы венчурных фондов. Идея заключалась в том, чтобы держатели токенов DAO голосовали по различным проектным предложениям. Если предложение набирает 20% голосов сообщества, оно получает средства, необходимые для начала работы.

У DAO также был "механизм разделения". В принципе, если участники не довольны проектами, внесенными в белый список, они могли отделиться от DAO и создать свою собственную "дочернюю DAO". В любом случае, DAO стала огромным хитом и в ходе краудсейла собрала ETH на сумму более 150 миллионов долларов. Для сравнения, это 14% всех выпущенных на сегодняшний день токенов Эфира.

Однако DAO имела серьезную уязвимость в коде. 17 июня 2016 года злоумышленник воспользовался этой уязвимостью для постоянного повторного входа в систему и выкачивания ETH на сумму 50 миллионов долларов. Большинство членов сообщества решили отменить этот инцидент с помощью хард форка. Однако некоторые члены сообщества были против этого шага. В итоге это привело к разделению протокола Ethereum на Ethereum и Ethereum Classic.
NEAR Протокол и Спутник DAO
В этой статье соучредитель Near Protocol Илья Полосухин рассказал о Спутник DAO. Он описал DAO, как "способ для новых и уже существующих сообществ и организаций по всему миру иметь свое представительство в блокчейне, управлять там своей деятельностью, регулировать принятие решений и (что важно!) взаимодействовать с другими DAO".

Спутник вобрал в себя следующие источники вдохновения для формирования "первой волны" экспериментов с DAO:

 	Способ, которым сообщество контролирует управление, не зависит от количества вовлеченных в процесс людей. Многие DAO потерпели неудачу по разным причинам - от технических проблем до отсутствия интереса к голосованию со стороны членов сообщества или отсутствия объединяющего, движущего фактора.
 	Невозможно иметь полностью систему DAO которая устраивает всех. Будут возникать конфликты интересов, и мнения людей о предложении могут измениться. Меньшинство в группе может отделиться от группы, чтобы следовать новой системе DAO.
 	Сообществу или организации необходимо руководство. Идеальное сообщество должно иметь преданных членов, которые отвечают за координацию, возможно, модерацию.
 	Даже если сообщество является децентрализованным и анонимным и не имеет прав доступа, должны быть публично известные участники, которые создадут ядро ​​сообщества.
 	Чем более децентрализованное сообщество ориентировано на "продукт", тем более пристальное внимание следует уделять руководству.
 	Голосование на основе долей всегда терпит неудачу, потому что большинство заинтересованных сторон не могут или не хотят быть активными участниками.

Интерфейс Спутника
Как только вы перейдете на главную страницу Спутника, вы увидите следующий экран.



Когда вы нажмете «NEAR Forum», вы увидите, что различные темы, аккуратно и соответствующим образом распределенные по категориям.



На главной странице, если вы нажмете на "Launch App", вы получите доступ к различным DAO, перечисленным в Спутнике.



В качестве примера давайте проверим все предложения в Learn NEAR DAO.



Итак, как вы видите, здесь перечислены различные предложения с соответствующими выплатами (в NEAR). Если предложение было одобрено или отклонено, это будет отмечено. Например, в предложении ID 22 кто-то успешно перевел главную страницу и нижний колонтитул на "вьетнамский язык", поэтому вы видите цифру "1" рядом с Approve и значок "Success".


Как мы используем Спутник DAO в LearnNEAR.Club
Существует ДВА уровня используемых DAO:

Материнская DAO и дочерние DAO (subDAO):

 	https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near

Рассматривайте материнскую DAO как Заказчика / спонсора, а subDAO как подрядчика. Участники subDAO будут в этой схеме субподрядчиками.

Давайте рассмотрим, как это работает для сообщества по переводу. Необходимо перевести на вьетнамский язык руководство Top 3 NFT Projects On The NEAR Protocol. Члены subDAO подали предложения для перевода и рецензирования.



Затем один из них представил консолидированное предложение в материнский DAO указав в качестве получателя средств subDAO.



После принятия работы и публикации переведенного руководства, члены subDAO распределяют средства в соответствии с поданными ранее предложениями.

Для возможного разрешения конфликтов, член материнской DAO, также выступает в качестве участника с правом голоса во ВСЕХ subDAO.
Вывод
Итак, теперь вы знаете насколько DAO революционны. Однако, чтобы действительно в будущем получить все преимущества DAO, нужно заложить правильную основу. Похоже, что Near Protocol подобрали ключ к решению многих проблем централизованных систем с помощью Спутника!

### LearnNEAR.Club LNC Weekly Update - August 22, 2021

Brief Summary:

 	Learn NEAR Club had a record week!

Results:

 	Over 5,500 (L)Earners visited during a week
 	Read about DeBio - very interesting project coming to NEAR Protocol via Octopus Network
 	NEAR Protocol Ecosystem directory (beta)
 	NEAR Certified Developer Level 1 course is available in Chinese!

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Weekly Beta Testing sprint: August 26 -September 2!

### A Quick Introduction To The DeBio Network

The Decentralized Biomedical Solution on the Octopus Network
The current biomedical system is broken. The status quo prevents patients from being able to access their data freely, and healthcare providers can’t guarantee the safety of their patient’s data. The DeBio Network aims to change that.
What is DeBio Network?
DeBio Network is a decentralized anonymous-first platform for medical and bioinformatics specializing in genomic testing. DeBio aims to revolutionize the current biomedical industry by giving patients full sovereignty over their data using the most cutting-edge blockchain technologies.

The introduction of blockchain in the current tech ecosystem plays a big role in the pursuit of decentralized global finance, but the use cases offered by blockchain exceed more than just finance. DeBio believes that the future of medical data relies partly on the use of blockchain, especially in the specialization of technology use cases as well as interoperability.
Centralized Genetic Testing Is A Privacy Risk
For the past few years, genetic testing has exploded in popularity. As a result, direct-to-consumer genetic testing platforms such as 23andMe, and AncestryDNA have seen an increase in consumers. But what many people fail to realize is the implicit privacy risk of using these platforms. 

Mainstream direct-to-consumer genetic testing platforms are centralized, making them an easy target for data breaches. In 2020, there were 1001 data breaches in the United States alone; with the healthcare industry receiving the brunt of it, Govtech reported.

Even more concerning is that genetic data is not unique to an individual but unique to the individual’s family tree. By using a centralized bioinformatics service you put at risk not only your privacy but also the privacy of your distant relatives. 

The harm of this is unambiguous because there is a possibility that your distant relatives, for example, a second cousin can be affected by your decision. Worrisome is the thought of a distant relative you don’t even know exists, taking a genetics test and having their genetic data be traced back to you.

Genetic data can be traced back to you even with a little amount of demographics information, such as their age and state. This type of information can be used against you by insurance companies, to make the most of their clients.
The DeBio Network Concept
The main concept behind DeBio is based on the notion of wanting to increase biomedical and genetic testing to consumers without forfeiting their privacy. But DeBio also wants to incentivize genetics research by offering collaborations between sovereign labs.
A Physical-To-Digital Bridge for Anonymous Testing
Consumers can select a wide range of products and laboratory recommendations from DeBio’s genetic testing marketplace. After the consumer has decided on a product they will only need to take two DNA samples via the buccal swab method or take samples of oral cells with cotton swabs.

The consumer then sends the DNA sample to the laboratory within an envelope with the only identifiable information written on the envelope is the genetic tracking ID for the sample. Laboratories cannot identify samples without a tracking ID because, for anonymity purposes, DeBio will not collect personally identifiable information of any kind, making the DNA samples untraceable back to the consumer.

The results (e.g, test and genome) are then encrypted with the consumer’s public key retrieved from the DeBio blockchain and stored then uploaded on decentralized storage. This allows consumers to maintain full sovereignty over their encrypted data — consumers must possess their private keys to decrypt the results.

The DeBio Network team is expanding this “physical-to-digital bridge” concept to use cases outside of the genetic testing market — which may include lab testing for diseases and other electronic medical record data or personal health information.
Sovereign Lab Collaboration To Offer Joint Products Integrating Services From Several Labs
After the consumer sends the DNA sample to the lab, the lab will be notified. When the sample arrives, the lab will begin sequencing the physical samples or will begin any biomarker tests. After finishing the subsequent tests, the lab will then encrypt the results using the consumer’s public key and upload them to decentralized storage.

The results cannot be decrypted without the use of the consumer’s private key, thus the consumer’s sovereignty over their biomedical testing results is secure. However, to further incentivize genetic testing, consumers are opted to stake their genetic testing data to be used by other labs.

The goal of having sovereign labs is to increase the availability of products and enable joint products by integrating services from several labs. This also allows DeBio to scale because labs do not need to be centralized allowing for multiple standalone genetics facilities to participate.




	

	
	
		
			
				Quiz: What problem does the DeBio Network intend to solve?
			
		

		
					

		
			
			
			
			Privacy concerns among online genetic testing platforms
		
			
			Obstacles in sovereign labs to do their work
		
			
			The lack of research in genomics
		
			
			Expensive healthcare
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The DeBio Network Techstack
Bioinformatics and biomedical ecosystems both have unique demands in how they both need to be accessible to the professionals conducting the studies but also be secure enough to safeguard the patient’s privacy and sovereignty. Thus, to guarantee patient sovereignty over their data, the entire tech stack consists of decentralized solutions ranging from decentralized authentication to decentralized file storage.



Image is taken from DeBio Deck

DeBio has incorporated a slew of cutting-edge technologies in the solution, including but not limited to:

 	Substrate
 	KILT Protocol
 	The Octopus Network
 	The InterPlanetary File System (IPFS)
 	Ocean Protocol

Substrate
The first notable tech incorporated is Substrate. Substrate is the framework behind the Polkadot token, enabling developers to build purposeful blockchains. The core services will be built using Substrate, making them the core building blocks of the solution. DeBio chose Substrate because of the two following reasons:

 	Blockchain interoperability (essentially being able to communicate between different blockchains).
 	Relay chain security (applying stricter security standards of the host relay chain).

Other than allowing blockchains to communicate with each other, the interoperability feature also enforces a security standard that will be inherited by each para chain connected to the main relay chain. As a result, the security of the DeBio blockchain is improved by following the standards of the corresponding relay chain.
KILT Protocol
The next notable mention would be the KILT Protocol. KILT is a protocol for creating, attesting and verifying identities anonymously on Web3. To authenticate themselves, each user needs to create a claim, that would then be sent to a trusted attester.

An attester has the responsibility of certifying a user’s claim, which will then transform into a hash to be saved on the KILT blockchain. A user’s claim sometimes contains sensitive data concerning the user, but because the hash cannot be transformed back into a user claim the user’s privacy is guaranteed.

After receiving the certificate from the trusted attester, the user can now use his/her claims on applications that use KILT and trusts the aforementioned attester. KILT is privacy by design. Applications that will verify the claim do not need to go through the attester and will directly compare the claim to the one stored in the KILT blockchain, cutting the attester off from the verification process and making it fully decentralized.

The KILT Protocol provides a solution that prevents data from being concentrated in one entity. It enables data sovereignty for the privacy-conscious. DeBio has partnered with KILT to implement a decentralized authentication system because it fits perfectly with DeBio’s anonymous-first use case.
The Octopus Network
Octopus is a crypto network for launching and running Web3 application-specific blockchains at the fraction of the cost. One of the considerations of using Octopus is that, compared to Polkadot, they offer a significantly cheaper security lease and comparable cross-chain capabilities. Octopus is backed by the NEAR Protocol, NEAR is a high-performance blockchain meant to solve the problem of scalability, and to increase developer productivity by simplifying the development process and creating a developer-friendly environment.

DeBio is already partnered with Octopus and will be one of the first five application-specific blockchains (app chains) launched on the Octopus Network. DeBio is also already part of the Octopus Guild, a community of developers and app chains on the Octopus Network.
The InterPlanetary File System (IPFS)
The InterPlanetary File System (IPFS) is a protocol made for fully decentralized, peer-to-peer data sharing and storage. IPFS was created as a solution for decentralized projects that want to store an amount of data that is too large to be stored in the blockchain itself. IPFS creates unique content addresses by hashing the content itself. Each unique content will have a different address pointing to its location. DeBio adds IPFS to store biomedical data such as encrypted human genomes and encrypted electronic medical records.
Ocean Protocol
The Ocean Protocol is built for the consumption of data assets in a secure, privacy-preserving fashion. It does this with the compute-to-data feature and enables the monetization of data without ever having to leave the owner’s premises. The Ocean Protocol’s open-source data marketplace called the Ocean Market is forkable; the DeBio Network team will use Ocean for biomedical data staking.
Privacy Computing
To stake biomedical data, DeBio will host anonymous biomedical data in their private data store. This process doesn’t involve the aforementioned IPFS because the data store will be completely separate from IPFS. Users who want to stake their data will need to decrypt and upload their biomedical data to their privately-held data store. While transferring decrypted biomedical data to a privately-held data store sounds eerie, DeBio will implement privacy computing concepts within the data store to safeguard your privacy.



Image retrieved from DeBio Whitepaper

Only after the user’s consent are the datasets aggregated through Ocean’s compute-to-data proxy, and the 3rd party will be able to create analytics and process the data all the while it remains on-premises.

By incentivizing users to stake their genomic/biomedical data, and hope that it would further incentivize research in the field. Moreover, the privately-held data store will not be gathering personally identifiable information thus there is no need to worry about your samples being traced back to you.

Pandu Sastrowardoyo, the CEO of DeBio, stated that one of the reasons she created DeBio is to help genetic research flourish by creating a fully anonymous genetic data marketplace. “DeBio is a whole new economic system for genomics — allowing genetic sovereignty, ensuring participation of smaller labs while supercharging genetic research. All done on top of a DeFi-like model that is fully decentralized,” said Pandu.




	

	
	
		
			
				Quiz: Where does DeBio store the staked data?
			
		

		
					

		
			
			
			
			Inside the DeBio blockchain
		
			
			Inside the data tokens
		
			
			On a private-held data store
		
			
			On IPFS
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Technical Architecture Layers
Our technical architecture consists of four layers, the main blockchain infrastructure, the transport and generic business logic layer, and lastly the top-level business logic layer.



DeBio Proposed Technical Architecture, Image retrieved from DeBio Whitepaper
Layer 1: The Blockchain Infrastructure
The first layer will contain the core services. The core services are built on top of Substrate, Octopus, and IPFS. Substrate is the core building block for the blockchain service. To save large files DeBio will use IPFS and save the content address inside Substrate instead. Finally, the entire app chain will be connected with the Octopus relay chain.
Layer 2 & 3: The Transport and Generic Business Logic Layer
The second and third layers contain the transport and generic business logic. These layers are responsible for serving data directly to the users. Each pallet contains the base business logic for interactions with the blockchain and will serve as an abstraction layer from the fourth layer to communicate with Substrate services on the first layer.
Layer 4: The Top-Level Business Logic Layer
The fourth layer would consist of the DeBio UI and Metamask. All interaction between the users and the blockchain will be done from the fourth layer. All queries will also be defined from the top level, and will then be processed on all the previously mentioned layers. To fund each transaction, users can use Metamask to pay using an ERC20 stable coin. In this case, DeBio will be using DAI as the stable coin of choice.
The Token Model


Image retrieved from DeBio Whitepaper

The DeBio Network team intends to release six tokens:

 	Mainnet Transaction Rewards & Validator Token ($DBIO)
 	The Governance Token ($GBIO)
 	The Genomics Data Token ($GENE, via Ocean Protocol)
 	The Biomed Data Token ($MED, via Ocean Protocol)
 	The Electronic Medical Records Data Token ($EMR, via Ocean Protocol)

Mainnet Coin (stable coin, etc)
The mainnet coin will be backed by a stable coin. DeBio decided to use a stable coin because it needs to be used as a stable exchange for transactions, and fees related to the work being done by the corresponding labs. DeBio is going to utilize $DAI as our stable token.
Governance Token ($GBIO)
Governance tokens will be used mainly for voting by the registered labs. DeBio Network is a decentralized organization so there needs to be a governance scheme in place for voting in the DAOGenics marketplace. Alternatively, the governance token can also serve as a method for lab onboarding.
The Data Tokens ($GENE, $MED, and $EMR)
These tokens are used as a method of transaction in the data marketplace. When staking biomedical data on the Ocean marketplace the consumers will be rewarded with data tokens that can be converted to $OCEAN.
Validator & Transaction Rewards ($DBIO)
The validator token is used to incentivize the node owners to validate transactions and secure the dApp from unauthorized users. The intended incentives provided for validators are LP rewards and governance tokens.
Consumer Transactions In DeBio Network
$DAI is the mainnet stable coin used for transactions on the DeBio platform. Consumers can use the mainnet coin to pay for products and service fees. Products that will be available in the marketplace include genomic testing products, biomedical testing products, and a sovereign electronic medical records storage service (EMR).



Image retrieved from DeBio Whitepaper
Transactional Rewards
Each transaction committed by the consumer will be rewarded by a validator token, more specifically a $DBIO token. The price of a single $DBIO token is determined by the DeBio Network data marketplace that houses the consumer genomic data available for staking.
Data Staking In DeBio Network
After buying a product on the marketplace, the consumers can opt to stake their results on the Ocean Marketplace. Data Staked by consumers will be categorized as data tokens, called $GENE, $MED, and $EMR for genomic data, biomedical data, and electronic medical records (EMR) respectively. The data tokens will be kept in the DeBio Network and aggregated to the data marketplace via Ocean Protocol as an ERC20 token. Because the genomic data, biomedical data, or EMR itself is too large to be saved inside the ERC20 data tokens, the data tokens will primarily serve as a pointer/link to the corresponding data.

Consumers who stake their data tokens will have a “data provider” role in the data marketplace. All transactions in the Ocean data marketplace will use $OCEAN tokens. Thus, if the transaction is successful, the buyer will be exchanging $OCEAN tokens for the data tokens ($GENE or $EMR or $MED). Whereas the “data provider” will receive the subsequent $OCEAN tokens.



Image retrieved from DeBio Whitepaper

If the data buyer wants to access the data linked in the data token, they need to send the data token to the data provider beforehand. As a result, the data provider will have both the $OCEAN token and data tokens while the data buyer will be sent the data linked by the data token.



Image retrieved from DeBio Whitepaper

Conversely, data tokens ($GENE or $MED or $EMR) received by the DAOGenics Foundation will be converted into $OCEAN tokens. After a certain period, the $OCEAN token received by DAOGenics Foundation will be converted into a $DBIO token through a non-permission smart contract.

As a result, DAOGenics Foundation will always buy back the $DBIO token through a non-permission smart contract based on transaction volume conducted in the data marketplace. More transactions in the data marketplace will increase demand for the $DBIO token.




	

	
	
		
			
				Quiz: When you stake data on the DeBio Network data marketplace, what do you earn?
			
		

		
					

		
			
			
			
			The mainnet coin ($DAI)
		
			
			Governance tokens ($GBIO)
		
			
			Transaction reward token ($DBIO)
		
			
			Ocean token ($OCEAN)
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Conclusion
There are many benefits of doing genetic testing. For the first time in the history of humanity, people have been able to determine their lifestyles to pursue longevity; the advantage of such knowledge is astounding. But while genetic testing has its wonderful benefits without proper regulations and standards it also has its shortcomings. Without the guarantee of having your genetic data private and secure, it could cause problems in the future.

DeBio aims to solve the problem before it’s too late. DeBio is building a decentralized platform for your personal medical needs, starting with genetics. Our concept allows synergy between labs of all scales while guaranteeing user anonymity and sovereignty at every step of the genomic data science workflow — from sample collection, data storage, to report generation.

Some people might say that our DNA is the most private thing we have, and we take that very seriously. Anonymity-first genetic testing should be the number one focus for all companies.

The future is here, DeBio is creating solutions to revolutionize the healthcare and genetic testing industry. Are you ready to change the world with us?

Adapted from the original article on Medium.

 

### LearnNEAR.Club LNC Weekly Update - August 15, 2021

Brief Summary:

 	August Redeem Window went smoothly, minor bugs found and fixed

Results:

 	We sent Ⓝ544 to our 68 hardworking (L)Earners

 	Read Guides about NEAR protocol in Chinese

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	NEAR Ecosystem integration

### LearnNEAR.Club LNC Weekly Update - August 8, 2021

Brief Summary:

 	Test Sprint was a success!

Results:

 	Weekly Beta test sprint is over "Discourse Login with NEAR",


Ⓝ60 were sent to LNC community testers


 	Guide in Chinese "NEAR入门" is published

Challenges & Blockers:

 	Looking for more learning materials from NEAR Ecosystem

Action Items:

 	Next week Beta test sprint

### NEAR彩虹桥是如何工作的

作为唯一的无需许可、去信任的以太坊桥，NEAR彩虹桥在密码学领域是很独特的。本文将介绍它的工作机制！

NEAR协议构建了彩虹桥—一个在密码学领域独特且高价值的完全去信任的桥，可以在以太坊与NEAR之间，以及最终与极光(Aurora)之间转移通证。已有一些技术文档描述这个桥，而本文希望能让任何一个对密码学有基本认识的人能了解这个桥的工作机制。
概念
假设我要从以太坊转移20枚DAI到NEAR上。当然不可能在两个网络之间将通证进行物理转移，这意味着我们需要将20枚DAI移出以太坊上的流通，再投放20枚DAI到NEAR上流通，这样总的DAI流通量保持不变。

以下是通过无需许可且去信任的方式完成该需求的方法：

 	告诉以太坊网络我要把20个DAI转移到其他地方；
 	以太坊锁定我的20个DAI到一个保管库（一个智能合约），这样它们就退出流通了；
 	一旦确认这20枚DAI已经被锁定在以太坊上了，我就告诉NEAR给我创建20个新的DAI；
 	然而空口无凭，NEAR要求我提供20枚DAI已经在以太坊上锁定的证明；
 	我向NEAR提交以太坊上的锁定证明；
 	NEAR独立验证这个证明，通过后给我创建NEAR上流通的20枚DAI。

之后，一旦我想把DAI转移回以太坊，只要简单逆转上述流程即可，很优雅，是吧？
参与方
现在让我们看看在使用彩虹桥的过程中，实际上发生了些什么。这涉及到组成彩虹桥的一些技术组件：

彩虹桥UI — 这是网址。作为用户，你使用它与彩虹桥交互，在网络之间转账。

轻节点(LiteNode) — 它是一个区块链节点，不过仅仅存储区块头，因此极大的减少了存储占用。轻节点是以智能合约实现的，一个部署在以太坊网络上，存储NEAR区块头，另一个部署在NEAR网络上，存储以太坊区块头。

(仅供参考，因为历史原因，轻节点在其他文档中也被叫做轻客户端(light client)。如果要问，“存储区块数据的实体应该叫什么？”，我的想法是“一个节点”，所以在这篇文档里，我用轻节点这个词，以便帮助建立思维模型。)

中继(Relayer) — 轻节点是智能合约，它们不会自己运行和更新信息。中继是一些脚本，运行于传统服务器上，它们周期性地从一个区块链上读取块，传递给运行于另一个链上的轻节点。也就是说，中继保持轻节点的数据最新。

每次更新轻节点都是一笔交易，因此会消耗gas费。NEAR上的轻节点（含有以太坊区块）逐个以太坊块进行更新（因为NEAR上的gas费便宜），而以太坊上的轻节点（含有NEAR区块）更新频率是可配置的，受限于经济性（目前是12到16小时更新一次）。

连接器(Connector) — 连接器是种智能合约，负责特定资产类型的跨链管理逻辑。与轻节点类似，它们成对出现。一个运行于以太坊，另一个运行于NEAR。例如，有一对“ETH连接器”，负责在链之间转移ETH资产。还有一对“ERC-20连接器”， 负责转移ERC-20通证。其他人可以根据他们的需要，开发一个“NFT连接器”、“预测市场结果连接器”、“DAO投票结果连接器”等。只要有对应的连接器，任何资产或数据都可以通过彩虹桥移动!
把组件合起来
要理解这些组件是如何组织起来，使得我可以无需许可的，去信任的在以太坊和NEAR之间转移通证，让我们重新过一遍开头的例子：

 	使用 彩虹桥UI, 我发起了从以太坊到NEAR的20个DAI的转移。
 	当我在MetaMask上确认了前两笔交易(approve 和 transfer)，彩虹桥与以太坊上的ERC-20 连接器通信 (因为DAI是一个ERC-20通证)，连接器将这20枚DAI锁定在它的保管库中。至此，这笔DAI就不再在以太坊上流通了。
 	基于我这笔交易区块的区块头数据，彩虹桥UI 计算出一个密码学“证明” 表明我确实锁定了20枚DAI。
 	接下来我要请求NEAR网络基于刚才以太坊上活动而创建一些DAI，就先要等待中继发送大概20个以太坊区块头给运行在NEAR上的轻节点。这是为了安全的考虑，跟你充值给虚拟币交易所时需要等一些确认一样。
 	之后，彩虹桥UI就允许我们执行流程中的第二步 — 让NEAR上的ERC-20 连接器为你在NEAR链上创建20枚新的DAI。
 	当向ERC-20 连接器发起这个请求时，我们要提供那个早先收到的密码学“证明”，以证明我们确实在以太坊上锁定了20枚DAI。
 	NEAR上的ERC-20 连接器接下来查找NEAR上轻节点的以太坊区块头，然后创建一个独立计算出来的密码学证明。
 	如果我们提供的证明匹配上连接器算出的那个，它就知道20枚DAI已经被安全的被我锁定在以太坊上了！ 接下来就在NEAR上创建20个新的DAI，并转账给我的钱包。

当我要把DAI转移回以太坊，流程反转。不过我们不是在NEAR上锁定那20枚DAI，而是销毁它，也叫做燃烧。然后我们提供燃烧的证明给运行于以太坊上的连接器。通过访问运行于以太坊上的轻节点里的NEAR区块数据，连接器验证那个证明，随后从保管库里释放20枚DAI并发送给我我的钱包!

简而言之，这就是彩虹桥的工作机制！它是密码学领域唯一按这种方式工作的以太坊桥。目前支持无需许可的在以太坊和NEAR之间转移资产，不久之后，极光链（Aurora）也会加入。而这一切都无需信任任何第三方. 非常的酷！
其他说明
这里有些有关以上内容的有趣的说明：

 	因为NEAR到以太坊中继每16个小时才发送一次NEAR区块头信息给以太坊上的轻节点，造成了该方向跨链在第一步和第二步之间有16个小时的延迟。 （还记得吧，这是因为以太坊上的gas费太高，每个块都更新轻节点过于昂贵。）有一些致力于降低该延迟的方案，团队正在积极研究中。
 	NEAR上的轻节点本来是要存储以太坊的所有历史区块。但是为了让存储可控，轻节点会清除大概两周之前的区块。这意味着，如果你发起一笔从以太坊到NEAR的转账，然后在第一步和第二步之间出去度假了三个星期，你将无法完成这笔转账，因为用来检验你的“证明”的那些NEAR上的以太坊数据已经被移除了！
 	NEAR区块头设计上有个有趣的特性，就是仅靠一个区块头，就能计算过去一大段时间里的区块历史。所以理论上，以太坊上的轻节点只需要一个NEAR区块；然而，我们仍然保留多个区块，因为进行那种计算消耗的gas费是一种对资源的纯粹浪费。
 	彩虹桥的开发团队正是极光，NEAR上的EVM，的开发团队。因为这个团队已经独立出去形成自己的实体，彩虹桥会由该实体负责运维管理和未来发展。
 	极光团队正致力于开发彩虹桥的“自动终结”特性。这样你就无需手动发起跨链转账的第二步了。这将给用户带来极大的便利（意味着你讲可以发起一笔以太坊到NEAR的转账，然后去度假！）
 	以太坊和极光之间的跨链转账是由极光桥负责的，它使用与彩虹桥相同的核心技术，增加了NEAR/极光之间转账的隐藏步骤处理。
 	彩虹桥和极光桥在用户界面和使用体验上有所不同。但是未来的某个时候，它们会趋于一致。

尽管简化了一些技术细节，你现在也对彩虹桥的运行机制有了一个基础的认识!

要深度了解彩虹桥，你可以阅读该文档。要跟进极光的所有相关信息，请关注极光的推特！

### NEAR 🤝 以太坊

今天，以太坊是区块链领域排名第一的智能合约平台，大多数智能合约和去中心化应用程序 (dApps) 都基于其区块链。 与以太坊一样，市场上还有其他几个智能合约平台。

然而，只是因为以太坊是智能合约和去中心化金融(DeFi)中排名第一的平台的話，并不意味着它没有问题。 以太坊存在一个明显的问题，那就是突出的扩容问题。它目前是无法有效支持大规模应用。

这就是 NEAR 协议出场的时候。NEAR 的与众不同之处是它使用基于分片的权益证明共识机制（Proof-of-Stake）。 在我们深入了解之前，让我们先认识一下以太坊和 NEAR。
什么是以太坊？
如果你在其网站上查看以太坊的定义，它是这样说的——

“以太坊是一种技术，它是数字货币、全球支付和应用程序的所在地。该社区已经建立了蓬勃发展的数字经济，为创作者提供了大胆的在线赚钱新方式等等。它对所有人开放，无论您身在何处。”

以太坊由 Vitalik Buterin 于 2015 年创立，已稳固地成为市值第二大的加密货币，仅次于比特币。以太坊建立在比特币的区块链之上，使其不仅仅是另一种允许用户在没有任何第三方干预的情况下发送或接收价值的加密货币。

以太坊通过用数千个节点替换中央服务器来确保去中心化，确保平台一直在线且不受任何第三方影响。智能合约也是以太坊生态系统不可或缺的一部分，由于该平台同时支持去中心化应用程序和智能合约，因此对开发者和用户都极具吸引力。

以太坊现在正在转向以太坊 2.0 (或者称为 Serenity）。升级将明显提高区块链的扩容能力、效率和以太坊区块链的速度。此外，升级将使以太坊能够降低gas成本并处理更多交易，在不影响安全性的情况下提高区块链的扩容能力。

升级还将使以太坊转向权益证明共识机制。通过PoS可以看做是所有验证节点是被算法选择，以向平台提供安全性。验证节点将通过锁定他们的 ETH 来保护平台。任何违背平台利益的验证节点都将削减其权益份额，确保平台的安全。
什么是 NEAR 协议？
NEAR 协议诞生于 2018 年夏天。作为一个去中心化的开发平台，该协议旨在为去中心化应用程序创造完美的环境，专注于应对其他平台的智能合约和 dApp 领域中的缺点，主要包括低速、低吞吐量以及与其他链的兼容性差的问题。

NEAR 运行在 NEAR 协议之上，这是一种权益证明 (PoS) 区块链，结合了多项特色和创新，為用户和开发人员降低成本及提高的可扩展性。此外，NEAR 采用独特的“分片”方法。

它还引入了 2019 年提出的名为“Doomslug”的区块生成机制。 Doomslug 采用了实用（即Doomslug）确定性，确保区块在几秒钟内获得确定性。

该协议基于与比特币相同的技术，而且结合了数据库分片等特色。 NEAR 协议是从头开始构建的，而且是最终用户和开发人员最轻易进入使用的网络，同时还确保了可扩展性和安全性。

大多数可扩展的区块链选择中心化的计算资源，将其限制在高端硬件上，这可以暂时提高其吞吐量，而 NEAR 允许平台以完全去中心化的方式进行线性扩展，最多可处理数十亿笔交易。

NEAR 由 NEAR 社区贡献者(the NEAR collective)开发，这是一个由开发人员和研究人员组成的社区，合作构建该项目。 NEAR 的一些重要特性是

 	NEAR 是一个分片系统，允许无限的可扩展性。
 	NEAR 是一种易于使用的协议，允许开发人员轻松快速地构建应用程序。
 	NEAR 不是侧链，而是 Layer-1 协议。
 	使用 NEAR 创建的 dApp 运行在底层 NEAR 层之上。

什么是 NEAR Collective？
NEAR Collective由不断致力于改进 NEAR 协议的个人组织和其他贡献者组成。其致力于为 NEAR 网络编写初始代码和实现等项目。NEAR 是完全去中心化的，独立运行，不能被关闭或操纵，即使是那些构建它的人。

NEAR Collective 拥有 NEAR 基金会等成员。NEAR 基金会是一个非营利组织，致力于围绕 NEAR 区块链创建一个充满活力的生态系统。它有助于协调治理活动和发展。NEAR Collective有多个项目，NEAR 区块链只是该组织支持的几个项目之一。
为什么像 NEAR 这样的区块链是必要的？
要理解这一点，我们必须首先了解区块链技术的演变。区块链可以分为三个阶段或世代。第一代区块链旨在成为一种简单的支付机制。比特币是第一代区块链的一个例子，它已经在加密领域稳固地确立了自己作为第一大平台的地位。然而，第一代区块链在复杂交易方面存在局限性。

第二代区块链平台随着以太坊和智能合约的概念脱颖而出，允许开发人员使能够透过智能合约对复杂的交易进行编程及创建 dApp。但是第二代区块链存在严重的可扩展性问题。例如，以太坊每秒只能处理大约 25 笔交易，将这个数字与 Visa 或 PayPal 等主流平台进行比较，您可以看到以太坊落后多远。

以太坊试图通过实施 Plasma 协议等第2层解决方案来解决其可扩展性问题，创建一个与主链协同运行的附加层。然而，第2层解决方案仍然没有达到预期的效果。

这将我们带到了第三代区块链 NEAR。NEAR摒弃了网络上的每个节点都必须运行整个代码的想法，因为团队认为那样会增加瓶颈。相反，区块链通过使用分片技术来解决可扩展性问题，允许区块链扩展网络容量。与使用第2层解决方案的第二代区块链不同，分片是第1层解决方案。
什么是分片？
在我们继续之前，让我们了解分片。有时系统必须处理大量数据。这会影响系统的性能，降低吞吐量并影响系统的性能。分片通过对数据进行水平分区来克服这一点，使其更小、更易于管理，更重要的是，处理速度更快。
NEAR和以太坊：NEAR和以太坊的工作原理？
以太坊
以太坊不仅仅是一个进行交易的金融平台；它还支持去中心分应用程式和智能合约。以太坊基于区块链技术，使用一个公共账本来存储所有经过验证的交易。任何想要查看交易的人都可以访问这些交易，确保完全透明，同时确保存储在区块链中的数据不会被更改或操纵。

以太坊的区块链类似于比特币区块链，充当一个公共账本，记录所有交易和智能合约历史。全球志愿者存储整个以太坊区块链的副本，使区块链完全分散。每次在区块链上发生交易或智能合约等行为时，全球所有节点都会对其进行处理，确保遵守区块链规则。

所有节点都是连接的，并且遵循关于智能合约和交易的相同规则集。以太坊的节点还跟踪所有应用程序、用户余额和智能合约代码的状态，确保所有信息始终是最新的。

借助 Solidity，开发人员可以编写智能合约来管理区块链上的交易及其结果。智能合约不同于传统合约，因为它们确保合同条款得到履行。此外，当一组预定条件得到满足时，它们会自动执行事务，而不需要任何第三方的介入。
NEAR
NEAR使用区块链技术，就像以太坊和卡尔达诺等其他区块链一样。NEAR充当基础区块链，应用程序可以在其上构建和部署。它使用了一种被称为Nightshade的共识机制来帮助它实现高吞吐量。NEAR的一致性机制假设来自所有shard的事务组合成一个块，这就是为什么每个shard提交每个块的一个片段。这个片段称为块。

验证者是被随机选择的，然后在多个分片链上处理交易，提高了NEAR协议的交易量。所有分块被处理后，会存储在区块链上以完成交易。

NEAR并不是基于每个节点都必须处理整个代码的想法来运行的。相反，它通过使用分片来解决可扩展性问题。利用分片，数据被水平分割，使得管理更容易，处理过程更快。
NEAR 和以太坊：共识机制
以太坊
目前，以太坊使用工作量证明 (PoW) 共识机制，但随着以太坊 2.0 的出现，该平台将转向权益证明(PoS)共识机制。权益证明将通过 Casper 协议实行，创建一个去信任的生态系统。在完全切换到权益证明机制之前，以太坊将实施混合 PoW-PoS 的共识机制。

让我们了解工作量证明和权益证明的工作原理。工作量证明要求矿工相互竞争，利用大量算力解决复杂的数学问题来验证交易。一旦交易得到验证，矿工就会得到相对应的奖励。以太坊正在转向权益证明机制，因为工作量证明存在几个问题，例如高能耗。这个转换同时解决以太坊的可扩展性问题。

在权益证明共识机制中，验证者质押他们的 ETH，然后随机选择他们来证明一个区块。选定的验证者产生一个区块，而其他验证者需要证明他们已经看到了该区块。一旦他们验证了区块，它就会被添加到区块链中，验证者就会得到奖励。因此，验证者会因产生和证明区块而获得奖励。
NEAR
NEAR 协议已实施 Nightshade 分片作为其权益证明共识机制。我们已经讨论过什么是分片，所以我们可以跳过它。然而，今天使用的分片方法有其问题，例如分片链和信标链中的分叉选择规则需要以不同的方式构建和测试。

但是，Nightshade 将系统视为单个区块链，每个区块都包含所有分片的交易。然而，参与者不需要下载完整的状态，而是只维护作为他们验证交易的分片一部分的状态。创建每个区块中所有交易的列表，然后将交易列表拆分为多个碎块，每个碎块中的分片会被分配另一个分片。

验证者是 NEAR 协议的关键部分，保持对协议的共识。因此，他们需要一直保持系统在最新状态，同时保持服务器在线。

 	每个时期都会根据他们的权益选择验证者。
 	验证者可以通过重新抵押他们的通证和奖励来再次参加。
 	验证者可以通过两种方式加强他们的权益，购买通证或通过权益委托借入通证。

NEAR 和以太坊：通证
以太坊的原生代币 Ether 激励程序员继续运行区块链协议，因为为以太坊提供动力的硬件价格昂贵且消耗大量电力。因此，矿工和程序员都因利用他们的资源并保持以太坊生态系统的安全和运行而获得以太币奖励。

开发人员还使用以太币进行支付，以便他们可以在以太坊区块链上启动智能合约或去中心化应用程序。它还用于访问智能合约。

NEAR 的原生代币,NEAR 代币用于激励网络上的验证者。 令牌还能驱动区块链上的交易和智能合约。 由于 NEAR 是一个社区治理平台，代币持有者在NEAR平台的治理中发挥着重要作用，对NEAR平台上的潜在变化进行投票。
以太坊和 NEAR 协议的项目
在去中心化应用程序和去中心化金融方面，以太坊处于领先地位，在其区块链上运行着 3000 多个 dApp。 以太坊的大多数项目都集中在def上，扩展加密货币的用途，以满足更复杂的金融用途。

以太坊区块链上的一些顶级项目是

 	Uniswap
 	MakerDAO
 	链环 (Chainlink)
 	Aave

尽管 NEAR 的主网是在一年多前推出的，但只有数个平台正在其上构建。 运用NEAR 协议的一些项目有:

 	Mintbase – 一个致力于简化 NFT 发行和销售的平台，同时也使整个过程变得便宜。
 	Flux – Flux 是一个去中心化的开放市场协议。 它于 2020 年在 NEAR 协议上启动。
 	Paras – Paras 是一个 NFT 市场，专注于精选艺术家创作的作品。

NEAR 资助计划目前由 NEAR 基金会运营，支持促进 NEAR 生态系统发展的项目。
极光(Aurora)在NEAR协议上的应用
极光(Aurora)也在NEAR 协议上推出，提供以太坊第 2 层体验，是一种允许开发人员接触其他市场的解决方案，极光(Aurora)利用 NEAR 协议的特色，例如 gas 费用补偿和分片。它在两个关键组件上运行，分別是 Aurora Bridge 和 Aurora Engine。

极光(Aurora)带来的一些改进包括:

 	每秒处理数千笔交易的能力，是以太坊的 50 倍。
 	区块确定性的时间为 2 秒，而以太坊的单区块确定性的时间为 13 秒。快速的确定性还减少了抢先交易攻击(Front-Running Attacks)。
 	面向未来的生态系统增长，NEAR 协议的分片方法允许水平 EVM 扩展和多个分片之间的异步通信。
 	极光(Aurora)的费用比以太坊低 1000 倍。举个例子，在 Aurora 上转移 ERC-20 代币的成本不到 0.01 美元，而在以太坊上，它的成本约为 5.40 美元。
 	极光通过 NEAR 协议与以太坊进行兼容。

极光 为以太坊生态系统面临的挑战提供了解决方案，同时保留了智能合约和前端代码。
NEAR 协议的优势
与以太坊和比特币等平台相比，NEAR的分片解决方案具有巨大优势，解决了以太坊网络可扩展性低、瓶颈频发的问题。通过将协议分片，NEAR的创始人将区块链的代码分解成块，并在并行节点上运行。这使得整个代码处理得很快，并且由于这种分割代码的能力，几乎不存在可伸缩性问题。

NEAR 协议有几个独特的功能，使其成为对用户和验证者有吸引力的提议。

 	用户体验（UX）灵活，并且访问Near平台上的服务有简单的入门流程
 	由于 NEAR 的分片协议，验证者无需下载复杂的软件即可加入平台。然后他们可以通过验证网络上的交易来赚取代币。
 	NEAR 允许企业为其用户自定义权限。随着市场的稳步增长，开发商也获得了不断增长的客户群。

NEAR 协议的未来之路
随着以太坊到 NEAR 桥（也称为彩虹桥）的推出，用户可以将他们的以太坊 ERC-20 通证桥接到 NEAR，并开始在 NEAR 的去中心化应用生态系统中使用它们。 这个发展是向着创始团队的愿景在平台的可使用性上迈出一大步。

NEAR 也致力于实行对以太坊虚拟机 (EVM)的支持。 此过程完成后，开发人员可以以最少的改动在 NEAR 上重新部署他们的 dApp，而且能够启动跨链。

NEAR 协议宣布与 Chainlink 建立合作伙伴关系，同时推出彩虹桥，允许 NEAR 和以太坊之间的交流。
结论
NEAR协议已经展示出诸多的可能性，它利用分片来解决第二代区块链的可扩展性的问题。此外，NEAR在没有放弃平台安全性的情况下明显地提高了吞吐量。

由于NEAR Collective的存在，数百名区块链工程师和开发人员可以全天候地努力改进协议。 NEAR 也推出了其主网，而该网络已准备好支持 dApps 和其他服务。 NEAR 集中于确保 NEAR 平台对验证者、最终用户和开发人员都是容易使用的，因此已成为智能合约平台领域的一股力量。

至于以太坊，由于其令人羡慕的开发者社区以及蓬勃发展的 DeFi 和 NFT 生态系统，以太坊保住了其宝座的地位。 这两种协议都为开发人员构建未来的去中心化生态系统提供了一个绝佳的平台。

原文链接：https://learnnear.club/near-ethereum

### NEAR 协议上排名前三的优秀NFT项目

DeFi 的成长使NFT成为主流的焦点，而NFT的成长也使得一些问题成为焦点。 以太坊垄断了这个NFT领域，在以太坊区块链上创建了许多NFT。所以在世界上最受欢迎的平台之一上创建NFT究竟有什么问题呢？ 当然就是昂贵的gas费用问题。以太坊目前面对的一大问题就是在gas费用，每次交易的gas费用可能会高达数百美元，这样会使到以太坊的使用变得非常不切实际。

那么NFT和NFT项目在平台方面会有哪些选择呢？(除了以太坊外)还有哪些选择？ NEAR协议在其平台上有几个重要项目，而且经常被吹捧为以太坊杀手。 NEAR 协议是一个具扩展性的区块链，可以简化和加速 dApp 的开发。目前，在NEAR 区块链上有 19 个用于NFT交换的去中心化平台。 NEAR 协议与以太坊比较是具有一些明显的优势，因为它比以太坊快很多，而且交易成本接近零，这样使NEAR可以成为NFT交易的理想平台。
什么是NEAR协议？
NEAR 协议是一个在2018年创建的去中心化开发平台。它的目的是为去中心化应用程序创建一个完美的运作环境，同时关注该领域中其他平台的明显缺点。 NEAR是在NEAR协议上运行，NEAR是一种权益证明 (PoS) 区块链，通过实施多项功能来降低成本及提高可扩展性。

NEAR 还通过引入新的区块生成机制“Doomslug”，实现了与众不同的分片方法。 Doomslug 于 2019 年提出，并引入了实用确定性或“Doomslug”确定性，允许区块在只需几秒钟内获得确定性。

NEAR 的功能与支持比特币的技术相同，是开发人员和最终用户最容易访问的网络。与 NEAR 不同，大部分的区块链采用中心化的处理方式使其需要在高端硬件上运行。 通过 NEAR，平台可以以完全去中心化的方式进行线性扩展至数十亿笔交易。
NEAR 的一些重要功能是什么？
NEAR 由一个名为 NEAR Collective 的开发人员和研究人员的小型社区开发。一些基本功能是

 	NEAR 是一种易于使用的协议，可以允许开发人员快速和容易地构建应用程序。
 	NEAR 允许无限的可扩展性。
 	NEAR 不是侧链，而是第 1 层协议。
 	在 NEAR 上创建的所有 dApp 都在NEAR层上运行。

The NEAR Collective
正如之前提及的，NEAR是由开发人员和研究人员的社区开发的。 他们是 The NEAR Collective的一部分。 The NEAR Collective是由不断努力确保 NEAR 协议的日常运作并不断改进它的组织和个人贡献者组成。

The NEAR Collective编写 NEAR 网络的初始代码及把NEAR实现出来。 虽然NEAR Collective确保协议的运作，但 NEAR 是完全去中心化的并独立运作。即使是开发它的团队也无法关闭它。

The NEAR Collective由 NEAR 基金会组成；一个非营利组织，专注于围绕 NEAR 区块链创建一个繁荣的生态系统。 NEAR 协议只是 NEAR Collective下的几个项目的其中一个。
NEAR 协议和 NFT
NEAR 协议是 NFT 的完美平台，因为它比以太坊有很多优势。 该协议明显快于以太坊。以太坊的Gas费用也高得多，而 NEAR 允许以微不足道的费用处理交易。这些因素使 NEAR 成为NFT交易的理想选择。

正如之前提及的，在 NEAR 区块链上已经创建了几个 NFT 项目。不过，在看项目之前，让我们先简单了解一下 NFT 的概念。
非同质化的意思
同质化资产是一种可以另一种相同资产进行交换的资产。比特币是同质化资产的一个很好的例子，这意味着你可以毫无问题地将一个比特币换成另一个比特币。 另一方面，非同质化资产是无法交换的独特资产。同质化资产的一个例子可以是独特的画作或限量版的收藏品。

非同质化资产具有使其与其他资产区别开来的独特属性。非同质化代币是基于非同质化资产，是一个运用了区块链技术的独特数字资产。
什么是 NFT？
NFT 是独特的数字资产，其识别信息的记录在智能合约上。智能合约上的信息使 NFT 独一无二。 比特币等同质化资产可以交换，这意味着您可以毫无障碍地发送或接收比特币。同质化资产也是可分割的，允许您发送比较小的数量。 非同质化资产是不可分割的。例如，您不能将一幅画的一部分或一张票据的一部分寄给某人。

NFT 是数字资产的所有权的数字证书。 NFT 是一种用于保护数字资产的智能合约。 完成资料写入后，它会以通证(ERC-721)的形式发布到区块链上。任何东西都可以变成 NFT，可以是最受欢迎的视频、GIF 或 JPEG。




	

	
	
		
			
				以下哪个是 NFT？
			
		

		
					

		
			
			
			
			比特币
		
			
			法定货币
		
			
			数字收藏品
		
			
			nDAI通证
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR协议上的NFT项目
目前，NEAR 上有几个 NFT 平台，让我们来看看平台上一些最流行的NFT项目。
Mintbase
Mintbase 于2018年开始，由 Nate Geier 和 Calorine Wend 创建。 Nate Geier 是公司的首席执行官，而 Caroline 是首席运营官，利用她在管理和业务发展上的专业知识。 Mintbase 在 2020 年的种子轮融资中成功筹集了 100 万美元。 Sino Global 领投了这轮融资，而其他跟投的风险投资公司还包括 Block Oracle Capital、D1 Ventures 和其他天使投资人。



一个数字区块链平台可以用于发行和交换非同质化通证，而Mintbase上的通证不同于其他常见的数字艺术品通证。 Mintbase平台允许用户创建和出售由 NFT代表的资产。用户可以将不同的数字资产铸造为NFT。这些资产的范围可以从活动门票到加密艺术以及在两者之间的一切东西。

Mintbase 差不多可以允许任何可以访问互联网的人制作 NFT，并让他们可以在其市场或OpenSea等NFT市场上出售。 铸币者可以创建智能合约并限制所铸的通证的可转让性，这样有助于防止欺诈或非法转移独特物品。 Mintbase 专注于创造独特的 NFT 创建体验，这正是为什么如之前所提及，它是支持不同的数字资产。这与只专注于一种特定NFT类别的竞争平台完全相反。
为什么 Mintbase切换到 NEAR？
所以究竟为什么要从以太坊切换到NEAR？ 答案是Gas费用。因为以太坊的Gas费用开始变得荒谬地贵。要在 Mintbase 上铸造 NFT，用户首先需要创建一个数字商店。 在这过程用户必须创建智能合约及向以太坊支付Gas费用。最初，相关的费用是很低，用户能够快速地部署数字商店。 不过随着以太坊网络的拥堵情况的加剧，费用也开始越来越高，开设数字商店的成本更可以高达数百美元。 由于成本变得如此之高，使到Mintbase也告诉其用户在部署数字商店之前需要等待 Gas费用下降。以太坊很快就在购买、出售或创建NFT等方面变得难以为继。

Mintbase 认为 NEAR 是一个比以太坊更好的平台，由于有更高效的合约执行模型，使得其Gas费用明显降低。 NEAR还使用 Nightshade，一种动态的分片方法。不过，Mintbase切换到NEAR的原因还有以下其他几个。

 	在NEAR平台上使用Rust或AssemblyScript编写智能合约，使开发人员可以轻鬆地编写代码
 	NEAR在合约和账户上具有人类可阅读的地址
 	由于有NEAR Drops，开发人员可以快速地加入用户。他们可以为他们的NEAR账户付款及发送NEAR通证
 	由于有ETH-NEAR彩虹桥，开发人员和用户可以快速移动资产
 	其他 DeFi 平台如 Aave 和 Balancer 也在 NEAR 上，这将使未来的任何整合变得容易。




	

	
	
		
			
				为什么 Mintbase切换到NEAR?
			
		

		
					

		
			
			
			
			高Gas费用
		
			
			NEAR 是一个更好的平台
		
			
			开发人员可以更快地移动资产
		
			
			上述所有的
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras 的创建愿景是为陈旧的传统收藏卡提供解决方案。 该平台透过快速且廉价的交易通过区块链验证所有权。该平台专注于创建加密原生集合(collections)，这些集合可以进一步多元化为更突出的媒体。



Paras 是一个建立在NEAR上的一站式数字艺术卡片市场。该平台可以验证所有权并让用户可以提供购买和铸造通证。 它提供快速且廉价的交易，并且通过提供集合而不是单一的作品使自己区别于其他市场。该平台的特性还有：  Paras可以确保收藏品不会随着时间的推移而有所消耗磨损，从而减轻收藏家的维护负担。 该平台解决了障碍，让艺术家和收藏家可以轻鬆进入数字收藏品的市场。由于有了NEAR协议，Paras可以减低艺术家出售卡片中所需的成本  Paras正在为未来的艺术家、游戏玩家和创作者开发垂直的数字艺术卡(DAC)，让艺术家能够创建一个与主题或特定知识相关联的集合。 通过这种方式，Paras中的数字艺术卡片可以充满了故事和背景。

Paras 能够使用专业的方法并创建NFT社区和体验。 Paras 通过选择艺术家和格式来确保一致性和质量。 艺术家需获得批准后才可以在Paras上创建新卡，每週获得批准的新艺术家数量会被限制为30位。艺术品还需要符合标准的 64:89 宽高比例。




	

	
	
		
			
				什么是Paras？
			
		

		
					

		
			
			
			
			一个一站式的数字艺术卡市场
		
			
			智能合约平台
		
			
			一种编程语言
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






自平台推出以来，Paras上的艺术家已经获得了超过 25,000 美元的收入，该平台能够从700多笔交易中促成价值超过 35,000 美元的交易量。 平台拥有80多位活跃的收藏家和超过70位的艺术家。以便宜的铸造费用让数字艺术家的进入门槛非常低，而且艺术家可以在一个不必担心铸造成本的情况下铸造卡片。
为什么 NEAR 非常适合 Paras？
由于对以太坊空间的需求，推高了平台的成本，新的 NFT 创建者正在寻找其他替代平台和解决方案。 NEAR 正在与以太坊合作开发平台之间可互操作的解决方案。 NEAR 上的交易成本仅仅为几美分，有时候甚至更低。 NEAR 钱包是非常高效，而且交易几乎可以即时完成。彩虹桥确保 NEAR 将与基于以太坊上的资产的可互操作。
Hip Hop Heads
Hip Hop Heads标志着美国文化的支柱已进入加密领域。 共同合作的艺术系列会以 The Source Magazine标志性的 The Last Word 的创作者 Andre LeRoy Davis 的作品为特色，还有以 The Source Magazine的共同所有者之一 Ed Young 的背景动画为特色。

Hip Hop Heads 诞生于 Universal Hip Hop 博物馆、The NEAR Protocol 和 Ed Young的协同合作。 他们共同决定创建一个 NFT 系列以 70 年代开始至今的艺术家为特色。这个名为 NFT.HipHop Heads 的系列将展出 47 位最具份量的说唱艺术家， 这样不但是向这些艺术家致敬，还将纪念嘻哈时代已经踏入第47年。该项目将最新的科技发展与说唱的起源重新联繫起来。



每个插图都将作为47系列而存在，以表示Hip Hop时代的47年。每个 Hip Hop Head 的第一个版本都是根据艺术家在 Hip Hop 历史上的位置来命名。 安德烈·勒罗伊·戴维斯 (Andre LeRoy Davis) 透过创作插画展示了每位艺术家的重要性。 背景动画的代码是Hip Hop历史上最重要的数字的结果，透过这些数字展示了 Hip Hop 时代在47年的进程中的不同时刻。 NFT 系列将会每天在其网站上进行拍卖直至 7 月 24 日。
为什么Hip Hop Heads会选择NEAR?
NEAR协议允许大众可以更容易获得 Hip Hop Heads的收藏品。如前所述，那些收藏品将会每天拍卖直至 7月 24 日，并可通过信用卡购买。 这就使得NEAR 可以让项目更切实可行。拍卖市场还也聚焦于NEAR协议的特点，例如有一个与web-2相似的熟悉且友好的界面、简单而且相对便宜的NFT铸造成本以及对终端用户的可访问性。

由于用户可以使用信用卡购买NFT，所以市场可以提供一种简单的NFT购买方式，不需任何复杂的步骤让用户可以跳过之前在购买上遇到的障碍。 NEAR协议上的NFT版税会被写入NFT代码，这样的话，即使NFT转移到另一个市场，创作者也可以从二次的销售中获得版税。 由于有NEAR的合约级NFT标准，NEAR 让艺术家和创作者掌控他们的NFT，让他们从自己的艺术品中获得利益。
总结
NEAR使到构建 和部署dApp比任何其他区块链协议更容易、更快、更便宜，而且NEAR是加密领域最有前景的项目之一。 它解决了以太坊项目面临的几个问题，例如昂贵的Gas费用和缓慢的处理速度。另外，由于NEAR的分片解决方案，让它还具有几个优于以太坊区块链的优势。

NEAR协议已经显示出明显的前景，利用分片来解决其他区块链面临的问题。由于这种方法，NEAR能够在不影响安全性下提高吞吐量。 The NEAR Collective 让工程师和开发人员可以持续的在NEAR协议上工作。

原文链接：https://learnnear.club/top-3-nft-projects-on-the-near-protocol/

### NEAR Protocol 和 Solana

今天，让我们来认识下世界上最有前途的两个智能合约平台- Near Protocol和Solana。尽管目前Ethereum依旧主导这个市场 但事实是它缺乏可扩展性和高昂的费用迫使大多数开发者寻找可行的替代方案。Near 和 Solana已经成为前两名的领跑者。
1.什么是 Solana?
Solana 成立于2017年，创始人是曾在 DropBox 工作过的 Yakovenko, Eric Williams 以及作为CTO的 Greg Fritzgerald， 创立Solana主要是解决比特币和以太坊目前存在的问题。该项目吸引了来自 Multicoin Capital、 Foundation Capital、 SLOW Capital、 CMCC Global、 Abstract Ventures 等公司的投资。



Solana区块链的特点

 	每秒50,000次交易和0.4秒的区块产生时间
 	该系统在40 gigabit 网络上每秒可提供2840万次交易
 	Solana使用历史证明（Proof-of-History）共识算法

历史证明算法是如何运作的？
在一个去中心化的网络中，共识是必不可少的。比特币使用工作证明(proof-of-work，PoW)共识来处理共识。虽然该方法非常安全， 但是很难不忽视它最重要的问题——缺乏可伸缩性。别忘了比特币每秒只能进行7次交易。

Solana使用历史证明算法，通过创造历史记录来证明某一事件发生在某一特定时刻。以下几点需要记住:

 	该算法使用了一个高频可验证延迟函数，该函数需要一定数量的连续步骤来完成
 	在网络中计时的交易或事件将被指定为唯一的散列计数，可以进行公开验证
 	计数允许网络准确地知道交易或事件发生的时间
 	每个节点都有一个用于跟踪网络时间和事件顺序的加密时钟

基于历史证明( PoH)，当使用 GPU 运行时，Solana 网络每秒支持50,000个交易。
什么是Solana Cluster?
cluster是一组独立拥有的计算机共同工作，可以被视为一个单一的系统。Cluster的主要特点如下:

 	它们有助于验证未受信任的输出及用户提交的程序
 	维护用户进行的任何交易或事件的记录
 	它保留着有关哪些计算机做了有意义的工作的纪录来维持网络运行
 	它保留着有关真实世界中资产的拥有权的纪录

以下哪项使用了分片？

 	Solana
 	Near protocol
 	Both

在 Solana 中编程
Solana 中的智能合约是用 Rust 或 c 编写的，并编译成伯克利包过滤器(BPF)。由于有更多的工具可用，建议您在 Rust 中编写代码。初学者应该使用 Anchor 框架编写程序代码，该框架可以简化执行。

Solana 类似于Linuc操作系统有的文件有一个独特的帐户模型。它们可以保存任何任意数据，还包含关于如何访问它们的元数据。请记住，这些帐户有一个固定的大小，不能调整大小。

Solana目前的编程模型受制于固定的帐户大小，可能会迫使你将应用程序的逻辑部份转移到链下或修改功能以提高效率。

以下哪项是Solana的组成部分？

 	 Cluster
 	 Collective
 	 Parachain

合约例子

#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}

合约解释

 	对于每个调用，要访问的所有帐户都用 #[derive(Accounts)]在结构上加注释
 	这些函数初始化所有者和 Purchase 的帐户数据。这使得任何人都可以购买更多的代币
 	临时数据被传递到函数参数中。这些参数位于 initialize 和 purchase 函数内部。这也包括保存交易所需帐户的上下文
 	合约的状态位于 ContentRecord 结构中。使用 #[account] 注解，以表明它代表了账户的数据布局

2.什么是 NEAR 协议？
NEAR 协议诞生于 2018 年夏天。 该协议旨在为去中心化应用程序创造完美的环境，它可以提供更高速、更高吞吐量以及与其他链有更好的兼容性。NEAR 有一个独特的分片技术， 它还引入了在 2019 年提出的名为"Doomslug"的区块生成机制。 Doomslug 允许实用确定性或"Doomslug"确定性，确保区块在几秒钟内获得确定性。

NEAR 协议是由 NEAR Collective 开发的，这是一个由开发人员和研究人员合作构建项目的社区。以下是NEAR 的一些关键特性:

 	NEAR 是一个分片系统，它支持无限的可伸缩性
 	NEAR 是一种易于使用的协议，允许开发人员轻松快速地构建应用程序
 	NEAR 不是一个侧链，而是一个Layer-1协议
 	使用 NEAR 创建的 dApps 运行在底层 NEAR 层之上

什么是 NEAR Collective
NEAR Collective由不断致力于改进 NEAR 协议的个人组织和其他贡献者组成。 该Collective致力于为 NEAR 网络编写初始代码和進行实践等项目。 NEAR 是完全去中心化的，独立运行，不能被关闭或操纵，即使是那些构建它的人。

这是一个专注于围绕 NEAR 区块链创建一个充满活力的生态系统的非营利组织。它有助于协调治理活动和开发。NEAR Collective有几个项目， NEAR 区块链只是几个项目之一。

NEAR 共识机制 在 NEAR 上实现的共识制称为Nightshade。Nightshade 将系统视为单个区块链。每个区块中所有交易的列表会被拆分为多个碎块，每个碎块中会有一个分片。所有碎块可以组成一个区块，块只可以被维持它的分片状态的节点进行验证。

说到验证，NEAR 的一个关键组件是验证者。这些验证者负责维持在协议内的共识。验证者是专门的节点，它需要保持服务器一直在线，同时保持系统在最新状态。

关于网络验证者，您必须牢记以下几点。

 	每个epoch都会确定它的网络验证者，并根据它们的抵押选择它们
 	已获选的验证者可以通过重新抵押他们的通证和累积的奖励来再次参加。
 	潜在的验证者必须保证他们的抵押保持在一个动态确定的值之上
 	验证者可以使用两种方法来加强他们的权益份额-自己购买通证或通过借用其他人的抵押委托。
 	您得到的回报与您的抵押成正比-抵押越多，奖励越多

这一共识是基于最重权重链共识。这意味着，一旦块生成器发布了一个块，它们将收集验证者节点的签名。然后，块的权重是该块中包含签名的所有签名者的累积。该链的权重是各块权重之和。另外，共识使用了一个确定性小工具，该工具引入了额外的”删除条件”以提高链的安全性。

Doomslug 是哪个协议的区块生成机制?

 	 NEAR 协议
 	 Solana

Aurora and NEAR 协议
Aurora 也在NEAR 协议上推出，提供以太坊第 2 层体验，Aurora 改进 NEAR 的一些方法是:

 	它有助于将吞吐量提高到每秒数千个交易
 	区块的确定性时间为2秒
 	未来生态系统的增长
 	低交易费，比以太坊低1000倍
 	与以太坊永远保持兼容性

代码示例

use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}


合约解释

 	该合约由 ContentTracker 中的 #[near_bindgen] 定义，它类似于 Solidity 中的构造函数，并在部署合约时调用
 	purchase函数 使用了 #[payable] 注解
 	合约包括以 Promise: : new (...) . transfer (...) ; lines 的形式进行的异步调用
 	数据结构 LookupMap < String，ContentRecord > 处理键值查找，这等同于solidity的“mapping”

3.总结
Solana 和 NEAR 协议都是卓越的智能合约平台，已经建立了高度活跃的社区。他们都带来了特殊的功能，帮助解决去中心化最大的问题-速度。 这两个平台都在不断成长，并且前景看好

### NEAR入门

账户/钱包
NEAR入门的第一件事，就是建立一个NEAR账户。

请观看NEAR账户相关视频

通过钱包，你可与发起智能合约调用，设置你的本地节点，收发资金。注册钱包账户ID时，你必须提供一个独一无二的名称。每个钱包都必须有唯一的名称，每个用户都可以创建多个钱包。

你可以想象这就类似脸书或者谷歌账户。一旦你注册了任一个服务，就可以使用相同的账户登录第三方服务。NEAR账户和谷歌账户之间的区别是那些代表账户的数据，是只能被钱包的所有者访问和管理的。除此以外，所有信息被存储在由节点组成的分布式网络上，而不是某个单独的服务器。

立刻创建NEAR账户

更多有关NEAR账户的内容请见DOCS.NEAR
NEAR 浏览器
NEAR 浏览器让你可以实时查看区块的创建！这个有用的工具可以查询交易 和 账户，让你可以查看用户和智能合约之间的所有交互。
如何获得NEAR通证?
有4种方式获得 $NEAR
以太坊用户可获得免费的NEAR
通过使用面向以太坊用户的水龙头https://faucet.paras.id，用户可以得到一个拥有少量免费NEAR的钱包账户。
赚取NEAR
你可以通过参与开发赏金任务获得$NEAR, 运营一个帮助大家在NEAR上开发的技术社区，赢取NEAR骇客松比赛，或成为社区里的积极分子。如果你能吸引别人投NEAR给你抵押，你就可以成为一个验证人来赚取$NEAR。
购买NEAR
在一些大交易所（详情见下文）上都有$NEAR。在那里你可以注册并用加密货币或法币购买NEAR通证。

支持$NEAR的交易所

你可以在coinmarketcap and coingecko上查看价格和交易对信息。

https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR
从朋友手里获得
你并不需要先有一个NEAR账户才能接收NEAR通证！“NEAR Drop” 功能让你的朋友可以预付得到一个新账户并通过一个链接让你接收通证。
我拿着NEAR通证能做什么？
转账NEAR
将 $NEAR 在你和朋友的账户之间转来转去，并可以在区块浏览器里查看对应的交易。因为交易手续费非常低，你可以方便快捷的转移非常小额的NEAR玩玩。

把它们作为礼物通过红包送出去。
试试NEAR空投 (邀请朋友)
如果你的朋友向创建一个NEAR账户，可以给他们发送一个NEAR空投。
使用NEAR应用
要查看日益增长的NEAR上的应用列表，点击这里。

轻松开启NFT之旅 - 购买/发布/交易 艺术品 就上 https://paras.id/

加入BerryClub参与艺术品的创作：https://berryclub.io/
使用NEAR的费用如何（Gas）？
当访问NEAR网络更新和改变数据时，运行网络基础架构的人就产生了一些开销。某些地方的某些计算机运行你的请求，而运营这些计算机的验证人需要支付显著的费用以确保这些计算机的运行。

与其他可编程网络类似，NEAR通过交易费，也叫Gas费补偿这些人。

如果你熟悉web2上的云服务提供商（亚马逊云，谷歌云等），区块链与其的最大不同是，用户在访问应用的时候直接支付费用，而不是开发者预付所有的基础设施费用。这带来了新的可能性，例如，应用本身规避了长期的入不敷出的资金风险。但这也带来了一些用户可用性上的问题。为了解决这个问题，NEAR也提供了让开发者支付用户使用开销的能力，让使用体验更靠近web2。

考虑gas时要牢记的两个概念:

 	Gas单位: 在内部，交易费不是直接用NEAR通证计算的，而是通过一个居中的gas单位。gas单位的好处是，他们是确定的，相同的交易总是消耗相同数量的gas单位。
 	Gas价格: gas单位乘以gas价格得到具体的向用户收取的费用。这个价格会在每个块时根据网络需求自动重新计算（如果前面块的gas数量超过半满，则价格上升，否则价格下降，每个块的价格变动不会超过1%）。最低的价格由网络配置决定，当前是1亿个yoctoNEAR。

注意：测试网和装的gas价格可能不同。在直接使用下面的数字之前，要检查一下gas价格。

从gas角度看

NEAR的出块时间在一秒左右，这归功于对每个区块gas数量的限制。Gas的单位经过仔细合理的计算，形成了一些易于理解的数字：

10¹² 个gas, 叫 1 TGas (TeraGas)…

≈ 1 毫秒的“计算”时间

…这样一来，在最小1亿个yoctoNEAR每gas的价格下，等值于0.1个milliNEAR。

这里的1ms是一个粗略但有益的近似，也是目前NEAR中单位gas的设计目标。Gas单位不仅封装了计算/CPU时间，也包含带宽/网络时间和存储/IO时间。通过治理机制，将来系统参数是可以调整的，可以改变TGas与1毫秒之间的对应关系。即便如此，上面的内容也是一个不错的开始，让你了解单位gas的意义以及它是怎么得来的。

小测验: 1 TeraGas 或者说 TGas 是多少:

1 TeraGas或TGas等于:
1 微秒的计算时间
10 秒的计算时间
1 毫秒的计算时
1 纳秒的计算时
常见操作的费用
为了让大家了解NEAR上的费用有个切入点，下面的表格展示一些常见操作，以及目前它们所消耗的TGas，以及对应的NEAR，分别以千分之一NEAR，NEAR为单位。使用的gas价格是1亿个yN。



操作
TGas
费用(单位mN)
费用(单位Ⓝ)




创建账户
0.42
0.042
4.2⨉10⁻⁵


转账
0.45
0.045
4.5⨉10⁻⁵


抵押
0.50
0.050
5.0⨉10⁻⁵


添加全权key
0.42
0.042
4.2⨉10⁻⁵


删除Key
0.41
0.041
4.1⨉10⁻⁵



如何获得NEAR?
抵押你的NEAR
POS模型的关键点在于，社区是如何通过抵押而给予验证人支持的。验证人运营节点以支撑起整个网络，因此获得每年5%固定通胀率的奖励，具体是每个周期（约12个小时）创建出一批新的通证。

验证人必须维持一个确保让他们拥有验证人席位的最少抵押数量。通证持有者可以选择一个他们认为能可靠运行网络的验证人去抵押通证，同时按比例获得网络产生的收益。这样就能激励通证持有者持续关注社区!

NEAR钱包已经把用户抵押接口直接集成进了web应用中。

抵押:

 	在导航条上选择 “Staking” (移动端是下拉框)
 	点击“Select Validator”按钮
 	选择一个人验证人
 	确认你的选择并点击“Stake with Validator”
 	输入你想要抵押的NEAR数量并点击“Submit Stake”

You will need to confirm two transactions, one to select the validator, and another to deposit and stake with the validator.

解抵押:

 	在抵押展示或抵押页面，选择你当前的验证人
 	点击“Unstake”并确认交易

36到48小时（4个完整的周期）之后，就可以提取权益了。做法是回到验证人页面，点击“Withdraw”。

每周期作为奖励而新生的通证，其产生的大约间隔时间为：
12 分钟
12 秒
12 天
12 小时
现在呢？我如何与NEAR互动？
接下来如何？如果你已经读到这里，也许会想更深入的了解NEAR协议. 所以接下来你可以查看NEAR白皮书. 如果你是个区块链新手，想要了解该领域本身，你可以查看这个视频解析区块链生态. 加入 NEAR Discord server 逛逛NEAR论坛.

原文链接：https://learnnear.club/what-is-near-protocol/

### NEAR Message System Beta test

Requirements 

 	Login with NEAR Testnet account at https://near-sms-tool.kiemtienonline360.com/
 	Send 1 message to at least  5 of your NEAR friends
 	Ask them to Reply to your message
 	Make a screenshot when you are received at LEAST 5 replies
 	Fill the Feedback form

The top 20 beta testers will get 5 NEAR, the best feedback submitter will get 10 NEAR. Please make sure that your testnet and main account MATCH exactly - eg. john.testnet and john.near.

Happy Testing!

### What Are DAOs? Looking Into Sputnik DAO.

One of the most exciting things that have gained a lot of traction in recent times is the concept of DAO or “Decentralized Autonomous Organization.” The idea is to create an internet-native business that’s collectively owned and managed by its members. There is no CEO controlling the flow of the business, no CMO, no CFO, no centralized board of directors. Instead, the business logic and execution are baked into the smart contracts to ensure streamlined deployment.

Hypothetical examples of DAOs:

 	Charity: Anyone can become a member and anyone can donate. The group decides how to spend donations.
 	Freelance Network: Network of contractors who pool together their funds for freelance-related tools.
 	Ventures and grants: A decentralized hedge fund where members can pool in their funds and vote on different proposals.

How Are DAOs Different?
The DAOs execute certain rules that are recorded on the smart contract and kept on the blockchain. A smart contract can be thought of as an automated agreement between two or more parties. Due to the transparent nature of the blockchain, it is impossible to change the code governing the smart contract without the entire network getting to know. This is what makes DAO more flexible and robust than typical organizations.

 	DAOs are a democratized organization wherein each member needs to vote for any changes that have to be implemented. DAO uses community-based governance instead of an executive-based one.
 	DAOs are global and completely transparent.

Why Hierarchical Organizations Aren’t Good Enough
A hierarchical and vertical organizational structure is a common way to organize a business. The idea is simple – every person within the organization (except the one at the top) is subordinate to another single individual or entity. Thus, those with the most power are at the top of the chart. At the same time, those with the least power would appear at the bottom. However, due to its inherent structure, it has several shortcomings when compared to DAOs.




DAOs
Hierarchical


Structure
Flat and democratized
Hierarchical


Voting
Every single change in the system requires voting by the members.
Whether a system requires voting or not depends on the structure and the rules defined by the system.


Intermediary
Votes are tallied and the outcome implemented without a trusted intermediary.
If the voting is allowed, they need to be tallied by an intermediary.


Automation
Governance-related issues are handled automatically in a decentralized manner.
Requires human and centralized handling. Hence they are vulnerable to manipulation.


Visibility
Fully public and transparent.
Private and mostly opaque.



Membership Models In DAO
So, how exactly does a DAO membership model work? This is pretty important since becoming a member is key to a DAO’s operational model.

Alright, so there are two membership models:

 	Token-based.
 	Share-based.

Token-based
Most of the protocols have a governance token that can be traded in various centralized and decentralized exchanges. One can either earn these tokens via participating in a consensus algorithm or providing liquidity. As the name suggests, owning these tokens gives you access to voting rights within the protocol. More tokens you hold, the more your voting power. An example of this is MakerDAO and its governance tokens – MKR. Anyone can participate in MakerDAO governance by buying the MKR tokens.
Share-based
Compared to token-based DAOs, share-based DAOs are more permissioned. Potential members must submit a proposal to join the DAO. The proposal accompanies a tribute in the form of tokens or some work. A participant’s share represents their direct voting power. They may exit any time with a proportionate share of the treasury. MolochDAO - a protocol responsible for funding Ethereum-based projects - is an example of a share-based DAO. You can’t buy governance tokens in the open market to gain access to the DAO. To join it, you need the necessary expertise and capital to help support potential projects.
Learning From The Mistakes – The DAO Hack
Of course, it is critical to learn about the DAO hack that split Ethereum into Ethereum and Ethereum Classic. Back in 2016, the Ethereum DAO was created to be a game-changer and completely rethink the way venture funds work. The idea was for DAO token holders to vote on various project proposals. If a proposal gets a 20% vote from the community, they will get the funds required to get started.

The DAO also had a “split mechanism.” Basically, if members aren’t happy with the projects whitelisted, they could split away from the DAO to create their own “child DAO.” Anyway, the DAO was a huge hit and accumulated over $150 million worth of ether in a crowdsale. For perspective’s sake, this was 14% of all ether tokens issued to date.

However, the DAO had a significant code vulnerability. On 17th June 2016, an attacker exploited this vulnerability to continually re-enter the system and siphon away $50 million worth of ETH. Most of the community decided to roll back on this incident via a hard fork. However, some of the community was against this move. This eventually led to a hard fork that split the Ethereum protocol into Ethereum and Ethereum Classic.
Near Protocol and Sputnik DAO
Near Protocol co-founder, Illia Polosukhin announced the Sputnik DAO in this article. He explained the DAO as a “way for new and existing communities and organizations around the world to have on-chain representation of their group, manage their on-chain activity, governs their decision-making, and (importantly!) interact with other DAOs.”

Sputnik took the following inspirations to form the “first wave” of DAO experimentation:

 	The way the community controls governance does not scale with the number of people involved. Many DAOs have failed for various reasons, from technical issues to lack of interest in voting from members or lack of a unifying, driving factor.
 	It’s impossible to have a completely happy DAO system, Interests will drift, and people’s opinions about a proposal might change. The minority in the group could potentially fork or diverge from the group to follow a new DAO system.
 	A community or organization needs leadership. An ideal community must have dedicated members who are responsible for coordination, potentially moderation.
 	Even if the community is permissionless and pseudonymous, there should be some publicly known members that will create the community's core.
 	The more “product” focused a decentralized community is, the more focused the leadership must be.
 	Pure stake-based weighting always fails because most stakeholders are not able to or don’t want to be active participants.

The Sputnik Interface
The moment you go to the Sputnik homepage you will see the following screen.



When you click on “NEAR Forum” you will see the different conversation threads neatly and appropriately categorized.



In the homepage, if you click on “Launch App” you will get access to the different DAOs listed in sputnik. 



Let’s give you an example of something that hits closer to home. Let’s check all the proposals in the Learn NEAR DAO.



So, as you can see, you have various proposals listed here, along with their respective payouts (in NEAR). If a proposal gets approved or rejected, it will be marked so. For example, in Proposal ID 22, someone successfully translated the homepage and footer to “Vietnamese,” which is why you can see that “1” next to Approve and the “Success” badge.


How we use Sputnik DAO at LeanNEAR.Club
There are TWO levels of DAO in use:

Mother DAO and the following subDAOs:

 	https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-rus.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-spanish.sputnikdao.near
 	https://www.sputnik.fund/#/dao/learn-near-china.sputnikdao.near.

Look at Mother DAO as a Client/Funder, subDAOs as a Contractor and subDAOs members as SubContractor.

Let’s take a look at how it works for community translation.A guide Top 3 NFT Projects On The NEAR Protocol needs to be translated in Vietnamese.
SubDAO members submit proposals for translation and review.



Then one of them submitted a consolidated proposal to the Mother DAO with subDAO as funds receiver



Once the work is accepted and translated Guide is published subDAO members split received funds as per proposals submitted earlier.

For possible conflict resolutions, Mother DAO member acts also as Voting Member at ALL subDAOs.
Conclusion
So, there you have it. DAOs are incredibly disruptive. However, one must implement it properly to truly reap the rewards. It seems like Near Protocol has indeed cracked the code with Sputnik!

### Octopus Network là gì?

Kết quả mong muốn: Cung cấp một cái nhìn tổng quan cho người sử dụng mạng lưới Octopus

Bạch tuộc rất khác với con người. Bạch tuộc rất khác với con người. Thay vì có một hệ thống thần kinh tập trung như con người, hai phần ba số tế bào thần kinh của bạch tuộc được trải khắp cơ thể và phân bổ giữa các tua của nó. Những tế bào thần kinh đó có thể tự đưa ra quyết định mà không cần đầu vào từ não - về cơ bản làm cho bạch tuộc trở thành một dạng sống trí tuệ phi tập trung.

Octopus Network là một công cụ mã hóa có khả năng tương thích đa dạng, mô phỏng lại loài Bạch tuộc. Giống như tua của một con bạch tuộc, mỗi chuỗi khối ứng dụng cụ thể được kết nối (appchains) được trao quyền với trí thông minh và cơ chế ra quyết định của riêng nó để thích ứng với môi trường luôn thay đổi. Khi được kết nối tổng thể, tất cả các thành viên đều được hưởng lợi từ các hiệu ứng mạng đáng kể và tính kinh tế theo quy mô - tạo ra một mạng Internet của các blockchain.

Octopus Network là một multichain cryptonetwork để cài đặt và chạy các nền tảng Web3.0 – blockchain cụ thể - appchains.



Appchains trong OctopusNetwork được hưởng lợi từ tính năng bảo mật cho thuê (LPoS)  là  tính linh hoạt và hiệu quả về chi phí, khả năng tương tác đa kênh độc lập, cơ sở hạ tầng hoàn chỉnh và một cộng đồng sẵn sàng tương tác.

Octopus Network giảm chi phí để cài đặt một chuỗi ứng dụng từ vài triệu đô la xuống dưới một trăm nghìn đô la - mở ra Làn sóng đổi mới thứ 3 của Cryptonetworks.
Cách mạng Web3.0 Applications
Web3.0 vẫn chưa xảy ra. Nhưng dựa trên các nguyên tắc đầu tiên, chúng tôi chắc chắn rằng cuối cùng sẽ làm được.

Giao dịch luôn chảy vào thị trường với chi phí thấp hơn, giống như nước luôn chảy xuống dốc.

Nền tảng Web2.0 được sở hữu và điều hành bởi các công ty có mục tiêu phù hợp trực tiếp với việc tối đa hóa giá trị của cổ đông. Họ trích càng nhiều lợi nhuận càng tốt từ các hoạt động kinh tế mà họ sở hữu. Cryptonetworks là thị trường dịch vụ kỹ thuật số với chi phí giao dịch được giảm thiểu. Vì vậy, các nền tảng Web2.0 đơn giản là không có khả năng ngăn cản việc cuối cùng bị thay thế bởi các công cụ mã hóa.

Web3 đề cập đến các ứng dụng phi tập trung chạy trên các blockchain thuộc sở hữu của cộng đồng người dùng chứ không phải là các công ty khai thác lợi nhuận. Web3.0 mong muốn trả lại giá trị cho những người sáng tạo thực sự.

Tuy nhiên nền tảng Web2.0 vẫn đem lại nhiều tiện ích cho người dùng Internet. Để một ứng dụng Web3.0 có thể thay thế một ứng dụng Web2.0, ngay từ đầu nó phải là một ứng dụng Web tuyệt vời và cung cấp trải nghiệm người dùng ít nhất là ngang bằng với ứng dụng Web2.0 tương ứng.

Việc phát triển ứng dụng Web3.0 thường phải hy sinh trải nghiệm người dùng vì công nghệ sổ cái phân tán phức tạp hơn và chi phí cao hơn so với Web2.0 - dẫn đến giảm trải nghiệm người dùng.

Làn sóng đổi mới công nghệ tiền mã hóa lần thứ 3 đang đến và nó đang mang lại các giải pháp ứng dụng Web3.0 đầy hứa hẹn.
Làn sóng đổi mới công nghệ tiền mã hóa lần thứ 3
Bitcoin là một chuỗi khối ứng dụng cụ thể (chuỗi ứng dụng) - chuỗi khối đầu tiên và thành công nhất.

Lấy cảm hứng từ Bitcoin, một loại appchains sau đó được phát triển từ năm 2011 đến năm 2015. Một số cố gắng trở thành một Bitcoin tốt hơn, trong khi những người khác nhắm mục tiêu vào nhiều trường hợp sử dụng khác nhau ngoài tiền tệ - khiến chúng ta có vô số coin đã chết. Lý do thường được thống nhất cho điều này là blockchain Bitcoin được xây dựng có mục đích và không phù hợp để giải quyết các trường hợp sử dụng khác bằng cách chia nhỏ hoặc mở rộng. Chúng ta có thể gọi giai đoạn này là “Làn sóng đổi mới tiền mã hóa đầu tiên”.

Làn sóng đổi mới tiền mã hóa lần thứ 2 được sinh ra với Ethereum. Ethereum là một blockchain công cộng có mục đích chung được trang bị máy ảo Turing-Complete (về mặt lý thuyết có thể thực hiện bất kỳ phép tính nào, miễn là nó vẫn nằm trong giới hạn độ phức tạp, còn gọi là giới hạn khí.) Ngôn ngữ lập trình EVM, Solidity, với Javascript của nó -như cú pháp, dễ học và rất giỏi trong việc kiểm soát các tài sản trên chuỗi.

Ethereum cho phép hàng nghìn nhà phát triển xây dựng các ứng dụng phi tập trung (dApps). Thật không may, rất ít người có thể giữ chân nhiều người dùng trong một khoảng thời gian dài cho đến khi vụ nổ DeFi năm 2020.

Nhưng thách thức chính mà Ethereum phải đối mặt là khả năng mở rộng - và phí gas để chạy các hợp đồng thông minh đã làm cho một số trường hợp sử dụng nhất định trở nên đắt đỏ. Trong khi Ethereum 2.0 nhằm mục đích nhắm mục tiêu những vấn đề này với một giao thức blockchain phân đoạn, thì Ethereum 2.0 là một lộ trình kéo dài nhiều năm với những rủi ro thực thi không xác định.

Tuy nhiên, Làn sóng Đổi mới Công nghệ Tiền điện tử thứ 3 đang ở ngay gần đây. Các khuôn khổ chuỗi khối như Substrate và Cosmos SDK có thể cung cấp không gian thiết kế khổng lồ chưa từng có cho các nhà phát triển ứng dụng Web3.0.

Các nhà phát triển hiện có thể cung cấp một ứng dụng Web3.0 được tối ưu hóa hoàn toàn bằng cách xây dựng một chuỗi ứng dụng.


Appchain là gì?
Ứng dụng phi tập trung hay dApp, là một ứng dụng web có ít nhất một phần phụ trợ của nó nằm trên một chuỗi khối. Phần phụ trợ của dApp có thể được triển khai theo hai cách - các hợp đồng thông minh có thể được lưu trữ trên nền tảng blockchain hoặc một ứng dụng phi tập trung có thể hoạt động trên blockchain chuyên dụng của riêng nó.

Khi một dApp có chuỗi khối riêng, nó được gọi là chuỗi khối dành riêng cho ứng dụng, viết tắt là chuỗi ứng dụng. Không giống như dApps, appchains cho phép các nhà phát triển tùy chỉnh ứng dụng của họ về cấu trúc quản trị, thiết kế kinh tế và thậm chí cả thuật toán đồng thuận cơ bản của nó.

Appchains cũng cung cấp cho các nhà phát triển khả năng xử lý giao dịch chuyên dụng, có nghĩa là một ứng dụng trên chuỗi ứng dụng không phải cạnh tranh với các ứng dụng khác về khả năng xử lý giao dịch trên mạng.

Để minh họa, trong khi hàng nghìn ứng dụng khác nhau có thể chia sẻ một bộ cấu hình tiêu chuẩn trên nền tảng hợp đồng thông minh chung, mỗi chuỗi ứng dụng trong cài đặt PoS có thể dễ dàng đạt được thông lượng 1K + TPS và độ hoàn thiện nhanh chóng - và tất cả khả năng xử lý giao dịch này sẽ chỉ dành riêng cho một đơn xin.

Không giống như các hợp đồng thông minh, appchains có thể phát triển nhanh chóng với tính hợp pháp. Mỗi chuỗi ứng dụng là một nền kinh tế tự quản với các quy trình rõ ràng được xác định bằng mã để đạt được các thỏa thuận về nâng cấp giao thức. Và, nhờ Substrate, chức năng chính của quản trị chuỗi đã sẵn sàng để sử dụng. Bất kỳ công cụ mật mã nào cũng có thể phản ánh quy trình quản trị của một quy trình khác bằng cách sao chép mã được dán. Bản thân quản trị chuỗi khối có thể phát triển giống như phần mềm mã nguồn mở.

Tuy nhiên, không ai có thể bỏ qua rằng các hợp đồng thông minh rất tuyệt vời cho các trường hợp sử dụng giao dịch tài sản, ví dụ: DeFi. Bởi vì các hợp đồng thông minh chạy dựa trên các giả định bảo mật giống nhau, khả năng kết hợp giữa chúng là công thức thiết yếu cho sự bùng nổ DeFi.

Tuy nhiên, trong khi trải nghiệm người dùng của DeFi không hoàn toàn tệ như ngân hàng trực tuyến, nó vẫn còn nhiều chỗ để cải thiện, đặc biệt là khi xem xét một blockchain lớp 1 có khả năng hơn Ethereum - chẳng hạn như Giao thức NEAR.
Tại sao Octopus chọn NEAR?
Mặc dù Substrate và Cosmos SDK đã giảm chi phí phát triển của appchains xuống mức ít nhất là tương đương với các hợp đồng thông minh, appchain bootstrapping vẫn là một công việc đòi hỏi nhiều vốn và phức tạp về mặt kỹ thuật đối với các nhà phát triển.

Giao thức NEAR là một chuỗi khối bằng chứng cổ phần (PoS) được chia nhỏ nhấn mạnh khả năng mở rộng và khả năng sử dụng. NEAR thường được gọi là một giải pháp khả năng mở rộng được tạo sẵn cho các dApp Ethereum hiện có, nhưng nó có khả năng tương đương với một bộ các loại giải pháp phi tập trung khác - chẳng hạn như appchains.

So với các nền tảng Lớp 1 khác cũng có thể chứa appchains, chẳng hạn như Polkadot hoặc Cosmos, NEAR có một số lợi thế kinh tế và kỹ thuật chính.

So với Cosmos, khởi chạy chuỗi ứng dụng trên NEAR dễ dàng hơn vì trình xác thực không cần phải khởi động cho từng chuỗi ứng dụng riêng lẻ.

Ví dụ: trên Cosmos, mỗi chuỗi ứng dụng phải tự bảo mật bằng một bộ xác thực phi tập trung, đủ cổ phần. Vì vậy, các nhà phát triển chuỗi ứng dụng trước tiên phải có được sự công nhận giá trị của mã thông báo gốc của chuỗi ứng dụng trong thị trường tài sản tiền điện tử, sau đó khởi động một cộng đồng trình xác thực đang hoạt động từ đầu.

So với Polkadot, NEAR cung cấp cho các appchains một hợp đồng thuê bảo mật rẻ hơn đáng kể và không có giới hạn về số lượng appchains có thể được khởi chạy.

Một parachain của Polkadot phải có đủ khả năng chi trả chi phí đồng thuận của một phân đoạn mạng - có thể tương đương với hàng chục triệu đô la một năm.

Trong một hệ thống tính toán, bảo mật cao hơn không nhất thiết phải đồng nghĩa với bảo mật tốt hơn, bởi vì mức bảo mật cao hơn luôn đi kèm với mức chi phí cao hơn. Vì vậy, những gì một hệ thống tính toán cần là sự bảo mật phù hợp và đầy đủ.

Trong Polkadot, các nhà phát triển không phải quyết định mức độ bảo mật thích hợp và đầy đủ cho parachain của họ. Họ chỉ có một sự lựa chọn - giành được một chỗ trong cuộc đấu giá. Nhưng ngay cả khi parachain thắng cuộc đấu giá, nó thường vượt quá thời gian bảo mật vì tiền điện tử trong các giai đoạn khởi chạy của nó không cần mức bảo mật nhiều tỷ đô la.

Hơn nữa, gánh nặng chi phí bảo mật cấp độ cao ngay từ đầu có thể đẩy parachain vào siêu lạm phát vì nó phải hứa hẹn phát hành một lượng lớn mã thông báo bản địa cho những người cho vay Crowdloan. Ít nhất, gánh nặng kinh tế này để lại một khoảng trống rất ít để khuyến khích những người tạo ra giá trị thực của giao thức của nó - những người tham gia giúp xây dựng hiệu ứng mạng của tiền mã hóa.

Nói một cách đơn giản, NEAR đã được Octopus chọn thay vì Polkadot và Cosmos vì nó đơn giản là tiết kiệm chi phí hơn, có thể mở rộng, thân thiện với người dùng và khả năng tương tác với các mạng như Ethereum hơn bất kỳ giải pháp L1 hiện có nào khác.

Chúng tôi tin rằng appchains sẽ là Làn sóng Đổi mới thứ 3 của Cryptonetworks đưa chúng ta vào Web3.0 - và Octopus Network sẽ giúp appchains có thể truy cập được vào vô số dự án với đủ loại ngân sách.




	

	
	
		
			
				Appchain là gì?
			
		

		
					

		
			
			
			
			Ứng dụng phi tập trung
		
			
			Mục đích chung của blockchain
		
			
			Ứng dụng đặc biệt của blockchain
		
			
			Hợp đồng thông minh
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Ưu điểm của Leased PoS (LPoS)

Bảo mật trong bối cảnh của blockchain là gì?

Nói một cách đơn giản, bảo mật là mức độ chắc chắn rằng các giao thức được xác định trước sẽ được áp dụng như hầu hết các bên liên quan mong đợi - cho dù ở lớp cơ sở hay lớp ứng dụng.

Bảo mật chuỗi khối thường được coi là một tài sản có thể định lượng được. Không thể có bảo mật tuyệt đối hoặc không giới hạn. Nếu một blockchain có tính bảo mật tuyệt đối, nó phải vừa không sử dụng được vừa không có khả năng chi trả.

So với mô hình bảo mật được chia sẻ của Polkadot parachain, chuỗi ứng dụng Leased PoS (LPoS) của Mạng Octopus có khả năng mở rộng và linh hoạt hơn nhiều. Bởi vì cho thuê tài sản bảo đảm về bản chất là cho thuê vốn hoặc cho thuê tài sản thế chấp, nó có quy mô mà không có giới hạn vật lý.

Trong Polkadot, mỗi parachain sẽ chứa một số lượng trình xác thực nhất định trong nhóm dành riêng cho bất kỳ kỷ nguyên nào. Thuật toán đồng thuận giới hạn tổng kích thước của nhóm. (Đó là lý do tại sao tổng số parachains dự kiến sẽ dưới 100 với ít hơn 10 vị trí parachain có sẵn trong năm nay.)

Octopus’s Leased PoS tiết kiệm chi phí hơn nhiều so với Polkadot’s. Vì Octopus không có blockchain riêng và mã thông báo $ OCT được phát hành và quản lý bởi một hợp đồng thông minh, nên Octopus không cần trực tiếp thanh toán chi phí đồng thuận. Vì vậy, tỷ lệ lạm phát $ OCT có thể được đặt bằng 0, có nghĩa là lãi suất cơ bản của hệ thống kinh tế Octopus bằng không.

Khi lãi suất cơ bản bằng 0, APY 3% -5% là lợi nhuận hàng năm khá tốt, (đây là phạm vi mà chúng tôi mong đợi một chuỗi ứng dụng sẽ trả cho bảo mật đã thuê của họ.) Ngược lại, Polkadot parachain phải trả 20% hoặc nhiều APY hơn để khiến bản thân trở nên hấp dẫn đối với những người cho vay $ DOT của Crowdloan vì đặt cược vào Polkadot Relay sẽ mang lại cho các nhà đầu tư lợi nhuận hàng năm không có rủi ro 14%.

Bởi vì LPoS là bảo mật dựa trên nhu cầu và cung cấp cho appchains đòn bẩy hiệu quả về chi phí để mở rộng quy mô một cách tự nhiên, chúng tôi tin rằng LPoS có lợi hơn cho sự phát triển lâu dài của appchains hơn là PoS độc lập. Tuy nhiên, chúng tôi cũng tin rằng quyền lựa chọn luôn thuộc về bất kỳ cộng đồng appchain nào.

Nếu bất kỳ chuỗi ứng dụng nào trên Mạng Octopus chọn ngừng sử dụng LPoS để chuyển đổi thành một chuỗi khối PoS độc lập, Octopus thậm chí sẽ cung cấp các công cụ hỗ trợ việc chuyển đổi của nó - Kết nối của nó với Mạng Octopus sau đó sẽ bị hạ cấp xuống kết nối của một cầu IBC tiêu chuẩn và các tài sản xuyên chuỗi hiện có sẽ không bị ảnh hưởng.
Tổng quan về Octopus Network

Legend: D-Delegator, S- Staking, V- Validator, RT - Runtime, N- Node
Octopus Relay nằm ở cốt lõi của Octopus Network. Octopus Relay là một tập hợp các hợp đồng thông minh chạy trên chuỗi khối NEAR (hay còn gọi là chuỗi chính) triển khai thị trường cho thuê bảo mật.

Các appchains bạch tuộc nằm ở phía cầu của thị trường. Các appchains Octopus thuê bảo mật từ các chủ sở hữu $OCT bằng cách trả tiền thuê bằng các mã thông báo gốc của họ. Mỗi chuỗi ứng dụng có thể chọn mô hình kinh tế của riêng mình, bao gồm số lượng mã thông báo gốc mà nó sẵn sàng trả cho Người xác thực để bảo mật.

Người xác nhận và Người ủy quyền của Octopus nằm ở phía cung của thị trường cho thuê bảo mật.

Octopus Validators đặt cọc các mã thông báo $OCT để xác thực một chuỗi ứng dụng cụ thể và thiết lập một nút để chạy giao thức của chuỗi ứng dụng đó. Đổi lại, Người xác thực đủ điều kiện để nhận mã thông báo gốc tương ứng của chuỗi ứng dụng mà họ đang xác thực.

Người đại diện của Octopus có thể ủy quyền $OCT của họ cho Người xác thực để được chia phần trong phần thưởng đặt cược của mã thông báo gốc của chuỗi ứng dụng. Phần thưởng đặt cọc được phân phối trực tiếp cho Người ủy quyền sau khi Người xác thực thu thập một khoản hoa hồng thống nhất.

Nếu người xác thực hoạt động sai (ví dụ: ngoại tuyến, tấn công mạng hoặc chạy phần mềm đã sửa đổi), họ (và Người ủy quyền của họ) sẽ bị cắt bằng cách mất phần trăm $OCT đã đặt cọc của họ. Tất cả các hình phạt được áp dụng cho Người ủy quyền theo tỷ lệ khi Người xác nhận của họ bị chém. Theo cách này, việc đặt cược hoạt động như một biện pháp không khuyến khích đối với các hành vi ác ý.

Bởi vì chủ sở hữu $OCT chịu trách nhiệm quyết định chuỗi ứng dụng nào họ muốn cổ phần, Octopus Network hoạt động như một thị trường miễn phí, nơi các ứng dụng có thể cho thuê mức độ bảo mật mà họ cần theo giá thị trường bất kỳ lúc nào.

Octopus Network cũng có một loạt công cụ dành cho các nhà cung cấp bảo mật, chẳng hạn như các công cụ triển khai và quản lý tự động nút trình xác nhận chuỗi ứng dụng, các quan điểm kinh tế mạng và các công cụ phân tích thống kê.

Thị trường LPoS củaOctopus Network cho phép bất kỳ nhà phát triển, dự án hoặc doanh nhân nào tạo chuỗi ứng dụng của riêng họ trên NEAR một cách nhanh chóng, hiệu quả và hợp lý.

Nhưng Octopus Network cũng hỗ trợ appchains theo nhiều cách khác bao gồm cung cấp khả năng tương tác chuỗi chéo, cơ sở hạ tầng tích hợp và một cộng đồng sẵn sàng tương tác.




	

	
	
		
			
				Ưu điểm của LPoS?
			
		

		
					

		
			
			
			
			LPoS có chi phí hiệu quả hơn
		
			
			LPoS  linh hoạt
		
			
			LPoS có tính mở rộng
		
			
			Tất cả đáp án trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interoperability
Bây giờ ít gây tranh cãi hơn khi khẳng định rằng tất cả các blockchain công cộng và mạng đa mạng cuối cùng sẽ được kết nối với nhau - tạo thành Internet của các Blockchains. Mạng Octopus được thiết kế đặc biệt để trở thành một phần của mạng lưới này.

Nhóm Octopus (trước đây được gọi là Cdot) đã làm việc trên giao thức tương tác blockchain phổ quát IBC và tích hợp chuỗi chéo trong hơn hai năm.

Octopus Relay cho phép khả năng tương tác của appchains với giao thức NEAR và Ethereum thông qua Rainbow Bridge. Ngoài ra, appchains có thể sử dụng một pallet IBC ngoài hộp để kết nối trực tiếp với bất kỳ blockchains nào hỗ trợ IBC.

Bất kỳ tài sản nào được phát hành trên Ethereum, NEAR hoặc bất kỳ chuỗi khối hỗ trợ IBC nào đều có thể được chuyển vào và sử dụng bởi các appchains của Octopus một cách đáng tin cậy. Ngược lại, bất kỳ tài sản nào được phát hành trên appchains có thể được chuyển một cách đáng tin cậy sang Ethereum, NEAR và bất kỳ chuỗi khối hỗ trợ IBC nào.

Dựa trên khả năng tương tác liền mạch giữa Mạng Octopus và NEAR, nhiều loại tài sản tiền điện tử được phát hành trên các appchains của Octopus cũng sẽ góp phần vào sự thịnh vượng của hệ sinh thái NEAR’s DeFi.
Infrastructure - Cơ sở hạ tầng
Mạng Octopus cung cấp một bộ cơ sở hạ tầng hoàn chỉnh cho appchains - bao gồm API Gateway, Blockchain Explorer, Archive Gateway, v.v.

Cầu Octopus sẽ triển khai hợp đồng trình bao bọc NEP-141 trên NEAR cho mỗi mã thông báo gốc của chuỗi ứng dụng. Sau đó, các ví và sàn giao dịch có thể tích hợp mã thông báo trình bao bọc tiêu chuẩn thay vì phải tích hợp với từng chuỗi ứng dụng riêng lẻ.

Vì vậy, các nhóm ứng dụng chỉ cần tập trung vào thời gian chạy Substrate và phát triển giao diện người dùng trong khi Mạng Octopus xử lý tất cả các nhu cầu kỹ thuật cần thiết khác.
Community - Cộng đồng
Một công cụ mật mã thuộc sở hữu của cộng đồng của nó. Đây là bản chất của phân quyền và là sự khác biệt cơ bản so với nền tảng Web2.0.

Mạng Octopus hoạt động như một cộng đồng meta để nuôi dưỡng hàng trăm cộng đồng ứng dụng Web3.0. Các nhà phát triển ứng dụng Web3.0 và những người sáng lập chuỗi ứng dụng có thể hiển thị giá trị của công việc tiền mã hóa của họ để thu hút nhiều người ủng hộ - chẳng hạn như các nhà đầu tư, Người xác thực, Người ủy quyền và những người tham gia giao thức.

Người dùng quan tâm đến các ứng dụng Web3.0 khác nhau sẽ chú ý đến các ứng dụng yêu thích của họ thông qua các sự kiện như ra mắt chuỗi ứng dụng Octopus. Theo cách này, Octopus là một cơ sở cộng đồng cho các appchains để hỗ trợ hành trình xây dựng cộng đồng tích cực xung quanh họ.

Mạng Octopus cũng cung cấp khả năng phân nhánh tuyệt vời cho tất cả các appchains của nó, khiến cho bất kỳ loại ông trùm hoặc bạo chúa nào tiếp quản một appchain mà không có sự đồng ý của cộng đồng là vô nghĩa - giữ cho nó phi tập trung. Octopus sẽ cung cấp tất cả các appchains của nó với khả năng phân nhánh bằng cách lưu trữ lịch sử khối appchain vào Arweave - một giao thức lưu trữ vĩnh viễn phi tập trung.

Dựa trên lịch sử khối đã lưu trữ, mọi chuỗi ứng dụng có thể được fork ở bất kỳ độ cao nào để trở thành chuỗi ứng dụng mới nếu cộng đồng của nó hỗ trợ fork. Và bất kỳ nhóm cốt lõi của chuỗi ứng dụng nào cũng có thể thay thế được nếu họ đánh mất sự tin tưởng của cộng đồng. Đây là cách nhận thức của người dùng đảm bảo sự phân quyền
Chương trình Octopus Accelerator là gì?


Nhóm Octopus nhận thức rõ rằng không gian blockchain vẫn chỉ là một phần nhỏ của toàn bộ ngành công nghiệp internet. Và trong không gian blockchain, các nhà phát triển hợp đồng thông minh Solidity đang sung mãn hơn nhiều so với các nhà phát triển Substrate.

Để tìm kiếm và thu hút các dự án chuỗi ứng dụng nổi bật, nhiệm vụ đầu tiên là chuyển đổi các nhà phát triển Web và Solidity thành các nhà phát triển Substrate. Về vấn đề này, đội ngũ Octopus rất giàu kinh nghiệm.

Nhóm Octopus đã xây dựng thành công IBC cho Chất nền và cũng đã cung cấp các khóa đào tạo trực tuyến về Chất nền ở Trung Quốc với những người đam mê Chất nền khác. Các khóa học này đã đào tạo hàng loạt các nhà phát triển Vật liệu nền đầu tiên ở Trung Quốc, khởi tạo nguồn gốc của Cộng đồng Vật liệu nền Trung Quốc. Các nhà phát triển Octopus cũng là nhà tổ chức của cộng đồng Rust ở Trung Quốc (bao gồm cả RustCon).

Cho đến nay, nhiều thành viên của nhóm Octopus đã làm trợ giảng cho khóa học, hiện là khóa học chính thức được tài trợ bởi Parity, Inc. Dựa trên những kinh nghiệm này, chúng tôi đang đàm phán với các đối tác trên toàn thế giới, bao gồm cả nhóm giáo dục NEAR, để cung cấp các khóa đào tạo tương tự trên toàn cầu.

Nhưng Octopus nhận ra rằng các nhà phát triển Substrate đủ điều kiện không phải là mọi thứ mà các dự án ứng dụng Web3.0 thành công yêu cầu. Đây là lý do tại sao chúng tôi ra mắt Chương trình Octopus Accelerator - một bộ sưu tập các khóa học và hội thảo mở và có thể tổng hợp được dành cho cả các nhà phát triển Substrate và các nhóm Web3.0 trên toàn thế giới.

Mỗi quý, Chương trình Tăng tốc Octopus sẽ tổ chức một loạt các khóa học kéo dài mười tuần. Trong mỗi thời gian khóa học, các môn học được cung cấp sẽ bao gồm các chủ đề như Kinh tế học mã thông báo, Thiết kế sản phẩm Web3.0, Xây dựng cộng đồng, Quản trị chuỗi khối, Quy định về tiền điện tử và Gây quỹ dự án tiền điện tử. Các chuyên gia được mời sẽ tham gia vào các cuộc hội thảo, cung cấp video về các chủ đề cụ thể và sẵn sàng làm cố vấn.

Vào cuối mỗi đợt khóa học, Octopus Foundation sẽ tổ chức sự kiện Demo Day để chọn ra năm dự án chuỗi ứng dụng hàng đầu và cung cấp cho họ tổng phần thưởng lên đến 200 nghìn đô la OCT.

Bằng cách này, Octopus Foundation sẽ tài trợ trực tiếp cho 20 dự án chuỗi ứng dụng thông qua Chương trình Octopus Accelerator mỗi năm, cung cấp cho họ tổng cộng 1 triệu đô la OCT. 




	

	
	
		
			
				Câu trả lời đúng về Octopus Development Team
			
		

		
					

		
			
			
			
			Octopus Development Team xây dựng IBC cho Substrate
		
			
			Octopus Development Team hỗ trợ đào tạo các nhà phát triển Substrate đầu tiên tại Trung Quốc
		
			
			Octopus Development Team trước đây có tên là Cdot
		
			
			Tất cả những điều trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Cách Appchains hoạt động trên Octopus


Thiết kế kiến trúc của Mạng Octopus - cùng với sức mạnh xử lý của Giao thức NEAR - giúp dễ dàng lưu trữ hàng trăm appchains. Quá trình lựa chọn chuỗi ứng dụng là một phần của giao thức Octopus và quyền quyết định thuộc về Cộng đồng Octopus.

Bên cạnh việc là Trình xác thực và Ủy quyền chuỗi ứng dụng, chủ sở hữu mã thông báo $OCT có quyền chọn các dự án chuỗi ứng dụng tốt nhất bằng cách tán thành hoặc phản đối trong hàng đợi ứng viên trên chuỗi.

Các chuỗi dựa trên chất nền có thể trở thành appchains của Octopus bằng cách hoàn thành thành công các giai đoạn sau:

 	Đăng ký - registration
 	Kiểm toán - audit
 	Biểu quyết - voting
 	Dàn dựng - staging
 	Khởi động - booting

 
Giai đoạn đăng ký – resigstration stage
Bất kỳ chuỗi dựa trên Chất nền nào cũng có thể đăng ký để trở thành chuỗi ứng dụng Octopus. Việc đăng ký yêu cầu giấy trắng hoặc thông số kỹ thuật và bản phát hành thời gian chạy đã được kiểm tra và đánh giá nội bộ. Để tránh lạm dụng, đăng ký yêu cầu một khoản tiền gửi nhỏ $ OCT.

 
Giai đoạn kiểm tra – Audit stage
Sau khi chuỗi ứng dụng được đăng ký, các thành viên của lực lượng đặc nhiệm cộng đồng sẽ kiểm tra nó. Mục đích của việc kiểm tra là để đảm bảo rằng chuỗi ứng dụng không có lỗ hổng bảo mật đã biết và logic ứng dụng của nó phù hợp với sách trắng hoặc thông số kỹ thuật của nó.

Bản thân việc kiểm tra chuỗi ứng dụng hiện đang là một nhu cầu chưa được đáp ứng trong không gian blockchain. Chỉ một số công ty trong ngành có kinh nghiệm liên quan và dịch vụ mà họ cung cấp rất đắt.

Việc kiểm toán do Octopus Network thực hiện không chỉ giúp giảm đáng kể chi phí khởi chạy chuỗi ứng dụng cho những người sáng lập mà còn góp phần tích lũy kiến thức liên quan và năng lực chuyên môn.
Giai đoạn bỏ phiếu – Voting stage
Khi một chuỗi ứng dụng đã vượt qua giai đoạn kiểm tra, nó sẽ đi vào hàng đợi ứng viên, nơi nó sẽ được những người nắm giữ $OCT ủng hộ hoặc phản đối.

Trong một khoảng thời gian kéo dài từ một đến hai tuần, chuỗi ứng dụng đứng đầu với số phiếu ủng hộ nhiều nhất trừ phiếu phản đối giảm trong hàng đợi sẽ chuyển sang trạng thái sắp xếp là chuỗi ứng dụng được hỗ trợ nhiều nhất bởi Cộng đồng Octopus.
Giai đoạn dàn dựng – staging stage
Trong giai đoạn tổ chức, chủ sở hữu $OCT có thể đặt cược hoặc ủy quyền trên chuỗi ứng dụng.

Khi giai đoạn giai đoạn kết thúc, nếu chuỗi ứng dụng đã thu hút đủ lượng đặt cược vượt quá điểm mấu chốt bảo mật, nó sẽ chuyển sang trạng thái khởi động.
Giai đoạn khởi động – Booting Rewards
Trong giai đoạn khởi động, các thành viên của lực lượng đặc nhiệm sẽ chạy 4 nút khởi động để khởi động chuỗi ứng dụng. Sau đó, Trình xác thực sẽ chạy các nút của họ để tham gia đồng thuận chuỗi ứng dụng.

Octopus Network cũng sẽ chạy một cụm nút đầy đủ cho mỗi chuỗi ứng dụng và cung cấp các dịch vụ truy cập API cho giao diện người dùng của chuỗi ứng dụng. Sau đó, các nhà phát triển chuỗi ứng dụng chỉ cần cập nhật cấu hình giao diện người dùng và chuỗi ứng dụng đã sẵn sàng cho người dùng cuối.
Phần thưởng chuỗi ứng dụng – Appchain Rewards
Octopus nhận ra rằng các dự án chuỗi ứng dụng là những người tạo ra giá trị của mạng. Trong khi các mạng đa mạng khác tính phí nhập học cho các appchains, Octopus coi các nhóm appchain là thành phần quan trọng nhất của cộng đồng và rất vui khi được chia sẻ lợi ích của việc mở rộng hiệu ứng mạng với họ.

Do đó, 100 appchains Octopus ra mắt đầu tiên sẽ được thưởng trực tiếp 100k $OCT.

Ngoài ra, quỹ đã quyết định cung cấp thêm phần thưởng 1 triệu đô la $OCT cho mười appchains đầu tiên công nhận họ là những appchains sáng lập.
$OCT token là gì?
$OCT, token gốc của Octopus Network, là một tokencó thể thay thế, không lạm phát với ba tiện ích chính:

 	Tài sản thế chấp để đảm bảo an ninh cho chuỗi ứng dụng
 	Quản trị
 	Xác nhận các ứng cử viên chuỗi ứng dụng bằng cách ủng hộ họ trong hàng đợi ứng viên

Tài sản đảm bảo – Security Collateral
$OCT đóng một vai trò quan trọng trong Octopus Network thông qua đặt cược chuỗi ứng dụng. Chủ sở hữu đặt cược $OCT của họ để cung cấp bảo mật cho các appchains mà họ tin tưởng để kiếm phần thưởng trong các token gốc của appchains tương ứng.

Đặt cọc $OCT cũng hoạt động như một biện pháp không khuyến khích đối với những người tham gia độc hại, những người sẽ bị phạt bằng cách cắt giảm $ OCT của họ, đây là nguồn bảo mật cho thuê appchains Octopus.

Khi Octopus hoạt động hết công suất, 30-50 appchains sẽ được tung ra trong mạng hàng năm.

Nếu tỷ lệ hoàn vốn cân bằng dài hạn của đặt cược chuỗi ứng dụng là 5% mỗi năm, chỉ riêng các ứng dụng mới ra mắt sẽ mang lại khoảng 400 triệu đô la cho nhu cầu tài sản thế chấp mỗi năm.
Quản trị - Governance
Chức năng thứ hai của $OCT là cho phép chủ sở hữu kiểm soát việc quản lý mạng, (cụ thể hơn là Octopus Relay nơi áp dụng tất cả các quy tắc kinh tế) bằng cách hình thành Octopus DAO.

Hội đồng Octopus DAO có tối đa 100 thành viên, nhưng nhiều khả năng sẽ phát triển từ một vài thành viên ban đầu lên vài chục khi ổn định.

Quyền lực quản trị của mỗi thành viên Hội đồng là có giá trị nhưng vẫn đủ phân tán để tránh thông đồng.

Theo ý kiến của chúng tôi, trong hầu hết các trường hợp, giá trị quản trị của mã thông báo không thể tách rời khỏi giá trị tiện ích của nó. Một quản trị hợp lý và có sự tham gia rộng rãi sẽ mang lại cho chủ sở hữu mã thông báo kỳ vọng giá trị ổn định hơn và ngăn chặn những biến động lớn về giá mã thông báo, do đó giảm chi phí tùy chọn ngầm của việc đặt cược chuỗi ứng dụng.
Bỏ phiếu – Appchain Voting
Chức năng thứ ba của $OCT thông qua người nắm giữ $OCT là lựa chọn các appchains nào sẽ tiếp tục hoạt động trong mạng bằng cách ủng hộ hoặc phản đối các ứng viên chuỗi ứng dụng.

Các nhóm Appchain sẽ cần thuyết phục cộng đồng Octopus rằng ứng dụng Web3.0 của họ có ý nghĩa và sẽ tạo ra các luồng giá trị liên tục cho các nhà đầu tư đặt cọc $OCT trên appchains của họ.

Những người nắm giữ $OCT sẽ chọn những appchains mà họ hỗ trợ một cách cẩn thận, vì sẽ có chi phí cơ hội nếu bỏ lỡ những app có thể có giá trị hơn.
Kết.
Chúng tôi đặt tên cho Mạng lưới Bạch tuộc theo tên sinh vật đáy biển thông minh dữ dội nhất. Từ quan điểm tiến hóa, bạch tuộc, bao gồm khoảng 300 loài, là một sinh vật cực kỳ thành công. Nó đã tồn tại khoảng 155 triệu năm, sống ở mọi đại dương và nhiều loài của nó đã thích nghi thành công với một loạt các môi trường sống biển đa dạng.

Chúng tôi hoàn toàn mong đợi Mạng Octopus cung cấp các ứng dụng phi tập trung cho mọi ngành công nghiệp trực tuyến mà người trung gian truyền thống Web2.0 trước đây đã kiểm soát - và trả lại giá trị cho những người sáng tạo thực sự.

Trong Mạng Octopus, chúng tôi có thể xây dựng các ứng dụng Web3.0 với trải nghiệm người dùng tuyệt vời bằng cách tận dụng công nghệ chuỗi ứng dụng - cho dù trong trò chơi, NFT, DAO, quảng cáo, nền kinh tế của người sáng tạo (video, âm thanh, đồ họa, văn bản), thị trường dự đoán, mã thông báo sổ đăng ký được quản lý (TCR) và hơn thế nữa.

Làn sóng đổi mới công nghệ tiền mã hóa thứ 3 hiện đang được mở ra trên mặt sau của Octopus đa năng mang theo tiềm năng tạo ra một cơn sóng thần của sự đổi mới phi tập trung Web3.0 - chỉ bị giới hạn bởi trí tưởng tượng.

### LearnNEAR.Club LNC Weekly Update - August 1, 2021

Brief Summary:

 	July Demo day was a blast!

Results:

 	July Demo Day  - 4 demo projects - check these 4 repositories at https://github.com/Learn-NEAR-Club - 2 projects were implemented in Rust language

$NEAR 400 were sent to projects developers
https://youtu.be/FLW22OLvV4Y



 	Guide  from NEAR ecosystem -What is Octopus Network?



 

Challenges & Blockers:

 	Looking for more learning materials from NEAR Collective

Action Items:

 	Ask and Answer questions about NEAR

### LearnNEAR.Club LNC Weekly Update - July 23, 2021

Brief Summary:



Busy with improving (L)Earning experience and getting more learning materials from NEAR ecosystem



Results:




Better code display added to Guides
Learn NEAR in Spanish -  ¿Qué es el protocolo NEAR?Challenges & Blockers:





RUST language learning materials are quire rare




Action Items:




Demo Day is coming - July 30th, 11 am EDT.




 

### Berry Club

Una dApp donde puedes cosechar tokens dibujando!
Saludos a mi querida familia hispana desde



NEAR Hispano


Hoy les voy a enseñar una dApp muy divertida con la que pueden interactuar, hacer dibujos y recibir recompensa en forma de tokens!
El primer paso es ingresar a https://berryclub.io y allí deben loggear con su wallet de Near dando un permiso.





1) Ingresar y dar click en Log in


2) Click en “Allow” autorizando a la dApp
Bien, luego de dar permiso a la dApp podemos utilizar nuestros NEAR para adquirir AGUACATES, es decir, le damos click en comprar 25 Aguacates por 0.1 Near transformando nuestros NEAR en AGUACATES.
*Near → Aguacates*
Luego podemos dibujar eligiendo un color, por cada pixel gastamos un aguacate.













Se observa que hay un tiempo para dibujo libre que no cobra Aguacate para dibujar.
Bien, cuando dibujamos podemos tener elegido en “Farming preference” Aguacates o Bananas. Por cada pixel que tengamos dibujado en el cuadro recibimos aguacates o bananas por día, fíjense que dibuje un unicornio, me tomo unos 418 píxeles, y por ello me aparezco en la tabla a la derecha de primero en lo más alto con 418 bananas por día.
Esto quiere decir que si nadie borra mi dibujo, o dibuja encima de los píxeles a los cuales les dí color, entonces en un día tendré 418 bananas.













Se puede observar fritzw…r.near (+418 bananas/día)
Ahora, hay quienes dibujan con opacidad/transparencia como se pide, porque el programa toma fotos cada tanto para luego vender los dibujos en el market place Berry Cards: https://berry.cards/
Por ello si no quieres dibujar y solo quieres recibir bananas o aguacates puedes dibujar con opacidad y así el dibujo se mantiene pero el pixel para “farmear” es tuyo.
Aquí observamos como marcel1111.near no le importan los dibujos ni seguir las reglas por lo que hizo un cuadro negro q daño el unicornio →













marcel1111.near haciendo de las suyas
Si te colocas encima de los usuarios el programa muestra los pixeles que tienen coloreados, por ejemplo encima de mi usuario se ve que muchos colorearon ya encima del unicornio con opacidad/transparencia →













Otros usuarios dibujaron con opacidad manteniendo el arte
En aproximadamente 11 horas borraron el arte entre varios usuarios, es difícil conseguir gente educada incluso en el mundo digital.













Arte eliminado
Pero muchos artes se salvan y pueden votar por los que más les guste o comprarlos como NFTs en https://berry.cards/













Berry Cards Elección
Volviendo ahora a la producción de tokens, una vez que tenemos bananas, podemos cambiarlas por pepinos https://farm.berryclub.io













Intercambiar Bananas por Pepinos
Yo conseguí con una inversión de 5 NEAR adquirir 87 bananas en 11 horas, con las cuales al transformar en pepinos pasas a dejar esos tokens en un estado infinito de STAKING, se observa en la siguiente imagen la cantidad a recibir de reward en NEAR:













Staking
Un día despues tengo en saldo 0.016 Near ! Bueno algo es algo, hehe. Se hizo una prueba exitosa y ya tenemos unos números base, y se esta generando dinero sólo sin que tengamos que mover un dedo más, bueno quizás si uno, darle click al boton de “Claim 0.016 N” para retirar de la dApp hacía mi Wallet.













Posibilidad de retirar 0.016 NEAR
Otra opción con nuestras bananas es vender las bananas por NEAR en un exchange descentralizado como https://app.ref.finance en el cual realizamos log-in igualmente como hicimos en Berry Club así la dApp sabe que poseemos unas bananas y nos permitirá intercambiarlas por NEAR.
De todas todas, pasaremos un buen rato y obtendremos NEAR como recompensa por nuestro Arte o el bullying que le agamos al arte de otro como hizo nuestro nefasto compañero marcel1111.near, del cual esperamos que este leyendo esto y le deseamos mucha felicidad con sus bananas para que pueda obtener el pepino que tanto anhela.
Hasta la próxima! =)

### What is Octopus Network?

In April 2024, during the Bitcoin halving, Octopus Network quietly rebranded as Omnity Network—shifting away from the NEAR Protocol to focus on building a new trust-minimized interoperability and programmability layer for Bitcoin.
Expected result: a general understanding of the Octopus Network from an end-user perspective

An Octopus is very different from a human. Instead of having a centralized nervous system as humans do, two-thirds of an octopus' neurons are spread throughout its body and distributed amongst its arms. Those neurons can make decisions on their own without input from the brain — essentially making the octopus a decentralized intelligent life form.

The Octopus Network is a multichain interoperable cryptonetwork that emulates the Octopus. Like the arms of an octopus, each connected application-specific blockchain (appchain) is empowered with its own intelligence and decision-making mechanisms to adapt to ever-changing environments. When connected as a whole, all members benefit from significant network effects and economies of scale — creating an Internet of Blockchains.



Octopus Network is a multichain cryptonetwork for launching and running Web3.0 application-specific blockchains — appchains.

Appchains in the Octopus Network benefit from flexible and cost-effective leased security (LPoS), out-of-the-box multichain interoperability, complete infrastructure, and a ready-to-be-engaged community.

The Octopus Network decreases the cost to launch an appchain from several million dollars to less than one hundred thousand dollars — unleashing the 3rd Innovation Wave of Cryptonetworks.
The Evolution of Web3.0 Applications
Web3.0 hasn't happened yet. But based on first principles, we’re certain it ultimately will.

Trading always flows to the market with lower transaction costs, just like water always flows downhill.

Web2.0 platforms are owned and run by companies whose goals are directly aligned with maximizing shareholder value. They extract as much profit as they can from the economic activities they coordinate. Cryptonetworks are digital service marketplaces with minimized transaction costs. So Web2.0 platforms simply have no defense against eventually being replaced by cryptonetworks.

Web3 refers to decentralized applications running on blockchains that are owned by the user community rather than profit extracting corporations. Web3.0 aspires to return value to the real creators.

But Web2.0 platforms are fantastic for Internet Users. For a Web3.0 application to supplant a Web2.0 application, it has to be a great Web application in the first place and provide a user experience that is at least as good as its Web2.0 counterpart.

Web3.0 application development typically has to sacrifice user experience because distributed ledger technology involves more complexities and increased costs than Web2.0 — which results in downgraded UX.

But a 3rd Cryptonetwork Innovation Wave is upon us and it’s bringing promising Web3.0 application solutions in with the tide.
The 3rd Cryptonetwork Innovation Wave
Bitcoin is an application-specific blockchain (appchain) — the first and the most successful one.

Inspired by Bitcoin, an assortment of appchains then developed from 2011 to 2015. Some tried to become a better Bitcoin, while the others targeted a variety of use cases other than currency — leaving us with a plethora of dead coins. The commonly agreed-upon reason for this is that the Bitcoin blockchain was purpose-built and unsuitable to address other use cases by being forked or extended. We can call this period the “1st Cryptonetwork Innovation Wave.”

The 2nd Cryptonetwork Innovation Wave was born with Ethereum. Ethereum is a general-purpose public blockchain equipped with a Turing-Complete virtual machine (which could theoretically execute any computation, as long as it remains within the complexity limitation, aka gas limit.) The major EVM programming language, Solidity, with its Javascript-like syntax, is easy to learn and very good at controlling on-chain assets.

Ethereum enabled thousands of developers to build decentralized applications (dApps). Unfortunately, very few could retain many users for an extended period of time until the 2020 DeFi explosion.

But the key challenge facing Ethereum is scalability — and gas fees for running smart contracts have made certain use cases prohibitively expensive. While Ethereum 2.0 aims to target these issues with a sharded blockchain protocol, Ethereum 2.0 is a multiple-year roadmap with unknown execution risks.

However, a 3rd Cryptonetwork Innovation Wave is right around the corner. Blockchain frameworks such as Substrate and Cosmos SDK can provide an unprecedented colossal design space to Web3.0 application developers.

Developers are now able to deliver a fully optimized Web3.0 application by building an appchain.


What is an Appchain?
A decentralized application or dApp, is a web application with at least a portion of its backend residing on a blockchain. A dApp’s backend can be implemented in two ways — smart contracts can be hosted on a blockchain platform, or a decentralized application could live on its own dedicated blockchain.

When a dApp has its own blockchain, it’s called an application-specific blockchain, or appchain for short. Unlike dApps, appchains allow developers to customize their application in terms of governance structure, economic design, and even its underlying consensus algorithm.

Appchains also give developers dedicated transaction processing capacity, which means that an application on an appchain doesn’t have to compete with other applications for transaction processing capacity on a network.

To illustrate, while thousands of different applications might share a standard set of configurations on a generic smart contract platform, each appchain in a PoS setting could easily achieve 1K+ TPS throughput and fast finality — and all this transaction processing capacity would be dedicated to just one application.

Unlike smart contracts, appchains can evolve quickly with legitimacy. Each appchain is a self-governed economy with code-defined explicit processes to reach agreements on protocol upgrades. And, thanks to Substrate, the primary function of on-chain governance is ready to use. Any cryptonetwork can mirror the governance process of another by copy-pasted code. Blockchain governance itself could evolve like open-source software.

Still, no one can ignore that smart contracts are great for asset trading use cases, e.g., DeFi. Because smart contracts run based on the same security assumptions, composability between them is the essential recipe for the DeFi explosion.

However, while DeFi’s user experience is not quite as bad as online banking, it still has a lot of room for improvement, especially when considering a more capable layer 1 blockchain than Ethereum — such as NEAR Protocol.
Why did Octopus choose NEAR?
While Substrate and Cosmos SDK have decreased the development cost of appchains to a level at least comparable with smart contracts, appchain bootstrapping is still a technically complex and capital-intensive job for developers.

NEAR Protocol is a sharded proof-of-stake (PoS) blockchain that emphasizes scalability and usability. NEAR is often referred to as a ready-made scalability solution for existing Ethereum dApps, but it is equally capable of handling a suite of other types of decentralized solutions — such as appchains.

Compared to other Layer 1 platforms that can also accommodate appchains, such as Polkadot or Cosmos, NEAR has some key technical and economic advantages.

Compared to Cosmos, launching an appchain on NEAR is easier because validators don’t need to be bootstrapped for each individual appchain.

For example, on Cosmos, each appchain must secure itself with a sufficiently staked, decentralized validator set. So, an appchain’s developers have to first obtain the value recognition of the appchain’s native token in the crypto-asset markets, then bootstrap an active validator community from the ground up.

Compared to Polkadot, NEAR offers appchains a significantly less expensive security lease and doesn’t have a limit on the number of appchains capable of being launched.

A Polkadot parachain must be able to afford the consensus cost of one shard of the network — which could equate to tens of millions of dollars a year.

In a computation system, higher security doesn’t necessarily equate with better security, because a higher level of security always comes with a higher level of cost. So, what a computation system needs is appropriate and adequate security.

In Polkadot, developers don’t get to decide an appropriate and adequate level of security for their parachain. They only have one choice —  win a slot in the auction. But even if a parachain wins the auction, it usually overpays for security because a cryptonetwork in its launching phases doesn’t need a multi-billion dollar level of security.

Furthermore, a high-level security cost burden from the onset could plunge a parachain into hyperinflation because it has to promise to issue a massive chunk of native tokens to Crowdloan lenders. At the very least, this economic burden leaves a parachain very little room to incentivize the real value-creators of its protocol — the participants who help build the network effects of the cryptonetwork.

To put it simply, NEAR was chosen by Octopus over Polkadot and Cosmos because it’s simply more cost-effective, scalable, user-friendly, and interoperable with networks like Ethereum than any other existing L1 solution.

We believe that appchains will be the 3rd Innovation Wave of Cryptonetworks that usher us into Web3.0 — and that Octopus Network will make appchains accessible to myriad projects with all kinds of budgets.




	

	
	
		
			
				What is an appchain?
			
		

		
					

		
			
			
			
			 A decentralized application
		
			
			A general-purpose blockchain
		
			
			An application-specific blockchain
		
			
			A smart contract
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






The Advantages of Leased PoS (LPoS)

What is security in the context of blockchain?

Simply put, security is the level of certainty that the predefined protocols will be applied as most stakeholders expected — whether at the base layer or application layer.

Blockchain security is generally considered a quantifiable property. There can’t be absolute or unlimited security. If a blockchain had absolute security, it must be both unusable and unaffordable.

Compared to a Polkadot parachain’s shared security model, the Octopus Network’s appchain Leased PoS (LPoS) is far more scalable and flexible. Because security leasing is essentially capital leasing or collateral leasing, it scales without physical limitations.

In Polkadot, each parachain will accommodate a certain number of validators in the pool exclusively in any given epoch. The consensus algorithm limits the total size of the pool. (That’s why the total number of parachains is expected to be under 100 with less than 10 parachain slots available this year.)

Octopus’s Leased PoS is much more cost-effective than Polkadot’s. Since Octopus doesn’t have its own blockchain, and the $OCT token is issued and managed by a smart contract, Octopus doesn’t need to pay for consensus costs directly. So, the $OCT inflation rate could be set to zero, which means the base interest rate of the Octopus economic system is zero.

When the base interest rate is zero, a 3%-5% APY is a decent annual return, (which is the range we expect an appchain will pay for their leased security.) In contrast, a Polkadot parachain has to pay 20% or more APY to make itself attractive to Crowdloan $DOT lenders because staking on the Polkadot Relay will give investors a 14% risk-free annual return.

Because LPoS is needs-based security and offers appchains the cost-effective leverage to scale organically, we believe that LPoS is more conducive to the long-term development of appchains than independent PoS. However, we also believe that the right to choose always belongs to any appchain community.

Should any appchain on the Octopus Network choose to stop using LPoS in order to transform into an independent PoS blockchain, Octopus will even provide the tools to support its transformation — Its connection with the Octopus Network would then be downgraded to that of a standard IBC bridge and existing cross-chain assets would not be affected.
Overview of the Octopus Network

Legend: D-Delegator, S- Staking, V- Validator, RT - Runtime, N- Node
The Octopus Relay is situated at the core of the Octopus Network. The Octopus Relay is a set of smart contracts running on the NEAR blockchain (aka mainchain) that implements the security leasing market.

Octopus appchains sit on the demand side of the market. Octopus appchains lease security from $OCT holders by paying rent in their native tokens. Each appchain can choose its own economic model, including how many native tokens it’s willing to pay Validators for security.

Octopus Validators and Delegators sit on the supply side of the security leasing market.

Octopus Validators stake $OCT tokens to validate a particular appchain and set up a node to run that appchain’s protocol. In return, Validators are eligible to receive the respective native token of the appchain they are validating.

Octopus Delegators can delegate their $OCT to Validators for a share in the staking rewards of an appchain’s native token. Staking rewards are distributed to Delegators directly after Validators collect a unified commission.

If Validators misbehave (e.g. go offline, attack the network, or run modified software), they (and their Delegators) are slashed by losing a percentage of their staked $OCT. All punishments are applied to Delegators proportionally when their Validators get slashed. In this way, staking acts as a disincentive for malicious behavior.

Because $OCT holders are responsible for deciding which appchain they’d like to stake on, the Octopus Network works as a free market where appchains can lease the level of security they need at market price any time.

The Octopus Network also has a series of tools for security providers, such as appchain validator node automatic deployment and management tools, network economic views, and statistical analysis tools.

The Octopus Network LPoS market enables any developer, project, or entrepreneur to quickly, efficiently, and affordably create their own appchain on NEAR.

But the Octopus Network also supports appchains in many other ways including providing crosschain interoperability, built-in infrastructure, and a ready-to-be-engaged community.




	

	
	
		
			
				What are the advantages of LPoS?
			
		

		
					

		
			
			
			
			LPoS is cost-effective
		
			
			LPoS is flexible
		
			
			LPoS is scalable
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Interoperability
It’s less controversial now to assert that all public blockchains and multichain networks will eventually be interconnected — forming the Internet of Blockchains. The Octopus Network is specifically designed to be a part of this.

The Octopus team (previously known as Cdot) has been working on universal blockchain interoperability protocol IBC and cross-chain integration for more than two years.

The Octopus Relay enables appchains’ interoperability with NEAR protocol and Ethereum via the Rainbow Bridge. Additionally, appchains can utilize an out-of-box IBC pallet to connect with any IBC enabled blockchains directly.

Any asset issued on Ethereum, NEAR, or any IBC enabled blockchain can be transferred into and utilized by Octopus appchains trustlessly. Conversely, any assets issued on appchains can be transferred trustlessly out to Ethereum, NEAR, and any IBC enabled blockchain.

Based on seamless interoperability between the Octopus Network and NEAR, the variety of crypto assets issued on Octopus appchains will also contribute to the prosperity of NEAR’s DeFi ecosystem.
Infrastructure
The Octopus Network provides a complete set of infrastructure for appchains —  including API Gateway, Blockchain Explorer, Archive Gateway, etc.

The Octopus Bridge will deploy a NEP-141 wrapper contract on NEAR for each appchain native token. Then wallets and exchanges can integrate standard wrapper tokens rather than having to integrate with each appchain individually.

So, appchain teams only need to focus on Substrate runtime and front-end development while the Octopus Network handles all the other technical necessities.
Community
A cryptonetwork is owned by its community. This is the essence of decentralization and the fundamental difference from Web2.0 platforms.

The Octopus Network acts as a meta-community for nurturing hundreds of Web3.0 application communities. Web3.0 application developers and appchain founders can display the merits of their cryptonetwork to attract a variety of supporters — such as investors, Validators, Delegators, and protocol participants.

Users interested in different Web3.0 applications will pay attention to their favorite applications through events such as the Octopus appchain launchings. In this way, Octopus is a community-base for appchains to support their own journey of building active communities around them.

The Octopus Network also provides great forkability to all its appchains, making it meaningless for any type of tycoon or tyrant to takeover an appchain without agreement from the community —  keeping it decentralized. Octopus will serve all its appchains with forkability by archiving the appchain block history to Arweave — a decentralized permanent storage protocol.

Based on the archived block history, every appchain can be forked at any height to become a new appchain if its community supports the fork. And any appchain core team is replaceable if it loses the trust of its community. This is how user awareness ensures decentralization.
What is the Octopus Accelerator Program?
 



The Octopus team is well aware that the blockchain space is still just a sliver of the entire internet industry. And within the blockchain space, Solidity smart contract developers are much more prolific than Substrate developers.

In order to find and attract outstanding appchain projects, the first task is to transform Web and Solidity developers into Substrate developers. In this regard, the Octopus team is very experienced.

The Octopus Team has successfully built IBC for Substrate and has also offered Substrate online training courses in China with other Substrate enthusiasts. These courses trained the first batch of Substrate developers in China, initializing the genesis of the Chinese Substrate Community. Octopus developers are also organizers of the Rust community in China (including RustCon).

To date, many members of the Octopus team have served as teaching assistants for the course, which is now an official course funded by Parity, Inc. Based on these experiences, we are negotiating with partners worldwide, including the NEAR education team, to provide similar training courses globally.

But Octopus recognizes that qualified Substrate developers aren’t everything that successful Web3.0 application projects require. This is why we’re launching the Octopus Accelerator Program — a collection of open and composable courses and seminars available to both Substrate developers and Web3.0 teams worldwide.

Each quarter, the Octopus Accelerator Program will hold a batch of courses lasting ten weeks. During each course period, subjects offered will include such topics as Token Economics, Web3.0 Product Design, Community Building, Blockchain Governance, Crypto Regulation, and Crypto Project Fundraising. Invited experts will participate in seminars, provide videos on specific topics, and be available as mentors.

At the end of each batch of courses, the Octopus Foundation will hold a Demo Day event to select the top five appchain projects and provide them with up to $250k in total rewards per quarter.

In this way, the Octopus Foundation will directly fund 20 appchain projects through the Octopus Accelerator Program each year, granting them more $1 mil in total.




	

	
	
		
			
				Which is true about the Octopus Development Team?
			
		

		
					

		
			
			
			
			The Octopus Development team built IBC for Substrate
		
			
			The Octopus Development team helped train the first Substrate developers in China
		
			
			The Octopus Development team was formerly known as Cdot
		
			
			All of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





How Appchains Go Live in Octopus


The architectural design of the Octopus Network — together with the processing power of the NEAR Protocol —  makes it easy to host hundreds of appchains. The process of appchain selection is a part of the Octopus protocol and the decision-making power belongs to the Octopus Community.

Besides being appchain Validators and Delegators, $OCT token holders have the right to select the best appchain projects by upvoting or downvoting in an on-chain candidate queue.

Substrate-based chains can become Octopus appchains by successfully completing the following stages:

 	Registration
 	Audit
 	Voting
 	Staging
 	Booting

Registration Stage
Any Substrate-based chain can apply to become an Octopus appchain. Registration requires a white paper or spec and a runtime release that has been internally tested and audited. To prevent abuse, the registration requires a small deposit of $OCT.
Audit Stage
After the appchain is registered, members of the community task force will audit it. The purpose of the audit is to ensure that the appchain has no known security vulnerabilities and that its application logic is consistent with its white paper or spec.

Appchain auditing itself is currently an unmet need in the blockchain space. Only a few companies in the industry have the relevant experience and the services they provide are expensive.

Auditing performed by the Octopus Network not only greatly reduces the cost of an appchain launch for its founders, but also contributes to the accumulation of relevant knowledge and professional capabilities.
Voting Stage
Once an appchain has passed the auditing phase, it enters the candidate queue where it will be upvoted or downvoted by $OCT holders.

In a rolling period that lasts one to two weeks, the appchain that ranks first with the most number of upvotes minus downvotes in the queue will enter the staging state as the most supported appchain by the Octopus Community.
Staging Stage
In the staging stage, $OCT holders can stake or delegate on the appchain.

When the staging period ends, if the appchain has attracted enough staking beyond the security bottom line, it will enter the booting state.
Booting Stage
In the booting stage, task force members will run 4 bootstrapping nodes to start the appchain. Then Validators should run their nodes to join the appchain consensus.

The Octopus Network will also run a full node cluster for each appchain and provide API access services to the appchain’s front-end. Appchain developers then just need to update the front-end configuration, and the appchain is ready for end-users.
Appchain Rewards
Octopus recognizes that appchain projects are the value creators of the network. While other multichain networks charge admission for appchains, Octopus considers appchain teams to be the most critical part of the community and is very happy to share the benefits of network effect expansion with them.

Therefore, the first 100 launched Octopus appchains will be directly rewarded with 100k $OCT.

In addition, the foundation has decided to provide an additional 1M $OCT rewards for the first ten appchains to recognize them as founding appchains.
What is the $OCT token?
$OCT, the native token of the Octopus Network, is a fungible, non-inflationary token with three primary utilities:

 	Collateral to guarantee appchain security
 	Governance
 	Endorsing appchain candidates by upvoting them in the candidate queue

Security Collateral
$OCT plays a key role in the Octopus Network through appchain staking. Holders stake their $OCT to provide security to the appchains they believe in to earn rewards in the respective appchains’ native tokens.

Staking $OCT also acts as a disincentive for malicious participants who would be penalized by having their $OCT slashed, which is the source of leased security for Octopus appchains.

When Octopus runs in its full capacity, 30-50 appchains will be launched in the network annually.

If the long-term equilibrium rate of return of appchain staking is 5% per annum, newly launched appchains alone would bring in about $400M in collateral demands each year.
Governance
The second function of $OCT is to entitle holders to control the governance of the network, (more specifically, the Octopus Relay where all economic rules apply,) by forming the Octopus DAO.

The Octopus DAO Council has a maximum of 100 members, but it’s most likely to grow from a few members in the beginning to a few dozen when stable.

Each Council member’s governance power is valuable but still dispersed enough to avoid collusion.

In our opinion, in most cases, a token’s governance value can not be decoupled from its utility value. A sound and widely participated-in governance will give token holders more stable value expectations and suppress extreme fluctuations in the token price, thereby reducing the implicit option cost of appchain staking.
Appchain Voting
The third function of $OCT via $OCT holders is the selection of which appchains will go on to live in the network by upvoting or downvoting on appchain candidates.

Appchain teams will need to convince the Octopus community that their Web3.0 application is meaningful and will create continuous value streams for investors who stake $OCT on their appchains.

$OCT holders will select which appchains they support carefully, for there is an opportunity cost of missing those which could be more valuable.
Conclusion
We named the Octopus Network after the most fiercely intelligent marine benthic creature. From an evolutionary perspective, the octopus, which consists of some 300 species, is an incredibly successful organism. It’s been around for 155 million years, lives in every ocean, and its many species have successfully adapted to a wide range of diverse marine habitats.

We fully expect the Octopus Network to deliver decentralized applications for every online industry that the Web2.0 traditional middleman has heretofore controlled — and return value to the real creators.

In the Octopus Network, we can build Web3.0 applications with great user experience by leveraging appchain technology — whether in gaming, NFTs, DAO, advertising, the creators’ economy (video, audio, graphics, text), prediction markets, the token curated registry (TCR), and more.

The 3rd Cryptonetwork Innovation Wave is currently being ushered in on the back of the versatile Octopus bringing with it the potential for a tsunami of Web3.0 decentralized innovation —  limited only by the imagination.

### ¿Qué es el protocolo NEAR?

Resultado esperado: Entendimiento básico de cómo funciona NEAR desde la perspectiva del usuario final

NEAR es una plataforma de aplicaciones descentralizada que corren sobre el protocolo Blockchain de NEAR. Esta blockchain (cadena de bloques) que corre a través de cientos de máquinas alrededor del mundo, está organizada para ser sin permisos, preformateada y lo suficientemente segura como para crear una capa de datos fuerte y descentralizada para la nueva web.

La misión principal de NEAR es presentar una plataforma que sea ideal para correr aplicaciones que tengan acceso a un conjunto de fondos, identidades y datos compartidos y seguros que poseen los usuarios. Combina las características como la resistencia a particiones del networking, el procesado de datos sin servidores y el almacenamiento de datos distribuido en un nuevo tipo de plataforma.

Entonces, antes de avanzar más, aprendamos un poco de historia y veamos cómo las plataformas blockchain han evolucionado en el tiempo.
La evolución de la tecnología Blockchain
Desde que Satoshi Nakamoto presentó la documentación del Bitcoin en Octubre del 2008, el mundo se ha estado familiarizado con la tecnología que rompe paradigmas Blockchain. Durante la última década, el blockchain ha pasado por tres etapas de evolución.

Generación 1: Bitcoin

El Bitcoin es el ejemplo perfecto de la primera generación blockchain. El propósito de este blockchain es ser simplemente un sistema de pago directo. Empezando como la “moneda del internet”, el bitcoin se ha convertido en uno de los activos más demandados. Sin embargo, existe un problema mayor cuando se trata del BTC. Es inviable realizar transacciones complicadas con ellos, los cuales tienen varias capas de metadatos y logia ligados a sí mismos.

Generación 2: Ethereum y plataformas de contratos inteligentes

Ethereum marcó el comienzo de la segunda generación de plataformas blockchain con los contratos inteligentes. Finalmente los desarrolladores podrán programar transacciones sofisticadas a través de este contrato inteligente, y podrán crear aplicaciones descentralizadas (dApps). A través de estas dApps, los casos de uso de la blockchain se fueron hasta el cielo.

Sin embargo, este espacio ha estado con sus penas crecientes. La causa principal es que estas blockchains están sufriendo severos problemas de escalabilidad. Por ejemplo, Bitcoin tiene un rendimiento de 7 transacciones por segundo, mientras que Ethereum puede solo manejar 25. Cuando se compara eso con Paypal (115 tps) y Visa (1.700 tps) es bastante abismal.

Para ser justos, Ethereum y Bitcoin recientemente han estado tratando de resolver este problema de escalabilidad con varias soluciones de segunda capa como Lighting Network, raiden, protocolo plasma etc. La idea acá es crear una capa adicional sobre la blockchain subyacente donde el protocolo principal pueda delegar tareas repetitivas y tediosas.

Sin embargo, hay dos problemas principales con este enfoque. Principalmente, esta solución de segunda capa no ha recibido una aceptación por las masas. Segundo, esta solución de segunda capa arruina la arquitectura original del protocolo, lo cual podría tener implicaciones a largo plazo.

Acá es donde entra la tercera generación.

Generación 3: NEAR

Near es un ejemplo de blockchain de tercera generación que apunta a solventar los problemas de escalabilidad y además permitir a los usuarios finales y desarrolladores disfrutar de todo el potencial de los contratos inteligentes en la tecnología blockchain. En vez de confiar en una tecnología de segunda capa, NEAR se libera de la idea de que cada nodo que participa en la red tiene que ejecutar todo el código porque eso esencialmente crea un cuello de botella excesivo y ralentiza todos los demás enfoques.

Para arreglar este problema NEAR usa una técnica que ya está bastante prevalente en el mundo de la database, Sharding. Si se ejecuta adecuadamente, permite a la red una capacidad de escalar tanto como número de nodos vaya aumentando, entonces no existe un límite teórico de la capacidad de la red. La mejor parte? Sharding es una técnica de escalabilidad de primera capa.
¿Qué es Sharding? (fragmentación)
En una base de datos, a veces se tiene que lidiar con grandes bancos de datos. Esto obstaculiza dramáticamente el rendimiento y desempeño y hace que todo el proceso sea extremadamente ineficiente. Acá es donde entra el Sharding.

Sharding hace una partición horizontal de tu base de datos y la convierte en tablas más pequeñas y manejables.

Entonces, ¿por qué una partición horizontal y no una vertical?

Considere ésta tabla:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Ahora, si particionamos esta tabla verticalmente:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



¿Ve eso ?
Por la partición la tabla se convierte en dos tablas completamente diferentes.

¿Opuesto a eso, que pasa cuando la tabla se particiona horizontalmente?

¿Ve lo que ocurre? Cuando particiona verticalmente la tabla terminan convirtiéndose en dos tablas completamente diferentes juntas.

Sin embargo, si la particionamos horizontalmente:



A
B
A*B
A/B


3
3
9
1


4
4
16
1



¿Ve eso?
Una partición horizontal convierte la base de datos en tablas más pequeñas de la misma base de datos.
Estas bases de datos más pequeñas son llamadas Shards (particiones)
¿Cómo el Sharding ayuda al blockchain?
Como hemos visto hasta ahora, mientras más nodos entren al ecosistema de ethereum y Bitcoin, el proceso total de consenso y verificación toma cada vez más tiempo.

Ahora, ¿qué hará el sharding para ayudar a esto?

El Sharding va a romper el estado global de la blockchain en pequeños shards más manejables.

¿Qué pasa en la activación de shard?

 	El estado se divide en shards
 	Cada cuenta está en un shard, y las cuentas de ese shard solo intercambian con cuentas del mismo shard.

En términos más simples, imagine este escenario. Hay una red hipotética con tres nodos- A, B y C y tienen que verificar data T. La data T se rompe en tres Shards T1, T2 y T3. En vez de que todos esos nodos trabajen sobre T como un todo, pueden individualmente trabajar en un shard al mismo tiempo. Como puede ver la cantidad de tiempo que está salvando es exponencial.

A diferencia de otros enfoques de fraccionamiento, donde se requiere que los nodos corran en hardwares incrementalmente complejos (reduciendo la posibilidad de más personas de participar en la red), la técnica de NEAR permite a los nodos permanecer lo suficientemente pequeños como para correr en una simple instancia hosteada en la nube.
¿Por qué son necesarias las blockchains escalables como NEAR?
Pista: No se trata todo de la velocidad!

Cuando se trata de segunda y tercera generación de blockchain, lo que realmente determina su valor innato es el ecosistema de dapp que prospera sobre ella. Como tal, la mayoría de estas plataformas blockchain están en perpetua competencia para atraer la mayor cantidad de desarrolladores posibles.

Sin embargo, el problema con las plataformas actuales es que no tienen la sofisticación necesaria para albergar aplicaciones de alta calidad. El problema aquí es que tenemos desarrolladores tratando de crear juegos de PS4 en una plataforma que es equivalente al Windows 98. Por ende, necesitan comprometerse fuertemente en el funcionamiento general de sus dApps.

Además, hay otro factor que debería ser considerado aquí. La velocidad es un factor vital cuando se trata de la usabilidad de la aplicación. Después de todo, ¿por qué los usuarios van a usar una aplicación que no es para nada usable? Los desarrolladores requieren un determinado número de usuarios que usen continuamente su aplicación antes de que llegue a volúmenes críticos.

Es por esto que una plataforma blockchain que sea escalable como NEAR es importante para la adopción de la blockchain y contratos inteligentes.

NEAR permite a los desarrolladores simplemente desplegar sus aplicaciones sin pensar mucho en como la infraestructura alrededor de ella opera o escala, lo cual es más como las nubes modernas de Amazon AWS o GCP o Azure las cuales manejan casi todas las aplicaciones de la web hoy día.
Breve historia de NEAR
Near comenzó en verano del 2018 desde que Alex Skidanov y Illia Polosukhin decidiera pivotar lejos de sus previas aventuras de emprendimiento, si estas curioso puedes leer más sobre eso aqui (LINK). Rápidamente, mientras Misha renunciaba a MemSQL, el equipo se extendió desde varios a 9 personas en un plazo de tres días en Agosto. El equipo inicial consistió en 7 ingenieros, Erik haciendo operaciones de negocios y Sasha hablando al mercado.

Hoy día el colectivo de NEAR está distribuido globalmente en grupos de equipos, conformado por muchas organizaciones individuales y contribuidores, quienes se organizan a sí mismos para traer esta tecnología a la vida. No es un negocio o nada ni cercanamente tan formal. Piensas en eso como un grupo de personas quienes dirigen grandes proyectos de código abierto.

Uno de los colectivos de proyectos está escribiendo el código y la implementación de referencia para la red NEAR de código abierto, algo así como construyendo los propulsores de un cohete en el transbordador espacial. Su trabajo es hacer la investigación y desarrollo necesarios para ayudar a la blockchain a llegar a órbita. El código de esa cadena es público entonces literalmente cualquier persona puede contribuir en él o ejecutarlo.

Es importante mencionar que redes como NEAR son diseñadas para ser totalmente descentralizadas. Esto significa que al final operan completamente por sí mismas y no pueden de hecho ser censuradas, apagadas o afectadas por terceras partes… ¡Ni siquiera el equipo que inicialmente la construyó! Entonces, mientras miembros de este colectivo están aquí para hacer que la rueda gire y construir la implementación de referencia, ellos rápidamente se convierten en no esenciales para la operación de la red una vez que comienza a ejecutarse. De hecho, una vez que está lista para ejecutarse, nadie puede modificar y correr el código del protocolo NEAR para iniciar su propia blockchain porque todo es de código abierto y cualquier cambio tendría que ser democráticamente aceptado por los validadores independientes quienes lo ejecutan.
Cómo funciona la blockchain NEAR
La tecnología reafirmando la criptomoneda. Blockchain es una tecnología que puede de forma segura almacenar registros de transacciones en una red peer-to-peer en vez de almacenarlos en una sola locación. Servidores independientes alrededor del mundo, llamados nodos, constituyen la red que opera la blockchain.

Uno de los aspectos más definitivos de la tecnología blockchain es la descentralización. Entonces, ¿por qué es la descentralización tan útil? Vamos a mirarla desde la perspectiva de los desarrolladores y usuarios.

 	Desarrolladores: En el mundo descentralizado, los desarrolladores están frecuentemente a la merced de plataformas en la nube o incluso de gobiernos para asegurarse de que pueden continuar ejecutando sus aplicaciones. En el mundo descentralizado no hay intermediarios dominantes.
 	Usuario Final: La transparencia de aplicaciones descentralizadas permite a los usuarios ver el código backend y saber exactamente como las aplicaciones van a usar tu información personal.

¿Qué es el algoritmo de consenso de NEAR?

Protocolos de consenso son usados para llegar a acuerdos en un solo valor entre múltiples participantes de un sistema. Si todos los participantes de una red colaboran en concordancia con el protocolo de consenso, nuevos valores pueden ser adjuntados a la capa y verificados por nodos. Sin embargo, en el caso de disputas, la red puede concentrarse solo en seguridad o vivacidad.

El mecanismo de consenso implementado en NEAR es llamado Nightshade. El Nightshade modela el sistema como una única blockchain. La lista de todas las transacciones en cada bloque se divide en pedazos físicos, un pedazo por shard. Todos los pedazos se acumulan en un bloque. Nota esos pedazos solo pueden ser validados por nodos que mantengan el estado del shard.

Hablando de validación, un componente clave de NEAR son los validadores. Estos validadores son responsables por mantener consenso entre el protocolo. Los validadores son nodos especiales que necesitan mantener sus servidores el 100% del tiempo mientras mantienen sus sistemas actualizados constantemente.

Aquí tiene algunos puntos que debe tener en mente acerca de los validadores de la red.

 	NEAR determina sus validadores de red en cada nuevo epoch, eligiendolos basados en su propio stake. (Staking: Consiste en mantener fondos en un monedero de criptomonedas, para respaldar la seguridad y las operaciones de una red blockchain).
 	Los validadores ya elegidos se inscriben nuevamente automáticamente haciendo stacking de nuevo de sus tokens más las ganancias obtenidas.
 	Validadores potenciales deben tener sus stake por encima de un nivel dinámico determinado.
 	Hay dos métodos que un validador puede usar para fortalecer su stake. Comprar los tokens por sí mismos, o prestarlos a través de la delegación de tokens.
 	La recompensa que recibe es directamente proporcional al stake. Mientras más tokes tiene más recompensas recibe.

El consenso está basado en el consenso más pesado de cadena. Significa que,una vez que un productor de bloques produce un bloque, ellos recolectan las firmas de los validadores de nodos. El peso de un bloque es entonces el stake acumulativo de todos los firmantes cuyas firmas están incluidas en el bloque. El peso de la cadena es la suma de los pesos de los bloques. Adicionalmente, el consenso utiliza un aparato adicional para añadir seguridad a la cadena.



	

	
	
		
			
				Quiz: El peso de un bloque es:
			
		

		
					

		
			
			
			
			El stake máximo de los firmantes cuyas firmas están en el bloque
		
			
			La suma de los stakes de todos los firmantes cuyas firmas están incluidas en el bloque.
		
			
			El promedio de stake de toda la red, dividido entre el número de firmantes del bloque.
		
			
			Ninguna de las anteriores.
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Tiempo de ejecución (runtime) de NEAR

La capa de ejecución es usada para ejecutar contratos inteligentes y otras acciones creadas por los usuarios y pre servidores de estado entre las ejecuciones. Puede ser descrita desde tres ángulos diferentes: yendo paso a paso a través de varios escenarios, describiendo los componentes del tiempo de ejecución, y describiendo las funciones que el tiempo de ejecución realiza.
¿Qué es el token NEAR?
El token NEAR es fundamentalmente un activo nativo del ecosistema NEAR y su funcionalidad es habilitada por todas las cuentas. Cada token es un activo único digital similar al Ether, el cual puede ser usado para:

 	Pagar al sistema por procesar transacciones o por almacenar datos.
 	Correr un nodo validador como parte de la red por participar en el proceso de stacking.
 	Ayudar a determinar cómo los recursos de la red son asignados y donde su dirección técnica futura estará por participar en el proceso de gobernanza.

El token NEAR permite la coordinación económica de todos los participantes que operan en la red, además habilita nuevos comportamientos entre las aplicaciones las cuales están construidas sobre esa red.
¿Cómo comenzar con NEAR?
Cuenta/Billetera (wallet)

Antes de que comience con NEAR, lo primero que debe hacer es configurar una cuenta de NEAR.

Vea este video sobre las cuentas de NEAR:



La billetera le permite hacer llamadas de contratos a la blockchain, configurar tu nodo local, y enviar y recibir fondos de otros usuarios. Cuando registre el ID de su cuenta, debe proporcionar un nombre único. Además cada billetera debe tener un nombre único, cada usuario puede configurar múltiples billeteras.

Puede imaginar esto similar a las cuentas de facebook o google. Una vez que haya registrado a cualquiera de estos dos servicios, puede usar la misma cuenta para entrar a servicios de terceras partes. La diferencia entre el ID de una cuenta de NEAR y la cuenta de Google es que los datos, almacenados en contra de un ID de cuenta, son solo accesibles y manejables por el dueño de la wallet. Adicionalmente, toda la información es almacenada en una red distribuida de nodos en vez de un solo servidor.

Crea su cuenta de near ahora mismo: https://wallet.near.org/create

Información mas a fondo acerca de las cuentas en: https://learnnear.club/doc/videos/accounts-keys/
Explorador de NEAR
El explorador de near le permite ver la creación de bloques en tiempo real! Esta útil herramienta le permite buscar transacciones y cuentas permitiéndole ver todas las interacciones entre los usuarios y contratos inteligentes.


¿Cómo obtener tokens NEAR?
Hay 4 formas de obtener $NEAR
NEARs gratis para usuarios de Ethereum
Comience por configurar una billetera con un poco de NEARs gratis a través de la “faucet” para usuarios de ethereum: https://faucet.paras.id/
Ganalos
Puede ganar $NEAR participando en las recompensas de desarrolladores, guiando una comunidad, lo cual ayuda a las personas a construir sobre NEAR, ganando un hackathoon o participando activamente en la comunidad. Si tiene la posibilidad de hacer que otras personas le preste tokens para el staking; también puede ganar $NEAR por ser un validador. 
Compralos
$NEAR está disponible en varios exchanges principales (ver abajo), donde puede registrarse y comprar tokens usando tanto moneda fiat como cripto.

Exchanges que enlistan a $NEAR

Puede ver los resúmenes de precios y pares en coinmarketcap y coingecko.
De un amigo
No debe tener una cuenta de NEAR para recibir tokens de NEAR! El “NEAR Drop” es un enfoque que le permite a sus amigos pre-financiar una nueva cuenta y enviarle un hot link para reclamar los tokens.
¿Qué puedo hacer con los tokens NEAR?
Transferir NEAR
Envía y recibe  $NEAR entre cuentas tuyas y de tus amigos, chequea transacciones en el explorador de bloques. Debido a que las comisiones de transacción son tan bajas, usted puede rápida y fácilmente mover pequeñas cantidades de $NEAR para pagar con ellos.

Envielos como regalos en http://redpacket.near.org/
Pruebe un NEAR drop (Invite a un amigo
Envíe a su amigo un NEAR drop si necesita crear una cuenta.
Use aplicaciones NEAR
Para ver la creciente lista de aplicaciones que están siendo construidas en NEAR, haga click aquí.

Comience con NFT- compre/publique/intercambie arte en https://paras.id/

Juegue en BarryClub para participar en una creación colectiva de arte: https://berryclub.io/
¿Cuánto cuesta usar NEAR (Gas)?
Cuando usted realiza llamadas a la blockchain de NEAR para actualizar o cambiar datos, las personas corriendo la infraestructura blockchain incurren en ciertos costos. Al final del día, algunas computadoras en algún lado procesan su solicitud, y los validadores corriendo estas computadoras gastan cantidades significativas de capital para mantener estas computadoras ejecutándose.

Como otras blockhchains programables, NEAR compensa a estas personas cobrando comisiones por las transacciones, también llamadas gas fees.

Si está familiarizado con los proveedores de servicios de la nube web2 (Amazon Web Services, Google Cloud, etc), una gran diferencia con blockchain es que esos usuarios son cobrados inmediatamente cuando hacen una llamada a una aplicación, en vez de que los desarrolladores afronten el costo por usar toda esa infraestructura. Esto crea nuevas posibilidades, tales como aplicaciones que no tienen riesgo a largo plazo de desaparecer debido a que los fondos de los desarrolladores/compañía se acaben. Sin embargo, también viene con ciertos baches en cuanto a usabilidad. Para ayudar con esto, NEAR además provee la habilidad para los desarrolladores de cubrir el costo del gas para los usuarios, para crear una experiencia más familiar para aquellos que vienen de la web2.

Cuando piense en gas mantenga dos conceptos en mente

 	Unidades de gas: Internamente, las comisiones de transacción no son calculadas directamente en tokens NEAR, en cambio pasan a través de una fase de “gas units” (unidades de gas). El beneficio de las unidades de gas es que son determinantes - la misma transacción va siempre a costar la misma cantidad de unidades de gas.
 	Costo del gas: Las unidades de gas luego se multiplican por el costo del gas para determinar cuánto se debe cobrar al usuario. Este precio es automáticamente calculado en cada bloque dependiendo de la demanda de la red (si un bloque previo se llena mas de la mitad el precio sube, de lo contrario baja, y no cambiará en más del 1% cada bloque), y su valor mínimo está configurado en la red, actualmente 100 millones de yoctoNEAR.

Note que el precio del gas puede variar entre la red principal de NEAR y la red de pruebas. Chequee el precio del gas antes de confiar en los valores de abajo.

Pensando en gas

NEAR tiene más o menos un segundo de tiempo de bloque, conseguido a través de limitar la cantidad de gas por bloque. Las unidades de gas han sido cuidadosamente calculadas para trabajar en números fáciles de pensar.

10¹² unidades de gas, o 1 TGas (TeragGas)...

≈ 1 milisegundo de tiempo de “cómputo” 

…Lo cual, a un mínimo de precio de gas de 100 millones de yoctoNEAR equivale a 0,1 miliNEAR de comisión.

Este 1ms es una aproximación útil, y es la forma actual como se definen las unidades de gas en NEAR. Las unidades de gas no solo encapsulan tiempo de cómputo/CPU también, tiempo de ancho de banda/network y tiempo de almacenamiento/IO. A través del mecanismo de gobernanza, los parámetros del sistema pueden ser afinados, cambiando el mapeo entre Tgas y milisegundos en el futuro, pero lo antes mencionado sigue siendo un buen punto de partida para pensar lo que significa las unidades de gas y de dónde vienen.




	

	
	
		
			
				Quiz: 1 TeraGas o Tgas es igual a:
			
		

		
					

		
			
			
			
			1 microsegundo de tiempo de cómputo
		
			
			10 segundos de tiempo de cómputo
		
			
			1 milisegundo de tiempo de cómputo
		
			
			1 nano segundo de tiempo de cómputo
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





El costo de acciones comunes
Para darle un punto de partida sobre qué esperar en cuanto a costos de NEAR, la tabla inferior enlista algunas de las acciones más comunes y cuanto TGas requieren actualmente, y cuanto seria la comisión del mismo, en miliNEAR, al precio minimo de gas que es 100 millones de yN.



Operation
TGas
fee (mN)
fee (Ⓝ)


Create Account
0.42
0.042
4.2⨉10⁻⁵


Send Funds
0.45
0.045
4.5⨉10⁻⁵


Stake
0.50
0.050
5.0⨉10⁻⁵


Add Full Access Key
0.42
0.042
4.2⨉10⁻⁵


Delete Key
0.41
0.041
4.1⨉10⁻⁵



¿Cómo puedo ganar con NEAR?
Stakea tus NEAR
Una muestra de cómo está soportada la comunidad de validadores es la proof-of-stake (prueba de stake). Los validadores ganan tokens NEAR como recompensa por operar los nodos que corren la red en forma de una tasa estática de inflación del 5% anual, creando nuevos tokens para validadores cada epoch (~12 horas) como recompensa.

Los validadores deben mantener una cantidad mínima de Stake para mantener su puesto de validador. Los titulares de los tokens pueden stackear sus tokens con un validador particular que ellos crean que está teniendo un rendimiento bueno para la red y ganar una porción de los tokens de recompensa generados por la red. Esto incentiva a los titulares de tokens a mantenerse involucrados en la comunidad.

La wallet de NEAR ahora tiene una interfase de staking directamente construida en la aplicación web.

Para stakear:

 	Seleccionar “Staking” en la barra de navegación (o menú desplegable en móvil).
 	Haz click en el botón “Select validator” 
 	Escoge un validador
 	Confirme su elección y seleccione “Stake with Validator”
 	Ingrese la cantidad de NEAR que quiere stakear y haga clic en “Submit Stake”

Deberá confirmar dos transacciones, una para elegir al validador y otra para depositar y stakear con ese validador.

Para des-Stakear:

 	En el menu de staking (/staking), seleccione el validador actual
 	Haga click en “unstake” y confirme la transacción

Luego de un plazo de 36 a 48 horas (4 epoch), usted tendrá la posibilidad de retirar su stake, vuelva a la página del validador y haga click en “withdraw”.

Nuevos tokens son creados como recompensa cada epoch lo que ocurre aproximadamente cada:



	

	
	
		
			
				Quiz: Nuevos tokens son creados como recompensa cada epoch lo que ocurre aproximadamente cada:
			
		

		
					

		
			
			
			
			12 minutos
		
			
			12 segundos
		
			
			12 días
		
			
			12 horas
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Entonces, ¿ahora qué? ¿Cómo puedo interactuar con NEAR?
Bien, qué pasa ahora? Si ha leído hasta este punto, usted probablemente quiere profundizar aun mas en el protocolo NEAR. Entonces, lo siguiente que debe hacer es revisar la documentación de NEAR. Si es nuevo en la blockchain y quiere aprender mas sobre la tecnologia en si misma, debe revisar este video deconstruyendo el ecosistema blockchain

Unase al servidor de discord y chequee el forum de NEAR.

### LearnNEAR.Club LNC Weekly Update - July 16, 2021

Brief Summary (1-2 paragraphs):



July Redeem Window faced nLEARNs "farmers" activityMultilanguage support improved including mobile



Results:



NEAR Certified Developer Level 1 course available in VietnameseWe sent 344.00 Ⓝ to our 43 hardworking (L)Earners



Challenges & Blockers:



Looking for more learning materials from NEAR Collective - Spanish is next!



Action Items:



Job Board is coming

### Top 7 dự án NFT trên NEAR Protocol

Sự phát triển của DeFi đã mang khái niệm NFT tới đông đảo mọi người, và khi NFT phát triển cũng kèm theo khá nhiều vấn đề cần phải giải quyết. Ethereum có thể coi là nền tảng độc quyền trong lĩnh vực này, với rất nhiều NFT được tạo ra trên blockchain Ethereum. Tuy nhiên việc tạo ra những NFT trên một trong những nền tảng blockchain phổ biến nhất này lại nảy sinh một vấn đề, đó là phí gas của Ethereum khá cao. Phí gas trên Ethereum có thể vượt quá cả trăm USD và điều này khiến cho việc tạo NFT trên Ethereum trở nên khá bất tiện.

Vậy, đối với NFT và những dự án NFT, sẽ có những lựa chọn nào ngoài Ethereum? Đã có khá nhiều dự án chất lượng được triển khai trên nền tảng của giao thức NEAR và nó cũng được coi là “Ethereum killer”. Giao thức NEAR là một blockchain có khả năng mở rộng, nó giúp đơn giản hóa và tăng tốc độ phát triển của các dApps. Hiện tại, có 19 nền tảng phi tập trung dành cho NFT trên blockchain NEAR. Giao thức NEAR có một lợi thế so với Ethereum đó là tốc độ vượt trội so với Ethereum và chi phí giao dịch gần như không tốn kém, điều này khiến NEAR được coi là nền tảng lý tưởng cho việc trading NFT.
NEAR Protocol và NFT
NEAR Protocol là nền tảng hoàn hảo cho NFT vì nó có nhiều ưu điểm hơn Ethereum, NEAR nhanh hơn đáng kể so với Ethereum. Ethereum có phí gas cao trong khi NEAR cho phép xử lý các giao dịch với phí gas rất rẻ. Những yếu tố này làm cho NEAR trở nên lý tưởng để giao dịch NFT.

Như đã đề cập trước đó, bài viết này sẽ giới thiệu một số dự án NFT đang khởi chạy trên blockchain của NEAR. Tuy nhiên, trước khi xem xét các dự án, chúng ta hãy tìm hiểu qua về khái niệm NFT.
Ý nghĩa của Non-Fungible
Fungible asset - Tài sản có thể thay thế là tài sản có thể được trao đổi với một tài sản khác giống hệt nó. Bitcoin là một ví dụ tuyệt vời về tài sản có thể thay thế, nghĩa là bạn có thể trao đổi một bitcoin này lấy một bitcoin khác mà không gặp bất kỳ vấn đề gì. Mặt khác, Non-Fungible asset - tài sản không thể thay thế là loại tài sản độc nhất không thể trao đổi với nhau được. Ví dụ về tài sản không thể thay thế có thể là một bức tranh độc đáo hoặc các bộ sưu tập phiên bản giới hạn.

Non-Fungible asset có một thuộc tính riêng biệt hoặc các thuộc tính làm cho nó khác biệt với các nội dung khác. NFT - Non-Fungible Token - Token không thể thay thế được dựa trên tài sản không thể thay thế và là tài sản kỹ thuật số duy nhất sử dụng công nghệ blockchain.
NFT là gì?
NFT là tài sản kỹ thuật số độc nhất có thông tin nhận dạng được ghi lại trên hợp đồng thông minh. Thông tin trên hợp đồng thông minh là điều tạo nên sự độc nhất của NFT. Các loại tài sản đáng tin cậy như Bitcoin có thể được trao đổi, có nghĩa là bạn có thể gửi hoặc nhận bitcoin mà không gặp bất kỳ sự cố nào. Loại tài sản này cũng có thể chia nhỏ , cho phép bạn gửi số tiền nhỏ hơn. Tài sản không thể thay thế thì không thể bị phân chia. Ví dụ: bạn không thể gửi cho ai đó một phần của bức tranh hoặc một tấm vé.

NFT là chứng chỉ kỹ thuật số về quyền sở hữu đối với tài sản kỹ thuật số. NFT là một hợp đồng thông minh được sử dụng để bảo vệ tài sản kỹ thuật số. NFT có thể được tạo và xuất bản dưới dạng token với các chuẩn khác nhau (ERC-721 đối với Ethereum / NEP-171 với NEAR) trên blockchain. Mọi thứ đều có thể được chuyển thành NFT, trong đó phổ biến nhất là video, GIF hoặc JPEG.




	

	
	
		
			
				Đâu là NFT? 
			
		

		
					

		
			
			
			
			Bitcoin
		
			
			Tiền pháp định
		
			
			Một bộ sưu tập kỹ thuật số
		
			
			nDai
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Những dự án NFT trên NEAR Protocol
Hiện tại đã có một số dự án NFT trên NEAR, chúng ta hãy xem xét một số dự án phổ biến trên nền tảng này.
Mintbase
Mintbase bắt đầu vào năm 2018 và được tạo ra bởi Nate Geier và Calorine Wend. Nate Geier là Giám đốc điều hành của công ty, trong khi Caroline là COO, sử dụng chuyên môn quản lý và phát triển kinh doanh của mình. Mintbase đã huy động được 1 triệu đô từ vòng tài trợ hạt giống (seed round) vào năm 2020. Sino Global dẫn đầu vòng này và cũng bao gồm các VC khác như Block Oracle Capital, D1 Ventures và các nhà đầu tư thiên thần khác.

Fish Woman by From my Dream.

Mintbase cho phép người dùng tạo và bán NFT trên NEAR. Người dùng có thể mint các tài sản kỹ thuật số khác nhau dưới dạng NFT. Những tài sản này có thể bao gồm từ vé sự kiện đến nghệ thuật số và nhiều thứ khác.

Mintbase cho phép mọi người tạo NFT và bán trên chợ NFT của họ hoặc trên các chợ NFT khác như OpenSea. Người tạo NFT có thể tạo một hợp đồng thông minh và giới hạn khả năng chuyển nhượng của các token được mint, giúp ngăn chặn gian lận hoặc chuyển nhượng bất hợp pháp các mặt hàng độc đáo. Mintbase tập trung vào việc tạo ra trải nghiệm tạo NFT duy nhất, độc đáo, đó là lý do tại sao nó hỗ trợ các tài sản kỹ thuật số khác nhau. Điều này trái ngược với các nền tảng cạnh tranh tập trung vào một danh mục NFT cụ thể.
Tại sao Mintbase chuyển sang NEAR?
Tại sao Mintbase chuyển từ Ethereum sang NEAR? Câu trả lời là phí gas. Phí gas trên Ethereum đã bắt đầu trở nên đắt đỏ. Để mint NFT trên Mintbase, người dùng cần tạo một cửa hàng kỹ thuật số. Điều này liên quan đến việc người dùng tạo một hợp đồng thông minh và trả phí Gas cho Ethereum. Ban đầu, mức phí thấp và người dùng có thể triển khai cửa hàng một cách nhanh chóng. Tuy nhiên, với sự tắc nghẽn ngày càng tăng trên mạng Ethereum, phí bắt đầu ngày càng cao, khiến cho việc tạo một cửa hàng tốn hàng trăm đô la. Chi phí trở nên cao đến mức Mintbase phải yêu cầu người dùng đợi giá Gas giảm trước khi triển khai cửa hàng của mình. Ethereum nhanh chóng trở nên quá đắt đỏ thể mua, bán hoặc tạo NFT.

 

Mintbase coi NEAR là một nền tảng tốt hơn so với Ethereum, với phí Gas thấp hơn đáng kể nhờ mô hình thực hiện hợp đồng thông minh hiệu quả hơn. NEAR sử dụng Nightshade - thuật toán đồng thuận áp dụng kỹ thuật Sharding. Bên cạnh đó, có một số lý do khác khiến Mintbase chuyển sang NEAR.

 	Việc sử dụng Rust hoặc AssemblyScript cho các hợp đồng thông minh trên NEAR giúp các nhà phát triển viết code dễ dàng
 	NEAR có các địa chỉ mà con người có thể đọc được cho cả hợp đồng và tài khoản
 	Các nhà phát triển có thể giới thiệu người dùng mới một cách nhanh chóng, nhờ vào NEAR Drops. Họ có thể thanh toán cho tài khoản NEAR của mình và gửi token NEAR
 	Các nhà phát triển và người dùng có thể di chuyển tài sản qua lại giữa hai nền tảng Ethereum và NEAR một cách nhanh chóng thông qua Rainbow Brigde ETH-NEAR
 	Các nền tảng DeFi khác như Aave và Balancer cũng đang tích hợp trên NEAR, điều này sẽ giúp cho mọi quá trình tích hợp trong tương lai trở nên dễ dàng.




	

	
	
		
			
				Tại sao Mintbase chuyển sang NEAR? 
			
		

		
					

		
			
			
			
			Gas quá cao trên Ethereum
		
			
			NEAR là nền tảng tốt hơn
		
			
			Nhà phát triển có thể chuyển tài sản nhanh hơn
		
			
			Tất cả các đáp án trên
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras được tạo ra với tầm nhìn cung cấp giải pháp cho các loại thẻ sưu tập. Nền tảng xác nhận quyền sở hữu thông qua blockchain với các giao dịch nhanh và rẻ của NEAR. Nền tảng tập trung vào việc tạo các bộ sưu tập tiền điện tử có thể được đa dạng hóa thành các phương tiện nổi bật hơn.

PunkyPoN#0006 by monztre.near

Paras là một thị trường thẻ nghệ thuật kỹ thuật số tất cả trong một được xây dựng trên NEAR. Nền tảng này có thể xác thực quyền sở hữu và cấp quyền truy cập vào mọi giao dịch mua và mint cho người dùng. Nó cung cấp các giao dịch nhanh chóng và rẻ, đồng thời tạo sự khác biệt với các thị trường khác bằng cách cung cấp các bộ sưu tập thay vì các bản phát hành đơn lẻ. Các ưu điểm nền tảng Paras. 

 	Paras làm giảm gánh nặng bảo trì cho những người sưu tập bằng cách đảm bảo rằng những món đồ sưu tầm của họ không bị hao mòn theo thời gian (tài sản số). Nền tảng loại bỏ các rào cản và giúp các nghệ sĩ và nhà sưu tập dễ dàng tiếp cận thị trường sưu tập kỹ thuật số. Nhờ NEAR, Paras có thể giảm chi phí phát sinh cho nghệ sĩ trong quá trình mua bán
 	Paras đang phát triển thị trường Digital Art Card (thẻ nghệ thuật Kỹ thuật số) cho các nghệ sĩ, game thủ và nhà sáng tạo trong tương lai, đồng thời cho phép các nghệ sĩ tạo bộ sưu tập liên kết đến một chủ đề hoặc câu chuyện của riêng mình. Thông qua phương pháp này, các  Digital Art Card trong Paras rất phong phú với các câu chuyện và bối cảnh riêng.

Paras có khả năng thực hiện cách tiếp cận được tuyển chọn và tạo ra cộng đồng trải nghiệm NFT. Paras đảm bảo tính nhất quán và chất lượng qua cách lựa chọn nghệ sĩ và các chủ đề. Ai cũng có thể tạo được các NFT trên Paras, tuy nhiên để hiện trên dề xuất thì chỉ những tài khoản được xác thực nghệ sĩ mới có thể làm được, số lượng nghệ sĩ được xác thực này giới hạn ở 30 nghệ sĩ mỗi tuần. 

Các nghệ sĩ cũng được yêu cầu tuân theo tỷ lệ khung hình chuẩn 64:89.




	

	
	
		
			
				Paras là gì?
			
		

		
					

		
			
			
			
			Nền tảng chợ thẻ kỹ thuật số tất cả trong một 
		
			
			Nền tảng Smart contract
		
			
			Ngôn ngữ lập trình
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Kể từ khi ra mắt nền tảng, các nghệ sĩ trên Paras đã kiếm được hơn 25.000 đô, Paras có thể tạo ra khối lượng giao dịch hơn 35.000 đô từ hơn 700 giao dịch. Nền tảng có hơn 80 nhà sưu tập đang hoạt động và hơn 70 nghệ sĩ. Phí mint NFT thấp khiến rào cản gia nhập đối với các nghệ sĩ là thấp, mọi người có thể mint thẻ NFT mà không cần lo lắng về chi phí gas. Paras đã phát triển mạnh mẽ với lượng volume đạt hơn 6 triệu đô trong vòng 30 ngày (2/2022).


Tại sao NEAR phù hợp với Paras?
Bởi vì nhu cầu về không gian trên Ethereum đang làm tăng chi phí trên nền tảng, những người tạo NFT mới hơn đang tìm kiếm các lựa chọn và giải pháp thay thế. NEAR đang làm việc với Ethereum trên một giải pháp có thể tương tác giữa hai blockchain (Aurora). Các giao dịch trên NEAR chỉ tốn vài xu, và đôi khi còn thấp hơn. Ví NEAR có hiệu quả cao và các giao dịch được hoàn thành gần như ngay lập tức. Rainbow Brigde đảm bảo rằng NEAR sẽ tương thích với các tài sản dựa trên Ethereum.
(L)Earner NFT
Learn NEAR Club cũng đang phát hành bộ NFT của mình - (L)Earner NFT, Genesis Edition. Chúng tôi sẽ phát hành dự án này trong thời gian tới và đã bắt đầu hợp tác với một trong những nhà thiết kế đồ họa được trao giải thưởng xuất sắc nhất thế giới để tạo nên sản phẩm thành công vang dội. Chúng tôi tin rằng dự án này sẽ phát triển không gian NEAR NFT một cách quy mô. Thông tin chi tiết thêm về (L) Earner NFTs, bao gồm chi phí mint sẽ sớm được công bố.

Bạn có thể đăng ký tại đây để nhận được quyền truy cập sớm. Và, tất nhiên, bạn sẽ cần phải là thành viên LNC và sẵn sàng chi một số điểm nLEARN để tham gia.
Hip Hop Heads
Hip Hop Heads đánh dấu sự gia nhập nền văn hóa Mỹ vào không gian tiền điện tử. Loạt ảnh nghệ thuật là tác phẩm của Andre LeRoy Davis, người sáng tạo ra tác phẩm The Last Word mang tính biểu tượng của Source Magazine và cũng có hoạt ảnh nền của một trong những người đồng sở hữu Source Magazine, Ed Young.

Hip Hop Heads được ra đời từ sự hợp tác giữa Universal Hip Hop Museum, The NEAR Protocol và Ed Young. Họ cùng nhau quyết định tạo ra một bộ sưu tập NFT có sự góp mặt của các nghệ sĩ từ những năm 70 đến nay. Bộ sưu tập mang tên NFT.HipHop Heads sẽ có sự góp mặt của 47 nghệ sĩ nhạc rap lớn nhất, tôn vinh không chỉ các nghệ sĩ mà còn đánh dấu năm thứ 47 của kỷ nguyên Hip Hop. Dự án kết nối lại với cội nguồn của nhạc rap bằng cách sử dụng những tiến bộ công nghệ mới nhất.

HipHopHead 10.292.22166

Mỗi hình minh họa sẽ tồn tại như một bộ sưu tập gồm 47 NFT, biểu thị 47 năm của kỷ nguyên Hip Hop. Phiên bản đầu tiên của mỗi phần đầu Hip Hop được đặt tên tùy thuộc vào vị trí của nghệ sĩ trong lịch sử Hip Hop. Tầm quan trọng của mỗi nghệ sĩ được thể hiện thông qua hình họa do Andre LeRoy Davis tạo ra. Hình nền là kết quả của những con số quan trọng nhất trong lịch sử của Hip Hop, chứng minh kỷ nguyên Hip Hop trong suốt 47 năm. Bộ sưu tập NFT sẽ được bán đấu giá hàng ngày trên trang web của dự án cho đến ngày 24 tháng 7.
Tại sao Hip-Hop Heads lại chọn NEAR?
NEAR cho phép bộ sưu tập Hip Hop Heads dễ tiếp cận hơn với người dùng. Như đã đề cập trước đó, bộ sưu tập sẽ được bán đấu giá hàng ngày cho đến ngày 24 tháng 8 và có thể được mua bằng thẻ tín dụng. Thị trường đấu giá cũng tập trung vào các tính năng của NEAR Protocol như giao diện quen thuộc và thân thiện tương tự như web-2, đúc NFT dễ dàng, rẻ và khả năng tiếp cận người dùng cuối đơn giản.

Bởi vì người dùng có thể mua NFT bằng thẻ tín dụng, thị trường cung cấp một cách đơn giản để mua NFT mà không cần bất kỳ bước phức tạp nào với người dùng. Tiền bản quyền NFT (royalty) trên NEAR được đúc vào NFT, cho phép người sáng tạo nhận được tiền bản quyền từ việc bán hàng thứ cấp, ngay cả khi NFT được chuyển sang thị trường khác. Điều này có thể thực hiện được nhờ tiêu chuẩn NFT ở cấp hợp đồng thông minh của NEAR. 

NEAR cung cấp cho các nghệ sĩ và người sáng tạo quyền kiểm soát NFT của họ, cho phép họ thu lợi từ công việc của mình.
NPunks
Sau thành công vang dội của Cryptopunks, Solpunks và Tpunks, NEAR cuối cùng cũng có phiên bản dự án của riêng mình, được gọi là Npunks. Như với dự án Punks ban đầu, sẽ có 10.000 NPunks độc nhất vô nhị với những đặc điểm quý hiếm của riêng mình. Bộ sưu tập sẽ có 9 người ngoài hành tinh, 24 vượn, 88 zombie và 111 bot.



Để tránh việc đầu cơ tích trữ và đảm bảo sự tham gia công bằng, mọi người đều có cơ hội mua một (hoặc nhiều Npunks). Các giao dịch mua được thực hiện ngẫu nhiên và danh tính được giữ bí mật cho đến khi giao dịch được coi là hoàn tất. Người dùng có thể tự do bán Npunk của họ trên thị trường thứ cấp như Paras sau khi mint.
NEAR Misfits


NEAR Misfists là bộ sưu tập NFT hoàn chỉnh bằng mật mã đầu tiên của NEAR. MIsfits bao gồm 1.600 Normie, 150 Zombies, 101 Skellies, 50 Meerkats và 22 Glitch Misfits.

Vào tháng 11 năm 2021, 1.923 Misfit NFT đã được bán hết trong vòng chưa đầy 36 giờ. Hiện tại, bạn có thể mua các NFT này trên các thị trường NEAR NFT như Paras và Mintbase.
NEARNauts
NEARNauts là một NFT do cộng đồng tạo ra ngẫu nhiên nhằm mục đích phát triển cộng đồng trung thành xung quanh dự án. Một nhóm các đặc điểm hiếm có đảm bảo tính độc nhất có thể kiểm chứng được. Chức năng ngẫu nhiên có thể xác minh (VRF) này bao gồm ba thuật toán - Generated, proof, và verification

 	Generated: Tạo ra hai cặp khóa - khóa bí mật (SK) và khóa công khai (pk).
 	Proof: Đưa SK và thông báo (x) cung cấp kết quả đầu ra ngẫu nhiên (y) và một bằng chứng.
 	Verification: Thuật toán xác minh lấy pk, x và y và sử dụng bằng chứng để xác minh tính hợp lệ của đầu ra.



Cộng đồng NEARNauts DAO sẽ hoạt động vào Q1, 2022.
Kết luận
NEAR đang làm cho việc xây dựng và triển khai dApps dễ dàng hơn, nhanh hơn và rẻ hơn bất kỳ giao thức blockchain nào khác và là một trong những dự án hứa hẹn nhất trong không gian tiền điện tử. NEAR giải quyết một số vấn đề mà các dự án trên Ethereum phải đối mặt, chẳng hạn như phí gas cao và tốc độ xử lý chậm. Nó cũng có một số lợi thế so với Ethereum nhờ vào giải pháp sharding của mình.

NEAR Protocol cho thấy một sự hứa hẹn đáng kể qua cách sử dụng Sharding để giải quyết các vấn đề mà blockchain khác phải đối mặt. Nhờ cách tiếp cận này, NEAR có thể tăng thông lượng mà không ảnh hưởng đến tính bảo mật. Nhóm NEAR Collective đảm bảo rằng các kỹ sư và nhà phát triển không ngừng làm việc để cải tiến giao thức NEAR.

### NEAR Sputnik DAO: Расширение возможностей сообществ

В основе Open Web и Web3 лежит идея о следующем поколении интернета, которое будет создано для людей и будет находиться в управлении лично ими. NEAR сформулировал это в рамках нашей миссии так: дать всем людям возможность контролировать свои финансы, данные и власть управления.




	

	
	
		
			
				Что, по вашему мнению, должно быть основной целью ДАО?
			
		

		
					

		
			
			
			
			Координация деятельности сообщества.
		
			
			Упрощение механизма управления
		
			
			Создание корпоративной структуры
		
			
			Поддержка токеномики
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






В старой (2014 года)  статье основателя Ethereum  Виталика Бутерина представлен новый взгляд на концепцию коллективных действий: вместо компании с акционерами, руководителями и сотрудниками может существовать децентрализованная автономная организация, или ДАО, члены которой владеют частью организации, вносят посильный вклад в ее развитие и получают вознаграждение пропорционально своему вкладу. Здесь нет начальников, нет иерархии, а участники объединены общей целью.

Помню, как был взволнован, когда впервые прочитал статью от  Виталика. Я представил себе будущее, где сообщество принадлежит самому себе, и где любой человек,  в любой точке планеты может создать группу и действовать независимо от границ, законов или банков. ДАО могут сделать это для сообществ ,так же, как Web3 на блокчейне делает это для частных лиц. В конечном счете, компании будут заменены ДАО, которые, будут обладать многими чертами, присущими компаниям, но при этом будут отличаться большей гибкостью, как при их создании, так и в дальнейшем, по мере изменения требований и приоритетов людей, вовлеченных в процесс.

Это понимание сложилось еще до моего интереса к Web3 и блокчейну. Я уехал из Украины, потому что не чувствовал себя в безопасности, создавая там компанию. Я не верю, что какому-либо украинскому банку можно доверить безопасное хранение моих денег. Только за последние десять лет правительство несколько раз меняло правила хранения американской валюты (например, требование продавать половину валюты при обмене на местную валюту). В Украине также очень много коррупции и жесткого контроля работы компаний. Во многих странах создание компании сопровождается дополнительными расходами из-за коррупции в правительстве, отсутствия верховенства закона и ненадежных банков, которые могут исчезнуть.

В той или иной степени это происходит везде. До появления блокчейна, если люди хотели объединиться в какую-нибудь официальную группу, им приходилось запрашивать лицензию у правительства (например, на создание компании), особенно если им требовался банковский счет и они хотели быть частью экономической системы. Этот процесс сложен, и отнимает много времени и денег, а на созданную организацию распространяются ограничения после ее формирования.

Даже неформальная координация сообществ требует правил и мер регулирования. Представьте, что студенческая группа любителей аниме хочет организовать международное фан-мероприятие, или коллектив успешных художников по всему миру хочет объединиться для поддержки начинающих творцов. Координация деятельности сообщества может включать в себя такие вещи как: способ публикации информации о том, к какому мнению склоняются члены группы по какому-либо вопросу, совместное создание произведений искусства или товаров, запуск приложения, инвестирование в цифровые активы или даже совместное владение социальным каналом, например, аккаунтом в Twitter. Все это реальные примеры координации, требующие механизмов управления.

Долгое время я верил в огромное количество маленьких команд, работающих вместе, вместо огромных компаний, которые создают монополию и затем борются за ее сохранение. На самом деле, около десяти лет назад мы с друзьями создали не-компанию ProstoKSI, которая состояла из разработчиков, совместно работающих над проектами с открытым исходным кодом.

Web3 делает возможным то, чего не может сделать Web2, благодаря гарантиям, которые дает криптовалюта. Представьте себе, что вы создаете свое приложение  на базе облачного провайдера или используете банк, которым управляет группа из 20 человек. Где гарантии что организация будет функционировать через год? Это очень ограничивает вас. Но в криптовалюте инфраструктура и децентрализованные приложения надежны, потому что они имеют открытый исходный код, открытое состояние и поставляются с надежными гарантиями. Приложения, построенные таким образом, предоставляют общие протоколы для взаимодействия друг с другом, на которые могут полагаться другие разработчики, предприятия и пользователи.

ДАО являются частью таких протоколов в современном мире. За семь лет, прошедших с тех пор, как Виталик написал свою статью, тысячи участников экспериментировали с ДАО в Ethereum и других сетях - среди самых известных можно назвать Maker, Moloch DAO, MetaCartel, The LAO и Flamingo DAO. Я взял некоторые ключевые выводы из первой волны экспериментов с ДАО, которые легли в основу видения ДАО в NEAR.

 	В целом ясно, что простые способы контроля за управлением сообществом не масштабируются с ростом числа участников. Тысячи людей не могут эффективно развивать или контролировать что-либо без введения правил, законов или иерархии. Мы также видели ряд экспериментов в блокчейнах , связанных с управлением протоколами и инвестиционными фондами. Многие из них провалились по разным причинам - от технических проблем до отсутствия интереса к голосованию со стороны участников или отсутствия объединяющего, движущего фактора.
 	Нельзя ожидать, что каждый участник всегда будет доволен. Интересы меняются, мнения людей пересматриваются. В конце концов, вокруг какого-то вопроса возникнет большинство и меньшинство. Даже если в большинстве случаев все придут к консенсусу посредством базового управления, такого как голосование, меньшинство сообщества должно иметь возможность в любой момент отделиться от первоначальной группы, чтобы следовать новому набору правил, если они не согласны с большинством и имеют свою точку зрения.
 	Любое сообщество или организация нуждается в руководстве. Даже если это очень ответственная группа людей - если они не работают полный рабочий день над совместным проектом, то они, вероятно, слишком заняты, чтобы быть активными все время и участвовать в каждом обсуждении или решении. В сообществах обычно есть ответственные лица, которые отвечают за координацию и модерацию.
 	Если сообщество не имеет центрального руководства и является анонимным, все равно ценно иметь членов, которые публично известны  и создают "ядро" сообщества. Сообщество будет прислушиваться к мнениям и взглядам этих людей больше, чем к другим, потому что они известны как наиболее заинтересованные и информированные участники.
 	Чем больше такое децентрализованное сообщество ориентировано на «продукт», тем более ответственным должно быть руководство, поскольку для разработки продукта обычно требуется гораздо больше опыта, чем есть у любого участника сообщества. Например, сообщество пытается совместно создать блокчейн или децентрализованную биржу.
 	Голосование на основе доли в стейкинге, всегда заканчивается неудачей, либо потому, что большинство заинтересованных сторон не могут или не хотят быть активными участниками, либо потому, что оно открывает легкие пути для атаки на процесс управления.




	

	
	
		
			
				Создан ли Sputnik ДАО специально для технических сообществ?
			
		

		
					

		
			
			
			
			Да
		
			
			Нет
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Таким образом, ДАО - это сообщество, объединенное вокруг какой-то общей цели, требующее определенных правил координации и управления, обладающее гибкостью, способное развиваться со временем по мере изменения интересов и целей сообщества, а также способное совершать сделки и зарабатывать деньги как единое целое с минимальными накладными расходами. Учитывая все эти выводы, мы решили создать на NEAR протокол ДАО, который позволил бы всем видам сообществ - не только техническим, управляемым инженерами, - получить гибкую и надежную основу для совместной работы и развития.




	

	
	
		
			
				Что из нижеперечисленного относится к руководству сообщества?
			
		

		
					

		
			
			
			
			Настоящее руководство гарантирует, что каждый член сообщества всегда будет счастлив
		
			
			Руководители сообщества не обязаны работать на сообщество полный рабочий день
		
			
			Даже в сообществе без центрального управления важно иметь ключевых участников/лидеров.
		
			
			Руководство управляет сообществом, создавая правила
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Sputnik DAO предлагает новым и существующим сообществам и организациям по всему миру возможность иметь представительство своей группы на цепочке, управлять своей деятельностью на цепочке, самостоятельно принимать решения и (что очень важно!) взаимодействовать с другими DAO. В настоящее время насчитывается около 100 Sputnik ДАО с момента первоначального запуска в феврале 2021 года, им выделено  ~$500k , а также  ~$500k содержатся в коллективных казначействах (см. статистику здесь).

Заходите на сайт sputnik.fund   и расскажите нам, что вы думаете о нашем ДАО. На следующей неделе мы представим бета-версию V2 со свежим UX, новыми функциями и еще одну статью с подробностями о том, как Sputnik  решает ключевые проблемы организации сообществ.

Оригинал статьи - Sputnik DAO: Empowering Communities. Автор: Illia Polosukhin.

### Топ 3 NFT проекта на NEAR Protocol

Рост DeFi привлек внимание к NFT, а рост NFT заострил внимание на нескольких существующих проблемах. Ethereum монополист в этой сфере. Но не смотря на монополию и огромное количество созданных NFT у платформы Ethereum есть большая проблема - комиссия за газ. Эта комиссия может достигать сотен долларов, что делает работу в блокчейне Ethereum не практичной.

Итак, когда мы говорим о NFT и NFT проектах, какие варианты у нас есть? Из чего мы можем выбрать?

NEAR Protocol  имеет несколько крупных проектов на своей платформе, и его часто называют убийцей Ethereum. NEAR Protocol  - это масштабируемый блокчейн, который упрощает и ускоряет разработку dApps. На данный момент на нем существует 19 децентрализованных платформ для обмена NFT. Преимущество Блокчейна NEAR перед Ethereum в том, что он значительно быстрее, а транзакции практически ничего не стоят, что делает его идеальной платформой для торговли NFT.
Что такое NEAR Protocol?
NEAR Protocol  - это децентрализованная платформа разработки, которая была создана в 2018 году. Она был разработана для создания идеальной среды для децентрализованных приложений с упором на решение недостатков других платформ в этой сфере. NEAR Protocol  это блокчейн 3-го поколения основанный на Proof-of-Stake (PoS), что снижает затраты на газ и улучшает масштабируемость.

Кроме того, блокчейн NEAR поддерживает шардинг, применяя новый механизм генерации блоков, "Doomslug". Он был предложен в 2019 году и обеспечивает практическую или "Doomslug" финальность, гарантируя, что блоки получат ее за секунды.

NEAR основан на той же технологии, что и Bitcoin, и является наиболее доступной сетью для разработчиков и конечных пользователей. В отличие от большинства других блокчейнов, в NEAR, шардинг позволяет линейно масштабироваться до миллиардов транзакций полностью децентрализованным способом.
Важные преимущества NEAR
NEAR разработан небольшим сообществом разработчиков известными как NEAR Collective. Некоторые ключевые особенности:

 	NEAR - это простой в использовании протокол, который позволяет разработчикам легко и быстро создавать приложения.
 	NEAR обеспечивает безграничную масштабируемость.
 	Вопреки ошибочному мнению, NEAR – это не  side chain (сторонняя цепочка блоков), а протокол первого уровня.
 	 dApps, созданные с помощью NEAR, запускаются поверх основного уровня NEAR.

NEAR Collective
Как упоминалось ранее, NEAR разрабатывается сообществом разработчиков являющихся частью NEAR collective. NEAR collective состоит из организаций и отдельных людей, которые работают над развитием NEAR Protocol,  постоянно совершенствуя его.

NEAR Collective пишет исходный код и реализацию для сети NEAR. Несмотря на то, что Collective  обеспечивает функционирование протокола, NEAR полностью децентрализован и работает независимо. Он не может быть остановлен даже командой, которая его разработала.

NEAR Collective включает в себя NEAR Foundation - некоммерческую организацию, деятельность которой направлена ​​на создание динамичной экосистемы вокруг блокчейна NEAR и где NEAR Protocol лишь один из нескольких проектов NEAR Collective.
NEAR Protocol и NFT
NEAR Protocol  - идеальная платформа для NFT, поскольку имеет много преимуществ перед Ethereum. Он значительно быстрее и позволяет обрабатывать транзакции с минимальной комиссией, в то время как в Ethereum эти комиссии очень высоки. Эти факторы делают NEAR идеальным для торговли  NFT.

Как упоминалось ранее, уже существует несколько проектов NFT, созданных на блокчейне NEAR. Однако прежде чем рассмотреть эти проекты, давайте вкратце разберемся в концепции NFT.
Что значит невзаимозаменяемый актив?
Заменяемый актив - актив, который можно обменять на другой идентичный актив. Биткойн - отличный пример взаимозаменяемого актива. Отдельно взятый BTC такой же, как и любой другой BTC в обращении. С другой стороны, невзаимозаменяемые активы уникальны, и не могут быть обменены или замещены аналогичным активом. Примером невзаимозаменяемого актива может быть уникальная картина или коллекционные предметы, выпущенные ограниченным тиражом.

Невзаимозаменяемый актив имеет индивидуальное свойство или свойства, которые отличают его от других активов. NFT основаны на невзаимозаменяемых активах и являются уникальными цифровыми активами, использующими технологию блокчейн.
Что такое NFT?
NFT - это уникальные цифровые активы, идентификационная информация которых записана в смарт-контракте.  Именно информация в смарт-контракте делает NFT уникальным. Заменяемые активы, такие как биткойн, можно обменивать. То есть вы можете без проблем отправлять и получать BTC. Заменяемые активы делимы, что позволяет оперировать меньшими суммами данного актива. Невзаимозаменяемые активы нельзя разделить. Например, вы не можете отправить кому-то часть картины или билета.

NFT - это цифровые сертификаты собственности, подтверждающие право владения цифровым активом. NFT - это смарт-контракт, который используется для защиты цифрового актива. После создания он публикуется на блокчейне в токене (для Ethereum это токены формата ERC 721). В NFT можно превратить все что угодно, и самыми популярными сейчас являются видео, GIF или JPEG.




	

	
	
		
			
				Что из перечисленного является NFT?
			
		

		
					

		
			
			
			
			Биткойн
		
			
			Фиатная валюта
		
			
			Цифровые предметы коллекционирования
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFT на NEAR Protocol
В настоящее время на NEAR существует множество платформ NFT, поэтому давайте рассмотрим некоторые из наиболее популярных.
Mintbase
Mintbase была создана Нейтом Гейером и Калорин Венд и запущена в 2018 году. Нейт Гейер является генеральным директором компании, а Кэролайн, используя свой опыт управления и развития бизнеса  - главный операционный директор. Mintbase удалось привлечь 1 миллион долларов на начальном этапе разработки в 2020 году. Главным инвестором стала Sino Global , а также другие венчурные фонды, такие как Block Oracle Capital, D1 Ventures и другие бизнес-ангелы.

Женщина-рыба от From my Dream

Mintbase это цифровая блокчейн-платформа, которая используется для выпуска и обмена невзаимозаменяемых токенов. Токены на Mintbase отличаются от других, которые обычно являются токенами, представляющими собой предметы цифрового искусства. Платформа Mintbase позволяет пользователям создавать, продавать и минтить(токенизировать) различные цифровые активы в виде NFT, начиная от билетов на мероприятия до крипто-арта и всего, что между ними.

Mintbase позволяет любому, с доступом к Интернету, создать NFT и выставить его на продажу на своей платформе или таких торговых площадках как OpenSea. Можно создать смарт-контракт и ограничить возможность передачи созданных токенов, что помогает предотвратить случаи мошенничества и незаконной передачи уникальных предметов. Mintbase ориентирована на получение уникального опыта создания NFT, и для этого поддерживает различные цифровые активы. Это отличает ее от конкурирующих платформ, которые сосредоточены на одной конкретной категории NFT.
Почему Mintbase перешла на NEAR?
Так зачем же нужен переход с Ethereum на NEAR ? Ответ - плата за газ, которая в Ethereum стала слишком дорогой. Чтобы сминтить NFT на Mintbase, пользователю необходимо открыть цифровой магазин. Для этого пользователю нужно создать смарт-контракт и заплатить Ethereum комиссию за газ. Первоначально плата была низкой, и пользователи могли развернуть магазин довольно быстро. Однако по мере роста нагрузки на сеть, плата стала расти все больше и больше, и создание магазина стало обходиться в сотни долларов. Стоимость стала настолько высокой, что Mintbase пришлось попросить  своих пользователей, чтобы они подождали, пока цены на газ упадут, прежде чем открывать свой магазин. Ethereum быстро стал непригоден для покупки, продажи или создания NFT.

Mintbase увидела в NEAR более удобную платформу по сравнению с Ethereum. Которая благодаря более эффективной модели исполнения контрактов требует значительно меньшей платы за газ. В ней также используется Nightshade - динамический подход к шардингу.

Вот еще несколько причин, по которым Mintbase перешла на NEAR.

 	Использование Rust или AssemblyScript для смарт-контрактов на платформе NEAR облегчает разработчикам написание кода.
 	NEAR имеет  удобные для восприятия человеком адреса как для контрактов, так и для аккаунтов.
 	Благодаря NEAR Drops разработчики могут быстро подключить пользователей. Они могут оплатить создание аккаунта и отправлять токены NEAR.
 	Разработчики и пользователи могут быстро перемещать активы благодаря мосту ETH-NEAR Rainbow bridge.
 	Другие платформы DeFi, такие как Aave и Balancer, также работают на NEAR, что сделает любую будущую интеграцию проще.




	

	
	
		
			
				Почему Mintbase перешла на NEAR?
			
		

		
					

		
			
			
			
			Высокая плата за газ
		
			
			NEAR - лучшая платформа
		
			
			Разработчики могут перемещать активы быстрее
		
			
			Все вышеперечисленное
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras был создан с целью предложить решение проблемы износа традиционных коллекционных карт. Платформа подтверждает право собственности через блокчейн посредством быстрых и недорогих транзакций и фокусируется на создании собственных крипто-коллекций, которые в дальнейшем могут быть перенесены на более популярные площадки.

PunkyPoN # 0006, автор: monztre.near

Paras - это универсальная торговая площадка для цифровых карт, построенная на NEAR. Платформа может подтвердить право собственности и предоставить пользователям доступ к каждой совершенной покупке пользователей и их созданным NFT. Она предлагает быстрые и дешевые транзакции и отличается от других торговых площадок тем, что предлагает коллекции вместо отдельных экземпляров. Платформа выделяется следующим образом:

 	Paras снижает затраты коллекционеров,  гарантируя, что их предметы коллекционирования не будут подвергнуты износу. Платформа позволяет художникам и коллекционерам легко выйти на рынок цифровых коллекционных предметов и благодаря NEAR Protocol снизить расходы авторов на продажу своих работ.
 	Paras развивает инновационную систему цифровых карт для будущих художников, геймеров и творческих личностей, позволяя им создавать коллекции, связанные с определенной темой или историей. Благодаря этому цифровые карты в Paras имеют интересные описания и большой сюжетный  бэкграунд.

Paras способно выступать в роли куратора и создать NFT сообщество с уникальным опытом. Paras обеспечивает стандартизацию и качество путем проведения тщательной проверки художников и формата их работ. Художники могут создавать новые карты на Paras, только после прохождения проверки, а количество новых художников которым разрешено выкладывать их работы, ограничено 30 в неделю. Художники также должны придерживаться в своих работах стандартного соотношения сторон 64:89




	

	
	
		
			
				Что такое Paras?
			
		

		
					

		
			
			
			
			Универсальная торговая площадка для цифровых карт
		
			
			Платформа смарт-контрактов
		
			
			Язык программирования
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






С момента запуска платформы художники на Paras уже заработали более $25 000, а платформа обработала 700+  транзакций на сумму $35 000. На платформе более 80 активных коллекционеров и более 70 художников. Низкие комиссии позволяют художникам  создавать карты, не беспокоясь о стоимости минта.
Почему NEAR идеально подходит для Paras?
Поскольку спрос на размещение NFT на Ethereum приводит к росту цен на платформе, люди ищут альтернативные варианты. NEAR работает с Ethereum над созданием совместимого решения. Стоимость транзакций на NEAR всего несколько центов, а иногда даже меньше. Кошелек NEAR очень удобен, а транзакции выполняются практически мгновенно. Rainbow bridge гарантирует, что NEAR будет совместим с активами в Ethereum.
Hip Hop Heads
Hip Hop Heads знаменует собой вступление одного из главных символов американской культуры в криптопространство. В этой коллаборации представлены работы Андре ЛеРоя Дэвиса, создателя культового журнала Source Magazine "Последнее слово", а также фоновая анимация одного из совладельцев журнала Source Magazine Эда Янга..

Hip Hop Heads возник в результате сотрудничества между Universal Hip Hop Museum, The NEAR Protocol и Эдом Янгом. Вместе они решили создать коллекцию NFT, в которой будут представлены артисты с 70-х годов и до наших дней. Коллекция NFT.HipHop  Heads будет посвящена не только 47 известнейшим рэп-артистам,  но и 47-му году эры хип-хопа. Проект возвращает нас к корням рэпа, используя последние технологические возможности

HipHopHead 10.292.22166

Каждая иллюстрация будет существовать как коллекция из 47 NFT, что означает 47 лет эры хип-хопа. Первое издание каждой Hip Hop Head названо в зависимости от роли артиста в истории хип-хопа. Важность каждого артиста демонстрируется с помощью иллюстрации, созданной Андре Лероем Дэвисом. Фоновый анимационный код представляет собой результат самых значимых чисел в истории хип-хопа, которые демонстрируют развитие эры хип-хопа на протяжении 47 лет. Коллекция NFT будет выставляться на аукцион каждый день на nft.hiphop до 24 июля.
Почему Hip Hop Heads выбрали NEAR?
NEAR Protocol позволяет сделать коллекцию Hip Hop Heads более доступной для широкой аудитории. Как упоминалось ранее, коллекция будет выставляться на аукцион ежедневно до 24 августа, и ее можно будет приобрести с помощью кредитной карты. Это позволяет NEAR сделать проект более доступным. Продажа в форме аукциона также подчеркивает такие особенности NEAR Protocol, как знакомый и дружественный пользователю интерфейс, похожий на web-2, легкий и дешевый минт NFT и доступность для конечного пользователя.

Торговая площадка предлагает простой способ приобретения NFT без сложных шагов, позволяя пользователям оплатить NFT кредитной картой. Роялти от продажи NFT в NEAR Protocol  записаны в коде NFT, что позволяет авторам получать роялти от вторичных продаж, даже если NFT переходит на другую торговую площадку. Это возможно благодаря стандарту NFT на уровне контракта NEAR. NEAR дает художникам и создателям полный контроль над их NFT, позволяя им получать доход за свою работу.
NPunks
После огромного успеха Cryptopunks, Solpunks и Tpunks у NEAR наконец-то появится собственная версия проекта под названием -  NPunks. Как и в оригинальном проекте Punks, будет 10 000 уникальных NPunk со своими уникальными чертами. В коллекции будет 9 инопланетян, 24 обезьяны, 88 зомби и 111 ботов. 


NEAR Misfits
NEAR Misfits — это первая полная криптографическая коллекция NFT от NEAR. Misfits состоит из 1600 Норми, 150 зомби, 101 скелета, 50 сурикатов и 22 Misfits-неудачников.



Еще в ноябре 2021 года 1923 Misfit NFT были распроданы менее чем за 36 часов. На данный момент вы можете купить эти NFT на торговых площадках NEAR NFT, таких как Paras и Mintbase. 
NEARNauts
NEARNauts — это случайно сгенерированный NFT, управляемый сообществом, целью которого является создание органичного и лояльного сообщества вокруг проекта. Набор редких черт обеспечивает проверяемую уникальность. Эта проверяемая случайная функция (VRF) включает в себя три алгоритма: сгенерированный, доказательственный и верифицирующий. 

 	Генерируемый:  создает две пары ключей — секретный ключ (sk) и открытый ключ (pk).
 	Доказательственный: принимает sk и сообщение (x), чтобы обеспечить случайный вывод (y) и доказательство.
 	Верифицирующий: алгоритм проверки принимает pk, x и y и использует доказательство для проверки правильности вывода.



Сообщество NEARNauts DAO будет запущено в первом квартале 2022 года. 
Заключение
NEAR делает создание и развертывание dApps проще, быстрее и дешевле, чем любой другой блокчейн протокол, и является одним из самых перспективных проектов в криптопространстве. Он решает такие проблемы как высокая плата за газ и низкая скорость обработки данных, с которыми сталкиваются проекты на Ethereum. Он также имеет ряд преимуществ перед блокчейном Ethereum благодаря использованию шардинга.

NEAR Protocol продемонстрировал большие перспективы, используя шардинг для решения проблем, с которыми сталкиваются другие блокчейны. Благодаря такому подходу NEAR способен увеличить пропускную способность без ущерба для безопасности. NEAR Collective гарантирует, что инженеры и разработчики постоянно работают над протоколом.

 

### LearnNEAR.Club LNC Weekly Update - July 9, 2021

Brief Summary (1-2 paragraphs):



Added Webpack to optimize FrontendImproved integration with docs.near.org via GithubFirst Guide for Developers published in Vietnamese



Results:



Better performanceRead about NEAR Ecosystem Treasury in RussianFirst Guide for Developers published in Vietnamese







Challenges & Blockers:



Looking for more learning materials from NEAR Collective - Spanish is next!



Action Items:



NEAR Certified Developer Course in Vietnamese

### Hướng dẫn xây dựng và phát triển trên NEAR

điều kiện tiên quyết:

NEAR là gì?

Kinh nghiệm phát triển JavaScript

Những kĩ sư lập trình là nguồn độc lực chính để phát triển các ứng dụng trong hệ sinh thái của một blockchain. Một blockchain cần phải cung cấp những công cụ và hệ thống giúp những kĩ sư lập trình có thể dễ dàng phát triển và triển khai những ứng dụng trên nền tản của blockchain đó. Do vậy, trong hệ sinh thái NEAR, các hợp động thông minh - smart contract có thể viết bằng một trong hai ngôn ngữ lập trình phổ biến đó là AssemblyScript và Rust.

Để xây dựng ứng dụng trên nền tảng blockchain của NEAR, chúng ta có thể sử dụng những công cụ sau:

 	JavaScript SDK: Kết nối, đăng ký, giao dịch và triển khai với bất kỳ mạng lưới NEAR nào từ bất kỳ JS context nào.
 	Rust Contract SDK: Xây dựng các hợp đồng an toàn, bảo mật để quản lý các tài sản có giá trị cao.
 	AssemblyScript Contract SDK: Tìm hiểu và tạo nguyên bản bằng cú pháp JS.
 	JSON RPC API: Tất cả các thông tin giao tiếp với nền tảng đều thông qua API này.
 	Near CLI: cung cấp tập hợp những câu lệnh cho phép người dùng tương tác với hệ thống blockchain của Near (ví dụ: tạo account, kiểm tra trạng thái của một giao dịch etc...)
 	NEAR Explorer: Near Explorer: hiển thị trực quan theo thời gian thực các thông tin liên quan đến Near blockchain, cho phép kiểm tra thông tin các tài khoản Near, lịch sử giao dịch etc..
 	Near Wallet: Ứng dụng web cho phép tạo và tương tác với những tài khoản người dùng của Near. Giao diện ứng dụng thân thiện và dễ dàng sử dụng trên các thiết bị mobile hoặc máy tính
 	NEARUP: Quản lý triển khai cục bộ và tham gia bất kỳ mạng lưới công cộng hoặc riêng tư nào.
 	Bridge: Khả năng tương tác nhanh, an toàn.
 	EVM: Máy ảo tương thích với Ethereum.

 

Bắt đầu nào, hãy thực hiện các bước đầu tiên.
Thông tin tổng quan
Các ứng dụng trên NEAR có hai phần riêng biệt, đó là back-end và front-end.

 	Hợp đồng thông minh (back-end): Lưu trữ và sửa đổi dữ liệu trên chuỗi. Hợp đồng cần đưa ra các phương pháp cho phép client (máy khách) “xem” và “thay đổi” trạng thái.

Tương tác với Hợp đồng thông minh (front-end): Bạn có thể tương tác với hợp đồng của mình hoặc hợp đồng do người khác triển khai. Bạn thực hiện việc này bằng cách sử dụng near-api-js Quickstart và Code Snippets trong ứng dụng của bạn.

Cách xây dựng và gọi hợp đồng thông minh

NEAR hiện hỗ trợ:

 	Rust – near-sdk-rs: Một trình wrapper (bọc) cung cấp sự an toàn được cải thiện cho ngôn ngữ lập trình Rust cho các hợp đồng giá trị cao.
 	AssemblyScript near-sdk-as: Một tập hợp các trình hỗ trợ làm cho các hợp đồng thông minh của bạn tương tự như TypeScript khi biên dịch sang Wasm để thực thi.

 

GHI CHÚ: AssemblyScript hiện không được khuyến nghị cho các ứng dụng tài chính sản xuất do tính mới của ngôn ngữ và các công cụ biên dịch có sẵn.

Tiếp đến, cùng đi sâu và hãy nghiêm túc.
Thiết lập Testnet
Cách dễ nhất để tạo tài khoản trên NEAR là với NEAR Wallet. NEAR có một số mạng lưới phát triển hoạt động độc lập với nhau với các ID tài khoản của riêng họ. Thực hiện theo các bước để tạo ví. Đảm bảo rằng bạn đã làm theo các bước bắt buộc để sao lưu bảo mật.

LƯU Ý: Tạo tài khoản trên mainnet gần giống với testnet nhưng sẽ yêu cầu một số NEAR nhất định để kích hoạt  tài khoản. Đây là hướng dẫn tạo tài khoản mainnet.

Khi triển khai, cho dù ứng dụng được viết bằng Rust hay AssemblyScript. Tất cả mã hợp đồng được biên dịch sang WebAssembly và được triển khai vào mạng lưới để chạy bên trong một máy ảo tương thích với Wasm. Bạn sẽ sử dụng một lệnh giống như yarn dev cho hầu hết các ứng dụng nhưng bạn có thể dễ dàng triển khai ứng dụng bằng cách sử dụng NEAR CLI với NEAR dev-deploy cho TestNet (hoặc triển khai NEAR nếu bạn đã tạo tài khoản).

Bây giờ, hãy làm những điều sau để bắt đầu khởi động:

 	Nhìn xung quanh trong NEAR Explorer. Tại đây bạn có thể tìm kiếm tất cả các giao dịch và block (khối) được sản xuất trên NEAR. Hãy thử tìm kiếm tài khoản bạn vừa tạo và xem các giao dịch bạn đã tạo.
 	Cài đặt ngay near-cli. Đây là một giao diện dòng lệnh cho phép bạn tương tác liền mạch với NEAR. Tài liệu NEAR này có tất cả các lệnh near-cli kèm theo các ví dụ.
 	Thử chạy lệnh đầu tiên của bạn: near login. Thao tác này sẽ chuyển hướng bạn đến NEAR Wallet của bạn và lưu các khóa tài khoản testnet của bạn.

Sau khi kiểm tra testnet, bạn có thể thoải mái chạy node (nút) cục bộ của mình. Tuy nhiên, nếu bạn chỉ muốn thử với các mã, thì chúng tôi khuyên bạn nên sử dụng testnet.
Làm thế nào để chạy một node?
Như với bất kỳ hệ sinh thái dựa trên blockchain nào, NEAR Protocol chạy trên một tập hợp các máy tính được bảo trì công khai (hoặc “các node”).

Bạn có thể quyết định chạy một node của riêng mình với một số lý do:

 	Để phát triển và triển khai các hợp đồng trên một node được kết nối với MainNet, TestNet hoặc BetaNet.
 	Để phát triển và triển khai các hợp đồng trên một node cục bộ (“LocalNet”).
 	Để tham gia mạng lưới với tư cách là validator, hãy chạy một "validator node"

Bạn có thể chạy các Node BetaNet và TestNet bằng cách cài đặt nearup. Xem hướng dẫn chi tiết tại https://github.com/near/nearup
Chạy một node chính thức bằng Docker
Theo mặc định, NEAR sử dụng Docker để chạy các client (máy khách). Vì vậy, điều đầu tiên bạn làm là cài đặt Docker và nearup. Bây giờ, hãy chạy hệ thống của bạn như bên dưới:
nearup betanet
(Nếu bạn thích sử dụng TestNet thì chỉ cần thay betanet bằng testnet trong lệnh trên)

Sau đó, bạn sẽ được yêu cầu nhập ID tài khoản. Bạn có thể để trống phần này nếu bạn chỉ muốn chạy một node. Các validator nên sử dụng ID tài khoản của tài khoản bạn muốn stake. Sau đó, bạn cần nhập lệnh này:

Nhập ID tài khoản của bạn (để trống nếu không trở thành một validator)

Bây giờ, node của bạn sau đó sẽ bắt đầu ở chế độ nền với Docker. Để kiểm tra các log bên trong Docker, hãy chạy docker log –follow nearcore.
Viết mã lệnh đơn giản trên NEAR
NEAR có một danh sách các chương trình hữu ích hoặc các ví dụ code mà bạn có thể kiểm tra một cách dễ dàng. Vì vậy, code mà chúng tôi sẽ kiểm tra là Guest Book. Sử dụng chương trình cho phép bạn đăng nhập với NEAR và thêm tin nhắn vào Guest Book! Một ứng dụng dành cho người mới bắt đầu được xây dựng với backend là AssemblyScript và frontend là React.
Tìm hiểu code của Guest Book
Để chạy dự án này trên môi trường cục bộ (localhost), bạn cần đảm bảo những điều sau:

 	Download và cài đặt Node.js ≥ 12 (https://nodejs.org/en/download/) -
 	Sử dụng công cụ NPM của Node.js để cài đặt Yarn bằng lệnh sau: npm install --global yarn (hoặc npm i -g yarn) -
 	Cài đặt các dependencies với lệnh: yarn install --frozen-lockfile (hoặc yarn --frozen-lockfile)

Triển khai ứng dụng trên môi trường cục bộ với lệnh: yarn dev (xem package.json để biết danh sách đầy đủ các scripts mà bạn có thể chạy với yarn)

Giờ đây, bạn sẽ có một môi trường phát triển cục bộ được hỗ trợ bởi NEAR TestNet! Chạy yarn dev sẽ cho bạn biết URL mà bạn có thể truy cập trong trình duyệt của mình để xem ứng dụng.

Một điều là hãy đảm bảo rằng bạn đã mở trang GitHub.

Bạn cũng có thể xem video bên dưới biết thêm chi tiết.

https://youtu.be/B6Gc_OQjX9E

Khám phá code
Như bạn có thể thấy, có hai phần chính của code đó là backend và frontend:

 	Code backend nằm trong thư mục /assembly. Code này được triển khai trên NEAR Blockchain khi bạn chạy triển khai yarn:contract. Đây là một hợp đồng thông minh trên NEAR.
 	Code frontend nằm trong thư mục /src. Và /src/index.html là một nơi tuyệt vời để bắt đầu khám phá. Cách mà phần frontend kết nối với NEAR Blockchain được định nghĩa trong /src/index.js.

Backend Code
#1 Contract Data Model:  assembly/model.ts
import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector<PostedMessage>("m");
Phân tích

@nearBindgen đánh dấu lớp là có thể tuần tự hóa. Serializable là một giao diện "đánh dấu" được sử dụng để các lớp đối tượng có thể có được một khả năng nhất định.

Lớp “PostedMessage” có ba tính năng:

 	premium để gắn cờ các tin nhắn có token NEAR đính kèm
 	sender để theo dõi người ký tin nhắn Guest Book
 	text để giữ tin nhắn Guest Book

Cuối cùng, “messages” là một tập hợp các tin nhắn trong Guest Book được lưu trữ dưới dạng PersistentVector của các đối tượng PostedMessage

#2 Contract Behavior:  assembly/main.ts
import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.
 * NOTE: This is a change method. Which means it will modify the state.
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array<PostedMessage>(numMessages);
  for(let i = 0; i < numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}
Phân tích

MESSAGE_LIMIT được sử dụng để tránh các lệnh gọi không giới hạn (tức là có thể tốn nhiều phí) để lấy các tin nhắn trong Guest Book từ bộ nhớ

Chúng ta đang sử dụng hai chức năng công cộng khác nhau trong hợp đồng này là addMessage() và getMessages()
Frontend Code
#1 Kết nối mạng lưới :  src/config.js
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;
Phân tích

Đoạn code trên xác định dữ liệu và điểm cuối cần thiết để kết nối với mạng lưới NEAR. Thông tin kết nối được xác định ở đây được bao gồm cho MainNet, TestNet và BetaNet cũng như cấu hình mặc định LocalNet.

#2 Cấu hình :  src/index.js
import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) => {
    ReactDOM.render(
      <App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      />,
      document.getElementById('root')
    );
  });
Phân tích

Đây là phần hấp dẫn nhất của phần giao diện người dùng, khi bạn cấu hình kết nối với mạng lưới NEAR. Bạn có thể cấu hình giao diện hợp đồng bằng cách chèn kết nối ví và kết nối cả hai phương thức hợp đồng.
Triển khai một hợp đồng thông minh
Mỗi hợp đồng thông minh trong NEAR đều có tài khoản liên kết riêng. Khi bạn chạy yarn dev, các hợp đồng thông minh của bạn sẽ được triển khai tới mạng lưới NEAR TestNet trực tiếp với một tài khoản tạm thời. Nếu bây giờ bạn muốn đặt nó vĩnh viễn, đây là những gì bạn cần làm.

Bước 0: Cài đặt near-cli

Đây là cách bạn cài đặt near-cli
npm install --global near-cli
Điều này sẽ cung cấp cho bạn công cụ near CLI. Đảm bảo rằng nó được cài đặt với:
near --version
Bước 1: Tạo tài khoản cho hợp đồng

Truy cập NEAR Wallet và tạo một tài khoản mới. Bạn sẽ triển khai các hợp đồng thông minh đến tài khoản mới này.

Bây giờ ủy quyền NEAR CLI cho tài khoản mới này và làm theo hướng dẫn:
near login
Bước 2: Đặt tên hợp đồng

Sửa đổi dòng trong src/config.js đặt tên tài khoản của hợp đồng. Đặt nó thành ID tài khoản bạn đã sử dụng ở trên.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Bước 3: Đổi cách kết nối URL từ xa nếu bạn đã sao chép repo (nơi lưu trữ). Trừ khi bạn đã phân tách kho lưu trữ, bạn sẽ cần phải thay đổi cách kết nối URL từ xa tới một kho lưu trữ mà bạn có quyền truy cập đến. Thực hiện những bước sau sẽ cho phép tự động triển khai đổi cách kết nối URL từ xa lên trang Github:

 	

 	 Truy cập GitHub và tạo một kho lưu trữ mới cho dự án này.
 	Mở giao diện dòng lệnh của bạn và vào bên trong thư mục gốc (root project) của dự án này, nhập thông tin sau:



$ `git remote set-url origin https:/Bước 3: Đổi cách kết nối URL từ xa nếu bạn đã sao chép repo (nơi lưu trữ). Trừ khi bạn đã phân tách kho lưu trữ, bạn sẽ cần phải thay đổi cách kết nối URL từ xa tới một kho lưu trữ mà bạn có quyền truy cập đến. Thực hiện những bước sau sẽ cho phép tự động triển khai đổi cách kết nối URL từ xa lên trang Github: 1. Truy cập GitHub và tạo một kho lưu trữ mới cho dự án này. 2. Mở giao diện dòng lệnh của bạn và vào bên trong thư mục gốc (root project) của dự án này, nhập thông tin sau:om/YOUR_USERNAME/YOUR_REPOSITORY.git`
Bước 4: Triển khai

Bạn chỉ cần lệnh sau để triển khai hợp đồng thông minh của mình:
yarn deploy
Lệnh này thực hiện hai điều:

 	Xây dựng và triển khai các hợp đồng thông minh cho NEAR TestNet
 	Xây dựng và triển khai code frontend cho GitHub bằng cách sử dụng gh-pages. Điều này sẽ chỉ hoạt động nếu dự án đã có một kho lưu trữ được thiết lập trên GitHub. Vui lòng sửa script triển khai trong package.json để triển khai ở nơi khác.




	

	
	
		
			
				 Every smart contract in NEAR has its own associated ____

			
		

		
					

		
			
			
			
			Token
		
			
			Wallet
		
			
			Account
		
			
			All of above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What Next?
Vừa rồi chúng ta đã đi qua những thông tin cơ bản và giờ đây bạn đã biết cách chạy các dòng code cơ bản, tìm hiểu sâu hơn và chi tiết hơn nữa trên NEAR có thể xem các tài liệu dành cho nhà phát triển.

### NEAR Sputnik DAO: Trao quyền cho cộng đồng

Open Web và Web3 đều bắt nguồn từ ý tưởng rằng thế hệ tiếp theo của Internet sẽ được xây dựng và quản lý bởi con người. NEAR thậm chí đã hệ thống hóa điều này trong sứ mệnh của chúng tôi: trao quyền cho tất cả mọi người kiểm soát tiền bạc, dữ liệu và quyền quản trị của chính họ.

Câu hỏi: Theo bạn, mục đích cốt lõi của một DAO là gì?

Điều phối các hoạt động cộng đồng

Tạo thuận lợi cho Cơ chế Quản trị

Tái tạo cấu trúc doanh nghiệp

Tạo điều kiện thuận lợi cho tokenomics

Một bài đăng trên blog từ năm 2014 của Vitalik Buterin, Founder của Ethereum đã tạo nên 1 hướng suy nghĩ mới về hoạt động tập thể, hình thức một công ty với những cổ đông, giám đốc điều hành và nhân viên được thay thế bằng một tổ chức tự trị phi tập trung, hay còn gọi tắt là DAO (Decentralized Autonomous Organization). Đây là nơi những thành viên sở hữu một phần của tổ chức có thể tham gia đóng góp công sức của chính bản thân họ vào thành công của tổ chức ấy và sẽ được trả thưởng tương ứng tùy với sự đóng góp của họ. Ở DAO, bạn sẽ không thấy các ông/bà chủ, không có hệ thống cấp bậc, và những người tham gia đoàn kết với nhau vì một mục đích chung.

Tôi nhớ cảm giác được truyền cảm hứng khi lần đầu tiên đọc bài đăng của Vitalik, hình dung ra một tương lai thực sự do cộng đồng làm chủ, nơi bất kỳ ai, ở bất kỳ đâu đều có thể chính thức hóa một nhóm và không có giới hạn, luật pháp hoặc ngân hàng — giống như Web3 hỗ trợ blockchain làm cho cá nhân, DAO có thể làm cho cộng đồng. Cuối cùng, các công ty sẽ được thay thế bởi các DAO, vẫn có nhiều chức năng giống như một công ty, nhưng với tính linh hoạt cao hơn cả khi mới thành lập và theo thời gian khi nhu cầu và ưu tiên của những người liên quan thay đổi.

Tầm nhìn này thậm chí còn có trước sự quan tâm của tôi đối với Web3 và Blockchain. Tôi rời Ukraine vì tôi chưa bao giờ cảm thấy yên tâm khi thành lập công ty ở đó. Tôi không tin rằng có thể tin cậy bất kỳ ngân hàng Ukraine nào để cất giữ tiền của tôi một cách an toàn. Chính phủ đã thay đổi các quy tắc xung quanh việc nắm giữ tiền tệ của Mỹ nhiều lần chỉ trong vòng mười năm qua (như việc phải bán một nửa số tiền đó khi nhận tiền lấy nội tệ). Có rất nhiều tham nhũng và cấu trúc cứng nhắc xung quanh cách các công ty có thể hoạt động ở Ukraine. Ở nhiều quốc gia, việc thành lập công ty còn đi kèm với chi phí bổ sung do chính phủ tham nhũng, thiếu pháp quyền và các ngân hàng không đáng tin cậy có thể biến mất bất cứ lúc nào.

Điều này đúng ở mọi nơi, ở một mức độ nào đó: trước khi có blockchain, nếu mọi người muốn tổ chức thành một nhóm chính thức, họ sẽ cần yêu cầu giấy phép từ chính phủ (ví dụ: tạo công ty), đặc biệt nếu họ cần tài khoản ngân hàng và muốn tham gia vào nền kinh tế với tư cách là một nhóm. Quá trình này tốn thời gian, tiền bạc, phức tạp và kết quả là tổ chức phải tuân theo các quy tắc hạn chế khi nó hình thành.

Ngay cả sự phối hợp không chính thức của cộng đồng cũng cần có các quy tắc và sự điều độ. Hãy tưởng tượng một nhóm sinh viên anime muốn điều phối một sự kiện dành cho người hâm mộ quốc tế, hoặc một tập thể các nghệ sĩ thành công trên thế giới muốn tham gia cùng nhau để hỗ trợ các nghệ sĩ mới vào nghề. Phối hợp cộng đồng có thể bao gồm mọi thứ, từ cách đăng bài theo cách mà các thành viên đang dựa vào câu hỏi nào đó, cùng nhau sáng tạo nghệ thuật hoặc sản phẩm, khởi chạy ứng dụng, đầu tư vào một số tài sản kỹ thuật số hoặc thậm chí đồng sở hữu một kênh xã hội như tài khoản Twitter. Tất cả những điều này đều là những ví dụ thực tế về sự phối hợp đòi hỏi một số kiểu quản trị.

Từ lâu, tôi đã tin tưởng vào vô số các nhóm nhỏ làm việc cùng nhau thay vì các công ty khổng lồ tạo ra thế độc quyền và sau đó chiến đấu để bảo toàn nó. Trên thực tế, khoảng mười năm trước, một số người bạn và tôi đã tạo ra ProstoKSI (không phải là một công ty), bao gồm các nhà phát triển làm việc cùng nhau trong các dự án mã nguồn mở.

Nhờ vào tiền mã hóa, Web3 biến tầm nhìn này thành khả thi theo cách mà Web2 không thể. Hãy tưởng tượng xây dựng ứng dụng trên nền tảng của một nhà cung cấp đám mây hoặc sử dụng một ngân hàng được điều hành bởi một nhóm chỉ gồm 20 người không có liên kết chính thức và không có sự đảm bảo rằng tổ chức vẫn sẽ hoạt động trong một năm — có những giới hạn cho những gì bạn có thể xây dựng trên đó. Nhưng trong thế giới tiền mã hóa, cơ sở hạ tầng và các ứng dụng phi tập trung là đáng tin cậy vì chúng là các dự án mã nguồn mở, công khai và đi kèm với sự đảm bảo đáng tin cậy. Các ứng dụng được xây dựng theo cách này cung cấp các giao thức chung để tương tác với nhau, mà các nhà phát triển, doanh nghiệp và người dùng khác có thể dựa vào.

DAO là một phần của các giao thức chung trong thế giới mới. Trong bảy năm kể từ bài đăng của Vitalik, hàng nghìn thành viên đã thử nghiệm DAO trên Ethereum và các mạng lưới khác - một số mạng nổi tiếng nhất bao gồm Maker, Moloch DAO, MetaCartel, The LAO và Flamingo DAO. Tôi đã có được một số bài học quan trọng từ làn sóng thử nghiệm DAO đầu tiên giúp cung cấp tầm nhìn cho các DAO trên NEAR.

 	Nhìn chung, rõ ràng rằng các cách đơn giản để một cộng đồng kiểm soát việc quản trị không quy mô theo số lượng người tham gia. Hàng nghìn người không thể phát triển hoặc kiểm soát bất cứ thứ gì một cách hiệu quả nếu không có các quy tắc, luật hoặc hệ thống phân cấp. Chúng ta cũng đã thấy một số thử nghiệm trong không gian blockchain xung quanh việc quản lý các giao thức và quỹ đầu tư. Nhiều người trong số này đã thất bại vì nhiều lý do khác nhau, từ các vấn đề kỹ thuật đến thiếu sự quan tâm của các thành viên trong việc bỏ phiếu hoặc thiếu một nhân tố thống nhất, thúc đẩy.
 	Không ai có thể kỳ vọng rằng mọi thành viên trong nhóm sẽ luôn vui vẻ. Sự thích thú trôi đi và ý kiến của mọi người có thể thay đổi; đa số và thiểu số cuối cùng sẽ xuất hiện xung quanh một số vấn đề. Mặc dù trong hầu hết các trường hợp, mọi người sẽ đi đến sự đồng thuận thông qua quản trị đơn giản như bỏ phiếu, nhưng thiểu số cộng đồng có thể tách khỏi nhóm ban đầu để tuân theo một bộ quy tắc mới, bất cứ lúc nào nếu họ không đồng ý với số đông và có đủ ý chí của bản thân.
 	Bất kỳ cộng đồng hoặc tổ chức nào cũng cần đến sự lãnh đạo. Ngay cả khi đó là một nhóm người rất tận tâm - nếu họ không làm việc toàn thời gian cho mục đích chung, thì có lẽ họ quá bận rộn để luôn hoạt động tích cực và tham gia vào mọi cuộc thảo luận hoặc quyết định. Các cộng đồng thường có các thành viên tận tâm chịu trách nhiệm điều phối, có khả năng kiểm duyệt.
 	Nếu như một cộng đồng không phân quyền và ẩn danh, thì việc có các thành viên được công chúng biết là tham gia và tạo ra “cốt lõi” của cộng đồng vẫn có giá trị. Cộng đồng sẽ lắng nghe quan điểm và ý kiến của các thành viên này hơn bất kỳ người nào khác vì họ được biết đến là những người có nhiều thông tin và đầu tư nhiều nhất.
 	Một cộng đồng phi tập trung càng tập trung vào “sản phẩm” thì lãnh đạo càng phải tập trung hơn, vì việc phát triển sản phẩm thường đòi hỏi nhiều sự hiểu biết về bối cảnh hơn bất kỳ người tham gia cộng đồng nào. Ví dụ: một cộng đồng đang cố gắng xây dựng một blockchain hoặc một sàn giao dịch phi tập trung cùng nhau.
 	Các nhóm dựa trên cổ đông luôn thất bại, hoặc bởi vì đa số các bên liên quan không thể hoặc không muốn là những người tham gia tích cực, hoặc vì nó mở ra những cách dễ dàng để tấn công vào quá trình quản trị.

Câu hỏi: Có phải Sputnik DAO được tạo riêng cho các cộng đồng kỹ thuật không?

Có

Không

Vì vậy, DAO là một cộng đồng thống nhất với một số mục đích chung, yêu cầu một số quy tắc để điều phối và quản trị, với tính linh hoạt phát triển theo thời gian khi lợi ích và mục tiêu của cộng đồng thay đổi, và khả năng giao dịch và kiếm tiền như một đơn vị có mức tối thiểu trên không. Với tất cả những kiến thức này, chúng tôi bắt đầu tạo ra một giao thức DAO trên NEAR để trao quyền cho tất cả các loại cộng đồng — không chỉ các cộng đồng kỹ thuật do các kỹ sư điều hành — với một khuôn khổ linh hoạt, mạnh mẽ để làm việc và phát triển cùng nhau.

Câu hỏi: Điều nào sau đây là đúng về lãnh đạo cộng đồng?

Lãnh đạo thực sự đảm bảo rằng mọi thành viên trong cộng đồng luôn được vui vẻ

Các nhà lãnh đạo cộng đồng không bắt buộc phải làm việc toàn thời gian cho cộng đồng

Ngay cả trong một cộng đồng không phân quyền (permissionless), vẫn cần phải có các thành viên hoặc lãnh đạo cốt lõi

Các nhà lãnh đạo của cộng đồng điều hành cộng đồng bằng cách tạo ra các quy tắc

Sputnik DAO, cung cấp một cách để các cộng đồng, tổ chức mới và hiện tại trên toàn thế giới có đại diện trực tuyến cho nhóm của họ, quản lý hoạt động trên chuỗi của họ, điều chỉnh việc ra quyết định của riêng họ và quan trọng là với các DAO khác. Hiện tại có khoảng 100 Sputnik DAO kể từ lần ra mắt đầu tiên vào tháng 2/2021, với ~$500k được phân bổ và ~$500k được chứa trong kho bạc (xem chi tiết tại đây).

Hãy trải nghiệm sputnik.fund và cho chúng tôi biết suy nghĩ của bạn. Tuần tới, chúng tôi sẽ chia sẻ bản beta V2 với UX mới, các tính năng mới và một bài viết khác với thông tin chi tiết về cách Sputnik đang giải quyết một cách độc đáo những thách thức chính trong việc tổ chức cộng đồng. Theo dõi trên Medium để cập nhật thông tin về phiên bản V2.

Cảm ơn nhóm cộng đồng ban đầu của Sputnik đã có ý tưởng cho phiên bản v2; đội ngũ NEAR,

Tara tan, Julia Lipton vì đã nhận xét và đề xuất và Mally Anderson để chỉnh sửa.

Bài báo gốc trên Medium

 	S. Bạn muốn đóng góp cho LearnNEAR.Club? Gửi đề xuất của bạn để HỌC VỀ NEAR DAO.

### NEAR Protocol và Solana

Hôm nay, chúng ta cùng xem qua hai trong số các nền tảng hợp đồng thông minh hot nhất hiện tại, đó chính là NEAR Protocol và Solana. Trong khi Ethereum vẫn đang thống trị thị trường này, thực tế là việc thiếu khả năng mở rộng và phí cao đã buộc hầu hết các nhà phát triển phải tìm kiếm các giải pháp thay thế khả thi. NEAR và Solana là hai cái tên đã nổi lên trong thời gian gần đây.
Solana là gì?
Solana được thành lập vào năm 2017 bởi Anatoly Yakovenko, trước đó đã làm việc tại DropBox. Yakovenko, cùng với Eric Williams và CTO Greg Fritzgerald, đã tạo ra Solana để giải quyết các vấn đề hiện có trong Bitcoin và Ethereum. Dự án đã thu hút các quỹ đầu tư hàng đầu như Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures, v.v.



Các tính năng của Solana Blockchain

 	50,000 giao dịch mỗi giây và thời gian 0,4 giây mỗi block
 	Hệ thống có thể cung cấp 28,4 triệu giao dịch mỗi giây trên mạng lưới 40 gigabit
 	Solana sử dụng thuật toán đồng thuận Proof of History (PoH)

Proof of History (PoH) làm việc như thế nào?

Trong mạng lưới phi tập trung trải rộng trên một khu vực rộng lớn, sự đồng thuận là điều cần thiết. Bitcoin sử dụng cơ chế Proof of Work (PoW) để đạt được sự đồng thuận. Mặc dù phương pháp này có tính bảo mật cao, nhưng khó có thể bỏ qua vấn đề quan trọng nhất của nó, đó là thiếu khả năng mở rộng. Đừng quên rằng Bitcoin chỉ có thể thực hiện 7 giao dịch mỗi giây.

Solana sử dụng Proof of History, trong đó nó tạo ra các bản ghi lịch sử để chứng minh rằng một sự kiện đã xảy ra vào một thời điểm cụ thể. Dưới đây là một số điểm bạn cần lưu ý:

 	Thuật toán sử dụng hàm tần số cao có thể xác minh được độ trễ (Verifiable Delay Function), yêu cầu một số bước tuần tự nhất định để kết thúc.
 	Các giao dịch hoặc sự kiện được thực hiện trong mạng lưới sẽ được chỉ định một số hash (băm) duy nhất, có thể được xác minh công khai.
 	Tính toán cho phép mạng lưới biết chính xác thời điểm giao dịch hoặc sự kiện đã xảy ra.
 	Mỗi node đều có một đồng hồ mật mã giúp theo dõi thời gian trên mạng lưới và thứ tự của các sự kiện.

Nhờ vào PoH, mạng lưới Solana cho phép thực hiện 50,000 giao dịch mỗi giây khi chạy với GPU. 

Solana Cluster là gì?

Là một tập hợp các máy tính sở hữu độc lập làm việc cùng nhau và có thể được xem như một hệ thống đơn lẻ. Các tính năng chính của Cluster như sau:

 	Chúng giúp xác minh đầu ra của các chương trình không đáng tin cậy, do người dùng gửi. 
 	Ghi và lưu lại bất kỳ giao dịch hoặc sự kiện nào mà người dùng thực hiện.
 	Theo dõi những máy tính nào đã làm công việc có ý nghĩa để duy trì cho mạng lưới hoạt động.
 	Theo dõi việc sở hữu các tài sản trong thế giới thực.

Lập trình trong Solana

Các hợp đồng thông minh trong Solana được viết bằng Rust hoặc C và được biên dịch sang bytecode Berkeley Packet Filter (BPF). Vì có nhiều công cụ hơn, bạn nên viết mã bằng Rust. Người mới bắt đầu nên viết chương trình của họ bằng Anchor framework, giúp đơn giản hóa việc thực thi.

Solana có một mô hình tài khoản duy nhất tương tự như các tệp trong hệ điều hành Linux. Chúng có thể chứa bất kỳ dữ liệu tùy ý nào và cũng chứa siêu dữ liệu về cách chúng có thể được truy cập. Tuy nhiên, hãy nhớ rằng các tài khoản có kích thước cố định và không thể thay đổi kích thước. 

Mô hình lập trình hiện tại của Solana có thể buộc bạn phải di chuyển logic ứng dụng ra khỏi chuỗi hoặc sửa đổi chức năng không hiệu quả và bị giới hạn bởi kích thước tài khoản cố định. 

Mẫu hợp đồng thông minh
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
Điều gì đang xảy ra trong hợp đồng?

 	Tất cả các tài khoản được truy cập đều được chú thích trong cấu trúc cho mỗi lệnh gọi với #[derive(Accounts)]. 
 	Các chức năng giúp khởi tạo dữ liệu tài khoản cho chủ sở hữu ban đầu và mua hàng. Điều này cho phép bất kỳ ai mua nó sẽ có thêm token.
 	Dữ liệu tạm thời được chuyển vào các tham số của hàm. Các tham số này nằm bên trong các chức năng khởi tạo và mua hàng. Điều này cũng bao gồm bối cảnh nắm giữ các tài khoản yêu cầu cho giao dịch.
 	Trạng thái của hợp đồng nằm trong cấu trúc ContentRecord. Điều này được chú thích thêm với #[account] để biết rằng nó đại diện cho bố cục dữ liệu cho một tài khoản.

NEAR Protocol là gì?
Ra đời vào mùa hè năm 2018, giao thức được thiết kế để tạo ra môi trường hoàn hảo cho các ứng dụng phi tập trung bằng cách cung cấp tốc độ cao hơn, thông lượng cao hơn và khả năng tương thích tốt hơn với các chuỗi khác. NEAR có một kỹ thuật Sharding độc đáo và giới thiệu một cơ chế tạo khối được gọi là “Doomslug” được đề xuất vào năm 2019. Doomslug cho phép tính cuối cùng thực tế (“Doomslug” finality), đảm bảo rằng các khối nhận được tính chính thức trong vài giây.

NEAR Protocol được phát triển bởi NEAR Collective, một cộng đồng các nhà phát triển và nhà nghiên cứu hợp tác xây dựng dự án. Một số đặc điểm nổi bật của NEAR là:

 	NEAR là một hệ thống phân mảnh (sharded), cho phép khả năng mở rộng vô hạn. 
 	Một giao thức dễ sử dụng, NEAR cho phép các nhà phát triển xây dựng ứng dụng một cách dễ dàng và nhanh chóng. 
 	NEAR không phải là một side chain mà là một giao thức Layer 1. 
 	dApps được tạo bằng cách sử dụng NEAR chạy trên nền là lớp NEAR bên dưới.

NEAR Collective là gì? 

NEAR Collective bao gồm các tổ chức cá nhân và những người đóng góp khác đang liên tục làm việc để phát triển và cải thiện NEAR Protocol. Collective làm việc trên các dự án như viết code ban đầu và triển khai cho mạng lưới NEAR. NEAR hoàn toàn phi tập trung, hoạt động độc lập và không thể bị tắt hoặc thao túng, ngay cả bởi những người đã xây dựng nó.

Đây là một tổ chức phi lợi nhuận tập trung vào việc tạo ra một hệ sinh thái sôi động xung quanh NEAR Blockchain. Nó giúp điều phối các hoạt động quản trị và phát triển. NEAR Collective có một số dự án, với NEAR Blockchain chỉ là một trong số các dự án dưới sự bảo trợ của tập thể.

Cơ chế đồng thuận trên NEAR

Cơ chế đồng thuận được thực hiện trên NEAR được gọi là Nightshade. Nightshade mô hình hóa hệ thống như một chuỗi khối duy nhất. Danh sách tất cả các giao dịch trong mỗi khối được chia thành các phần vật lý, một phần cho mỗi phân đoạn. Tất cả các khối tích lũy thành một khối. Lưu ý rằng các phân đoạn chỉ có thể được xác thực bởi các node duy trì trạng thái của phân đoạn đó.

Nói về xác thực (validator), một thành phần quan trọng của NEAR là các validator. Các validator này chịu trách nhiệm duy trì sự đồng thuận trong giao thức. Validator là các node chuyên biệt cần giữ máy chủ của họ trực tuyến 100% thời gian trong khi giữ cho hệ thống của họ được cập nhật liên tục. 

Dưới đây là một số điểm cần lưu ý về các validator mạng lưới:

 	NEAR xác định các validator của mình ở mỗi epoch mới, lựa chọn dựa trên số tiền mà họ stake.
 	Các validator đã được chọn sẽ được đăng ký lại bằng cách tự động re-staking token của họ cộng với phần thưởng đã tích lũy.
 	Các validator tiềm năng phải được stake trên một mức được xác định cụ thể.
 	Có hai phương pháp mà validator có thể sử dụng để củng cố việc stake của họ là mua token của chính họ hoặc vay thông qua stake ủy quyền.
 	Phần thưởng bạn nhận được tỷ lệ thuận với tiền đã stake của bạn — stake càng nhiều, phần thưởng của bạn càng nhiều.

Đồng thuận dựa trên sự đồng thuận dây chuyền trên chuỗi. Có nghĩa là, khi một nhà sản xuất khối tạo ra một khối, họ sẽ thu thập chữ ký của các validator node. Trọng lượng của một khối sau đó là số tiền tích lũy của tất cả những người ký có chữ ký được bao gồm trong khối. Trọng lượng của một chuỗi là tổng trọng lượng của khối. Ngoài ra, sự đồng thuận sử dụng một tiện ích cuối cùng đưa ra các điều kiện cắt giảm bổ sung để bảo mật chuỗi cao hơn.

Aurora và NEAR Protocol

Aurora cũng đã ra mắt trên NEAR Protocol, cung cấp trải nghiệm Ethereum Layer 2. Một số điểm mà Aurora giúp cải thiện NEAR là:

 	Giúp tăng thông lượng lên hàng nghìn giao dịch mỗi giây.
 	Thời gian hoàn thành khối là 2 giây.
 	Tăng trưởng hệ sinh thái trong tương lai.
 	Phí giao dịch thấp, thấp hơn 1,000 lần so với Ethereum.
 	Khả năng tương thích hoàn hảo với Ethereum.

Mẫu hợp đồng thông minh
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

Điều gì đang xảy ra trong hợp đồng?

Những gì đang xảy ra ở đây trong hợp đồng trên? Chúng ta hãy xem xét kỹ hơn.

 	Hợp đồng được xác định bởi #[near_bindgen] trong ContentTracker, nó tương tự như một phương thức khởi tạo trong Solidity và được gọi khi hợp đồng được triển khai.
 	Chức năng mua hàng được chú thích bằng #[payable].
 	Hợp đồng bao gồm các lệnh gọi không đồng bộ dưới dạng Promise::new(…).transfer(…); lines.
 	Cấu trúc dữ liệu LookupMap<String, ContentRecord> xử lý tra cứu key-value, truy cập bộ nhớ. Điều này tương đương với Solidity “mapping.”

Kết luận
Cả Solana và NEAR Protocol đều là những nền tảng hợp đồng thông minh tuyệt vời, được xây dựng bởi những cộng đồng tích cực. Cả hai đều mang lại những tính năng đặc biệt giúp giải quyết các vấn đề lớn nhất đang gây ra cho thế giới phi tập trung đó chính là tốc độ. Cả hai nền tảng vẫn đang phát triển và hứa hẹn sẽ mở rộng trong tương lai.

### Все что нужно знать о голосовании NEAR Ecosystem Treasury

«Предлагаю создать Ecosystem Treasury DAO (Казначейство экосистемы Децентрализованной Автономной Организации). Предложение включает в себя отбор участников, и выделение финансирования на сумму до 200M $NEAR от NEAR Foundation. Следующий шаг - сообщество NEAR должно дать обратную связь по этому предложению и, если в течение следующих 2 недель не возникнет серьезных проблем, запустить голосование за  первых членов этой DAO ».
Экосистема NEAR уже давно стала домом для различных объединений людей, интересующихся криптовалютой. С появлением все большего количества творческих личностей, гильдий и готовящейся к запуску  новой структуры DAO, экосистема NEAR переживает масштабную модернизацию:  Treasury DAO было предложено соучредителем NEAR Ильей Полосухиным, чтобы создать по-настоящему децентрализованный механизм управления для роста экосистемы NEAR.
Что нужно знать:
Что такое NEAR Treasury DAO? Это DAO для управления другими DAO на NEAR

Если коротко, NEAR Treasury DAO является органом управления экосистемой NEAR, а NEAR Ecosystem treasury эффективно распределяет токены $NEAR на ее нужды. Как на форуме объясняет сам Илья:

«Для распределение средств, Treasury DAO не будет выделять их непосредственно на проекты/инициативы. Вместо этого оно будет направлять средства в другие DAO . И его внимание сосредоточится на тщательной проверке/отборе самих DAO для финансирования.»

Группа из 21 участника выбирает "Председателя", который управляет распределением $NEAR среди суб-DAO, финансирующих проекты или конкретных людей в рамках своей специализации. У этих суб-DAO также есть свой собственный совет из конкретных представителей, отвечающих за финансируемую сферу.

Участники должны будут выбрать "Председателя", который будет отвечать за разработку стратегии на самом высоком уровне, собирать информацию о проектах и следить за своевременным исполнением решений DAO.



"Председатель"  Treasury DAO будет регулярно информировать остальных членов экосистемы NEAR о своей работе и плане дальнейшего развития:

"Председатель также ответственен за обеспечение прозрачности распределения средств для сообщества, участвуя в Собраниях и докладывая о текущем состоянии дел и достигнутых  результатах".
Как работает Treasury DAO:
Теперь, зная основу, мы можем немного углубиться в тонкости, связанные с фактическими операциями Treasury DAO. Вкратце:

 	В конце квартала участники Совета могут быть заменены, если изменится количество их стейка $NEAR или придут новые участники, которые внесут больше токенов $NEAR в стейк.
 	   В течение квартала этот участник имеет равный со всеми другими членами DAO голос при утверждении предложений, выдвинутых другими участниками или Председателем DAO
 	   В конце квартала участники Совета могут быть заменены, если изменится количество их стейка $NEAR или придут новые участники, которые внесут больше токенов $NEAR в стейк.

Таким способом, Совет DAO Treasury  эффективно проводит «выборы» с помощью "Стейка",  который выступает средством  отбора наиболее квалифицированных и заинтересованных участников.

"Каждый пользователь блокчейна NEAR, сделавший стейк, может вызвать функцию delegate(account_id, amount_pct) на контракте DELEGATION, чтобы выделить процент от своего стейка одному из кандидатов в Совет Treasury DAO. Каждый квартал происходит обновление информации о количестве стейка участников Совета, и членами совета становятся те кто имеет большее количество NEAR в стейке в момент снапшота."
Эволюция  Treasury DAO:
В долгосрочной перспективе NEAR Treasury DAO станет одним из крупнейших спонсоров экосистемы NEAR. Для начала они начнут со скромной суммы в 30 миллионов $NEAR, чтобы продемонстрировать свои способности в управлении развитием экосистемы.

«Грант Treasury DAO может быть увеличен начиная с первого распределения токенов  (всего до 200 миллионов  $NEAR), если у Treasury DAO не возникнет никаких проблем и она заслужит поддержку сообщества.»

Ближайшая дорожная карта для стандартизации развития экосистемы на NEAR:



Крипто экосистемы все еще находятся в зачаточном состоянии. В условиях недостаточного понимания ценности сообществ, экосистема NEAR находится на передовой развития социальной и личностной инфраструктуры саморазвивающейся экосистемы. Благодаря одной из самых развитых и гибких инфраструктур DAO, а также растущему количеству высокоактивных участников, можно создать множество DAO и Советов для удовлетворения конкретных потребностей экосистемы.

В рамках изначального предложения, выдвинутого Ильей: , уже обсуждался ряд суб-DAO:

 	Liquidity DAO: DAO, ориентированная на финансирование поощрений по поддержанию ликвидности и других потребностей DeFi в экосистеме.
 	 Marketing DAO: DAO для финансирования деятельности гильдий, занимающихся рекламой и продвижением проектов экосистемы. В NEAR уже есть несколько таких гильдий, и они важны для повышения узнаваемости и распространения информации более открытым, децентрализованным способом. Очевидно, что NEAR Foundation не в силах эффективно распространять информацию для всей экосистемы.
 	Grants DAO: DAO, которая распределяет гранты среди разработчиков в экосистеме. Это дополнит существующую программу грантов NEAR Foundation и обеспечит более масштабируемый и прозрачный подход в будущем.
 	Guilds DAO: DAO, которая будет распределять средства между всеми гильдиями в экосистеме.

В целом, NEAR Ecosystem Treasury DAO и множество суб-DAO, действующих под ее управлением, демонстрируют один из самых уникальных и инновационных подходов к управлению сообществом. Обязательно оставляйте комментарии на форуме NEAR и готовьтесь к голосованию по этому предложению, которое состоится в ближайшие недели!

### LearnNEAR.Club LNC Weekly Update - July 2, 2021

Brief Summary (1-2 paragraphs):

 	Chinese Community translators working on NEAR learning materials
 	First LNC NEAR Certified Developer Level 2 graduate project got beta tested by (L)Earners.

Results:

 	First Guide translated in Chinese
 	First LNC NEAR Certified Developer Level 2 graduate project got beta tested by (L)Earners! 65 $NEAR paid!

 	Guide Top 3 NFT Projects On The NEAR Protocol


 

Challenges & Blockers:

 	Looking for more learning materials from NEAR Collective

Action Items:

 	Develop and implement LNC contributors framework/flow powered by sub-dao method.

### Top 7 NEAR NFT Projects

The growth of DeFi has brought NFTs into mainstream focus, and the growth of NFTs has also brought several problems into sharp focus. Ethereum has a monopoly over this sector, with many NFTs created on the Ethereum blockchain. So what is the problem with creating NFTs on one of the most popular platforms in the world? The issue of high gas fees. Ethereum has a big problem when it comes to fees which can potentially cross hundreds of Dollars, which makes it very impractical. 

So what are the options when it comes to NFTs and NFT projects? What other choices do they have? The NEAR Protocol has several important projects on its platform and is often touted as the Ethereum killer. The NEAR Protocol is a scalable blockchain that simplifies and accelerates the development of dApps. At the moment, there are 19 decentralized platforms and NEAR NFT Marketplaces to mint and trade NFTs on the NEAR blockchain. The NEAR Protocol has a significant advantage over Ethereum, as it is significantly faster than Ethereum, and transactions cost next to nothing, making it an ideal platform for trading in NFTs
NEAR Protocol And NFTs
The NEAR Protocol is the perfect platform for NFTs as it has many advantages over Ethereum. The protocol is significantly faster than Ethereum. Ethereum also has substantially higher gas fees, while NEAR allows transactions to be processed for a negligible fee. These factors make NEAR ideal for buying and selling NFTs.

As mentioned earlier, there are already several NFT projects that have been created on the NEAR blockchain. However, before taking a look at the projects, let us briefly understand the concept of NFTs.
The Meaning Of Non-Fungible
A fungible asset is an asset that can be exchanged for another identical asset. Bitcoin is an excellent example of a fungible asset, which means you can exchange one bitcoin for another bitcoin without any problems. Non-fungible assets, on the other hand, are unique assets that cannot be traded. An example of a non-fungible asset can be a unique painting or limited edition collectibles.

A non-fungible asset has a distinct property or properties that set it apart from other assets. Non-fungible tokens are based on non-fungible assets and are unique digital assets that use blockchain technology.
What Is An NFT?
NFTs are unique digital assets that have their identifying information recorded on a smart contract. The information on the smart contract is what makes an NFT unique. Fungible assets like Bitcoin can be exchanged, meaning you can send or receive bitcoin without any hitches. Fungible assets are also divisible, allowing you to send smaller amounts. Non-fungible assets are not divisible. For example, you can’t send someone a part of a painting or a ticket.

NFTs are digital certificates of ownership for digital assets. An NFT is a smart contract that is utilized for securing a digital asset. Once written, it is published into a token (ERC-721) on the blockchain. Anything can be turned into an NFT, with the most popular being videos, GIFs, or JPEGs.




	

	
	
		
			
				Which of the following is an NFT? 
			
		

		
					

		
			
			
			
			Bitcoin 
		
			
			Fiat currency
		
			
			A digital collectible
		
			
			nDAI
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NFT Projects on NEAR Protocol
Currently, there are several NFT platforms on NEAR so let us look at some of the more popular projects on the platform.
Mintbase
Mintbase started in 2018 and was created by Nate Geier and Calorine Wend. Nate Geier is the company’s CEO, while Caroline is the COO, utilizing her management and business development expertise. Mintbase managed to raise $1 million from a seed funding round in 2020. Sino Global led the round and also consisted of other VCs such as Block Oracle Capital, D1 Ventures, and other angel investors.

Fish Woman by From my Dream

The Mintbase platform allows users to create and sell NEAR NFTs. Users can mint different digital assets as NFTs. These assets could range from event tickets to crypto art and everything in between.

Mintbase allows pretty much anyone with access to the internet to make an NFT and make it available for sale in their NEAR NFR marketplace or on NFT marketplaces like OpenSea. Minters can create a smart contract and limit the transferability of the tokens minted, helping prevent fraud or the illegal transfer of unique items. Mintbase is focused on creating an NFT creation experience that is unique, which is why, as mentioned earlier, it supports different digital assets. This is contrary to competing platforms that focus on one specific NFT category.
Why Did Mintbase Switch To NEAR?
So why the switch from Ethereum to NEAR? The answer is Gas fees. Ethereum Gas fees had started to become ridiculously expensive. To mint NFTs on Mintbase, a user needs to create a digital store. This involves the user creating a smart contract and pay Ethereum a Gas fee. Initially, the fee was low, and users were able to deploy the store quickly. However, with increasing congestion on the Ethereum network, the fees started to get higher and higher, with store creation costing hundreds of dollars. The cost became so high that Mintbase had to tell its users to wait for Gas prices to drop before deploying a store. Ethereum quickly became untenable to buy, sell or create NFTs.

Mintbase saw NEAR as a better platform compared to Ethereum, with significantly lower Gas fees thanks to a more efficient contract execution model. It also uses Nightshade, a dynamic approach to Sharding. However, there are several other reasons why Mintbase switched to NEAR.

 	The use of Rust or AssemblyScript for smart contracts on the NEAR platform makes it easy for developers to write code
 	NEAR features human-readable addresses for both contracts and accounts
 	Developers can onboard users quickly, thanks to NEAR Drops. They can pay for their NEAR accounts and send NEAR tokens
 	Developers and users can move assets quickly thanks to the ETH-NEAR Rainbow bridge
 	Other DeFi platforms such as Aave and Balancer are also on NEAR, which will make any future integration easy.




	

	
	
		
			
				Why did Mintbase switch to NEAR? 
			
		

		
					

		
			
			
			
			High Gas fees
		
			
			NEAR is a better platform 
		
			
			Developers can move assets faster
		
			
			All of the above 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Paras
Paras was created with a vision of providing the solution to aging traditional collectible cards. The platform validates ownership through the blockchain through fast and inexpensive transactions. The platform focuses on creating crypto-native collections which can be further diversified into more prominent mediums.

PunkyPoN#0006 by monztre.near

Paras is an all-in-one digital art card marketplace built on NEAR. The platform can validate ownership and give access to every purchase and mint to users. It offers quick and cheap transactions, and it differentiates itself from other marketplaces by offering collections instead of single releases. The platform differentiates itself in the following way.

 	Paras reduces the maintenance burden on collectors by ensuring that their collectibles do not wear out over time. The platform removes barriers and gives artists and collectors easy access to the digital collectibles market. Thanks to the NEAR Protocol, Paras can reduce the costs incurred by artists to sell their cards
 	Paras is developing the Digital Art Card vertical for future artists, gamers, and creatives and enabling artists to create a collection that links to a theme or lore. Through this method, Digital art cards in Paras are rich with stories and backgrounds.

Paras is able to take a curated approach and create an NFT community and experience. Paras ensures consistency and quality by selecting artists and formats. Artists can create new cards on Paras only after being approved, and the number of new artists approved is limited to 30 artists per week. Artists are also required to conform to the standard 64:89 aspect ratio.




	

	
	
		
			
				What is Paras? 
			
		

		
					

		
			
			
			
			An all-in-one digital art card marketplace
		
			
			A smart contract platform 
		
			
			A programming language 
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Since the platform’s launch, artists on Paras have already made more than $25,000, with the platform able to facilitate a trading volume of more than $35,000 from more than 700+ transactions. The platform has more than 80 active collectors and over 70 artists. The low minting fee keeps the entry barrier for digital artists pretty low, and artists can mint cards without worrying about the minting cost.
Why Is NEAR A Great Fit For Paras?
Because demand for space on Ethereum is driving up costs on the platform, newer NFT creators are looking for alternatives and solutions. NEAR is working with Ethereum on an interoperable solution. Transactions on NEAR cost only a few cents, and sometimes even less. The NEAR wallet is highly efficient, and transactions are completed almost instantly. The Rainbow bridge ensures that NEAR will be interoperable with assets based on Ethereum.
(L)Earner NFT
Learn NEAR Club is also issuing our own generated PFP NEAR NFTs - (L)Earner.
(L)Earner NFT collection is a collab between LNC community and one of the best award winning graphic designers in Europe.
Art concept is based on dynamic human intelligence diversity powered by uniqueness of every learner.

Nerve endings are similar in all people but are unique in each. The concept of this collection is built on the connections of impulses that occur during the process when we learn. It is part of the map of our experience of getting any information. From learning a new word to learning a new skill these nerve impulses are generated by a machine in an attempt to study the human experience.
 



Every NFT minter is invited to creatively participate in this project:

 	Generate, pick posture and colors of the graphic character crafted by design genius
 	Give name to your creature
 	Curate your personal unique collection.

The cost of minting is set to 2 $NEAR for the first 250 mints so it is supposed to be affordable for every Learn NEAR Club member.
Minting cost is gradually increasing with every mint and will reach 10 $NEAR for (L)Earner #10,000 mint.
First 10 (L)Earners squared


(L)Earner NFT holders also get benefits at Learn NEAR Club:

 	Priority 2 hours earlier access to Redeem to NEAR window
 	Mint Proof of (L)Earn NFT
 	more to come.

NameSky





NameSky is an NFT project on the NEAR blockchain. It’s built with utilities to make buy & sell NEAR accounts easy and secure as NFTs.



Every NFT represents the ownership of the attached NEAR account, i.e. buying an NFT with account id alice.near means buying the alice.near NEAR account.







How to turn a NEAR account into an NFT?






Upon minting an NFT, a lock contract will be deployed to the attached NEAR account and all access keys will be removed from that attached NEAR account. Thus, only the owner of the NFT can access the NEAR account through the lock contract.

How to turn an NFT back into a NEAR account?






The owner of NameSky NFT can take back the attached NEAR account from this website.

Only the NFT owner is able to bind a new access key to the attached NEAR account through the lock contract which is deployed during minting process. The NFT will be burned after binding a new access key is done.

The recovery phase is generated locally from owner’s device and only be visible to the owner. Thus the owner and ony the owner can take back control of the attached NEAR account.









NPunks
After the tremendous success of Cryptopunks, Solpunks, and Tpunks, NEAR will finally have its own version of the project, called Npunks. As with the original Punks project, there will be 10,000 unique NPunks with their own rarity traits. The collection will have 9 aliens, 24 apes, 88 zombies, and 111 bots.



To avoid hoarding and ensure fair participation, everyone has the chance to buy one (or more Npunks). The purchases are made randomly and the identity is kept a mystery until the transaction is deemed complete. Users are free to sell their Npunk in the secondary market post-mint.
NEAR Misfits
NEAR Misfists are NEAR's first cryptographically complete NFT collection. The MIsfits consists of 1,600 Normie, 150 Zombies, 101 Skellies, 50 Meerkats, and 22 Glitch Misfits.



Back in November 2021, 1,923 Misfit NFTs were sold out in under 36 hours. As of now, you can buy these NFTs on NEAR NFT marketplaces like Paras and Mintbase.
NEARNauts
NEARNauts is a community-driven, randomly generated NFT that aims to grow an organic and loyal community around the project. A pool of rare traits ensures verifiable uniqueness. This Verifiable Random Function (VRF) includes three algorithms – generated, proof, and verification. 

 	Generated: This produces two pairs of keys – a secret key (SK) and a public key (pk).
 	Proof: Takes the SK and message (x) to provide a random output (y) and a proof.
 	Verification: The verification algorithm takes pk, x, and y and uses the proof to verify the validity of the output.



The NEARNauts Community DAO will go live in Q1, 2022.
Conclusion
NEAR is making building and deploying dApps easier, faster, and cheaper than any other blockchain protocol and is one of the most promising projects in the crypto space. It addresses several issues faced by projects on Ethereum, such as high gas fees and slow processing speeds. It also has several advantages over the Ethereum blockchain thanks to its sharded solution.

The NEAR Protocol has shown significant promise, utilizing Sharding to solve issues faced by other blockchains. Thanks to this approach, NEAR is able to increase throughput without compromising on security. The NEAR Collective ensures that engineers and developers are constantly working on the protocol.

### NEAR账户 - 快速指南

NEAR账户介绍

 	NEAR使用人类可读的账户标识符。例如，maria.near 或 jane.near。
 	从 NEAR 帐户可以根据需要创建多个子帐户的角度来看，NEAR 帐户系统类似于网站域名系统。 例如，maria.near 的帐户可以创建像 sub.maria.near 帐户，以及first.sub.masha.near, second.sub.maria.near等。
 	NEAR钱包 (https://wallet.near.org/) 、NEAR水龙头(https://faucet.paras.id/)（Ethereum和Metamask用户可以使用）和 near-cli (https://github.com/near/near-cli) （为NEAR集成提供功能的命令行接口）都可以用来创建帐户。
 	通过 https://nearnames.com 服务，您可以创建一个 NEAR 帐户并的作为礼物发送给朋友或订阅者。
 	您可以在NEAR浏览器（https://explorer.near.org/）以及NEAR的钱包中查看帐户信息。
 	除了显式帐户（name.near类型），NEAR 生态系统还支持通过 near-cli 创建隐式账户（它们看起来与比特币和以太坊地址相似）。 您可以在此处找到详细的英文指南
 	系统中的每个帐户只能部署1个智能合约。 对于要求用户使用多个智能合约的应用程序，可以使用子帐户来部署。 例如 contract_1.maria.near、contract_2.maria.near等。
 	在NEAR生态系统中有开发者帐户（https://docs.near.org/docs/concepts/account#dev-accounts）。 他们的专用于测试和调试智能合约。

NEAR账户 - Keys

 	NEAR和其他大多数区块链一样使用基于密码学的密钥。 它依赖于一对或多对由相互匹配的公钥（public key）和私钥（private key） 组成的密钥对。
 	NEAR 用户使用公钥进行身份识别，用私钥进行签名交易（在交易创建期间确认帐户所有权）。
 	NEAR 有3种类型的密钥：Access Keys用于帐户交易签名，Validator Keys允许与网络验证相关的操作，Node Keys（网络节点）允许网络上节点之间的底层通信。更多资料介绍可以参考这里
 	密钥可以存储在3种不同的存储中：BrowserLocalStorageKeyStore - 未加密的本地浏览器存储，用于使用浏览器中的应用程序；InMemoryKeyStore - 内存存储，用于临时方案或在本地程序指定特定的密钥； UnencryptedFileSystemKeyStore - 用于 near-cli或本地程序，是位于文件系统中的未加密存储。
 	帐户可以具有多个访问密钥或没有密钥。
 	密钥可以具有不同的访问级别 - FullAccess（完全访问）或 FunctionCall（只能调用合约方法）。
 	所有密钥在一个帐户中是唯一的，但同一个公钥可以以不同访问级别添加到不同帐户上。 访问级别决定了可以使用此密钥执行帐户中的哪些操作。
 	对于 FullAccess 访问级别，所有8种类型的操作均可用：CreateAccountAction（创建帐户）、DeployContractAction（部署合约）、FunctionCallAction（调用合约方法）、TransferAction（将通证发送到另一个帐户）、StakeAction（质押通证）、AddKeyAction（给账户添加密钥）、DeleteKeyAction（删除帐户的某个密钥）、DeleteAccountAction（删除帐户）。
 	对于 FunctionCall 访问级别，只有FunctionCallAction可用（调用合约方法）。 此外，对于这样的密钥，您可以指定它可以调用的合约方法。

### NEAR Protocol и Solana

Рассмотрим две самые перспективные платформы смарт-контрактов в мире - Near Protocol и Solana. Не смотря на отсутствие масштабируемости и высокие комиссии, Ethereum по-прежнему доминирует на рынке платформ смарт-контрактов, однако многие разработчики начали искать жизнеспособные альтернативы, среди которых Near и Solana выбились в лидеры.
Что такое Solana?
Компания Solana была основана в 2017 году Анатолием Яковенко, который ранее работал в DropBox (компании, предоставляющий файловый хостинг - прим. переводчика). Яковенко вместе с Эриком Уильямсом и техническим директором Грегом Фрицджеральдом создали Solana для решения существующих проблем в Bitcoin и Ethereum. Проект привлек инвестиции от венчурных компаний Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures и др.


Особенности блокчейна Solana

 	
50 000 транзакций в секунду и время блока 0,4 секунды

 	
28,4 миллиона транзакций в секунду в 40-гигабитной сети.

 	
алгоритм консенсуса Proof-of-History.


Как работает Proof-of-History (PoH)?
Для децентрализованной сети метод достижения консенсуса крайне важен. Для обеспечения консенсуса сеть Биткойн использует доказательства выполнения работы (proof-of-work, PoW). Хотя метод очень безопасен, трудно не заметить его самую существенную проблему - отсутствие масштабируемости. Сеть Биткойн может проводить только 7 транзакций в секунду.
Solana использует доказательство истории (Proof-of-History, PoH), в котором создаются исторические записи, доказывающие, что событие произошло в определенный момент времени. Вот некоторые моменты, которые необходимо иметь в виду:


 	
Алгоритм использует высокочастотную функцию проверяемой задержки (Verifiable Delay Function, VDF), которая требует определенного количества последовательных шагов для завершения.

 	
Транзакции или события, с тактовым временем сети, будут обозначены уникальным порядковым номером хеширования (count), который может быть публично проверен.

 	
Порядковый номер хеширования позволяет сети точно знать, когда произошла транзакция или событие.

 	
Каждая нода имеет криптографические часы, которые помогают отслеживать время в сети и порядок событий.


Благодаря PoH сеть Solana поддерживает 50 000 транзакций в секунду при работе на графических процессорах.

Что такое кластер Solana?
Кластер - это набор независимых компьютеров, работающих вместе, которые можно рассматривать как единую систему. Основные характеристики кластера:


 	
Помогает проверять вывод программ, переданных пользователем.

 	
Ведет запись любой транзакции или события, которое совершает пользователь.

 	
Отслеживает, какие компьютеры выполняли значимую работу для поддержания работоспособности сети.

 	
Отслеживает владение активами реального мира.





	

	
	
		
			
				Что из перечисленного использует шардинг?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			И то и другое
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Программирование в Solana
Смарт-контракты в Solana написаны на Rust или C и скомпилированы в байткод фильтра пакетов Berkeley (Berkeley Packet Filter, BPF). Рекомендуется писать на Rust,  поскольку для него доступно больше инструментов. Новичкам следует писать свои программы с использованием фреймворка Anchor, который упрощает их выполнение.
Solana имеет уникальную модель аккаунтов, которая похожа на файлы в операционной системе Linux. Они могут содержать произвольные данные, а также метаданные о том, как к ним можно получить доступ. Следует помнить, что аккаунты имеют фиксированный размер и не могут быть изменены.
Текущая модель программирования Solana может вынудить вас перенести логику приложения за пределы блокчейна или изменить функциональность так, чтобы она соответствовала ограничениям размера аккаунта. Однако это может снизить эффективность программы



	

	
	
		
			
				Что из перечисленного ниже является важной частью Solana?
			
		

		
					

		
			
			
			
			Кластер
		
			
			Парачейн
		
			
			Solana Collective
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Example Contract
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
Что происходит в контракте?

 	
Все аккаунты, к которым необходимо получить доступ, описываются в структуре для каждого вызова с помощью #[derive(Accounts)].

 	
Дополнительные функции помогают инициализировать данные аккаунта первоначального владельца и покупок. Это позволяет любому желающему приобрести их за большее количество токенов.

 	
Временные данные передаются в параметрах функции. Эти параметры находятся внутри функций initialize и purchase. Сюда также входит контекст (Context), в котором хранятся аккаунты, необходимые для транзакции.

 	
Состояние контракта находится в структуре ContentRecord. Он дополнительно помечен #[account], показывая, что он представляет собой слой данных для аккаунта.


Что такое NEAR Protocol?
Протокол появился летом 2018 года и был разработан для создания идеальной среды для децентрализованных приложений. Он обеспечивает более высокую скорость транзакций и лучшую совместимость с другими цепочками. В NEAR есть уникальная технология шардинга и введен механизм генерации блоков под названием "Doomslug", предложенный в 2019 году. Doomslug обеспечивает рациональную или "Doomslug" финальность, гарантируя, что блоки финализируются за считанные секунды.
Протокол NEAR разработан NEAR Collective, сообществом разработчиков и исследователей, сотрудничающих в создании проекта. Вот некоторые критические особенности NEAR:


 	
NEAR - это шардированная система, обеспечивающая бесконечную масштабируемость.

 	
NEAR - это простой в использовании протокол, который позволяет разработчикам легко и быстро создавать приложения.

 	
NEAR - это полноценный блокчейн первого уровня.

 	
Децентрализованные приложения (dApps), созданные с помощью NEAR, работают поверх блокчейна NEAR.


Что такое NEAR Collective?
NEAR Collective включает в себя отдельные организации и любых других участников, которые постоянно работают над улучшением протокола NEAR. Collective работает над такими проектами, как написание изначального кода и реализация в сети NEAR. NEAR полностью децентрализован, работает независимо и не может быть остановлен или подвержен манипуляциям даже теми, кто его создал.
Это некоммерческая организация, деятельность которой сосредоточена на создании живой экосистемы вокруг блокчейна NEAR. Она помогает в координации деятельности по управлению и разработке. Блокчейн NEAR - лишь один из нескольких проектов под эгидой Collective.

Механизм консенсуса NEAR
Механизм консенсуса, реализованный в NEAR, называется Nightshade. Nightshade моделирует систему как единый блокчейн. Список всех транзакций в каждом блоке разбивается на физические кусочки - чанки (chunks), по одному на каждый шард. Все чанки накапливаются в один блок. Обратите внимание, что чанки могут быть подтверждены (валидированы) только нодами, которые поддерживают состояние этого шарда.
Ключевым компонентом NEAR являются валидаторы. Валидаторы отвечают за поддержание консенсуса в рамках протокола. Валидаторы - это специализированные ноды, которые должны поддерживать свои серверы онлайн 100% времени, при этом постоянно обновляя свои системы.
Вот несколько моментов, которые нужно помнить о валидаторах сети.


 	
NEAR определяет своих сетевых валидаторов каждую новую эпоху, избирая их на основе их заблокированной доли - стейка.

 	
Уже избранные валидаторы повторно регистрируются автоматически заново отправляя в стейк свои токены и начисленные вознаграждения.

 	
Потенциальные валидаторы должны иметь стейк выше динамически определяемого уровня.

 	
Есть два способа, которые валидатор может использовать для увеличения своего стейка - он может купить токены самостоятельно или одолжить через делегирование доли.

 	
Вознаграждение, которое вы получаете, прямо пропорционально вашему стейку - больше стейк, больше вознаграждение.


Консенсус основан на выборе самой тяжелой цепочки. Это означает что, как только производитель блока публикует блок, он собирает подписи нод-валидаторов. Вес блока - это совокупный стейк всех подписавших нод, чьи подписи включены в блок. Вес цепочки - это сумма весов блоков. Кроме того, в консенсусе используется гаджет финальности, который вводит дополнительные условия наказаний (слешинга) для повышения безопасности цепочки.



	

	
	
		
			
				Doomslug" - это механизм генерации блоков какого протокола?
			
		

		
					

		
			
			
			
			NEAR Protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Aurora и NEAR Protocol
Aurora также запущенная на NEAR Protocol, обеспечивает работу с Ethereum являясь Layer-2 решением. Ключевые особенности Aurora:


 	
Помогает увеличить пропускную способность до тысяч транзакций в секунду.

 	
Время финализации блока составляет 2 секунды.

 	
Устойчивость к росту экосистемы в будущем

 	
Низкие комиссии за транзакции, которые в 1000 раз ниже, чем у Ethereum.

 	
Абсолютная совместимость с Ethereum.


Пример контракта
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

Что происходит в контракте?
Давайте рассмотрим подробнее, что же происходит в контракте.


 	
Контракт определяется #[near_bindgen] в ContentTracker, он похож на конструктор в Solidity (язык программирования смарт-контрактов в Ethereum) и вызывается при развертывании контракта.

 	
Описание функции покупки #[payable].

 	
Контракт включает асинхронные вызовы в виде строк Promise::new(...).transfer(...);.

 	
Структура данных LookupMap<String, ContentRecord> обрабатывает поиск ключ-значение, которое обращается к хранилищу. Это равносильно "маппингу" (mapping) в Solidity.


Заключение
И Solana, и NEAR Protocol - это блестящие платформы смарт-контрактов, созданные очень активными сообществами. Обе они обладают специальными функциями, которые помогают бороться с самой большой проблемой децентрализованного мира - скоростью. Обе платформы продолжают развиваться и имеют большие перспективы.

### LearnNEAR.Club LNC Weekly Update - June 25, 2021

Brief Summary (1-2 paragraphs):

 	Vietnamese and Russian Community translators working on learning materials.

Results:

 	Sub-DAO framework is being used for funding and self-organization. Check https://www.sputnik.fund/#/dao/learnnear.sputnikdao.near and https://www.sputnik.fund/#/dao/learn-near-vietnam.sputnikdao.near https://learnnear.club/vi/near-rainbow-bridge-hoat-dong-nhu-the-nao/
 	June Demo Day  - 2 demo projects

https://youtu.be/1nYONR06sUA

 	Guide  NEAR protocol and Solana



Challenges & Blockers:

 	Looking for more learning materials from NEAR Collective

Action Items:

 	Job Board connecting LNC learners and NEAR ecosystem projects

### НИАР протокол и Этереум

Сегодня, Ethereum является ведущей платформой для смарт-контрактов в криптопространстве, большинство смарт-контрактов и децентрализованных приложений (dApps) основаны на его блокчейне. Помимо Ethereum, на рынке есть несколько других платформ для смарт-контрактов.

Однако то, что Ethereum является лучшей платформой, когда дело доходит до смарт-контрактов и DeFi, не значит, что у него нет проблем. У него есть одна вопиющая проблема, и это серьезные проблемы с масштабируемостью. Etherium просто не может масштабировать свою сеть.

Здесь на сцену выходит NEAR Protocol. УТП(уникальное торговое предложение) NEAR заключается в том, что он использует механизм консенсуса Proof-of-Stake, который использует шардинг. Прежде чем мы погрузимся глубже, давайте познакомимся с Ethereum и NEAR.

Что такое Ethereum?

Если вы посмотрите определение Ethereum на его веб-сайте, оно выглядит следующим образом:

«Ethereum - это технология, являющаяся обителью цифровых денег, глобальных платежей и приложений. Сообщество создало быстро развивающуюся цифровую экономику, новые смелые способы заработка в Интернете для авторов и многое другое. Он открыт для всех, где бы вы ни находились ».

Основанная в 2015 году Виталиком Бутериным, Ethereum прочно зарекомендовала себя как вторая по величине криптовалюта по рыночной капитализации, уступая только Биткойну. Ethereum основан на блокчейне Биткойна, что делает его больше, чем просто еще одну криптовалюту, которая позволяет пользователям отправлять или получать ценности без какого-либо вмешательства третьих лиц.

Ethereum обеспечивает децентрализацию, заменяя центральные серверы тысячами узлов, гарантируя, что платформа всегда в сети и свободна от какого-либо стороннего влияния. Смарт-контракты также являются неотъемлемой частью экосистемы Ethereum, и поскольку платформа поддерживает как децентрализованные приложения, так и смарт-контракты, она чрезвычайно привлекательна как для разработчиков, так и для пользователей.

Ethereum сейчас переходит на Ethereum 2.0 или Serenity. Обновление значительно улучшит масштабируемость, эффективность и скорость блокчейна Ethereum. Кроме того, оно позволит Ethereum снизить затраты на газ и обрабатывать больше транзакций, улучшая масштабируемость блокчейна без ущерба для безопасности.

Обновление также приведет к переходу Ethereum на механизм консенсуса Proof-of-Stake . PoS увидит валидаторов, выбранных алгоритмически, для обеспечения безопасности платформы. Валидаторы защитят платформу, заблокировав свои ETH. Любому валидатору, действующему против интересов платформы, сокращается его стейк, обеспечивая безопасность платформы.

Что такое протокол NEAR?

NEAR Протокол берет свое начало летом 2018. Являясь децентрализованной платформой разработки, протокол был разработан для создания идеальной среды для децентрализованных приложений с упором на недостатки других платформ в области смарт-контрактов и децентрализованных приложений. Эти недостатки в основном связаны с низкими скоростями, низкой пропускной способностью и плохой совместимостью с другими цепочками.

NEAR работает на основе протокола NEAR, блокчейна Proof-of-Stake (PoS), включая несколько функций и нововведений для снижения затрат и повышения масштабируемости как для пользователей, так и для разработчиков. Кроме того, NEAR использует уникальный подход к «Шардингу».

Он также вводит механизм генерации блоков под названием «Doomslug», который был предложен в 2019 году. Doomslug допускает практическую или «Doomslug» finality (Гарантия того, что криптовалютные транзакции не могут быть изменены, или отменены после их завершения.), гарантируя, что блоки получат finality за секунды.

Протокол основан на той же технологии, что и Биткойн, в сочетании с такими функциями, как шардинг базы данных. Протокол NEAR создан с нуля и является наиболее доступной сетью для конечных пользователей и разработчиков, а также обеспечивает масштабируемость и безопасность.

Большинство масштабируемых блокчейнов использую централизованную обработку , зависящую от высокопроизводительного оборудования, что обеспечивает лишь временное повышение их пропускной способности, NEAR позволяет платформе линейно масштабироваться до миллиардов транзакций полностью децентрализованным образом.

NEAR разработан NEAR collective, сообществом разработчиков и исследователей, объединившихся для создания проекта. Некоторые важные особенности NEAR:

 	NEAR - это шардированyая система, обеспечивающая бесконечную масштабируемость.
 	NEAR - простой в использовании протокол, который позволяет разработчикам легко и быстро создавать приложения.
 	NEAR - это не  side chain(сторонняя цепочка блоков) боковая цепь, а протокол первого уровня.
 	dApps, созданные с помощью NEAR, запускаются поверх основного уровня NEAR.

Что такое  NEAR Collective?
NEAR Collective состоит из отдельных организаций и других участников, которые постоянно работают над улучшением протокола NEAR. Коллектив работает над такими проектами, как написание исходного кода и реализация NEAR Network. NEAR полностью децентрализован, работает независимо и не может быть отключен или изменен даже теми, кто его построил.

NEAR Collective включает в себя NEAR Foundation. NEAR Foundation - это некоммерческая организация, деятельность которой направлена ​​на создание динамичной экосистемы вокруг блокчейна NEAR. Это помогает в координации управленческой деятельности и развития. У NEAR Collective есть несколько проектов, и  блокчейн NEAR - лишь один из нескольких проектов под эгидой коллектива.

Зачем нужны такие блокчейны как NEAR?

Чтобы понять это, мы должны сначала понять эволюцию технологии блокчейн. Блокчейн можно разделить на три этапа или поколения. Блокчейны первого поколения были разработаны как простой платежный механизм. Биткойн является примером блокчейна первого поколения, который прочно признается в криптопространстве как платформа номер один. Однако у блокчейнов первого поколения есть ограничения, когда дело доходит до сложных транзакций.

Платформы блокчейнов второго поколения получили признание с Ethereum и концепцией смарт-контрактов, что позволило разработчикам использовать их и программировать более сложные транзакции и создавать децентрализованные приложения. Но блокчейны второго поколения страдают от серьезных проблем с масштабируемостью. Например, Ethereum может обрабатывать только около 25 транзакций в секунду, сравните это число с основными платформами, такими как Visa или PayPal, и вы увидите, насколько сильно отстает Ethereum.

Ethereum попытался исправить проблемы масштабируемости, реализовав решения второго уровня , такие как  plasma protocol, создав дополнительный уровень, работающий в тандеме с основной цепочкой. Однако решения второго уровня все еще не получили достаточного распространения.

Это подводит нас к NEAR, блокчейну третьего поколения. NEAR отвергает идею о том, что каждая нода в сети должна обрабатывать весь код, поскольку команда считает что это неэффективно и только приводит к задержкам. Вместо этого блокчейн устраняет проблемы масштабируемости, используя технику шардинга, что позволяет увеличивать пропускную способность сети. И в отличие от блокчейнов второго поколения, которые используют решение уровня 2, сегментирование является решением уровня 1 .
Что такое шардинг?
Прежде чем двигаться дальше, давайте разберемся с шардингом. Иногда системам приходится иметь дело с большим объемом данных. Это влияет на производительность системы, снижает пропускную способность и влияет на производительность системы. Шардинг преодолевает это, разделяя данные горизонтально, делая их меньше по размеру, более управляемыми и, что более важно, более быстрыми в обработке.
NEAR и Ethereum: как работают NEAR и Ethereum?
Ethereum 
Ethereum это  больше, чем просто финансовая платформа, выполняющая транзакции; он также поддерживает децентрализованные приложения и смарт-контракты. Ethereum основан на технологии блокчейн и использует публичный реестр, в котором хранятся все проверенные транзакции. Транзакции доступны для всех, кто хочет их просмотреть, обеспечивая полную прозрачность, гарантируя, что данные, хранящиеся в цепочке блоков, не могут быть изменены или обработаны.

Блокчейн Ethereum похож на блокчейн Bitcoin и действует как публичный реестр, в котором хранятся записи обо всех транзакциях и истории смарт-контрактов. Волонтеры по всему миру хранят копию всей цепочки блоков Ethereum, что делает цепочку блоков полностью децентрализованной. Каждый раз, когда в блокчейне происходит такое действие, как транзакция или исполнение смарт-контракта, все ноды по всему миру обрабатывают его, обеспечивая соблюдение правил блокчейна.

Все узлы подключены и следуют единому набору правил в отношении смарт-контрактов и транзакций. Узлы Ethereum также отслеживают состояние всех приложений, балансов пользователей и код смарт-контракта, гарантируя, что вся информация всегда актуальна.

Благодаря Solidity разработчики могут писать смарт-контракты, которые могут управлять транзакциями в цепочке блоков и их результатами. Смарт-контракты отличаются от традиционных контрактов, поскольку они обеспечивают выполнение условий контракта. Кроме того, они автоматически выполняют транзакции, когда выполняется набор заранее определенных условий, устраняя все третьи стороны, участвующие в любой транзакции.
NEAR
NEAR использует технологию блокчейнов, как и другие блокчейны, такие как Ethereum и Cardano. NEAR действует как базовый блокчейн, на котором можно создавать и развертывать приложения. Он использует механизм консенсуса, известный как Nightshade, который помогает достичь высокой пропускной способности. Механизм консенсуса NEAR предполагает, что транзакции со всех шардов объединяются в блок, поэтому каждый шард представляет сегмент каждого блока. Этот сегмент называется чанком.

Валидаторы выбираются случайным образом, а затем обрабатывают транзакции в нескольких шардовых цепочках, улучшая транзакционную емкость протокола NEAR. Чанки обрабатываются, а затем сохраняются в цепочке блоков, завершая транзакции.

Мы считаем, что каждый узел не должен обрабатывать весь код. Вместо этого NEAR решает проблемы масштабируемости с помощью шардинга. Благодаря сегментированию данные разделяются по горизонтали, что упрощает управление и ускоряет обработку.

NEAR и Ethereum: механизм консенсуса
Ethereum
В настоящее время Ethereum использует механизм консенсуса Proof-of-Work, но с появлением Ethereum 2.0 платформа перейдет на механизм консенсуса Proof-of-Stake. Proof-of-Stake будет реализован с помощью протокола Casper, создавая экосистему без доверия. Прежде чем полностью перейти на механизм Proof-of-Stake, Ethereum реализует гибридный механизм консенсуса PoW-PoS.

Давайте разберемся, как работают и Proof-of-Work, и Proof-of-Stake. Proof-of-Work требует, чтобы майнеры соревновались друг с другом, используя огромные вычислительные мощности для решения сложных математических задач для проверки транзакций. После подтверждения транзакции майнер получает вознаграждение. Ethereum переходит на механизм Proof-of-Stake, потому что Proof-of-Work имеет несколько проблем, например, таких как высокое потребление энергии. Переход также необходим для решения проблем масштабируемости Ethereum.

В механизме консенсуса Proof-of-Stake валидаторы стейкают свои ETH, после чего их случайным образом выбирают для подтверждения блока. Выбранный валидатор предлагает блок, в то время как другие валидаторы должны подтвердить, что они видели блок. После того, как они подтвердили блок, он добавляется в цепочку блоков, и валидаторы получают вознаграждение. Таким образом, валидаторы получают вознаграждение как за предложение, так и за подтверждение блока.
NEAR
Протокол NEAR реализовал Nightshade Sharding в качестве механизма консенсуса Proof-of-Stake. Мы уже обсуждали, что такое шардинг, поэтому можем пропустить это. Однако используемый метод шардинга который используется сейчас имеет свои проблемы,как например fork choice rule(правило выбора ответвления) в шарде и в Beacon Chain (кординатор новой сети, отвечающий за создание новых блоков, обеспечение их валидности и вознаграждение валидаторов ETH за обеспечение безопасности сети), необходимо создавать и тестировать по-разному.

Nightshade же рассматривает систему как единый блокчейн, и каждый блок содержит транзакции для всех шардов. Однако участникам не нужно загружать все данные, вместо этого обрабатываются только данные, которое является частью шарда, для которого они проверяют транзакции. Создается список всех транзакций в каждом блоке, который затем разбивается на чанки, причем каждому шарду назначается один шард.

Валидаторы - ключевая часть протокола NEAR, поддерживающая консенсус по протоколу. Следовательно, им необходимо постоянно обновлять свои системы, при этом сохраняя свои серверы в сети.

 	Валидаторы выбираются каждую эпоху в зависимости от их стейка.
 	Валидаторов можно снова зарегистрировать, повторно разместив свои токены и награды.
 	Валидаторы могут увеличить количество застейканых токенов двумя способами: купить токен или занять их через стейк-делегирование.

 NEAR и Ethereum: токены
Собственный токен Ethereum, Ether, стимулирует программистов продолжать работу по протоколу блокчейна, поскольку оборудование, на котором работает Ethereum, дорогое и потребляет значительное количество энергии. Таким образом, майнеры и программисты получают вознаграждение в эфире за использование своих ресурсов и поддерживая экосистему Ethereum безопасной и функциональной.

Разработчики также используют Ether для оплаты возможности запускать смарт-контракты или децентрализованные приложения на блокчейне Ethereum. Он также используется для доступа к смарт-контрактам.

Собственный токен NEAR, NEAR token, используется для стимулирования валидаторов в сети. Токен также управляет транзакциями и смарт-контрактами в блокчейне. Поскольку NEAR это  платформа, управляемая сообществом, держатели токенов играют значительную роль в управлении платформой NEAR, голосуя за возможные изменения на платформе NEAR.

Проекты на Ethereum и NEAR Protocol

Ethereum является лидером в области децентрализованных приложений и децентрализованных финансов: на его блокчейне работает более 3000 децентрализованных приложений. Большинство проектов Ethereum сосредоточены на DeFi, расширяя использование криптовалют для более сложных финансовых задач.

Некоторые из лучших проектов на блокчейне Ethereum:

 	Uniswap
 	MakerDAO
 	Chainlink
 	 Aave

Несмотря на то, что основная сеть NEAR была запущена чуть больше года назад, несколько платформ уже строятся на ней. Некоторые из проектов на протоколе NEAR

 	Mintbase - платформа, предназначенная для упрощения выпуска и продажи NFT, а также для удешевления всего процесса.
 	Flux -  это децентрализованный протокол открытого рынка. Он был запущен на протоколе NEAR в 2020 году.
 	Paras - это торговая площадка NFT, специализирующаяся на работах, созданных художниками.

Программа грантов NEAR, в настоящее время управляемая Фондом NEAR, поддерживает проекты, которые способствуют развитию экосистемы NEAR.

Aurora в протоколе NEAR

Aurora также запущена на протоколе NEAR, предоставляя Ethereum Layer 2 решение, которое позволяет разработчикам выходить на дополнительные рынки. Aurora использует преимущества протокола NEAR, такие как вознаграждение за газ и шардинг. Он работает на двух важнейших компонентах: Aurora Bridge и Aurora Engine.

Некоторые из улучшений, которые приносит Aurora:

 	Возможность обрабатывать тысячи транзакций в секунду, что в 50 раз больше, чем у Ethereum.
 	Время завершения блока( block finality time) составляет 2 секунды, по сравнению с временем подтверждения одиночного блока, равным 13 секундам на Ethereum. Быстрая finality также снижает вероятность атак в будущем.
 	Перспективный рост экосистемы, подход шардинга протокола NEAR обеспечивает горизонтальное масштабирование EVM(Ethereum Virtual Machine) и асинхронную связь между несколькими шардами.
 	Комиссии на Aurora в 1000 раз ниже, чем на Ethereum. Например, передача токена ERC-20 на Aurora стоит менее 0,01$, а на Ethereum - около 5,40$.
 	Aurora предлагает бескомпромиссную совместимость с Ethereum по протоколу NEAR.

Aurora предлагает решение проблем, с которыми сталкивается экосистема Ethereum, с сохранением как смарт-контрактов, так и  front-end кода.
Преимущества протокола NEAR
Шардированное решение NEAR дает ему огромное преимущество перед такими платформами, как Ethereum и Bitcoin, решая проблему низкой масштабируемости и частым задержкам в сети Ethereum. Сделав свой протокол шардированным, основатели NEAR разбивают код блокчейна на чанки, выполняемые на параллельных нодах. Это приводит к быстрой обработке всего кода и освобождению NEAR от проблем с масштабируемостью благодаря возможности фрагментировать код.

Протокол NEAR имеет несколько уникальных функций, которые делают его привлекательным для пользователей и валидаторов.

 	Удобство и гибкость интерфейса для пользователя, доступ к сервисам, работающим на платформе NEAR, обеспечивают простой процесс адаптации.
 	Благодаря сегментированному протоколу NEAR валидаторы могут присоединяться к платформе без загрузки сложного программного обеспечения. Затем они могут зарабатывать токены, проверяя транзакции в сети.
 	NEAR позволяет бизнесу настраивать разрешения для своих пользователей. С устойчивым ростом рынка разработчики также получают доступ к растущей клиентской базе.

 Путь впереди для протокола NEAR
С запуском моста Ethereum-to-NEAR, также называемого радужным мостом(Rainbow Bridge), пользователи могут связать свои токены Ethereum ERC-20 с NEAR и начать использовать их в экосистеме децентрализованных приложений NEAR. Эта разработка является огромным шагом, для того чтобы  сделать платформу максимально доступной.

NEAR также работает над реализацией поддержки виртуальной машины Ethereum (EVM). После завершения этого процесса разработчики могут повторно развернуть свои dApps на NEAR с минимальными изменениями и сделать возможным запуск cross-chain(Кросс-цепочка - передает значения и информацию между различными сетями цепочки блоков.).

Протокол NEAR объявил о партнерстве с Chainlink, а также о запуске Rainbow Bridge , который позволяет взаимодействовать NEAR и Ethereum.
Заключение
Протокол NEAR показал многообещающие возможности, поскольку он использует шардинг для решения проблем масштабируемости блокчейнов второго поколения. Кроме того, NEAR значительно увеличивает пропускную способность без ущерба для безопасности платформы.

Благодаря NEAR collective сотни инженеров и разработчиков блокчейнов работают над улучшением протокола 24/7. NEAR также запустил свою основную сеть, и сеть готова поддерживать dApps и другие сервисы. Сфокусировавшись на том, чтобы платформа NEAR была простой в использовании для валидаторов, конечных пользователей и разработчиков, NEAR стала заметной силой в пространстве платформы смарт-контрактов.

Ethereum, с другой стороны, сохранил свои позиции на троне благодаря огромному сообществу разработчиков и процветающим экосистемам DeFi и NFT. Оба эти протокола предоставляют разработчикам прекрасную платформу для построения децентрализованной экосистемы будущего.

### Hướng dẫn nhanh về tài khoản NEAR

Giới thiệu về tài khoản NEAR

 	
NEAR cung cấp ID tài khoản theo định dạng dễ hiểu cho người dùng. ID tài khoản NEAR có định dạng tên.near. Ví dụ: maria.near, jane.near hay icebear.near.

 	
Hệ thống tài khoản NEAR tương tự như hệ thống phân giải tên miền website. Cụ thể là với một tài khoản chính, chúng ta có thể tạo ra nhiều tài khoản phụ (sub accounts) tùy thích, cũng giống như việc dựa trên một tên miền website ta có thể tạo ra nhiều tên miền phụ (subdomain). Ví dụ, với một tài khoản NEAR mang tên icebear.near, ta có thể tạo ra một tài khoản phụ mới là sub.icebear.near, lần lượt như thế ta có thể tiếp tục tạo  thêm nhiều tài khoản phụ khác như first.sub.icebear.near, second.sub.icebear.near, …

 	
Tạo tài khoản NEAR bằng cách truy cập vào các website sau: Ví NEAR (https://wallet.near.org/), (ví giao thức NEAR), NEAR Faucet (https://faucet.paras.id/) (một faucet dành cho người dùng Ethereum и Metamask), hay near-cli (https://github.com/near/near-cli) (một giao diện dòng lệnh cung cấp các tính năng cho việc tích hợp NEAR).

 	
Bạn có thể tặng cho bạn bè hoặc những người hâm mộ của mình tài khoản NEAR bằng cách sử dụng dịch vụ của https://nearnames.com.

 	
Bạn có thể kiểm tra thông tin về tài khoản NEAR của mình trên NEAR Explorer (https://explorer.near.org/) hoặc trên ứng dụng ví NEAR (NEAR Wallet).

 	
Bên cạnh việc cung cấp các tài khoản dạng name.near thì hệ sinh thái NEAR còn hỗ trợ chúng ta tạo ra tài khoản dạng invisible (định dạng này giống như địa chỉ Bitcoin hay Ethereum) bằng cách sử dụng near-cli. Bạn có thể thêm thông tin chi tiết về tài khoản này tại đây.

 	
Mỗi tài khoản NEAR trong hệ thống sẽ có một và chỉ một smart-contract. Đối với các ứng dụng yêu cầu người dùng sử dụng nhiều smart-contract, chúng ta có thể sử dụng các tài khoản con (child account) như contract_1.icebear.near, contract_2.icebear.near, …

 	
Hệ sinh thái NEAR còn cung cấp các tài khoản dành cho nhà phát triển (https://docs.near.org/docs/concepts/account#dev-accounts). Điểm đặc biệt ở các  tài khoản này là chúng có thể giúp nhà phát triển thử nghiệm và sửa lỗi cho các smart-contract.


Các khóa (Keys) của một tài khoản NEAR

 	
Giống như nhiều blockchain khác, NEAR cũng được xây dựng dựa trên mật mã học với một mã mở (open key). Mỗi cặp khóa bao gồm một khóa công khai (public key) và một khóa bí mật (private key).

 	
NEAR sử dụng public key để nhận danh người dùng và private key để ký kết các giao dịch (xác nhận quyền sở hữu tài khoản NEAR trong suốt quá trình tạo giao dịch).

 	
NEAR có 3 kiểu khóa: Khóa truy cập (Access key) dùng để ký kết các giao dịch, khóa xác thực (Validator key) thực hiện các thao tác liên quan tới việc xác nhận mạng lưới, khóa nút (Node key) cho phép các giao tiếp đơn giản giữa các node.

 	
Các khóa có thể được lưu trữ ở 3 kho khác nhau. InMemoryKeyStore - lưu trữ trong bộ nhớ, được sử dụng cho các tình huống tạm thời. BrowserLocalStorageKeyStore - lưu trữ cục bộ của trình duyệt, không được mã hóa, được sử dụng để làm việc với các ứng dụng trên trình duyệt. UnencryptedFileSystemKeyStore - lưu trữ  trên hệ thống tệp tin, không được mã hóa, được sử dụng khi làm việc với near-cli.

 	
Mỗi tài khoản NEAR có thể có nhiều Access Key, hoặc không có cái nào.

 	
Các khóa này có các mức độ truy cập khác nhau: FullAccess (toàn quyền truy cập) hoặc FunctionCall (chỉ có thể gọi tới các phương thức trong contract).

 	
Với mỗi tài khoản thì các khóa là duy nhất. Tuy nhiên, khóa công khai (public key) có thể được gán cho các tài khoản khác nhau với các mức độ truy cập khác nhau. Mức độ truy cập sẽ quyết định những hoạt động mà tài khoản đó được thực hiện.

 	
Đối với cấp độ truy cập FullAccess (toàn quyền truy cập) thì tài khoản có thể thực hiện toàn bộ 8 hành động sau: CreateAccountAction (tạo một tài khoản mới), DeployContractAction (triển khai một smart contract), FunctionCallAction (gọi các phương thức của một hợp đồng), TransferAction (gửi token tới tài khoản khác), StakeAction (thực hiện staking token), AddKeyAction (thêm key vào tài khoản), DeleteKeyAction (xóa key khỏi tài khoản), DeleteAccountAction (xóa tài khoản).

 	
Đối với mức độ truy cập FunctionCall, tài khoản chỉ có thể thực hiện hành động FucntionCallAction (gọi tới phương thức trong hợp đồng). Đồng thời, với một key, bạn cũng có thể chỉ định những phương thức nào trong hợp đồng mà tài khoản có thể gọi tới.

### Giao thức NEAR là gì?

Kết quả nhận được: Hiểu được cơ bản cách mà NEAR hoạt động từ góc nhìn của người dùng.

NEAR là một nền tảng ứng dụng phi tập trung (decentralized application – dApps) chạy trên công nghệ chuỗi khối (blockchain) thông qua giao thức NEAR. Blockchain này hoạt động trên hàng trăm máy tính khắp thế giới, được tổ chức mà không cần cấp phép, hoạt động hiệu quả, đủ an toàn để tạo ra một lớp dữ liệu mạnh mẽ và phi tập trung cho một thế hệ web mới.

Tầm nhìn của NEAR là một nền tảng lý tưởng để chạy ứng dụng mà có thể truy cập vào hệ thống chia sẻ, bảo mật của tiền, định danh và dữ liệu sở hữu bởi người dùng. Kết hợp sức mạnh của hiệu ứng network, điện toán phi máy chủ (serverless compute) và lưu trữ phân tán (distributed storage) thành một nền tảng mới.

Vì vậy, trước khi tìm hiểu kĩ hơn, hãy cùng tìm hiểu về một vài cột mốc lịch sử và xem các nền tảng công nghệ blockchain đã phát triển như thế nào trong những năm qua.
Sự phát triển của công nghệ blockchain
Bắt đầu từ khi Satoshi Nakamoto phát hành whitepaper Bitcoin vào tháng 10 năm 2008, thế giới đã bắt đầu làm quen với sức ảnh hưởng của công nghệ blockchain. Trong vòng 1 thập kỷ qua, blockchain đã trải qua ba giai đoạn phát triển.

Thế hệ 1: Tiền ảo (Bitcoin)

Bitcoin là một ví dụ hoàn hảo về thế hệ đầu của blockchain. Mục đích của blockchain là trở thành một hệ thống thanh toán trực tuyến đơn giản. Bắt đầu như là “tiền kỹ thuật số” (internet’s currency), Bitcoin đã trở thành nằm trong nhóm tài sản được săn đón nhất. Tuy nhiên, đã có một vấn đề nghiêm trọng phát sinh với BTC. Nó không thể kiểm soát được những giao dịch phức tạp mà có nhiều lớp dữ liệu và logic được đính kèm cùng.

Thế hệ 2: Ethereum và nền tảng Smart contract.

Ethereum mở ra nền tảng công nghệ blockchain thế hệ thứ hai với Smart contract  (hợp đồng thông minh). Cuối cùng thì các nhà phát triển đã có thể lập trình các giao dịch phức tạp thông qua những hợp đồng thông minh này, và có thể tạo ra các ứng dụng phi tập trung (decentralized application – dApps). Thông qua dApps, ứng dụng của blockchain ngày càng tăng cao.

Tuy nhiên, công nghệ này ngày càng gặp phải nhiều khó khăn khi tăng trưởng. Vấn đề lớn nhất mà các blockchain này đang gặp phải là về khả năng mở rộng (scalability). Ví dụ, Bitcoin có thông lượng là 7 giao dịch/ giây, trong khi đó Ethereum chỉ có thông lượng là 25 giao dịch. So sánh với Paypal (115 giao dịch/ giây) và Visa (1 700 giao dịch/ giây) thì Ethereum kém hơn khá nhiều.

Công bằng mà nói, Ethereum và Bitcoin đã cố gắng sửa chữa những vấn đề về khả năng mở rộng với các giải pháp layer-2 như lightning network, raiden, plasma, … Ý tưởng ở đây là tạo ra một lớp nữa trên blockchain giúp cho giao thức chính có thể ủy thác các công việc lặp lại phức tạp.

Tuy nhiên, có hai vấn đề phát sinh với sự điều chỉnh này. Thứ nhất, các giải pháp layer-2 này vẫn chưa nhận được sự chấp thuận từ công chúng. Thứ hai, giải pháp này phá vỡ cấu trúc nguyên gốc của giao thức, gây ra nhiều ảnh hưởng lâu dài.

Đây chính là lúc thế hệ thứ 3 xuất hiện

Thế hệ 3: NEAR

NEAR là một ví dụ về blockchain thế hệ 3, với mục đích giải quyết vấn đề về khả năng mở rộng và cho phép cả người dùng, nhà phát triển sử dụng toàn bộ tính năng của smart contracts và công nghệ blockchain. Thay vì phải dựa vào công nghệ layer-2, NEAR phá bỏ ý tưởng rằng mỗi node tham gia vào hệ thống mạng phải chạy tất cả các mã dẫn tới tắc nghẽn và làm chậm tất cả giải pháp khác.

Để giải quyết này, NEAR sử dụng một công nghệ rất phổ biến trong cơ sở dữ liệu – sharding. Nếu được thực hiện đúng cách, nó sẽ cho phép dung lượng mạng được mở rộng đồng thời số lượng node tăng lên, vì thế, theo lý thuết sẽ không có bất cứ một giới hạn về dung lượng mạng. Điều thú vị nhất là gì? Sharding là một công nghệ mở rộng layer-1.
Sharding là gì?
Trong một cơ sở dữ liệu, đôi khi bạn phải xử lý nhiều dữ liệu phức tạp. Việc này cản trở đáng kể hiệu suất và thông lượng, nó còn làm cho toàn bộ quá trình trở nên kém hiệu quả. Đây là lúc Sharding xuất hiện.

Sharding thực hiện phân vùng ngang trong cơ sở dữ liệu (horizontal partition) của bạn và phân chúng thành các bảng nhỏ hơn để dễ quản lý.

 

Vậy tại sao lại là một phân vùng ngang mà không phải là phân vùng dọc?



Hãy xem bảng dưới này:



A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



 

 

 

 

 

Bây giờ nếu chúng ta phân vùng theo chiều dọc:



A
B


1
1


2
2


3
3


4
4



 

 

 

 



A*B
A/B


1
1


4
1


9
1


16
1



 

Bạn thấy chưa?

Vì phần vùng dọc,bảng biến thành hai bảng hoàn toàn khác nhau.

Ngược lại, điều gì sẽ xảy ra nếu bảng được phân vùng theo nhiều ngang:

Bạn có thấy không? Khi bạn phân vùng bảng theo chiều dọc thì chúng sẽ có khuynh hướng trở thành hai bảng khác nhau hoàn toàn.

Tuy nhiên, nếu chúng ta phân vùng chúng theo chiều ngang:



A
B
A*B
A/B


3
3
9
1


4
4
16
1



Thấy chưa?

Phân vùng ngang biến cơ sở dữ liệu thành các bảng nhỏ hơn với cùng một dữ liệu. Những bảng dữ liệu nhỏ này được gọi là các shards.
Sharding giúp Blockchain như thế nào?
Như chúng ta có thể thấy, ngày càng nhiều node tham gia vào hệ sinh thái của Ethereum và Bitcoin khiến cho toàn bộ quá trình đồng thuận và xác minh ngày càng tốn nhiều thời gian. Vậy thì Sharding đã làm gì để thay đổi điều này?

Sharding phân chia blockchain toàn cầu thành các shards nhỏ hơn để dễ quản lý.

Điều gì sẽ xảy ra với việc kích hoạt các phân đoạn nhỏ này?

 	Trạng thái hệ thống được chia thành các shard
 	Mỗi tài khoản ở một shard, và các tài khoản chỉ có thể giao dịch với tài khoản khác cùng shard.

Nói một cách dễ hiểu, hãy tưởng tượng trường hợp này. Một mạng lưới giả định với 3 node- A, B và C và chúng phải xác minh dữ liệu T. Dữ liệu T bị chia ra thành 3 shard T1, T2 và T3. Thay vì tất cả các node đều làm việc trên T, chúng có thể hoạt động riêng lẻ trên một shard cùng lúc. Như bạn có thể thấy, lượng thời gian bạn tiết kiệm được sẽ tăng theo cấp số nhân.

Không giống như giải pháp sharding khác, yêu cầu các node phải chạy trên các phần cứng ngày càng phức tạp (giảm thiểu khả năng tham gia vào mạng lưới của nhiều người), NEAR cho phép các node cần điều kiện tối thiểu để có thể chạy trên cloud.
Tại sao giải pháp mở rộng như NEAR lại cần thiết?
Gợi ý: Nó không chỉ về tốc độ!

Khi đề cập đến blockchain thế hệ hai và ba, điều thật sự có thể xác định được giá trị nội tại của nó là sự phát triển mạnh mẽ của hệ sinh thái ứng dụng phi tập trung. Chính vì vậy, hầu hết các nền tảng blockchain này luôn trong một cuộc chiến thu hút được càng nhiều nhà phát triển càng tốt.

Tuy nhiên, vấn đề của nền tảng hiện tại là chúng không đủ độ tinh xảo để làm chủ được các ứng dụng chất lượng cao. Vấn đề ở đây là chúng ta có các nhà phát triển luôn cố gắng tạo ra các trò chơi PS4 trên nền tảng tương tự như Windows 98. Cũng vì thế, họ cần thỏa hiệp về toàn bộ chức năng của dApps.

Thêm vào đó, một yếu tố khác cũng cần được chú ý đến. Tốc độ là một tác nhân quan trọng khi đề cập đến khả năng sử dụng ứng dụng. Rốt cuộc tại sao người dùng lại sử dụng một ứng dụng nếu nó hoàn toàn không thể sử dụng được? Các nhà phát triển cần một lượng người dùng sử dụng ứng dụng của họ trước khi nó đạt đến một mức đáng kể.

Đây là lý do tại sao mà một nền tảng blockchain có thể mở rộng như NEAR lại quan trọng đối với việc chấp nhận sử dụng blockchain và smart contract.

NEAR cho phép các nhà phát triển triển khai ứng dụng của họ mà không cần suy nghĩ quá nhiều về cơ sở hạ tầng của nó được vận hành như thế nào hoặc quy mô ra sao, điều này tương tự như các nền tảng cloud hiện đại của Amazon AWS, GCP hay Azure đang vận hành hầu hết các ứng dụng web ngày nay.
Tóm tắt về lịch sử của NEAR
NEAR ra mắt vào mùa hè năm 2018 khi mà Alex Skidanov và Illia Polosukhin quyết định dừng cuộc hành trình kinh doanh của mình trước đó, nếu bạn cảm thấy tò mò thì bạn có thể tìm hiểu thêm về họ ở đây. Không lâu sau đó, Misha đã rời khỏi MemSQL, nhóm đã mở rộng từ vài người thành 9 người chỉ trong vòng 3 ngày vào tháng 8. Nhóm ban đầu bao gồm 7 kỹ sư, Erik phụ trách các hoạt động kinh doanh, trong khi đó Sasha lo việc tìm hiểu thị trường.

Ngày nay, NEAR Collective là một tổ chức khắp toàn cầu, được tạo nên bởi các tổ chức cá nhân cùng với các người đóng góp, họ là những người tự tạo dụng nên nền tảng công nghệ này đến với cuộc sống. Nó không hẳn là tổ chức kinh doanh hay bất cứ thứ gì tương tự. Thay vào đó, hãy nghĩ rằng nó chỉ đơn giản là những nhóm người đang điều hành các dự án về phần mềm mã nguồn mở lớn (open-source software).

Một trong những dự án Collective là viết mã nguồn và thiết lập cài đặt tham khảo (reference implementation) cho mạng lưới mã nguồn NEAR, giống như việc gắn động cơ đẩy vào tàu con thoi. Công việc mà họ cần làm là R&D để giúp cho blockchain đi vào đúng quỹ đạo của nó. Mã cho chuỗi này là mã mở (open source), hay nói cách khác là bất cứ ai cũng có thể sửa chữa hoặc chạy nó.

Điều quan trọng cần phải nhấn mạnh là các mạng lưới như NEAR được thiết kế ra để mang tính phi tập trung hoàn toàn. Nghĩa là chúng hoạt động theo ý của mạng lưới và không bị bên thứ ba kiểm duyệt, đóng cửa hay gây rối, … kể cả các team đầu tiên đã xây dựng nên chúng! Vì thế, ngay cả khi các thành viên của tập thể này bắt đầu thiết lập các cài đặt tham khảo, chúng sẽ nhanh chóng trở nên vô dụng với sự vận hành mạng lưới một khi nó bắt đầu chạy. Trong thực thế, sau khi đã sẵn sàng khởi động, bất cứ ai cũng có thể sửa đổi và chạy mã giao thức NEAR để khởi tạo blockchain của riêng họ bởi vì nó là mã nguồn mở và bất cứ thay đổi nào đều được chấp nhận bởi validator, người mà vận hành nó.
Cách NEAR blockchain hoạt động.
Công nghệ chính là nền tảng cho tiền điện tử. Blockchain là một công nghệ có thể lưu trữ hồ sơ về các giao dịch an toàn trên mạng ngang hàng thay vì lưu trữ chúng tập trung tại một nơi. Các máy chủ độc lập trên toàn thế giới, được gọi là node, tạo ra mạng lưới để vận hành blockchain.



Một trong những khía cạnh xác thực của công nghệ blockchain là sự phi tập trung hóa. Vậy thì tại sao sự phi tập trung hóa lại hữu ích đến như vậy? Hãy cùng tìm hiểu chúng qua góc nhìn của các nhà phát triển và người người dùng nhé.

Nhà phát triển: Trong thế giới kết nối hiện nay, các nhà phát triển thường bị lệ thuộc vào nền tảng đám mây hoặc thậm chí là chính phủ để chắc chắn rằng họ có thể tiếp tục chạy các ứng dụng. Nhưng trong thế giới phi tập trung thì không qua bất cứ trung gian nào.

Người dùng: Tính minh bạch của các ứng dụng phi tập trung cho phép người dùng có thể thấy được mã backend và biết được chính xác ứng dụng đang sử dụng thông tin cá nhân của bạn như thế nào.

Thuật toán đồng thuận (consensus algorithm) NEAR là gì?

Giao thức đồng thuận được sử dụng để đạt được thỏa thuận về một giá trị độc nhất giữa những người tham gia trong hệ thống. Nếu tất cả người tham gia mạng lưới đều đồng thuận với kết quả từ giao thức đồng thuận, các giá trị mới có thể được thêm vào sổ cái và xác minh bởi các node. Tuy nhiên, trong trường hợp có tranh chấp, mạng lưới sẽ tập trung vào tính an toàn hoặc khả tồn tại.

Cơ chế đồng thuận được thực hiện trên NEAR được gọi là Nightshade. Nightshade mô phỏng hệ thống giống như một blockchain duy nhất. Danh sách các giao dịch trong một block được chia thành các phần, mỗi một phần ứng với một chunk. Tất cả các phần được lưu trữ trong một khối. Lưu ý rằng tất cả chunk chỉ có thể xác thực bởi các node mà duy trì trạng thái của shard đó.

Về vấn đề xác nhận giao dịch, một thành phần chủ chốt của NEAR là validator (người xác nhận giao dịch). Những validator chịu trách nghiệm duy trì sự đồng thuận trong giao thức. Validator là các node chuyên dụng cần thiết để giữ cho các máy chủ luôn ở trạng thái trực tuyến 100% trong khi hệ thống luôn cập nhật liên tục.

Dưới đây là một số ý chính mà bạn phải ghi nhớ về validator.

 	NEAR thiết lập validator mỗi epoch mới, bầu chọn theo phương thức staking.
 	Validator có thể đăng kí lại bằng cách tự động đặt cược lại token của họ cộng thêm tiền thưởng.
 	Những validator tiềm năng phải có cổ phần linh động trên một mức nhất định.
 	Có hai phương pháp mà một người xác nhận giao dịch có thể sử dụng để tăng token của họ - mua tokens hoặc vay thông qua ủy nhiệm cổ phần.
 	Tiền thưởng mà bạn nhận được tỷ lệ thuận với tiền cược của bạn. Càng nhiều tiền cược, bạn càng nhận được nhiều lợi nhuận.

Sự đồng thuận dựa trên chuỗi đồng thuận được có trọng số lớn nhất. Nghĩa là khi một block mới được tạo ra, họ gắn thêm chữ ký từ các validator nodes. Trọng số của block là số chữ ký được tạo thành từ block. Trọng số của một chuỗi bằng tổng giá trị của các khối. Ngoài ra, sự đồng thuận còn sử dụng một số hình phạt như điều kiện bổ sung để mức độ bảo mật chuỗi cao hơn.

Môi trường chạy NEAR

Lớp runtime được sử dụng để thực hiện các hợp đồng thông minh và các hoạt động khác được tạo ra bởi người dùng và duy trì trạng thái giữa các lần thực hiện. Nó còn có thể được mô tả từ 3 góc độ khác nhau: đi từng bước qua các scenarios khác nhau, mô tả các thành phần của hệ thống, và mô tả các chức năng runtime có thể thực hiện.
NEAR token là gì?
NEAR token là tài sản gốc của hệ sinh thái NEAR và chức năng của nó được sử dụng cho mọi tài khoản. Mỗi token là một tài sản kỹ thuật số độc quyền giống như Ether, được sử dụng để:

Thanh toán cho tác vụ xử lý giao dịch và lưu trữ dữ liệu.

Chạy một node xác thực như là một phần của mạng lưới bằng cách tham gia quá trình staking.

Giúp xác định tài nguyên mạng được phân bổ như thế nào và định hướng kỹ thuật trong tương lai bằng cách tham gia các quy trình quản trị.

NEAR token cho phép sự phối hợp về mặt kinh tế của tất cả người tham gia, điều hành mạng lưới, đồng thời cho phép tính năng mới dựa trên các ứng dụng được xây dựng trên nền tảng.
Làm thế nào để sử dụng NEAR?
Tài khoản/ Ví
Trước khi bắt đầu dùng NEAR, điều đầu tiên bạn cần làm là tạo một tài khoản NEAR.

Xem video này để hiểu rõ về tài khoản NEAR:

Ví tiền cho phép bạn thực hiện tương tác với các hợp đồng trên blockchain, thiết lập node của bạn, gửi và nhận tiền từ những người dùng khác. Khi bạn đăng ký ID cho tài khoản, bạn sẽ phải cung cấp một cái tên duy nhất. Mặc dù mỗi ví tiền sở hữu độc quyền một cái tên, một người dùng vẫn có thể thiết lập nhiều ví.

Bạn có thể hình dung rằng tài khoản này cũng tương tự như tài khoản Facebook hay Google. Khi bạn đã đăng kí vào một trong số các dịch vụ đó, bạn có thể sử dụng cùng một tài khoản để đăng nhập vào dịch vụ của bên thứ ba. Sự khác biệt giữa khải khoản IDs NEAR và Google chính là dữ liệu, chúng được lưu trữ dựa trên tài khoản ID, vì vậy mà chỉ có chủ sở hữu của ví mới có thể đăng nhập và quản lý được. Ngoài ra, tất cả các thông tin đều được lưu trữ trên mạng được phân tán bởi các node thay vì một máy chủ duy nhất.

Tạo một tài khoản NEAR tại đây: https://wallet.near.org/create

Các thông tin sâu hơn về tài khoản NEAR tại DOCS.NEAR

NEAR Explorer

NEAR Explorer cho phép bạn xem cách tạo lập block trong thời gian thực! Công cụ hữu ích này giúp bạn tìm kiếm các giao dịch và tài khoản mà cho phép bạn xem tất cả các hoạt động tương tác giữa người dùng với các hợp đồng thông minh.

 
Làm sao để có NEAR tokens?
Có 4 cách để sở hữu $NEAR
NEAR miễn phí cho người dùng Ethereum
Bắt đầu bằng việc thiết lập ví với một ít NEAR miễn phí cho người dùng Ethereum:
https://faucet.paras.id
Nhận nó
Bạn có thể nhận $NEAR bằng cách tham gia vào chương trình tiền thưởng cho việc phát triển, hay bằng cách tổ chức một cộng đồng giúp mọi người xây dựng trên NEAR, bằng việc giành chiến thắng trong cuộc thi hackathon hoặc những hoạt động khác để trở thành một thành phần nổi trội trong cộng đồng đó. Nếu bạn có thể thu hút nhiều người cho bạn vay token để đặt cược, bạn có thể kiếm $NEAR bằng cách hoạt động như một validator.
Mua
$NEAR có sẵn trên một số sàn giao dịch lớn (xem thêm bên dưới), nơi mà bạn có thể đăng nhập và mua token bằng tiền định danh (fiat currency) hay tiền điện tử.

Các sàn giao dịch được liệt kê trên $NEAR

Bạn có thể xem tổng quan về giá cả và các cặp trên coinmarketcap và coingecko.

https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR
Từ bạn bè
Bạn không nhất định phải có một tài khoản Near mới nhận được NEAR token! Giải pháp “NEAR Drop” cho phép bạn của bạn nạp tiền trước vào một tài khoản mới và gửi cho bạn một đường liên kết để lấy tokens.
Bạn có thể làm được gì với NEAR token?
Chuyển đổi NEAR
Gửi $NEAR qua lại giữa các tài khoản của bạn và một người bạn, kiểm tra các giao dịch trên Block Explorer. Bởi vì phí giao dịch khá thấp mà bạn có thể dễ dàng và nhanh chóng di chuyển một lượng nhỏ $NEAR để thử nghiệm.

Bạn có thể gửi chúng như một món quà thông qua http://redpacket.near.org/
Thử NEAR Drop (Mời bạn bè)
Gửi NEAR drop cho bạn bè khi họ muốn lập tài khoản mới.
Sử dụng các ứng dụng trên NEAR
Để xem danh sách các ứng dụng đang được xây dựng và phát triển trên NEAR, nhấn vào đây

Bạn có thể dễ dàng bắt đầu với việc mua/đăng tải/giao dịch tác phẩm nghệ thuật NFT trên https://paras.id

Truy cập BerryClub để tham gia collective art creation: https://berryclub.io/
Chi phí để sử dụng NEAR (Gas)?
Khi tương tác với NEAR blockchain để cập nhật hoặc thay đổi dữ liệu, những người điều hành cơ sở hạ tầng của blockchain sẽ phải chi một khoản tiền. Đến cuối cùng, một vài chiếc máy tính sẽ xử lý yêu cầu của bạn, và validator chạy những chiếc máy tính này sẽ chi một khoản vốn đáng kể để chúng tiếp tục hoạt động.

Như các blockchain có thể được lập trình khác, NEAR sẽ trả cho những người này bằng cách trả phí giao dịch, hay còn gọi là phí Gas

Nếu bạn đã quen với các nhà cung cấp dịch vụ đám mây web2 (Amazon Web Service, Google Cloud, …), một sự khác biệt lớn ở blockchain đó là người dùng phải trả phí ngay lập tức khi họ tương tác đến một ứng dụng nào đó thay vì những nhà phát triển sẽ trả phí trước cho việc sử dụng các cơ sở hạ tầng. Việc này tạo ra những tiềm năng mới, chẳng hạn như các ứng dụng không còn nguy cơ đóng cửa dài hạn vì cạn kiệt quỹ của các nhà phát triển/ công ty. Tuy nhiên, nó cũng kèm theo một vài vấn đề liên quan tới tính khả dụng (usability). Để xử lý, NEAR cũng đồng thời cung cấp cho các nhà phát triển khả năng chi trả phí Gas cho người dùng, với mong muốn tạo ra một trải nghiệm quen thuộc hơn cho những người đến từ web2.

Khi nghĩ đến Gas, hãy giữ 2 quan niệm này trong đầu:

 	Gas Units: trong nội bộ, chi phí cho các cuộc giao dịch không được tính trực tiếp trong NEAR token, nhưng thay vào đó sẽ đi qua một giai đoạn trung gian gọi là “gas units”. Lợi ích của gas units là chúng có tính xác định – Cùng một giao dịch sẽ luôn tốn cùng một lượng gas units.
 	Giá gas: gas units nhân với giá gas nhất định để xác định xem phí của người dùng là bao nhiêu. Giá tiền này sẽ tự động tính toán lại ở mỗi block dựa trên nhu cầu của mạng lưới (nếu block trước cao hơn một nửa, giá sẽ tăng, ngược lại nếu nó giảm, giá gas sẽ không thay đổi nhiều hơn 1% mỗi block), và giá sàn được thiết lập trước bởi mạng lưới, hiện tại là 100 triệu yoctoNEAR. Lưu ý rằng giá gas có thể khác giữa mainnest và testnet. Hãy kiểm tra giá gas dựa vào những con số dưới đây.

Về gas

NEAR có xấp xỉ một giây một block được thực hiện bằng cách giới hạn lượng gas mỗi block. Gas units phải được tính toán cẩn thận để đưa ra một con số dễ nhớ:

10¹² gas units, hoặc 1 TGas (TeraGas)…

≈ 1 phần nghìn giây thời gian tính toán

...nghĩa là mức phí gas thấp nhất là 100 nghìn yoctoNEAR, bằng với khoản phí là 0,1 milliNEAR

1ms này là ước lượng gần đúng, và là mục tiêu hiện tại về cách gas unit được thiết lập trong NEAR. Gas units không chỉ rút gọn được thời gian tính toán/CPU mà còn bao gồm cả bandwidth/network time và storage/IO time. Thông qua cơ chế quản lý, các thông số hệ thống có thể tùy chỉnh, thay đổi việc lập bảng giữa TGas và mili giây trong tương lai, nhưng những điều ở trên vẫn là một khởi đầu khá tốt để hiểu về ý nghĩa của gas units.
Chi phí cho các hoạt động thông thường.
Để bạn có thể hình dung về chi phí ở NEAR, bảng sau sẽ liệt kê một số thao tác phổ biến và cần bao nhiêu TGas để thực hiện, phí sẽ là bao nhiêu tính theo đơn vị milliNEAR, tại mức giá gá tối thiểu là 100,000,000 yN



Tác vụ
TGas
fee (mN)
fee (Ⓝ)


Tạo tài khoản
0.42
0.042
4.2⨉10⁻⁵


Chuyển tiền
0.45
0.045
4.5⨉10⁻⁵


Stake
0.50
0.050
5.0⨉10⁻⁵


Thêm khóa truy cập
0.42
0.042
4.2⨉10⁻⁵


Xóa khóa truy cập
0.41
0.041
4.1⨉10⁻⁵



 
Tôi có thể nhận được NEAR như thế nào?
Stake NEAR của bạn
Mấu chốt cho mô hình Bằng chứng cổ phần (Proof-of-stake, PoS) là Validator được cộng đồng hỗ trợ thông qua việc stacking (khoá các đồng tiền mã hoá để nhận các phần thưởng hay nói cách khác là đặt cọc coin). Validator kiếm được NEAR token như phần thưởng cho việc vận hành các node chạy trong mạng lưới dưới dạng lạm phát tĩnh với 5% mỗi năm, tạo ra những tokens mới trong mỗi chu kì (12 giờ) như thành quả dành cho các Validator.

Các Validator buộc phải duy trì số dư Stake tối thiểu để giữ chiếc ghế Validator của họ. Người giữ Token có quyền đặt cược với một Validator cụ thế mà họ tin sẽ hoạt động tốt cho mạng lưới và cũng sẽ kiếm được một phần trong phần thưởng Token tạo ra bởi mạng lưới. Điều này khuyến khích những người nắm giữa Token ở lại để tham gia với cộng đồng!

Ví NEAR giờ đã có giao diện staking được xây dựng trực tiếp trong bản ứng dụng web

Để Stake:

 	Chọn “Staking” trong thanh điều hướng (hoặc menu xổ xuống trên bản mobile)
 	Nhấn “Select Validator”
 	Chọn một validator
 	Xác nhận lựa chọn của bạn và tiếp tục ở: “Stake with Validator”
 	Nhập lượng NEAR bạn muốn đặt vào và nhấn “Submit Stake”

Bạn sẽ cần phải xác nhận 2 giao dịch: một là để chọn validator, còn lại để đặt cọc và staking bằng validator.

Để huỷ stake:

 	Trong bảng quảng trị  staking (/staking), chọn validator hiện tại của bạn
 	Nhấn “Unstake” và xác nhận giao dịch

Sau từ 36 đến 48 giờ (3 chu kỳ trọn vẹn), bạn sẽ có thể rút tiền cọc của bạn. Để làm vậy, quay trở về trang validator và nhấn “Withdraw”
Tiếp theo? Vậy làm sao để có thể tương tác với NEAR?
Được rồi, vậy thì tiếp theo sẽ là gì? Nếu bạn đã đọc đến đây, bạn có thể muốn tìm hiểu sâu thêm về giao thức NEAR. Vì vậy, điều tiếp theo bạn nên làm đó chính là kiểm tra NEAR whitepaper. Nếu bạn chưa quen với blockchain và muốn học thêm về công nghệ này, bạn có thể xem video về giải thích cấu trúc của hệ sinh thái blockchain này.
Hãy tham gia Discord của NEAR và xem diễn đàn NEAR nhé.

🏆 Nếu bạn muốn có thêm cơ hội nhận được những món quà hấp dẫn, hãy cung cấp cho chúng tôi những phản hồi hữu ích? Vào đơn phản hồi này.

### NEAR Rainbow Bridge hoạt động như thế nào?

Article by Matt Henderson of Aurora 

NEAR Rainbow Bridge là công nghệ độc nhất trong thế giới tiền mã hóa, nó là cầu nối không phân quyền (permissionless)  và không cần sự tin cậy (trustless), duy nhất tới Ethereum. Trong bài viết này, chúng ta sẽ tìm hiểu cách thức hoạt động của NEAR Rainbow Bridge.

Giao thức NEAR đã tạo ra Rainbow Bridge, một ứng dụng vừa độc nhất và vừa giá trị trong không gian tiền mã hóa, nó là một cầu nối hoàn toàn “không tin cậy” để chuyển các token giữa Ethereum và NEAR - và cuối cùng là Aurora. Bạn có thể tìm thấy những mô tả kỹ thuật về Rainbow Bridge ở đâu đó, tuy nhiên bài viết này có mục đích giúp những người chỉ với kiến thức cơ bản về tiền mã hóa cũng có thể hiểu được cách thức hoạt động của Rainbow Bridge.
Khái niệm
Hãy bắt đầu bằng việc tưởng tượng tôi muốn chuyển 20 DAI từ Ethereum sang NEAR. Do việc chuyển giao các token một cách vật lý giữa các mạng lưới là không thể, có nghĩa là chúng ta cần đưa 20 DAI ra khỏi lưu thông trên mạng lưới Ethereum và mang 20 DAI vào lưu thông trên NEAR nhằm giữ nguồn cung DAI toàn cầu không thay đổi.

Và đây là cách để tôi làm được việc này mà không cần sự cho phép cũng như không cần sự tin tưởng:

 	Tôi thông báo tới mạng lưới Ethereum rằng tôi muốn chuyển 20 DAI tới một nơi khác.
 	Mạng Ethereum khóa 20 DAI của tôi vào trong một kho tiền (một hợp đồng thông minh), để chúng có thể được đưa ra ngoài lưu thông của Ethereum.
 	Khi tôi chắc chắn rằng 20 DAI đó đã được khóa lại trên Ethereum, tôi sẽ yêu cầu mạng NEAR tạo ra 20 DAI cho tôi trên NEAR.
 	Tất nhiên, NEAR không tin tưởng tôi và nó yêu cầu tôi chứng minh rằng tôi đã khóa 20 DAI ở trên Ethereum.
 	Tôi cung cấp cho NEAR bằng chứng rằng tôi đã khóa 20 DAI trên Ethereum.
 	NEAR xác minh bằng chứng của tôi một cách độc lập và sau đó tạo ra 20 DAI để tôi sử dụng trên NEAR.

Sau đó, nếu tôi muốn chuyển DAI từ NEAR về lại Ethereum thì tôi chỉ đơn giản đảo ngược lại quy trình bên trên. Khá gọn gàng phải không nào?
Những thành phần chính
Bây giờ chúng ta cùng xem xét tất cả những điều trên trong thực tế sẽ diễn ra như thế nào bằng cách sử dụng Rainbow Bridge.

Câu chuyện sẽ liên quan đến một số thành phần kỹ thuật tạo nên cầu nối này:

Rainbow Bridge UI (Giao diện Rainbow Bridge) - đây là một trang web, nơi mà bạn - người sử dụng, tương tác với cây cầu để chuyển những tài sản giữa các mạng lưới.

LiteNode - giống như một nút trên chuỗi khối, ngoại trừ việc nó chỉ lưu trữ các header của các khối, nhằm giảm đáng kể không gian lưu trữ cần thiết. LiteNode được triển khai dưới dạng hợp đồng thông minh và chúng ta có 2 LiteNode - một lưu trữ header khối NEAR được triển khai trên mạng Ethereum, và một lưu trữ header khối Ethereum và được triển khai trên mạng NEAR.

(Ở trong các bài viết khác, LiteNode ở đây thực ra được gọi là “light client” vì những lý do lịch sử. Nếu bạn hỏi tôi, “Cái gì lưu trữ dữ liệu blockchain?”, điều đầu tiên tôi nghĩ đến là một “node” (nút mạng) và trong bài viết này tôi sẽ gọi nó là LiteNode.)

Relayers (Bộ chuyển tiếp) - Vì LiteNode là những hợp đồng thông minh nên chúng không thể tự chạy và cập nhật. Relayers là các tập lệnh chạy trên các máy chủ truyền thống, định kỳ đọc các khối từ một blockchain và giúp chúng giao tiếp với LiteNode đang chạy trên blockchain kia. Vì vậy có thể hiểu Relayer giúp cập nhật LiteNode.

Vì có phí giao dịch - tức phí gas - nên mỗi lần Relayer cập nhật một LiteNode thì LiteNode trên NEAR (chứa các khối Ethereum) được cập nhật trên mỗi khối Ethereum (vì phí gas trên NEAR rất rẻ), trong khi tần suất cập nhật trên Ethereum (chứa các khối NEAR) có thể cấu hình và được xác định bởi một ngân sách kinh tế (hiện tại là khoảng 12 giờ đến 16 giờ).

Connectors (Trình kết nối) - là những hợp đồng thông minh chịu trách nhiệm về tất cả logic liên quan đến việc quản lý chuỗi chéo của một loại tài sản nhất định. Giống như LiteNode, các Connector tồn tại theo cặp - một chạy trên Ethereum và một chạy trên NEAR. Ví dụ có một cặp “ETH Connectors” chịu trách nhiệm chuyển ETH giữa hai mạng và có một cặp “ERC-20 Connectors” chịu trách nhiệm chuyển các ERC-20 token. Ai đó có thể viết một “NFT” Connector, một “Prediction Market Outcome” Connector, hoặc một “DAO Vote Results” Connector nếu họ muốn. Bất kỳ tài sản hoặc dữ liệu nào cũng có thể được chuyển qua Rainbow Bridge, miễn là các Connector có liên quan tới tài sản hoặc dữ liệu đó tồn tại.
Kết nối các mảnh ghép lại với nhau
Nhằm hiểu cách tất cả các yếu tố trên hoạt động cùng nhau để tôi chuyển các token giữa Ethereum và NEAR mà không cần sự cho phép (permissionless) và sự tin cậy (trustless), hãy cùng xem lại ví dụ ban đầu của chúng ta:

 	Tôi bắt đầu việc chuyển 20 DAI từ Ethereum sang NEAR bằng cách sử dụng Rainbow Bridge UI
 	Khi tôi xác nhận giao dịch đầu tiên trong hai giao dịch trên MetaMask, Rainbow Bridge sẽ giao tiếp với ERC-20 Connector trên Ethereum (do DAI là một ERC-20 token), chuyển và khóa 20 DAI trong kho tiền của nó. Những DAI này sau đó không còn được lưu hành trên mạng Ethereum nữa.
 	Dựa trên dữ liệu header trong khối giao dịch của tôi, Rainbow Bridge UI sẽ tạo ra một bằng chứng mật mã rằng tôi đã thực sự khóa 20 DAI.
 	Tiếp theo chúng ta sẽ yêu cầu mạng NEAR tạo một số DAI dựa trên những gì vừa xảy ra trên Ethereum, trước tiên chúng ta chờ Relayer gửi khoảng 20 header khối Ethereum tới LiteNode đang chạy trên NEAR. Việc làm này nhằm mục đích bảo mật, giống như cách mà sàn giao dịch tiền mã hóa khiến bạn đợi một số lần xác nhận trước khi sử dụng số tiền đã ký gửi của mình.
 	Sau thời gian chờ đợi, Rainbow Bridge UI sẽ cho phép chúng ta thực hiện bước hai trong quy trình - yêu cầu ERC-20 Connector trên NEAR tạo 20 DAI mới cho chúng ta trên mạng NEAR.
 	Khi thực hiện yêu cầu này của ERC-20 Connector, chúng ta cung cấp bằng chứng mật mã mà chúng ta đã nhận được trước đó, chứng minh rằng chúng ta đã khóa 20 DAI trên Ethereum.
 	Sau đó, ERC-20 Connector trên NEAR sẽ tra cứu header khối Ethereum của chúng ta trong LiteNode đang chạy trên NEAR và thực hiện tính toán một cách độc lập bằng chứng mật mã.
 	Nếu bằng chứng mà chúng ta cung cấp khớp với bằng chứng mà ERC-20 Connector tính toán thì nó biết rằng 20 DAI đã được khóa an toàn ở trên Ethereum - và chính tôi là người đã khóa! - và tiếp tục tạo (đúc) 20 DAI mới trên NEAR và chuyển chúng đến ví của tôi.

Khi chúng ta muốn chuyển DAI từ NEAR về lại Ethereum, quá trình sẽ diễn ra ngược lại, tức là thay vì khóa 20 DAI trong NEAR, chúng ta phá hủy chúng (hay còn gọi là đốt cháy), và sau đó chúng ta cung cấp bằng chứng về việc đốt cháy đó cho Connector chạy trên Ethereum. Connector chạy trên Ethereum này có quyền truy cập vào các khối NEAR trong LiteNode chạy trên Ethereum, nó xác thực bằng chứng của chúng ta và giải phóng 20 DAI từ kho tiền của nó và gửi chúng đến ví của chúng ta!

Tóm lại, đó là cách Rainbow Bridge hoạt động. Đây là chiếc cầu nối Ethereum duy nhất hoạt động theo cách này - hiện tại nó cho phép bạn chuyển tài sản giữa Ethereum và NEAR (và sắp tới là Aurora) mà không cần sự cấp phép cũng như không cần đặt bất kỳ sự tin tưởng nào vào bên thứ ba. Quá tuyệt vời!
Những mảnh ghép khác
Sau đây là một số điểm đáng chú ý khác ngoài những gì được trình bày ở trên:

 	Do NEAR-to-Ethereum Connector chỉ gửi header khối NEAR đến Ethereum LiteNode sau mỗi 16 giờ, nên sẽ có độ trễ 16 giờ giữa bước một và bước hai khi di chuyển token theo hướng từ NEAR tới Ethereum. (Điều này là do phí gas trên Ethereum khiến cho việc Relayer cập nhật mỗi khối trên LiteNode trở nên đắt đỏ). Có một số phương pháp giúp chúng ta giảm thiểu sự chậm trễ này và nhóm phát triển đang tích cực làm việc để đưa chúng vào thực tế.
 	Trên NEAR, LiteNode lưu trữ tất cả các header khối Ethereum trong quá khứ. Để dung lượng lưu trữ không bị cạn kiệt, LiteNode “cắt tỉa” (xóa) những khối được tạo ra khoảng trên hai tuần trước đó. Điều này có nghĩa là nếu bạn chuyển từ Ethereum sang NEAR và đi chơi trong ba tuần giữa bước một và bước hai, bạn sẽ không thể hoàn tất quá trình chuyển token của mình, vì dữ liệu Ethereum được lưu trữ trên NEAR rất cần thiết cho việc xác minh bằng chứng của bạn thì đã bị xóa mất!
 	Một thuộc tính thú vị của thiết kế header khối NEAR là với một header khối đơn, chúng ta có thể tính toán lịch sử của các khối trước đây trong một khoảng thời gian khá dài. Vì vậy, về lý thuyết, LiteNode trên Ethereum chỉ cần một khối NEAR duy nhất; tuy nhiên, chúng ta vẫn giữ chúng vì chi phí gas cần thiết để thực hiện việc cắt tỉa về cơ bản sẽ là một sự lãng phí.
 	Nhóm tạo ra Rainbow Bridge cũng chính là nhóm đã tạo ra Aurora - NEAR EVM. Do nhóm tạo ra Rainbow Bridge đã tách ra thành một nhóm riêng, nhóm sẽ quản lý, vận hành, bảo trì và phát triển Rainbow Bridge trong tương lai.
 	Nhóm Aurora đang làm việc trên tính năng “tự động hoàn thiện” (auto-finalization) cho Rainbow Bridge, bạn sẽ không còn phải thực hiện thủ công bước số hai trong những lần chuyển token nữa. Điều này sẽ rất thuận tiện cho người dùng (có nghĩa là bạn có thể bắt đầu việc chuyển từ Ethereum sang NEAR rồi thực hiện chuyến đi nghỉ của bạn!)
 	Việc chuyển tài sản giữa Ethereum và Aurora được thực hiện bởi Aurora Bridge, sử dụng công nghệ lõi tương tự như Rainbow Bridge, nhưng được ẩn đi bước chuyển NEAR / Aurora trong quá trình chuyển.
 	Giao diện người dùng (UI) và trải nghiệm người dùng (UX) của Aurora Bridge hiện hơi khác so với Rainbow Bridge, nhưng trong tương lai gần điều này sẽ được cải thiện để đem lại trải nghiệm tốt hơn cho người dùng.

Mặc dù một số chi tiết kỹ thuật đã được đơn giản hóa, bây giờ bạn đã nắm được những hiểu biết cơ bản về cách Rainbow Bridge hoạt động.

Bạn có thể đọc bản bài viết này nếu muốn tìm hiểu sâu hơn về Rainbow Bridge và hãy cập nhật mọi thứ liên quan tới Aurora.

Hãy nhớ theo dõi Aurora trên Twitter!

 

### Что такое протокол NEAR?

NEAR — это децентрализованная платформа приложений, которая работает на блокчейне протокола NEAR. Этот блокчейн, который работает на сотнях машин по всему миру, организован так, чтобы быть производительным и достаточно безопасным, чтобы создать надежный и децентрализованный уровень данных для новой сети.
Основная миссия NEAR — предоставить платформу, которая идеально подходит для запуска приложений, имеющих доступ к общему пулу денег, и безопасности личных данных пользователей. Он объединяет в себе функции устойчивой к разделению сети, бессерверных вычислений и распределенного хранилища в платформу нового типа.
Итак, прежде чем мы пойдем дальше, давайте узнаем предысторию и посмотрим, как блокчейн-платформы развивались с течением времени.
Эволюция технологии блокчейн
С тех пор, как Сатоши Накамото выпустил технический документ о биткойнах в октябре 2008 года, мир познакомился с технологией блокчейн, изменивший правила игры. За последнее десятилетие блокчейн прошел три стадии эволюции.
Поколение 1: Bitcoin
Биткойн — прекрасный пример блокчейна первого поколения. Цель этого блокчейна — быть простой и понятной платежной системой. Начинаясь как «Интернет валюта», Биткойн с тех пор стал одним из самых востребованных классов активов. Однако, когда дело доходит до BTC, возникает серьезная проблема. С ними невозможно проводить сложные транзакции, которые могут иметь несколько уровней метаданных и логики.
Поколение 2 : Ethereum и платформы смарт-контрактов
Ethereum положил начало блокчейн-платформам второго поколения со смарт-контрактами. Наконец, разработчики смогли запрограммировать сложные транзакции с помощью этих смарт-контрактов и создать децентрализованные приложения (dApps). Благодаря этим децентрализованным приложениям сценарии использования блокчейна резко возросли.
Однако оказалось что эти блокчейны страдают от серьезных проблем с масштабируемостью. Например, биткойн имеет пропускную способность 7 транзакций в секунду, в то время как Ethereum может обрабатывать только 25. Если сравнить это с PayPal (115 транзакций в секунду) и Visa (1700 транзакций в секунду), это никуда не годится.
Честно говоря, Ethereum и Bitcoin недавно пытались исправить эти проблемы с масштабируемостью с помощью нескольких решений второго уровня, таких как Lightning Network, Raiden, plasma protocol и т.д. Идея здесь состоит в том, чтобы создать дополнительный уровень над базовым блокчейном, которому может делегировать повторяющиеся и громоздкие задачи.
Однако у этого подхода есть две проблемы. Во-первых, эти решения второго уровня еще не получили широкого признания. Во-вторых, эти решения уровня 2 разрушают исходную архитектуру протокола, что может иметь последствия в дальнейшем .
Вот тут-то и появляется третье поколение.
Поколение 3: NEAR
NEAR — это пример блокчейнов третьего поколения, которые направлены на решение проблем масштабируемости и позволяют как конечным пользователям, так и разработчикам в полной мере использовать потенциал смарт-контрактов и технологии блокчейнов. Вместо того, чтобы полагаться на технологию второго уровня, NEAR отказывается от идеи, что каждый отдельный узел, который участвует в сети, должен запускать весь код, потому что это, по сути, создает узкое место и замедляет все остальное.
Чтобы решить эту проблему, NEAR использует метод, который уже широко распространен в мире баз данных, — шардинг. При правильном выполнении он позволяет наращивать пропускную способность сети по мере увеличения количества узлов в сети, поэтому теоретического ограничения пропускной способности сети нет. Что в этом самое лучшее? Шардинг — это метод масштабируемости уровня 1.

Что такое шардинг?
В базе данных иногда приходится иметь дело с большими объемными данными. Это резко снижает производительность и пропускную способность, а также делает весь процесс крайне неэффективным. Вот тут-то и появляется шардинг.
Шардинг разделяет вашу базу данных по горизонтали и превращает ее в более мелкие и более управляемые таблицы.

Итак, почему горизонтальное разделение , а не вертикальное? Рассмотрим эту таблицу:




A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Теперь, если бы мы разбили эту таблицу по вертикали:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



Видите, что происходит? Из-за разбиения таблица превращается в две разные таблицы А вот, что происходит, когда таблица разбивается по горизонтали:




A
B
A*B
A/B


3
3
9
1


4
4
16
1



А происходит то, что горизонтальное разделение превращает базу данных в меньшие таблицы той же базы данных. Эти небольшие базы данных называются шардами.
Как Шардинг(сегментирование) помогает блокчейну?
Как мы уже видели, по мере того, как все больше и больше нод входят в экосистему Ethereum и Bitcoin, весь процесс консенсуса и проверки занимает еще больше времени. Итак, что сделает шардинг, чтобы помочь с этим?
Шардинг разбивает глобальное состояние блокчейна на более мелкие, более управляемые сегменты.
Что происходит при активации шарда?


 	Данные делятся на сегменты .
 	Каждая уникальная учетная запись находится в одном сегменте, и учетные записи в этом сегменте будут взаимодействовать только с другими учетными записями в том же сегменте.

Упрощенно представьте себе этот сценарий. Существует гипотетическая сеть с тремя узлами — A, B и C, и они должны проверять данные T. Данные T разбиты на три сегмента: T1, T2 и T3. Вместо того, чтобы все эти узлы работали над T как единое целое, они могут индивидуально работать с шардом в одно и то же время. Как видите, время, которое вы экономите, экспоненциально.
В отличие от множества других подходов к сегментированию, которые по-прежнему требуют, чтобы узлы работали на все более сложном оборудовании (что снижает возможность участия большего числа людей в сети), метод NEAR позволяет узлам оставаться достаточно маленькими для работы на простых экземплярах, размещенных в облаке.
Зачем нужны масштабируемые блокчейны, такие как NEAR?
Когда дело доходит до блокчейнов второго и третьего поколения, то, что действительно определяет их внутреннюю ценность, — это экосистема децентрализованных приложений, которая процветает на их основе. Таким образом, большинство этих блокчейн-платформ находятся в постоянном соревновании за привлечение как можно большего числа разработчиков.
Однако проблема текущих платформ заключается в том, что они не обладают достаточной сложностью, необходимой для размещения высококачественных приложений. Проблема здесь в том, что у нас есть разработчики, пытающиеся создавать игры для PS4 на платформе, эквивалентной Windows 98. Таким образом, им необходимо серьезно пойти на компромисс в отношении общей функциональности своих децентрализованных приложений.
Кроме того, здесь следует учитывать еще один фактор. Скорость — жизненно важный фактор, когда речь идет об удобстве использования приложения. В конце концов, зачем пользователям использовать приложение, если оно вообще непригодно для использования? Разработчикам требуется определенное количество пользователей для непрерывного использования их приложений, прежде чем оно достигнет критической массы.
Вот почему масштабируемая платформа блокчейна, такая как NEAR, важна для массового внедрения блокчейна и смарт-контрактов.
NEAR позволяет разработчикам просто развертывать свое приложение, не задумываясь о том, как работает или масштабируется окружающая его инфраструктура, что больше похоже на современные облака, такие как Amazon AWS, GCP или Azure, которые управляют почти всеми сегодняшними веб-приложениями.
NEAR Краткая история
NEAR стартовал летом 2018, в августе команда насчитывала 9 человек. Первоначальная команда состояла из 7 инженеров, Эрика, ведущего бизнес, и Саши, занимающегося рынком.
Сегодня NEAR Collective — это глобально распределенная группа команд, состоящая из множества отдельных организаций и участников, которые самоорганизуются, чтобы воплотить эту технологию в жизнь. Это не бизнес или что-то такое формальное. Вместо этого думайте об этом как о группах людей, которые запускают большие проекты программного обеспечения с открытым исходным кодом.
Один из проектов Collective — это написание исходного кода и эталонной реализации для сети NEAR с открытым исходным кодом, что-то вроде создания ракетных ускорителей на космическом шаттле. Их работа — проводить необходимые исследования и разработки, чтобы помочь блокчейну выйти на орбиту. Код для этой цепи является открытым исходным кодом , так буквально каждый может внести свой вклад или запустить его.
Важно подчеркнуть, что такие сети, как NEAR, спроектированы так, чтобы быть полностью децентрализованными. Это означает, что они в конечном итоге работают полностью самостоятельно и не могут подвергаться цензуре, отключению или иным вмешательствам третьих лиц… даже командам, которые изначально их создавали! Таким образом, хотя члены этого коллектива находятся здесь, чтобы начать работу над созданием эталонной реализации, они быстро становятся несущественными для работы сети, как только она заработала. Фактически, как только он будет готов к запуску, любой может изменить и запустить код протокола NEAR для запуска своей собственной цепочки блоков, потому что все это открытый исходный кодом, и любые изменения должны быть демократически приняты независимыми валидаторами, которые его запускают.

Как работает NEAR Blockchain
Блокчейн — это технология, которая может безопасно хранить записи транзакций в одноранговой сети вместо того, чтобы хранить их в одном месте. Независимые серверы по всему миру, называемые узлами, составляют сеть, которая управляет цепочкой блоков

Одним из наиболее определяющих аспектов технологии блокчейн является децентрализация. Итак, чем полезна децентрализация? Давайте посмотрим на это с точки зрения разработчиков и конечных пользователей.


 	Разработчики: в централизованном мире разработчики часто зависят от облачных платформ или даже правительства, чтобы убедиться, что они могут продолжать запускать приложения. В децентрализованном мире нет доминирующих посредников.
 	Конечные пользователи: прозрачность децентрализованных приложений может позволить пользователям видеть внутренний код и точно знать, как приложения собираются использовать вашу личную информацию.

Что такое алгоритм консенсуса NEAR?
Протоколы консенсуса используются для достижения соглашения об одном значении между несколькими участниками системы. Если все участники сети сотрудничают в соответствии с протоколом консенсуса, новые значения могут быть добавлены в реестр и проверены узлами. Однако в случае возникновения споров сеть может сосредоточиться либо на безопасности, либо на живучести.
Механизм консенсуса, реализованный в NEAR, называется Nightshade. Nightshade моделирует систему как единый блокчейн. Список всех транзакций в каждом блоке разделен на физические блоки, по одному блоку на шард. Все фрагменты накапливаются в один блок. Обратите внимание, что блоки могут быть проверены только узлами, которые поддерживают состояние этого шарда.
Говоря о валидации, ключевым компонентом NEAR являются валидаторы. Эти валидаторы несут ответственность за поддержание консенсуса в протоколе. Валидаторы — это специализированные узлы, которым необходимо поддерживать свои серверы в сети 100% времени, постоянно обновляя свои системы.
Вот несколько моментов, которые вы должны помнить о сетевых валидаторах.


 	NEAR определяет свои сетевые валидаторы каждую новую эпоху, выбирая их на основе их доли.
 	Уже избранные валидаторы повторно регистрируются путем автоматического повторного размещения своих токенов и начисленных вознаграждений.
 	Потенциальные валидаторы должны иметь свою ставку выше динамически определяемого уровня.
 	Есть два метода, которые валидатор может использовать для усиления своей доли — купить токены самостоятельно или занять их через делегирование доли.
 	Вознаграждение, которое вы получаете, прямо пропорционально вашей ставке. Чем больше ваша ставка, тем больше ваше вознаграждение.

Консенсус основан на консенсусе самой тяжелой цепочки. Это означает, что как только производитель блоков публикует блок, они собирают подписи узлов валидатора. Вес блока — это совокупная ставка всех подписывающих сторон, чьи подписи включены в блок. Вес цепочки — это сумма весов блоков. Кроме того, консенсус использует finality gadget, который вводит дополнительные условия сокращения для более высокой безопасности цепи.
NEAR Время выполнения
Уровень выполнения используется для выполнения смарт-контрактов и других действий, созданных пользователями, и сохранения состояния между выполнениями. Его можно описать с трех разных сторон: пошаговое рассмотрение различных сценариев, описание компонентов среды выполнения и описание функций, которые выполняет среда выполнения.
Что такое токен NEAR?
Токен NEAR является основным собственным активом экосистемы NEAR, и его функции доступны для всех учетных записей. Каждый токен представляет собой уникальный цифровой актив, аналогичный эфиру, который можно использовать для:


 	Оплаты системе за обработку транзакций и хранение данных.
 	Запуск ноды как часть сети, участвуя в стейкинге.
 	Помощь в определении, как распределяются сетевые ресурсы и куда пойдет его будущее техническое направление, участвуя в процессах управления.

Токен NEAR обеспечивает экономическую координацию всех участников, управляющих сетью, а также позволяет создавать новые модели поведения приложений, построенных поверх этой сети.

Как начать с NEAR?
Аккаунт / Кошелек
Прежде чем вы начнете работать с NEAR, первое, что вам нужно сделать, это создать учетную запись NEAR.
Кошелек позволяет выполнять вызовы по контракту в блокчейн, настраивать локальный узел, а также отправлять и получать средства от других пользователей. Когда вы регистрируете свой и Аккаунт IDучетной записи, вы должны указать уникальное имя. Хотя каждый кошелек должен иметь уникальное имя, каждый пользователь может настроить несколько кошельков.
Вы можете представить это как учетную запись Facebook или Google. После регистрации в любой из служб вы можете использовать ту же учетную запись для входа в сторонние службы. Разница между идентификаторами учетной записи NEAR и учетными записями Google заключается в том, что данные, хранящиеся в соответствии с идентификатором учетной записи, доступны и управляются только владельцем кошелька. Кроме того, вся информация хранится в распределенной сети узлов, а не на одном сервере.
Создайте аккаунт NEAR прямо сейчас: https://wallet.near.org/create
Более подробная информация об учетных записях на DOCS.NEAR(ENG)
NEAR Explorer
NEAR Explorer позволяет просматривать создание блоков в реальном времени! Этот полезный инструмент позволяет искать транзакции и учетные записи, позволяя просматривать все взаимодействия между пользователями и смарт-контрактами.


Как получить NEAR токены?
Есть 4 способа получить $ NEAR
БЕСПЛАТНЫЕ NEAR для пользователей Ethereum
Начните с настройки кошелька с небольшим количеством бесплатного NEAR через кран для пользователей Ethereum: https://faucet.paras.id
Заработать
Вы можете заработать NEAR, участвуя в грантах на разработку , управляя сообществом, которое помогает людям строить NEAR, выигрывая хакатон NEAR или иным образом принимая активное участие в сообществе. Так же если вы можете привлечь других людей, чтобы они одолжили вам токены для стекинга, и еще можно заработать $NEAR, став валидатором.
Купить
$ NEAR доступен на нескольких основных биржах (например на https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR ), где вы можете зарегистрироваться и купить токен, используя либо фиатную валюту, либо криптовалюту.
Биржи, на которых котируется $ NEAR
Вы можете увидеть обзоры цен и доступные пары на coinmarketcap и coingecko .
Получить от друга
Для получения токенов NEAR необязательно иметь Аккаунт NEAR! « NEAR Drop » позволяет вашему другу предварительно внести средства на новую учетную запись и отправить вам ссылку для получения токенов.

Что я могу делать с токенами NEAR?
Переводить NEAR
Отправляйте $ NEAR туда и обратно между своими счетами и друзьями и проверяйте транзакции в проводнике блоков . Поскольку комиссия за транзакцию очень низкая, вы можете быстро и легко переводить даже маленькое количество $NEAR для тренировки.
Отправляйте как подарок на http://redpacket.near.org/
Попробуйте NEAR Drop (пригласите друга)
Отправьте своему другу NEAR drop(ENG) если ему нужно создать учетную запись.
Используйте приложения NEAR
Чтобы просмотреть растущий список приложений, создаваемых на NEAR, нажмите здесь .
Начните знакомиться с NFT — покупка / публикация / обмен произведений искусства на https://paras.id/
Играйте в BerryClub, чтобы участвовать в коллективном творчестве: https://berryclub.io/

Сколько стоит использование NEAR (Газ)?
Когда вы звоните в блокчейн NEAR для обновления или изменения данных, люди, управляющие инфраструктурой блокчейна, несут определенные затраты. В конце концов, некоторые компьютеры где-то обрабатывают ваш запрос, и валидаторы, работающие на этих компьютерах, тратят значительные средства на поддержание работы этих компьютеров.
Как и другие программируемые блокчейны, NEAR компенсирует этим людям комиссию за транзакцию, также называемую комиссией за газ.
Если вы знакомы с поставщиками облачных сервисов web2 (Amazon Web Services, Google Cloud и т. Д.), Большая разница с блокчейнами заключается в том, что с пользователей сразу же взимается плата, когда они вызывают приложение, а не разработчики, покрывают стоимость использования всей этой инфраструктуры. Это создает новые возможности, такие как приложения, которые не рискуют исчезнуть из -за того, что у разработчика / компании закончились средства. Тем не менее, это также связано с некоторыми ограничениями скорости. Чтобы помочь в этом, NEAR также предоставляет разработчикам возможность покрывать расходы на газ для пользователей, чтобы создать более знакомый опыт для тех, кто приходит из web2.
Думая о газе, помните о двух концепциях:
1. Единицы газа: внутри комиссионные за транзакции не рассчитываются непосредственно в токенах NEAR, а проходят промежуточную фазу «gas units». Преимущество gas units состоит в том, что они детерминированы — одна и та же транзакция всегда будет стоить одинаковое количество единиц газа.
2. Цена на газ: затем gas units умножаются на цену газа, чтобы определить, сколько взимать с пользователей. Эта цена автоматически пересчитывается для каждого блока в зависимости от спроса в сети (если предыдущий блок заполнен более чем наполовину, цена повышается, в противном случае она снижается и не меняется более чем на 1% каждый блок) и нижняя цена, сконфигурированная сетью, в настоящее время составляет 100 миллионов yoctoNEAR.
Обратите внимание, что цена на газ может отличаться в основной и тестовой сети NEAR. Прежде чем полагаться на приведенные ниже цифры, проверьте цену на газ.
Размышляя о газе
NEAR имеет время блока примерно в одну секунду, что достигается ограничением количества газа на блок. Gas units были тщательно рассчитаны, чтобы получить некоторые простые для понимания цифры:
1⁰¹² газа, или 1 ТГаз (ТераГаз)…
≈ 1 миллисекунда «вычислительного» времени
… Что при минимальной цене на газ в 100 миллионов yoctoNEAR составляет плату в размере 0,1 milliNEAR.
Gas units инкапсулируют не только время вычислений / CPU, но также пропускную способность / время сети и время хранения / ввода-вывода. С помощью механизма управления можно настраивать параметры системы, сдвигая соответствие между TGas и миллисекундами в будущем, но вышеизложенное по-прежнему является хорошей отправной точкой для размышлений о том, что означают единицы газа и откуда они берутся.
Стоимость затрат газа
Чтобы дать вам отправную точку для того, каких затрат ожидать от NEAR, в таблице ниже перечислены некоторые распространенные действия и количество TGas, которое им в настоящее время требуется, а также размер комиссии в milliNEAR при минимальной цене на газ в 100 миллионов yN.




Operation
TGas
fee (mN)
fee (Ⓝ)


Create Account
0.42
0.042
4.2⨉10⁻⁵


Send Funds
0.45
0.045
4.5⨉10⁻⁵


Stake
0.50
0.050
5.0⨉10⁻⁵


Add Full Access Key
0.42
0.042
4.2⨉10⁻⁵


Delete Key
0.41
0.041
4.1⨉10⁻⁵



Как я могу зарабатывать с NEAR?
Добавьте ваши NEAR в стейкинг
Ключом к модели Proof-of-Stake является то, как валидаторы поддерживаются сообществом через Стейкинг. Валидаторы получают вознаграждение в виде токенов NEAR за работу узлов, управляющих сетью, в виде статического уровня инфляции 5% каждый год, создавая новые токены для валидаторов каждую эпоху (~ 12 часов) в качестве вознаграждения.
Валидаторы должны поддерживать минимальный размер стейкинга , чтобы сохранить свое место в Валидаторах. Держатели токенов могут делать стейк с конкретным Валидатором, который, по их мнению, хорошо работает для сети, и зарабатывать часть вознаграждений за токены, генерируемых сетью. Это стимулирует держателей токенов оставаться в сообществе!
У кошелька NEAR есть пользовательский интерфейс для стейкинга , встроенный непосредственно в веб-приложение.
Как сделать стейкинг:
1. Выберите «Staking» на панели навигации (или в раскрывающемся списке на мобильном устройстве).
2. Нажмите кнопку «Select Validator».
3. Выберите валидатора.
4. Подтвердите свой выбор и выберите «Stake with Validator».
5. Введите сумму NEAR, которую вы хотите застейкать, и нажмите «Submit Stake».
Вам нужно будет подтвердить две транзакции: одну для выбора валидатора, а другую для внесения депозита и ставки с помощью валидатора.
Как вернуть токены из стейкинга:
1. На панели управления стейкингом (/ staking) выберите текущего валидатора.
2. Нажмите «Unstake» и подтвердите транзакцию.
Через 36–48 часов (3 полных периода) вы сможете снять свою ставку. Для этого вернитесь на страницу валидатора и нажмите «Withdraw».
Присоединяйтесть к нашей группе в Телеграм!

### How the NEAR Rainbow Bridge works

Article by Matt Henderson of Aurora 

The NEAR Rainbow Bridge is unique in crypto as the only permissionless, trustless bridge to Ethereum. In this article, we’re going to demystify how it works!

The NEAR Protocol created the Rainbow Bridge—something that's both unique and valuable in the crypto space, a fully "trustless" bridge for transferring tokens between Ethereum and NEAR—and ultimately, Aurora. While there are technical descriptions of the bridge out there, this article will explain how it works in a way hopefully understandable by anyone with a basic familiarity with crypto.
The concept
Let's start by just imagining that I want to transfer 20 DAI from Ethereum to NEAR. Since physical transfer of tokens isn't possible between networks, this means we need to take 20 DAI out of circulation on Ethereum, and put 20 DAI into circulation on NEAR, so that the global supply of DAI doesn't change.

Here's how I could do that in a trustless, permissionless way:

 	I tell the Ethereum network that I want to transfer 20 DAI somewhere else.
 	The Ethereum network locks my 20 DAI in a vault (a smart contract), so that they are taken out of circulation.
 	Once I'm certain those 20 DAI have been locked on Ethereum, I then tell NEAR to create 20 new DAI for me there.
 	NEAR doesn't trust me, of course, and so it asks me to prove that I've locked 20 DAI on Ethereum.
 	I provide NEAR with proof that I've locked those DAI on Ethereum.
 	NEAR independently verifies my proof, and then creates 20 new DAI for me to use on NEAR.

Later, if and when I wish to move my DAI from NEAR back to Ethereum, I simply reverse the above procedure. Neat, huh?
The actors
So now let's look at how all that happens in practice, using the Rainbow Bridge. The story is going to involve a number of technical components that make up the bridge:

The Rainbow Bridge UI — this is the website where you, as a user, interact with the bridge to transfer your assets between networks.

The LiteNode — This is like a blockchain node, except that it only stores block headers, dramatically reducing the storage space needed. The LiteNode is implemented as a smart-contract, and we have two of them—one deployed on the Ethereum network, which stores NEAR block headers, and one deployed on NEAR which stores Ethereum block headers.

(Just an FYI, the LiteNode is actually referred to as the "light client" in other articles, for historical reasons. If you ask me, "What stores blockchain data?", my first thought is "a node", and so in this article, to help with mental models, I'm calling it the LiteNode.)

Relayers — Since LiteNodes are smart contracts, they can't run and update themselves. Relayers are scripts running on traditional servers, that periodically read blocks from one blockchain, and communicate them to the LiteNode running on the other. So the relayers keep the LiteNodes up-to-date.

Since there is a transaction cost—i.e. gas fees—each time a relayer updates a LiteNode, the one on NEAR (containing the Ethereum blocks) is updated on each Ethereum block (since NEAR gas fees are cheap), while the update frequency on Ethereum (containing the NEAR blocks) is configurable and determined by an economic budget (currently about 12 to 16 hours).

Connectors — Connectors are smart contracts responsible for all of the logic associated with the cross-chain management of a given asset type. Like LiteNodes, they exist in pairs—one running on Ethereum, and one running on NEAR. For example, there is a pair of "ETH Connectors" responsible for transferring ETH between the two networks. And there's an "ERC-20 Connector" pair responsible for transferring ERC-20 tokens. Someone could write an "NFT" Connector, "Prediction Market Outcomes" Connector or "DAO Vote Results" Connector if they wished. Any asset or data can be transferred across the Rainbow Bridge, if relevant Connectors exist!
Putting the pieces together
To understand how all these elements work together to allow me to permissionlessly, and trustlessly, transfer tokens between Ethereum and NEAR, let's walk through our original example again:

 	Using the Rainbow Bridge UI, I start a transfer of 20 DAI from Ethereum to NEAR.
 	When I confirm the first of two transactions in MetaMask, the Rainbow Bridge communicates with the ERC-20 Connector on Ethereum (since DAI is an ERC-20 token), which transfers and locks 20 DAI in its vault. These DAI are then no longer in circulation on the Ethereum network.
 	Based on the header data in my transaction block, the Rainbow Bridge UI calculates a cryptographic "proof" that I really did lock 20 DAI.
 	Since we're next going to ask the NEAR network to create some DAI based on what just happened on Ethereum, we first wait for the Relayer to send about 20 Ethereum block headers to the LiteNode running on NEAR. This is for security, in the same way your crypto exchange makes you wait for some confirmations before using your deposited funds.
 	After this wait, the Rainbow Bridge UI then allows us to take step two in the process—asking the ERC-20 Connector on NEAR to create 20 new DAI for us on the NEAR network.
 	When we make this request of the ERC-20 Connector, we provide our cryptographic proof we received earlier, "proving" that we locked 20 DAI on Ethereum.
 	The ERC-20 Connector on NEAR will then lookup our Ethereum block header in the LiteNode running on NEAR, and make its own independent calculation of the cryptographic proof.
 	If the proof we provided matches the proof that the ERC-20 Connector calculates, then it knows those 20 DAI are safely locked away on Ethereum—and that it was me who locked it!—and proceeds to create (mint) 20 new DAI on NEAR and delivers them to my wallet.

When we want to transfer DAI from NEAR back to Ethereum, the process happens in reverse, i.e. rather than locking 20 DAI in NEAR, we destroy them—known as "burning"—and then we provide the "proof" of that burn to the Connector running on Ethereum. Having access to the NEAR blocks in the LiteNode running on Ethereum, it validates our proof, and releases 20 DAI from its vault and sends them to our wallet!

And that, in a nutshell, is how the Rainbow Bridge works! It's the only Ethereum bridge in crypto that works this way, currently—allowing you to permissionlessly transfer assets between Ethereum, NEAR—and soon, Aurora—without having to put any trust in third parties. Very cool!
Other bits and pieces
Here's some interesting notes to go along with that overview:

 	Since the NEAR-to-Ethereum Relayer only sends NEAR block headers to the Ethereum LiteNode every 16 hours, there's a 16 hour delay between steps one and two when moving tokens in that direction. (Remember, this is because Ethereum gas fees make it prohibitively expensive for the Relayer to update the LiteNode on every block.) There are a number of approaches that would allow us to reduce this delay, and the team is actively working on that.
 	On NEAR, the LiteNode stores all past Ethereum block headers. In order that storage space doesn't get out of hand, the LiteNode "prunes" (deletes) blocks older than about two weeks. This means if you start a transfer from Ethereum to NEAR, and go on vacation for three weeks between steps one and two, you won't be able to complete your transfer, because the Ethereum data stored NEAR necessasry to verify your "proof" would have been deleted!
 	An interesting property of the NEAR block header design, is that with a single block header, we can compute the history of past blocks for quite a long period. So in theory, the LiteNode on Ethereum only needs a single NEAR block; however, we keep them because the gas costs needed to perform pruning would basically be a waste of resources.
 	The team that created the Rainbow Bridge is the same that created Aurora—the NEAR EVM. Since that team has spun-out into its own entity, the Rainbow Bridge will come under its management for operations, maintenance and future evolution.
 	The Aurora team are working on "auto-finalization" for the Rainbow Bridge, so that you will no longer have to manually initiate step two of these transfers. This will be very convenient for users (and meaning that you could start your Ethereum to NEAR transfer and then go on vacation!)
 	Transfers between Ethereum and Aurora are performed by the Aurora Bridge, which uses the same core technology as the Rainbow Bridge, but augmented to handle the NEAR/Aurora hidden step in the transfers.
 	The user interface and experience of the Aurora Bridge is different than Rainbow Bridge, and at some point in the future, these will be harmonized.

Although some technical details have been simplified, you now have a fundamental understanding of how the Rainbow Bridge works!

For a in-depth description of the Rainbow Bridge, you can read this article, and to keep up with everything related to Aurora, be sure to follow Aurora on Twitter!

 

### NEAR Protocol and Solana

Today let’s look at two of the most promising smart contract platforms in the world – Near Protocol and Solana. While Ethereum still dominates this market, the fact is that its lack of scalability and high fees have forced most developers to look for viable alternatives. Near and Solana have emerged as the top two front runners.
What is Solana?
Solana was founded in 2017 by Anatoly Yakovenko, who had previously worked at DropBox. Yakovenko, along with Eric Williams and CTO Greg Fritzgerald, created Solana to solve the existing problems in Bitcoin and Ethereum. The project has attracted investments from Multicoin Capital, Foundation Capital, SLOW Capital, CMCC Global, Abstract Ventures, and more. 



Features of the Solana blockchain

 	50,000 transactions per second and 0.4 seconds block time
 	The system can provide 28.4 million transactions per second on a 40 gigabit network.
 	Solana uses Proof-of-History consensus algorithm.

How does Proof-of-History (PoH) work?

In a decentralized network that spreads over a large area, consensus is essential. Bitcoin uses the proof-of-work (PoW) consensus to take care of consensus. While the method is highly secure, it is hard not to ignore its most significant problem – the lack of scalability. Don’t forget that Bitcoin can only do 7 transactions per second.

Solana uses proof-of-history, wherein it creates historical records to prove that an event occurs during a specific moment in time. Here are some points that you need to keep in mind:

 	The algorithm uses a high-frequency Verifiable Delay Function which requires a certain number of sequential steps to finish.
 	The transactions or events clocked within the network will be designated a unique hash a count, which can be publicly verified.
 	The count allows the network to know exactly when the transaction or the event has happened.
 	Every node has a cryptographic clock that helps track the network time and order of events.

Due to PoH, the Solana network supports 50,000 transactions per second while running with GPUs. 

What is a Solana Cluster?

A cluster is a set of independently-owned computers working together and can be viewed as a singular system. The main features of the Cluster are as follows:

 	They help verify the output of untrusted, user-submitted programs. 
 	Maintains a record of any transaction or event that a user makes.
 	It keeps track of which computers did meaningful work to keep the network running.
 	It keeps track of the possession of real-world assets.




	

	
	
		
			
				Which of the following utilizes sharding?
			
		

		
					

		
			
			
			
			Solana
		
			
			NEAR protocol
		
			
			Both
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Programming in Solana

The smart contracts in Solana are written in Rust or C and compiled to Berkeley Packet Filter (BPF) bytecode. Since there are more toolings available, it is recommended that you code in Rust. Beginners should code their programs using the Anchor framework, which simplifies execution.

Solana has a unique account model that is similar to files in the Linux operating system. They can hold any arbitrary data and also contain metadata about how they can be accessed. Keep in mind though, that the accounts have a fixed size and cannot be resized. 

Solana’s current programming model may force you to move application logic off-chain or modify the functionality to be inefficient and limited by the fixed account size. 




	

	
	
		
			
				Which of the following is an integral part of Solana?
			
		

		
					

		
			
			
			
			Cluster
		
			
			Collective
		
			
			Parachain
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Example Contract
#![feature(proc_macro_hygiene)]

use anchor_lang::prelude::*;
use anchor_spl::token::{self, TokenAccount, Transfer};

#[program]
pub mod plutocratic_hosting {
    use super::*;

    /// Initialize a new contract with initialized content.
    #[access_control(Initialize::validate(&ctx, nonce))]
    pub fn initialize(
        ctx: Context<Initialize>,
        price: u64,
        content: String,
        nonce: u8,
    ) -> ProgramResult {

        // Transfer funds to the contract vault.
        let cpi_accounts = Transfer {
            from: ctx.accounts.from.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Initialize the content data.
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.nonce = nonce;
        content_record.owner = *ctx.accounts.owner.to_account_info().key;
        content_record.vault = *ctx.accounts.vault.to_account_info().key;
        Ok(())

    }

    /// Purchase content address for new price, if transferring more tokens.
    #[access_control(check_funds(&ctx.accounts.content, price))]
    pub fn purchase(ctx: Context<Purchase>, price: u64, content: String) -> ProgramResult {
        // Transfer funds from contract back to owner.
        let seeds = &[
            ctx.accounts.content.to_account_info().key.as_ref(),
            &[ctx.accounts.content.nonce],
        ];
        let signer = &[&seeds[..]];
        let cpi_accounts = Transfer {
            from: ctx.accounts.vault.to_account_info().clone(),
            to: ctx.accounts.owner_token.to_account_info().clone(),
            authority: ctx.accounts.contract_signer.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);
        token::transfer(cpi_ctx, ctx.accounts.content.price)?;

        // Transfer funds from new owner to contract.
        let cpi_accounts = Transfer {
            from: ctx.accounts.new_owner_token.to_account_info().clone(),
            to: ctx.accounts.vault.to_account_info().clone(),
            authority: ctx.accounts.new_owner.clone(),
        };
        let cpi_program = ctx.accounts.token_program.clone();
        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);
        token::transfer(cpi_ctx, price)?;

        // Overwrite content
        let content_record = &mut ctx.accounts.content;
        content_record.price = price;
        content_record.content = content;
        content_record.owner = *ctx.accounts.new_owner.to_account_info().key;

        Ok(())
    }
}

#[account]
pub struct ContentRecord {
    /// Price at which the current content is owned.
    pub price: u64,
    /// Content Data.
    pub content: String,
    /// Public key of current owner of the content.
    pub owner: Pubkey,
    /// Address for token program of funds locked in contract.
    pub vault: Pubkey,
    /// Nonce for the content, to create valid program derived addresses.
    pub nonce: u8,
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut, "&vault.owner == contract_signer.key")]
    vault: CpiAccount<'info, TokenAccount>,
    /// Program derived address for the contract.
    contract_signer: AccountInfo<'info>,
    /// Token account the contract is made from.
    #[account(mut, has_one = owner)]
    from: CpiAccount<'info, TokenAccount>,
    /// Owner of the `from` token account.
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
    rent: Sysvar<'info, Rent>,
}


impl<'info> Initialize<'info> {
    pub fn validate(ctx: &Context<Self>, nonce: u8) -> Result<()> {
        let signer = Pubkey::create_program_address(
            &[
                ctx.accounts.content.to_account_info().key.as_ref(),
                &[nonce],
            ],
            ctx.program_id,
        )
        .map_err(|_| ErrorCode::InvalidNonce)?;
        if &signer != ctx.accounts.contract_signer.to_account_info().key {
            return Err(ErrorCode::InvalidSigner.into());
        }
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Purchase<'info> {
    #[account(mut, has_one = vault)]
    content: ProgramAccount<'info, ContentRecord>,
    #[account(mut)]
    vault: CpiAccount<'info, TokenAccount>,
    #[account(seeds = [
        content.to_account_info().key.as_ref(),
        &[content.nonce],
    ])]
    contract_signer: AccountInfo<'info>,
    #[account(mut, has_one = owner)]
    owner_token: CpiAccount<'info, TokenAccount>,
    #[account(mut)]
    new_owner_token: CpiAccount<'info, TokenAccount>,
    #[account(signer)]
    new_owner: AccountInfo<'info>,
    owner: AccountInfo<'info>,
    token_program: AccountInfo<'info>,
}

fn check_funds(check: &ContentRecord, new_price: u64) -> Result<()> {
    if check.price >= new_price {
        return Err(ErrorCode::InsufficientFunds.into());
    }

    Ok(())
}

#[error]
pub enum ErrorCode {
    #[msg("The given nonce does not create a valid program derived address.")]
    InvalidNonce,
    #[msg("The derived signer does not match that which was given.")]
    InvalidSigner,
    #[msg("Insufficient funds provided to purchase route.")]
    InsufficientFunds,
}
What’s happening in the contract?

 	All accounts to be accessed are annotated in structure for each call with #[derive(Accounts)]. 
 	The functions help intialize the account data for the initial owner and Purchase. This allows anyone to purchase it for more tokens. 
 	Temporary data is passed into function parameters. These parameters are inside the initialize and purchase functions. This also include the Context holding the accounts requires for the transaction.
 	The contract’s state is located in the ContentRecord struct. This is further annotated with #[account] to indicate that it represents the data layout for an account.

What is NEAR Protocol?
Coming into existence in the summer of 2018, the protocol was designed to create the perfect environment for decentralized applications by providing higher speeds, higher throughput, and better compatibility with other chains. NEAR has a unique Sharding technique and introduces a block generation mechanism called “Doomslug” proposed in 2019. Doomslug allows practical or “Doomslug” finality, ensuring that the blocks receive finality in seconds.

 

NEAR protocol is developed by the NEAR Collective, a community of developers and researchers collaborating on building the project. Some critical features of NEAR are:

 	NEAR is a sharded system that allows for infinite scalability. 
 	An easy-to-use protocol, NEAR allows developers to build apps easily and quickly. 
 	NEAR is not a side chain but a Layer-1 protocol. 
 	dApps created using NEAR run on top of the underlying NEAR layer. 

What Is The NEAR Collective? 

The NEAR Collective includes individual organizations and other contributors that are continuously working on improving the NEAR Protocol. The Collective works on projects such as writing the initial code and implementation for the NEAR Network. NEAR is entirely decentralized, operating independently, and cannot be shut down or manipulated, even by those that built it.

It is a non-profit organization that is focused on creating a vibrant ecosystem around the NEAR blockchain. It helps in the coordination of governance activities and development. The NEAR Collective has several projects, with the NEAR blockchain just one of several projects under the aegis of the collective. 

NEAR Consensus Mechanism

The consensus mechanism implemented on NEAR is called Nightshade. Nightshade models the system as a single blockchain. The list of all the transactions in each block is split into physical chunks, one chunk per shard. All chunks accumulate to one block. Note that chunks can only be validated by nodes that maintain the state of that shard.

Speaking of validation, a key component of NEAR are the validators. These validators are responsible for maintaining consensus within the protocol. Validators are specialized nodes that need to keep their servers online 100% of the time while keeping their systems continually updated. 

Here are a few points that you must keep in mind about network validators.

 	NEAR determines its network validators every new epoch, electing them based on their stake.
 	The already elected validators are re-enrolled by automatically re-staking their tokens plus the accrued rewards.
 	Potential validators have to have their stake above a dynamically determined level.
 	There are two methods that a validator can use to strengthen their stake – buy the tokens themself or borrow via stake delegation.
 	The reward you receive is directly proportional to your stake—more your stake, more your rewards.

The consensus is based on the heaviest chain consensus. Meaning, once a block producer publishes a block, they collect the signatures of validator nodes. The weight of a block is then the cumulative stake of all the signers whose signatures are included in the block. The weight of a chain is the sum of the block weights. Additionally, the consensus utilizes a finality gadget that introduces additional slashing conditions for higher chain security.




	

	
	
		
			
				Doomslug” is a block generation mechanism of which protocol?
			
		

		
					

		
			
			
			
			NEAR protocol
		
			
			Solana
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Aurora and NEAR Protocol

Aurora has also launched on the NEAR Protocol, providing an Ethereum Layer-2 experience. Some of the ways that Aurora improves NEAR are: 

 	It helps boost throughput to thousands of transactions per second.
 	A block finality time of 2 seconds.
 	Futureproof ecosystem growth
 	Low transaction fees, which are 1000x lower than Ethereum.
 	Uncompromising compatibility with Ethereum.

Example Contract
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[global_allocator]
static ALLOC: near_sdk::wee_alloc::WeeAlloc = near_sdk::wee_alloc::WeeAlloc::INIT;

#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentRecord {
    pub price: Balance,
    pub content: String,
    pub owner: AccountId,
}

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct ContentTracker {
    values: LookupMap<String, ContentRecord>,
    contract_owner: AccountId,
}

impl Default for ContentTracker {
    fn default() -> Self {
        let contract_owner = env::predecessor_account_id();
        Self {
            values: LookupMap::new(b"v".to_vec()),
            contract_owner,
        }
    }
}

#[near_bindgen]
impl ContentTracker {
    /// Gets content at a given route.
    pub fn get_route(&self, route: String) -> Option<String> {
        self.values.get(&route).map(|v| v.content)
    }

    /// Purchases a route based on funds sent to the contract.
    #[payable]
    pub fn purchase(&mut self, route: String, content: String) {
        let deposit = env::attached_deposit();
        assert!(deposit > 0);
        if let Some(entry) = self.values.get(&route) {
            assert!(
                deposit > entry.price,
                "Not enough deposit to purchase route, price: {} deposit: {}",
                entry.price,
                deposit
            );


            // Refund purchase to existing owner
            Promise::new(entry.owner).transfer(entry.price);
        }


        // Update record for the contract state.
        self.values.insert(
            &route,
            &ContentRecord {
                price: deposit,
                content,
                owner: env::predecessor_account_id(),
            },
        );
    }


    /// Allows owner of the contract withdraw funds.
    pub fn withdraw(&mut self) {
        assert_eq!(env::predecessor_account_id(), self.contract_owner);


        // Send the contract funds to the contract owner
        Promise::new(self.contract_owner.clone()).transfer(env::account_balance());
    }
}

What is going on in the contract?

So, what is going on here in the contract? Let’s take a closer look.

 	The contract is defined by #[near_bindgen] in the ContentTracker it is similar to a constructor in Solidity and gets called when contract is deployed.
 	The purchase function is annotated with #[payable].
 	The contract includes asynchronous calls in the form of  Promise::new(…).transfer(…); lines.
 	The data structure LookupMap<String, ContentRecord> handles the key-value lookup, which accesses storage. This is equal to Solidity “mapping.”

Conclusion
Both Solana and NEAR Protocol are brilliant smart contract platforms that have built up highly active communities. Both of them bring in special features that help combat the biggest issue plaguing the decentralized world – speed. Both of the platforms are still growing and have a lot of promise.

### NEAR 🤝 Ethereum 

Hiện nay, Ethereum là nền tảng điện toán số một trong thế giới tiền điện tử, với phần lớn hợp đồng thông minh (Smart contract) và ứng dụng phi tập trung (decentralized application - dApps) dựa trên công nghệ chuỗi khối (blockchain).Bên cạnh đó, trong thị trường cũng có những nền tảng điện toán khác tương tự như Ethereum.

Dù Ethereum là nền tảng số một khi nói về hợp đồng thông minh và tài chính phi tập trung (decentralized finance - DeFi) không có nghĩa là nó không có bất cứ vấn đề nào. Ethereum có một vấn đề rõ ràng và nó thậm chí là vấn đề lớn với khả năng mở rộng của nền tảng này. Nó không thể tự mở rộng mạng lưới của mình.

Đây là vấn đề mà NEAR sẽ nhảy vào giải quyết. Điểm khác biệt vượt trội của NEAR là nó sử dụng cơ chế đồng thuận “Bằng chứng Cổ phần” (Proof-of-State) cho việc phân đoạn dữ liệu (sharding).Trước khi tìm hiểu sâu hơn, hãy cùng đọc qua về Ethereum và NEAR:
Ethereum là gì?
Nếu xem định nghĩa về Ethereum trên website chính thức của nó, thì bạn sẽ thấy định nghĩa:

“Ethereum là một ngôi nhà của tiền kĩ thuật số, thanh toán toàn cầu và ứng dụng phi tập trung. Cộng đồng đã dựng lên một nền kinh tế số phát triển, cách thức mới đầy sáng tạo cho những người sáng tạo kiếm tiền trực tuyến và hơn thế nữa. Nó chào đón tất cả mọi người dù bạn có ở đâu trên thế giới.”

Được thành lập năm 2015 bởi Vitalik Buterin, Ethereum đã khẳng định bản thân là đồng tiền ảo lớn thứ hai theo vốn hoá thị trường, chỉ sau Bitcoin. Ethereum được tạo ra từ ý tưởng của Bitcoin, điều này làm nó không chỉ là một đồng tiền ảo đơn thuần mà còn có khả năng cho phép người dùng gửi và nhận giá trị mà không có bất cứ sự can thiệp của bên thứ ba.

Ethereum đảm bảo tính phi tập trung bằng cách thay thế các máy chủ tập trung bằng hàng ngàn node, đảm bảo rằng nền tảng luôn trực tuyến và không bị ảnh hưởng bởi bất kỳ bên thứ ba nào. Hợp đồng thông minh (Smart contract) cũng là thành phần không thể thiếu trong hệ sinh thái của Ethereum và vì giao thức phần mềm này hỗ trợ cả ứng dụng phi tập trung và hợp đồng thông minh, nên nó đặc biệt thu hút các nhà lập trình viên cũng như người dùng.

Ethereum đang nâng cấp lên  phiên bản Ethereum 2.0 hay được biết với tên Serenity. Bản nâng cấp này cải thiện đáng kể về khả năng mở rộng (scalability), hiệu suất (efficiency) và tốc độ của blockchain Ethereum. Thêm vào đó, sự nâng cấp này sẽ cho phép nền tảng Ethereum giảm thiểu phí gas và thực hiện nhiều giao dịch hơn, nâng cấp khả năng mở rộng chuỗi mà không ảnh hưởng rủi ro về an ninh (security).

Sự đổi mới cho thấy Ethereum sẽ chuyển sang cơ chế đồng thuận Bằng chứng cổ phần (Proof-of-Stake hay PoS). PoS sẽ có những validator (người xác nhận giao dịch) sẽ được lựa chọn theo thuật toán để cung cấp bảo mật cho nền tảng. Validator sẽ bảo mật nền tảng bằng cách khóa ETH của họ. Bất kỳ tài khoản nào hành động chống lại lợi ích của nền tảng đều bị cắt cổ phần của họ, đảm bảo tính bảo mật của nền tảng.
Giao thức NEAR là gì?
Giao thức NEAR là gì?

Giao thức NEAR ra mắt vào vào mùa hè năm 2018. Một nền tảng phát triển phi tập trung, giao thức này đã được thiết kế để tạo ra một môi trường hoàn hảo cho những ứng dụng phi tập trung, tập trung vào những khuyết điểm của các nền tảng khác trong Smart contract và kho ứng dụng dApp. Sự thiếu sót ấy chủ yếu về vấn đề về tốc độ chậm, thông lượng thấp, và khả năng tương thích kém với những chuỗi khác.

NEAR vận hành trên nền tảng giao thức NEAR, một PoS blockchain, kết hợp cùng một số tính năng và cải tiến để giảm thiểu chi phí và tăng khả năng mở rộng cho cả người dùng và developer. Hơn nữa, NEAR có giải pháp độc quyền gọi là “Sharding”

Nó còn ra mắt một cơ chế sản sinh khối được đề xuất năm 2019 với tên gọi là “Doomslug”. Doomslug đảm bảo các blocks nhận được giá trị cuối cùng của mạng trong vài giây.

Giao thức này dựa trên công nghệ tương tự như Bitcoin, kết hợp với những tính năng khác như sharding. Giao thức NEAR được phát triển từ con số không và đã trở thành mạng lưới dễ truy cập nhất cho người dùng và developer mà vẫn giữ được tính mở rộng (scalability) và khả năng bảo mật (security).

Hầu hết các blockchain hỗ trợ khả năng mở rộng đều tập trung trong tác vụ xử lý, giới hạn ở phần cứng cao cấp, điều này tạm thời sẽ làm tăng cao thông lượng , NEAR cho phép nền tảng mở rộng quy mô tuyến tính, lên đến hàng tỷ giao dịch theo cách hoàn toàn phi tập trung.

NEAR được phát triển bởi NEAR collective, một cộng đồng các developer và nhà nghiên cứu hợp tác xây dựng dự án. Một số tính năng quan trọng của NEAR

 	NEAR là hệ thống Sharding (tạm dịch là phân đoạn) cho phép khả năng mở rộng vô hạn.
 	Một giao thức dễ sử dụng, NEAR cho phép các developer xây dựng ứng dụng một cách dễ dàng và nhanh chóng.
 	NEAR không phải là một chuỗi phụ mà là một giao thức Layer-1.
 	dApps được tạo bằng cách sử dụng NEAR chạy trên hạ tầng NEAR bên 

NEAR Collective là gì? 
NEAR Collective bao gồm các tổ chức cá nhân và những người đóng góp khác đang liên tục làm việc để cải thiện Giao thức NEAR. Tập thể này làm việc trên các dự án như viết mã nguồn và triển khai cho mạng NEAR. NEAR hoàn toàn phi tập trung, hoạt động độc lập và không thể bị tắt hoặc thao túng, ngay cả bởi những người đã xây dựng nó.

NEAR Collective có các thành viên như NEAR Foundation. NEAR Foundation là một tổ chức phi lợi nhuận tập trung vào việc tạo ra một hệ sinh thái sôi động xung quanh blockchain NEAR. Nó giúp điều phối các hoạt động quản trị và phát triển.NEAR Collective có một số dự án và NEAR chỉ là một trong số các dự án dưới sự bảo trợ của Collective.
Tại sao những blockchain như NEAR lại cần thiết? 
Để hiểu được điều này, chúng ta trước hết phải biết được sự phát triển của công nghệ blockchain. Blockchain có thể được chia thành ba giai đoạn hoặc thế hệ. Các blockchain thế hệ đầu tiên được thiết kế để trở thành một cơ chế thanh toán đơn giản. Bitcoin là một ví dụ về blockchain thế hệ đầu tiên đã khẳng định vị thế vững chắc trong thế giới tiền điện tử như một nền tảng số một. Tuy nhiên, các blockchain thế hệ đầu tiên có những hạn chế liên quan đến những giao dịch phức tạp.

Nền tảng blockchain thế hệ thứ hai nổi bật nhất là Ethereum và khái niệm Smart Contract, cho phép các developer sử dụng chúng và lập trình các giao dịch phức tạp hơn và tạo dApps. Nhưng các blockchain thế hệ thứ hai gặp phải các vấn đề nghiêm trọng về khả năng mở rộng. Ví dụ, Ethereum chỉ có thể xử lý khoảng 25 giao dịch mỗi giây, hãy so sánh con số này với các nền tảng chính thống như Visa hoặc PayPal, và bạn có thể thấy Ethereum đang tụt lại bao xa.

Ethereum đã cố gắng khắc phục các vấn đề về khả năng mở rộng của nó bằng cách triển khai các giải pháp Layer-2, như giao thức plasma, tạo ra một lớp bổ sung chạy song song với chuỗi chính. Tuy nhiên, các giải pháp Layer-2 vẫn chưa tạo ra được sự chú ý.

Điều này đưa chúng ta đến NEAR, một blockchain thế hệ thứ ba. NEAR loại bỏ ý tưởng rằng mỗi node trên mạng phải chạy toàn bộ mã vì nhóm tin rằng tất cả những gì nó làm chỉ tạo ra tắc nghẽn. Thay vào đó, blockchain khắc phục các vấn đề về khả năng mở rộng bằng cách sử dụng kỹ thuật sharding, cho phép blockchain mở rộng công suất mạng. Không giống như các blockchain thế hệ thứ hai sử dụng giải pháp Layer-2, sharding là giải pháp Layer-1.
Sharding là gì? 
Trước khi tiếp tục sâu hơn, hãy cùng tìm hiểu về sharding. Đôi khi các hệ thống phải xử lý rất nhiều dữ liệu. Điều này ảnh hưởng đến hiệu suất của hệ thống, làm giảm thông lượng và ảnh hưởng đến hiệu suất của hệ thống. Sharding khắc phục điều này bằng cách phân vùng dữ liệu theo chiều ngang, làm cho dữ liệu nhỏ hơn, dễ quản lý và quan trọng hơn là xử lý nhanh hơn.

NEAR và Ethereum: NEAR và Ethereum hoạt động như thế nào?
Ethereum 
Ethereum không chỉ là một nền tảng tài chính thực hiện các giao dịch; nó cũng hỗ trợ các ứng dụng phi tập trung dApp và Smart contract. Ethereum dựa trên công nghệ blockchain và sử dụng sổ cái công khai, nơi lưu trữ tất cả các giao dịch đã xác minh. Bất kỳ ai muốn xem các giao dịch đều có thể truy cập được, đảm bảo tính minh bạch (Transparency) hoàn toàn trong khi đảm bảo dữ liệu được lưu trữ trong blockchain không thể bị thay đổi hoặc thao túng.

Blockchain của Ethereum tương tự như blockchain Bitcoin và hoạt động như một sổ cái công khai lưu giữ hồ sơ về tất cả các giao dịch và lịch sử hợp đồng thông minh. Các tình nguyện viên trên toàn thế giới lưu trữ một bản sao của toàn bộ blockchain Ethereum, làm cho blockchain này trở nên hoàn toàn phi tập trung. Mỗi khi một hành động như giao dịch hay hợp đồng thông minh diễn ra trên blockchain, tất cả các nút trên toàn thế giới sẽ xử lý nó, đảm bảo rằng các quy tắc blockchain được tuân thủ.

Tất cả các Node được kết nối và tuân theo cùng một bộ quy tắc trên hệ thống. Các Node của Ethereum cũng theo dõi trạng thái của tất cả các ứng dụng, số dư của người dùng và mã hợp đồng thông minh, đảm bảo rằng tất cả thông tin luôn được cập nhật.

Nhờ Solidity, các developer có thể viết các hợp đồng thông minh có thể quản lý các giao dịch trên blockchain và kết quả của chúng. Hợp đồng thông minh khác với các hợp đồng truyền thống vì chúng đảm bảo rằng các điều khoản của hợp đồng được thực hiện. Ngoài ra, chúng tự động thực hiện các giao dịch khi một tập hợp các điều kiện xác định trước được đáp ứng, loại bỏ tất cả các bên thứ ba liên quan đến bất kỳ giao dịch nào
NEAR
NEAR sử dụng công nghệ blockchain, giống như các blockchain khác như Ethereum và Cardano. NEAR hoạt động như một blockchain hạ tầng mà các ứng dụng có thể được xây dựng và triển khai. Nó sử dụng một cơ chế đồng thuận được gọi là Nightshade giúp nó đạt được thông lượng cao. Cơ chế đồng thuận của NEAR giả định rằng các giao dịch từ tất cả các Shard kết hợp để tạo thành một khối, đó là lý do tại sao mỗi Shard giữ một phần của mỗi khối. Phần này được gọi là một chunk.

Validator được chọn ngẫu nhiên, sau đó xử lý các giao dịch trên nhiều shard, nâng cao khả năng giao dịch của giao thức NEAR. Các chunk được xử lý và sau đó được lưu trữ trên blockchain, hoàn thành các giao dịch.

NEAR không chạy theo ý tưởng rằng mỗi note phải xử lý toàn bộ mã. Thay vào đó, nó giải quyết các vấn đề về khả năng mở rộng bằng cách sử dụng sharding. Thông qua sharding, dữ liệu được phân vùng theo chiều ngang, giúp quản lý dễ dàng hơn và xử lý nhanh hơn.
NEAR và Ethereum: Cơ chế đồng thuận 
Ethereum 
Hiện tại, Ethereum sử dụng cơ chế đồng thuận Proof-of-Work, nhưng với Ethereum 2.0 sắp tới, nền tảng này sẽ chuyển sang cơ chế đồng thuận Proof-of-Stake. Proof-of-Stake sẽ được thực hiện với giao thức Casper, tạo ra một hệ sinh thái độc lập. Trước khi hoàn toàn chuyển sang cơ chế Proof-of-Stake, Ethereum sẽ thực hiện cơ chế đồng thuận lai giữa PoW và PoS.

Hãy cùng đào sâu vào cách thức hoạt động của cả Proof-of-Work và Proof-of-Stake. Proof-of-Work yêu cầu các thợ đào (miner) phải cạnh tranh với nhau, sử dụng lượng lớn sức mạnh tính toán để giải quyết các vấn đề toán học phức tạp nhằm xác thực các giao dịch. Khi giao dịch được xác thực, người khai thác sẽ được thưởng. Ethereum đang chuyển sang cơ chế Proof-of-Stake vì Proof-of-Work có một số vấn đề, chẳng hạn như tiêu thụ năng lượng cao. Việc chuyển đổi cũng đang được thực hiện để giải quyết các vấn đề về khả năng mở rộng của Ethereum.

Trong cơ chế đồng thuận Proof-of-Stake, những validator đặt cược ETH của họ, sau đó họ được chọn ngẫu nhiên để chứng thực một khối. Validator được chọn đề xuất một khối, trong khi các validator khác cần chứng thực rằng họ đã nhìn thấy khối đó. Khi họ đã xác thực khối, nó sẽ được thêm vào blockchain và những người này sẽ được thưởng. Do đó, những validator được thưởng cho cả việc đề xuất và chứng thực khối.
NEAR 
NEAR Protocol đã triển khai Nightshade Sharding như là cơ chế đồng thuận Proof-of-Stake của họ. Chúng ta đã thảo luận về sharding là gì, vì vậy chúng ta có thể bỏ qua phần đó. Tuy nhiên, phương pháp sharding đang được sử dụng ngày nay có những vấn đề của nó, chẳng hạn như quy tắc lựa chọn fork trong cả chuỗi shard và chuỗi báo hiệu cần được xây dựng và thử nghiệm khác nhau.

Tuy nhiên, Nightshade coi hệ thống như một blockchain duy nhất và mỗi khối chứa các giao dịch cho tất cả các shard. 

Người tham gia không cần tải xuống trạng thái đầy đủ mà thay vào đó chỉ duy trì trạng thái là một phần của phân đoạn mà họ đang xác thực giao dịch. Danh sách tất cả các giao dịch trong mỗi khối được tạo, sau đó được chia thành nhiều phần, với mỗi shard được để cử.

Validator là một phần quan trọng của giao thức NEAR, duy trì sự đồng thuận trên giao thức. Do đó, họ cần giữ hệ thống của mình được cập nhật mọi lúc đồng thời giữ cho máy chủ của họ trực tuyến.

 	Validator được lựa chọn với mọi chu kỳ (epoch) dựa trên số tiền đặt cược của họ.
 	Validator có thể được tham gia lại bằng cách cược lại token và phần thưởng của họ.
 	Validator có thể tăng cường cổ phần của họ theo hai cách, mua thêm token hoặc mượn chúng thông qua ủy quyền cổ phần.

NEAR và Ethereum: Token 
Token gốc của Ethereum, Ether, khuyến khích các lập trình viên tiếp tục vận hành giao thức của blockchain vì phần cứng cung cấp năng lượng cho Ethereum rất đắt và tiêu thụ một lượng điện năng đáng kể. Do đó, cả những người khai thác và lập trình viên đều được thưởng bằng Ether vì đã sử dụng tài nguyên của họ và giữ cho hệ sinh thái Ethereum an toàn và hoạt động.

Developer cũng sử dụng Ether để thanh toán vì vậy họ ra mắt Smart Contract hoặc những ứng dụng phi tập trung trên Ethereum blockchain. Điều này cũng phục vụ cho việc truy cập vào smart contract.

Token gốc của NEAR, NEAR token, được dùng để khuyến khích những validator trong mạng lưới. Token này cũng thúc đẩy các giao dịch và hợp đồng thông minh trên blockchain. NEAR là nền tảng chi phối bởi cộng đồng nên người sở hữu token cũng sẽ có tầm ảnh hưởng trong việc quản trị nền tảng NEAR, bỏ phiếu quyết định cho những thay đổi tiềm năng của nền tảng.
Những dự án trên Ethereum và giao thức NEAR 
Ethereum là nền tảng đi đầu khi đề cập tới ứng dụng và tài chính phi tập trung với hơn 3000 dApps hoạt động trên blockchain của họ. Hầu hết những dự án của Ethereum tập trung vào Defi, mở rộng việc sử dụng tiền điện tử để thực hiện các mục đích sử dụng tài chính phức tạp hơn.

Một số dự án đi đầu trên Ethereum blockchain:

 	Uniswap
 	MakerDAO 
 	Chainlink 
 	Aave

Mặc dù mainnet của NEAR chỉ mới ra mắt cách đây một năm hơn, đã có một số nền tảng đang được xây trên nó. Một trong những dự án trên giao thức NEAR là:

 	Mintbase – Một nền tảng chuyên dụng để đơn giản hóa việc phát hành và bán NFT đồng thời làm cho toàn bộ quy trình rẻ hơn.
 	Flux – Flux là một giao thức thị trường mở phi tập trung. Nó ra mắt trên hạ tầng NEAR vào năm 2020.
 	Paras – Paras là một thị trường NFT tập trung vào các tác phẩm do các nghệ sĩ được chọn lọc tạo ra.

Chương trình NEAR Grants, hiện do NEAR Foundation điều hành, hỗ trợ các dự án cho phát triển trên hệ sinh thái NEAR.
The NEAR Grants Program, currently operated by the NEAR Foundation, supports projects that enable the growth of the NEAR ecosystem. 

Aurora trên giao thức NEAR
Aurora được ra mắt trên hạ tầng NEAR, cung cấp giải pháp Layer-2. Một giải pháp cho phép developer vươn ra các thị trường khác, Aurora tận dụng những tính năng của giao thức NEAR như phí gas và sharding. Nó hoạt động dựa trên 2 thành phần cốt lõi, Aurora Bridge và Aurora Engine.

Một số cải tiến mà Aurora mang lại:

 	Khả năng xử lý hàng nghìn giao dịch mỗi giây, cao hơn 50 lần so với Ethereum.
 	Thời gian xác nhận khối là 2 giây, so với thời gian xác nhận khối đơn lẻ là 13 giây trên Ethereum .Ngoài ra, tính hoàn thiện nhanh chóng của blockchain NEAR cũng làm giảm đáng kể nguy cơ cho các cuộc tấn công.
 	Hệ sinh thái tăng trưởng trong tương lai, phương pháp tiếp cận sharding của giao thức NEAR cho phép mở rộng quy mô EVM theo chiều ngang và giao tiếp không đồng bộ giữa nhiều phân đoạn.
 	Phí trên Aurora thấp hơn 1000 lần so với phí trên Ethereum. Để lấy một ví dụ, chuyển Token ERC-20 trên Aurora có giá dưới $0,01, trong khi trên Ethereum, chi phí khoảng $5,40.
 	Aurora cung cấp khả năng tương thích nhất định với Ethereum qua giao thức NEAR.

Aurora cung cấp giải pháp cho các vấn đề hiện tại và tương lai của hệ sinh thái Ethereum, đồng thời đảm bảo không có quá nhiều thay đổi trong cả Smart contract lẫn front-end code
Ưu điểm của giao thức NEAR
Giải pháp Sharding của NEAR mang lại cho nó một lợi thế rất lớn so với các nền tảng như Ethereum và Bitcoin, giải quyết vấn đề về khả năng mở rộng kém và tắc nghẽn thường xuyên trên mạng Ethereum. Bằng cách làm cho giao thức của họ được chia nhỏ, những người sáng lập NEAR sẽ chia mã của blockchain thành các chunk chạy trên các node song song. Điều này làm tăng tốc độ xử lý mã và giải quyết các vấn đề về khả năng mở rộng nhờ việc phân mảnh mã.

Ngoài ra, giao thức NEAR còn có một số tính năng độc nhất giúp nó trở thành đề xuất hấp dẫn với người dùng và validator như:

 	Trải nghiệm người dùng linh hoạt và khả năng truy cập vào các dịch vụ chạy trên nền tảng NEAR cũng có quy trình giới thiệu dễ hiểu.
 	Do giao thức sharding của NEAR, validator có thể tham gia nền tảng mà không cần tải xuống phần mềm phức tạp. Sau đó, họ có thể nhận được token bằng cách xác thực các giao dịch trên nền tảng.
 	NEAR cho phép các doanh nghiệp tùy chỉnh quyền cho người dùng của họ. Với sự tăng trưởng ổn định trên nền tảng, các developer có thể tiếp cận với lượng khách hàng đang tăng lên từng ngày.

Tương lai của giao thức NEAR 
Với sự ra mắt của Ethereum-to-NEAR bridge, còn được gọi là Rainbow Bridge, người dùng có thể kết nối các Ethereum ERC-20 token của họ với NEAR và bắt đầu sử dụng chúng trong hệ sinh thái ứng dụng phi tập trung của NEAR. Sự phát triển này là một bước tiến lớn đối với tầm nhìn của nhóm sáng lập là làm cho nền tảng dễ tiếp cận nhất có thể.

NEAR cũng đang làm việc để triển khai hỗ trợ Máy ảo Ethereum (EVM). Sau khi quá trình này hoàn tất, các developer có thể triển khai lại các dApp của họ trên NEAR với những thay đổi tối thiểu và khởi chạy trên những chain khác.

Giao thức NEAR đã công bố quan hệ đối tác với Chainlink, cùng với sự ra mắt của Rainbow Bridge, cho phép tương tác giữa NEAR và Ethereum.
Kết luận   
Giao thức NEAR cho thấy rất nhiều hứa hẹn, sử dụng sharding để giải quyết các vấn đề về khả năng mở rộng của blockchain thế hệ thứ hai. Ngoài ra, NEAR làm tăng đáng kể thông lượng mà không ảnh hưởng đến tính bảo mật của nền tảng.

Nhờ có NEAR Collective, hàng trăm kỹ sư và developer blockchain đang làm việc để cải thiện giao thức 24/7. NEAR cũng đã ra mắt mainnet của mình và mạng này đã sẵn sàng hỗ trợ các dApp và các dịch vụ khác. Với trọng tâm là đảm bảo Nền tảng NEAR dễ sử dụng cho validator, người dùng cuối và developer, NEAR đã nổi lên như một thế lực trong thế giới nền tảng Smart contract.

Mặt khác, Ethereum vẫn giữ được vị trí dẫn đầu nhờ cộng đồng developer tài năng và hệ sinh thái DeFi và NFT đang phát triển mạnh mẽ. Cả hai giao thức này đều cung cấp một nền tảng tuyệt vời cho các developer để xây dựng hệ sinh thái phi tập trung của tương lai.

### Integrating with NEAR Protocol

A write up of our NEAR integration journey




Lets start with what the 3 pillars of NEAR Protocol are:


 	Proof of Stake
 	Sharded
 	WASM Smart Contracts

As a Proof of Stake blockchain consensus is achieved by staking not by mining. Near has fast 1 second blocks with short finality.
The blockchain is sharded meaning calls between contracts are asynchronous (not to be confused with synchronous like on Ethereum or Solana). Coding Near contracts you need to take the mindset of working with actor model (or microservices, but I hate that term). The requirement of asynchronicity is needed so shards can be processed in parallel leading to much larger transaction throughput. Blockchains where smart contracts are not sharded will simply will hit a scalability ceiling, offloading to GPU or ASIC (while still synchronous) can only horizontally delay this ceiling, but it will not lead to exponential scaling.
Near contracts are WASM code, so you can code in any language that can compile down to WASM. Currently AssemblyScript (subset of TypeScript) and RUST are most supported with proper tool chains.




DISCLAIMER: This will take you LESS than 30 minutes if you can program in TypeScript.



To build a WebApp on NEAR protocol  (which is exactly what Near access at) is very easy compared to other blockchains.
Lets clone the counter example here https://github.com/near-examples/counter.

git clone https://github.com/near-examples/counter
yarn












We only care about these 2 folders and 1 file
assembly/ is where our smart contract is (that will compile down to WASM).
src/ is where our frontend code goes that interacts with the contract.
package.json is where our extra JavaScript dependencies go.
















The core of our contract includes on chain storage, control logging for the generated receipt, and exported public functions. Functions that set storage must be called otherwise they can be viewed (without a NEAR account even).
Near supports multiple types of collections (that self describe themselves) under the near-sdk-as.













https://github.com/near/near-sdk-as/tree/master/sdk-core/assembly/collections
The main ones you will need:


 	storage.getPrimitive — get/set
 	persistentMap — set/get
 	persistentUnorderedMap — set/get/query/length

I do not include persistentVector because you should avoid using it, its very easy to burn tons of gas iterating vectors, try to use sets whenever possible.
Default values for persistentMap collections need to be suffixed with !

let balance = myPersistentMap.get("myacc.near", u128.Zero)!
logging.log will print log output on your receipt when calling a function, this is useful for control flow to what went on, especially as contracts get more complex. Example of a human readable minting contract can have a log message of “alice.near has minted 5.0 ZOD from zod.near”.




Lets deploy our contract, for this we need near-cli.



npm install near-cli -g
And to deploy we can create a dummy testnet account. Accounts are contracts and you can only have 1 contract per account. To create multiple contracts you need to use sub accounts, contract1.me.near, contract2.me.near.
Lets deploy and call the getCounter function.

yarn build
ACC1=$(near dev-deploy out/main.wasm | sed 's/.*id: \(.*\), node.*/\1/' | head -n 1)
near view --accountId $ACC1 $ACC1 getCounter '{}'
Output is

View call: dev-1623290109414-64922580028342.getCounter({})
0
Lets increment the counter

near call --accountId $ACC1 $ACC1 incrementCounter '{"value": 1}'
Lets view this call on the block explorer https://explorer.testnet.near.org/accounts/dev-1623290109414-64922580028342
Awesome.




To view a function we can use curl but need to parse some commandline output, it is simpler to write a quick node script. We do not even need a near account.



node << EOF
const fetch = require('node-fetch');
async function go() {
  const args_base64 = Buffer.from('{}').toString('base64')
  const params = {account_id: "zodtv.near", method_name: "mint_status", 
    request_type: "call_function", finality: "final", "args_base64": args_base64}
  const json_args = {jsonrpc: "2.0", id: "1", method: "query", params: params}

  const fetch_args = {
    method: "POST",
    body: JSON.stringify(json_args),
    headers: {
      "Content-Type": "application/json"
    }
  }
  const response = await fetch("https://rpc.mainnet.near.org", fetch_args);
  const {result} = await response.json();

  const mint_status = JSON.parse((new TextDecoder()).decode(new Uint8Array(result.result)))
  console.log(mint_status)
}
go()
EOF
The following snippet uses RPC API https://docs.near.org/docs/api/rpc to query the state of of the zodtv.near mint contract.

{
  "total_minted": "3120000000000000000000000000",
  "level": "0",
  "near_price": "3000000000000000000000000",
  "zod_price": "10000000000000000000000"
}
Near denominates to the 24, the yocto.
3_000_000_000_000__000_000_000_000
is 3.0






That ends the first series here the next on would be working with a web frontend and correctly getting balance, state and more.

### NEAR Smart Contracts in RUST - Best Practices

Init once
Make sure you check that state doesn't exists in init using

assert!(!env::state_exists(), "The contract is already initialized");

Prevent Default
By default near_sdk allows contract to be initialized with default state. Usually, if you have a constructor, you want to prevent default state initialization.

impl Default for Contract {
    fn default() -> Self {
        env::panic(b"The contract should be initialized before usage")
    }
}

Public vs private methods
pub fn makes a method public and exposes it in a contract. It means anyone can call it. fn makes the method private and it's not exposed from the contract. No one can call it directly. It can only be called within a contract directly (not through a promise).
Private callbacks
If you're using callbacks, makes sure you check the caller.

assert_eq!(env::current_account_id(), env::predecessor_account_id(), "Can only be called within a contract");

Callbacks have to be public methods.
JSON types
NEAR currently expects contracts to support JSON serialization. JSON can't handle large integers (above 2**53 bits). That's why you should use helper classes from the json_types in near_sdk for u64 and u128. We provide types U64 and U128, that wraps the integer into a struct and implements JSON serialization and deserialization as a base-10 strings.

E.g.

pub fn add(&self, a: U128, b: U128) -> U128 {
    (a.0 + b.0).into()
}

View vs Change method
By default, near_sdk assumes that the method is a view if it has &self and method is change if it has &mut self. View methods usually don't have ability to change state and have limited context. Change methods will save the modified state back to the contract.
STATE storage key
The contract will save the main structure state under the storage key STATE. Make sure you don't modify it e.g. through collection prefixes or raw storage access.
Enable overflow checks
It's usually helpful to panic on integer overflow. To enable it, add the following into your Cargo.toml file:

[profile.release]
overflow-checks = true

Use assert! early in the method.
Try to validate the input, context, state and access first before making any actions. This will safe gas for the caller to fail earlier.
Use env::log
Use logging for debugging and notifying user. When you need a formatted message, you can use the following:

env::log(format!("Transferred {} tokens from {} to {}", amount, sender_id, receiver_id).as_bytes());

Return Promise
If your method makes a cross-contract call, you may want to return the Promise that the contract creates. It allows the caller to wait for the result of the promise instead of the returning the result immediately. Because if the promise fails for some reason, the caller will not know about this or the caller may display the result earlier.

E.g.

pub fn withdraw(&mut self, amount: U128) -> Promise {
    Promise::new(self.owner_id.clone()).transfer(amount.0)
}

### NEAR Sputnik DAO: Empowering Communities

Open Web and Web3 messaging all stems from the idea that the next generation of the internet will be built for and governed by the people. NEAR has even codified this in our mission: empowering all people to control their own money, data, and power of governance.



	

	
	
		
			
				What according to you should be the core purpose of a DAO?
			
		

		
					

		
			
			
			
			Coordinating community activities
		
			
			Facilitate the Governance Mechanism
		
			
			 Replicate the corporate structure
		
			
			Facilitate tokenomics
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





A very old (2014) blog post by Ethereum founder Vitalik Buterin painted a new way of thinking about collective action, where instead of a company with shareholders, executives, and employees, there could be a decentralized autonomous organization, or DAO, where members own a portion of the organization, contribute what they can to its success, and are rewarded proportionally to their contribution. There are no bosses, no hierarchy, and the participants are united by a common purpose.
I remember feeling inspired when I first read Vitalik’s post, imagining a truly community-owned future where anyone, anywhere could formalize a group and its actions independent of the bounds of borders, laws, or banks — much like blockchain-powered Web3 does for the individual, DAOs could do for communities. Eventually companies would be replaced by DAOs, still having many company-like features, but with greater flexibility both at their founding and over time as the demands and priorities of the people involved change.
This vision even predated my interest in Web3 and blockchain. I left Ukraine because I never felt secure starting a company there. I don’t believe any Ukrainian bank can be trusted to store my money safely. The government has changed the rules around holding US currency multiple times just over the last ten years (like the need to sell half of it on receival for local currency). There is a lot of corruption and rigid structure around how companies can operate in Ukraine, as well. In many countries, forming a company comes with additional overhead due to government corruption, lack of rule of law, and unreliable banks that can disappear.
This is true everywhere, to some extent: before blockchain, if people wanted to organize into a formal group, they would need to request a license from the government (e.g. create a company), especially if they needed a bank account and wanted to participate in the economy as a group. This process is time-consuming, expensive, complex, and the resulting organization is subject to restrictive rules once it forms.
Even informal community coordination requires rules and moderation. Imagine an anime student group wants to coordinate an international fan event, or a collective of successful artists around the world want to join together to support novice artists. Community coordination could include everything from a way to post which way members are leaning on some question, creating art or a product together, launching an app, investing in some digital assets, or even co-owning a social channel like a Twitter account. All of these are real-world examples of coordination that require some kind of governance.
For a long time, I have believed in a myriad of small teams working together instead of huge companies that create a monopoly and then fight to preserve it. In fact, about ten years ago, some friends and I created the not-a-company ProstoKSI, which was made up of developers working together on open-source projects.
Web3 makes this vision possible in a way that Web2 can’t, because of the guarantees that come with crypto. Imagine building on top of a cloud provider or using a bank that is just run by a group of 20 people with no formal affiliation and no guarantees that the organization will still be functioning in a year — there are limits to what you can build on it. But in crypto, infrastructure and decentralized applications are reliable because they are open source, open state, and come with reliable guarantees. Apps built in this way provide common protocols to interact with each other, which other developers, businesses, and users can rely on.
DAOs are a part of such common protocols in the new world. In the seven years since Vitalik wrote this very high-level post, thousands of members have experimented with DAOs on Ethereum and other networks — some of the best-known include Maker, Moloch DAO, MetaCartel, The LAO, and Flamingo DAO. I’ve taken some key learnings from the first wave of DAO experimentation that informed the vision for DAOs on NEAR.


 	It’s generally clear that simple ways for a community to control governance do not scale with the number of people involved. Thousands of people can’t effectively develop or control anything without the introduction of rules, laws, or hierarchies. We also have seen a number of experiments in the blockchain space around the governance of protocols and investment funds. Many of these have failed for various reasons, from technical issues to lack of interest in voting from members or lack of a unifying, driving factor.
 	One can’t expect that every member will always be happy. Interests drift and people’s opinions evolve; majorities and minorities will eventually emerge around some issue. Even though in most cases everyone will fall into consensus through basic governance like voting, the minority of the community should be able to fork, or diverge from the original group to follow a new set of rules, at any time if they don’t agree with the majority and have enough of their own will.
 	Any community or organization requires leadership. Even if it’s a highly dedicated group of people — if they are not working full-time on the shared cause, they are probably too busy to be active all the time and participate in every discussion or decision. Communities usually have dedicated members who are responsible for coordination, potentially moderation.
 	If a community is permissionless and pseudonymous, it’s still valuable to have members who are publicly known to be involved and create the “core” of the community. The community will listen to these members’ perspectives and opinions above any others because they’re known to be the most invested and informed.
 	The more “product” focused such a decentralized community is, the more focused the leadership must be, as product development usually requires a lot more context than any community participant would have. For example, a community trying to build a blockchain or a decentralized exchange together.
 	Pure stake-based weighting always fails, either because the majority of stakeholders are not able to or don’t want to be active participants, or because it opens up easy ways to attack the governance process.




	

	
	
		
			
				Is the Sputnik DAO created specifically for technical communities?
			
		

		
					

		
			
			
			
			Yes
		
			
			No
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





So a DAO is a community united around some common purpose, requiring some rules for coordination and governance, with the flexibility to evolve over time as the interests and goals of the community shift, and the ability to transact and make money as a unit with minimal overhead. With all of these learnings in mind, we set out to create a DAO protocol on NEAR that would empower all kinds of communities — not just technical ones run by engineers — with a flexible, robust framework for working and evolving together.



	

	
	
		
			
				Which of the following is/are true about community leadership?
			
		

		
					

		
			
			
			
			True leadership ensures that every single community member is always happy
		
			
			Community leaders are not required to work full-time for the community
		
			
			Even in a permission-less community, it is important to have core members/leaders
		
			
			Leaders of the community govern the community by creating rules
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





The resulting protocol, Sputnik DAO, offers a way for new and existing communities and organizations around the world to have on-chain representation of their group, manage their on-chain activity, govern their own decision-making, and (importantly!) interact with other DAOs. Currently there are about 100 Sputnik DAOs since the initial launch in February 2021, with ~$500k allocated and ~$500k contained in the collective treasuries (see stats here).
Check out sputnik.fund and tell us what you think. Next week we will share a V2 beta with a fresh UX, new features, and another article with details about how Sputnik is uniquely solving key challenges of organizing communities. Make sure to follow our Medium to be notified about V2.
Thanks to Sputnik’s early community group for ideas for v2; NEAR Team, 



Tara Tan, Julia Lipton for comments and suggestions and 



Mally Anderson  for heavy editing.
Original article on Medium.
P.S.
Want to contribute to LearnNEAR.Club? Submit your proposal to Learn NEAR DAO

### NEAR 🤝 Ethereum 

Today, Ethereum is the number one smart contract platform in the crypto space, with a majority of smart contracts and decentralized applications based (dApps) based on its blockchain. Like Ethereum, there are several other smart contract platforms in the market as well. 
However, just because Ethereum is the number one platform when it comes to smart contracts and DeFi, does not mean it does not have problems. Ethereum has one glaring problem, and that is significant scalability problems. It just cannot get its network to scale. 
This is where the NEAR Protocol comes into the picture. NEAR’s USP is that it uses a Proof-of-Stake consensus mechanism that utilizes sharding. Before we dive deeper, let us get to know both Ethereum and NEAR. 

What Is Ethereum? 
If you look at Ethereum’s definition on its website, it is as follows -
“Ethereum is a technology that’s home to digital money, global payments, and applications. The community has built a booming digital economy, bold new ways for creators to earn online, and so much more. It’s open to everyone, wherever you are in the world.”
Founded in 2015 by Vitalik Buterin, Ethereum has firmly established itself as the second-largest cryptocurrency by market capitalization, second only to Bitcoin. Ethereum builds upon Bitcoin’s blockchain, making it more than just another cryptocurrency that allows users to send or receive value without any third-party intervention. 
Ethereum ensures decentralization by replacing central servers with thousands of nodes, ensuring that the platform is always online and free from any third-party influence. Smart contracts also form an integral part of Ethereum’s ecosystem, and because the platform supports both decentralized applications and smart contracts, it is exceptionally appealing to developers and users alike. 
Ethereum is now moving to Ethereum 2.0 or Serenity. The upgrade will significantly improve the blockchain’s scalability, efficiency, and speed of the Ethereum blockchain. In addition, the upgrade will allow Ethereum to reduce gas costs and process more transactions, improving the scalability of the blockchain without compromising on security. 
The upgrade will also see Ethereum switch to a Proof-of-Stake consensus mechanism. PoS will see validators who have been chosen algorithmically provide security to the platform. The validators will secure the platform by locking up their ETH. Any validator that acts against the interest of the platform has their stake slashed, ensuring the platform’s security. 

What Is the NEAR Protocol? 
The NEAR Protocol came into existence in the summer of 2018. A decentralized development platform, the protocol was designed to create the perfect environment for decentralized applications, focusing on the shortcomings of other platforms in the smart contract and dApp space. These shortcomings are mainly issues with low speeds, low throughput, and poor compatibility with other chains. 
NEAR operates on top of the NEAR Protocol, a Proof-of-Stake (PoS) blockchain, incorporating several features and innovations to reduce costs and improve scalability for both users and developers. In addition, NEAR takes a unique approach to “Sharding.”
It also introduces a block generation mechanism called “Doomslug” that was proposed in 2019. Doomslug allows practical or “Doomslug” finality, ensuring that the blocks receive finality in seconds.
The protocol is based on the same technology as Bitcoin, combining it with features such as database sharding. NEAR Protocol is built from scratch and is the most accessible network for end-users and developers while also ensuring scalability and security. 
Most scalable blockchains centralize processing, limiting it to high-end hardware, which provides a temporary boost to their throughput, NEAR allows the platform to scale linearly, upto billions of transactions in a completely decentralized way. 
NEAR is developed by the NEAR collective, a community of developers and researchers collaborating on building the project. Some important features of NEAR are 


 	NEAR is a sharded system that allows for infinite scalability. 
 	An easy-to-use protocol, NEAR allows developers to build apps easily and quickly. 
 	NEAR is not a side chain but a Layer-1 protocol. 
 	dApps created using NEAR run on top of the underlying NEAR layer. 

What Is The NEAR Collective? 
NEAR Collective comprises individual organizations and other contributors that are continuously working on improving the NEAR Protocol. The Collective works on projects such as writing the initial code and implementation for the NEAR Network. NEAR is completely decentralized, operating independently and cannot be shut down or manipulated, even by those that built it.
The NEAR Collective has members such as the NEAR Foundation. The NEAR Foundation is a non-profit organization that is focused on creating a vibrant ecosystem around the NEAR blockchain. It helps in the coordination of governance activities and development. The NEAR Collective has several projects, with the NEAR blockchain just one of several projects under the aegis of the collective. 

Why Are Blockchains Like NEAR Necessary? 
To understand this, we must first understand the evolution of blockchain technology. Blockchain can be divided into three stages or generations. First-generation blockchains were designed to be a simple payment mechanism. Bitcoin is an example of a first-generation blockchain that has firmly established itself in the crypto space as the number one platform. However, first-generation blockchains have limitations when it comes to complex transactions. 
Second-generation blockchain platforms came to the fore with Ethereum and the concept of smart contracts, allowing developers to use them and program more sophisticated transactions and creating dApps. But second-generation blockchains suffer from severe scalability issues. For example, Ethereum can process only about 25 transactions per second, compare this number with mainstream platforms like Visa or PayPal, and you can see how far behind Ethereum is lagging. 
Ethereum has tried to fix its scalability issues by implementing Layer-2 solutions like the plasma protocol, creating an additional layer that runs in tandem with the main chain. However, Layer-2 solutions still have not gained enough traction. 
This brings us to NEAR, a third-generation blockchain. NEAR discards the idea that each node on the network has to run the entire code as the team believes that all it does is create bottlenecks. Instead, the blockchain fixes scalability issues by utilizing a sharding technique, allowing the blockchain to scale up the network’s capacity. And unlike second-generation blockchains that use a Layer-2 solution, sharding is a Layer-1 solution. 

What Is Sharding? 
Before we move ahead, let us understand sharding. Sometimes systems have to deal with a lot of data. This affects the performance of the system, reducing throughput and affects the performance of the system. Sharding overcomes this by partitioning data horizontally, making it smaller, manageable, and, more importantly, quicker to process. 

NEAR and Ethereum: How Do NEAR And Ethereum work?
Ethereum 
Ethereum functions as more than just a financial platform carrying out transactions; it also supports decentralized applications and smart contracts. Ethereum is based on blockchain technology and uses a public ledger where all verified transactions are stored. The transactions are accessible to anyone who wants to view them, ensuring complete transparency while ensuring that the data stored in the blockchain cannot be changed or manipulated. 
Ethereum’s blockchain is similar to the bitcoin blockchain and acts as a public ledger that keeps a record of all transactions and smart contract history. Volunteers worldwide store a copy of the entire Ethereum blockchain, making the blockchain completely decentralized. Each time an action like a transaction or smart contract takes place on the blockchain, all nodes worldwide process it, ensuring that the blockchain rules are followed. 
All nodes are connected and follow the same set of rules regarding smart contracts and transactions. Ethereum’s nodes also keep track of the state of all applications, user balances, and the smart contract code, ensuring that all information is always up-to-date.
Thanks to Solidity, developers can write smart contracts that can manage transactions on the blockchain and their outcomes. Smart contracts differ from traditional contracts as they ensure that the terms of the contract are fulfilled. In addition, they automatically execute transactions when a set of predetermined conditions are fulfilled, eliminating all third parties involved in any transaction. 

NEAR 
NEAR uses blockchain technology, just like other blockchains such as Ethereum and Cardano. NEAR acts as the base blockchain upon which applications can be built and deployed. It uses a consensus mechanism known as Nightshade that helps it achieve its high throughput. NEAR’s consensus mechanism assumes that transactions from all shards combine to make a block, which is why each shard submits a segment of each block. This segment is called a chunk. 
Validators are chosen at random then process transactions across multiple shard chains, improving the transaction capacity of the NEAR protocol. The chunks are processed and then stored on the blockchain, finalizing the transactions. 
NEAR does not run on the idea that each node has to process the entire code. Instead, it addresses scalability issues by using sharding. Through sharding, the data is horizontally partitioned, making it easier to manage and quicker to process. 

NEAR and Ethereum: Consensus Mechanism 
Ethereum 
Currently, Ethereum uses a Proof-of-Work consensus mechanism, but with Ethereum 2.0 on the horizon, the platform will shift to a Proof-of-Stake consensus mechanism. Proof-of-Stake will be implemented with the Casper protocol, creating a trustless ecosystem. Before completely switching to a Proof-of-Stake mechanism, Ethereum will implement a hybrid PoW-PoS consensus mechanism. 
Let us understand how both Proof-of-Work and Proof-of-Stake work. Proof-of-Work requires that miners compete with each other, utilizing massive amounts of computational power to solve complex mathematical problems to validate transactions. Once a transaction is validated, the miner is rewarded. Ethereum is switching to a Proof-of-Stake mechanism because Proof-of-Work has several issues, such as high energy consumption. The switch is also being made to address Ethereum’s scalability issues. 
In a Proof-of-Stake consensus mechanism, validators stake their ETH, after which they are randomly selected to attest a block. The selected validator proposes a block, while the other validators need to attest that they have seen the block. Once they have validated the block, it is added to the blockchain, and the validators are rewarded. Thus, validators are rewarded for both proposing and attesting the block. 

NEAR
NEAR Protocol has implemented Nightshade Sharding as their Proof-of-Stake consensus mechanism. We have already discussed what sharding is, so we can skip past that. However, the sharding method in use today has its issues, such as the fork choice rule in both the shard and beacon chains needs to be built and tested differently. 
However, Nightshade treats the system as a single blockchain, and each block contains transactions for all shards. However, participants need not download the full state, instead maintaining only the state that is part of the shard they are validating transactions for. A list of all transactions in each block is created, which is then split into chunks, with each shard being assigned one shard. 
Validators are a key part of the NEAR protocol, maintaining consensus on the protocol. Therefore, they need to keep their systems updated at all times while also keeping their servers online. 


 	Validators are selected with every epoch based on their stake. 
 	Validators can be enrolled again by re-staking their tokens and rewards. 
 	Validators can strengthen their stake in two ways, buy a token or borrow them through a stake delegation. 

NEAR and Ethereum: The Tokens 
Ethereum’s native token, Ether, incentivizes programmers to continue running the blockchain’s protocol since the hardware that powers Ethereum is expensive and consumes a significant amount of power. Thus, miners and programmers are both rewarded in Ether for utilizing their resources and keeping the Ethereum ecosystem secure and functioning. 
Developers also use Ether to pay so that they can launch smart contracts or decentralized applications on the Ethereum blockchain. It is also used to access smart contracts. 
NEAR’s native token, the NEAR token, is used to incentivize validators on the network. The token also drives transactions and smart contracts on the blockchain. Since NEAR is a community-governed platform, token holders play a significant role in the NEAR platform’s governance, voting on potential changes on the NEAR platform. 

Projects On Ethereum And The NEAR Protocol 
Ethereum is the leader when it comes to decentralized apps and decentralized finance, with over 3000 dApps running on its blockchain. Most of Ethereum’s projects focus on DeFi, expanding on the uses of cryptocurrencies to fulfill more complex financial uses. 
Some of the top projects on the Ethereum blockchain are 


 	Uniswap
 	MakerDAO 
 	Chainlink 
 	Aave

Even though NEAR’s mainnet was launched a little over a year ago, several platforms are building on it. Some of the projects on the NEAR Protocol are 


 	Mintbase - A platform dedicated to simplifying issuing and selling NFTs while also making the entire process cheap.  
 	Flux - Flux is a decentralized open-market protocol. It launched on the NEAR Protocol in 2020. 
 	Paras - Paras is an NFT marketplace focusing on works created by select artists. 

The NEAR Grants Program, currently operated by the NEAR Foundation, supports projects that enable the growth of the NEAR ecosystem. 

Aurora On The NEAR Protocol
Aurora has also launched on the NEAR Protocol, providing an Ethereum Layer-2 experience A solution that allows developers to reach out to additional markets, Aurora takes advantage of the NEAR Protocol features such as gas fee remuneration and sharding. It runs on two critical components, the Aurora Bridge and the Aurora Engine. 
Some of the enhancements that Aurora brings are:


 	The ability to process thousands of transactions per second, a 50x increase over Ethereum. 
 	A block finality time of 2 seconds, as compared to the single block confirmation time of 13 seconds on Ethereum. The fast finality also reduces frontrunning attacks. 
 	Futureproof ecosystem growth, NEAR protocol’s sharding approach allows horizontal EVM scaling, and asynchronous communication between multiple shards. 
 	Fees on Aurora are 1000x times lower than those on Ethereum. To take an example, Transferring an ERC-20 token on Aurora costs less than $0.01, while on Ethereum, it costs around $5.40. 
 	Aurora offers uncompromising compatibility with Ethereum over the NEAR Protocol. 

Aurora provides a solution for the challenges faced by the Ethereum ecosystem, while preserving both smart contracts and the front-end code.

Advantages Of NEAR Protocol
NEAR’s sharded solution gives it a huge advantage over platforms like Ethereum and Bitcoin, solving the problem of low scalability and frequent bottlenecks on the Ethereum network. By making their protocol sharded, the founders of NEAR break the blockchain’s code into chunks run on parallel nodes. This results in the entire code processed quickly and freeing NEAR from scalability issues thanks to this ability to fragment the code. 
The NEAR Protocol has several unique features that make it an attractive proposition for users and validators. 


 	A flexible UX and access to services that run on the NEAR platform also feature an easy onboarding process. 
 	Due to NEAR’s sharded protocol, validators can join the platform without downloading complex software. They can then earn tokens by validating transactions on the network. 
 	NEAR allows businesses to customize permissions for their users. With steady growth in the market, developers also gain access to a growing customer base. 

The Road Ahead For The NEAR Protocol 
With the launch of the Ethereum-to-NEAR bridge, also called the Rainbow Bridge, users can bridge their Ethereum ERC-20 tokens to NEAR, and start using them within NEAR’s  decentralized application ecosystem. This development is a huge step towards the founding team’s vision of making the platform as accessible as possible. 
NEAR is also working on implementing Ethereum Virtual Machine (EVM) support. Once this process is complete, developers can re-deploy their dApps on NEAR with minimal changes, and enable cross-chain launches. 
The NEAR Protocol announced a partnership with Chainlink, along with the launch of Rainbow Bridge, allowing NEAR and Ethereum interaction. 

Conclusion    
The NEAR Protocol has shown a lot of promise, utilizing sharding to solve second-generation blockchains’ scalability issues. In addition, NEAR significantly increases throughput without compromising the security of the platform. 
Thanks to the NEAR collective, hundreds of blockchain engineers and developers are working on improving the protocol 24/7. NEAR also launched its mainnet, and the network is ready to support dApps and other services. With its focus on  ensuring that the NEAR Platform is easy to use for validators, end-users and developers, NEAR has emerged as a force in the smart contract platform space.
Ethereum, on the other hand, has retained its position on the throne thanks to its enviable developer community and the thriving DeFi and NFT ecosystems. Both of these protocols provide a brilliant platform for developers to build the decentralized ecosystem of the future.

### NCD Frequently Asked Questions

NEAR Certified Developer Course

Are the meetings recorded?
Yes, there are recordings for each cohort.

What will we learn in a week?
The course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform.
During this course we practice the following:


 	perceiving web 3 in the context of human history
 	reading contract code in Rust and AssemblyScript
 	writing contracts using Rust and AssemblyScript
 	testing contracts using unit and simulation tests
 	deploying contracts and a sensible user interface

The course includes lots of listening, watching, reading and writing. A minimum of 2 hours per day is recommended but up to 4-6 hours per day is likely, especially for developers with less than three years web development experience.

What will we submit at the end of the week?
Each group will submit a project that is structured like this example: NEARly Neighbors
The project must include the following elements:


 	contract source code (Rust, AssemblyScript or both)
 	unit tests, all passing
 	simulation tests, all passing
 	mockups (frontend UX), but no working frontend is required
 	documentation (build, run tests, etc) to help others learn from your work

If you want a specific example of all of this, please refer to NEARly Neighbors linked above.

How many people form a group?
Groups should be 3-5 people. They should be in similar (or same) timezone for more convenient collaboration.

What is the difference between NCD.L1 vs NCD.L1v?
NCD certification for Level 1 (L1) has 2 components:


 	NCD.L1 certified participants – members of this group attend one week of NCD and participate in building and demo to receive a “certificate of completion”
 	NCD.L1v verified developers – members of this group complete NCD. l1 and pass a 60 minute technical interview to receive a “certificate of verification”

NCD.L1 is a signal of your intention to learn and your commitment to the 5-day program from Kickoff to Demo.
NCD.L1v is a verifiable record of evidence that you have understood the material and are able to apply it to the design, development, testing and deployment of NEAR Smart Contracts
To earn an L1v, participants must first complete the standard NCD L1 course with a demo and then schedule a 60 minute paired technical interview with a verification specialist.
The verification session will include at least some of following activities at the discretion of the verifier:


 	Explaining a working contract

 	Reasoning about the behavior of a contract (core contracts, learn-near examples, etc.)
 	Predicting the effect of a change in the contract
 	Creating a guide to using the contract (NEAR CLI commands, API calls, etc.)


 	Troubleshooting a broken contract

 	Fixing a compilation error
 	Fixing a failing unit test
 	Fixing a failing simulation test
 	Fixing a runtime error (contract logic, interface or other issues)


 	Improving a working contract

 	Refactoring the contract
 	Enhancing an existing feature
 	Adding a new feature
 	Optimizing the contract (size, speed, storage, etc)


 	Creating a new contract

 	Translating an existing contract from AssemblyScript to Rust or vice versa
 	Designing a new contract as an improvement to an existing one
 	Designing an entirely new contract based on requirements (to be provided by verifier)
 	Designing an entirely new contract based an original idea (either their own or the verifier’s idea)



The outcome of a verification session will be one of either: (a) Verified or (b) Unverified
If you do not pass the verification interview, you may reschedule the session 1 time (max 2 attempts) before being waitlisted for 180 days.

Is it possible to jump straight to L3 certification in case one already has a running dApp?
The key question here could be “why get certified at all?” since certification is a signal that a developer would use to communicate understanding to others like potential investors, co-founders and employers.
In other words, if you successfully launched Instagram last year, there’s no need to get a JavaScript Developer Certification to prove that you did it.
If for some reason you want a certification then I’m sure we can accommodate you.


 NEAR Protocol

How does NEAR compare with Ethereum 2.0?
NEAR and Ethereum 2.0 are solving similar challenges: high transaction costs, scalability, and throughput. They are also taking similar approaches in some ways, but very different in other ways.


 	Check out NEAR 102: Intro to NEAR for Ethereum Developers (November 2020)
 	Check out Alex Skidanov and Justin Drake re: NEAR vs Ethereum 2.0 (April 2020)
 	Check out Why doesn’t NEAR just replicate Ethereum Serenity design? (November 2018)

What’s the consensus algorithm used in NEAR?
The consensus mechanism implemented on NEAR is called Nightshade. Nightshade models the system as a single blockchain. The list of all the transactions in each block is split into physical chunks, one chunk per shard. All chunks accumulate to one block. Note that chunks can only be validated by nodes that maintain the state of that shard.

Theoretically, each logical block contains all the transactions for all the shards. However, since transmitting a logical block across the network would be prohibitively expensive, it is never initiated. Instead, each network participant maintains the state that corresponds to the shards that they validate transactions for and any additional shard that they want to track.

The consensus is based on the heaviest chain consensus. Meaning, once a block producer publishes a block, they collect the signatures of validator nodes. The weight of a block is then the cumulative stake of all the signers whose signatures are included in the block. The weight of a chain is the sum of the block weights. Additionally, the consensus utilises a finality gadget that introduces additional slashing conditions for higher chain security.

For more information on security, cross-shard communication, and validation roles, please refer to the Nightshade Paper or our summary in the docs.

– Source: Layer 1 Platform Overview
Also related:


 	Check out NEAR Protocol consensus specification
 	Check out the Nightshade Whitepaper
 	Check out other papers and articles

What does the wallet look like?
NEAR Wallet is a non-custodial web-based wallet. It supports several methods for controlling your private keys including:


 	Browser localstorage (this is the most convenient for you but also least secure)
 	Ledger (this is the least convenient for you but also most secure)
 	account recovery using email, phone or controlling the seed phrase directly

You can find out more about the NEAR Wallet here:


 	create a TestNet account or follow a guided walkthrough
 	read docs.near.org
 	fund an account for a friend
 	read the wallet source code
 	check out an alternative: Narwallet

Is 2FA centralized?
NEAR Wallet currently supports 2-factor-authentication by deploying a contract to your account. There are currently plans to change this approach.

What is the TPS of NEAR?
NEAR currently supports up to 200 TPS per shard. This number is rising quickly as the team turns their focus to performance. You can find out more about high level facts about NEAR here


 Accounts

Is my account and my contract the same address?
Yes, that’s right. NEAR uses human-readable account names. You can deploy one contract to an account if you have a FullAccess key on the account. Accounts also have subaccounts which would be useful for creating user accounts under your dApp, for example, or an account for each member of your family under your family name. You can read more about NEAR accounts in our platform specification, developer docs and video walkthroughs.
Express Guide on NEAR Account

Can I hide my implicit account transactions?
All transactions on NEAR are public. There is a Cypherpunk Guild currently working on introducing private transactions on NEAR and improving privacy on web3 in general

What does it mean to say “accounts are distributed among shards”?
Although NEAR MainNet is currently running on a single shard, the plan is to upgrade to a mulit-sharded network before 2022. On a multi-sharded system, accounts must be allocated to one and only one shard among many. Developers may want to choose the “best shard” because it’s close to other accounts they depend on. NEAR Protocol does not allow this.
Instead, the protocol reserves the right to move accounts around, or “redistribute” them, to maintain network performance. If one account becomes very popular, it may be moved to it’s own shard, for example.


 Access Keys

Are FullAccess and FunctionCall access keys stored on chain?
Each account holds its own keys in it’s storage. These are the public keys, of course, while the private keys remain with the users or developers.

Can I pay gas for the user?
Yes, NEAR supports paying for user onboarding using FunctionCall access keys.
There are a few examples of how this can be done in the NEAR Live App Review playlist.


 Contracts

What contract languages does NEAR support?
NEAR currently supports 2 languages: AssemblyScript and Rust. NEAR also intends to support many more languages like C++, C# and Go as can be seen on the list of suggestions for grant proposals
A high level comparison of the pros and cons of each language is included in the March 8th kickoff slides and recording. Here is the slide again.

Generally speaking, a contract written in AssemblyScript will be smaller than the same contract written in Rust, but the Rust contract will be safer (less likely to have surprising behavior, bugs, etc).
Both Rust and AssemblyScript contracts compile to Wasm so the only differences in contract features are conveniences in the SDKs. The Rust SDK near-sdk-rs is more mature than the AssemblyScript SDK near-sdk-as. The NEAR team and community try to maintain feature and syntax parity (same features, same words) among SDKs so you should expect to see these two SDKs, and others that come later, all provide the same benefits for developers.
NEAR does not currently teach Rust nor AssemblyScript programming but we are considering running courses for both languages. If you know of anyone interested in these courses, either as a student or teacher (!), please ask them to reach out to us on Discord.

What’s the main difference between AssemblyScript and Rust Contracts?
The NEAR Runtime executes compiled Wasm. Since both AssemblyScript and Rust compile to Wasm, there is not technical limitation on what is possible with either language.
Practically speaking, Rust is a far more mature language and ecosystem and the Rust toolchain that developers use to write, debug, test and compile Rust code to Wasm is the best in the industry. In this way, NEAR recommends using Rust for high value contracts including those that manage valuable assets like NFTs or financial applications.
From a learning perspective, both languages communicate with the NEAR Runtime using the same register-based interface so the lessons learned while writing contracts are the same. The Rust sdk (near-sdk-rs) does have a few conveniences like being able to mark a method as #[payable] which will allow users to attached a deposit (otherwise all methods throw by default if a deposit is attached). The exact same functionality can be introduced to an AssemblyScript contract with a single line of code but some developers prefer the expressiveness of built-in macros for readability.
The key point to understand here is that, if you’re just starting to learn NEAR, it doesn’t matter which language you choose as long as the language does NOT add more to your learning workload. Our recommendation is to focus on the contract language that is easiest for you to understand, learn to write contracts for the NEAR platform then reconsider your language choice for production-grade applications if necessary.

How much does a typical contract call cost?
There is no such thing as a “typical contract call” but it would be useful to look at historical average costs for contract calls on the platform. Developers usually attach about 5 Tgas (~ 5 milliseconds of compute time) for single function calls and up to 20 Tgas for cross-contract calls because of the machinery to broadcast the receipts across the network and spin up another contract.
The best place to look for these kinds of estimates is among our Core Contracts.

Why is a smart contract function call limited to 200ms?
NEAR Protocol is designed for fast block times of about 1 second per block and fast finality of about 2 seconds. Each function call must be limited to 200 ms (200 Tgas) to allow for the overhead of cross-contract calls (up to an additional 300 Tgas allowable for generating cross-contract calls) and the overhead of network communications to arrive at consensus.
It’s useful to keep in mind that if function calls were allowed to run for longer than 200 ms then this would increase the necessary block time to arrive at consensus about what happened during the execution of a function.
If you need more than 200 ms to complete an operation then you must break the operation down into multiple-cross contract calls. Have a look at this merge sort example in near-sdk-rs for instance.

Can AssemblyScript contracts interact with Rust contracts?
Absolutely yes. Contracts are compiled to Wasm and executed by the NEAR Runtime. The runtime does not care what technology was used to develop the contract, whether AssemblyScript, Rust or some new contract development language.
From the contract’s perspective, you’re just calling another contract. You don’t care which technology was used to implement it.


 Use Cases

How do I get a grant？
Visit near.org / grants

The NEAR Grants Program (NGP), directed by the NEAR Foundation, provides funding and resources to expand the NEAR ecosystem.

The program supports projects that share NEAR’s mission: to accelerate the world’s transition to open technologies by growing and enabling a community of developers and creators.

In the first half of 2021, the NEAR Grants Pilot Program will award $1 million (USD equivalent) in grants funding and resources to promising teams whose work will foster and expand NEAR’s technology and community.


Can NEAR be used in game product scenarios?
Absolutely, NEAR is a smart contract platform and can be used to track any data or compute.
There are several groups thinking about building games on NEAR but one new kind of game is a prediction market created by Flux.


 General Questions

What’s a “unit test”?
Testing is an important part of software development for a few reasons:


 	tests help to prevent “regression errors” where changes you will make tomorrow break things you build today
 	tests help focus the development process so developers don’t build more than they need to (see test-driven development or TDD)
 	tests give developers confidence in the code they write

Are the testing steps meant to collect errors or just to step the developing process?
Writing tests as part of the demo is important to help others understand how your code works and to verify that it works as expected.

### NEAR Account - Express Guide

Intro to NEAR Account

 	NEAR uses account identifiers that are readable by humans in the format name.near. For example, maria.near or jane.near. NEAR accounts are not case-sensitive. In fact only low case letters can be used. Your NEAR account ID can contain any of the following:

 	Lowercase characters (a-z)
 	Digits (0-9)
 	Characters (_-) can be used as separators

Your account ID CANNOT contain:

 	Characters "@" or "."
 	Fewer than 2 characters
 	More than 64 characters (including .near).


 	The NEAR account system is similar to the website domain system in the sense that an account can create as many sub accounts as needed. For example, an account with the name maria.near can create an account like sub.maria.near, and it in turn can create the accounts first.sub.masha.near, second.sub.maria.near and so on. You can create sub-account using NEAR CLI or at NameSky
 	NEAR Wallets like MyNEARWallet, Meteor wallet, Here wallet, Hot wallet or Bitte wallet or near-cli  (command line interface that delivers functionality for NEAR integration) can all be used to create an account.
 	You can check account information in the NEARBlocks, Pikespeak or NEAR Wallet of you
 	Besides visible accounts (name.near type), the NEAR also supports the creation of Implicit accounts are denoted by a 64 character address, which corresponds to a unique public/private key-pair. You can find a detailed English guide here
 	Every account in the system can have only 1 smart-contract. For apps that require the user to use multiple smart contracts child accounts can be used.  For example contract_1.maria.near, contract_2.maria.near, etc.

NEAR ACCOUNT - Keys

 	NEAR like most other blockchains is based on cryptography with an open key. It relies on pairs of keys each of which consists of an open key (public key) matched with a closed key (private key).
 	NEAR uses the open key for identification and the closed key for signing transactions (confirmation of account ownership during transaction creation).
 	In NEAR there are 3 types of keys. Access keys are for signing transactions from the account, validator keys allow for operations relating to network validation, node keys (network node) allow for low-level communication between nodes on the network.
 	Keys can be stored in 3 different storages. InMemoryKeyStore - memory storage, used for temporary scenarios. BrowserLocalStorageKeyStore - unencrypted local browser storage, used to work with applications in the browser. UnencryptedFileSystemKeyStore - unencrypted storage in the file system, used when working with near-cli.
 	An account can have multiple access keys or none.
 	Keys can have different access levels - FullAccess (full access) or FunctionCall (only the ability to call contract methods).
 	All keys are unique within one account, but the public key can be assigned to different accounts with different access levels. The access level determines what actions in the account can be performed with this key.
 	For the FullAccess access level, all 8 types of actions are available: CreateAccountAction (create an account), DeployContractAction (deploy a contract), FunctionCallAction (call contract methods), TransferAction (send tokens to another account), StakeAction (staking tokens), AddKeyAction (add a key to an account), DeleteKeyAction (delete an account key), DeleteAccountAction (delete an account).
 	For the FunctionCall access level, only the FunctionCallAction is available (calling contract methods). Also, for such a key, you can specify which contract methods it can call.

### How to Build on NEAR? Starting Guide

Prerequisites

 	Read "What is NEAR?"
 	JavaScript development experience

Developers are the lifeblood of the blockchain ecosystem. For blockchain technology to gain mainstream adoption, it needs to lower the barriers for entry for developers and allow them to create fun and sophisticated apps for the regular folks to enjoy. It is for this very reason that NEAR’s smart contracts are written using AssemblyScript due to its similarity to JavaScript.

So, if you are keen on building on NEAR, you can use the following tools

 	JavaScript SDK. Connect, sign, transact and deploy to any NEAR network from any JS context
 	Rust Contract SDK. Build safe, secure contracts that manage high value assets
 	AssemblyScript Contract SDK. Learn and prototype with zero friction using JS syntax
 	JSON RPC API. All communications with the platform pass through this API including ours
 	Command Line Interface. Full featured command line toolkit for developers and validators
 	NEAR Explorer. A blockchain search tool allowing developers to view transaction details, accounts, block details and more
 	NEAR Wallet. Create accounts, manage access keys, and more with our user friendly UI
 	nearup. Manage deployments locally and join any public or private network
 	Bridge. Fast, secure interoperability
 	EVM. Ethereum-compatible virtual machine.

Alright, let’s take the first steps.
A Brief Overview
Applications on NEAR have two distinct parts – a back-end and front-end.

 	Smart Contract (back-end): Storing and modifying data on the chain. Contracts need to expose methods that allow clients to "view" and "change" state.
 	Interactions with Smart Contract (front-end): You can interact with your contracts or contracts deployed by other people. You do this by using near-api-js Quickstart and Code Snippets in your application.




	

	
	
		
			
				Applications on NEAR have two distinct parts – a back-end and front-end.
The backend is the…..


			
		

		
					

		
			
			
			
			Mainnet
		
			
			Testnet
		
			
			Smart contracts
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






How to Build and Call Smart Contracts

NEAR currently supports:

 	Rust - near-sdk-rs: A wrapper that provides improved safety for the Rust programming language for high-value contracts.
 	AssemblyScript near-sdk-as: A collection of helpers that make your SmartContracts look similar to TypeScript while compiling to Wasm for execution.

NOTE: AssemblyScript is currently not recommended for production financial applications due to the newness of the language and compilation tools available.

Alright, let’s get serious.
Setting Up Testnet
The easiest way to create an account on NEAR is with NEAR Wallet. NEAR has several development networks operating independently of each other with their own accountIDs. Go, follow the steps to create a wallet. Make sure that you have followed the required steps for your security backup.

NOTE: Creating an account on mainnet is almost identical to testnet but will require initial funding for the account. Here is a guide to mainnet account creation.

It doesn’t matter, when deploying, whether the application is written in Rust or AssemblyScript. All contract code is compiled to WebAssembly and deployed to the network to be run inside a Wasm-compatible virtual machine. You will use a command like yarn dev for most applications but you can just as easily deploy an application using NEAR CLI with near dev-deploy for TestNet (or near deploy if you have already created an account).




	

	
	
		
			
				All contract code is compiled to WebAssembly and deployed to the network to be run inside a _______
			
		

		
					

		
			
			
			
			Sandbox
		
			
			Wasm-compatible virtual machine
		
			
			EVM
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Now, do the following to warm yourself up:

 	Look around in NEAR Explorer. Here you can search for all transactions and blocks produced on NEAR. Try searching for the account you just created and see the transactions you've created.
 	Now install near-cli. This is a command line interface that allows you to interact seamlessly with NEAR. This NEAR docs has all of the near-cli commands with examples.
 	Try running your first command: near login. This will redirect you to your NEAR Wallet and save your testnet account keys locally.

After checking out the testnet, you may feel free to run your local node. However, if you just wanna play around with the codes, then we suggest that you stick to the testnet.
How Do I Run A Node?
As with any blockchain-based ecosystem, NEAR Protocol runs on a collection of publicly maintained computers (or "nodes").

You may decide to run a node of your own for a few reasons:

 	To develop and deploy contracts on a node connected to MainNet, TestNet or BetaNet
 	To develop and deploy contracts on a local (independent and isolated) node (sometimes called "LocalNet").
 	To join a network as a validator running a "validator node"

You can launch NEAR betanet and testnet nodes by installing nearup. You can do so by following the instructions at https://github.com/near/nearup




	

	
	
		
			
				As with any blockchain-based ecosystem, NEAR Protocol runs on a collection of publicly maintained computers called _______
			
		

		
					

		
			
			
			
			Nodes
		
			
			Blockchain
		
			
			Near Protocol
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





Running an Official Node using Docker
By default, NEAR uses Docker to run the client. So, the first thing you do is install Docker and nearup. Now, run your system with this:
nearup betanet
(If you prefer to use TestNet then just replace betanet with testnet in the command above)
You will then be prompted for an Account ID. You can leave this empty if you would just like to run a node. Validators should use the account ID of the account you want to stake with. Following that, you need to enter this code:
Enter your account ID (leave empty if not going to be a validator)
Now, your node will then start in the background with Docker. To check the logs inside Docker, run docker logs --follow nearcore.

Creating A Simple Code On NEAR
NEAR has a list of helpful programs or example codes that you can checkout with ease. So the code that we will be checking out is the Guest Book. Using the program allows you to sign in with NEAR and add a message to the guest book! A starter app built with an AssemblyScript backend and a React frontend. 

Looking Into Guest Book Code
To run this project locally, you need to ensure the following.


 	Make sure you have Node.js ≥ 12 installed (https://nodejs.org), then use it to install yarn: npm install --global yarn (or just npm i -g yarn)
 	Install dependencies: yarn install (or just yarn)
 	Run the local development server: yarn dev (see package.json for a full list of scripts you can run with yarn)

Now you'll have a local development environment backed by the NEAR TestNet! Running yarn dev will tell you the URL you can visit in your browser to see the app.
Oh and make sure that you have the GitHub page open. 
You may find this video useful as well.
https://youtu.be/B6Gc_OQjX9E

Exploring The Code
As you can see there are two sides to the code – backend and frontend:


 	The backend code lives in the /assembly folder. This code gets deployed to the NEAR blockchain when you run yarn deploy:contract. This is a NEAR smart contract.
 	The frontend code lives in the /src folder. /src/index.html is a great place to start exploring. Note that it loads in /src/index.js, where you can learn how the frontend connects to the NEAR blockchain.

Backend Code
#1 Contract Data Model :  assembly/model.ts

[code lang="js"]import { context, u128, PersistentVector } from "near-sdk-as";
/** 
 * Exporting a new class PostedMessage so it can be used outside of this file.
 */
@nearBindgen
export class PostedMessage {
  premium: boolean;
  sender: string;
  constructor(public text: string) {
    this.premium = context.attachedDeposit >= u128.from('10000000000000000000000');
    this.sender = context.sender;
  }
}
/**
 * collections.vector is a persistent collection. Any changes to it will
 * be automatically saved in the storage.
 * The parameter to the constructor needs to be unique across a single contract.
 * It will be used as a prefix to all keys required to store data in the storage.
 */
export const messages = new PersistentVector&lt<PostedMessage>("m");[/code]

Analysis

@nearBindgen marks the class as serializable. Serializable is a marker interface used to "mark" classes so that the objects of these classes may get a certain capability.

The “PostedMessage” class has three features –

 	premium to flag messages with attached NEAR tokens
 	sender to track the signer of the guest book message
 	text to hold the guest book message

Finally, “messages” is a collection of guest book messages stored as a PersistentVector of PostedMessage objects
#2 Contract Behavior :  assembly/main.ts

[code lang="js"]import { PostedMessage, messages } from './model';
// --- contract code goes below
// The maximum number of latest messages the contract returns.
const MESSAGE_LIMIT = 10;
/**
 * Adds a new message under the name of the sender's account id.\
 * NOTE: This is a change method. Which means it will modify the state.\
 * But right now we don't distinguish them with annotations yet.
 */
export function addMessage(text: string): void {
  // Creating a new message and populating fields with our data
  const message = new PostedMessage(text);
  // Adding the message to end of the the persistent collection
  messages.push(message);
}
/**
 * Returns an array of last N messages.\
 * NOTE: This is a view method. Which means it should NOT modify the state.
 */
export function getMessages(): PostedMessage[] {
  const numMessages = min(MESSAGE_LIMIT, messages.length);
  const startIndex = messages.length - numMessages;
  const result = new Array&lt;PostedMessage&gt;(numMessages);
  for(let i = 0; i <  numMessages; i++) {
    result[i] = messages[i + startIndex];
  }
  return result;
}[/code]

Analysis

MESSAGE_LIMIT is used to avoid unbounded calls (ie. potentially expensive) to retrieve guest book messages from storage

We are also using two different public functions in this contract – addMessage() and getMessages()
Frontend Code
#1 Network Connection :  src/config.js

[code lang="js"]const CONTRACT_NAME = process.env.CONTRACT_NAME || 'guest-book.testnet';
function getConfig(env) {
  switch(env) {
    case 'mainnet':
      return {
        networkId: 'mainnet',
        nodeUrl: 'https://rpc.mainnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.near.org',
        helperUrl: 'https://helper.mainnet.near.org'
      };
    // This is an example app so production is set to testnet.
    // You can move production to mainnet if that is applicable.
    case 'production':
    case 'development':
    case 'testnet':
      return {
        networkId: 'default',
        nodeUrl: 'https://rpc.testnet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.testnet.near.org',
        helperUrl: 'https://helper.testnet.near.org'
      };
    case 'betanet':
      return {
        networkId: 'betanet',
        nodeUrl: 'https://rpc.betanet.near.org',
        contractName: CONTRACT_NAME,
        walletUrl: 'https://wallet.betanet.near.org',
        helperUrl: 'https://helper.betanet.near.org'
      };
    case 'local':
      return {
        networkId: 'local',
        nodeUrl: 'http://localhost:3030',
        keyPath: `${process.env.HOME}/.near/validator_key.json`,
        walletUrl: 'http://localhost:4000/wallet',
        contractName: CONTRACT_NAME
      };
    case 'test':
    case 'ci':
      return {
        networkId: 'shared-test',
        nodeUrl: 'https://rpc.ci-testnet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    case 'ci-betanet':
      return {
        networkId: 'shared-test-staging',
        nodeUrl: 'https://rpc.ci-betanet.near.org',
        contractName: CONTRACT_NAME,
        masterAccount: 'test.near'
      };
    default:
      throw Error(`Unconfigured environment '${env}'. Can be configured in src/config.js.`);
  }
}
module.exports = getConfig;[/code]

Analysis

The code above defines the data and endpoints required to connect to the NEAR network. The connection information defined here is included for MainNet, TestNet and BetaNet as well as the default LocalNet configuration
#2 Configuration :  src/index.js

[code lang="js"]import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import getConfig from './config.js';
import * as nearAPI from 'near-api-js';
// Initializing contract
async function initContract() {
  const nearConfig = getConfig(process.env.NODE_ENV || 'testnet');
  // Initializing connection to the NEAR TestNet
  const near = await nearAPI.connect({
    deps: {
      keyStore: new nearAPI.keyStores.BrowserLocalStorageKeyStore()
    },
    ...nearConfig
  });
  // Needed to access wallet
  const walletConnection = new nearAPI.WalletConnection(near);
  // Load in account data
  let currentUser;
  if(walletConnection.getAccountId()) {
    currentUser = {
      accountId: walletConnection.getAccountId(),
      balance: (await walletConnection.account().state()).amount
    };
  }
  // Initializing our contract APIs by contract name and configuration
  const contract = await new nearAPI.Contract(walletConnection.account(), nearConfig.contractName, {
    // View methods are read-only – they don't modify the state, but usually return some value
    viewMethods: ['getMessages'],
    // Change methods can modify the state, but you don't receive the returned value when called
    changeMethods: ['addMessage'],
    // Sender is the account ID to initialize transactions.
    // getAccountId() will return empty string if user is still unauthorized
    sender: walletConnection.getAccountId()
  });
  return { contract, currentUser, nearConfig, walletConnection };
}
window.nearInitPromise = initContract()
  .then(({ contract, currentUser, nearConfig, walletConnection }) =&gt; {
    ReactDOM.render(
      &lt;App
        contract={contract}
        currentUser={currentUser}
        nearConfig={nearConfig}
        wallet={walletConnection}
      /&gt;,
      document.getElementById('root')
    );
  });[/code]

Analysis

This is the meat and potatoes of the frontend section, when you configure connection to NEAR network. You may configure contract interface by injecting wallet connection and wiring up both contract methods.
Deploying A Smart Contract
Every smart contract in NEAR has its own associated account. When you run yarn dev, your smart contracts get deployed to the live NEAR TestNet with a temporary account. If you now want to make it permanent, here’s what you need to do.
Step 0: Install near-cli
Here’s how you globally install near-cli
npm install --global near-cli
This will give you the near CLI tool. Ensure that it's installed with:
near --version
Step 1: Create an account for the contract
Visit NEAR Wallet and make a new account. You'll be deploying these smart contracts to this new account.

Now authorize NEAR CLI for this new account, and follow the instructions it gives you:
near login
Step 2: Set contract name in code
Modify the line in src/config.js that sets the account name of the contract. Set it to the account id you used above.
const CONTRACT_NAME = process.env.CONTRACT_NAME || 'your-account-here!'
Step 3: change remote URL if you cloned this repo
If you fork the repository you will need to change the remote URL to a repo that you have “commit” access to. This will allow auto deployment to Github Pages from the command line.

 	Go to GitHub and create a new repository for this project.
 	Open your terminal and in the root of this project enter the following:

$ `git remote set-url origin https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.git`
Step 4: Deploy!
You just need the following command to deploy your smart contract:
yarn deploy
This command does two things:

 	Builds & deploys smart contracts to NEAR TestNet
 	Builds & deploys frontend contract code to GitHub using gh-pages. This will only work if the project already has a repository set up on GitHub. Feel free to modify the deploy script in package.json to deploy elsewhere.




	

	
	
		
			
				 Every smart contract in NEAR has its own associated ____

			
		

		
					

		
			
			
			
			Token
		
			
			Wallet
		
			
			Account
		
			
			All of above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





What Next?
Alright, now that you know how to run a basic code, you may want to get deeper into NEAR. For that, checkout NEAR’s developer docs.

### What is NEAR protocol?

Expected result: basic understanding on how NEAR works from end-user perspective
NEAR is a decentralized application platform which runs atop the NEAR Protocol blockchain. This blockchain, which runs across hundreds of machines around the world, is organized to be permissionless, performant and secure enough to create a strong and decentralized data layer for the new web,
NEAR’s main mission is to present a platform that’s ideal for running applications that have access to a shared — and secure — pool of money, identity and data which is owned by their users. It combines the features of partition-resistant networking, serverless compute and distributed storage into a new kind of platform.
So, before we go any further, let’s learn some of the backstory and see how blockchain platforms have evolved over time.

The Evolution of Blockchain Technology
Ever since Satoshi Nakamoto released the Bitcoin whitepaper in October 2008, the world has gotten acquainted with the game-changing blockchain technology. Over the last decade, the blockchain has gone through three stages of evolutions.
Generation 1: Bitcoin
Bitcoin is the perfect example of the first-gen blockchain. The purpose of this blockchain is to be a simple and straightforward payment system. Starting out as the “internet’s currency,” Bitcoin has since become one of the most in-demand asset classes. However, there is a major problem when it comes to BTC. It is infeasible to conduct complicated transactions with them which may have several layers of metadata and logic attached to it.
Generation 2: Ethereum and Smart Contract Platforms
Ethereum ushered in the second-gen blockchain platforms with smart contracts. Finally, developers were able to program sophisticated transactions through these smart contracts, and were able to create decentralized applications (dApps). Through these dApps, the blockchain’s use cases went through the roof.
However, this space has been struggling with its growing pains. The main thing is that these blockchains are suffering from severe scalability issues. For example, Bitcoin has a throughput of 7 transactions per second, while Ethereum can only manage 25. When you compare that with PayPal (115 tps) and Visa (1,700 tps), it’s pretty abysmal.
To be fair, Ethereum and Bitcoin have recently been trying to fix these scalability issues with several layer-two solutions like lightning network, raiden, plasma protocol etc. The idea here is to create an additional layer over the underlying blockchain which the main protocol can delegate repetitive and cumbersome tasks too.
However, there are two issues with this approach. Firstly, these layer-2 solutions haven’t yet achieved acceptance from the masses. Secondly, these layer-2 solutions ruin the original architecture of the protocol, which may have long-lasting implications.
This is where the third generation comes in.
Generation 3: NEAR
NEAR is an example of gen-3 blockchains, which aim to solve the scalability issues and allow both the end-users and developers to enjoy the full potential of smart contracts and blockchain technology. Instead of relying on layer-2 tech, NEAR breaks free from the idea that every single node which participates in the network has to run all of the code because that essentially creates one big wasteful bottleneck and slows down all of the other approaches.
To fix this issue, NEAR uses a technique that is already extremely prevalent in the database world - sharding. If properly executed, it allows the network’s capacity to scale up as the number of nodes in the network increases so there isn’t a theoretical limit on the network’s capacity. The best part? Sharding is a layer-1 scalability technique.

What is Sharding?
In a database, you sometimes have to deal with large bulky data. This dramatically hinders performance and throughput and it makes the entire process extremely inefficient.  This is where sharding comes in. 
Sharding does a horizontal partition of your database and turns into smaller, more manageable tables.

So, why a horizontal partition and not a vertical partition?
Consider this table:




A
B
A*B
A/B


1
1
1
1


2
2
4
1


3
3
9
1


4
4
16
1



Now, if we were to partition this table vertically:




A
B


1
1


2
2


3
3


4
4






A*B
A/B


1
1


4
1


9
1


16
1



See that?
Because of the partition, the table turns into two completely different tables. 
As opposed to that, what happens when the table gets partitioned horizontally:
Do you see what happens? When you vertically partition a table they tend to become two completely different tables altogether.
However, if we were to partition them horizontally:




A
B
A*B
A/B


3
3
9
1


4
4
16
1



See that?
A horizontal partition turns the database into smaller tables of the same database. These smaller databases are called shards.

How does Sharding Help Blockchain? 
As we have seen so far, as more and more nodes enter the Ethereum and Bitcoin ecosystem, the entire consensus and verification process takes even more time. Now, what will sharding do to help this?
Sharding is going to break the global state of the blockchain into tinier more manageable shards.
What happens on shard activation?


 	The state gets split into shards
 	Every single unique account is in one shard, and the accounts in that shard will only transact with the other accounts in the same shard.

In simplistic terms, imagine this scenario. There is a hypothetical network with three nodes- A, B, and C and they have to verify data T. The data T is broken down into three shards T1, T2, and T3. Instead of all these nodes working on T as a whole, they can individually work on a shard at the same time. As you can see the amount of time you are saving is exponential.
Unlike a lot of other sharding approaches, which still require nodes to be run on increasingly complex hardware (reducing the ability of more people to participate in the network), NEAR’s technique allows nodes to stay small enough to run on simple cloud-hosted instances.

Why are scalable blockchains like NEAR necessary?
Hint: It’s not all about speed!
When it comes to second and third gen blockchains, what truly determines its innate value is the dapp ecosystem that thrives on top of it. As such, most of these blockchain platforms are in a perpetual competition to attract as many developers as possible. 
However, the problem with the current platforms is that they don’t have the sophistication required to host high quality apps. The issue here is that we have developers trying to create PS4 games on a platform that’s equivalent to Windows 98. As such, they need to heavily compromise on the overall functionality of their dApps.
Plus, there is another factor that should be considered here. Speed is a vital factor when it comes to application usability. After all, why are users going to use an application if it's not usable at all? Developers require a set number of users to continually use their applications before it reaches critical mass.
This is why a blockchain platform that’s scalable like NEAR is important for the mainstream adoption of blockchain and smart contracts.
NEAR allows developers to just deploy their app without thinking too much about how the infrastructure around it operates or scales, which is more like the modern clouds like Amazon AWS or GCP or Azure which drive almost all of today’s web applications.

NEAR Brief history
NEAR started in summer of 2018 upon Alex Skidanov and Illia Polosukhin deciding to pivot away from their previous entrepreneurial adventure, if you’re curious you can read more about it here. Very quickly, as Misha quit MemSQL, the team expanded from several to 9 people within 3 days in August. Initial team consisted of 7 engineers, Erik doing business operations, and Sasha talking to the market.
Today NEAR Collective is the globally distributed group of teams, made up of many individual organizations and contributors, who self-organize in order to bring this technology to life.  It is not a business or anything nearly so formal. Think of it instead like the groups of people who run large open-source software projects.
One of the Collective’s projects is writing the initial code and the reference implementation for the open source NEAR network, sort of like building the rocket boosters on the space shuttle. Their job is to do the necessary R&D work to help the blockchain get into orbit. The code for that chain is open source so literally anyone can contribute to or run it.
It’s important to stress that networks like NEAR are designed to be totally decentralized. This means they ultimately operate completely on their own and can’t actually be censored, shut down or otherwise messed with by third parties… not even the teams who initially built them! So, while members of this collective are here to get the ball rolling on building the reference implementation, they quickly become nonessential to the operation of the network once it has started running.  In fact, once it’s launch-ready, anyone could modify and run the NEAR Protocol code to start up their own blockchain because it’s all open source and any changes would have to be democratically accepted by the independent validators who run it.
NEAR has a diverse team from various backgrounds, consisting of devs and researchers from companies such as Microsoft, MemSQL, Meta, Google, and more. The project also has the backing of over 40 investment firms which include some of the most influential VCs in Silicon Valley, such as Andreessen Horowitz’s a16z, Metastable, Pantera, Ripple’s developer ecosystem project Xspring, and Coinbase. 

Following the mainnet launch, the team at NEAR began work on preparing the groundwork for the adoption phase. 
Development Of The Rainbow Bridge 
The Rainbow Bridge is considered to be the most important bridge in the NEAR ecosystem. The NEAR protocol envisaged the bridge as a trustless and permissionless bridge that enables the transfer of assets between Ethereum, NEAR, and, ultimately, Aurora. The Rainbow bridge allows developers to use Ethereum assets on NEAR seamlessly and NEAR assets on Ethereum. Since the launch of the bridge, developers have used the bridge to transfer over $1 million worth of DAI, ETH, and more. The Rainbow Bridge can also be repurposed and connect NEAR and all Ethereum-compatible chains such as Binance Smart Chain, Polygon, Avalanche, Optimism, Arbitrum, and more. 
Development Of Aurora 
The development of the Aurora EVM is also considered a key milestone in NEAR’s push for adoption. Aurora can be considered the most powerful EVM in existence, taking advantage of the several unique features offered by NEAR. Aurora consists of two core components, the Aurora Engine and the Rainbow Bridge. The Aurora Engine enables the seamless deployment of Solidity and Vyper smart contracts, while the Rainbow Bridge enables the permissionless transfer of assets between Ethereum and Aurora. Compared to Ethereum, Aurora is able to offer fees up to a 1000x lower and host thousands of transactions per second, representing an increase of 50x over Ethereum. 
Private Shards Launch 
In September 2021, NEAR achieved a significant milestone with the launch of Private Shards. These private shards operate as a shard on NEAR, allowing public chain contracts to call into private shard contracts and vice versa. 

Read more about Private Shards on NEAR at Calimero website
Creation Of DeFi Funds 
In October 2021, Proximity Labs announced a $350 million development fund for NEAR. The grant would help build decentralized finance - DeFi applications on NEAR. This was followed by an announcement by the NEAR Foundation, stating that it was creating an $800 million DeFi fund. Blockworks has also announced the launch of a NEAR-focused fund, with plans to raise around $40 million. 
Other Important Developments 
The developments listed above were not the only developments that occurred concerning the NEAR Protocol. 

 	In November 2021, global travel agency Travala.com announced a partnership with NEAR that would see the network token integrated with Travala. 
 	NEAR also announced the launch of Pagoda, a startup platform that would focus on helping developers create apps on NEAR. Following this announcement, NEAR also announced the launch of NEARPay. NEARPay became the first debit card and payments widget on NEAR, bridging fiat and crypto. 
 	NEAR was also selected by OrangeDAO, a crypto collective created by Y Combinator Alumni, as its primary Layer-1 blockchain. 
 	NEAR-native stablecoin $USN launched via Decentral Bank.

How NEAR Blockchain works
The technology underpinning cryptocurrency. Blockchain is a technology that can safely store transaction records on a peer-to-peer network instead of storing them in a single location. Independent servers around the world, called nodes, make up the network that operates the blockchain.

One of the most defining aspects of blockchain technology is decentralization. So, why is decentralization useful? Let’s look at it from the perspective of developers and end users.


 	Developers: In the centralized world, the developers are often at the mercy of cloud platforms or even the government to make sure that they can continue to run the apps. In the decentralized world, there are no domineering intermediaries.
 	End Users: The transparency of decentralized applications can allow users to see the backend code and know exactly how the apps are going to use your personal information.

What is the NEAR consensus algorithm?
Consensus protocols are used to reach agreement on a single value between multiple participants in a system. If all network participants collaborate in accordance with the consensus protocol, new values may be appended to the ledger and verified by nodes. However, in the case of disputes, the network may focus on either safety or liveness.
The consensus mechanism implemented on NEAR is called Nightshade. Nightshade models the system as a single blockchain. The list of all the transactions in each block is split into physical chunks, one chunk per shard. All chunks accumulate to one block. Note that chunks can only be validated by nodes that maintain the state of that shard.
Speaking of validation, a key component of the NEAR are the validators. These validators are responsible for maintaining consensus within the protocol. Validators are specialized nodes that need to keep their servers online 100% of the time while keeping their systems continually updated. 
Here are a few points that you must keep in mind about network validators.


 	NEAR determines its network validators every new epoch, electing them based on their stake.
 	The already elected validators are re-enrolled by automatically re-staking their tokens plus the accrued rewards
 	Potential validators have to have their stake above a dynamically determined level.
 	There are two methods that a validator can use to strengthen their stake – buy the tokens themself or borrow via stake delegation.
 	The reward you receive is directly proportional to your stake. More your stake, more your rewards.

The consensus is based on the heaviest chain consensus. Meaning, once a block producer publishes a block, they collect the signatures of validator nodes. The weight of a block is then the cumulative stake of all the signers whose signatures are included in the block. The weight of a chain is the sum of the block weights. Additionally, the consensus utilises a finality gadget that introduces additional slashing conditions for higher chain security.



	

	
	
		
			
				Express Quiz: The weight of a block is:
			
		

		
					

		
			
			
			
			The maximum stake of the signers whose signatures are included in the block
		
			
			The cumulative stake of all the signers whose signatures are included in the block
		
			
			The average stake of the entire network divided by the number of signers in the block
		
			
			None of the above
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	





NEAR Runtime
Runtime layer is used to execute smart contracts and other actions created by the users and preserve the state between the executions. It can be described from three different angles: going step-by-step through various scenarios, describing the components of the runtime, and describing the functions that the runtime performs.

What is NEAR token?
NEAR token is the fundamental native asset of the NEAR ecosystem and its functionality is enabled for all accounts.  Each token is a unique digital asset similar to Ether which can be used to:


 	Pay the system for processing transactions and storing data.
 	Run a validating node as part of the network by participating in the staking process.
 	Help determine how network resources are allocated and where its future technical direction will go by participating in governance processes.

The NEAR token enables the economic coordination of all participants who operate the network plus it enables new behaviors among the applications which are built on top of that network.

How to start with NEAR?
Account/Wallet
Before you get started with NEAR, the first thing that you want to do is to set up a NEAR account.
Watch this video about NEAR accounts:

The wallet allows you to make contract calls to the blockchain, set up your local node, and send and receive funds from other users. When you register your Account ID, you have to provide a unique name. Although every wallet has to have a unique name, every user can set-up multiple wallets.
You can imagine this similar to a Facebook or Google account. Once you have registered to either of the services, you can use the same account to log into third-party services. The difference between NEAR Account IDs and Google accounts is that the data, stored against an Account ID, is only accessible and manageable by the owner of the wallet. Additionally, all information is stored on a distributed network of nodes instead of a single server.
Create NEAR account right now: https://wallet.near.org/create
More in-depth information about Accounts at DOCS.NEAR

NEAR Explorer
NEAR Explorer allows you to view block creations in real time! This useful tool allows you to search for transactions and accounts allowing you to view all interactions between users and smart contracts.


How to get NEAR tokens?
There are 3 ways to get $NEAR

Earn it
You can earn $NEAR by taking part in development bounties, by running a community which helps people build on NEAR, by winning a NEAR hackathon or otherwise being an active part of the community.  If you are able to attract other people to lend you tokens for staking, you can also earn $NEAR by running a validator.

Buy it
$NEAR is available on several major exchanges (see below), where you can sign up and buy the token using either fiat currency or crypto.
Exchanges which list $NEAR
You can see overviews of pricing and pairs on coinmarketcap and coingecko.
https://www.binance.com/en/my/wallet/exchange/deposit/crypto/NEAR

From a Friend
You don’t have to have a NEAR account to receive NEAR tokens!  The “NEAR Drop” approach allows your friend to pre-fund a new account and send you a hot link to retrieve the tokens.

What can I do with NEAR tokens?
Transfer NEAR
Send $NEAR back and forth between accounts of your and a friend and check out the transactions in the Block Explorer. Because transaction fees are very low, you can quickly and easily move very small amounts of $NEAR to play with it.
Send them as a gift on http://redpacket.near.org/

Try a NEAR Drop (Invite a friend)
Send your friend a NEAR drop if they need to create an account.

Use NEAR Apps
To view the growing list of apps being built on NEAR, click here.
Easy start with NFT- purchase/publish/trade art on https://paras.id/
Play at BerryClub to participate in collective art creation: https://berryclub.io/

How much does it cost to use NEAR (Gas)?
When you make calls to the NEAR blockchain to update or change data, the people running the infrastructure of the blockchain incur some cost. At the end of the day, some computers somewhere process your request, and the validators running these computers spend significant capital to keep these computers running.
Like other programmable blockchains, NEAR compensates these people by charging transaction fees, also called gas fees.
If you’re familiar with web2 cloud service providers (Amazon Web Services, Google Cloud, etc), a big difference with blockchains is that users get charged immediately when they make a call to an app, rather than developers fronting the cost of using all that infrastructure. This creates new possibilities, such as apps that have no long-term risk of going away due to developer/company funds running out. However, it also comes with some usability speed bumps. To help with this, NEAR also provides the ability for developers to cover gas costs for users, to create a more familiar experience to those coming from web2.
When thinking about gas, keep two concepts in mind:


 	Gas units: internally, transaction fees are not calculated directly in NEAR tokens, but instead go through an in-between phase of “gas units”. The benefit of gas units is that they are deterministic – the same transaction will always cost the same number of gas units.
 	Gas price: gas units are then multiplied by a gas price to determine how much to charge users. This price is automatically recalculated each block depending on network demand (if previous block is more than half full the price goes up, otherwise it goes down, and it won’t change by more than 1% each block), and bottoms out at a price that’s configured by the network, currently 100 million yoctoNEAR.

Note that the gas price can differ between NEAR’s mainnet & testnet. Check the gas price before relying on the numbers below.
Thinking in gas
NEAR has a more-or-less one second block time, accomplished by limiting the amount of gas per block. The gas units have been carefully calculated to work out to some easy-to-think-in numbers:
10¹² gas units, or 1 TGas (TeraGas)…
≈ 1 millisecond of “compute” time
…which, at a minimum gas price of 100 million yoctoNEAR, equals a 0.1 milliNEAR charge
This 1ms is a rough but useful approximation, and is the current goal of how gas units are set within NEAR. Gas units encapsulate not only compute/CPU time but also bandwidth/network time and storage/IO time. Via a governance mechanism, system parameters can be tweaked, shifting the mapping between TGas and milliseconds in the future, but the above is still a good starting point for thinking about what gas units mean and where they come from.
Quiz: 1 TeraGas or TGas is equal to:



	

	
	
		
			
				1 TeraGas or TGas is equal to:
			
		

		
					

		
			
			
			
			1 microsecond of compute time
		
			
			10 seconds of compute time
		
			
			1 millisecond of compute time
		
			
			1 nano second of compute time
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	







The cost of common actions
To give you a starting point for what to expect for costs on NEAR, the table below lists some common actions and how much TGas they currently require, and what the fee would be, in milliNEAR, at the minimum gas price of 100 million yN.




Operation
TGas
fee (mN)
fee (Ⓝ)


Create Account
0.42
0.042
4.2⨉10⁻⁵


Send Funds
0.45
0.045
4.5⨉10⁻⁵


Stake
0.50
0.050
5.0⨉10⁻⁵


Add Full Access Key
0.42
0.042
4.2⨉10⁻⁵


Delete Key
0.41
0.041
4.1⨉10⁻⁵



How can I earn with NEAR?
Stake your NEAR
Key to the Proof-of-Stake model is how Validators are supported by the community via Staking. Validators earn NEAR token rewards for operating the nodes which run the network in the form of a static inflation rate of 5% each year, creating new tokens for Validators every epoch (~12 hours) as rewards.
Validators must maintain a minimum amount of Stake to keep their Validator seat. Token holders are able to stake with a particular Validator they believe is performing well for the network and earn a portion of Token rewards generated by the network too. This incentivizes Token holders to stay involved with the community!
The NEAR Wallet now has a staking user interface built directly into the web app.
To Stake:


 	Select “Staking” from the navigation bar (or dropdown on mobile)
 	Click the “Select Validator” button
 	Choose a validator
 	Confirm your choice and select “Stake with Validator”
 	Enter the amount of NEAR you would like to stake, and click “Submit Stake”

You will need to confirm two transactions, one to select the validator, and another to deposit and stake with the validator.
To Unstake:


 	On the staking dashboard (/staking), select your current validator
 	Click “Unstake” and confirm the transaction

After 36 to 48 hours (4 full epochs), you will be able to withdraw your stake. To do so, return to the validator page, and click “Withdraw.”



	

	
	
		
			
				New tokens are created as rewards after epoch which is approximately every:
			
		

		
					

		
			
			
			
			12 minutes
		
			
			12 seconds
		
			
			12 days
		
			
			12 hours
		
	
		

		
		
			
				Correct!
				Wrong!
			
			
		
	

	






Building DeFi On NEAR
The DeFi (Decentralized Finance) ecosystem is on fire. Ethereum currently holds a DeFi network worth more than $100 billion. When it comes to this NEAR, its DeFi ecosystem is still young and growing. 


As per DeFiLlama, the Total Value Locked (TVL) of the NEAR ecosystem is less than $100 million, with Ref Finance being the market leader. The very fact that Ethereum’s DeFi ecosystem is 1000X that of NEAR shows that we are very early when it comes to NEAR DeFi. In fact, in 2021, the NEAR Protocol actually announced an $800 million funding initiative. The majority of the fund is set to grow the protocol’s DeFi sector.

If you want to learn more about NEAR’s DeFi ecosystem, read this.
NEAR’s Growing NFT Ecosystem
A non-fungible asset has a distinct property or properties that set it apart from other assets. Non-fungible tokens are based on non-fungible assets and are unique digital assets that use blockchain technology. Lately, this sector has caught fire and exploded in popularity.

The NEAR Protocol is the perfect platform for NFTs as it has two major advantages over Ethereum:

 	NEAR is significantly faster.
 	Ethereum also has substantially higher gas fees.

These factors make NEAR ideal for buying and selling NFTs. Read this article to know more about the top 7 NFT projects on NEAR.
So, What Now? How Can I Interact With NEAR?
Alright, so what happens next? If you have read this far, you’d probably want to delve deeper into the NEAR protocol. So, the next thing you should do is checkout the NEAR whitepaper. If you are new to the blockchain and want to learn more about the tech itself, you may check out this video on deconstructing the blockchain ecosystem.
Join NEAR Discord server and check NEAR Forum


## Pages

### Redeem nLEARNs - September 15th 2025 9AM ET - opens for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This September  Redeem we are learning about NEAR in 2025
 	Go to this mini-course NEAR in 2025
 	Take every lesson, pass Quizzes (both Easy and Advanced) with (L)Earn AI


 	Take ONE screenshot of a Quiz question

 	Complete course
 	Mint yourself an NFT Certificate
 	Post on X - Studying with Verifiable AI  is the future of learning. Already live at @LearnNEAR 🕺
and attach your screenshot
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting September 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled October, 2025.
Happy (L)Earning!

### Redeem nLEARNs - August 15th 2025 9AM ET - opens for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This August Redeem we are learning how to Read NEAR Intents transaction
 	Read and Like this guide How to read any NEAR Intents transaction (step-by-step)
 	Add your NEAR account that you will use to try Intents and monitor to LNC NEAR Watcher bot https://t.me/nearwatchbot  (hint👉: you just need to type in the account)
 	Go to NEAR Intents https://near-intents.org/
 	Deposit a tiny amount of a token you want to swap and swap it  - say $NEAR into $USDC
 	Check if you get notification by LNC NEAR Watcher

Read the bot message and try to understand the transaction yourself (hint👉: you may also explore transaction at Pikespeak - just click )


 	Click on Explain transaction.
You will be brought to LNC website and (L)Earn AI🕺 will try to explain the transaction

 	Take a screenshot with transaction explanation
 	Post on X - Learning NEAR by doing! NEAR Intents transaction explained by (L)Earn @LearnNEAR
and attach your screenshot
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting August 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled September, 2025.
Happy (L)Earning!

### Transaction Explanation



### Redeem nLEARNs - July 15th 2025 9AM ET - opens for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This July Redeem we are making (L)Earn AI🕺 better by testing Fact Check
 	Read and Like this guide NEAR Protocol: Making AI Transparent and Verifiable
 	Explore NEAR ecosystem X and find a post with fact that you may want to check
 	Click on (L)Earn AI tab and choose Fact Check

 	Paste the fact text and source URL (X post URL) and press Fact Check

 	Review the agent response, Flag it if it is not relevant and nStamp

 	Take a screenshot with nStamp transaction

 	Post on X - Making AI Transparent and Verifiable - superpower of NEAR protocol! I just nStamped this Fact Check agent respond at @LearnNEAR
and attach your screenshot
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting July 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled August, 2025.
Happy (L)Earning!

### partners-learnclub-near LNC

[wpcal id=10]

### efiz-near Collaboration

[wpcal id=9]

### Redeem nLEARNs - June15th 2025 9AM ET - opens for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This June Redeem we are (l)earning together with Intear Wallet💧

 	Read and Like this Guide Introduction to Intear Wallet
 	Go to https://wallet.intear.tech/and create a cool .near account - 💡hint use smth related to tears, like learningtears.near
 	Now create a a subaccount  - smth like alice.learningtears.near

 	Now login to LNC with newly created subaccount - please uncheck
 	Go Intear Wallet  at NEAR Ecosystem, Like it and post or Reply a legit comment

 	Take a screenshot of your comment or reply showing your subaccount smth like alice.learningtears.near

 	Tip the Comment you liked the best
 	Post on X - Just tried Intear Wallet and wow – creating an account & subaccount was a breeze. Now I’m learning with @LearnNEAR. Normies, this is for you!
and attach your screenshot
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting June 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled July 15th, 2025.
Happy (L)Earning!

### debug search ai



### Redeem nLEARNs - May 15th 2025 9AM ET- May 21 AM ET

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This May Redeem we are (l)earning together with (L)Earn AI🕺 - trying ✅Quiz

 	Search, Read and Like any Guide of your choose - the one that you really want to learn
 	Now click on (L)Earn AI🕺 -> ✅Quiz to generate a quiz for you
 	Take a screenshot of the first question
 	Pass the Quiz
 	Post on X - Just tried @LearnNEAR’s verifiable AI—quizzes pop up right in my guide, tailor-made for me. Learning just got a serious glow-up! 🕺
and attach your screenshot
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting May 15, 2025 at 9am ET. Ends on May 21 AM ET
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled June 15th, 2025.
Happy (L)Earning!

### Lnc ai chat bot connect



### Redeem nLEARNs - April 15th 2025 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This April Redeem we are (l)earning together with (L)Earn AI🕺

 	Read and Like this guide about Private Personalized AI agent  💡HINT: now you can ask AI🕺 to summarize guide for you
 	Make AI🕺 assisted comment
 	Ask  AI🕺 about something related NEAR and eco but you believe still missing at LNC learning materials
 	If needed try it several times before you find the gap in the knowledge base
 	Downvote the answer you did not like
 	Take a screenshot of answer you did not like
 	Prepare your version of the answer to make AI🕺 smarter - it must be submitted at the from later during Redeem
 	Post on X - "At @LearnNEAR, we learn with AI — and help it learn too! Every time we give feedback, (L)Earn AI  gets smarter. Win-win-win. "
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting April 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled May 15th, 2025.
Happy (L)Earning!

### March Redeem Issue



### Redeem nLEARNs - March15th 2025 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This March Redeem we are learning more about using nCaptcha at Telegram

 	Read and Like this guide about How nCaptcha Fights Spam  💡HINT: now you can ask AI🕺 to summarize guide for you
 	Go to dedicated Telegram Group Chat LNC March Redeem
 	Take a screenshot of nCaptcha message
 	Pass nCaptcha
 	Post a message - like say Hi to (l)earning friends
 	Follow nCapcha on X
 	Post on X - "web3 tools are win+win+win. I just passed @ncaptcha_xyz and I like it. - spam, + RevShare"
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting March 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled April  15th, 2025.
Happy (L)Earning!

### Redeem nLEARNs - February 15th 2025 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This February Redeem we are learning more about user owned AI

 	Read and Like this guide about (L)Earn AI agent on NEAR AI
 	Go to https://app.near.ai/agents. Find learn_near_comments_agent and STAR IT⭐!!!
 	Write a comment, polish it with (L)Earn AI🕺and post it
 	Take a screenshot of your comment
 	Post on X - "NEAR is blockchain for AI.  Verifiable (L)Earn AI agent available at @LearnNear"
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting February 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled March 15th, 2025.
Happy (L)Earning!

### Redeem nLEARNs - January 15th 2025 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	NEW! Ask (L)Earn AI legit questions at least twice a month and provide feedback (👍 or 👎)
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This January Redeem we are learning more about user owned AI

 	Read and Like this guide about (L)Earn AI agent on NEAR AI
 	Go to https://app.near.ai/agents. Find learn_near_agent and STAR IT⭐!!!
 	Leave a meaningful  comment
 	Take a screenshot of your comment
 	Post on X - "NEAR AI aims to become platform for verifiable AI.  Check in how it is useful for learning at @LearnNear"
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting January 15, 2025 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled February 15th, 2025.
Happy (L)Earning!

### Top learners 2024

LNC Top (L)Earners in 2024

### debug



### Redeem nLEARNs - December 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This December Redeem we are learning about how to play net positive game with AI

 	Read, watch short video and Like this guide about What Is GPT And How Does It Work and Why Users Matter.
 	qVote (vote at quadratic poll) for Your Personal Data
 	Read and Tip comments you like
 	Leave a meaningful  comment (hint: ask NEAR AI to help you, review and adjust generated to fit more to what you think)
 	Take a screenshot of your comment
 	Post on X - "AI is here to stay. And I started learning how play net positive game with it at  @LearnNear"
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting December 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled January 15th, 2024.
Happy (L)Earning!

### Redeem nLEARNs - November 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This October Redeem we are learning how to use NEAR CLI (Command Line Interface)

 	Read and Like this guide about Using Your Ethereum Wallet on NEAR.  Leave a comment if you think it is cool (hint: ask NEAR AI to help you)
 	Install Ethereum wallet (Metamask recommended)
 	Create Ethereum account
 	Login to LNC website using  Ethereum Wallet
 	Go to your LNC profile
 	Take a screenshot
 	Post on X - "Chain Abstraction is REAL! I just started learning NEAR with my Ethereum account ! Great job @auroraisnear  @LearnNear "
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting November 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled December 15th, 2024.
Happy (L)Earning!

### (L)Earn

📚(L)Earn🕺



(L)Earn is a method with the goal to make learning fun and rewarding.Instead of charging people for getting new knowledge and skills we do the opposite - we give micro-bonuses to those who learn.We do believe that EARN is integrated part of LEARN - you earn new knowledge, skills, make new connections with similar people and building solid foundation for real EARNINGS via future participation in ecosystem.



The decentralized NEAR AI infrastructure represents a significant step forward in enabling user-owned AI. By offering transparency, control, and flexibility, NEAR AI empowers users to interact with AI agents in a way that ensures data privacy and fosters trust.



As a learner, you’re invited to actively participate in this innovative (L)Earn ecosystem. Ask the (L)Earn AI relevant questions, pay with nLEARNs, gain knowledge, and earn nLEARNs by contributing to the AI’s improvement.(L)Earn score - amount of nLEARNs project gets as learners interact with learning materials perfectly reflects how much interest it gets from the community.





Join 1,211,666 (L)Earners🕺



From web3 enthusiast to Rust engineers, from gamers to professional translators, tens of thousands LNC (L)Earners from around the globe are (l)earning together.




Start NOW!










nLEARNs ›



 







💸Redeem to NEAR ›



 







📚(L)Earn Guides›



 









📣Share with Friends ›



 







💁‍♂️Tip and get tipped ›



 







🗳Have your say ›



 









⚗Incubate your project ›



 







👀BugEye ›



 







🕺 (L)Earn with AI ›



 










LNC Featured Partners











Why become 📚(L)Earner🕺?




Why starting (l)earning makes sense?It is FREE!  It is FUN! It is Rewarding!Stop wasting your time and brain power watching stupid videos.Try (l)earning and thank us later!






Read more about nLEARNs

### Redeem nLEARNs - October 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This October Redeem we are learning how to use NEAR CLI (Command Line Interface)

 	Read and Like this guide about NEAR CLI.  Leave a comment if you think it is cool (hint: ask NEAR AI to help you)
 	Install  NEAR CLI on your computer
 	Run NEAR CLI
 	Using interactive mode View account summary for the account of your choice
 	Take a screenshot
 	Post on X - "
NEAR CLI is super easy to use! 🙌 Huge kudos to @NEARDevHub for building such a great tool and to @LearnNear for making it accessible to normies! 🚀"
and attach your screenshot
 	Extra activity - try to create a subaccount!
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting October 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled November 15th, 2024.
Happy (L)Earning!

### Near AI



### Redeem nLEARNs - September 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This September Redeem we are checking revolutionary on-boarding via sponsored transactions by Bitte.

 	Read and Like this guide about Bitte paymaster.  Leave a comment if you think it is cool (hint: ask NEAR AI to help you)
 	Invite your friend using your referral.
 	Ask them to use Bitte wallet and Create new account. They should be able to login seamlessly.
 	Ask them to Confirm referral.
 	Ask them to mint LNCer NFT (this time we cover the transactions) so it is FREE
 	Ask them to set LNCer NFT as profile picture.
 	Find your friend at LNC members directory.
 	Take a screenshot with their name and profile (must be LNCer NFT)
 	Post on X - "My friend just become  (L)Earner @LearnNear. This is next level of onboarding! Kudos to @BitteProtocol for making this real🙏 "
and attach your screenshot
 	Extra activity - mint an LNCer NFT if you don't have yet!
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting September 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled October 15th, 2024.
Happy (L)Earning!

### Redeem nLEARNs - August 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 4 nLEARN within 7 days since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This August Redeem we use NameSky as prediction - vote for your Candidate for US President

 	Go to NameSky voting page https://www.namesky.app/2024-potus
 	Cast your vote for the candidate of your choice by liking  the NFT
 	Take a screenshot of the NFT you liked
 	Post on X - "Another cool thing you can do with NEAR accounts as NFTs - check this out.  Live @NameSkyApp, project from LNC Barrel @LearnNear "
and attach your screenshot
 	Extra activity - maker an offer to NFT of your choice to get a chance to OWN this historical account!
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 150, the rest  350 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting August 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled September 15th, 2024.
Happy (L)Earning!

### Moon redeem



### Wheel of Transactions NEAR Testnet

Read this Guide and try to future of NEAR blockchain by launching transactions batch!
We have reserved some 🤑NEAR🤑 to be distributed among participants!
🕺NOW IS TIME TO LAUNCH 🚀
And may the force be with you!

Congrats to all NEARians!
Nightshade 2.0 is live on NEARP Mainnet!
Claim your reward for testing NEAR now!

### Moon Quiz

Good job, 🌔(l)earners🕺 5,000 have passed the NanoQuiz!
Redeem opens July 25, 9am EDT
Redeem

### Submit project to 👀BugEye sprint

nCaptcha Transaction
                        
                        
                            
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Telegram @(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Desirable 👀BugEye sprint start date
                            
                            MM slash DD slash YYYY
                        
                        Tell us few words about your project(Required)Checklist to prepare for 👀BugEye sprint(Required)
								
								Join LNC Telegram group*
							
								
								Prepare GDoc with test requirements**
							
								
								Confirm 👀BugEye sprint dates
							
								
								Mint a (L)Earner NFT similar to this***
							
								
								Support 👀BugEyers at LNC Telegram group
							Once the 👀BugEye sprint  ended entries will be emailed/DMed to youLink to GDoc with 👀BugEye requirements(Required)
                    
                *LNC Telegram group
 	** 👀BugEye sprint requirements - you may refer to this example  
 	***👀BugEye (L)Earner NFT example this

### LNC Hot NanoQuiz Claim tech issues form



### Redeem nLEARNs - July 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This July we take it easy. Just post on X why you like Learn NEAR Club, smth like:
"The best thing about Learn NEAR Club @LearnNear is ..."

 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting July 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled August 15th, 2024.
Happy (L)Earning!

### Redeem nLEARNs - June 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This June we will support our partner Meteor wallet!
 	Please read this Guide Introduction to Harvest $MOON
 	Tip the Author
 	Answer Quizzes
 	Like the Guide
 	Read the comments and tip the ones you liked
 	Take a screenshot of the comment you tipped
 	Post on X - "(L)Earners are talking about ''Introduction to Harvest $MOON'' by  @MeteorWallet at Learn NEAR Club @LearnNear"
and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting June 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled July 15th, 2024.
Happy (L)Earning!

### Welcome Firedrop #1 claim



### Redeem nLEARNs - May 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This May we gonna try NameSky - Buy & Sell NEAR accounts as NFTs!

 	Login to NameSky
 	Go to NameSky Marketplace
 	Find the NFT with NEAR name that you like the MOST
 	Like it

 	Make a screenshot
 	Post on X - "I love this NEAR account NFT at @NameSkyApp, project from @LearnNear Barrel"
and attach your screenshot and a link to that NFT - shall look similar to this: https://namesky.app/passbook.near
 	Extra activity - make an offer to this NFT
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting April 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled June 15th, 2024.
Happy (L)Earning!

### Что такое nLEARNs?

Что такое nLEARNs?



 



nLEARNS — это внутренние баллы Learn NEAR Club



nLEARNs НЕ являются токенами и НЕ имеют денежной стоимости.LEARNs это мини-стипендии/бонусы для лучших (L)учеников.



Как авторы, так и учащиеся получают вознаграждение в nLEARNs во время обучения.




















Как зарабатывать nLearns?





Регулярно посещайте Learn NEAR Club



Делитесь полезными гайдами в Х



Приводите друзей по партнерской программе





Читайте гайды и отвечайте на вопросы



Учитесь на курсах — проходите этапы, отправляйте задания, сдавайте тестирование



Делайте разумные комментарии





Как тратить nLearns?





Оплачивайте программы/курсы



Учавстуйте в квадратичных опросах





Давайте чаевые авторам гайдов и курсов и комментариев



Обменивайте на $NEAR во время редима










Вниманию злоумышленников и спамеров



ПОЖАЛУЙСТА, ПОЖАЛУЙСТА, ПОЖАЛУЙСТА!



НЕ тратьте впустую свой талант, время и энергию, пытаясь фармить nLEARNs, перескакивая от гайда к гайду, отправляя БЕСПОЛЕЗНЫЕ отзывы и НЕПРАВИЛЬНЫЕ задания. Это приведёт к сокращению Ваших nLEARNs.







LearnNEAR.Club — это платформа будущего обучения. Приглашаются и приветствуются все, но в LearnNEAR.Club нет места для "ПЛОХИХ" учеников.



Happy (L)Earning!

### 🗡Wheel of Transactions Second Round🚀

UPDATE: The second round of LNC Attack of Transactions of NEAR stateless network is over! We are analyzing results and will post results early next week!
Read this Guide and try to future of NEAR blockchain by launching transactions batch!. We have reserved some NEAR to be distributed among participants!
You can spin the Wheel of Transactions once an hour.
⚔NOW IS TIME FOR ATTACK OF TRANSACTION🚀
And may the force be with you!

### 🗡Wheel of Transactions Second Round🚀

UPDATE: The second round of LNC Attack of Transactions of NEAR stateless network is over!  Claim redeem
Read this Guide and try to future of NEAR blockchain by launching transactions batch!
You can spin the Wheel of Transactions once an hour.
⚔NOW IS TIME FOR ATTACK OF TRANSACTION🚀
And may the force be with you!

### Redeem nLEARNs - April15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This April we gonna try how Ecommerce paired with NFT - WooNFT store powered by Mintbase wallet!

 	Read this Guide NFT art for WooCommerce products , Like it, Tip the Author
 	On your Android phone or iOS device visit WooNFT store - https://woonft.art/shop/
 	Simulate the order (you are not buying T-short for real) and claim free NFT (this one is real)
 
 	Create new account via Mintbase Wallet
 	Make a screenshot of your NFT at your Mintbase wallet
 	Post on X - "I just got my first @WooCommerce NFT via @mintbasewallet at @woonft_art online store during @LearnNear Redeem" and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Limited number of (L)Earner NFT holders have 2 hours priority access to Redeem - first come, first served!
 	This time we cap the priority access by 100, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting April 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled May 15th, 2024.
Happy (L)Earning!

### Reward claim agreement



### Wheel of Transactions

UPDATE!
The first round of LNC Attack of Transactions of NEAR stateless network is over! Pool of 100 NEAR to be distributed among top 400 participants. Check if you qualified  to claim here. 

In the rapidly evolving world of blockchain technology, keeping up with the latest developments can feel like trying to drink from a firehose. One of the most exciting updates making waves recently is the NEAR Protocol’s announcement of its Phase 2 Sharding launch. But what does this actually mean for you and me?

Read this Guide and try to future of NEAR blockchain by launching transactions batch!
You can spin the Wheel of Transactions once an hour.
We have reserved some NEAR to be distributed among participants!
⚔NOW IS TIME FOR ATTACK OF TRANSACTION🚀
And may the force be with you!

### Redeem nLEARNs - March15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	This March we learn about Chain Abstraction!
 	Read carefully this Guide Embracing Web3 Through Chain Abstraction: A Path to Digital Self-Sovereignty

 	Answer the micro quizzes
 	Leave a meaningful comment about the most interesting and appealing topic (💡Hint - you may ask AI to help you with the comment)
 	Take a screenshot of your comment!
 	Xpost (tweet) "This is what I learned about Chain Abstraction @LearnNear" and attach your screenshot
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 250, the rest  250 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting March 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled April 15th, 2024.
Happy (L)Earning!

### lolson-near Lolson

[wpcal id=7]

### mywalletmy-near near

[wpcal id=6]

### wathercat24-near q

[wpcal id=5]

### Top learners 2023

LNC Top (L)Earners in 2023

### Redeem nLEARNs - February 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	NEW! This February we founded the LNC HOT village!
 	Have your Telegram ready on the phone, desktop or web app.
 	Explore this guide
 	Join LNC Hot village
 	Take a screenshot!
 	Xpost (tweet) "I just joined @LearnNear  LNC HOT village. Thank you, @here_wallet  for such a cool community building initiative! #BuiltOnNear"
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 300, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 700 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting February 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled March 15th, 2024.
Happy (L)Earning!

### Join LNC Mods team

nCaptcha Transaction
                        
                        
                            
                        Name(Required)
                            
                            
                                                    
                                                    Your name
                                                
                            
                            
                            
                        Email(Required)
                            
                        Long Description(Required)Tell us about yourselfX
                    
                https://twitter.com/yourpoject

### Recent comments

Explore the latest discussions within our ecosystem through the most recent comments.
Wanna become LNC Mod? Join here
👍Tip legit comments  👎Untip so-so ones

### Redeem nLEARNs - January 15th 2024 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	NEW! This January we are rating comments at Guides and Ecosystem projects!
 	Go to a Guide or Project you like.
 	Explore comments
 	Tip the best one and Untip the worst one
 	Take a screenshot!
 	Xpost (tweet) "I just tipped good comment and untipped bad comment at LNC Talks @LearnNear #BuiltOnNear"
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 300, the rest  400 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 700 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting January 15, 2024 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled February 15th, 2024.
Happy (L)Earning!

### Redeem nLEARNs - December 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 80 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	NEW! This December we are choosing the best project at NEAR Ecosystem gallery!
 	Go to NEAR Ecosystem
 	Find your find your favorite project.
 	Like it and leave a comment about it
 	Take a screenshot!
 	Xpost (tweet) "I just choose my favorite project at NEAR Ecosystem gallery by @LearnNear #BuiltOnNear"
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 300, the rest  200 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting December 15, 2023 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled January 15th, 2024.
Happy (L)Earning!

### hpanon-mintbase-near Regata Dona Maria

[wpcal id=4]

### Submit your project to NEAR Ecosystem

nCaptcha Transaction
                        
                        
                            
                        Name(Required)
                            
                            
                                                    
                                                    Your name
                                                
                            
                            
                            
                        Email(Required)
                            
                        Project name(Required) Short Description(Required) Long DescriptionCategory(Required) Website
                    
                X
                    
                https://twitter.com/yourpojectLogo(Required)Max. file size: 20 MB.Careers/Jobs

### Built on Near



### Redeem nLEARNs - November 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	NEW! This November we are testing 3-in-1: Near easy on-boarding, sponsored transactions with HERE Wallet and Near as Datachain with nStamp!
 	Create a new named account at HERE wallet - FREE!
 	Sign in to LNC with newly created account.
 	Fill this form with nStamp - 1 transaction is FREE!
 	Take a screenshot!
 	Xpost (tweet) "I just nStamped at @LearnNear my form submission to NEAR DA (Datachain) for FREE  with @here_wallet #BuiltOnNear"
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting November 15, 2023 at 9am ET.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled December 15th, 2023.
Happy (L)Earning!

### LNCer NFT

LNCer NFT



You Pick, You Name, You Mint!



Generate your unique LNCer until you like it!



Name your LNCer - say, "Pop Dancer"



Mint cost: FREE after NEAR 101 course completion











About LNCer NFT Collection



LNCer NFT collection is a collab between LNC community and one of the best award winning graphic designers in Europe.Art concept is based on dynamic human intelligence diversity powered by uniqueness of every learner.Every NFT minter is invited to creatively participate in this project:- Generate and pick posture of the graphic character crafted by design genius- Give name to your creature- Curate your personal unique collection



 



Get your LNCer now





    
        
    
    

        
            Connect wallet to
                mint your (L)Earner!
        

        
             Generate 
        

        
            
                
                    
                
            
            
                Mint *
            
        

        

    



    Your (L)NCER Gallery
    


            
                Please login to Mint (L)Earner NFT
                
                
                   Logout
                
            



Quick Facts









Community Generated



LNC  LNCer  NFT project connects every minter's creativity with graphic design genius.Read more









Free



Frees after NEAR 101 course completion, only gas fee required









FIVE NFTs



Limited 5 (FIVE) NFT per account - you can use them in any way you like - Proof of Achievement, Gifts, etc.

### Form submission nStamp verification



### Redeem nLEARNs - October 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	NEW! Mint Own LNCer NFT- treat it as LNC membership card - MUST HAVE! Set it as your LNC profile if you do not have (L)Earner NFT
 	You will be asked to upload screenshot and provide a link to your LNCer NFT during redeem quiz
 	Own (L)Earner NFT if redeemed 2 times or more - treat (L)Earner NFT as Premium Membership
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting September 15th.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled November 15th, 2023.
Happy (L)Earning!

### Test nstamp

nStamp Example
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Your name(Required) Your NEAR Account(Required) Email(Required)
                            
                        URL to your Tweet(Required)
                    
                Your thoughts and Suggestions after testing new feature project, What did you like the best, What did you like the least?(Required)What we can do to make this product better?Submit with nStamp

### Redeem nLEARNs - September 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Think about What you want to (l)earn next to get ready for Redeem quiz.
It can be new Guide, Course, NEAR project to try, anything else you want LNC to prepare for you
 	You will need to post your suggestion on X-Twitter as comment to this post
https://twitter.com/LearnNear/status/1702647800985497705
If you do not have access to X-Twitter, vote and leave a comment why you do not have it about here
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting September 15th.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled October 15th, 2023.
Happy (L)Earning!

### Courses



### Redeem nLEARNs - August 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Read this Guide "How to prepare for NEAR Wallet changes"
 	Have your say by qVoting here
 	Migrate at least one of your accounts from wallet.near.org to MyNearWallet/Meteor or HERE wallet@ncaptcha_xyz on Twitter
 	Have TWO screenshots ready to upload - one before migration and another one after
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting August 15th.
It takes 2 business days to process submissions so come to claim NEAR here in 2 business days.
Next Redeem Window is scheduled September 15th, 2023.
Happy (L)Earning!

### Become a part of BugEye

Join BugEye
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Tell us few words about your project(Required)NEAR Account to manage project profile and rewards(Required)

### LNC for projects: BugEye

LNC for projects: 👀BugEye







There are over 2,000 LNC members who participate in 👀BugEye - community user testing platform for  projects from LNC Barrel and other NEAR Ecosystem projects.







Rewardsin NEAR tokens











 Featured 👀BugEyers



                            
                    
                                                arjasepp
                    
                
                            
                    
                                                chuoichuoi
                    
                
                            
                    
                                                coldy
                    
                
                            
                    
                                                cuongdcdev
                    
                
                            
                    
                                                davletuner
                    
                
                            
                    
                                                duchieniu
                    
                
                            
                    
                                                fritzwagner
                    
                
                            
                    
                                                harrynguyen
                    
                
                            
                    
                                                keny
                    
                
                            
                    
                                                lovelysugar
                    
                
                            
                    
                                                lovesontungmtp1
                    
                
                            
                    
                                                malaysia88
                    
                
                            
                    
                                                rmlsnk
                    
                
                            
                    
                                                sahista4341f
                    
                
                            
                    
                                                that83
                    
                
                            
                    
                                                volodymyr_matseliukh.tg
                    
                
                            
                    
                                                wabinab
                    
                
                            
                    
                                                xxx911
                    
                
                        




How it works



Runs 27/7, all you need is just set a link at your website or app and let community explore, find issues and submit.






https://youtu.be/xKiLSJElwGU




web3 tooling protects you form spam submission.And you decide how much to reward!But don't be to greedy - testers will loose interest you break win-win-win rules!














Join 👀BugEye as Project  ›







Submit 👀BugEye Issue  ›













Done by HUMANS



👀BugEyers are seasoned NEAR builders and users.









Bring Awareness



👀BugEye is LNC community initiative so your project is being introduced the entire LNC Community of 90K+ (L)Earners









web3 powered



Reports and awards are running via NEAR smart contract, web3 spam submissions protection





👀BugEyed Projects





















Loved by NEAR Ecosystem



Do not expect your community to work hard for your project as core team does. For free. Instead, provide users with meaningful and respectful inceptives for contribution. At LNC we use 👀BugEye - community micro-bounty platform. #web3=win+win+winLNC

### 👀Submit Issue



### Approval



### Partner Redeem nLEARNs to Meta

In order to participate in Partner Redeem nLEARNs to $Meta, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 4 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Explore learning Guides about MetaPool

 	Leave a cool comment at one of the Metapool guides and make a screenshot
 	Follow @meta_pool  at Twitter
 	Tweet your screenshot with this text  "(L)Earning with @meta_pool is fun and rewarding!"
 	(L)Earner NFT holders have 2 hours priority access to Redeem
 	This time we cap the priority access by 90, the rest  10 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 100 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting June 23. Please expect to process the $Meta tokens within 2 business days.
Happy (L)Earning!

### Redeem nLEARNs - July 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Read this Guide about NCaptcha
 	Have your say by qVoting here
 	Follow @ncaptcha_xyz on Twitter
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting May to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled August 15th, 2023.
Happy (L)Earning!

### O que é nLEARNs?

What are nLEARNs?



 



nLEARNS são os pontos internos do Learn NEAR Club que dão impulso à economia (L) Earning. 



nLEARNS “NÃO” são tokens e “NÃO” têm valor monetário. Pense nos nLEARNs como mini-bolsas de estudos/benefícios para (L)Earners (alunos) excepcionais. 



Tanto os criadores quanto os alunos recebem recompensas em nLEARNs durante o aprendizado.
















O caso do uso definitivo de nLEARNs é a Prova de (L)Earn. Qualquer histórico de (L)Earner pode ser verificado para que os membros ou projetos da comunidade possam ter uma ideia sobre a consistência do progresso de aprendizagem.





The ultimate use case of nLEARNs is Proof of (L)Earn. Any (L)Earner history can be verified so community members or projects can get an idea about how consistent is the learning progress. 





Como ganhar nLearns?





Visite Learn NEAR Сlub regularmente



Compartilhe guias úteis



Indique um amigo pelo programa de afiliados (encontre-o no seu LNC profile)





Leia Guias e aprove os testes



Aprenda nos cursos – complete os passos, envie as tarefas, responda os testes receba  dicas nLEARNs no LNC do Telegram para ajudar seus colegas





Como empregar nLearns?





Fazer stake para se inscrever em  Programa/Curso



Resgatar ofertas especiais de parceiros NEAR



Participar em enquetes de Votação Quadrática





Premiar Autores de guias e cursos



Enviar como agradecimento a  dicas nLEARNs no LNC do Telegram pela ajuda de seus colegas



Resgatar para Ⓝ durante Janelas de resgate










Atenção Sybil Attackers e Spammers



Por favor, por favor, por favor!



“NÃO” desperdice seu talento, tempo e energia tentando colher nLEARNs saltando o Passo a Passo, enviando feedback INÚTIL e tarefas FALSAS. O comportamento malicioso resultará na perda de nLEARNs.







LearnNEAR.Club é uma plataforma de Aprendizado para o Futuro. Todos são convidados e bem-vindos, mas não há lugar para inescrupulosos no palco da SUMA POSITIVA.



Portanto, faça sua lição de casa e volte quando estiver pronto para o Futuro da Economia Aberta.



Feliz (L)Earning!





Get the latest from LNC



Connect your LNC account to LNC Notifier Telegram bot and get notified about Beta Test Sprints and other opportunities to (L)Earn.

### New nCpatcha test

new nCaptcha test
                            
                         
 
                        Untitled

### Redeem nLEARNs - June 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral
 	Read about a Guide about NEAR FastAuth 
 	Create an account using FastAuth
 	Follow @partners.learnclub.near at near.org
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 250, the rest  100 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 350 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting May to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled July 15th, 2023.
Happy (L)Earning!

### Top LNC Authors



### Redeem nLEARNs - May 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times or more
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral. Check this requirements at our Telegram.
 	Mint at least one of your coolest near accounts and put it on Sale at NameSky
 	Follow @NameSkyApp on Twitter
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting May to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled June 15th, 2023.
Happy (L)Earning!

### Beta test claim



### Redeem nLEARNs - April 15th 2023 9AM ET- Open for 12 hours

Update April 18: We opening 100 more slots instead of those who participated in Twitter share abuse.
In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	Invite at least 2 friends(accounts) to Join LNC and ask them to confirm referral. Check this requirements at our Telegram.
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 350, the rest  150 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting April 15th, 2023 at 9am ET.
Once summited your offer please give us some time to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled May 15th, 2023.
Happy (L)Earning!

### Redeem nLEARNs - March 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	Invite at least 2 friends(accounts) to Join LNC and ask them to mint a LNC referral NFT . Check this requirements at our Telegram.
 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 233, the rest  100 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 333 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting March 15th, 2023 at 9am ET.
Once summited your offer please give us some time to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled April 15th, 2023.
Happy (L)Earning!

### Sputnik authorize



### qVotes - quadratic voting polls



### Demo nLearns page

nLearnsCaptchaDemo
                            
                         
 
                        Untitled nLearnsCaptcha
							
						nLearnsCaptcha collects a small amount on nLearns to prevent spam.

### Ask (L)Earner AI



### FAQ by (L)Earner AI

Search for:
                    
                    
                    
                    
                
                
            
        
                
                                                    
                Explain me what is an args Object in Javascript and an example of how to use an Array instead as an argument in a function

                
                                             vaceituno.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        An args Object is a JavaScript object that contains a list of arguments and their respective values that can be passed to a function. It is often used to pass a set of known arguments to a function, without having to explicitly specify each argument.An example of using an Array instead as an argument in a function would be:function myFunc(arg1, arg2, arg3){ //do something}var arr = [arg1, arg2, arg3];myFunc(...arr);                    
                
            
                                
                Please explain the syntax of transactions in NEAR in detail, particularly about data formats

                
                                             vaceituno.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        In NEAR transactions are written using a reducer-based language that allows for complex transactions consisting of operations and queries. Transactions are organized into a series of reducers that are responsible for making changes to the blockchain state, called a Contract Action. A Contract Action is composed of three general parts: 1. A set of operations that instruct the NEAR virtual machine to do something;2. A set of queries that make sure that the operations are valid; and 3. A set of changes that specify which parts of the state need to be updated.Operations in a transaction are written in JSON format and represent a call to the NEAR VM function with an array of arguments. Queries are also written in JSON format and represent read-only methods that can be used to check the current state of the blockchain before making a change. Changes are written in tuples and consist of a set of instructions like "add x to y" or "move y to x".Each reducer is associated with a fee, that is paid directly to the Merkle tree for each operation completed. This fee is used to incentivize miners to create valid blocks. In addition to the fee, users can also attach a bonus to the transaction to further incentivize miners to include the transaction in the block. With the new NEAR Protocol, transactions are faster and more efficient. Instead of using an on chain transaction scripting environment, the protocol supports a JavaScript-like scripting language, allowing developers to interact with the blockchain more intuitively. This language is also more secure, as its syntax is much more restricted and eliminates many opportunities for malicious code.                    
                
            
                                
                Making thehumanity apowerful brain

                
                                             decodingmarsnear.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Making humanity a powerful brain means creating opportunities for people to collaborate and learn from each other. This could be done by making sure everyone has access to the necessary education, technology, and tools to effectively and collaboratively share their knowledge and experiences. This could be supported through initiatives such as open source and coding education, as well as training courses on project management and other collaboration-promoting activities, such as peer-to-peer mentorship. Additionally, providing platforms that facilitate collective thinking and creativity, such as collaborative Design Thinking tools, could make the collective brain of humanity more powerful.                    
                
            
                                
                Explain learning from neuro science perspective? How do people learn?

                
                                             partners.learnclub.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Learning from a neuroscience perspective refers to the study of the biological processes that underlie learning and memory. It involves understanding how the nervous system acquires, stores, and recalls information and behavior over time. It seeks to explore the underlying neurological mechanisms that result in changes in behavior as a result of practice, experience, and environmental stimuli. People learn through a combination of input from the senses, existing knowledge, and mental processing. This input is used to form neural connections in the brain that facilitate learning and storage of information. The more people interact with experiences, the more neural pathways are created and strengthened in the brain, enabling more effective and efficient learning. Additionally, the environment, personality, motivation and emotion can all impact the learning process.                    
                
            
                                
                How about Near ecosystem to day

                
                                             stephenmai88.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        The Near Protocol ecosystem is continuing to evolve and grow. Every day, users and developers are exploring ways to use the platform and finding ways to benefit from it. From the novel Proof-of-Stake consensus mechanism to its built-in digital wallet and recent token launch, Near is becoming increasingly popular as a platform for developers, entrepreneurs, and users. It has also become a platform for digital asset trading with emerging decentralized exchanges. Companies such as Earbird, NEAR Anchors, and Nearby Exchange are just a few of the applications built on the Near platform. As the NIP-7 governance proposal is in the process of finalization and the token launches of several new applications take place, the Near team and ecosystem will continue to build and bring new use cases.                    
                
            
                                
                nguyen dinh cuong

                
                                             2020va2022.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Nguyen Dinh Cuong is a Vietnamese doctor, lecturer and researcher. He graduated from the Medical University of Hanoi, holding the degree in Doctor of Medicine in 1989. He specializes in the field of Internal Medicine and Cardiology, and he did a residency program at the National Cardiology Hospital in Hanoi from 1990-1994. In 1994, he began teaching at the Medical University of Hanoi and in 1995, he became a lecturer. He was appointed professor at the Medical University of Hanoi in 2002, and professor of the Academy of Medical Sciences Vietnam in 2004. He is currently the director of the Hanoi Heart Institute, the Department of Cardiology of the Vietnam National Institute of Heart and Tropical Diseases, the Vietnam National Institute of Cardiology, and a professor at the Medical University of Hanoi. His research interests include cardiorespiratory physiology, pharmacology and pathophysiology, with particular emphasis on pathways controlling hypertension, myocardial infarction, and coronary heart disease.In addition to being an esteemed academic, Prof. Cuong is also involved with numerous medical organizations, including being a board and council member at several cardiology research institutes since 1993. He is a fellow of both the American College of Cardiology and the European Society of Cardiology. He has authored dozens of academic papers and was awarded numerous prestigious awards in the field of Cardiology, including the Golden Mouse Award from the Vietnam Ministry of Health, the Golden Stethoscope Award from the Ministry’s Ho Chi Minh City Medicine Association, and the Vietnam National Medical Association’s Outstanding Achievement Award. He has also received prestigious awards for teaching and for his contributions to the advancement of cardiology and internal medicine in Vietnam, including the Vietnam National Medical Association’s Outstanding Teaching Award, the Vietnam Union of Science and Technology Associations’ Teaching Excellence Award, and the Vietnam Academic Alliance in Cardiology’s “Sun of Medical Science and Technology” Award.  Prof. Cuong has played a critical role in the development of Cardiology in Vietnam and is a respected leader in his field. He is an inspiration to the medical community in Vietnam and a testament to hard work and dedication.                    
                
            
                                
                How to make near ecosystem grow up?

                
                                             duongntsav.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        1. Promote species diversity: Plant more native species such as trees and shrubs that are appropriate for the local environment. Increase the number of species in the system to create a more diverse atmosphere.2. Protect existing wildlife: Introduce protective measures to help conserve existing species. Ensure that threatened species are protected from overexploitation and preserve their habitats.3. Reduce environmental impacts: Minimize human-induced environmental damage. Try to reduce pollution, fertilizers, and pesticides, as well as stop soil erosion, deforestation, and invasive species.4. Introduce beneficial species: Introduce species that can help revitalize a near ecosystem. For example, choosing species that act as natural pest control or that provide shade or food for wildlife.5. Restore habitats: Restore habitats that are damaged by human activity or natural events. Repair wetlands, plant trees, and reintroduce native species to encourage a healthy ecosystem.6. Manage resources: Proper management of natural resources within the ecosystem is a critical aspect of keeping the ecosystem healthy. Monitor activities in the environment to ensure that resources are being used responsibly and sustainably.                    
                
            
                                
                Robot, help me

                
                                             nearwallets27.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        I am here to help you. What would you like me to do?                    
                
            
                                
                Do you know namesky

                
                                             liaa.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        ?Namesky is a website that provides name search services. It helps people to find and purchase a unique name for their business, product, or brand.                    
                
            
                                
                How to Write Better Prompts and Questions for Chat GPT?

                
                                             futured.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        1. Make sure that the questions and prompts you provide are clear and specific. Avoid overly long questions or vague language.2. Make sure that the questions and prompts are phrased in a way that stimulates an interesting response from the chatbot. Ask questions that require a more detailed or thoughtful response.3. Use relevant keywords and phrases to help the chatbot understand the context of the conversation and respond more accurately.4. Give the chatbot enough time to process the conversation and come up with a response. Don't rush the conversation and don't bombard the chatbot with too many questions.5. Don't be afraid of using humor or sarcasm in your questions. It may help to keep the conversation more lighthearted and engaging.6. Challenge the chatbot by asking more open-ended questions. This encourages more creative thinking and allows the chatbot to delve into more interesting topics.                    
                
            
                                
                why near ecosystem is too small, how we can grow up

                
                                             dang95.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        near ecosystem?Near Ecosystem can be grown up by encouraging more developers to join the Near Protocol. This can be achieved by motivating developers to use their resources to create tools and applications on top of the Near Protocol, promote the growth of its community, and look for new ways to further develop the platform. Other ways to grow the Near Ecosystem include hosting events, participating in hackathons, and creating educational materials to teach people about the Near Protocol and its capabilities. Additionally, creating partnerships and collaborations to bring more businesses and developers into the fold would open the door for more innovation.                    
                
            
                                
                What future updates do we expect from the New Learn NEAR Club?

                
                                             lover98.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Future updates from the New Learn NEAR Club could include more in-depth video tutorials, discussions and projects tailored to specific areas of blockchain and NEAR, as well as new resources and events to facilitate deeper learning. There may also be new courses and certifications offered to members, and more opportunities to attend local workshops and meetups. Additionally, more expert-led Q&A sessions, hackathons and other competitions could be organized to foster collaboration among members.                    
                
            
                                
                New Learn NEAR Club updates?

                
                                             grom25gr.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Learn NEAR Club recently updated their online platform to make it easier for users to explore the world of decentralized apps (dAPPs). They have added new tutorials, resources, and integrations to help developers get started building on NEAR. Additionally, they recently launched an ambassador program to engage the NEAR community and promoteNEAR globally. In the future, they plan to add more educational resources to the platform.                    
                
            
                                
                What products will have WEB3 from Near itself?

                
                                             kot1337.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Near Protocol provides a suite of products with WEB3 capabilities, including: - Near Contract Interface (NCI), the contract-level and user-level APIs - Near Developer Library (NDL), the foundation that enables seamless account management and contract deployment- Near Explorer, a block explorer specifically built for the Near protocol - Near Wallet, a crypto wallet providing security, insurance and user experience optimization- Near Studio, a browser-based IDE for developing smart contracts                    
                
            
                                
                In which WEB3 projects, Near makes a strong bet?

                
                                             alexander2804.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Near makes strong bets in the following WEB3 projects:1. Decentralized Finance (DeFi): Developing a decentralized platform to enable frictionless financial services and DeFi applications such as lending, savings and trading.2. Governance: Creating a digital democracy where people can vote on key decisions, such as resource allocations and upgrades to the network.3. Privacy and Security: Establishing a secure network for communication and transaction privacy with tools such as zero-knowledge proofs and encryption algorithms.4. Identity: Designing tools for digital ID profiles that enable secure identity management, KYC/AML compliance, and more.                    
                
            
                                
                What is Learn NEAR Club?

                
                                             partners.learnclub.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Learn NEAR Club is an online learning community for developers, designers, and entrepreneurs who are interested in building products on the NEAR blockchain network. Members have access to community-created resources, education sessions, and support from the NEAR team.                    
                
            
                                
                Why people say GM at Twitter?

                
                                             partners.learnclub.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        GM is a common acronym on Twitter that stands for "Good Morning." People often use this acronym to greet others, especially in the early morning hours. It is a polite way to start a conversation and a friendly way to say hello.                    
                
            
                                
                What is blockchain?

                
                                             partners.learnclub.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Blockchain is a distributed public ledger that records and verifies digital transactions involving cryptocurrencies or other digital assets. It is a decentralized, distributed, and public ledger of every cryptocurrency transaction that is verified and stored in chronological order through an encrypted network. Each subsequent transaction is linked to the previously verified one in order to create an immutable chain of data. This technology is used to create secure and efficient digital financial infrastructure, making it a revolutionary new technology in many industries.                    
                
            
                                
                What is Ref.Finance?

                
                                             futured.near
                                        
            
                
                    
                        
                            
                            
                            2 nL
                            
                            4 nL
                            
                            8 nL
                        
                        👍Tip 2 nL
                    
                
            
        
                                
                

                
                    
                        Ref.Finance is a web-based platform designed to help financial advisors focus on client acquisition and retention. The platform provides a range of features including insights into customer behavior, campaign tracking, analytics and reporting, marketing automation, and comprehensive client relationship management. Ref.Finance enables advisors to efficiently and effectively serve their clients and grow their businesses.

### LNC for NEAR projects: Display

LNC for NEAR projects: Display



 



There are about 900+ projects built on NEAR.



LNC is the best place to introduce your project to NEAR users who loves NEAR and actually uses NEAR.



 

















Inform HUMANS



LNC members are real people who loves NEAR and USE NEAR.









Bring Awareness



Your banner will be displayed to the entire LNC Community of 50K+ (L)Earners for a week









Performance Reports



Views and clicks report will be provided






How it works



Just prepare your banner and LNC takes care of the rest.

### Redeem nLEARNs - February 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	Invite at least 5 friends(accounts) to Join LNC. Check this requirements at our Telegram. Please take screenshots of your profile as evidence

 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 400, the rest  100 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting February 15th, 2023 at 9am ET.
Once summited your offer please give us some time to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled March 15th, 2023.
Happy (L)Earning!

### Top (L)Earn NEAR projects of year 2022



### Redeem nLEARNs - January 15th 2023 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	Refer at least 2 friends to Join LNC. Check this requirements at our Telegram. Please take a screenshot of your profile as evidence

 	(L)Earner NFT holders have 2 hours priority access to Redeem.
 	This time we cap the priority access by 400, the rest  100 will be available at 9 am ET to everyone. This way seems to be more fair  - recently joined learners get a chance to redeem too.
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting January 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled February 15th, 2023.
Happy (L)Earning!

### Redeem nLEARNs - December 15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Joined LNC at least 2 weeks ago
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	Complete NEAR Power User course and mint NFT certificate. Check this for help
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting November 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and come to claim NEAR here within 2 business days.
Next Redeem Window is scheduled January 15th, 2023.
Happy (L)Earning!

### Top NEAR Dapps used by Sweatcoin accounts active in October 2022



### partners-learnclub-near Contact LNC

[wpcal id=3]

### coldy-near My test event

[wpcal id=2]

### Funds Distribution Report October 2022

NEAR accounts active in October 2022
 

### Funds Distribution Report September 2022

NEAR accounts active in September 2022
 

### ahsas.near

CalenD: Schedule a call in web3 manner
[wpcal id=1]

### CalenD

CalenD Schedule a call in web3 manner by requiring mini-deposits.



If you hold (L)Earner NFT just go your profile page and create you CalenD event


Fee free to come with questions and suggestions to LNC Telegram

### Custom data analytics report request

Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Please describe briefly what kind of report you need(Required)nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.

### First Dapps Used

First Dapps Used by users with new NEAR accounts.
Learn NEAR Club asked Datus if it is possible to figure out what are the very first steps made by newly created NEAR accounts.

Bellow please find the results aggregated by month.

Interested to get your own custom report for your project? Please use this form.

 

 

### Datus

Dashboards and deep dive analysis on NEAR protocol

### Redeem nLEARNs - November 15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 2 hours starting December 15th, 2022 at 9am ET.
(L)Earner NFT holders have priority 2 hours earlier access.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled December 15th, 2022.
Happy (L)Earning!

### ntest

ntest
                            
                         
 
                        Untitled nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.

### 15 Minute Meeting

[wpcal id=1]

### LNC for NEAR projects

(L)Earn for NEAR projects



As a community (L)Earning platform LNC has some pretty cool offers to help NEAR Ecosystem projects to bring their products to thousands of NEAR users.(L)Earn score  - amount of nLEARNs project gets as learners interact with learning materials perfectly reflects how much interest it gets from the community.










Start NOW!










🌌Add your Project ›



 







📚Publish your Guide ›



 







👀BugEye Sprint ›



 









🌐Translate your Guides ›



 







📣Display your banner›



 







🏗Publish your Course ›



 









⚗Kickstart your project ›



 







👀BugEye ›



 











1,211,666 LNC hungry (L)Earners waiting!



From web3 enthusiast to Rust engineers, from gamers to professional translators, tens of thousands LNC (L)Earners are ready to read your Guides, take your courses, translate your learning materials in to 10 languages, beta test and code review your Dapp! 








LNC Featured Partners











Why become (L)Earning Partner?




Why partnering with LNC makes sense?Because we use our very one (L)Earn method that encourages proactive learners and vets out "free-honey" seekers.Try it and you'll like it!






Read more about (L)Earn method and nLEARNs

### Redeem nLEARNs - October 15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Own (L)Earner NFT if redeemed 2 times
 	For security purposes number of participants is limited to 500 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting October 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled November 15th, 2022.
Happy (L)Earning!

### Learn NEAR Club

Pelajari cara menggunakan dan membangun diatas NEAR dan menghasilkan NEAR



"Semua platform orientasi langsung secara inklusif ke Protokol NEAR atau terhubung langsung ke NEARProyek ekosistem kepada anggota member yang proaktif melalui metode (L)Earn.Didukung oleh NEAR Foundation."








Panduan orientasi








Bergabung dengan para 1,211,666 LNC (L)Earners



Dari para penggemar hingga pengembang yang berpengalaman melalui partisipasi dalam spektrum luasdari kehidupan nyata. Blockchain ini diatur agar bersifat permissionless, berkinerja baikdan cukup aman untuk membuat lapisan data yang kuat dan terdesentralisasi untuk menjadi web baru.




Ekosistem NEAR






Saat berinteraksi di LNC, Anda akan menerima nLearns, yakni poin internal dari LNC.Lihatlah ini sebagai bonus untuk para pelajar yang luar biasa.Happy (L)Earning!!






Pelajari lebih lanjut tentang nLEARNs







Mulai menggunakan






Panduan NEAR ›



 







Kursus NEAR ›



 







Tentang nLEARNs ›



 






(L)Earning bersama dengan
























































Courses



Program Sertifikasi Developer NEAR



Ini merupakan kesempatan untuk para web developer untuk mendapatkan sertifikat kelulusan yangmewakili kemampuan untuk merancang, mengembangkan, menguji, dan menerapkan smart contract diPlatform NEAR - Sertifikasi Developer NEAR (NCD).




Pelajari selengkapnya




 






Panduan Terbaru






Semua panduan›




Mulai belajar sekarang






Stake: 16 nL



11 lessons



Build With NEAR



Basic course




Enroll NOW ›















Dapatkan info terkini dari LNC



Connect your LNC account to LNC Notifier Telegram bot and get notified about Beta Test Sprints and other opportunities to (L)Earn.





Connect NOW

### Claim redeem



### LNC for NEAR projects: Publish

LNC for NEAR projects: Publish



 



There are about 900+ projects built on NEAR.



LNC is the best place to introduce your project to NEAR users who loves NEAR and actually uses NEAR.



The more (l)earners interact with project learning materials, the high (L)Earn score project gets



Authors also receive nLEARNs if their learning materials being read and used by (L)Earners.















Featured Authors



                            
                    
                                                adriaparcerisas
                    
                
                            
                    
                                                ai.learnclub
                    
                
                            
                    
                                                aspiro
                    
                
                            
                    
                                                birchmd
                    
                
                            
                    
                                                bugeye.built-on
                    
                
                            
                    
                                                chefsale
                    
                
                            
                    
                                                cryptovaibhav
                    
                
                            
                    
                                                ctraltf
                    
                
                            
                    
                                                cuongdcdev
                    
                
                            
                    
                                                dan_web3
                    
                
                            
                    
                                                dashasha
                    
                
                            
                    
                                                davletuner
                    
                
                            
                    
                                                donganh
                    
                
                            
                    
                                                ek
                    
                
                            
                    
                                                fridmarr
                    
                
                            
                    
                                                frol
                    
                
                            
                    
                                                gyan
                    
                
                            
                    
                                                inna_everstake
                    
                
                            
                    
                                                kamil_nightly
                    
                
                            
                    
                                                meta-pool-official
                    
                
                        




How it works



Just prepare your content and follow the process - LNC takes care of the rest.




Submit to Publish  ›











Write for HUMANS



LNC members are real people who loves NEAR and USE NEAR.









Bring Awareness



Your Guide or Article will be introduced the entire LNC Community of 1M+ (L)Earners via ALL possible channels - LNC website, X, Telegram, email, push notification, and most important - referring to friends.









Fast Submission



Fast and easy content submission process





Partners Guides/Articles

### Redeem nLEARNs - September 15th 2022 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	Owns (L)Earner NFT if redeemed 2 times
 	For security purposes number of participants is limited to 1,000 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting September 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled October 15th, 2022.
Happy (L)Earning!

### LNC for projects: 👀BugEye sprint

👀BugEye sprint







There are about 450+ LNC members who participate in 👀BugEye sprints for projects from LNC Barrel and other NEAR Ecosystem projects.







Rewardsin NEAR tokens











Featured LNC 👀BugEye sprinters🕺



                            
                    
                                                arjasepp
                    
                
                            
                    
                                                chuoichuoi
                    
                
                            
                    
                                                coldy
                    
                
                            
                    
                                                cuongdcdev
                    
                
                            
                    
                                                davletuner
                    
                
                            
                    
                                                duchieniu
                    
                
                            
                    
                                                fritzwagner
                    
                
                            
                    
                                                harrynguyen
                    
                
                            
                    
                                                keny
                    
                
                            
                    
                                                lovelysugar
                    
                
                            
                    
                                                lovesontungmtp1
                    
                
                            
                    
                                                malaysia88
                    
                
                            
                    
                                                rmlsnk
                    
                
                            
                    
                                                sahista4341f
                    
                
                            
                    
                                                that83
                    
                
                            
                    
                                                volodymyr_matseliukh.tg
                    
                
                            
                    
                                                wabinab
                    
                
                            
                    
                                                xxx911
                    
                
                        




How it works



Runs on-demand, 3 days long 👀BugEye sprint, with a goal to provide early feedback to LNC Pro Barrel and other NEAR Ecosystem projects and rewarding participants with NEAR tokens. Up to 10 NEAR per meaningful submission, the rate can vary as per requirements.




Submit your project  ›











Done by HUMANS



👀BugEye sprinters are real people who loves NEAR and USE NEAR.









Bring Awareness



Test Project is being introduced the entire LNC Community of 90K+ (L)Earners via ALL possible channels - website, Twitter, email, push notification, and most important - referring to friends.









Fast Reports



👀BugEye sprint reports are ready within 24 hours after sprint is completed.





Tested Projects

















































































Loved by NEAR Ecosystem



"Toolblox is not a traditional end-user DApp but more like a SaaS application which allows anybody to create smart contracts without any coding skills. We were skeptical about the testing but in the end were pleasantly surprised.We got a lot of feedback about our documentation being very helpful and understandable, the usability was touted and we managed to extract 11 new ideas or improvements which we can now implement. Furthermore we got some cool ideas which we hadn't thought about internally.In retrospect it was a good idea to ask participants to invent a novel workflow and share it on Twitter - even though we did not get a lot of beta testers in numbers the additional social media boost was a nice bonus."Toolblox



Past 👀BugEye sprints

### Redeem nLEARNs - August15th 2022 9AM ET- Open for 12 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 1,000 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting August 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled September 15th, 2022.
Happy (L)Earning!

### (L)Earn Quizzes

(L)Earn Quiz is a super efficient and meaningful on-boarding tool. 



 
















Main Features









Perfect for IRL events



Just prepare a QR and access codes to for a draw









Loved by community



Nothing feels better than getting new knowledges combined with a  small bonus









Reward with



$NEAR, your own token and/or NFT






Schedule





Ref.Finance - TBD






+ Add to google calendar






 Passed (L)Earn Quizzes





NEAR Space at ETHCC 2022 hold by NEAR UA













Ended







Get the latest from LNC



Submit your email and get notified about Beta Test Sprints and other opportunities to (L)Earn.

### Learn NEAR Club

Aprenda como usar e construir em NEAR e ganhar NEAR



Plataforma de integração prática com tudo incluído para o protocolo NEAR - conectando o NEARProjetos de ecossistemas para membros pró-ativos da comunidade através do método (L)Earn.Apoiado pela Fundação NEAR.








Comece com






Guias NEAR ›



 







Cursos NEAR ›



 







Sobre nLEARNs ›



 









Cursos



Programa de Desenvolvedor Certificado NEAR



Esta é uma oportunidade para os desenvolvedores da web ganharem um certificado de conclusão querepresenta a capacidade de projetar, desenvolver, testar e implantar contratos inteligentes noPlataforma NEAR - NEAR Certified Developer (NCD)




Aprenda mais




 







Ao interagir no LNC, você receberá nLearns, pontos internos do LNC.Olhe para eles como um bônus para alunos excepcionais.Bom aprendizado!






Leia mais sobre nLEARNs







Aprendendo junto com






















































Junte-se a 1,211,666 LNC (L)Earners



"De entusiastas a desenvolvedores experientes, participando de um amplo espectro de atividades da vida real. Este blockchain é organizado para ser sem permissão, com desempenho e seguro o suficiente para criar uma camada de dados forte e descentralizada para a nova web"




Ecossistema NEAR





 



 



Guias de integração







Guias mais recentes






Todos os guias ›




Vamos começar a aprender






Stake: 16 nL



11 lessons



Build With NEAR



Basic course




Enroll NOW ›















Receba as últimas novidades do LNC



"Envie seu e-mail e seja notificado sobre sprints de teste beta e outras oportunidades para (L)Earn."

### LNC NEAR SocialFi Playground

Disclaimer: everything on NEAR testnet has no monetary value and is being used for testing and learning ONLY.



LNC NEAR SocialFi Playground




Get hands-on experience with web3 token tools on NEAR Testnet



Play nice and safe with tokens EXCLUSIVELY on NEAR testnet!








Explore LNC NEAR SocialFi  Guides







Start playing with






 



Mint your token ›







 



Sell your token ›







 



Token Swap ›







 



Run DAO ›












Playing NEAR SocialFi together with:





















 



NEAR DeFi Guides

### Submit your project to LNC Pro Peer review

Peer review my project
                            
                         
 
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Tell us few words about your project(Required)nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.

### Redeem nLEARNs - July15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 300 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting July 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled August 15th, 2022.
Happy (L)Earning!

### LNC Pro Authors Guide requirements

LNC is community learning platform so we are focusing on the content that helps learners to acquire new knowledge and skills related to web3 and NEAR.

 	Please explore a couple of Guides here
 	Recommended length: 5-7 reading minutes
 	Guide shall include in-guide mini quizzes to help learners to comprehend major concepts
Usually we have 2 multi-choice and 2 True/False questions
 	Guide shall have a LNC branded feature image. Find LNC logo here
Recommended size 1200x536 pixels
 	Login to LNC website with your NEAR account to be added as Author. As LNC Pro Author you will be able to get nLEARNs for viewing your content including quizzes.\
 	Mint your self a (L)Earner NFT and set is as profile pic
 	Join LNC Telegram group

### LNC Pro Beta test procedure

Review the Beta Test info page
 	Submit your project details
 	Join LNC Telegram group
 	Prepare test requirements - you may refer to this example  and send to LNC
 	Confirm Beta Test sprint dates
 	During test sprint please provide the following
- Support testers at LNC Telegram group
- Tip testers with nLEARNs who asks questions
 	Once the test sprint ended a consolidated test feedback will be emailed
 	Choose ONE top quality feedback tester and up to 20 good ones and send to LNC to process rewards
 	Mint a (L)Earner NFT similar to this and send to the best feedback tester
 	Send some NEAR to the feedback testers you like the most

### SocialFi

Coming soon

### Claim 256 LNC tokens on testnet to play on SocialFi playground

LNC tokens are issued on NEAR testnet for learning purposes and have NO value.



Hey (L)Earner!



We are launching LNC SocialFi imitative with a goal to provide learners with opportunity to play with tokens on NEAR testnet exclusively.



LNC token was created with initial allocation and vesting conditions and crowd sold on TokenHub, SocialFi learning platform from LNC Barrel.



So today we are opening 72 hours Claim Window - Every (L)Earner is entitled to claim 256  LNC tokens on testnet.





 

### Redeem nLEARNs - June15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 200 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting June 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled July 15th, 2022.
Happy (L)Earning!

### Redeem nLEARNs - TEEEST

[Content is password protected]

### (L)Earner NFT

(L)Earner NFT



You Pick, You Name, You Mint!



Generate your unique (L)Earner until you like it!



Name your (L)Earner - say, "Pop Dancer"



Mint cost started from 2 $NEAR in September 2022 and gradually increases as collection grows.Current minting cost is ~2.94 NEAR.











About (L)Earner NFT Collection



(L)Earner NFT collection is a collab between LNC community and one of the best award winning graphic designers in Europe.Art concept is based on dynamic human intelligence diversity powered by uniqueness of every learner.Every NFT minter is invited to creatively participate in this project:- Generate, pick posture and colors of the graphic character crafted by design genius- Give name to your creature- Curate your personal unique collection







Get your (L)Earner now





    
        
    
    

        
            Connect wallet to
                mint your (L)Earner!
        

        
             Generate 
        

        
            
                
                    
                
            
            
                Mint
            
        

        

    



    Your (L)Earners Gallery
    


            
                Please login to Mint (L)Earner NFT
                
                
                   Logout
                
            



Quick Facts









Community Generated



LNC (L)Earner NFT project connects every minter's creativity with graphic design genius.Read more









Affordable but not Free



The cost of minting is set to 2 $NEAR for the first 250 mints so it is supposed to be affordable for every Learn NEAR Club member.Minting cost is gradually increasing with every mint and will reach 10 $NEAR for (L)Earner #10,000 mint.









Capped 10,000 NFTs



Even there are unlimited combinations of (L)Earner postures and colors, we decided to cap the collections at 10K.This helps to balance availability and scarcity.









LNC Benefits




Priority 2 hours earlier access to Redeem to NEAR window



Early access to (l)earning materials



4 weeks login session



Proof of (L)Earn NFTs



Personal CalenD



Priority response at LNC Telegram



more to come ...

### LNC AMA



### Nmans



### Redeem nLEARNs - May15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 250 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting April 15th, 2022 at 9am ET.
Once summited your offer please give us some time to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled June 15th, 2022.
Happy (L)Earning!

### Learn NEAR Club

Verdiene Near während du lernst, wie die NEAR nutzen und darauf entwickeln kannst



Das All-inclusive-Onboarding-Plattform für das NEAR-Protokoll verbindet NEAR Ökosystem-Projekte mit pro-aktiven Community-Mitgliedern über die (L)Earn-Methode.Sie wird unterstützt von der NEAR Foundation.








Beginne mit






NEAR Anleitungen ›



 







NEAR Kursen ›



 







Über nLEARNs ›



 









Courses



Zertifizierter NEAR Entwickler Progemm



Dies ist eine Gelegenheit für Webentwickler ein Abschlusszertifikat zu erwerben, das die Fähigkeit nachweist, Smart Contracts zu entwerfen, zu entwickeln, zu testen und auf der NEAR-Plattform zu deployen - NEAR Certified Developer (NCD)




Erfahre mehr




 







Tritt 1,211,666 LNC (L)Earners bei



Vom Enthusiasten bis zum erfahrenen Entwickler über die Teilnahme an einem breiten Spektrum von Aktivitäten im wirklichen Leben. Diese Blockchain ist so organisiert, dass sie erlaubnisfrei, leistungsfähig und sicher genug ist, um eine starke und dezentralisierte Datenebene für das neue Web zu schaffen.




NEAR Ökosystem





 



(L)Earning zusammen mit



 














































Während Du auf LNC interagierst, erhältst Du nLearns, LNC-interne Punkte. Betrachten Sie diese als Bonus für herausragende Lerner.



Viel Spaß beim (L)Earning!






Lies mehr über nLEARNs







Leitfäden für das Onboarding







Neueste Anleitungen






Alle Anleitungen ›




Lasst uns anfangen zu lernen






Stake: 16 nL



11 lessons



Build With NEAR



Basic course




Enroll NOW ›















Erfahre das Neueste vom LNC



Trage Deine E-Mail ein und lass Dich über Beta-Test-Sprints und andere Gelegenheiten zum (L)Earnen informieren.

### Redeem nLEARNs - April15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 32 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 300 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting April 15th, 2022 at 9am ET.
Once summited your offer please let us 48 hours to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled May 15th, 2022.
Happy (L)Earning!

### LNC Barrel - NEAR project Incubator

LNC Barrel - NEAR project Incubator







LNC exclusive boutique incubator for all kind of projects: NEAR DeFi, NEAR Games, NEAR NFTs, etc.







Best in the industry mentorship.Business development and marketing support.












How it works



Runs 24/7 year round exclusive boutique NEAR incubator for cherry picked projects running by NEAR Certified Developer course graduates and NEAR hackathons participants



The main goal of LNC Barrel is to help NEAR Doers to bring their projects to NEAR mainnet and help them to get dedicated and engaged users.



Projects at LNC Barrel get priority access to Translators, BugEye Sprints, P2P Security review and Security Audits by LNC Partners.




Apply Now ›











HUMAN RELATIONSHIPS 



LNC Barrel projects get connected with real people who loves NEAR and USE NEAR.









Bring Awareness



LNC Barrel Project is being introduced the entire LNC Community of 1M+ (L)Earners via ALL possible channels - website, Twitter, Discord, email, push notification, and most important - referring to friends.









Fun and Engaging Environment



Having your project at LNC Barrel is definitely be a life changing opportunity for NEAR developer/entrepneur.









⚗️ Projects Brewing at LNC Barrel        
            
                
                    
                        
                                                            
                                                                    
                                                                                        
                                    WooNFT                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    👀BugEye                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    nStamp                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    NEAR WordPress                                
                                                    
                    

                            
        

                
    
        



🏆 Projects Brewed at LNC Barrel        
            
                
                    
                        
                                                            
                                                                    
                                                                                        
                                    NameSky                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    CalenD                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    nCaptcha                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Coinsender                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    LNC Community Bot                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Datus                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    nSpot                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    DeepGreen                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    dWork                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    TokenHub                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    LNC NEAR watcher                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Dapplets Project                                
                                                    
                    

                            
        

                
    
        



⏸️ Projects On-hold        
            
                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Fundue                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Glass Fund                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    SmartTips                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Nephilim                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    Haher                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    dSuite                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    NEATAR                                
                                                    
                    

                
                    
                        
                                                            
                                                                    
                                                                                        
                                    NEAR Message System

### Wheel of Demo

This is demo. You will not get any rewards using it

### LNC Pro Peer Review

Learn NEAR Club Pro Peer Review



 



This a very minimum requirement to get your NEAR project ready for Mainnet launch.







Rewards in NEAR tokens processed via projects DAOs. Check an example.











 Featured LNC Pro Reviewers



                            
                    
                                                coldy
                    
                
                            
                    
                                                harrynguyen
                    
                
                            
                    
                                                kalloc
                    
                
                            
                    
                                                rmlsnk
                    
                
                            
                    
                                                vans163
                    
                
                        




How it works



Runs on-demand, by your LNC peers - NEAR Fortified Developers, with a goal to check if the project is built according to best practices and eliminate possible flaws and issues before launch on mainnet.




Submit your project  ›











Done by LNC NFDs



LNC Pro Reviewers are experienced NEAR Fortified Developers who loves NEAR and USE NEAR.









Friendly Process



LNC Pro Peer Review is done internally at LNC. So you do not have to perfectly polish your code, comments and docs to be ready for 3rd party. 









Cost Efficient



Security audits of blockchain projects are very costly - starting from $20K.With LNC Pro Peer review projects pay directly to your Peer (L)Earner.





Reviewed Projects






























                
                        
                            Peer review my project
                            
                         
 
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Tell us few words about your project(Required)nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.

### Redeem nLEARNs - March 15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 300 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting March 15th, 2021 at 9am ET.
Once summited your offer please let us 48 hours to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled April 15th, 2022.
Happy (L)Earning!

### Learn NEAR Club

Apprenez à utiliser et à développer NEAR et gagnez NEAR



Plateforme d'intégration pratique tout compris au protocole NEAR - reliant les projets de l'écosystème NEAR aux membres proactifs de la communauté via la méthode (L)Earn.










Commencer avec






NEAR Guides ›



 







NEAR Cours ›



 







À propos des nLEARN ›



 









Courses



Programme de développeur certifié NEAR



Il s'agit d'une opportunité pour les développeurs Web d'obtenir un certificat d'achèvement qui représente la capacité à concevoir, développer, tester et déployer des contrats intelligents sur la plate-forme NEAR - NEAR Certified Developer (NCD)




Apprendre plus




 







Rejoignez 1,211,666 LNC (L)Earners



Des passionnés aux développeurs expérimentés en participant à un large éventail d'activités réelles. Cette blockchain est organisée pour être sans autorisation, performante et suffisamment sécurisée pour créer une couche de données solide et décentralisée pour le nouveau Web




Écosystème NEAR





 



(L)Gagner ensemble avec



 














































En interagissant sur LNC, vous recevrez des nLearns, des points internes LNC. Considérez-les comme des bonus pour les apprenants exceptionnels. Joyeux gain !






En savoir plus sur les nLEARN







Guides d'intégration







(L)Gagnez AUJOURD'HUI🕺






Tous les guides ›




Lets start learning






Stake: 16 nL



11 leçons



Build With NEAR



Basic course




Inscrivez-vous MAINTENANT ›















Recevez les dernières nouvelles de LNC



Soumettez votre e-mail et soyez informé des sprints de test bêta et autres opportunités de (L)Gagner.

### NEAR Fortified Developers

Total 13 certified members 
        
                                            
                    
                        
                                                        alsakhaev.near
                        
                    
                

                                            
                    
                        
                                                        ilyar.near
                        
                    
                

                                            
                    
                        
                                                        daothang.near
                        
                    
                

                                            
                    
                        
                                                        harrynguyen.near
                        
                    
                

                                            
                    
                        
                                                        cryptovaibhav.near
                        
                    
                

                                            
                    
                        
                                                        coldy.near
                        
                    
                

                                            
                    
                        
                                                        vans163.near
                        
                    
                

                                            
                    
                        
                                                        rmlsnk.near
                        
                    
                

                                            
                    
                        
                                                        kalloc.near
                        
                    
                

                                            
                    
                        
                                                        chestedos.near
                        
                    
                

                                            
                    
                        
                                                        liaa.near
                        
                    
                

                                            
                    
                        
                                                        xsb.near
                        
                    
                

                                            
                    
                        
                                                        yoshi-tech.near

### Certificate viewer



### Bounty

Coming soon!

### Learn NEAR Club

Узнай, как использовать НИР и как разрабатывать на НИРе.Учи НИР, зарабатывай НИР!



Learn NEAR Club - платформа, цель которой привлечение новых пользователей и разработчиков в НИР протокол!Метод (L)Earn позволяет выявить и заинтересовать наиболее активных и заинтересованных членов коммюнитии познакомить их с проектами из экосистемы НИРа.Поддерживается NEAR Foundation.








Начни с 






NEAR Гайды›



 







NEAR Курсы›



 







Подробнее о nLEARNs›



 






Начни учиться!






Стейк: 2 nL



5 уроков



Продвинутый ПользовательNEAR



Курс для начинающих




Запишись сейчас ›














Присоединяйся к 1,211,666 LNC (L)Earners



LNC коммьюнити включает в себя весь спектр - энтузиасты и холдеры, бета-тестеры и переводчики, фронт-енд и бэк-енд разраработчки - любой может активно участвовать в  мероприятиях LNC и зарабатывать НИР.




Экосистема НИРа





 



(L)Earning вместе с



 














































Принимая активное участие в LNC мероприятиях, ты получешь nLearns, LNC поинты.Happy (L)Earning!






Подробнее о nLEARNs







Гайды для начинающих










Courses



NEAR Certified Developer Program



По успешному окончанию этой программы ты сможешь - проектировать, разрабатывать, тестировать и деплоить смарт контракты на НИРе и получить сертификат разработчика – NEAR Certified Developer (NCD).




Подробнее




 






Новые Гайды






Все Гадйды ›






Не пропусти важные апдейты от LNC



Подпишись и получай уведомления о новых пероприятиях (L)Earn - Бета Тестах, Баунти и других!n.

### Learn NEAR Club

Aprende cómo usar y construír en NEAR y adquiere NEAR



Incorporación de todos hacia la plataforma del Protocolo NEAR - Conectando los proyectos del ecosistema NEAR a miembros proactivos mediante el método (L)EARN (Aprender y Ganar) respaldado por la Fundación NEAR








Empieza con






Guías NEAR›











Cursos NEAR›











Sobre nLEARNs›













Courses



NEAR Certified Developer Program



Ésta es una oportunidad para desarrolladores web de adquirir un certificado que represente la habilidad de diseñar, desarrollar, testear y lanzar contratos inteligentes en la plataforma NEAR - NEAR Certified Developer (NCD)




Learn more












Únete a 1,211,666 LNC (L)Earners



Desde entusiastas hasta experimentados desarrolladores por medio de la participación en un amplio espectro de actividades de la vida real. Ésta blockchain está organizada para ser sin permisos, ejecutante y suficientemente segura para crear una capa de datos fuerte y descentralizada para la nueva web.




NEAR Ecosystem





 



(L)Earning juntos con



 














































While interacting on LNC, you will receive nLearns, LNC internal points. Look at Mientras interactúas en LNC, vas a recibir nLearns, puntos internos de LNC. Puedes verlo como recompensas por ser Learners sobresalientes. Feliz (L)Earning!






Lee más acerca de nLEARNs







Guías de Introducción







Nuevas Guías






Todas las guías ›




Lets start learning






Stake: 16 nL



11 lessons



Build With NEAR



Basic course




Aplica AHORA ›















Entérate de lo último de LNC



Envía tu email y notifícate sobre las carreras de prueba beta y otras oportunidades para (L)Earn

### 🧧Red packet Redeem to NEAR Window

In order to participate in 🧧Red packet Redeem to NEAR Window, (L)Earner shall confirm:


 	Being an active LNC member for at least 30 days
 	(L)Earned at least 32 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 50 for this Redeem Window so please act in timely manner.

Red packet Redeem to NEAR Window opens for 50 (L)Earners only! First come, First served!
Once summited your offer please let us 48 hours to process it and expect funds credited to your NEAR account by EOD  February 3d.
Next Redeem Window is scheduled February 15th, 2022.
Happy (L)Earning!

### Điểm nLEARN là gì?

Điểm nLEARN là gì?



 



nLEARN là điểm trong hệ thống của LEARN NEAR Club giúp vận hành nền kinh tế Học và Kiếm điểm.



Điểm nLEARN KHÔNG phải là token và KHÔNG quy đổi được ra tiền pháp định. Hãy nghĩ về điểm nLEARN như một suất học bổng / phúc lợi nhỏ dành cho những học viên xuất sắc!



Cả Người sáng tạo và Người học đều nhận được nLEARN trong quá trình học tập!
















Cách kiếm điểm nLearns?





Truy cập Learn NEAR Club thường xuyên



Chia sẻ những bài viết hữu ích



Giới thiệu bạn bè trong chương trình Affiliate





Đọc hướng dẫn và vượt qua phần Quizz



Learn at courseHọc tại các khóa học - hoàn thành các bước, nộp bài tập, trả lời các câu hỏi





Làm thế nào để sử dụng nLearns





Stake để tham gia các chương trình/khóa học



Đổi lấy các ưu đãi đặc biệt từ các đối tác của NEAR





Tip cho tác giả



Đổi thành Ⓝ tại đây










Lưu ý dành cho những kẻ tấn công và spam



XIN ĐỪNG



ĐỪNG phí năng lực, thời gian và công sức của bạn để farm điểm nLEARN bằng cách nhảy đi nhảy lại từ bước này sang bước khác, gửi những feedback VÔ DỤNG hay gửi bài tập GIẢ MẠO. Hành vi gian dối sẽ dẫn tới việc điểm nLEARN của bạn bị phạt nặng.







LearnNEAR.Club là nền tảng cho việc học tập vì tương lai. Mọi người đều được chào đón NHƯNG không có chỗ cho các hành vi XẤU trong môi trường TÍCH CỰC này



Vậy nên hãy làm bài tập về nhà của bạn và trở lại đây khi đã sẵn sàng cho Tương Lai của Nền Kinh Tế Mở



Happy (L)Earning!





Nhận tin tức mới nhất từ LNC



Nhập email của bạn và nhận thông báo từ chương trình Beta Test và nhiều cơ hội khác để vừa học vừa kiếm tiền.

### Learn NEAR Club

Nhận NEAR khi bạn học cách sử dụng và xây dựng trên NEAR



Tất cả nền tảng thực hành tích hợp cho NEAR Protocol Kết nối các dự án hệ sinh thái NEAR với các thành viên cộng đồng tích cực hoạt động với phương thức Học và Kiếm tiền! Được hỗ trợ bởi NEAR Foundation








Bắt đầu với










Hướng dẫn NEAR›



 












Khóa Học NEAR›



 












Về nLEARN›



 










Khóa họces



Chương trình chứng nhận nhà phát triển NEAR



Khóa học này là cơ hội để các nhà phát triển Web truyền thống có thể sở hữu chứng chỉ NEAR Certified Developer (NCD) minh chứng cho khả năng thiết kế, phát triển, kiểm thử và vận hành các Smart Contract trên nền tảng của NEAR




Tìm hiểu thêm




 







Tham gia cùng 1,211,666 LNC (L)Earners



từ những người đam mê đến các nhà phát triển có kinh nghiệm, thông qua việc tham gia vào các hoạt động thực tế. Blockchain NEAR được xây dựng để trở nên permissionless, hiệu quả và an toàn nhằm tạo ra một layer dữ liệu mạnh mẽ và phi tập trung cho thế hệ web mới.




Hệ sinh thái NEAR





 



Học và nhận NEAR với



 









































Trong khi tương tác tại LNC, bạn sẽ nhận được điểm nLearn. Hãy xem đó như là phần thưởng cho những học viên xuất sắc. Happy (L)Earning!






Tìm hiểu thêm về nLEARN







Hướng dẫn cho người mới







Hướng dẫn mới nhất






Tất cả hướng dẫn ›






Nhận tin tức mới nhất từ LNC



Nhập email của bạn và nhận thông báo từ chương trình Beta Test và nhiều cơ hội khác để vừa học vừa kiếm tiền.

### NEAR Jobs



### Redeem nLEARNs

nLEARNs Redeem to NEAR Window opens on 15th day of the month



 



Next nLEARNs to NEAR Redeem Window is scheduled on October 15th 2025 – opens at 9am ET for 24 hours.(L)Earner NFT holders have a chance for 2 hours early access.Please note: Redeem to NEAR is just a nice micro-bonus to help you learn more how to use NEAR and how to build on NEAR.Ask your questions here




 + Add Google calendar



About nLEARNs










 






5 Simple Requirements









Membership age



Joined Learn NEAR Club at least 2 weeks ago









Be active



(L)Earned at least 64 nLEARNs since previous Redeem date – stay ACTIVE









Invite friends



Invite at least 2 friends









Don't skip a week



(L)Earn at least4 (FOUR) nLEARNs every 7 days









(L)Earn with AI!!!



Ask (L)Earn AI 🕺questions and provide feedbackat least 2 times a month






Wanna get a chance of 2 hours earlier access during Redeem to NEAR Window? First come, first served.



To Redeem multiple times you must hold:LNCer NFT starting 2nd Redeem🕺(L)Earner NFT starting from 11th Redeem



 



Schedule





Redeem nLEARNs - October 15th 2025 – Open for 24 hours only






+ Add to google calendar








Redeem nLEARNs – September 15th 2025 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – August 15th 2025 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – July 15th 2025 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – June 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – May 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs –  April 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – March 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – February 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – January 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – December 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – November 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs – October 15th 2024 9AM ET- Open for 12 hours





















Ended







Redeem nLEARNs - September 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - August 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - July 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - June 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - May 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - April 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - March 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - February 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - January 15th 2024 – Open for 12 hours only





















Ended







Redeem nLEARNs - December 15th 2023 – Open for 12 hours only





















Ended







Redeem nLEARNs - November 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - October 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - September 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - July 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - July 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - June 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - May 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - April 15th 2023 – Open for 12 hours only

















Ended







Redeem nLEARNs - March 15th 2023 – Open for 24 hours only

















Ended







Redeem nLEARNs - February 15th 2023 – Open for 24 hours only

















Ended







Redeem nLEARNs - January 15th 2023 – Open for 24 hours only

















Ended







Redeem nLEARNs - December 15th 2022 – Open for 24 hours only

















Ended







Redeem nLEARNs - November 15th 2022 – Open for 24 hours only

















Ended







Redeem nLEARNs – October 15 2022 - Open for 24 hours only

















Ended







Redeem nLEARNs – September 15 2022 - Open for 12 hours only

















Ended







Redeem nLEARNs – August 15 2022 - Open for 12 hours only

















Ended







Redeem nLEARNs – July15 2022 - Open for 12 hours only

















Ended







Redeem nLEARNs – June 15 2022 - Open for 12 hours only













Ended







Redeem nLEARNs – May 15 2022 - Open for 12 hours only













Ended







Redeem nLEARNs – April 15 2022 - Open for 12 hours only













Ended







Redeem nLEARNs – March 15 2022 - Open for 12 hours only













Ended







Redeem nLEARNs – February 15 2022 - Open for 12 hours only













Ended







Redeem nLEARNs – January 15 2022 - Open for 12 hours only









Ended







Redeem nLEARNs – December 15 2021 - Open for 12 hours only





Ended







Redeem nLEARNs – November 15 2021 - Open for 12 hours only





Ended







Redeem nLEARNs – October 15 2021 - Open for 24 hours only





Ended







Redeem nLEARNs – September 15 2021 - Open for 24 hours only





Ended







Redeem nLEARNs – August 15 2021 - Open for 24 hours only





Ended







Redeem nLEARNs – July 15 2021 - Open for 24 hours only





Ended







Redeem nLEARNs – June 15 2021 - Open for 24 hours only





Ended







Get the latest from LNC



Submit your email and get notified about Beta Test Sprints and other opportunities to (L)Earn.

### What are nLEARNs?

What are nLEARNs?







nLEARNS are Learn NEAR Club internal points powering (L)Earning economy. 



nLEARNS are NOT tokens and do NOT have monetary value.Think about nLEARNs as mini-scholarships/benefits for outstanding (L)Earners. 



Both Creators and Learners get rewards in nLEARNs during Learning.
















Why get nLearns?





The ultimate use case of nLEARNs is Proof of (L)Earn. Any (L)Earner history can be verified so community members or projects can get an idea about how consistent is the learning progress. 





How to earn nLearns?





Visit Learn NEAR Сlub regularly



Share useful Guides



Refer a friend by Affiliate program (fond it at your LNC profile)





Read Guides and pass Quizzes



Learn at Courses – complete steps, submit assignments, answer Quizzes



Get nLEARNs for (L)Earn AI🕺 feedback 





How to spend nLearns?





Stake to enroll to Program/Course



Talk to (L)Earn AI agent🕺 about NEAR and NEAR Ecosystem



Participate in Quadratic Voting polls





Tip Authors of guides and courses



Send nLEARNs tips at LNC Telegram for the help from your peers



Redeem to Ⓝ during Redeem Windows. Amount of NEAR depends on number of participants, as well as NEAR exchange rate, Redeem tasks complexity.  










Attention Sybil Attackers and Spammers



PLEASE, PLEASE, PLEASE!



Do NOT  waste your talent, time and energy trying to farm nLEARNs hopping from Step to Step, submitting USELESS feedback and FAKE assignments. Malicious behavior results in nLEARNs slashing.







LearnNEAR.Club is a platform of Future Learning. Everyone is invited and welcomed but there is no room for BAD actors in POSITIVE SUM game.



So please do your homework and come back when ready for Open Economy Future.



Happy (L)Earning!





Get the latest from LNC



Connect your LNC account to LNC Notifier Telegram bot and get notified about Beta Test Sprints and other opportunities to (L)Earn.

### Redeem nLEARNs - February 15th 2022 9AM ET- Open for 24 hours

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 400 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting December 15th, 2021 at 9am ET.
Once summited your offer please let us 48 hours to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled March 15th, 2022.
Happy (L)Earning!

### How we use Sputnik DAO at LeanNEAR.Club

LNC Pro Translate
There are TWO levels of DAO in use:

Mother DAO and the following subDAOs:

 	https://dao.learnnear.club/#/dao/learnnear.sputnikdao.near
 	https://dao.learnnear.club/#/dao/learn-near-rus.sputnikdao.near
 	https://dao.learnnear.club/#/dao/learn-near-spanish.sputnikdao.near
 	https://dao.learnnear.club/#/dao/learn-near-china.sputnikdao.near
 	https://dao.learnnear.club/#/dao/learn-near-french.sputnikdao.near

Look at Mother DAO as a Client/Funder, subDAOs as a Contractor and subDAOs members as Subcontractor.

Let’s take a look at how it works for community translation. A guide Top 3 NFT Projects On The NEAR Protocol needs to be translated in Vietnamese.
SubDAO members submit proposals for translation and review.



Then one of them submitted a consolidated proposal to the Mother DAO with subDAO as funds receiver



Once the work is accepted and translated Guide is published subDAO members split received funds as per proposals submitted earlier.

For possible conflict resolutions, Mother DAO member acts also as Voting Member at ALL subDAOs.
Awards
Consolidated Award Proposal [Translator + Reviewer]=$25/500 words

### LNC Pro Translate

Learn NEAR Club Pro Translate



On-demand community powered translating into Spanish, French, Russian, Vietnamese, Chinese, German, Portuguese, Indonesian. Operations are run via learnnear.sputnik DAO, language based subDAOs, and NEAR Community Forum. 



















Featured LNC Pro Translators



                            
                    
                                                abdelillah77
                    
                
                            
                    
                                                alecaseg
                    
                
                            
                    
                                                ame9986
                    
                
                            
                    
                                                andersonr
                    
                
                            
                    
                                                cuongdcdev
                    
                
                            
                    
                                                dakin
                    
                
                            
                    
                                                derymars
                    
                
                            
                    
                                                dmitri_0x01
                    
                
                            
                    
                                                fritzwagner
                    
                
                            
                    
                                                icebear
                    
                
                            
                    
                                                jeph
                    
                
                            
                    
                                                ramgor
                    
                
                            
                    
                                                rodobossa
                    
                
                            
                    
                                                that83
                    
                
                        




How it works



Usually, we have 1-3 Guides about NEAR Protocol NEAR Ecosystem Guides published and translated a week.



Learn Near Club Translate collective has about 25 active contributing (L)Earners.Read more about the process and rewards










Done by HUMANS



LNC Pro translators are real people who loves NEAR and USE NEAR.









Quality



Each and every translation is being reviewed by peer translator reviewer.









(L)Earn



Both Translator and Reviewer get nLEARNs when the learning material is read/quiz answered, etc.






Want to help with translation?




Let's talk at Telegram











Don't miss important update from LNC



Submit your email and get notified about Beta Test Sprints and other opportunities to (L)Earn

### NFT Lend beta test feedback



### LNC 👀BugEye sprint

👀BugEye sprint







There are about 550+ LNC members who participate in 👀BugEye sprint for projects from LNC Barrel and other NEAR Ecosystem projects.







Rewardsin NEAR tokens











Featured LNC 👀BugEye sprinters






How it works



Runs on-demand, 3 days long 👀BugEye sprint, with a goal to provide early feedback to LNC Pro Barrel and other NEAR Ecosystem projects and rewarding participants with NEAR tokens. Up to 10 NEAR per meaningful submission, the rate can vary as per requirements.




Submit your project  ›











Done by HUMANS



LNC 👀BugEye sprinters🕺 are real people who loves NEAR and USE NEAR.









Bring Awareness



Test Project is being introduced the entire LNC Community of 100,000+ (L)Earners via ALL possible channels - website, Twitter, Discord, email, push notification, and most important - referring to friends.









Fast Reports



👀BugEye sprint reports are ready within 24 hours after sprint is completed.





👀BugEyed Projects


























































































                
                        
                            Join 👀BugEye sprint program
                            
                         
 
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        NEAR Account(Required) Choose your favorite dApps(Required)
								
								Games
							
								
								DeFi
							
								
								NFT
							
								
								Other
							nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.
          
            
            
            
            
            
            
            
            
            
        
                        
                        




Passed 👀BugEye sprints

### Redeem nLEARNs - January15th 2022 9AM ET- Open for 12 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 400 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting December 15th, 2021 at 9am ET.
Once summited your offer please let us 48 hours to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled February 15th, 2022.
Happy (L)Earning!

### TokenHub Token Factory Testers Feedback



### Redeem nLEARNs - December 15th 2021 9AM ET- Open for 12 hours only

Wow! This Redeem Window was a blast!
We reached the cap for this month.
Please come next time. Thank you and happy (L)Earning!

### FLASH Cyber Monday Redeem Window

In order to participate in 🤖 Cyber Monday Redeem Window, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 60 days
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 50 for this Redeem Window so please act in timely manner.

The Redeem Test Window opens for 50 (L)Earners only!
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD December 2nd.
Next Redeem Window is scheduled December 15th, 2021.
Happy (L)Earning!

### Near login page



### Discord Tip Beta Testers Feedback



### Redeem Agreement November 2021

HiddenEnter code:NEAR Redeem Program Reward Agreement(Required)Congratulations, and thank you! We are grateful for your submission to the NEAR Redeem Program and your help in our continuous efforts to improve the NEAR ecosystem.

We are pleased to notify you that NEAR wishes to award you with a payment in NEAR tokens in the amount of specified in Redeem Windows you patriciate  ​which you specifically agree to not disclose to anyone under any circumstances (unless expressly warranted by law). We will deliver this amount to you using your contact information below within TWO (2) days of our receipt from you of this completed form.

By completing this form and signing below, you acknowledge and agree to the following:

 	 You have complied and will continue to comply with the NEAR Redeem Program terms and conditions. 
 	 You are of legal age in your jurisdiction to enter into this agreement (or your parent or guardian is signing this agreement for you); payment of the reward to you will not violate any applicable laws; and you are solely responsible to report and pay income or other taxes, if any, that apply to your receipt of this reward.
 Accepted and agreed by:First and Last Name(Required) Email(Required)
                            
                        NEAR Account(Required) Town and Country(Required) nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.CommentsThis field is for validation purposes and should be left unchanged.

### Learn NEAR Club

Learn how to use and build onNEAR and Earn NEAR



All inclusive hands-on onboarding platform to NEAR Protocolconnecting NEAR Ecosystem projects to pro-active community members via (L)Earn method.Supported by NEAR Foundation.










📚(L)Earn TODAY🕺







Stake: 1 nL



10 minutes



NEAR in 2025



Basic course, NFT Certificate




Enroll NOW ›
















📚Guides (+16 nL)







👀BugEye sprints Ⓝ







🗳LNC Polls








While interacting on LNC, you will receive nLearns, LNC internal points.Look at them as a bonuses for outstanding Learners.Happy (L)Earning!






Show me more about nLEARNs







📚Popular from Community🕺








Join 1,211,666 LNC (L)Earners🕺



From enthusiasts to experienced developers via participating in a wide specter of real life hands-on activities on NEAR.Learn NEAR Club is a welcoming place for everyone, except free-honey seekers.










(L)Earning together with





Onboarding Guides







Start with






NEAR Guides ›



 







NEAR Courses ›



 







(L)Earner NFT ›



 









Courses



NEAR Certified Developer Program



This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).




Learn more




 

### Redeem nLEARNs - Flash Test Window

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 10 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 10 (L)Earners only!
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD November 13th.
Next Redeem Window is scheduled November 15th, 2021.
Happy (L)Earning!

### Brand logos

Download logo set

### Redeem Agreement NCD



### NEATAR

How to get your NEAR NFT avatar - NEATAR.

 	Make sure your NEAR testnet account is the same as mainent:
alice.near => alice.testnet
If you do not have testnet account yet, you can create one here https://wallet.testnet.near.org/
 	Login to NEATAR
https://neatar.github.io/
and mint a NEATAR. You can burn and mint again until you like it.
 	Go to your LNC profile to sync your NEATAR.

 	Get 16 nLEARNS once done.

### testnl1



### Redeem nLEARNs - November 15 2021 9AM ET- Open for 12 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 200 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 12 hours starting November 15th, 2021 at 9am ET.
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account within 2 business days.
Next Redeem Window is scheduled December 15th, 2021.
Happy (L)Earning!

### Redeem confirmation



### Redeem nLEARNs - October 15 2021- Open for 24 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 1 nLEARN a WEEK since previous Redeem Window - stay ACTIVE
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 48 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting September 15th, 2021 at midnight EDT.
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD October 17th.
Next Redeem Window is scheduled November 15th, 2021.
Happy (L)Earning!

### LNC Pro



### NEAR Certified Developers Level2

Testnet Project
                Total 13 certified members 
        
                                            
                    
                        
                                                        alsakhaev.near
                        
                    
                

                                            
                    
                        
                                                        ilyar.near
                        
                    
                

                                            
                    
                        
                                                        daothang.near
                        
                    
                

                                            
                    
                        
                                                        harrynguyen.near
                        
                    
                

                                            
                    
                        
                                                        cryptovaibhav.near
                        
                    
                

                                            
                    
                        
                                                        coldy.near
                        
                    
                

                                            
                    
                        
                                                        vans163.near
                        
                    
                

                                            
                    
                        
                                                        rmlsnk.near
                        
                    
                

                                            
                    
                        
                                                        kalloc.near
                        
                    
                

                                            
                    
                        
                                                        chestedos.near
                        
                    
                

                                            
                    
                        
                                                        liaa.near
                        
                    
                

                                            
                    
                        
                                                        xsb.near
                        
                    
                

                                            
                    
                        
                                                        yoshi-tech.near
                        
                    
                

                                


            
NEAR Ecosytem Contributors
                Total 2 certified members 
        
                                            
                    
                        
                                                        net_x.near
                        
                    
                

                                            
                    
                        
                                                        vladakdd.near
                        
                    
                

                                


            

 

### Verified Ai Tests



### Home

欢迎来到 Learn NEAR Club











学习为今天的开放经济构建应用 NEAR Protocol 将帮助全球的开发者学习 Web3 技术栈  边学习 NEAR，边挣到 NEAR  来自 NEAR 的独家优惠 









NEAR 认证开发者课程





本课程是 Web 开发者获得证书的机会，该证书代表了在 NEAR 平台上设计、开发、测试和部署智能合约的能力——NEAR 认证开发者 (NCD).




入门指南












最新指南





学习并挣到 NEAR

### Redeem nLEARNs - September 15 2021- Open for 24 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 4 weeks
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 48 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting September 15th, 2021 at midnight EDT.
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD September 17th.
Next Redeem Window is scheduled October 15th, 2021.
Happy (L)Earning!

### Members Feedback

[sv_my_contributions display="all"]

### Activities

[anspress]

### Tags

[anspress]

### Categories

[anspress]

### Profile

[anspress]

### Ask a question

[anspress]

### Questions

[anspress]

### Trang chủ

Chào mừng đến với Learn NEAR











Học cách xây dựng một nền kinh tế mở ngay hôm nayGiáo dục mọi người về các công nghệ Web 3 với giao thức NEARNhận NEAR khi bạn học về NEARVà nhiều ưu đãi hấp dẫn tới từ NEAR





NEAR Certified Developer Program





Khóa học này là cơ hội để các nhà phát triển Web có thể đạt được chứng chỉ NCD từ NEAR thể hiện khả năng thiết kế, phát triển, kiểm thử và triển khai hợp đồng thông minh trên nền tảng NEAR.




Tham gia khóa học tại đây












Hướng dẫn mới





Học và nhận NEAR









 

### Redeem nLEARNs - July 15 2021- Open for 24 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 3 weeks
 	(L)Earned at least 64 nLEARNs since previous Redeem Window - stay ACTIVE
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 32 for this Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting July 15th, 2021 at midnight EDT.
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD July 17th.
Next Redeem Window is scheduled August 15th, 2021.
Happy (L)Earning!

### Redeem nLEARNs - June 15 2021- Open for 24 hours only

In order to participate in Redeem nLEARNs to NEAR, Learn NEAR Club (LNC) Member shall confirm:


 	Being an active LNC member for at least 2 weeks
 	Never participated in "bad" activities - jumping from Step to Step without Learning a thing
 	Have enough amount of nLEARNs at the account
 	For security purposes number of participants is limited to 25 for this inaugural Redeem Window so please act in timely manner.

The Redeem Window opens for 24 hours starting June 15th, 2021 at midnight EDT.
Once summited your offer please let us 24 hours to process it and expect funds credited to your NEAR account by EOD June 17th.
Next Redeem Window is scheduled July 15th, 2021.
Happy (L)Earning!

### Events



### Enroll to Beta Tester program

Join 👀BugEye sprint program
                            
                         
 
                        Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        NEAR Account(Required) Choose your favorite dApps(Required)
								
								Games
							
								
								DeFi
							
								
								NFT
							
								
								Other
							nCaptcha
							
						nCaptcha collects a small amount on NEAR to prevent spam. Please double check amount and destination ncaptcha.near address at the wallet.

### Pre-demo form



### LNC Code of Conduct

Welcome To Learn NEAR Club

We want this to be a fun, pleasant, and harassment-free experience for everyone, regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, or religion. We do not tolerate harassment of participants in any form. Participants asked to stop any harassing behavior are expected to comply immediately.
Confidentiality:
Please be mindful that things you say here may at some point become public. While we expect members to honor the confidentiality of this space, we cannot guarantee that they will do so--nor can we guarantee that every member's login credentials and logged-in devices are secure. Please exercise caution and refrain from sharing sensitive information that could harm you or others if it became public.

Harassment:
Harassment includes:
Offensive comments related to gender, gender identity and expression, sexual orientation, disability, mental illness, neuro(a)typicality, physical appearance, body size, race, or religion
Unwelcome comments regarding a person’s lifestyle choices and practices, including those related to food, health, parenting, drugs, and employment.
Deliberate misgendering or use of ‘dead’ or rejected names
Gratuitous or off-topic sexual images or behavior in spaces where they’re not appropriate
Simulated physical contact (e.g. textual descriptions like “hug” or “backrub”) without consent or after a request to stop.
Threats of violence
Incitement of violence towards any individual, including encouraging a person to commit suicide or to engage in self-harm
Deliberate intimidation
Sustained disruption of discussion
Unwelcome sexual attention
Continued one-on-one communication after requests to cease
Publication of non-harassing private communication
Reporting
If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact us. We'll respond as promptly as we can.
We will respect confidentiality requests for the purpose of protecting victims of abuse. At our discretion, we may publicly name a person about whom we’ve received harassment complaints, or privately warn third parties about them. We will not name harassment victims without their affirmative consent.
Consequences
Participants asked to stop any harassing behavior are expected to comply immediately.
If a participant engages in harassing behavior, the admins may take any action they deem appropriate, up to and including expulsion from this Club and identifying the participant publicly as someone about whom we've received complaints.

### Useful Tools and Recourses

Tools
Near Wallet

Near Explorer

Multi sender
Recourses
Docs.near.org

 

 

 

 

### Contact Us

nCaptcha Transaction
                        
                        
                            
                        
            
            Your name(Required) Email(Required)
                            
                        How can we help?(Required)




Submit with nStamp

### NCDL1 Registration Form

NCD Registration
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Native Language*
			
				
				English
			
			
				
				Chinese
			
			
				
				Russian
			
			
				
				Vietnamese
			
			
				
				Korean
			
			
				
				
			Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account*

### Tech list 2



### Tech list



### delete duplication



### NEAR Certified Developers Gallery

Total 236 certified members 
        
                                            
                    
                        
                                                        sergey_zenkov.near
                        
                    
                

                                            
                    
                        
                                                        futured.near
                        
                    
                

                                            
                    
                        
                                                        ozanisgor.near
                        
                    
                

                                            
                    
                        
                                                        cagataysoyer.near
                        
                    
                

                                            
                    
                        
                                                        ug03fast.near
                        
                    
                

                                            
                    
                        
                                                        dannyfung.near
                        
                    
                

                                            
                    
                        
                                                        docker.near
                        
                    
                

                                            
                    
                        
                                                        mshankarrao.near
                        
                    
                

                                            
                    
                        
                                                        ryzm.near
                        
                    
                

                                            
                    
                        
                                                        memoriesadrift.near
                        
                    
                

                                            
                    
                        
                                                        hiba.near
                        
                    
                

                                            
                    
                        
                                                        aronbsz.near
                        
                    
                

                                            
                    
                        
                                                        simonpalmer.near
                        
                    
                

                                            
                    
                        
                                                        anuj.near
                        
                    
                

                                            
                    
                        
                                                        martinyeung.near
                        
                    
                

                                            
                    
                        
                                                        cryptotwilight.near
                        
                    
                

                                            
                    
                        
                                                        0xnik.near
                        
                    
                

                                            
                    
                        
                                                        xawangxl.near
                        
                    
                

                                            
                    
                        
                                                        jibo.near
                        
                    
                

                                            
                    
                        
                                                        mdex.near
                        
                    
                

                                            
                    
                        
                                                        wongxf.near
                        
                    
                

                                            
                    
                        
                                                        maxluk.near
                        
                    
                

                                            
                    
                        
                                                        bingryan.near
                        
                    
                

                                            
                    
                        
                                                        alsakhaev.near
                        
                    
                

                                            
                    
                        
                                                        tom-xu.near
                        
                    
                

                                            
                    
                        
                                                        hatchet.near
                        
                    
                

                                            
                    
                        
                                                        gyan.near
                        
                    
                

                                            
                    
                        
                                                        sunhao.near
                        
                    
                

                                            
                    
                        
                                                        robertyan.near
                        
                    
                

                                            
                    
                        
                                                        ryu.near
                        
                    
                

                                            
                    
                        
                                                        elderorb.near
                        
                    
                

                                            
                    
                        
                                                        alexcj96.near
                        
                    
                

                                            
                    
                        
                                                        murilo.near
                        
                    
                

                                            
                    
                        
                                                        humanman.near
                        
                    
                

                                            
                    
                        
                                                        lobana.near
                        
                    
                

                                            
                    
                        
                                                        igorfroehner.near
                        
                    
                

                                            
                    
                        
                                                        berryoska.near
                        
                    
                

                                            
                    
                        
                                                        vans163.near
                        
                    
                

                                            
                    
                        
                                                        ilyar.near
                        
                    
                

                                            
                    
                        
                                                        oui.near
                        
                    
                

                                            
                    
                        
                                                        varadbal.near
                        
                    
                

                                            
                    
                        
                                                        jothiprasath.near
                        
                    
                

                                            
                    
                        
                                                        ach.near
                        
                    
                

                                            
                    
                        
                                                        thanhlm.near
                        
                    
                

                                            
                    
                        
                                                        cristian-zambrano.near
                        
                    
                

                                            
                    
                        
                                                        mark1.near
                        
                    
                

                                            
                    
                        
                                                        aostanina.near
                        
                    
                

                                            
                    
                        
                                                        lempire.near
                        
                    
                

                                            
                    
                        
                                                        alway.near
                        
                    
                

                                            
                    
                        
                                                        nikhil1439.near
                        
                    
                

                                            
                    
                        
                                                        cocaman.near
                        
                    
                

                                            
                    
                        
                                                        cuongdcdev.near
                        
                    
                

                                            
                    
                        
                                                        that83.near
                        
                    
                

                                            
                    
                        
                                                        daothang.near
                        
                    
                

                                            
                    
                        
                                                        vanhiepdam.near
                        
                    
                

                                            
                    
                        
                                                        tieubaoca.near
                        
                    
                

                                            
                    
                        
                                                        icebear.near
                        
                    
                

                                            
                    
                        
                                                        vladakdd.near
                        
                    
                

                                            
                    
                        
                                                        lk2684753.near
                        
                    
                

                                            
                    
                        
                                                        tlgkien.near
                        
                    
                

                                            
                    
                        
                                                        mingjun.near
                        
                    
                

                                            
                    
                        
                                                        bhc8521.near
                        
                    
                

                                            
                    
                        
                                                        paulwu.near
                        
                    
                

                                            
                    
                        
                                                        alansh.near
                        
                    
                

                                            
                    
                        
                                                        sharkme.near
                        
                    
                

                                            
                    
                        
                                                        jialeieos333.near
                        
                    
                

                                            
                    
                        
                                                        jiahong.near
                        
                    
                

                                            
                    
                        
                                                        wisarmy.near
                        
                    
                

                                            
                    
                        
                                                        csp.near
                        
                    
                

                                            
                    
                        
                                                        abort.near
                        
                    
                

                                            
                    
                        
                                                        xsb.near
                        
                    
                

                                            
                    
                        
                                                        liaa.near
                        
                    
                

                                            
                    
                        
                                                        ngo-sy-truong.near
                        
                    
                

                                            
                    
                        
                                                        dispa1r.near
                        
                    
                

                                            
                    
                        
                                                        ttnguyen999.near
                        
                    
                

                                            
                    
                        
                                                        mtoan2193.near
                        
                    
                

                                            
                    
                        
                                                        neutrino.near
                        
                    
                

                                            
                    
                        
                                                        hiphop200x.near
                        
                    
                

                                            
                    
                        
                                                        net_x.near
                        
                    
                

                                            
                    
                        
                                                        thucdv.near
                        
                    
                

                                            
                    
                        
                                                        harrynguyen.near
                        
                    
                

                                            
                    
                        
                                                        brefchan.near
                        
                    
                

                                            
                    
                        
                                                        hoza.near
                        
                    
                

                                            
                    
                        
                                                        zefost.near
                        
                    
                

                                            
                    
                        
                                                        bim.near
                        
                    
                

                                            
                    
                        
                                                        chestedos.near
                        
                    
                

                                            
                    
                        
                                                        santhoshkumar.near
                        
                    
                

                                            
                    
                        
                                                        nguyenpikachu.near
                        
                    
                

                                            
                    
                        
                                                        anhnhantn97.near
                        
                    
                

                                            
                    
                        
                                                        robert.redbag.near
                        
                    
                

                                            
                    
                        
                                                        canhnt.near
                        
                    
                

                                            
                    
                        
                                                        tinnguyen.near
                        
                    
                

                                            
                    
                        
                                                        tranxuanquy.near
                        
                    
                

                                            
                    
                        
                                                        jilt.near
                        
                    
                

                                            
                    
                        
                                                        yiranlandtour.near
                        
                    
                

                                            
                    
                        
                                                        porcobosso.near
                        
                    
                

                                            
                    
                        
                                                        abysus.near
                        
                    
                

                                            
                    
                        
                                                        juaner.near
                        
                    
                

                                            
                    
                        
                                                        boxer.near
                        
                    
                

                                            
                    
                        
                                                        cryptovaibhav.near
                        
                    
                

                                            
                    
                        
                                                        tuanlv.near
                        
                    
                

                                            
                    
                        
                                                        quanle191.near
                        
                    
                

                                            
                    
                        
                                                        nguyenthixuan.near
                        
                    
                

                                            
                    
                        
                                                        johnlee179.near
                        
                    
                

                                            
                    
                        
                                                        neiknav.near
                        
                    
                

                                            
                    
                        
                                                        manhquan1992.near
                        
                    
                

                                            
                    
                        
                                                        sakura1999tb.near
                        
                    
                

                                            
                    
                        
                                                        typhutranvancan.near
                        
                    
                

                                            
                    
                        
                                                        trang90.near
                        
                    
                

                                            
                    
                        
                                                        tueman.near
                        
                    
                

                                            
                    
                        
                                                        phamminhnhan.near
                        
                    
                

                                            
                    
                        
                                                        phucngo.near
                        
                    
                

                                            
                    
                        
                                                        minhtam9.near
                        
                    
                

                                            
                    
                        
                                                        huuthang.near
                        
                    
                

                                            
                    
                        
                                                        phuockl.near
                        
                    
                

                                            
                    
                        
                                                        leonacky.near
                        
                    
                

                                            
                    
                        
                                                        linh21.near
                        
                    
                

                                            
                    
                        
                                                        thuantranqnu.near
                        
                    
                

                                            
                    
                        
                                                        phuocthaolh.near
                        
                    
                

                                            
                    
                        
                                                        leconghieu.near
                        
                    
                

                                            
                    
                        
                                                        namthiennguyen.near
                        
                    
                

                                            
                    
                        
                                                        kingqng.near
                        
                    
                

                                            
                    
                        
                                                        navie.near
                        
                    
                

                                            
                    
                        
                                                        cttam89.near
                        
                    
                

                                            
                    
                        
                                                        thuphuong256.near
                        
                    
                

                                            
                    
                        
                                                        quyet193.near
                        
                    
                

                                            
                    
                        
                                                        steveyu.near
                        
                    
                

                                            
                    
                        
                                                        ntan1210.near
                        
                    
                

                                            
                    
                        
                                                        thangnguyen272.near
                        
                    
                

                                            
                    
                        
                                                        cuong2hg.near
                        
                    
                

                                            
                    
                        
                                                        danielrpeavey.near
                        
                    
                

                                            
                    
                        
                                                        quangpuma.near
                        
                    
                

                                            
                    
                        
                                                        koduckiss20.near
                        
                    
                

                                            
                    
                        
                                                        ngohacamau.near
                        
                    
                

                                            
                    
                        
                                                        thanhbinhclick.near
                        
                    
                

                                            
                    
                        
                                                        chanhtong.near
                        
                    
                

                                            
                    
                        
                                                        lotustar.near
                        
                    
                

                                            
                    
                        
                                                        nguyenhuynhtrung.near
                        
                    
                

                                            
                    
                        
                                                        hoanghuy97.near
                        
                    
                

                                            
                    
                        
                                                        phanhuydung.near
                        
                    
                

                                            
                    
                        
                                                        nghiabui.near
                        
                    
                

                                            
                    
                        
                                                        thi1994.near
                        
                    
                

                                            
                    
                        
                                                        tuyennguyen07.near
                        
                    
                

                                            
                    
                        
                                                        huy_nguyen.near
                        
                    
                

                                            
                    
                        
                                                        phanthanhdat97132.near
                        
                    
                

                                            
                    
                        
                                                        duongtrungsuc.near
                        
                    
                

                                            
                    
                        
                                                        imlang.near
                        
                    
                

                                            
                    
                        
                                                        truong98.near
                        
                    
                

                                            
                    
                        
                                                        minhkhang20182020.near
                        
                    
                

                                            
                    
                        
                                                        longphamtran.near
                        
                    
                

                                            
                    
                        
                                                        thaikyanh338.near
                        
                    
                

                                            
                    
                        
                                                        joengelh.near
                        
                    
                

                                            
                    
                        
                                                        taphuhiep52990.near
                        
                    
                

                                            
                    
                        
                                                        bobonsponge.near
                        
                    
                

                                            
                    
                        
                                                        minhnhut99.near
                        
                    
                

                                            
                    
                        
                                                        tranthanhphong.near
                        
                    
                

                                            
                    
                        
                                                        tuna2908.near
                        
                    
                

                                            
                    
                        
                                                        yoshitoke.near
                        
                    
                

                                            
                    
                        
                                                        thaoduc.near
                        
                    
                

                                            
                    
                        
                                                        kulasama.near
                        
                    
                

                                            
                    
                        
                                                        onthecoin.near
                        
                    
                

                                            
                    
                        
                                                        wabinab.near
                        
                    
                

                                            
                    
                        
                                                        vu_nguyen.near
                        
                    
                

                                            
                    
                        
                                                        fakesportsnews.near
                        
                    
                

                                            
                    
                        
                                                        tilek.near
                        
                    
                

                                            
                    
                        
                                                        rmlsnk.near
                        
                    
                

                                            
                    
                        
                                                        ast3ros.near
                        
                    
                

                                            
                    
                        
                                                        coldy.near
                        
                    
                

                                            
                    
                        
                                                        thanhnham.near
                        
                    
                

                                            
                    
                        
                                                        nearsocial.near
                        
                    
                

                                            
                    
                        
                                                        kunaldawar.near
                        
                    
                

                                            
                    
                        
                                                        maharana.near
                        
                    
                

                                            
                    
                        
                                                        rdbhagat999.near
                        
                    
                

                                            
                    
                        
                                                        auok007.near
                        
                    
                

                                            
                    
                        
                                                        manhnv.near
                        
                    
                

                                            
                    
                        
                                                        lawrence_liu.near
                        
                    
                

                                            
                    
                        
                                                        olina_ly.near
                        
                    
                

                                            
                    
                        
                                                        0xjackzhang.near
                        
                    
                

                                            
                    
                        
                                                        nearlap.near
                        
                    
                

                                            
                    
                        
                                                        mikeadam.near
                        
                    
                

                                            
                    
                        
                                                        balda.near
                        
                    
                

                                            
                    
                        
                                                        ewtd.near
                        
                    
                

                                            
                    
                        
                                                        tin_nguyen.near
                        
                    
                

                                            
                    
                        
                                                        young_cn.near
                        
                    
                

                                            
                    
                        
                                                        zuongnh.near
                        
                    
                

                                            
                    
                        
                                                        kalloc.near
                        
                    
                

                                            
                    
                        
                                                        timthang.near
                        
                    
                

                                            
                    
                        
                                                        happyrobot.near
                        
                    
                

                                            
                    
                        
                                                        verbgap.near
                        
                    
                

                                            
                    
                        
                                                        jacky2022.near
                        
                    
                

                                            
                    
                        
                                                        venti66.near
                        
                    
                

                                            
                    
                        
                                                        cornflower.near
                        
                    
                

                                            
                    
                        
                                                        cristian_nguyen.near
                        
                    
                

                                            
                    
                        
                                                        putong999.near
                        
                    
                

                                            
                    
                        
                                                        gadillac.near
                        
                    
                

                                            
                    
                        
                                                        thanhntphys.near
                        
                    
                

                                            
                    
                        
                                                        josealfredoroman.near
                        
                    
                

                                            
                    
                        
                                                        coderli.near
                        
                    
                

                                            
                    
                        
                                                        vodkabuaa.near
                        
                    
                

                                            
                    
                        
                                                        freyaz.near
                        
                    
                

                                            
                    
                        
                                                        bodyarovoy.near
                        
                    
                

                                            
                    
                        
                                                        wakili.near
                        
                    
                

                                            
                    
                        
                                                        akinyemesaheedwale.near
                        
                    
                

                                            
                    
                        
                                                        scofield_1999.near
                        
                    
                

                                            
                    
                        
                                                        junemichael84699.near
                        
                    
                

                                            
                    
                        
                                                        nopee.near
                        
                    
                

                                            
                    
                        
                                                        liuck8080.near
                        
                    
                

                                            
                    
                        
                                                        919603023.near
                        
                    
                

                                            
                    
                        
                                                        yoshi-tech.near
                        
                    
                

                                            
                    
                        
                                                        ramboj.near
                        
                    
                

                                            
                    
                        
                                                        evietwo.near
                        
                    
                

                                            
                    
                        
                                                        volodymyr_matseliukh.tg
                        
                    
                

                                            
                    
                        
                                                        1234qwer.near

### Tip Author with NEAR

Coming soon!

### NEAR Certified Developer Program (NCD)

Level 1
There is a need to distinguish between 3 groups: 


 	People who participate in the NEAR Certified Developer (NCD) program and completed all the Steps
 	People who participate AND deliver a demo with their team on Friday
 	People who participate, deliver a demo AND prove they understand the material

For this reason we have identified 3 levels of L1 certification:


 	Participants -- this group receives no reward and no recognition for participation
 	L1 certified participants -- this group receives rewards and certificates of completion
 	L1v verified developers -- this group receives rewards, certificates of verification and more

To earn an L1v, participants who complete NCD with a demo (L1 certified participants ONLY) must immediately schedule a 30-60 minute in-person pairing session with a verification specialist (currently Sherif but will be many more as they are trained)
The verification session will NOT include all of following activities, only some (at the discretion of the verifier):


 	Explaining a working contract

 	Reasoning about the behavior of a contract (core contracts, learn-near examples, etc.)
 	Predicting the effect of a change in the contract
 	Creating a guide to using the contract (NEAR CLI commands, API calls, etc.)




 	Troubleshooting a broken contract

 	Fixing a compilation error
 	Fixing a failing unit test
 	Fixing a failing simulation test
 	Fixing a runtime error (contract logic, interface or other issues)




 	Improving a working contract

 	Refactoring the contract
 	Enhancing an existing feature
 	Adding a new feature
 	Optimizing the contract (size, speed, storage, etc)




 	Creating a new contract

 	Translating an existing contract from AssemblyScript to Rust or vice versa
 	Designing a new contract as an improvement to an existing one
 	Designing an entirely new contract based on requirements (to be provided by verifier)
 	Designing an entirely new contract based an original idea (either their own or the verifier’s idea)



The outcome of a verification session will be one of either:


 	Verified 
 	Unverified

L1 certified participants who do NOT pass verification may reschedule the session 2 times (max 3 attempts) before being waitlisted for 90 days.
L1v verified developers are immediately added to an exclusive group (newsletter, discord, etc) and presented with opportunities to fast-track bounties, grants, etc.

### Activity



### Login with NEAR

Logout

### Near error



### Auth



### Demo quadratic vote with nLEARNs

qVote guide 
            
                301 votes by,
                619 nLEARNs spent
            
            
            
                                    
                        
                            Yes                            
                                (285 votes,
                                597 nLEARNs)
                            
                        
                        
                             
                            95%
                        
                    
                                    
                        
                            No                            
                                (6 votes,
                                10 nLEARNs)
                            
                        
                        
                             
                            2%
                        
                    
                                    
                        
                            Not sure what that even means                            
                                (10 votes,
                                12 nLEARNs)
                            
                        
                        
                             
                            3%

### Guides

This is an example page. It's different from a blog post because it will stay in one place and will show up in your site navigation (in most themes). Most people start with an About page that introduces them to potential site visitors. It might say something like this:




Hi there! I'm a bike messenger by day, aspiring actor by night, and this is my website. I live in Los Angeles, have a great dog named Jack, and I like piña coladas. (And gettin' caught in the rain.)




...or something like this:




The XYZ Doohickey Company was founded in 1971, and has been providing quality doohickeys to the public ever since. Located in Gotham City, XYZ employs over 2,000 people and does all kinds of awesome things for the Gotham community.




As a new WordPress user, you should go to your dashboard to delete this page and create new pages for your content. Have fun!

### Submit guide to publish

Fill this form to publish guide
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Please review carefully and complete ALL the items at the check list below.
It will allow us to publish your guide faster!
If you have any questions please ping at LNC Telegram.Email(Required)
                            
                        First Name(Required)
                            
                            
                                                    
                                                    First Name
                                                
                            
                            
                            
                        Project Title(Required) Website(Required)
                    
                Project type(Required)
								
								NFT
							
								
								DeFi
							
								
								Game
							
								
								Other
							Tell us few words about your project(Required)Check list(Required)
								
								Join LNC Telegram group*
							
								
								Explore a couple of Guides**
							
								
								Guide shall include in-guide mini quizzes to help learners to comprehend major concepts. Usually we have 2 multi-choice and 2 True/False questions. Please put them at the bottom of the Gdoc.
							
								
								LNC co-branded feature image. Recommended size 1200×536 pixels. Please put them at the Top of the Gdoc
							
								
								Login to LNC website with your NEAR account to be added as Author. As LNC Pro Author you will be able to get nLEARNs for viewing your content including quizzes.
							
								
								Mint your self a (L)Earner NFT and set is as profile pic***
							
								
								Submit link to Gdoc with content
							
*LNC Telegram group
 	** Sample Guides - you may refer to  these guides
	  You may find this simple template useful
 	***Mint (L)Earner NFTLink to GDoc with content(Required)
                    
                Desirable publication date
                            
                            MM slash DD slash YYYY

### All  wheels top




## Courses

### NEAR in 2025

First of all - congrats!
You landed here and this is cool - you gonna learn some exciting stuff on the intersection of 2 greatest technologies of 21 century - blockchain and AI.
NEAR evolves fast!
This mini-course will help you to get a quick solid overview of NEAR protocol and its ecosystem in 2025.
We encourage you to try learning together with (L)Earn AI🕺 - your NEAR native verifiable and private(soon) AI assistant dedicated to NEAR and its; ecosystem!



Ask questions, pass quizzes and help us to improve it  - just in one click right at the lesson!
Happy (L)Earning🕺!

### NEAR 101

The best way to start your journey on NEAR!

### Meta Pool Ambassador

This course covers various aspects of Meta Pool's products, services, and community involvement, providing a comprehensive overview for potential ambassadors.

### Desenvolvimento de Smart Contracts na Near Blockchain

Bem-vindo à nossa série abrangente de vídeos dedicados ao desenvolvimento de smart contracts e à integração na Near Blockchain. Nesta série, exploraremos passo a passo como criar contratos inteligentes eficientes e como conectá-los de maneira eficaz a um frontend. Prepare-se para aprofundar seus conhecimentos em blockchain e Near Protocol!
📚 Recursos e Ferramentas:

 	Near SDK para JavaScript:
- GitHub: [Near SDK para JavaScript](https://github.com/near/near-sdk-js)
- Uma ferramenta poderosa para simplificar o desenvolvimento de contratos inteligentes na Near Blockchain usando JavaScript. Acesse o repositório para explorar a documentação e os exemplos práticos.
 	MyNearWallet:
- Website: [MyNearWallet](https://www.mynearwallet.com/)
- Descubra como usar MyNearWallet para gerenciar seus ativos na Near Blockchain. Uma carteira intuitiva e segura para interagir com seus contratos inteligentes.
 	Near CLI - Interface de Linha de Comando:
- Documentação: [Near CLI](https://docs.near.org/tools/near-cli)
- Aprenda a utilizar a interface de linha de comando Near CLI para interagir com a Near Blockchain de forma eficiente. A documentação abrangente será seu guia nesta jornada. 

👉 Inscreva-se agora para receber atualizações sobre os próximos episódios e aprofundar sua compreensão na Near Blockchain!

### NEAR Open Web Certified Developer

 

This course is no longer accepting new learners.

The comprehensive "NEAR Open Web" online dev course, led by the NEAR Balkans Hub, provides the learners with their first exposure to the blockchain realm, NEAR Protocol, the BOS Open Web stack, and hands-on, certified Open Web development experience on the NEAR Protocol.

Here's what you can expect to learn:

 	Understanding the blockchain fundamentals
 	Deep dive into NEAR Protocol
 	Mastering the BOS Open Web stack
 	Building smart contracts on NEAR Protocol
 	Building Open Web decentralized front-ends using the BOS stack.

Who Should Enroll:

 	Web2 developers looking to transition into the exciting world of Web3
 	Web3 developers eager to deepen their understanding of NEAR Protocol.

Course Format:

 	Self-paced online learning modules accessible from anywhere, anytime
 	Engaging tutorials, interactive quizzes, and hands-on coding exercises.

### NEAR Certified Developer 한국어 코스

NEAR Certified Developer(NCD)는 웹 개발자들을 위한 스마트 컨트랙트 학습 프로그램으로 NEAR 프로토콜을 활용하여 스마트 컨트랙트를 설계, 개발, 테스트하고 배포하는 방법을 배울 수 있습니다. 모든 과정을 완수하면, NEAR가 인증한 개발자(NCD)임을 나타내는 인증서를 발부해 드립니다.
목표:
NCD 과정을 완수하면,

 	Web3 애플리케이션에 대한 높은 이해도를 가질 수 있습니다.
 	NEAR에서 구동되는 Web3 애플리케이션의 스마트 컨트랙트를 이해할 수 있게 됩니다.
 	Javascript와 Rust를 사용하여 컨트랙트를 짤 수 있게 됩니다.
 	애플리케이션의 테스트(Unit Test, Integration Test)를 할 수 있게 됩니다.
 	테스트넷에 앱을 배포하고, NEAR CLI와 연동시킬 수 있습니다.
 	프로젝트를 만들고, Demo를 진행할 수 있습니다.

대상:
NCD 프로그램은 NEAR를 통해 개발하는 것에 관심이 있는 모든 사람에게 열려 있습니다. 아래의 조건에 맞는 사람들은 보다 더 쉽게 NCD 프로그램을 이수할 수 있습니다.

 	기본적인 프로그래밍 지식을 갖추고 있고, 1년 이상의 업력을 가진 개발자
 	NEAR 프로토콜을 통해 Web3 제품을 구축하려고 하는 Web3 개발자

프로그램 안내
NCD 프로그램은 온라인 과정으로 총 6단계로 구성되어 있습니다. 각 단계 별 소요 예상시간은 시니어 개발자 기준 2시간 이상, 주니어 개발자 기준으로는 최대 6시간입니다.

NCD 프로그램은 (L)Earn 코스의 일환으로, 가이드에 따라 모든 코스를 수행한 (L)Earner*를 대상으로 최대 $500에 달하는 NEAR를 지급하고 있습니다.

*모든 과정 이수와 함께 DEMO DAY에 어플리케이션 프리젠테이션까지 완료한 수료자 대상

### Master Security for Rust Developers on NEAR Protocol

Welcome to the NEAR Rust Smart contract security course by Timur Guvenkaya.

In this course I aim to teach you NEAR Rust Smart contract security based on my experience and vulnerabilities I discovered.
Code and slide deck : https://github.com/timurguvenkaya/near-sc-security-course

Don't forget to follow me on:
Twitter: https://twitter.com/timurguvenkaya
Lenster: https://lenster.xyz/u/timurguvenkaya
LinkedIn: https://www.linkedin.com/in/timur-guvenkaya/
GitHub: https://github.com/timurguvenkaya
For more Rust and Solidity programming and smart contract security tips and updates.

### Mintbase - build your own NFT market

UPDATE:
Mintbase—now rebranded as Bitte Protocol—has officially phased out its NFT marketplace functionality in favor of AI-driven agent tools, and as a result, the Learn NEAR Club course “Mintbase – Build Your Own NFT Market” is no longer accepting new learners.
Anything we've built on Mintbase, (minter, market, auction, airdrop, redeemer) you can build yourself, and we are pushing to make this easier every day.











































1. We are using the NEAR Protocol










2.Use MintbaseJS for any transactions (writing data to chain)










3.Use our GraphQL indexer to get realtime chain data (who owns what)










4.There is a full testnet environment for testing ui, indexer, and transactions










5.Our Smart Contracts are open-sourced

### Продвинутый ПользовательNEAR

Пройди курс и стань Продвинутым пользователем НИР!

### NEAR Power User

Learn how to use NEAR and become NEAR Power User [NPU]

### Your first smart contract on NEAR

This express-course is designed for those who don’t have programming experience and want to make the first steps to learn how to write smart contracts on NEAR blockchain.

Before we actually start to write a code let’s discuss what is a Smart Contract? A “Smart Contract” is simply a program that runs on the NEAR blockchain. It is a collection of code (its functions) and data (its state) that resides at a specific address on the NEAR blockchain. You can think of a smart contract as an account on the NEAR network, which runs as a program. Users can interact with a smart contract by submitting transactions that execute a function defined on the smart contract. Once deployed on the blockchain the smart contract can not be changed that’s why you need to carefully check your code and test it before deploying it on the blockchain.

Now let’s make further steps to write your first smart contract and deploy it on the NEAR testnet. To do so we need a NEAR account and setting up our IDE (where we actually write our code).

### How to use NEAR in a game

This is the first express course workshop to cover basics of NEAR Protocol being used for game.
Recommended reading

 	App examples on https://examples.near.org
 	"Basics" section of NEAR docs, starting from https://docs.near.org/docs/concepts/account
 	Building smart contracts in AssemblyScript: https://docs.near.org/docs/develop/contracts/as/intro
 	Client-side API quick reference: https://docs.near.org/docs/api/naj-quick-reference
 	NEAR Lands source code: https://github.com/vgrichina/near-lands
 	Berry Club source code: https://github.com/evgenykuzyakov/berryclub

Support

 	Telegram: https://t.me/neardev
 	Discord https://near.chat
 	Docs: https://docs.near.org/

### NEAR 认证开发者（一级）

NEAR 认证开发者（一级）
本课程是 Web 开发者获得证书的机会，该证书代表了在 NEAR 平台上设计、开发、测试和部署智能合约的能力——NEAR 认证开发者 (NCD)。
你会学到什么
web3 技术栈的基础知识包括：

 	应用架构
 	使用 AssemblyScript 和 Rust 开发 NEAR 智能合约
 	合约单元测试和模拟测试
 	NEAR API
 	合约部署和版本升级
 	更多

目标人群：
任何有兴趣在 NEAR 上开发的人。 欢迎非专业开发者参加该课程，但应注意，该材料将针对具有至少 1 年经验的 Web 开发者和接受过编程训练的毕业生量身定制
你需要做什么：
本课程包含6个步骤，仅需要远程参与。需要高级开发者每步至少承诺 2 小时，初级开发者每步最多 6 小时，具体取决于技术经验。

这是一个 Learn+Earn 计划，为合格的学习者提供至多 500美元的 $NEAR 奖励！ 必须完成所有步骤并在 演示日（Demo Day） 提交演示应用程序。

### CHỨNG CHỈ NHÀ PHÁT TRIỂN NEAR (NCD)

Blockchain hiện là xu hướng công nghệ hàng đầu. Với sự bùng nổ từ các sản phẩm tài chính (DeFi), Game (Play-to-Earn) hay GameFi, NFT đã khiến một lượng không nhỏ các nhà tạo lập, nhà đầu tư quan tâm tham gia vào thị trường này. Mang đến cơ hội việc làm với mức lương “khủng” cho các bạn developer. LearnNearClub cho rằng xu hướng này sẽ còn phát triển mạnh mẽ trong vài năm tới.

Theo quan sát, các bạn developer thường gặp rất nhiều khó khăn như sau:

 	Blockchain quá mới nên việc tự học gặp rất nhiều khó khăn, thiếu tài liệu và người hướng dẫn giàu kinh nghiệm.
 	Có nhiều nền tảng blockchain khác nhau, không biết nên bắt đầu từ đâu.
 	Bạn có nhu cầu tích hợp Blockchain vào app nhưng lại không rõ cơ chế và các rủi ro cần phòng tránh. Thiệt hại là rất khủng khiếp!!!
 	Cơ hội việc làm và phát triển sự nghiệp với blockchain tại Việt Nam.

Nắm bắt được nhu cầu này, LearnNearClub và NEARVietnamHub cùng GFI và VBI labs mở ra khoá học hoàn toàn miễn phí cho các bạn developer với việc thiết kế, lập trình, testing và deploy smart contract trên NEAR.
Vậy bạn sẽ học được gì sau khoá học này?

 	Hiểu biết về Web3 và kiến trúc ứng dụng Web3.
 	Xây đựng được NEAR Smart contract với Javascript, Rust, AssemblyScript
 	Unit tests và Integration tests smart contract
 	Tương tác với blockchain qua Near CLI và Near API Js
 	Deploy smart contract, versioning và migrate data
 	Tự xây dựng được sản phẩm cho chính mình
 	Và nhiều điều thú vị khác

Ai có thể tham gia khoá học?

 	Bất kì ai yêu thích và mong muốn học hỏi để có thể xây dựng ứng dụng trên NEAR.
 	Các bạn developers có kiến thức lập trình web căn bản (khoảng 1 năm kinh nghiệm) và hiểu biết về một trong những ngôn ngữ lập trình Javascript, Rust, Assembly Script.

Để hoàn thành tốt khoá học?

 	Khoá học được xây dựng gồm 6 bài học, LNC cần bạn cam kết tham giá ít nhất 2h nếu bạn đang là một junior developer và 1h nếu bạn đang là senior developer, điều này hoàn toàn dự trên kỹ năng và tư duy lập trình của bạn.
 	Bạn sẽ tự mình lên ý tưởng và xây dựng ứng dụng demo cuối khoá, trình bày về sản phẩm của mình trong DEMO DAY. Phần thưởng khi bạn hoàn thành khoá học có thể lên tới 500$, vì vậy hay cố gắng nhé!

Nội dung khoá học:

 	

 	Giới thiệu về NEAR Certified Developer (NCD).
 	Bước 1: Kiến thức và khái niệm cơ bản về Web3.
 	Bước 2: Đọc hiểu và dùng thử ứng dụng Web3 - Bài tập đi kèm.
 	Bước 3: Lập trình ứng dụng Web3 - Bài tập đi kèm.
 	Bước 4: Kiểm thử ứng dụng Web3.
 	Bước 5: Deploy ứng dụng Web3.
 	Bước 6: Lên ý tưởng và lập trình xây dựng sản phẩm Web3.
 	Bước cuối cùng: Submit ứng dụng và trình bày về ứng dụng của bạn trong DEMO DAY.

### Berry Club Bot Workshop

This is a workshop to cover basics of NEAR Protocol smart-contracts written in Rust.
Support

 	Telegram: https://t.me/neardev
 	Discord https://near.chat
 	Docs: https://docs.near.org/

### Бэрри Бот Семинар

На этом семинаре вы познакомитесь с основами разработки смарт-контрактов на языке Rust для NEAR Protocol.
Тех-поддержка

 	Телеграм РУС: https://t.me/near_protocol
 	Телеграм ENG: https://t.me/neardev
 	Discord https://near.chat
 	Документация ENG: https://docs.near.org/
 	Скачать Презентацию Бэрри Бот Семинар

 

### NEAR Certified Developer

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

Objectives
After course completion you will


 	Have a good understanding of the web3 application
 	Be able to understand the smart contract of web3 application built on NEAR
 	Be able to build your own or edit contracts in Javascript and/or Rust
 	Able to know how to use unit tests, and integration tests in the application
 	Deploy the app to testnet and interact with NEAR CLI
 	Build and demo your project.

Audience:
Anyone interested in building on NEAR and best fitted to


 	developers with basic programming knowledge, one year or more of experience
 	experienced builders who want to build their web3 product on NEAR protocol

What you will need to do:
This 6-Steps remote-only program will require a commitment at least 2 hours per Step from senior developers and up to 6 hours per Step for junior developers depending on technical experience.
This is a (L)Earn program with up to $500 in NEAR tokens for qualified (L)Earners*!
*Must complete ALL STEPS and satisfy the following conditions:


 	Present a demo application on DEMO DAY
 	The project MUST bring value to learning community:
- interesting/viral  idea to test at LNC Beta test
- worth to clone GitHub repo that can help other users to learn
- promising project to bring to NEAR mainnet via LNC Barrel

### Build on NEAR

This course will walk through a simple AssemblyScript Smart Contract in NEAR.
We will see how to deploy the smart contract on the Testnet and what are the required installation to set up your working environment.

### NEAR Certified Developer NCDL1C6

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

 

### NEAR Fortified Developer

This program  is for candidates to Learn NEAR Club Barrel - our very own exclusive boutique accelerator.

### NEAR Certified Developer NCDL1C5

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

### NEAR Certified Developer NCDL1C4

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

### NEAR Certified Developer NCDL1C3

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

### NEAR Certified Developer NCDL1C2

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).

### NEAR Certified Developer NCDL1C1

This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform – NEAR Certified Developer (NCD).


## Steps

### Conclusion and NFT Certificate

Great work finishing NEAR 2025.

Keep the momentum - learning sticks when you practice and teach others.
Give NEAR a hands-on try right now!

 	Pick a wallet and create an account. Back up recovery
 	 Try a tiny swap om NEAR Intents
 	 Explore crosschain NFT marketplace
 	 Learn more with (L)Earn AI🕺
 	Mint NFT Certificate

 	Follow and subscribe to NEARWEEK

Happy (L)Earning!

### NEAR Wallets in 2025

The 2025 World of NEAR Wallets: Simple, Secure, and Full of Choice
When NEAR launched in 2020 it had one “official” web wallet. Five years later, that single gate has become a bustling marketplace. The original wallet was shut down in December 2023, and dozens of community-built wallets rushed in to serve different tastes—mobile, web, chat-based, even hardware. For newcomers this variety can feel confusing, but it is good news: more wallets mean more innovation, better security, and true decentralization. This article walks you through why the change happened, what the most popular wallets offer, and how to pick the one that fits you best.

Meet the Leading NEAR Wallets



NEAR Wallet
Where You Use It
What Makes It Special
NEAR Intents Integration
Best For




MyNEARWallet
Web browser
Same look-and-feel as the old official wallet, Ledger support
No
General NEAR holders, stakers, and newcomers who want the “default” NEAR web wallet with Ledger safety


HERE Wallet
Android & iOS app
Mobile‑first NEAR wallet; swap, bridge (incl. Binance), stake (liquid/non‑blocking), gas‑free USDT transfers; connect Ledger/hardware; strong on-device security (PIN, biometrics) and audit history
No
Mobile users who want easy staking + transfers, low fees, and hardware connect on the go


Meteor Wallet
Web, browser extension, mobile
Zero-fee token swaps and built-in bridge, gamified quests
No
DeFi fans and NFT traders who enjoy a playful UI


NEAR Mobile
Android & iOS app
One-tap swaps of BTC, ETH, SOL to NEAR using Intents, password-less FastAuth
Yes
Newcomers who need simple cross-chain actions without jargon


HOT Wallet
Telegram mini‑app + Mobile/Web/Extension
MPC non‑custodial multi‑chain wallet (NEAR, TON, Solana, Tron, EVM + more) with optional 2FA; in‑chat swaps/bridges/staking; NEAR side supports Rhea + Intents swaps, liquid & native NEAR staking, Burrow yields; robust recovery + chain abstraction via HOT Protocol.
Yes
Telegram‑centric users & multi‑chain power users who want one tap trading, staking, and cross‑chain actions from chat.


Intear Wallet
Web (mobile coming)
Fastest wallet that has DEX Aggregator (9 providers in one swap interface), Smart Wallet (recovery via different methods, without seed phrase), Ledger support, Open Sourced
Yes
Memecoin traders, NFT collectors, people who interact with dapps daily






How Wallet Selector Ties It All Together
Opening a dApp and wondering which wallet button to press? NEAR Wallet Selector solves that. It is a pop-up every dApp can add. When you click “Connect,” a list of compatible wallets appears—just choose yours.
The result: you keep your favorite wallet and still enjoy any NEAR application.




Key Takeaways

 	
The closure of the old NEAR wallet sparked a competitive, community-led wallet scene.

 	
Today’s wallets cover every style: web, mobile, extension, chat, and hardware.

 	
Wallet Selector acts as the glue, letting any wallet talk to any dApp

 	
Your best wallet depends on where you spend your time (browser, phone, Telegram) and what features you value most (staking, swaps, multichain, security).

 	
Diversity brings resilience: should one wallet falter, your assets remain safe and movable to another.





Reflective Questions

 	
Which wallet features—staking rewards, cross-chain swaps, or social payments—matter most to your own goals?

 	
How does the Wallet Selector improve user security compared to copying a private key into every dApp?

 	
If a friend new to crypto asked for the simplest way to hold NEAR on their phone today, which wallet would you recommend and why?

### Chain Abstraction on NEAR

The idea in one minute
Most crypto apps make you choose a network, switch wallets, bridge tokens, and approve many steps. Chain abstraction hides that work. You say what you want to do. The system figures out the path across chains and does it for you. On NEAR, this is powered by Intents, Chain Signatures, and the OmniBridge.

What you feel as a user

 	
One account that works across many chains

 	
No network switching

 	
One clear screen, one confirmation

 	
You ask for a result like “swap A to B at the best price” and get it


The building blocks
1) Intents
You describe the goal, not the steps. Solvers compete to fulfill your request and give you a quote. You confirm once. They execute across one or more chains.

2) Chain Signatures
NEAR accounts and smart contracts can securely sign on other chains using a decentralized MPC network. This lets apps act on Bitcoin, Ethereum, and more from one place.

3) OmniBridge
A multi-chain bridge that uses Chain Signatures and chain-specific checks. It moves assets quickly and safely between ecosystems.

Simple example
Without chain abstraction you would bridge, pick venues, approve tokens, and manage fees. With NEAR Intents you submit “swap A to B at the best price,” review the quote, and approve once. The system routes, bridges, and settles in the background.

Why it matters
For users: simple, consistent experience across networks and tokens.For builders: one integration that reaches many chains so you can focus on product.

Key terms

 	
Intent: a request that states the desired result

 	
Solver: a service or agent that fulfills an intent

 	
MPC: multi-party computation used for secure, shared signing


Takeaway
NEAR’s chain abstraction removes chain-level friction. You keep one account, state the goal, and the network handles the steps with Intents, Chain Signatures, and the OmniBridge.

### NEAR and AI

Imagine an internet where helpful software partners keep working after you log off. They pay your bills, book flights, or balance a city’s power grid without taking coffee breaks. Economists say these autonomous agents could unlock trillions of dollars by 2030. Yet the current web, run by a few giant platforms, wasn’t built for programs that must trust, pay, and check one another’s work. NEAR Protocol, a fast public blockchain, wants to fix that. It offers the open road where human users and AI agents can travel safely together.




1. A New Internet of Autonomous Agents
Autonomous agents are small computer programs that decide and act with little help from people. Think of a trading bot that moves money while you sleep, or a voice assistant that orders groceries on its own. The idea of billions of such helpers is called the Agentic Web.
https://learnnear.club/wp-content/uploads/2025/07/the_agentic_web__the_protocol_for_it.mp4



2. Why Today’s Web Holds Them Back
Traditional “Web2” platforms like Google or Amazon keep data behind private gates. That hurts agents in five ways:


 	
Data Silos. Valuable information stays in separate corners of the internet, hard to reach.

 	
No Shared Identity. One agent can’t easily prove it should be trusted by another.

 	
Slow or Costly Payments. Tiny, frequent transfers face bank fees and delays.

 	
Low Transparency. It is tough to verify that an agent really did its job.

 	
Security Risks. Central servers invite hackers and unwanted snooping.


To welcome agents, we need an open foundation where rules are baked into the system rather than enforced by any single company.




3. Blockchain to the Rescue and Why NEAR Shines
A blockchain is a public ledger that anyone can inspect but no one can secretly change. Agents from many creators can meet there, trade value, and leave a clear record. Early blockchains, however, were slow and pricey. NEAR Protocol was built to remove those limits.




4. NEAR’s AI Roots
NEAR was built for AI from day 1.
It might surprise you, but NEAR Protocol’s origins are deeply tied to AI. NEAR was founded in 2017 by Illia Polosukhin and Alex Skidanov – both of whom came from the world of advanced computing and AI research. Illia was actually a co-author of Google’s landmark 2017 paper “Attention Is All You Need” (which introduced the Transformer architecture at the heart of modern AI models like GPT). Alex was a former Microsoft and MemSQL engineer and an ICPC programming champion, with a knack for building scalable systems. The two originally started a project called NEAR.ai with the goal of using AI to write code (a field known as program synthesis). They amassed a dataset of 30,000+ programming problems with millions of solutions to train AI, pushing the boundaries of having machines generate software.
When they moved into blockchains, they kept their focus on massive scale and automation.




5. How NEAR Stays Fast and User Friendly





NEAR Feature
Simple Meaning
Why Agents Care




Sharding
The ledger is split into parallel lanes, so many computers process transactions at once.
Keeps fees tiny (often less than one cent) and confirmations under a second even during heavy traffic.


Readable Accounts
Wallet names look like alice.near instead of long codes.
Easier for both people and programs to map a name to a service.


Fine-Grained Keys
One account can hand out limited keys. Example: “trade this token up to fifty dollars per day.”
Lets you give an AI agent narrow powers without risking your whole balance.


Asynchronous Calls
Programs on different lanes can message each other without waiting.
Supports complex tasks that need many steps at once.











6. Building Blocks Made for AI

 	
NEAR Intents. A user or agent states what it wants, like “Swap one hundred USDC for the best price in BTC.” Competing solvers plan and complete the job in a single secure transaction. Agents write one instruction instead of ten manual steps.

 	
Chain Signatures. A NEAR account can control addresses on blockchains such as Bitcoin or Ethereum through a shared signing service. Agents get one home base yet can act anywhere, without risky bridges.

 	
Confidential Computing. Secure hardware enclaves let smart contracts crunch encrypted data and then prove they followed the rules. A hospital could ask an AI to study scans without exposing raw patient files. Learn with NEAR AI, Phala and XTrace.

 	
Built-In Micropayments. Everything on NEAR is token-based, so an AI model can charge fractions of a cent for each query and get paid instantly. Small developers can earn money without big middlemen.





7. Looking Ahead
As software agents grow smarter, people will ask, “Can we trust them?” A public ledger answers with math, not promises. NEAR’s mix of speed, low cost, cross-chain reach, and privacy tools makes it a real contender for that trust layer. Whether it becomes the universal hub is still unknown, but its AI-first design gives it a head start.




Takeaway
The Agentic Web could bring hands-free services and huge economic gains, but it needs neutral ground where countless agents can meet, trade, and prove they did their work. NEAR Protocol offers that ground. If autonomous agents are indeed the next big thing, a platform like NEAR may be what lets them cooperate safely—and lets the rest of us enjoy the benefits.




Reflective Questions

 	
Which NEAR feature (sharding, intents, chain signatures, or confidential computing) strikes you as most important for autonomous agents, and why?

 	
How might user-friendly account names change everyday use of blockchain apps?

 	
Can you think of a task you handle today that a trustworthy software agent on NEAR could manage for you?

 	
What privacy worries might appear when agents process sensitive data, and how could confidential computing address them?

### NEAR Ecosystem

NEAR in 2025 feels focused. The network positions itself as an execution layer for apps that use agents. Intents let people and software ask for an outcome and let the system handle the steps across chains. The protocol also raised capacity with more shards and shipped features that make code easier to reuse. This guide maps active projects from Learn NEAR Club’s 2025 list and gives you a simple path to try things yourself.

What changed in 2025

 	
Agents and data tools moved from talk to shipping products.

 	
Intents left the demo stage and landed in real wallets and apps.

 	
Throughput increased with an extra shard on mainnet.

 	
Developers gained more reuse with features like global contracts.


Wallets and accounts
NEAR Mobile, Meteor, HERE, Intear Wallet, and HOT Wallet cover most needs. You can create an account, keep recovery simple, and try a swap or a stake without juggling chains. NameSky adds a market for .near accounts. Each wallet has a slightly different flow; pick one and stick with it for a week to build habit.
Explore transactions at Nearblocks and Pikespeak

Infra and developer tools
Near One drives core protocol work. FastNEAR, INTEAR, and other providers keep calls fast and predictable. If you build, you will see lean SDKs, clean docs, and fewer surprises moving from test to prod.

AI, agents, and data
NEAR AI ships research and tooling for user-owned agents. XTrace focuses on private memory. PublicAI organizes human-generated data that models can trust. Together they give agents storage, recall, and cleaner inputs.

Public goods and community
PotLock funds shared tools in the open. DevHub helps teams coordinate. Both reduce the cost of starting something useful.
NEARN  is also worth to check - explore top NEAR projects sponsorships and bounties all in one place!

Projects to try this week

 	
Pick a wallet and create an account. Back up recovery.

 	
Run one intent for a small swap. Notice how few choices you must make.

 	
Explore a marketplace such as HOT Craft and mint or trade a low-cost item.

 	
Support a public good on PotLock, even with a tiny amount.


Want to explore more? Check NEAR Catalog!

### NFTs on NEAR



### NEAR Intents

Introduction
Blockchains are powerful but often feel like puzzles. To make a simple swap, you may need to pick a chain, approve tokens, sign many times, and sometimes even use a bridge. It’s confusing for beginners and inefficient for AI agents that need to act quickly.

NEAR Intents takes a different path. Instead of focusing on steps, it focuses on outcomes. You just say what you want, and a network of competing solvers figures out the safest, cheapest way to make it happen. This outcome-first design makes blockchain easier, faster, and far more user-friendly.
What Is an “Intent”?
An intent is a statement of what you want to happen, not instructions on how to do it.

Example: “Swap 10 NEAR to USDC and send it to my friend.”

 	You define the goal.
 	Solvers compete to fulfill it.
 	The system handles routes, exchanges, and bridges behind the scenes.

Analogy: It’s like ride-hailing. You say “Take me home,” and the system finds a driver, car, and route. You don’t plan every turn. The solver does it for you.

https://learnnear.club/wp-content/uploads/2025/07/near.org_video_long-form_intents_720.mp4
Why Intents Matter
NEAR Intents is built on two key principles:

 	Outcome-driven design

 	You focus on results, not mechanics.
 	Complex actions feel like one step.
 	Less room for mistakes.


 	Multichain by default

 	With Chain Signatures, one NEAR account can act across many blockchains.
 	No fragile bridges.
 	You keep control from a single account.



This makes blockchain less about technical details and more about getting things done. It works for both everyday users and AI agents.
The Key Roles
To understand NEAR Intents, think of it as a small ecosystem where different roles work together:

 	Users and AI Agents: People or programs that state an outcome.
 	Distribution Channels: Wallets, apps, or exchanges where intents are created and managed. Their job is to keep the experience simple.
 	Solvers (Market Makers): Compete to fulfill intents. They provide quotes, source liquidity, and route across chains. More solvers mean better prices.
 	Message Bus (off-chain): A relay that gathers solver quotes and returns them quickly.
 	Verifier (on-chain contract): The settlement layer at intents.near. It secures deposits, executes approved intents, and ensures balances remain safe.

Analogy: Imagine booking a delivery. You confirm one price. The delivery service then coordinates drivers, routes, and hand-offs, all invisible to you.
How an Intent Flows

 	Create the intent: Example: “Swap exactly 10 NEAR to USDC.”
 	Get quotes: The app asks solvers for options. Solvers compete to offer the best deal.
 	Sign and commit: You approve your chosen quote. A signed commitment is prepared.
 	Settle on NEAR: The Verifier contract executes the plan. It moves funds, swaps tokens, and sends them where you asked.

From your point of view, it’s one smooth action with no chains, bridges, or headaches.
Safety First: Deposits and Withdrawals

 	You can deposit tokens before creating an intent, or deposit and execute in one step.
 	Withdrawals are flexible, either through a new intent or a direct call.
 	Works across token standards like fungible tokens, NFTs, and more.

This design balances flexibility with strong protection.
Multichain Made Simple
The secret to NEAR Intents is Chain Signatures:

 	Your NEAR account can sign on other blockchains.
 	No need to hop through fragile bridges.
 	Supported chains and wallets are growing all the time.

It feels like one account, everywhere.
Tools for Builders
Developers can integrate NEAR Intents in different ways:

 	Message Bus API: Request quotes quickly from multiple solvers.
 	1Click API: Simplifies the full flow into a single, easy call.
 	SDK and State Machines: Model complex flows and edge cases.
 	Direct Verifier Calls: Power users can interact directly with the on-chain contract.

Takeaway
NEAR Intents makes blockchain human-friendly. Instead of managing chains, bridges, and approvals, you just state your outcome. Solvers compete to deliver the best path, and the Verifier contract secures the result. The approach reduces friction, cuts errors, and unlocks new applications in DeFi, commerce, and real-world services.

By focusing on what you want, not how to get it, NEAR Intents opens the door to a smoother, smarter, and more accessible blockchain future.
Want to go deeper? Explore this How to read any NEAR Intents transaction
Reflective Questions

 	Why does an outcome-first model make blockchain easier for beginners?
 	How do Chain Signatures help intents work across multiple blockchains?
 	Which everyday service could you imagine being powered by intents?
 	What safety features (like deposits, withdrawals, or simulations) make you more confident about using intents?

### What is NEAR Protocol?

Introduction
Imagine a busy city where new roads appear automatically whenever traffic grows, toll booths charge less than a cent, and drivers never wait at red lights for more than a second. That is the promise of NEAR Protocol—a next-generation public blockchain designed for both speed and ease of use. Whether you want to build an app, swap tokens, or let an AI agent act on your behalf, NEAR aims to make the experience simple, cheap, and reliable. Let’s explore how it works and why it matters for everyday users and developers alike.




1. What Exactly Is NEAR Protocol?
NEAR is a layer-1 blockchain—the base network on which applications run—created to support millions of users without slowing down. Since launching in 2020, it has processed peaks of over 13 million transactions with zero downtime. Unlike earlier blockchains that struggle as they grow, NEAR was built from day one to scale horizontally, much like cloud servers that add more machines when demand spikes.
Key facts at a glance:


 	
Average block time: 600 milliseconds (how often a new block is produced).

 	
Finality: 1.2 seconds (the point at which a transaction cannot be reversed).

 	
Current size: 9 shards (explained next) and around 300 validator nodes keeping the network secure.
https://learnnear.club/wp-content/uploads/2025/07/near.org_video_short-form_blockchain_tiny.mp4




2. Scaling Through Nightshade Sharding
Think of a freeway that splits into extra lanes during rush hour and merges back when traffic is light. NEAR achieves this with Nightshade 2.0 sharding. A shard is a smaller piece of the network that processes its own set of transactions. By adding or removing shards dynamically, NEAR avoids bottlenecks and keeps fees low.


 	
Linear throughput growth: Doubling shards nearly doubles capacity. The network’s jump from 8 to 9 shards happened with no service interruption. NEAR engineers plan a path toward 100+ shards, setting the stage for mass-market apps.

 	
Real-world analogy: Picture a supermarket that opens new checkout counters the moment queues form, so no customer waits more than a minute.





3. Speed, Cost, and Reliability
Fast confirmation times matter because they shape user experience. Waiting ten minutes for a payment to clear is unacceptable for most everyday tasks.


 	
Block time (600 ms): Comparable to the blink of an eye.

 	
Finality (1.2 s): Your transaction is locked in before you finish a short sentence.

 	
Fees (< 1 US cent): Because capacity keeps pace with demand, prices stay predictable.


NEAR Core 2.6, the latest software release, also lets popular smart contracts be deployed once and reused across shards. This shared-library model lowers costs for builders and ultimately for users.




4. A Blockchain Designed for Everyday Users
Traditional crypto wallets display long strings like 0x83a…f9B. NEAR replaces these with named accounts such as alice.near, making addresses as memorable as email handles.
Other user-centric features include:


 	
Access Keys: One account can hold multiple keys, each with specific permissions. Imagine lending a spare apartment key that only opens the lobby, not your flat.

 	
Gasless experience: With meta-transactions (someone else covers the network fee), newcomers can interact without first buying tokens.

 	
Simple sign-up: Create an account using email or Telegram—no seed phrase required at first touch.

 	
Chain Signatures: A recent upgrade adds EdDSA cryptography, allowing NEAR accounts to sign actions on other chains like Solana or TON. This is similar to a universal remote that controls multiple TVs.





5. A Productive Platform for Developers
NEAR’s smart-contract runtime supports Rust and JavaScript—languages millions already know. This lowers the learning curve compared with chains that require niche languages.
Why builders appreciate NEAR:


 	
Earn as they run: When users call a contract, 30 % of the gas burned (destroyed) is rerouted back to the developer as revenue.

 	
Account abstraction (built-in): Complex wallet logic, subscription models, or social-login flows can be coded directly in the protocol layer, not bolted on later.

 	
Tooling and docs: Rich libraries, clear tutorials, and an active open-source community speed up development.


Real-world example: A gaming studio launches an on-chain collectibles marketplace. Players sign in with email, buy items for pennies in fees, and the studio earns passive income every time its contract executes—without managing separate servers.




6. The New Operating Layer for AI
AI agents need a fast, low-cost ledger to store results, coordinate with other agents, and exchange value. NEAR’s dynamic sharding, near-instant finality, and upcoming private execution (encrypted computing that hides sensitive data) give machine intelligence a blockchain it can actually use. Picture thousands of AI “micro-apps” doing tasks for you—booking flights, rebalancing portfolios—while settling safely on NEAR.




Takeaway
NEAR Protocol blends cloud-style scalability, human-friendly design, and robust incentives for developers. Its combination of speed, cost efficiency, and multichain compatibility positions it as a strong foundation for the next wave of consumer apps and autonomous AI agents. If you are exploring blockchain for the first time, NEAR offers a gentle on-ramp without sacrificing performance.




Reflective Questions

 	
In your own words, how does Nightshade sharding keep the NEAR network from slowing down as more people use it?

 	
Which feature—named accounts or gasless transactions—do you think removes the biggest barrier for beginners, and why?

 	
Imagine an AI assistant that books travel for you. How could NEAR’s fast finality and cross-chain signatures make that assistant more reliable?

### What makes NEAR special?



### Conclusion

👍Great job, (L)earner!🕺

Now that you successfully passed the 101 course you are eligible to mint Learn NEAR Club membership NFT  - 🕺LNCer🕺.

Mint yours now!

This is just the beginning of your jorney in web3 and NEAR!

Welcome to the Club and we encourage you to explore 📚(l)earning🕺 opportunities!

### Understanding NEAR Tokens

​In the NEAR Protocol ecosystem, tokens are digital assets that facilitate various operations and interactions. These tokens are primarily categorized into two types: Fungible Tokens (FTs) and Non-Fungible Tokens (NFTs).​
Fungible Tokens (FTs):
Fungible tokens are interchangeable assets where each unit holds the same value and characteristics as another. This uniformity makes them suitable for use as currencies or utility tokens within decentralized applications (dApps). For instance, one NEAR token is equivalent in value to another NEAR token. In the NEAR ecosystem, FTs are implemented following the NEP-141 standard, which defines the core functionalities and interfaces for these tokens.​
Non-Fungible Tokens (NFTs):
Conversely, non-fungible tokens represent unique, indivisible assets. Each NFT has distinct metadata and properties, making it ideal for representing ownership of digital art, collectibles, or virtual real estate. On NEAR, NFTs adhere to the NEP-171 standard, ensuring a consistent approach to their creation and management across the platform.​
Key Differences Between FTs and NFTs:


 	
Interchangeability: FTs are interchangeable; each unit is identical to another. NFTs are unique, with each token representing a distinct item or piece of content.​

 	
Divisibility: FTs can be divided into smaller units (e.g., NEAR tokens can be split into fractions). NFTs are indivisible; they exist as whole items.​

 	
Use Cases: FTs are commonly used for currencies, staking, or utility purposes within dApps. NFTs are utilized for representing ownership of unique items like digital art, music, or in-game assets.​


Understanding these distinctions is crucial for developers and users interacting with the NEAR Protocol, as it informs the design and utilization of digital assets within the ecosystem.

### Examining NEAR Transactions

Now let's learn about NEAR Transactions.
In the NEAR Protocol, transactions are the means by which users interact with the blockchain—whether it's transferring tokens, deploying smart contracts, or engaging with decentralized applications (dApps). Here's a straightforward breakdown of how transactions work:​
1. Initiating a Transaction: When you decide to perform an action on the NEAR blockchain—like sending NEAR tokens to a friend—you create a transaction. This transaction includes details such as:​


 	
Sender (Signer): Your NEAR account initiating the transaction.​

 	
Receiver: The NEAR account intended to receive the tokens or interact with your action.​

 	
Action: The specific operation you're performing, such as transferring tokens or calling a function in a smart contract.​


2. Signing the Transaction: To ensure authenticity and security, you sign the transaction with your private key. This digital signature verifies that the transaction is genuinely from you and hasn't been tampered with.​
3. Broadcasting to the Network: Once signed, your transaction is broadcasted to the NEAR network. Here, validators—special nodes responsible for verifying transactions—receive and process it.​
4. Validation and Inclusion in a Block: Validators check the transaction for correctness, ensuring you have sufficient funds and that all details are accurate. Valid transactions are then grouped into blocks and added to the blockchain, making them a permanent part of the ledger.​
5. Transaction Fees (Gas): Executing transactions consumes computational resources. To account for this, NEAR requires a fee, often referred to as "gas." The amount depends on the complexity of the transaction—the more complex, the higher the fee. These fees incentivize validators and help maintain network health.​
6. Confirmation and Finality: After inclusion in a block, transactions achieve finality, meaning they're permanently recorded and cannot be altered. NEAR's design ensures rapid finality, typically within seconds, providing users with quick and reliable transaction confirmations.​
Understanding this flow is essential for anyone interacting with the NEAR Protocol, as it ensures clarity on how actions are processed and recorded on the blockchain.

### Learn about Seed Phrase

Let's learn what is Seed Phrase and How it works.
💡HINT: Ask (L)Earn AI about the topic and provide your feedback 👍 or 👎 to get more nLEARNs


In the NEAR Protocol, a seed phrase—also known as a recovery phrase or passphrase—is a sequence of 12 to 24 randomly generated words that serves as a master key to access and manage your cryptocurrency wallet. This phrase is crucial for signing transactions and recovering your wallet if your device is lost or damaged.
When you create a NEAR wallet, you're provided with a unique seed phrase. This phrase encodes your private key, allowing you to control your wallet and its associated assets. It's essential to store your seed phrase securely, preferably offline, as anyone with access to it can control your funds. ​
In addition to the seed phrase, NEAR Wallet supports key recovery via SMS, offering an alternative method to recover your account. ​
To enhance security, consider using hardware wallets like Ledger Nano S or X, which store your private keys offline, providing robust protection against online threats. ​
Remember, safeguarding your seed phrase is paramount. If it's lost or compromised, recovering your assets becomes exceedingly difficult, if not impossible. Always keep your seed phrase confidential and stored in a secure location

### Intro

First Steps

                 
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        NEAR Account*

### Meta Pool Improvement Proposals

Carefully read third module Meta Pool Improvement Proposals  and answer ALL quizzes

### Participating in Meta Pool’s governance

Carefully read forth module Participating in Meta Pool’s governance  and answer ALL quizzes

### Decentralized Finances x Meta Pool

Carefully read third module Decentralized Finances x Meta Pool  and answer ALL quizzes

### Step



### Crowdfunding on Meta Pool

Carefully read first second module Crowdfunding on Meta Pool and answer ALL quizzes



 

### Staking with Meta Pool

Carefully read first module Staking with Meta Pool and answer ALL quizzes

### Paso 11

Por fim, vamos testar a parte de votar:
test("can vote", async (t) => {
  const { contract, root } = t.context.accounts
  
  const now = new Date().getTime()

  // Crea la elección
  await root.call(contract, "create_election", {
    endsAt: now + 1000 * 60 * 60,
    name: "Test Election",
    startsAt: now, 
  })

  // Agrega el candidato
  await root.call(contract, "add_candidate_to_election", {
    accountId: "test.accountId", 
    electionId: 0
  })

   // Agrega otro candidato
   await root.call(contract, "add_candidate_to_election", {
    accountId: "test.accountId2", 
    electionId: 0
  })

  // Vota
  await root.call(contract, "vote", {
    electionId: 0,
    candidateId: "test.accountId"
  })

  const election: Election = await contract.view("get_election", { electionId: 0 })

  const candidates: Candidate[] = election.candidates

  t.is(candidates[0].totalVotes, 1)
  t.is(candidates[1].totalVotes, 0)
})
Novamente, criamos uma eleição, adicionamos candidatos fictícios e chamamos a função *vote*. Lembre-se que nessa função o timestamp na criação de eleição é importante, uma vez que não será possível votar se a eleição não estiver acontencendo e nosso teste falhará.
Por fim, retornamos os candidatos da eleição e verificamos o número de votos dos mesmos utilizando o método *is*, que verifica o valor de uma variável.

Agora que criamos o testes, podemos executá-los utilizando o seguinte comando no terminal:

npm run test

Caso todos passem, parabéns! Você concluiu com êxito esse curso e seu contrato pode ser deployado com mais segurança!

### Contrato - Recapitulação

Agora vamos testar a adição de candidatos em uma eleição
test("candidate can be added to election", async (t) => {
  const { contract, root } = t.context.accounts
  
  const now = new Date().getTime()

  // Crea la elección
  await root.call(contract, "create_election", {
    endsAt: now + 1000 * 60 * 60,
    name: "Test Election",
    startsAt: now, 
  })

  // Agrega el candidato
  await root.call(contract, "add_candidate_to_election", {
    accountId: "test.accountId", 
    electionId: 0
  })

  // Obtiene todos los candidatos de la elección
  const election: Election = await contract.view("get_candidates_by_election", { electionId: 0 })

  const candidate: Candidate = election.candidates[0]

  t.deepEqual(candidate, { 
    accountId: 'test.accountId', totalVotes: 0 
  })
})
Como a gente reinicia o ambiente após cada teste, devemos criar uma nova eleição antes de adicionar um candidato. Lembre-se das nossas validações no contrato.
Após adicionar um candidato a essa eleição, usando o método *deepEqual* para verificar a equidade dos objetos.

https://www.youtube.com/watch?v=H3n9PgJky0o&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=10

### Contrato - Parte 9

Vamos começar testando se uma eleição pode ser criada
test("election can be created", async (t) => {
  const { contract, root } = t.context.accounts
  
  const now = new Date().getTime()

  // Crea la elección
  await root.call(contract, "create_election", {
    endsAt: now + 1000 * 60 * 60,
    name: "Test Election",
    startsAt: now, 
  })

  const election: Election = await contract.view("get_election", { electionId: 0 })

  t.not(election, null)
})
Estamos retornando *contract* e *root*, onde *root* é uma conta de testes e *contract* é a sub conta na qual o contrato foi deployado. Utilizamos *root* para chamar o método *create_election* de nosso contrato, simulando um endereço de carteira criando uma eleição.
Os dados da eleição não tem relevância nessa parte, portanto não dê ênfase a isso no momento. Após isso, verificamos se ela foi criada fazendo uma chamada para o método *get_election* passando o id = 0 e verificando se o objeto retornado é diferente de null.

https://www.youtube.com/watch?v=A8XAOHbOqxs&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=9

### Contrato - Parte 8

Agora que finalizamos nosso contrato, é hora de escrevermos alguns testes. Testes podem ser feitos localmente, como faremos, e também podem ser feitos utilizando a Near CLI que é uma ótima prática antes de fazer o deploy de seu contrato de fato.
Vá na pasta *sandbox-ts/src/main.ava.ts* e remova todos os testes criados por padrão quando criamos um projeto. Seu arquivo deve ficar assim:
import { Worker, NearAccount } from 'near-workspaces';
import anyTest, { TestFn } from 'ava';

const test = anyTest as TestFn<{
  worker: Worker;
  accounts: Record<string, NearAccount>;
}>;

test.beforeEach(async (t) => {
  // Inicia el worker y comienza un servidor Sandbox
  const worker = await Worker.init();

  // Implementa el contrato
  const root = worker.rootAccount;
  const contract = await root.createSubAccount('test-account');
  // Obtén la ruta del archivo wasm desde el script de prueba package.json en la carpeta superior
  await contract.deploy(
    process.argv[2],
  );

  // Guarda el estado para las ejecuciones de prueba, es único para cada prueba
  t.context.worker = worker;
  t.context.accounts = { root, contract };
});

test.afterEach.always(async (t) => {
  // Detén el servidor Sandbox
  await t.context.worker.tearDown().catch((error) => {
    console.log('Failed to stop the Sandbox:', error);
  });
});
Resumidamente, antes de cada teste(beforeEach) estamos criando um worker, que é o executor dos nossos testes, criando uma conta teste e fazendo o deploy do contrato em uma sub conta da mesma. Após cada execução de cada teste(afterEach), nós vamos encerrar nosso worker, o que irá limpar o estado do mesmo.
Estamos fazendo isso para garantir que sempre teremos um ambiente "limpo" para a execução de cada teste, para que cada um ocorra de forma isolada sem interferir nos demais. Não alteraremos essas partes.

https://www.youtube.com/watch?v=_elCxgx2scI&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=8

### Contrato - Parte 7

Antes de votar em um candidato devemos validar se a eleição está ou não ocorrendo. Não será possível votar se a eleição não estiver entre o startsAt e endsAt.
Portanto, vamos criar uma função de suporte para lidar com isso no mesmo arquivo:
verifyElectionIsHappening(electionId: number): boolean {
  const election = this.elections.get(String(electionId))

  const now = near.blockTimestamp()

  const isHappening = election.startsAt < now && election.endsAt > now

  return isHappening
}
Nota que estamos usando el objeto `near`. Se importa del SDK de NEAR y nos da acceso a mucha información, incluido `blockTimestamp`. `blockTimestamp` es el momento en que se está ejecutando el método del contrato, la marca de tiempo.

Ahora creemos nuestra función de voto:
@call({})
vote({ electionId, candidateId }: { electionId: number, candidateId: string }): void {
  const election = this.elections.get(String(electionId))
  assert(election !== null, "Election not found.")

  const electionIsHappening = this.verifyElectionIsHappening(electionId)
  assert(electionIsHappening, "Election has not started or has already been finished.")

  const alreadyVoted = election.voters.filter(({ accountId }) => {
    return accountId === near.signerAccountId()
  }).length > 0
  assert(!alreadyVoted, "User has already voted. Reverting call.")

  const candidate = election.candidates.filter(({ accountId }) => {
    return accountId === candidateId
  })[0]

  assert(typeof candidate !== 'undefined', "Candidate not found. Reverting call.")

  const voter = new Voter({ accountId: near.signerAccountId(), votedCandidateAccountId: candidate.accountId, votedAt: near.blockTimestamp() })

  election.voters.push(voter)
  election.totalVotes += 1
  election.candidates.filter((candidateFilter) => {
    return candidateFilter.accountId === candidate.accountId
  })[0].totalVotes += 1
  this.elections.set(String(electionId), election)
}
Novamente utilizamos o *assert* para validações na função. Perceba também que estamos utilizando *near.signerAccountId()* que é o endereço da carteira Near que está chamando a função.
No final da função, basicamente atualizamos o array de eleitores, o número de votos da eleição, o número de votos do candidato votado, o qual receberemos o ID dos parâmetros do método e, por fim, atualizamos a eleição do UnorderedMap com o objeto atualizado.
Além disso, validamos algumas questões no nosso método de voto:
- Se o eleitor já votou.
- Se o candidato existe de fato.
- Se a eleição está ocorrendo.

https://www.youtube.com/watch?v=Q5ZsZ3T0VsE&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=7

### Contrato - Parte 6

Após criar uma eleição, o próximo passo será adicionar um candidato a mesma.

Antes de adicionarmos um candidato à uma eleição, devemos validar se ele já não existe, portanto, vamos criar uma função de suporte para isso:
verifyCandidateExistence(candidateId: string, electionId: number): boolean {
  const candidates = this.elections.get(String(electionId)).candidates

  if (candidates === null) {
    return false
  } else {
    const candidate = candidates.filter(({ accountId }) => {
      return accountId === candidateId
    })
    
    const exists = candidate.length > 0

    return exists
  }
}
No fim, seu código deve ficar assim:
import { NearBindgen, UnorderedMap, assert, call, initialize, near, view} from 'near-sdk-js';
import { Candidate, Election } from './model';

@NearBindgen({})
class VotingNear {
  electionsCounterId: number
  elections: UnorderedMap<Election> = new UnorderedMap<Election>("elections")

  @initialize({})
  init() {
    this.electionsCounterId = 0
  }

  @view({})
  get_all_elections() {
    return this.elections.toArray().reverse() // reverse() is being called in order to get from newest to oldest
  }

  @view({})
  get_election({ electionId }: { electionId: number }): Election {
    return this.elections.get(String(electionId))
  }

  @call({})
  create_election({ endsAt, name, startsAt }: Election): void {
    const election = new Election(
      { 
        id:

 this.electionsCounterId,
        startsAt: BigInt(Number(startsAt) * 10 ** 6), // Convertir milisegundos de JavaScript a nanosegundos estándar del blockchain NEAR
        endsAt: BigInt(Number(endsAt) * 10 ** 6), // Convertir milisegundos de JavaScript a nanosegundos estándar del blockchain NEAR
        name, 
        candidates: [], 
        voters: [],
        totalVotes: 0 
      }
    )
    this.elections.set(String(this.electionsCounterId), election)


    this.electionsCounterId += 1
  }

  @call({})
  add_candidate_to_election({ accountId, electionId }: { accountId: string, electionId: number }): void {
    const electionToAddCandidate = this.elections.get(String(electionId))
    assert(electionToAddCandidate !== null, "Election not found.")

    const candidateAlreadyExists = this.verifyCandidateExistence(accountId, electionId)
    assert(!candidateAlreadyExists, "Candidate already exists. Reverting call.")

    const candidate = new Candidate({ accountId, totalVotes: 0 })

    electionToAddCandidate.candidates.push(candidate)
    this.elections.set(String(electionId), electionToAddCandidate)
  }

  verifyCandidateExistence(candidateId: string, electionId: number): boolean {
    const candidates = this.elections.get(String(electionId)).candidates

    if (candidates === null) {
      return false
    } else {
      const candidate = candidates.filter(({ accountId }) => {
        return accountId === candidateId
      })
      
      const exists = candidate.length > 0
  
      return exists
    }
  }
}
Duas coisas importantes para ressaltar aqui são o método *assert* e a forma que criamos a função suporte:
- O assert vai verificar uma condição, se retornar *true* a função continuará sua execução, se retornar false, ela irá encerrar sua execução, devolvendo um erro.
- Perceba que a função *verifyCandidateExistence* não é criado com um decorator anterior a ela. Isso ocorre porque ela é apenas usada internamente e não será um método de nosso contrato.

Perceba que para essa função usamos a classe Candidate, assim como usamos a classe Election para a tipagem da nossa variável *elections* e para a criação da mesma. Esse é o motivo de termos exportado elas do nosso *model.ts*

https://www.youtube.com/watch?v=kBvdBJaOvJI&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=6

### Contrato - Parte 5

Agora podemos começar com nossa função de criar eleição. Uma vez que ele irá atualizar dados na blockchain, ela será do tipo *call*
@call({})
create_election({ endsAt, name, startsAt }: Election): void {
  const election = new Election(
    { 
      id: this.electionsCounterId,
      startsAt: BigInt(Number(startsAt) * 10 ** 6), // Convertir milisegundos de JavaScript a nanosegundos estándar del blockchain NEAR
      endsAt: BigInt(Number(endsAt) * 10 ** 6), // Convertir milisegundos de JavaScript a nanosegundos estándar del blockchain NEAR
      name, 
      candidates: [], 
      voters: [],
      totalVotes: 0 
    }
  )
  this.elections.set(String(this.electionsCounterId), election)
  this.electionsCounterId += 1
}
Em toda criação de eleição, eleitores e candidatos não existirão ainda, assim como os votos. Portanto, inicializaremos ambos como arrays vazios e os votos como 0. Ao fim da execução, devemos atualizar nosso
UnorderedMap e adicionar nossa nova eleição ao mesmo, usando o ID da mesma como key para referenciá-la.
Além disso, devemos incrementar nosso *electionCounterId* para que não haja eleições com mesmo ID uma vez que isso quebraria nossa aplicação.

Por que estamos multiplicando o startsAt e endsAt por (10 ** 6)? Porque o javascript utiliza milissegundos como timestamp (10 ** 3), enquanto a Near utiliza nanossegundos para o blocktimestamp(10 ** 9).
Considerando que o startsAt e endsAt virão de um frontend, devemos convertê-lo.

https://www.youtube.com/watch?v=Z3W6EoXhJmU&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=5

### Contrato - Parte 4

Agora que já temos as classes e tipagens da aplicação, vamos começar criando nossos métodos de ler dados da blockchain utilizando *view*.
Vamos criar duas funções:
- Listar todas as eleições
- Listar eleição por ID

Para pegarmos uma eleição por ID, vamos utilizar o ID da mesma como chave em nosso UnorderedMap. Para os IDs nesse projeto iremos utilizar um incremento simples no valor:
import { NearBindgen, UnorderedMap, initialize, view} from 'near-sdk-js';
import { Election } from './model';

@NearBindgen({})
class VotingNear {
  electionsCounterId: number
  elections: UnorderedMap<Election> = new UnorderedMap<Election>("elections")

  @initialize({})
  init() {
    this.electionsCounterId = 0
  }

  @view({})
  get_all_elections() {
    return this.elections.toArray()
  }

  @view({})
  get_election({ electionId }: { electionId: number }): Election {
    return this.elections.get(String(electionId))
  }
}
 

https://www.youtube.com/watch?v=xJeA4-IhyNU&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=4

### Contrato - Parte 3

Pensando em um contrato para eleições, vamos considerar as principais funcionalidades:
- Criar eleição
- Adicionar candidato à eleição
- Votar

Para iniciar, vamos criar uma variável onde iremos armazenar todos os dados da eleição, como número de votos, candidatos, tempo de início e encerramento, eleitores e todas as tipagens relacionadas à variável.
import { NearBindgen} from 'near-sdk-js';

@NearBindgen({})
class VotingNear {
  elections: UnorderedMap<Election> = new UnorderedMap<Election>("elections")
}
Para organizar mejor nuestro proyecto, crea un archivo `src/model.ts` para definir nuestras clases para Elección.
export class Election {
  id: number
  name: string
  startsAt: bigint
  endsAt: bigint
  candidates: Candidate[]
  totalVotes: number
  voters: Voter[]

  constructor({ endsAt, id, name, startsAt, candidates, totalVotes, voters }: Election) {
    this.id = id
    this.endsAt = endsAt
    this.name = name
    this.startsAt = startsAt
    this.totalVotes = totalVotes
    this.candidates = candidates
    this.voters = voters
  }
}

export class Candidate {
  accountId: string
  totalVotes: number

  constructor({ accountId }: Candidate) {
    this.accountId = accountId
    this.totalVotes = 0
  }
}

export class Voter {
  accountId: string
  votedCandidateAccountId: string
  votedAt: bigint

  constructor({ accountId,  votedCandidateAccountId, votedAt }: Voter) {
    this.accountId = accountId
    this.votedCandidateAccountId = votedCandidateAccountId
    this.votedAt = votedAt
  }
}
Para organizar melhor nosso projeto, crie um arquivo src/model.ts para criarmos nossas classes para Election.

https://www.youtube.com/watch?v=N0oOC8h0BBo&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=3

### Contrato - Parte 2

Com o projeto criado, vamos começar limpando nossa src/contract.ts até que fique assim:
import { NearBindgen} from 'near-sdk-js';

@NearBindgen({})
class VotingNear {}
 

https://www.youtube.com/watch?v=8a33NqKNaYQ&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=2

### Contrato - Parte 1

Primeiramente, vamos criar um projeto de smart contract usando o comando a seguir no terminal

npx create-near-app@latest

Usando as setas do teclado, selecione a opção de Smart Contract e a linguagem JS/TS.

https://www.youtube.com/watch?v=yHLExRIukks&list=PLBGoiE3f9hHD5Ya-QhXqzAdeJk8WMI_vZ&index=1

### Intro

First Steps
Please complete the following as soon as possible  It is essential for the success of this program to coordinate our activities and this will help us do just that.
Add our Telegram bot to monitor your accounts:

Mainent:  https://t.me/nearwatchbot

Testnet:  https://t.me/LNC_testenet_watcher_bot


                
                        
                            NEAR Open Web Certified Developer
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account*

### Module4: Building Smart Contract on NEAR

This module focuses on setting up the development environment for deploying smart contracts on the NEAR Protocol, and deployment of a simple smart contract.
Setting up NEAR Command Line Interface (CLI)
The NEAR Command Line Interface (CLI) is a tool that enables users to interact with the NEAR network directly from the shell. Among other things, the NEAR CLI enables you to:

 	Login with a NEAR account
 	Deploy a contract
 	Interact and query information from a deployed contract

Installation Mac and Linux

 	

 	 Install npm and node using a package manager like nvm as sometimes there are issues using Ledger due to how OS X handles node packages related to USB devices. [click here]
 	Ensure you have installed Node version 12 or above.
 	Install near-cli globally by running:
npm install -g near-cli



Note: Make sure you have a current version of npm and NodeJS installed.
Installation Windows

 	Install WSL [click here]
 	Install npm [click here]
 	Install Node.js [click here]
 	Change npm default directory [click here] 

 	This is to avoid any permission issues with WSL


 	Open WSL and install near-cli globally by running:
npm install -g near-cli

Note: For Windows users, we recommend using Windows Subsystem for Linux (WSL).
Connecting your wallet
For deploying and management of smart contracts you will need to dedicate a NEAR Account. You can either use your wallet, or dedicate a fresh NEAR Wallet for deployment. The command for connecting  is” near login”, which opens a web page to authorise the CLI.

near login

After logging in you can verify your connection and see the details of your NEAR Wallet using:

near state <your-account-name>
Building the smart contract
import { NearBindgen, near, call, view, UnorderedMap } from 'near-sdk-js';
import { AccountId } from 'near-sdk-js/lib/types';

type Side = 'heads' | 'tails'

function simulateCoinFlip(): Side {
  // randomSeed creates a random string, learn more about it in the README
  const randomString: string = near.randomSeed().toString();

  // If the last charCode is even we choose heads, otherwise tails
  return randomString.charCodeAt(0) % 2 ? 'heads' : 'tails';
}


@NearBindgen({})
class CoinFlip {
  points: UnorderedMap<number> = new UnorderedMap<number>("points");

  /*
    Flip a coin. Pass in the side (heads or tails) and a random number will be chosen
    indicating whether the flip was heads or tails. If you got it right, you get a point.
  */
  @call({})
  flip_coin({ player_guess }: { player_guess: Side }): Side {
    // Check who called the method
    const player: AccountId = near.predecessorAccountId();
    near.log(`${player} chose ${player_guess}`);

    // Simulate a Coin Flip
    const outcome = simulateCoinFlip();

    // Get the current player points
    let player_points: number = this.points.get(player, { defaultValue: 0 })

    // Check if their guess was right and modify the points accordingly
    if (player_guess == outcome) {
      near.log(`The result was ${outcome}, you get a point!`);
      player_points += 1;
    } else {
      near.log(`The result was ${outcome}, you lost a point`);
      player_points = player_points ? player_points - 1 : 0;
    }

    // Store the new points
    this.points.set(player, player_points)

    return outcome
  }

  // View how many points a specific player has
  @view({})
  points_of({ player }: { player: AccountId }): number {
    const points = this.points.get(player, {defaultValue: 0})
    near.log(`Points for ${player}: ${points}`)
    return points
  }
}
Code source: https://github.com/near-examples/coin-flip-js/blob/main/contract/src/contract.ts
Code explanation
Import Statements:

 	NearBindgen, near, call, view, UnorderedMap: Imported from near-sdk-js, these are essential for smart contract functionality.
 	AccountId: Used for identifying NEAR account IDs.

Type Declaration - ‘Side’:

 	Defines a custom type ‘Side’ with two possible values, 'heads' or 'tails'.

Function ‘simulateCoinFlip’:

 	Simulates a coin flip.
 	Uses ‘near.randomSeed()’ to generate a random string, and determines the outcome based on the last character's ASCII code.

Smart Contract Class - ‘CoinFlip’:

 	Contains a map ‘points’ to store player scores.
 	Two main methods: ‘flip_coin’ and ‘points_of’.

Method ‘flip_coin’:

 	A callable method (‘@call’ decorator) allowing players to guess the coin flip outcome.
 	Determines the caller (‘player’) using ‘near.predecessorAccountId()’.
 	Calls ‘simulateCoinFlip’ to get the coin flip result.
 	Updates the player's points based on whether their guess was correct.
 	Logs actions and results for transparency.

Method ‘points_of’:

 	A viewable method (‘@view’ decorator) that returns a player’s points.
 	Retrieves points from the ‘points’ map.
 	Logs the query for record-keeping.

Bonus resources

 	 https://www.youtube.com/watch?v=QYNyC6__pw8
 	 https://docs.near.org/develop/quickstart-guide
 	 https://docs.near.org/tools/near-cli

### Module3: Build your decentralized message board

In this module, we will guide you through setting up your development environment on near.org. We will be developing a decentralized message board and deploying it on the Open Web. Let's dive into the code and explain its functionality step by step.
Development Environment Setup
Accessing the Workspace: To start, visit near.org, and log in with your NEAR Wallet, and then navigate to the "Develop" section in the navigation bar. Look for "Sandbox."



Understanding the Sandbox: Familiarize yourself with the Sandbox environment. This is your secure space for experimenting with component development.



The NEAR Sandbox environment, is an IDE for creating, inspecting, modifying, and composing components and dApps on the Open Web. The UI shows a list of components, such as CollectionSelector and EventPlanner, suggesting a modular approach to building applications. Users can create new components, view and edit properties and metadata, and manage their projects. Features like "Save Version," "Fork," and "Publish" imply version control and deployment capabilities, while "Render Preview" suggests the ability to visualize components in real-time.
Code
const accountId = props.accountId || context.accountId;
const contractId = "wearedevs.near";

State.init({
  messages: [],
  status: null,
});

const getMessages = () => {
  const messages = Near.view(contractId, "get_all_statuses", null);
  State.update({
    messages,
  });
};

const postMessage = () => {
  if (!accountId) return;

  if (state.status === null || state.status == "") return;

  Near.call(contractId, "set_status", {
    message: state.status,
  });

  getMessages();
};

getMessages();

const content = (
  <div>
    <div className="hero min-h-screen bg-base-200">
      <div className="hero-content text-center">
        <div className="max-w-md">
          <h1 className="text-5xl font-bold text-base-content">
            NEAR Dev Course
          </h1>
          <p className="mb-4 text-base-content">
            Welcome to the status board, feel free to update your status for
            others to see.
          </p>
          <p className="mb-4 text-base-content">
            You are logged in as <b>{accountId}</b>
          </p>
          <div className="my-2">
            <textarea
              placeholder="Your status"
              className="textarea textarea-bordered textarea-lg w-full max-w-xs"
              value={state.status}
              onChange={({ target: { value } }) =>
                State.update({ status: value })
              }
            ></textarea>
          </div>
          <button className="btn btn-primary mb-4" onClick={postMessage}>
            Post status
          </button>

          <div className="my-4">
            {state.messages.map((status) => (
              <div className="card bg-base-100 shadow-xl mb-4">
                <div className="card-body">
                  <h2 className="card-title text-base-content">
                    {status.message}
                  </h2>
                  <p className="text-left text-base-content">
                    {status.account_id}
                  </p>
                </div>
              </div>
            ))}
          </div>
        </div>
      </div>
    </div>
  </div>
);

return (
  <Widget
    src="igris.near/widget/DaisyUIWrapper"
    props={{ children: content, daisyUiTheme: "dark" }}
  />
);

 
Code Explanation:
const accountId = props.accountId || context.accountId;
const contractId = "wearedevs.near";
We initialize two variables: accountId and contractId. accountId is set based on the props passed or derived from the context.accountId. contractId is set to the contract name "wearedevs.near".
State.init({
  messages: [],
  status: null,
});

Here, we initialize the application's state using the State.init() method. We set two properties: messages as an empty array and status as null.
const getMessages = () => {
  const messages = Near.view(contractId, "get_all_statuses", null);
  State.update({
    messages,
  });
};

This function getMessages() retrieves messages from the blockchain. It uses the Near.view method to call the get_all_statuses function from the specified contract (contractId). It then updates the messages property in the application's state.
const postMessage = () => {
  if (!accountId) return;

  if (state.status === null || state.status == "") return;

  Near.call(contractId, "set_status", {
    message: state.status,
  });

  getMessages();
};

The postMessage() function allows users to post a message on the message board. It first checks if the accountId exists and if the state.status is not null or empty. If these conditions are met, it uses Near.call to invoke the set_status function of the contract, passing the user's message. After posting, it calls getMessages() to refresh the message board.

getMessages();getMessages();

This line of code initiates the loading of messages when the page is loaded initially.

The rest of the code defines the user interface using JSX and sets up a simple message board where users can post and view messages. It also displays the user's wallet name.
Setting up the Metadata
For the component to be discoverable on the Open Web the metadata needs to be set up. To do so navigate to the Metadata tab of your component, and fill in the relevant fields such as Title “Dev Message Board” and Tags “Message-board”.



 

### Module2: What is NEAR Protocol?

NEAR Protocol stands as a third-generation blockchain platform designed to address scalability and performance issues faced by previous blockchain generations. It utilizes a sharding mechanism, Nightshade, to enhance its capacity and efficiency.

Evolution and Features

 	Blockchain Generations: Traces the evolution from Bitcoin (first-gen) to Ethereum (second-gen) and then to NEAR (third-gen).
 	Sharding Mechanism: Implements sharding for scalability, allowing the network to handle a larger number of transactions efficiently.

Developer and User Focus: Prioritizes a friendly environment for developers and a seamless experience for users.

Read and answer quizzes at this Guide:
What is NEAR protocol?

### Module1:Understanding the Open Web

NEAR Protocol's Blockchain Operating System (BOS), introduced in March 2023, aims to bridge the gap between Web2 and Web3, providing an ideal entry point for the Open Web. This transition is facilitated through BOS's unique architecture, which focuses on simplifying interactions with blockchain technologies.

Key Features

 	Open Web Concept: Promotes a decentralized internet free from central oversight, fostering open communication and collaboration.
 	Components: Offers a user-friendly interface for interacting with decentralized applications (dApps), simplifying the development and deployment process.

Gateways and Blockchains: Facilitates accessibility to decentralized frontends and supports cross-blockchain functionalities.

Read and answer quizzes at this Guide:

NEAR BOS: NEAR Protocol’s Blockchain Operating System
 Also check this workshop by NEAR Balkans and Quantox Technology:

https://youtu.be/tF9lQlVkAMU

### The Future of Zero Knowledge Proofs

Technical Improvements in ZK Programming
Section Overview: In this section, the speaker discusses two major strategies for improving ZK programming and highlights some technical improvements.
Two Major Strategies for ZK Programming

 	There are two major strategies for ZK programming: writing your own circuits or using a language like Noir or Leo Snarky JS where you program directly in ZK.
 	Writing your own circuits is done with Circom, which will get better because of improvements made by Polygon's team.
 	It is still early in terms of which languages or CK programming works best.

Technical Improvements

 	Recursive snarks can be used when doing a roll-up or any time where you're doing a bunch of proofs all at once. This makes it easier because you're doing less work at once.
 	ZPrize is a competition run by Elio for general improvements that should be made to zero knowledge. Some of the big ones include accelerating things with FPGA or GPU and making important functions run faster.

Zero Knowledge Virtual Machine (ZKVM)
Section Overview: In this section, the speaker talks about Risk Zero's strategy to create a zero knowledge virtual machine.

 	Risk Zero's strategy is to create a zero knowledge virtual machine that is compatible with RISC-V architecture.
 	This virtual machine allows you to write normal code in Rust or C++ and then compile it down to an intermediate representation.
 	From there, the actual virtual machine creates zero knowledge proofs for everything.
 	This approach allows you to program as normal and pretend the ZK is not there, which is different from writing your own fine-tuned circuit.

Recursive Snarks
Section Overview: In this section, the speaker talks more about recursive snarks and how they can be used to make computations easier.

 	Recursive snarks can be used to continuously add new transactions into a proof, making it easier because you're doing less work at once.
 	Mina uses this strategy in its state proof, which is only 22 kilobytes.
 	Recursive snarks are also being used by L2s who are renting out the maximum size computer on AWS.

Conclusion
Section Overview: In this section, the speaker concludes the class and summarizes what was discussed.

 	The speaker concludes the class on "The Future of Zero Knowledge".
 	Technical improvements were discussed such as recursive snarks and ZPrize competition.
 	Risk Zero's strategy to create a zero knowledge virtual machine was highlighted.

Specialized Hardware and Zero Knowledge Proofs for Blockchain Gaming
Section Overview: In this section, the speaker discusses the need for specialized hardware and zero knowledge proofs in blockchain gaming.
Need for Zero Knowledge Proofs in Blockchain Gaming

 	Dark Forest is a good example of a game that uses zero knowledge proofs.
 	Many games have fog of war or incomplete information, making zero knowledge proofs necessary to ensure fair play.
 	Zero knowledge proofs are essential for blockchain gaming to take off.

ZK Bridges and ZK Identity

 	ZK Bridges, such as those being developed by Succinct Labs, will allow different blockchains to communicate with each other securely.
 	One-way bridges can be used to move money across chains without security concerns.
 	ZK Identity has many privacy applications, such as proving age or education credentials.

Upcoming Classes on Cryptography and Zero Knowledge Proofs
Section Overview: In this section, the speaker discusses upcoming classes related to cryptography and zero knowledge proofs.
Uncloak's Rest Cryptography Engineering Class

 	The speaker recommends taking Uncloak's Rest Cryptography Engineering class to improve programming skills in cryptography.

ZK Mook Course

 	A massive open online course on zero knowledge proofs is being developed by top professors in the field.

Future of ZK
Section Overview: In this section, the speaker talks about their plans to continue learning and teaching about ZK technology. They also encourage viewers to claim their class certificate and NFT.
Plans for the Future

 	The speaker plans to keep learning, studying, and teaching about ZK technology.
 	They want to make more videos as they learn and solidify what they are teaching.
 	Viewers can claim their class certificate and free NFT by clicking on the link provided in the chat.

The Future of ZK

 	The speaker believes that ZK snarks will be a significant revolution as they become more mainstream over the next 10 to 20 years.
 	They think that ZK technology will become as popular as blockchain and AI in the future.
 	Learning about ZK now will pay off in the future because it is such a cool technology that will be used beyond just blockchain.

Overall, this section discusses the importance of continuing to learn about ZK technology and how it will impact the future.

### Intro to ZK Programming

Cryptography Engineering Resources

Section Overview: In this section, the speaker discusses resources for cryptography engineering.
Good Resources for Cryptography Engineering

 	There are not many good books on cryptography and practice available.
 	Real World Cryptography by David Wong is one of the best books on cryptography that exists.
 	Filippo.io is a good resource if you want to experiment with rolling your own cryptography.
 	Crypto Puzzles Challenge is the best CTF out there if you're looking to understand these things better.

Zero Knowledge Programming Options
Section Overview: In this section, the speaker discusses different options for zero knowledge programming.
Options for Zero Knowledge Programming

 	Circom is probably the most common option with a large community around it. It's also one of the oldest options available.
 	Snarky JS is almost like JavaScript or TypeScript for writing ZK apps. It's recommended if you want to write a full production mode CK app like tomorrow because developers will have an easier time with something that looks more like TypeScript than something that looks like what Circom looks like.
 	Other options include Stark, Cairo, Aztec Noir, and several other languages.

Why There Are Different Options for Zero Knowledge Programming
Section Overview: In this section, the speaker explains why there are different options for zero knowledge programming.
Explanation of Different Options for Zero Knowledge Programming

 	The reason there are different options is that each option has its own strengths and weaknesses.
 	Some languages may be better suited to certain tasks than others.
 	It's important to choose the right language for your specific use case.

Introduction to ZK Circuits
Section Overview: In this section, the speaker introduces the concept of Zero-Knowledge (ZK) circuits and explains how they work.
ZK Circuit Components

 	A ZK circuit consists of four main components: the circuit itself, the witness calculation, the setup algorithm, and the verifier.
 	The circuit takes an input and generates two outputs: an R1CS file and a Wasm or C++ file.
 	The witness calculation provides an input that goes into the circuit to make it true.
 	The setup algorithm generates two files: a proving key and a verification key. These are public parameters used by the prover and verifier respectively.
 	The prover uses the proving key and witness to generate a proof and public parameters in JSON format.
 	The verifier checks whether something is true or false using a Solidity file on-chain.

Rank One Constraint System
Section Overview: In this section, the speaker explains what rank one constraint system (R1CS) is and why it's important for ZK circuits.
Understanding R1CS

 	R1CS is a type of constraint system where all inputs and variables should be degree one. This means that only additions and multiplications are allowed, with repeated multiplication being acceptable as well.
 	Exponentiation or other complex operations are not allowed because everything needs to be turned into polynomials for zero-knowledge circuits.
 	R1CS helps simplify calculations for zero-knowledge circuits by limiting their complexity.

Understanding Circuits and Constraints
Section Overview: In this section, the speaker explains how to create constraints for arithmetic circuits. They also provide examples of how to constrain binary values and how to constrain a value to be equal to one of two other values.
Creating Constraints for Arithmetic Circuits

 	The code will only run and pass the proof if inputs a, b, and output c are such that a times b is equal to c.
 	Constraints should not include division. Instead, move the variable being divided to the other side of the equation.
 	Arithmetic circuits help in understanding how we get from code to constraints that are just plus and times.

Examples of Constrained Values
Constraining Binary Values

 	To constrain an X value as binary, use x times x minus 1 equals 0.
 	If x is zero or one, then x times x minus 1 equals zero. Any other value will not satisfy this constraint.

Constraining a Value Equal to One of Two Other Values

 	Use a plus b minus a times b as an example of constraining X equaling either A or B.
 	Rank one can be thought of as first degree everywhere in linear algebra.

Algebra and Magnolia
Section Overview: The instructor gives a brief introduction to two concepts, algebra and Magnolia.
Examples of Zero Knowledge Proofs

 	The instructor recommends checking out the ZK Battleship example on Ezekiel GitHub repo.
 	The Tornado Cash repo is another example to read through, specifically looking at the circuits they use in circom.

Short Class Setup for Next Week
Section Overview: The instructor sets up the class for next week and encourages students to ask questions on Discord.

 	Today's class is short as there isn't much to cover.
 	A student asks why a plus B minus a times B works in algebra. The instructor explains that it can be thought of as combining different cases by when things are zero or one.
 	If trying to show that X is equal to a or b, it's important to also show that a and b are binary.

Overall, this was a short class with only a few key points covered.

### Zero Knowledge Proofs in Practice: Ethereum, Scroll, zkSync, StarkNET, Aztec, Zcash, Mina,Manta,Aleo

Ethereum Whisk

Section Overview: This section discusses Ethereum Whisk, which uses zero knowledge proofs to improve privacy in blockchain elections.

 	Ethereum Whisk is being added to Ethereum core and is based on a paper by Dan Boneh, a Stanford cryptography professor.
 	It improves privacy in blockchain elections by electing 32 block proposers at the beginning of each epic without revealing their identities until it happens.
 	This avoids denial-of-service attacks that could occur if identities were revealed ahead of time.

Using Zero Knowledge Proofs for Shuffling
Section Overview: In this section, the speaker discusses the use of zero knowledge proofs to ensure that shuffles are being done correctly. They explain why a trusted setup is not desirable and introduce the concept of zero knowledge proofs.
Anonymized List and Shuffle Process

 	The validators shuffle an anonymized list.
 	Each person in the circle shuffles a deck of cards once.
 	The list must be anonymized so that no one knows which cards or people are coming up next.

Verification with Zero Knowledge Proofs

 	It's important to verify that the shuffle was done correctly.
 	A zero knowledge proof is used to verify that all shuffles are being done correctly.
 	Ethereum Whisk uses a shuffle argument from Bayer and Groth using optimized inner product arguments inspired by bulletproofs.

Conclusion

 	Zero knowledge proofs are necessary to prove that all shuffles are being done correctly.

Ethereum L2 Roll-Up
Section Overview: In this section, the speaker talks about the concept of Roll-Ups and how they work in general. They also discuss the benefits of using Roll-Ups for scaling Ethereum.
What is a Roll-Up?

 	A regular Ethereum transaction for an ERC20 token might cost 45,000 gas.
 	With a roll-up, it can take up less space on-chain and be under 300 gas.
 	All roll-ups give about a 100x performance increase or are 100x cheaper.
 	The important part of a roll-up contract is the concept of Merkle trees.

How Does a Roll-Up Work?

 	There is a roll-up contract that exists on Ethereum.
 	It includes the state route of where the roll-up blockchain is so far.
 	Someone will post the batch transaction on layer one which updates what's happened since the last step.
 	There's a pre-state route and post-state route which represent before and after changes to data respectively.
 	After going through updates, we get to post-state route and then post it back to the roll-up contract which updates its state route from old to new.

Types of Roll-Ups
Optimistic Roll-Ups

 	Using fraud proofs so you don't need proof initially
 	If anything goes wrong, someone will post a fraud proof
 	Usually have a time window of up to seven days where you can't withdraw from an optimistic roll-up

ZK Roll-Ups

 	You need proof before any changes are made
 	Uses ZK snark that proves state route matches correct execution of batch and all transactions
 	Every single update comes with proof

Roll-Ups and ZK Sync
Section Overview: In this section, the speaker discusses Roll-Ups and ZK Sync, two scaling solutions for Ethereum.
Roll-Ups

 	Roll-Ups use a sequencer to post all data back to the rollup contract on Ethereum.
 	Proof generation takes a long time, so each block is sent through a coordinator to create proof generation. Proofs are then aggregated into a proof of proofs to save resources.
 	The proof of proofs is how massive scaling factors are achieved in some Roll-Up solutions.
 	Scroll is doing native EVM bytecode and has an article on KZG commitments.

ZK Sync

 	ZK Sync has something called ZK Porter which is a cheaper alternative to posting all data back to Ethereum.
 	ZK Sync 2.0 launches tomorrow with every single Ethereum opcode implemented inside zero knowledge proof.
 	For full EVM compatible smart contracts, ZK EVM's are used.

ZK Rollups and Smart Contract Languages
Section Overview: In this section, the speaker discusses the importance of ZK-friendly hash functions for zero-knowledge proofs. They also talk about CK Sync and its compatibility with Solidity, as well as StarkNet's use of Cairo for smart contract language. The speaker then introduces Aztec and their private ZK rollup.
ZK-Friendly Hash Functions

 	Zero-knowledge proofs are limited in what they can prove using only plus and times.
 	ZK-friendly hash functions like Poseidon are important for supporting these proofs.

CK Sync and Solidity Compatibility

 	CK Sync is live with their zke EVM tomorrow.
 	It is compatible with Solidity, which compiles down to EVM bytecode.

StarkNet and Cairo

 	StarkNet is built on ZK Starks instead of ZK snarks.
 	Smart contracts on StarkNet must be written in Cairo.

Aztec's Private ZK Rollup

 	Aztec uses Noir as their smart contract language, built on Planck.
 	Transactions on Aztec's rollup are all private, making it a zero-knowledge version of a zero-knowledge rollup.

Zcash, Halo 2 and Mina
Section Overview: In this section, the speaker talks about Zcash, its relationship with Electric Coin Company and Zcash Foundation. They also discuss Halo 2 and Mina.
Zcash

 	Zcash is built on Planck which is used in many projects like Meta Dusk ccash and ZK sync.
 	Zcash was originally called Zero Cash back in 2014 when they published the original white paper.
 	The team behind Zcash has some of the best knowledge proof researchers.
 	There are no smart contracts on Zcash yet; it's just for private transfers of money.
 	Following what's happening with cryptography in Zcash can help you learn a lot about cryptography.

Halo 2

 	Vitalik Buterin wrote a post about Halo 2 where he talked about its importance benefits such as removing the trusted setup and massively reducing verification costs.
 	Recursive proofs are powerful because they compress everything down into a tiny size.

Mina

 	Mina is the world's lightest blockchain that uses kimchi proofs based on plonk and pasta curves to verify everything that's happened since the first block.
 	Pickles are added for recursion so if you do a bunch of kimchi proofs with recursion and pickles, what you end up with is something that's 22 kilobytes and never goes any larger.
 	Using zero-knowledge snark makes it quicker to verify instead of verifying the entire chain's history manually.

Prover Speed Improvements
Section Overview: In this section, the speaker talks about the importance of prover speed improvements in zero knowledge proofs and highlights the work done by Manta Network in this area.
Prover Speed Improvements

 	The prover speed is the slowest part of zero knowledge proofs.
 	It is mandatory for every zero knowledge proof that's very easy for the verifier.
 	Blockchain limitations make it important to focus on achieving fast prover times.
 	Manta Network has been focusing a lot on prover speed improvements and achieving very fast times.

Elio - Building Foundations for Decentralized Web Applications
Section Overview: In this section, the speaker talks about Elio's goal to build foundations for decentralized web applications and their programming language Leo.
Elio - Building Foundations for Decentralized Web Applications

 	Elio's goal is to build foundations for the next generation of decentralized web applications.
 	Their programming language is Leo.
 	They are enabling decentralized private computation.
 	They have built a lot of cool things like CK Cloud snark OS snark VM generated millions of zero knowledge proofs.

Zprize - Open Bounties for Solving Big Challenges in Zero Knowledge Proofs
Section Overview: In this section, the speaker talks about zprize, which offers open bounties for solving big challenges in zero knowledge proofs.
Zprize - Open Bounties for Solving Big Challenges in Zero Knowledge Proofs

 	Zprize offers open bounties for solving big challenges in zero knowledge proofs.
 	Some of these bounties go up to almost a million dollars if you can come up with some amazing solution.
 	There are different categories such as accelerating the Poseidon hash function, accelerating plonk up, and more.
 	Zprize is a good place to keep an eye on the progress being made in zero knowledge proofs.

Other Projects to Keep an Eye On
Section Overview: In this section, the speaker talks about other projects to keep an eye on in the zero knowledge community.
Other Projects to Keep an Eye On

 	The speaker mentions that there are many other projects in the zero knowledge community worth keeping an eye on.
 	They mention Manta Network, Elio, and zprize as some of the most interesting ones.
 	The speaker also mentions that they will be participating in Manta Network's upcoming trusted setup.

Cryptography Teams in the Blockchain Space
Section Overview: In this section, the speaker discusses various cryptography teams in the blockchain space and their potential impact on the industry.
Notable Cryptography Teams

 	Panther Protocol is a private DeFi project that uses zero-knowledge proofs. They recently appeared on the ZK podcast.
 	Eigenlayer is a data availability layer for Roll-Ups that uses Casey G commitments. They are not a full ZK company but use similar math and technology as zero-knowledge proofs.
 	Ethereum Foundation has an amazing cryptography team and is probably the number one group of people to follow for zero-knowledge proofs.
 	Algorand's team includes several MIT professors and academic cryptographers, making them another strong cryptography team to watch.
 	StarkNet is not live yet, but they have hired ten of the best cryptographers out there, making them another team to keep an eye on.

Q&A Session
Section Overview: In this section, the speaker answers questions from viewers about various topics related to blockchain technology.
Questions and Answers

 	Ring signatures are used by Monero.
 	Web 3 companies are currently profitable, but exponential growth is expected as more people enter the space.
 	Halo cannot support smart contracts because it is Zcash's blockchain that cannot accept them yet. The details of Halo and Zcash's interaction are unclear at this time.
 	Data availability is usually stored on-chain, but some projects are experimenting with storing data off-chain. However, it's important to be careful when removing things from the blockchain to ensure decentralization and the benefits of a blockchain are not lost.
 	StarkNet uses Stark proofs, which are different from SNARKs. Archive nodes keep up with all transactions, but data is not necessary for consensus or validation.

Side Chains vs Roll-Ups
Section Overview: In this section, the speaker discusses the differences between side chains and roll-ups in terms of security assumptions and trust requirements.
Roll-Ups

 	Data is always on the smart contract level.
 	Users can exit anytime they want to, even if the entire Layer Two crashes or censors their transaction.
 	Users don't have to trust Layer Two as much as with a side chain.

Side Chains

 	Users need to trust that the side chain is operating correctly.
 	Trust requirements are higher than with roll-ups.

Tornado Cash and Zcash
Section Overview: In this section, the speaker talks about Tornado Cash and its relationship with Zcash.

 	Tornado Cash was a fork of part of Zcash down to Ethereum.
 	The math behind Tornado Cash is almost identical to that of Zcash.

Verifiable Computation for Voting
Section Overview: In this section, the speaker discusses verifiable computation for voting and how it adds more trust to election systems.

 	Verifiable computation for voting should be standard practice.
 	Zero knowledge proofs can be used to provide proof that a vote was added to the tally without revealing individual votes.

### Tornado Cash Whitepaper

Protocol Description
Section Overview: In this section, the speaker describes the functionality of Tornado Cash protocol.
Inserting and Depositing Money

 	Users can insert and deposit money into a smart contract with a fixed amount of ether called a coin.
 	Depositing should be done with a uniform amount of ether to make it harder to know who's who on withdrawal later.

Removing and Withdrawing Money

 	Users can remove or withdraw money from the smart contract either through a layer or directly.
 	If users go through a layer, they pay a fee F to the relayer for helping out.
 	If users go directly, they have to pay gas fees.

Deposit Process
Section Overview: In this section, the speaker explains how users can deposit coins into Tornado Cash protocol.

 	To deposit a coin, users generate two random numbers K and R in this field.
 	Then compute C as equal to hash function of K and R bitwise put next to each other.
 	Send an Ethereum transaction with an eth value interpreted as an unsigned 256-bit integer if the tree is not full.
 	The contract accepts the transaction and adds C to the tree as a new non-zero leaf.

Tornado Cash: Deposit and Withdrawal
Section Overview: In this section, the speaker explains how deposit and withdrawal work in Tornado Cash. They also discuss the Merkle tree and the nullifier hash.
Deposit

 	To deposit, select a root R for the tree among the stored ones in the contract.
 	Compute an opening that ends with R.
 	Prove that your value is in the tree.
 	Fiat deposit pick two numbers to withdraw later.
 	Remember them to withdraw.

Withdrawal

 	Provide recipient address A and fee value.
 	Prove that your value was in the tree at this position using a Merkle tree root.
 	Compute nullifier hash to prevent double spending attacks by remembering hashes of all K values that have successfully withdrawn so far.
 	Verify proof and uniqueness of nullifier hash before sending money to you and fee to layer.

Implementation Details
Section Overview: This section covers implementation details of cryptographic functions used in Tornado Cash.
Cryptographic Functions

 	Four libraries are used, two written by item three and two by Tornado Cash.
 	MC sponge contract is a common hash function, circum is what will be learned next week.

Security Claims

 	Only coins deposited in the contract can be withdrawn.
 	No coin can be withdrawn twice due to nullifier hash usage.
 	Any coin can be withdrawn once if parameters KR are known unless a coin with same K has already been deposited and withdrawn.

 	Randomly generate K so it's not picked by someone else.
 	Big 256 bit values should provide enough room for unique picks.
 	If K or R is unknown, a coin cannot be withdrawn.
 	Attacker cannot prevent one who knows KR from withdrawing coin even if K is unknown to attacker.
 	Transaction cannot be front run due to zero knowledge proofs.



Security Claims and Implementation
Section Overview: In this section, the speaker discusses the security claims and implementation of Tornado Cash.
Cryptographic Primitives Used by Tornado Cash

 	The cryptographic primitives used by Tornado Cash have at least 126-bit security, except for the curve of the discrete logs which has 100 bits.
 	The security does not degrade because of their composition.

Combining Secure Encryption Methods

 	It is fine to combine less secure encryption methods with more secure ones as long as they are used together.
 	Each withdrawal and deposit since the last moment when the contract has zero ether till the formation of the root can be a potential coin.
 	Some coins are more likely to be withdrawn depending on user behavior.

User Behavior and Privacy Risks

 	Users can mess up using Tornado Cash if their behavior is not normal.
 	If a user withdraws immediately after depositing a large amount, it may reveal their identity.

Groth16 ZK-SNARK
Section Overview: In this section, the speaker talks about Groth16 ZK-SNARK.
Most Common ZK-SNARK

 	Groth16 is referred to commonly as Groth 16 and is the most common ZK-SNARK used in most applications.

Understanding Groth16

 	The speaker will go into more detail later on how Groth16 works because it's so common.

Setup
Section Overview: In this section, we learn about setting up Tornado Cash.
Defining Terms

 	B is equal to a set of zero and one.
 	E is a pairing operation used in snark proofs which is defined over the group's Prime order Cube.
 	H1 from B to zp is a Pederson hash function defined in Peterson's paper.
 	H2 from zp zp be the mem C hash function to find some MC permutation in five still mode and sponge mode of operation.

Merkle Tree

 	T is a Merkel tree of height 20 where each non-leaf value node hashes its two children with H2.
 	Mimsy hash function will be used later for our Merkle tree.

Initializing Memc

 	Memc is initialized with all leaves being zero values later zero values are gradually added.

Conclusion
Tornado Cash uses cryptographic primitives that have at least 126-bit security, except for the curve of the discrete logs which has 100 bits. Combining less secure encryption methods with more secure ones is fine as long as they are used together. User behavior can reveal their identity if not normal. Groth16 ZK-SNARK is the most common ZK-SNARK used in most applications. Setting up Tornado Cash involves defining terms such as Pederson hash function and Merkel tree, and initializing Memc with all leaves being zero values later zero values are gradually added.
Introduction to Tornado Cash
Section Overview: In this section, the speaker introduces the concept of Tornado Cash and explains how it works.
How Tornado Cash Works

 	Users pick a nullifier and randomness randomly.
 	The user proves that they know K and R such that H(K,R,L,O) is the hash of K, O is the opening of hash 2 of KNR at position L to R.
 	The user reveals H as a public parameter.
 	The user shows that K and R are inside their tree at root r.

Merkle Tree

 	A Merkle tree is used to store values in Tornado Cache.
 	The Merkel tree root by itself doesn't really tell you what's in the tree.

ZK Snark from Grot16 Proving Verifying Key Pair for S

 	D is equal to DP and DV be the ZK snark from grot16 proving verifying key pair for S created using some trusted setup procedure.

Ethereum Address of Coin Recipient and Fee

 	Ethereum address of coin recipient (A), and fee (F), are included in zero-knowledge proof but not used on the right-hand side.

[t=1507s] Introduction to Zero Knowledge Proofs
Section Overview: In this section, the speaker introduces the concept of zero knowledge proofs and how they can be used to prevent front-running attacks.
How Zero Knowledge Proofs Prevent Front-Running

 	A coin cannot be front-run from an attacker if the withdrawing address is included in the zero knowledge proof.
 	Including the receiving address inside the zero knowledge proof prevents front-running.
 	Zero knowledge proofs can be useful in preventing front-running when withdrawing transactions.

MEV and Minor Extractable Value
Section Overview: This section explains what MEV (Minor Extractable Value) means and how it relates to blockchain transactions.
MEV Explained

 	MEV stands for Minor Extractable Value or Maximum Extractable Value. It refers to validators moving transactions around for profit.
 	Ethereum doesn't have minors anymore because it's not proof of work, but people still use the term loosely to refer to bots that benefit from having their transactions placed at a specific index in black arbitrage liquidation, front-run, sandwich, etc.

Withdrawing Transactions Anonymously
Section Overview: This section explains how anonymity is maintained when withdrawing transactions using Tornado Cash.
Withdrawing Transactions Anonymously

 	To maintain anonymity when withdrawing, deposit money with a fixed amount of ether and withdraw one ether at a time.
 	Depositing 10 ether into a tree where everyone else is also depositing 10 ether will help maintain anonymity when withdrawing large amounts of money.

Trusted Setup Procedure
Section Overview: This section explains the concept of a trusted setup procedure and how it relates to zero knowledge proofs.
Trusted Setup Procedure

 	DP and DV are public parameters created from a trusted setup procedure.
 	The term "key pair" is not accurate for DP and DV since they are public parameters, not secret or private keys.

MEV Bots
Section Overview: This section explains what MEV bots are and how they benefit from having their transactions placed at specific indexes in blockchain transactions.
MEV Bots Explained

 	MEV bots refer to bots that benefit from having their transactions placed at specific indexes in blockchain transactions.

Anonymity in Tornado Cash
Section Overview: In this section, the speaker discusses how to maintain anonymity while using Tornado Cash.
Maintaining Anonymity

 	To maintain anonymity, wait until other people are using Tornado Cash before making a transaction. This makes it less clear who is who.
 	The larger pools in Tornado Cash are likely used by only a few people, so they may not be as anonymous.

Trusted Setup and ZK Snarks

 	Groth16 requires a trusted setup that needs to be done before defining proof of values and outputting a proof.
 	The math behind Groth16 is not necessary to understand for building zero-knowledge proof applications but understanding why they're useful is important.

Storing Recent Root Values

 	A smart contract stores the last 100 root values in the history array for the latest Merkel tree T and also stores the values of nodes on the path from the last added leaf to the root that are necessary to compute the next root. This helps generate proofs when someone goes to withdraw.

Using Tornado Cash on L2

 	Using Tornado Cash on L2 can help with anonymity and efficiency as long as there are enough users. However, if there's only one main tornado cash everyone uses on Ethereum and then multiple L2s make their own versions of tornado cash, each L2 may not have as many users which could impact privacy.

Tornado Cash Overview
Section Overview: In this section, the speaker explains how Tornado Cash works and how it prevents double spending.
How Tornado Cash Works

 	When someone pays into Tornado Cash, the tree is updated.
 	The verification process checks that the submitted public values match the electric proof P.
 	If verification succeeds, the contractor releases minus f e to address a and Phi f e to really error address t.
 	To prevent double spending, the nullifier hash from the proof must not have appeared before.

Bridging Deposits to Anonymous Chains

 	If deposits were bridged to another anonymous chain or Monero and back, it would not be anonymous on Tornado if there was only one depository.
 	Timing attacks are a problem with relayers like Tor Browser because transactions can be linked based on timing.
 	Bouncing something through a bridge and back within the same transaction would not add privacy.

Summary of Tornado Cash

 	Deposits can be made into Tornado Cash and withdrawn later using a Merkle tree data structure.
 	A proof is required for withdrawal from the Merkle tree.
 	There's nothing too specific about each hash function used in Tornado Cash.

Understanding Tornado Cash
Section Overview: In this section, the speaker explains how Tornado Cash works and clarifies some of the terminology used in relation to it.
Nodes and Coins

 	Each coin is a deposit of one ether.
 	The smart contract and each of the Tornado Cash users are important, not individual nodes.
 	The consensus algorithm and different nodes are not too important at this level of abstraction.

On-chain Identity Verification

 	EK snarks can be used for on-chain identity verification.
 	Zero knowledge identity and CK identity can prove certain facts about yourself without revealing too much information.
 	It's unclear whether Tornado Cash has any direct identity implications.

Merkle Trees

 	Each tree node is a coin in Tornado Cash.
 	The nodes in the Merkle tree are each like one saved coin.
 	A transaction follows a Merkle tree by remembering your path to the top of the tree to prove that your leaf node is a member of this tree.

Combining with an Integrated DEX

 	There is no immediate benefit to combining Tornado Cash with an integrated DEX.
 	It's better to let each thing do its own thing properly and use them separately.

Size Constraints

 	The size of the Merkle tree is fixed at inception by the number of leaves.
 	The height of 20 means we can include 2^20 transactions because it's a binary tree.

 	Only a million people would be able to use Tornado Cash at once due to space constraints on Ethereum.



Anonymity

 	Transactions come from Ethereum nodes, so you have to insert your transaction into the mempool.

 	At that time, they could log where that transaction is coming from.
 	Use Tor Browser or other methods for anonymity when depositing native cash transactions.



Matching Withdrawals with Deposits

 	The original deposit generates two random numbers K and R.
 	Tornado Cash is only given the hash of K and R, which is used to compute C.

 	There is no direct way to match withdrawals with deposits.



Tornado Cash and QAP Reduction
Section Overview: In this section, the speaker explains how Tornado Cash works and how it uses zero-knowledge proofs to maintain privacy. They also briefly introduce QAP reduction and explain how it is used in Graph 16 protocol.
Tornado Cash

 	Tornado Cash uses zero-knowledge proofs to maintain privacy.
 	The smart contract has a balance of ether from different people, but when one ether is withdrawn, you don't know which person it came from.
 	Tornado Cash is a famous example of a zero-knowledge proof application.

QAP Reduction

 	Graph 16 protocol is the most used case in Arc out there. Zcash used it, and many people have used the tornado cache who used it.
 	The qap reduction starts with magic polynomials that encode the problem.
 	Special polynomials are built, multiplied, combined, and added to generate a big polynomial.
 	A times B equals C plus H times E.

Checking on Chat
Section Overview: In this section, the speaker quickly checks on chat.
Checking on Chat

 	No significant content in this section.

Smart Contract Tornado Cash
Section Overview: In this section, the speaker discusses the Smart Contract Tornado Cash and its deletion from GitHub.
Smart Contract Tornado Cash

 	The Smart Contract Tornado Cash has been deleted from GitHub.
 	The speaker suggests discussing it in another class.
 	No further discussion of the topic is planned for today's class.

QAP Stands for Quadratic Arithmetic Programs Zero to Hero
Section Overview: In this section, the speaker introduces QAP and explains how it relates to quadratic arithmetic programs.
QAP Stands for Quadratic Arithmetic Programs Zero to Hero

 	QAP stands for Quadratic Arithmetic Programs.
 	The goal is to get from computation into QAP with all polynomials and create a proof.
 	The process involves breaking down each step slowly and translating from each layer to the next.
 	Limited operations are available: add, subtract, multiply, divide, and constant power explanation.

Computing a Function
Section Overview: In this section, the speaker explains how to compute a function using limited operations.
Computing a Function

 	To compute a function with limited operations:

 	Encode it in a format that's nice
 	Prove some facts about it
 	Break down each step one at a time
 	Work with limited operations (add, subtract, multiply, divide)



Flattening Steps One at a Time
Section Overview: In this section, the speaker breaks down flattening steps one at a time.
Flattening Steps One at a Time

 	Flattening involves breaking down each step one at a time.
 	Simple variables are introduced to slow down the process.
 	Gate to R1CS involves three vectors: A, B, and C.
 	The solution vector s satisfies the equation s dot a times s dot b minus s dot c is equal to zero.

R1CS and QAP
Section Overview: In this section, the speaker explains how to convert a program into polynomials using R1CS (Rank-1 Constraint System) and then use those polynomials in a Quadratic Arithmetic Program (QAP) to create a zero-knowledge proof.
Converting Program to Polynomials

 	Create arrays with columns for one, X, out, symbol one, Y, and symbol two.
 	Use matrices to represent computations step by step.
 	Convert matrices into polynomials.
 	Mix polynomials together and prove facts about them.

R1CS and QAP

 	R1CS is commonly used in converting programs into polynomials.
 	QAP uses the polynomials created from R1CS to create a zero-knowledge proof.
 	Read through articles for more detailed explanations on how the coefficients are formed in creating the polynomial.
 	The speaker will discuss R1CS further on Thursday's session.

### Introduction to Groth16

Introduction to Groth 16
Section Overview: In this section, the speaker introduces himself and explains that he will be discussing Groth 16, which is a proof system commonly used in blockchain technology. He also mentions that this will be the last week of class and attendance NFTs will be given out on Thursday.
Groth 16 Paper

 	Groth 16 is named after researcher Jens Groth who published it in 2016.
 	It is currently used by various blockchain technologies such as Zcash, Polygon, Mass Dark Force Tornado Cash, Semaphore Loop Ring, among others.
 	The paper is more efficient than previous papers and has become the most common proof system.

Elliptic Curve Pairing

 	The speaker explains elliptic curve pairing as having two groups from elliptic curves G1 and G2 where you take the first two as inputs and output a third paired together in a nice way to prove extra effects.
 	He offers to go into detail on what are groups or elliptic curve outline if needed.

Zero Polynomial

 	The speaker defines zero polynomial as z sub s of X being the product of all S and S of x minus s for a multi-set of s elements from the field.

Proving a Polynomial is Zeroed at Multiple Points
Section Overview: In this section, the speaker explains how to prove that a polynomial is zeroed at multiple points.
Dividing Polynomials

 	To prove that a polynomial is zeroed at multiple points, divide it by another polynomial.
 	If there is no remainder, then it's true that the polynomial zeroes at those points.

Introduction to Elliptic Curve Pairing
Section Overview: The speaker introduces elliptic curve pairing and acknowledges that it may not be common knowledge.
Elliptic Curve Pairing

 	Elliptic curve pairing will be discussed later in the talk.
 	It may not be common knowledge outside of obscure math circles.

Building Up Zero Knowledge Proof
Section Overview: The speaker discusses building up zero knowledge proof from a program.
Turning Program into R1CS Constraint System

 	Start with your program and turn it into an R1CS constraint system.
 	R1CS stands for Rank One Constraint System.
 	Follow Vitalik's post for a step-by-step guide on how to get from the polynomial to the rank one constraint system and down into QAP.

Rank One Constraint System (R1CS)

 	An R1CS has variables M constants P public inputs I have a witness Vector w.
 	The M constraints are the product equation between three inner products.
 	Every constraint should be true for every single tie for every single constraint.
 	Use matrices to write all the constraints in one big box.

Quadratic Arithmetic Program (QAP)

 	The goal is to prove that w and a times W and B should be equal to W and C polynomial QAP.
 	Fix basis X in our field and for each constraint, find polynomials a sub I at x j which is equal to a i j so that the inside the Matrix at rho I column J if we have some polynomial similarly for B and C then Define a of X is the sum from overall I of the witness at I times a i x similarly for B and C.
 	The constraints are equivalent to checking that a at x i times B at x i is equals c times x i.
 	This form is called quadratic arithmetic program can be verified by the existence of a low degree HX that satisfies.

Polynomial Equations and Trusted Setups
Section Overview: In this section, the speaker discusses polynomial equations and trusted setups in the context of Groth16.
Polynomial Equations

 	A polynomial equation can be efficiently verified by evaluating it at a random Tau.
 	Malleability is a potential issue with public input in Groth16. Strategies to avoid malleability include signed proofs, nullifiers, tracking used public inputs, using Ethereum addresses, or not using Groth16.
 	The use of a trusted setup is required for every circuit in Groth16.

Trusted Setups

 	Grass 16 requires a trusted setup to create a shared set of values known as a common reference string (CRS).
 	The CRS is created by picking an upper bound M and generating random values Tau, Alpha, Beta, Theta.
 	The CRS includes all these powers of Tau times G1/G2 and Alpha/Beta/Theta times all these powers of Tau times G1/U1.
 	Linear combinations are used to construct Li from the generated values.

Powers of Tau and Common Reference Strings
Section Overview: This section continues the discussion on common reference strings (CRS) and powers of Tau in Groth16.
Powers of Tau

 	Powers of Tau are used to generate the CRS in Groth16.
 	The number of constraints determines the upper bound M for selecting random values for generating the CRS.

Common Reference Strings

 	A common reference string (CRS) is created by generating random values for Tau, Alpha, Beta, Theta.
 	The CRS includes all these powers of Tau times G1/G2 and Alpha/Beta/Theta times all these powers of Tau times G1/U1.

Generating Values and Linear Combinations
Section Overview: This section discusses the generation of values and linear combinations in Groth16.
Generating Values

 	Given circuits A, B, C, generate values Sigma and Gamma.
 	Li cannot be generated directly because Alpha and Beta are used up in the CRS. However, they can be constructed using linear combinations of the generated values.

Linear Combinations

 	Li is constructed using linear combinations of the generated values.
 	The formula for constructing Li involves multiplying Beta by Ai(X), Alpha by Bi(X), and Theta by Ci(X).
 	After this step, Alpha and Beta are thrown away.

Introduction to Trusted Setups
Section Overview: In this section, the speaker explains what trusted setups are and how they work. They discuss the importance of public parameters, such as proving and verification keys, and why avoiding group three elements is critical for soundness.
Trusted Setup Protocols

 	Public parameters include proving and verification keys.
 	Group three elements tend to be big and weird, so they are avoided.
 	Avoiding group three elements in phase two ceremony is critical for soundness.
 	Zcash team has developed multi-party computation protocols to share the setup across many participants.

Multi-party Computation

 	Multi-party computation is critical for security because values must not be known to anyone.
 	As long as one participant is secure, the system is secure even if 99% of people aren't contributing random values.
 	Vitalik's write-up provides a good introduction to how trusted setups work.

Proving Witness
Section Overview: In this section, the speaker discusses how to prove a witness that satisfies constraints. They explain how degree polynomials are computed and how private witness problem monomials are used.
Computing Degree Polynomials

 	Given a witness that satisfies constraints, degree polynomials A, B, C, H are computed.
 	Private witness problem monomials L of X are equal to the sum over all I of the witness times Li.

Note: The speaker also mentions picking random values helps with shoving everything down into one polynomial.
Generating Proofs with Polynomials
Section Overview: In this section, the speaker explains how to generate proofs using polynomials. They discuss the process of adding polynomials together and generating random values R and S to compute a, b, and c.
Adding Polynomials Together

 	To generate proofs using polynomials, we add them all together.
 	A is like the key piece - alpha times G1 and beta times G2.
 	B is generated in a similar way to A.
 	C is what happens when you multiply A by B.

Randomness and Blurring Factor

 	There's a blurring factor because R and S are random.
 	The inclusion of some random factors makes it hard for someone else to figure out what A is.

Visualizing the Math Part

 	Looking at code can be super helpful in understanding how things work.
 	Reading through code can be a hands-on way of understanding how things work.

Verifying Proofs with Polynomials
Section Overview: In this section, the speaker explains how to verify proofs using polynomials. They discuss the process of aggregating public inputs into a polynomial l and checking that e times C plus L equals Alpha times G1 plus Beta times G2.
Checking Public Inputs

 	Given the proof and public inputs, aggregate the public inputs into polynomial L.
 	Check that e times C plus L equals Alpha times G1 plus Beta times G2.

Understanding the Proof

 	The proof is malleable, so it's important to be careful with implementation.
 	Including as many things as possible inside the proof is important to ensure consistency.

Grasshopper 16 Overview
Section Overview: In this section, the speaker provides an overview of Grasshopper 16 and its structure. They also discuss why people still use Grot16 despite other polynomial commitment schemes having a more modular structure.
Structure of Grasshopper 16

 	Grasshopper 16 is a single complex expression that is hard to separate into clear parts.
 	The completeness of Grasshopper 16 follows from the expansion of the pairing track soundness.
 	Zero knowledge follows from A and B being uniformly random through R and S and C being fully determined through the claim.

Why People Still Use Grot16

 	Polynomial commitments have a much more modular structure but have larger proofs and more steps.
 	Grot16 does everything at once, which can make it difficult to piece together sometimes.

Grasshopper 16 Paper Overview

 	Jens Groth published "On the Size of Pairing-Based Non-Interactive Arguments" in 2016.
 	The paper's first contribution is a pairing-based pre-processing snark for arithmetic circuits as viability, which is NP complete language.
 	The proof is only three group elements, making it very small, and verification consists of checking a single pairing product equation using three pairings in total.
 	The snark is zero knowledge and does not reveal anything about the witness or proverb.

Introduction to Zero Knowledge Proofs
Section Overview: In this section, the speaker introduces the concept of zero-knowledge proofs and highlights the history behind it.
History of Zero-Knowledge Proofs

 	Goldwasser McCauley and Rakoff introduced zero-knowledge proofs in 1989.
 	The speaker mentions a talk by Jen Scrath on YouTube that goes through the full history of zero-knowledge proofs.
 	Groth16 is still being used because it was one of the first efficient solutions for zero-knowledge proofs.

Non-Interactive Zero-Knowledge Argument

 	The speaker talks about constructing a non-interactive zero-knowledge argument for arithmetic circuit satisfiability where proof consists of only three group elements.
 	The verifier computation is also less, only three pairings and one pairing equation.
 	This was a big efficiency improvement on previous works.

Bilinear Groups

 	The speaker explains why elliptic curve pairings are used for bilinear groups.
 	Bilinear groups are linear in both the first group and second group, making them easier to understand than elliptic curves.

Resources

 	There is an implementation of Groth16 into code available at Artworks.
 	Additional resources for those interested in learning more about pairings include reading papers or watching videos.

Cryptography Resources
Section Overview: In this section, the speaker recommends two resources for learning more about cryptography and pairings.
Graduate Course in Applied Cryptography

 	The book "Graduate Course in Applied Cryptography" by Dan Boneh and Victor Shoup is a great resource for getting hands-on with cryptography.
 	Chapter 15 of the book covers cryptography and pairings, providing a nice introduction to why you want pairings and how they work.
 	The book is version 0.5, but it's still very good.
 	Reading clubs exist where people read through one chapter at a time for weeks at a time.

Pairings for Beginners

 	"Pairings for Beginners" by Craig Costello is another great resource for learning about pairings in detail.
 	The book is around 150 pages long and covers everything you need to know about pairings.

### Introduction to ZKP

About Zero Knowledge Proofs

 	Zero knowledge proofs are a new development in cryptography.
 	Encryption is traditional cryptography, while zero knowledge proofs are newer.
 	Zero knowledge proofs are used in blockchain technology.

Cryptography
Section Overview: The speaker talks more about cryptography, including encryption, code breaking, and algebraic structures.
Traditional Cryptography

 	Encryption is a traditional form of cryptography.
 	It involves codes and code breaking.

Algebraic Structures

 	Algebraic structures are used in cryptography.
 	Zero knowledge proofs use algebraic structures.

Course Outline
Section Overview: In this section, the instructor goes over the course outline and what will be covered in each class.
Class 1: Introduction

 	The first class is an introduction to zero-knowledge proofs.
 	The instructor aims to cover the main topics and provide a concrete understanding of how ZK works.

Class 2: Industry Overview

 	This class covers different companies using ZK and Y, including Ethereum's L2 scaling model.
 	The instructor will go through various privacy applications like Tornado Cash or Zcash.

Class 3: Types of Zero Knowledge Proofs

 	This class delves deeper into types of zero-knowledge proofs such as snarks versus starks.
 	Different algorithms like plonk, plunkish, plonky, bulletproofs are explained.

Class 4: Math Details

 	This class covers more math details related to zero-knowledge proofs.

Class 5 & 6: Programming Surcom

 	These classes focus on programming surcom so that students can write their own circuits.

Class 7: Deep Dive on Elliptic Curve Pairings

 	This class provides a full deep dive on elliptic curve pairings and why they come up in ZK technology.

Class 8: Summary and Future Thoughts on ZK Technology

 	The final class summarizes everything covered in the course and provides thoughts on the future of ZK technology.

Background Experience with ZK Tech
Section Overview: In this section, the instructor talks about their background experience with zero-knowledge technology.

 	The instructor started studying zero-knowledge proofs about a year ago when they became interested in blockchain technology.
 	They aim to provide a solid overview for beginners so that by the end of the course, students should have intermediate knowledge of ZK technology.

Introduction to Zero Knowledge Proofs
Section Overview: In this section, the speaker introduces the concept of zero knowledge proofs and explains how it can be used for verifiable computation.
What is Zero Knowledge?

 	Zero knowledge is a field of verifiable computation that allows one to prove that a computation was done correctly.
 	The power of zero knowledge lies in its ability to verify computations without revealing any information about them.
 	Many applications labeled as "zero knowledge" may not actually require privacy features.

Background in Mathematics

 	Polynomials are a key component of zero knowledge proofs.
 	Different polynomials are mostly different, which allows us to check if two polynomials are the same by checking them at one point.

Motivating Problem

 	How do you know if someone has your data when sending it over an untrusted network?
 	A solution will be presented later on in the class.

Verifiable Computation
Section Overview: In this section, the speaker discusses the problem of verifying computations and introduces the concept of verifiable computation.
The Problem of Verifying Computations

 	The problem of verifying computations is ubiquitous.
 	Solution 1 to verify if all data points are saved is to ask for all million data points back from Eve. This solution is not efficient when doing a computation.
 	Solution 2 is to ask Eve to send one value back at a time. However, this method is also inefficient as it requires asking for many values.

Making a Polynomial through All Points

 	A polynomial can be made through all data points, and then evaluated at one random point outside the original data.
 	If Eve has all the data points, she will be able to make the correct polynomial and evaluate it correctly.
 	If Eve does not have all the data points, there will be a strong probability that she will mess up with a high percentage of times.

Achievable Problems
Section Overview: In this section, the speaker talks about how it is possible to get a million data points by just asking for one point. This idea can give intuition for how achievable problems are.
Understanding Achievable Problems

 	It is possible to get a million data points by just asking for one point.
 	This idea can give intuition for how achievable problems are.

Desired Properties of Ethereum
Section Overview: In this section, the speaker discusses the desired properties of Ethereum and what they want to achieve with it.
Desired Properties of Ethereum

 	The desired properties of Ethereum include being cheap to verify and generate.
 	They don't want Eve to have to do too much work generating proofs.
 	They want proof size to be small.
 	Recent ZK developments aim at making proofs cheaper for Eve.

ZK Snarks
Section Overview: In this section, the speaker introduces ZK snarks as a solution that meets their desired properties.
Introduction to ZK Snarks

 	ZK snarks meet the desired properties of being cheap to verify and generate while keeping proof size small.
 	The goal is to make the solution non-interactive so that proofs can be posted once without back-and-forth communication between parties.

Generating a Polynomial Proof
Section Overview: In this section, the speakers discuss how to generate a polynomial proof that can be verified without revealing the data. They explain why it is important to prevent Eve from having control over the evaluation point and introduce the concept of trusted setup.
Preventing Eve from Cheating

 	To prevent Eve from cheating, we shouldn't let her pick the evaluation point.
 	The task is for Eve to generate a polynomial to prove that the data has been processed and the result is uniquely verifiable.
 	We want Eve to be able to generate the entire proof on our own but still not let her pick whichever evaluation point she wants.

Fiat-Shamir Transformation

 	The Fiat-Shamir transformation is used when we don't want you to pick the points so we're going to use a trusted setup.
 	Trusted setup means everyone in the world agrees on some randomness.
 	A hash function is used in this example where Peggy has no control over what output of hash will be because no one can reverse engineer hash functions.
 	By taking hash, we end up with this value C that Peggy couldn't have known ahead of time.

Using Randomness in Cryptographic Algorithms
Section Overview: In this section, speakers discuss using randomness in cryptographic algorithms and how it helps keep information zero knowledge.
Discrete Logarithm Problem

 	The discrete logarithm problem involves proving that you know some X such that when you raise G to power X, you get some Y which is public.
 	We include some randomness as a blinding factor so that we don't reveal information about what's happening and keep it zero knowledge.
 	Hash function comes into play here as it's like a one-way function and by taking its hash, we end up with value C which Peggy couldn't have known ahead of time.

Trusted Setup

 	Trusted setup is used in ZK snarks where everyone agrees on some randomness.
 	There are whole ceremonies with multi-party computation where everybody adds a little randomness in and as long as one person did it correctly, there's going to be some random value.
 	The future zero knowledge proofs can refer to this random value in the trusted setup.

Making Proofs Non-Interactive
Section Overview: In this section, the speaker discusses how to make proofs non-interactive using a hash function and polynomial commitment.
Discrete Logarithm Problem

 	The discrete logarithm problem is used to create a wave so that Eve cannot pick the points.
 	A hash function is used to generate an output that is uncontrollable.

Polynomial Commitment

 	To make solutions more efficient, a polynomial commitment is used instead of reading the whole polynomial.
 	This allows for checking only certain points rather than all of the data.
 	Merkle trees are used as a data structure for polynomial commitments.

Merkle Trees

 	Merkle trees start with data blocks at the bottom and hash them together to create a top hash.
 	The top hash can be put on the blockchain or sent over to commit to everything below it.
 	Hash functions are one way, so the only way to get the top hash is by starting with the data and going through all of the hashes.

Polynomial Commitment and Fry
Section Overview: In this section, the speaker discusses polynomial commitment and Fry, which stands for fast read Solomon interactive Oracle proofs of proximity.
Polynomial Commitment

 	A top hash is a sort of a commit polynomial commitment.
 	The coefficients of the polynomials are committed to by posting the top hash to the blockchain.
 	There are scaling solutions to blockchains by storing some data on-chain and having the rest off-chain.
 	The problem with polynomial commitment is that if one is not going to read the whole polynomial, how do they know it's a polynomial?
 	Vitalik has a blog post on Fry (fast read Solomon interactive Oracle proofs of proximity), which refers to polynomials that are fast and interactive Oracle proofs.

Fry

 	Interactive Oracle proofs involve back-and-forth checking of points.
 	Proofs of proximity ensure that it's close to small polynomials most of the time.
 	Arrange data points into a grid and check rows, columns, and diagonal points to ensure it's a low degree polynomial.
 	Combining with Merkle tree involves committing to entire data structure so that specific pieces can be requested later.

Recursive Snarks
Section Overview: In this section, the speaker talks about recursive snarks as an improvement over current methods.
Recursive Snarks

 	Instead of verifying proof directly, verify that proof verifies by coming up with another proof or quick check.
 	Condense all information down into quick check.

Markle Trees and Rank One Constraint System
Section Overview: In this section, the speaker explains how Markle trees work and why they are useful in zero-knowledge proofs. The speaker also introduces the concept of rank one constraint system (R1CS) as an intermediate representation of code that can be fed into a zero-knowledge proof.
Markle Trees

 	Hashing all data together is not efficient for verifying specific pieces of data.
 	Markle trees allow for quick verification by checking only relevant hash values instead of every single piece of data.
 	This cheap verification cost makes Markle trees ideal for use in zero-knowledge proofs.

Rank One Constraint System (R1CS)

 	R1CS is an intermediate representation of code that can be fed into a zero-knowledge proof.
 	R1CS involves converting code to polynomials using logic gates such as plus and times.
 	The output is a polynomial that represents the computation performed by the original code.

Zero-Knowledge Proofs with Snarks
Section Overview: In this section, the speaker explains how to convert code into a format suitable for use in zero-knowledge proofs with snarks. They also discuss how snarks can be used to verify computations without revealing any sensitive information.
Converting Code to Snark-Friendly Format

 	Code must be converted to r1cs or another snark-friendly format before it can be used in a zero-knowledge proof.
 	The snark requires a trusted setup with randomness parameters.
 	The verifier is typically a smart contract on the blockchain, while the prover generates a proof and sends it to the verifier.

Verifying Computations with Snarks

 	Snarks can be used to verify computations without revealing any sensitive information.
 	Efficiency for both the prover and verifier is a main concern in using snarks.

Resources for Learning ZK
Section Overview: In this section, the speaker recommends resources for learning Zero Knowledge (ZK) concepts and programming.
Recommended Resources

 	: A series of 11 or 12 videos on ZK concepts. The first three videos by Dan Benet are highly recommended.
 	: A community of smart people from the ZK community who can help with questions.
 	: A podcast that covers various topics related to ZK.
 	: A practical class for programmers to learn Hands-On programming.

Incentives and Scalability in ZK
Section Overview: This section discusses incentives and scalability in using Zero Knowledge (ZK) proofs.
Incentives for Provers and Verifiers

 	Transaction fees are the incentive for provers and verifiers. The more proofs added, the less reward to users involved.
 	As scale increases, efficiency improves. For example, if a Merkle tree has only four values, it is not very efficient. However, if it has a billion values, it becomes much more efficient.
 	Roll-Ups generate a proof every couple of hours because batching many things at once into one short simple proof is more efficient than generating one every minute.

Sharing Information to Generate Proof

 	To generate a proof, you need the code or circuit and the Trusted setup.
 	From the Stark process, you get R1CS to feed into the snark, which produces a verifier and prover.
 	Once you have the proof and a way to verify it, you can post it on the blockchain.

Use Cases for ZK
Section Overview: This section discusses use cases for Zero Knowledge (ZK) proofs.
Incentives for Non-Financial Tasks

 	The incentive for using ZK in non-financial tasks is when the proverb doesn't trust the verifier.

Recap of Information Shared to Generate Proof

 	To generate a proof, you need the code or circuit and the Trusted setup.
 	From the Stark process, you get R1CS to feed into the snark, which produces a verifier and prover.
 	Once you have the proof and a way to verify it, you can post it on the blockchain.

Learning Resources

 	Trail of Bits has a good resource on common ZK security vulnerabilities.
 	The speaker plans to cover this topic in one of their later classes.
 	They recommend checking out Trail of Bits or Outpost for more information.

### NEAR Certified Developer 그 다음 단계

NCD 프로그램을 성공적으로 마치고 NEAR 메인넷에 있는 수천명의 유저들에게 프로젝트를 알리고 싶다면 하단의 프로그램에 지원해보세요.

NEAR Fortified Developer

아니면

NEAR 생태계 프로젝트 채용공고에 지원해보세요

해당 단계까지 도달하셨다면 최종 작업물을 제출하는 단계만 남았습니다.

데모는 완전히 기능하는 애플리케이션이 될 수도, (테스트를 거치거나 아직 거치지 않은) 컨트랙트가 될 수도, 아니면 디자인에 그친 상태여도 상관없습니다. 

단순히 “다른 사람들과 공유하고 싶은 아이디어”에만 그치지 않으시면 됩니다.

 	필수 제출사항:

 	데모 프로젝트명

 	팀 이름

 	깃허브 저장소(Github Repo) 

 	본인 데모 프로젝트에서 가장 마음에 든 부분

 	본인 데모 프로젝트에서 가장 마음에 들지 않은 부분

제출된 응답은 추후 심사평가 받게 됩니다.

### NEAR Certified Developer 6단계 – Web3 데모 제출하기

스마트 컨트랙트 프로젝트 보여주기

 해당 단계는 자신의 작업물을 남들에게 보여주는 것을 목표로 삼고 있습니다.
 주요 활동 

 	본인 프로젝트의 시연을 영상과 슬라이드로 담아주세요.
 	매월 마지막 금요일에 진행되는 NCD 데모 라이브 세션에서 5-10분 내로 프로젝트를 발표해주세요. 
 	성공적으로 프로그램을 마친 것을 축하드립니다.

데모 제출하기

                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### NEAR Certified Developer 5단계 – Web3 배포하기

위 단계들을 통해 스마트 컨트랙트를 개발하고 시험해볼 수 있는 방법들을 알려드렸습니다. 5단계에선 유저들이 실제로 사용할 수 있도록 스마트 컨트랙트를 NEAR 블록체인에 배포하는 방법을 알려드리겠습니다. 

NEAR에는 다양한 네트워크가 있고, 그 중에는:

 	메인넷 
 	테스트넷 

등이 있습니다. 

이번 단계에서는 NEAR 테스트넷에 스마트 컨트랙트를 배포하는 방법을 알려드릴 것이며, 메인넷에 배포하는 방법은 테스트넷과 동일합니다. 
테스트넷에 스마트 컨트랙트 배포하기
먼저 아래 커맨드를 통해 컴퓨터 상 NEAR-CLI를 준비합니다.

$ near --version

1단계: 스마트 컨트랙트 만들기

NEAR는 WASM 양식을 사용하므로 스마트 컨트랙트를 배포하기에 앞서 .wasm 파일 양식에 맞춰 스마트 컨트랙트를 준비해주시기 바랍니다. 스마트 컨트랙트를 만들기 위해 아래 커맨드를 사용해주세요.

$ npm run build:contract

성공적으로 스마트 컨트랙트를 만들고 나면 /contract/build/contract.wasm에서 파일을 확인하실 수 있습니다.

2단계: 테스트넷에 컨트랙트 배포하기

테스트넷에 스마트 컨트랙트를 배포하는 데는 2가지 방법이 있습니다

 	near dev-deploy: 자동으로 개발자 계정을 생성하여 빠르게 테스트넷에 스마트 컨트랙트를 테스트할 수 있도록 스마트 컨트랙트를 배포합니다
 	near deploy: 기존에 생성한 계정에 컨트랙트를 배포합니다

“near dev-deploy” 사용하기

커맨드:

$ near dev-deploy <path_to_wasm_file>

contract.wasm을 배포하기 위해 아래 커맨드를 실행하시기 바랍니다: 

$ near dev-deploy contract/build/contract.wasm

NEAR에서 자동으로 무작위 개발자 계정을 생성하고 테스트넷에 스마트 컨트랙트를 배포해줍니다.



위 예시에선 dev-1667173869138-29253364925009 라는 계정에 스마트 컨트랙트가 배포 됐음을 확인할 수 있습니다

이처럼 개발자 계정은 본인의 홈 디렉토리 내의 .near-credentials 폴더에 저장됩니다.

“near deploy” 사용하기

near deploy를 사용할 경우 본인이 선택한 계정에 스마트 컨트랙트를 배포할 수 있고, 이를 위해 우선 본인의 계정으로 NEAR-CLI에 가입하셔야 합니다 :

$ near login

본인의 NEAR 지갑에서 가입에 사용할 계정을 선택해주세요.



위 예시의 경우 NEAR 지갑을 통해 nearvietnamhub.testnet 계정을 선택한 것을 확인할 수 있습니다.

컨트랙트를 위한 서브계정 만들기

커맨드 : 

$ create-account near <sub-account> --masterAccount <master account> --initialBalance 5

서브계정 (sub-account)이란 주 계정을 통해 만들어진 계정을 의미합니다. 서브계정은 독자적 계정으로 주 계정에 의해 관리되지는 않습니다.

예: example.nearvietnamhub.testnet , nft.nearvietnamhub.testnet, counter.nearvietnamhub.testnet etc.



서브계정을 만든 뒤 아래 커맨드로 컨트랙트를 배포하세요.

$ near deploy <sub-account> <path_to_wasm_file>



상기 단계들을 성공적으로 따랐으면, 위 예시처럼 counter.nearvietnamhub.testnet과 같이 서브계정에 성공적으로 컨트랙트가 배포됐음을 확인할 수 있습니다.
NEAR-CLI를 통해 스마트 컨트랙트와 상호작용
NEAR-CLI는 스마트 컨트랙트와 상호작용할 수 있도록 2가지 커맨드를 제공합니다

View 커맨드

View 커맨드는 컨트랙트의 기능들을 볼 수 있게 하는 커맨드로, 자유롭게 사용 가능하며 가스비를 필요로 하지 않습니다.

$ near view <contractId> <methodName>



카운터 컨트랙트(counter contract)에서 해당 기능을 테스트하실 수 있습니다.

Call 커맨드

Call 커맨드는 읽기, 쓰기 기능을 수행합니다. 위 방법을 사용하기 위해선 Call을 호출하기 위해 사용되는 계정을 지정하셔야 합니다. 지정된 계정은 트랙잭션 처리를 위해 가스비를 사용합니다. 

$ near call <contractId> <methodName> <jsonArgs> --accountId <yourAccount> [--deposit<amount>] [--gas<GAS>]

예



성공적으로 실행한 후, 카운터 값을 확인해주시기 바랍니다.



위 예시에선 카운터 값이 1로 올라간 것을 확인할 수 있습니다
더 알아보기
NEAR에서 스마트 컨트랙트 배포하는 방법에 대해 더 알아보고 싶으신 분들은, 아래와 같은 방법들을 사용하실 수 있습니다

 	해당 프로그램의 2단계를 읽고 컨트랙트를 개발 및 배포하기
 	카운터 컨트랙트(counter contract)의 잔여 function들 호출하기

참고자료

 	스마트 컨트랙트 배포하기: https://docs.near.org/develop/deploy
 	NEAR-CLI: https://docs.near.org/tools/near-cli
 	NEAR-CLI로 call method에 매개변수(params)를 전달 :  https://docs.near.org/tools/near-cli
 	스마트 컨트랙트에 프론트엔드 만들기: https://docs.near.org/develop/integrate/frontend
 	near-api-js: https://docs.near.org/tools/near-api-js/quick-reference
 	create-near-app을 통해 NEAR 블록체인에 빠르게 앱 개발하기 https://github.com/near/create-near-app

위 단계까지 착실히 따라오셨다면 이제 데모를 제출하실 준비가 됐습니다.


                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### NEAR Certified Developer 4단계 – Web3 테스트하기

개발자라면 기능들이 의도한 대로 안전하게 수행되는지 항상 검증해야 하며, NEAR에선 이를 지원할 수 있도록 검증 도구를 준비했습니다.

기본적으로 기능 검증을 위해 2가지 유형의 테스트를 제공하고 있습니다: 

 	유닛 테스트: 컨트랙트의 프로그래밍 언어를 사용하고 로컬에서 테스트를 실행합니다. 유닛 테스트는 스마트 컨트랙트의 개별 기능을 테스트하기 위해 사용합니다.
 	통합 테스트 : 실제 환경에서 스마트 컨트랙트가 어떻게 작동하는지 확인합니다. 통합 테스트는 Rust 또는 JavaScript (TypeScript)를 사용하여 작성할 수 있습니다. 

통합 테스트는 일반적으로 샌드박스 또는 NEAR 테스트넷 네트워크에서 수행됩니다.

LNC는 실제 환경에서 스마트 컨트랙트가 제대로 작동하는지 확인할 수 있도록 유닛 테스트와 통합 테스트를 모두 수행하는 것을 권장합니다. 각각의 테스트 유형은 스마트 컨트랙트 운영 중 발생할 수 있는 다른 종류의 오류를 식별하는 데 적합합니다.
스마트 컨트랙트 테스트 
테스트 하기에 앞서 이전 섹션에서 LNC가 안내해 만든 카운터 스마트 컨트랙트(counter smart contract)(counter contract)로 돌아가보도록 하겠습니다. 이번 섹션에서는 해당 컨트랙트 자체에 대한 테스트를 작성하는 방법을 알려드리겠습니다. 
1단계: 테스트의 초기 구성 및 설정 검토하기 
/integration-tests/src/main.ava.ts 파일에 접근합니다.



아래 function들을 통해 애플리케이션 테스트를 진행해보시기 바랍니다. 

 	test는 Worker 샌드박스로 테스트 모듈을 선언하고, context에서 테스트를 수행할 계정의 목록을 저장합니다.
 	test.beforeEach() function은 테스트를 시작하기 전에 실행되고 test.afterEach() function은 테스트 후에 실행됩니다. 
 	특히 test.beforeEach()에 더 주의를 기울여 주시기 바랍니다. 이 function에서 LNC는 init Worker 를 선언하고 루트에서 서브계정을 생성한 다음 해당 계정에 컨트랙트를 배포합니다. 테스트넷에서 사용하든 메인넷에서 사용하든 동일하게 구현하기 때문에 스마트 컨트랙트가 실제로 어떻게 작동하는지 정확히 확인할 수 있습니다. 

2단계: 테스트 function 작성하기

 	 number의 초기값 가져오기




View method인 get_number로 현재 카운터값을 가져옵니다.

 	increase_number, decrease_number : number의 값을 증가시키고 감소시킵니다.






increase_number, decrease_number 둘 다 call method이므로, 컨트랙트를 호출하기 위해선 계정을 통해 호출해야 합니다.

 	사용자 계정에서 컨트랙트로 NEAR 예치 테스트하기:



 	Private function 테스트하기:




Private function은 컨트랙트 계정에서 나타난 method 호출만 허용하므로 contract.call을 사용합니다.

‘Private’ function은 주로 컨트랙트 계정에서 직접 호출되기 보다 ‘stake()’와 같은 다른 function의 콜백(callback)으로 사용됩니다.

테스트 섹션에서 사용되는 소스 코드는 전부 해당 링크에서 확인할 수 있습니다.
3단계. 테스트 실행하기
하단의 커맨드로 테스트를 실행해보세요

$ npm run build:contract && npm run test

결과:


참고 자료

 	NEAR 유닛 테스트: https://docs.near.org/develop/testing/unit-test
 	NEAR 통합 테스트: https://docs.near.org/develop/testing/integration-test

### NEAR Certified Developer 3단계- Web3 애플리케이션 구축하기

Web3 애플리케이션 구축하기 단계의 이해를 돕기 위해, LNC는 오늘날 널리 사용되는 프로그래밍 언어인 JavaScript 프로그래밍 언어(TypeScript)를 사용하여 스마트 컨트랙트를 생성하는 과정을 안내해드리겠습니다.
환경설정
시작하기 전에, 컴퓨터가 NEAR에서 스마트 컨트랙트를 구축할 수 있도록 환경과 도구가 준비되어 있어야 합니다:

 	 Git: https://git-scm.com/
 	 NodeJs 및 npm:  https://nodejs.org/en/
 	 NEAR-CLI: https://github.com/near/near-cli
 	 Visual Studio Code: https://code.visualstudio.com/
 	 NEAR 테스트넷 지갑 생성: https://wallet.testnet.near.org/

모든 것이 준비됐는지 확인하려면 다음 커맨드로 확인하세요:

$ git --version

$ node -v

$ npm -v

$ near --version

참고: 먼저 커맨드 라인 사용법을 숙지하고 있어야 합니다.

추천 키워드를 통해 자세히 알아보세요: “윈도우/리눅스/맥OS에서 커맨드 라인을 사용하는 방법”
템플릿 프로젝트 복제
LNC는 복잡한 파라미터와 라이브러리를 구성하지 않아도 됩니다.

즉, 스마트 컨트랙트를 바로 시작할 수 있도록 템플릿을 만들었습니다.

$ git clone https://github.com/nearvndev/near-ts-template.git

$ cd near-ts-template && npm install

참고: 아니면 create-near-app를 사용하여 새 프로젝트를 부트스트랩하실 수도 있습니다.
프로젝트 템플릿 구조
프로젝트 템플릿은 더 작은 프로젝트로 나뉘어져 있습니다:

 	/contract - 프로젝트의 스마트 컨트랙트 
 	/frontend - ReactJS 프론트엔드 
 	/integration-tests - 통합 테스트 

이번 단계에서는 스마트 컨트랙트 구축에 초점을 맞출 것입니다. 따라서 /contract 폴더에 더 많은 주의를 기울이시기 바랍니다.
NEAR에서 스마트 컨트랙트를 구축하기 위한 가이드
LNC는 다음과 같은 기본 function으로 카운터 스마트 컨트랙트(counter smart contract)(counter contract)를 생성하는 과정을 안내하겠습니다. 
이제 NEAR에서 스마트 컨트랙트를 최대한 쉽게 구축할 수 있도록 도와드리겠습니다: 

 	카운터 스마트 컨트랙트(counter smart contract)(counter contract)는 0과 같은 정수로 시작합니다. 
 	사용자가 현재 번호의 값을 가져올 수 있도록 허용합니다. 
 	사용자가 현재 숫자의 값을 늘리거나 줄일 수 있습니다. 
 	컨트랙트 소유자가 숫자를 0으로 재설정할 수 있습니다.
 	이 외에도 다양하고 재밌는 기능들이 많이 있습니다.

1단계: Contract class에 대해 알아보기 

Visual Studio Code에서 near-ts-template을 열고/contract/src/contract.ts로 이동합니다



 	 NearBindgen: 프로젝트의 다른 class와 다른 스마트 컨트랙트의 main class로 어노테이션(annotation)을 하는데 사용됩니다. 
 	 call, view, near: 스마트 컨트랙트 function과 상호작용하기 위해 NEAR-SDK-JS에서 가져온 것 입니다. 

2단계: 컨트랙트 상태 초기화하기

컨트랙트에 자료형이 number인 변수 num = 0을 선언 및 초기화합니다.



3단계: Function 만들기

View, Call functions



위 예시에서 보시면, 3개의 새로운 function get_number, increase_number, decrease_number 가 있습니다.

 	get_number: 아무 것도 변경하지 않고 컨트랙트에서 데이터만 가져오는 function이므로 @view({})를 이용합니다.
 	increase_number, decrease_number: 이러한 function은 컨트랙트의 데이터를 변경하므로 @call({})를 이용해야 합니다. call function을 사용하면 사용자 계정으로 call에 서명해야 합니다. near.predecessorAccountId() 또는 near.singerAccountId()를 통해 accountId를 가져올 수 있습니다. 

Private function : 

그렇다면 컨트랙트의 소유자만 접근할 수 있는 function을 원한다면 어떻게 해야 할까요? 

@call({privateFunction: true})으로 function에 어노테이션(annotation)을 달기만 하면 됩니다. 

예: 카운터를 0으로 설정하고 컨트랙트 소유자만 이 method를 호출할 수 있는 reset_number function을 추가할 수 있습니다.



Payable function :

사용자가 기부, NFT 구매, 결제 등의 작업을 위해 컨트랙트에 NEAR를 입금 할 수 있도록 합니다. @call({payableFunction: true})로 function을 표시할 수 있습니다. 

예를 들어, 사용자가 NEAR를 입금할 수 있는 function을 선언하고 사용자가 입금한 NEAR의 양을 가져옵니다.



모든 function을 구축한 뒤, 컨텐츠가 내포된 컨트랙트를 확인할 수 있습니다: (참고링크: (1) )
컨트랙트 만들기
NEAR는 컨트랙트에 WASM을 사용하므로 컨트랙트 코드를 JavaScript에서 WebAssembly로 컴파일해야 합니다. 다음 커맨드를 실행하세요 : 

$ npm run build:contract

컨트랙트가 완료되면 /contract/build/contract.wasm에서 파일을 확인합니다. 

해당 단계를 마치셨다면 새로운 NEAR 기반의 스마트 컨트랙트가 성공적으로 생성됐을 것입니다.
더 알아보기

 	Guest-book JS 예제보기 – 매개변수(params)가 있는 function: https://github.com/near-examples/guest-book-js
 	https://docs.near.org/tutorials/welcome 에서 JavaScript/Rust 기반의 더 많은 dApp 예시 보기
 	컨트랙트의 특정 기능을 수정하거나 재작성해보시고, 마음껏 창의력을 발휘해보세요 #createWithoutLimits

더 알아보기
이 튜토리얼은 JavaScript로 컨트랙트를 구축하는데 중점을 두고 있습니다.
또한, Rust를 선호하는 경우 (참고링크: (1) )에 있는 튜토리얼을 참조할 수 있습니다. Web3 애플리케이션 구축하는 것에 대해 더 자세히 알아보고 싶으신 분들은 하단의 링크를 참고하시기 바랍니다.

 	NEAR JavaScript SDK: https://docs.near.org/tools/near-sdk-js
 	NEAR Rust SDK: https://docs.near.org/tools/near-sdk-rs
 	대체 불가능한 토큰(Non-fungible Token): https://nomicon.io/Standards/Tokens/NonFungibleToken/
 	대체 가능한 토큰(Fungible Token): https://nomicon.io/Standards/Tokens/FungibleToken/
 	멀티 토큰(Multi Token): https://nomicon.io/Standards/Tokens/MultiToken/

Rust
컴퓨터에서 Rust를 처음 사용하는 경우, 문서에 있는 Intro to Rust를 참조하세요. "3단계 Rust 설치 방법(3-Step Rust Installation)"를 통해 필요한 소프트웨어를 설치하실 수 있을 것입니다. 

Rust 기반의 애플리케이션 개발에 관심있으신 분들은 [Rust 기반 dApp 목록 보기]를 참조하시기 바랍니다.

CORE Activity로 표시된 애플리케이션을 최소 3개 이상 읽어야 합니다. 

Rust 컨트랙트 기본 사항에 대한 자세한 내용도 읽어보실 수 있습니다.


컨트랙트를 이용하지 않는 경우 
NEAR에서는 컨트랙트를 사용하지 않는 애플리케이션도 구축할 수 있습니다. 

다음은 몇가지 예시들 입니다: [컨트랙트를 사용하지 않는 애플리케이션 목록 보기]

### NEAR Certified Developer 2단계 – Web3 읽기

이전 단계에서는 Web3, Web3 애플리케이션 아키텍처, 그리고 NEAR 프로토콜에 대해 배웠습니다. 다음 단계에서 NEAR 기반 Web3 애플리케이션을 구축할 수 있도록 컨트랙트 읽기를 집중적으로 익혀보겠습니다. 컨트랙트는 어떻게 돈과 재산, 신원, 소유권을 관리하는지 알아볼까요?
2단계를 완전히 이해하려면
이번 강의의 목표는 최대한 많은 스마트 컨트랙트를 읽어보는 것입니다. 컨트랙트나 프로젝트를 살펴 보시면서 아래와 같은 질문을 생각해봐주시기 바랍니다:


 	이 컨트랙트의 목적은 무엇인가?
 	이 컨트랙트는 어떻게 작성됐는가?
 	이 컨트랙트는 왜 이렇게 작성됐는가?

주의사항:

 	JavaScript/TypeScript 및 Rust 프로그래밍 언어에는 수많은 컨트랙트가 있습니다. 자신에게 맞는 언어를 선택하세요.
 	컨트랙트를 개발하거나 테스트할 필요는 없습니다.
 	전체적으로 코드를 이해할 필요도 없습니다.
 	컨트랙트의 가장 기본적인 부분을 읽고 컨트랙트의 목표를 어떻기 코드로 구현했는지에 더 집중해보도록 합니다.

이 시점에서 무엇을 해야 하는지 완전히 이해하지 못할 수도 있습니다. 어디서부터 시작해야 할지 모르겠는 분들을 위해 먼저 프로젝트를 읽는 기본적인 방법을 알려드리겠습니다.
Hello NEAR 프로젝트 – JavaScript
깃허브 프로젝트 : https://github.com/near-examples/hello-near-js

Hello NEAR는 인사말을 저장하는 데 사용되는 간단한 디앱(dApp, 탈중앙화 애플리케이션)입니다. 위 디앱은 크게 두 파트로 구성됩니다:


 	인사말을 저장하고 변경할 수 있는 스마트 컨트랙트
 	인사말을 표시하고 사용자가 변경할 수 있는 간단한 웹 인터페이스

우선 JavaScript 프로그래밍 언어로 Hello NEAR 프로젝트를 읽어보도록 하겠습니다.

프로젝트의 구조는 다음과 같습니다:

 

 	프론트엔드 – /frontend에 ReactJs
 	/contract에 스마트 컨트랙트 코드

[ 컨트랙트 ]
file/contract/src/contract.ts로 접속합니다.



컨트랙트에는 스마트 컨트랙트를 나타내는 HelloNear class가 있습니다:


 	스마트 컨트랙트는 greeting 변수에 초기값 “Hello"를 저장합니다.
 	get_greeting function은 @view({}), i.e.로 표시되어 있고, 트랜잭션 수수료 없이 블록체인에서 데이터를 읽기만 합니다. get_greeting은 greeting에 저장된 값을 반환합니다.
 	set_greeting function은 @call()로 표시되어 블록체인에 저장된 값을 변경하므로 function을 호출할 때 트랜잭션 수수료가 발생합니다. set_greeting은 사용자가 입력한 새 값을 greeting 변수의 값으로 저장합니다.

여러분의 임무는 아래 목록에서 최대한 많은 컨트랙트를 읽은 다음 최종 과제를 완료하는 것입니다.
더 알아보기 
기본 컨트랙트부터 고급 컨트랙트까지 원하는 언어로 하단 링크에서 읽어보시기 바랍니다: https://docs.near.org/tutorials/welcome

### NEAR Certified Developer 1단계 - Web3 이해하기

NEAR 프로토콜을 사용하여 Web3 애플리케이션을 만드는 방법을 배우기에 앞서, Web3란 무엇인지, Web3 애플리케이션의 구조, 그리고 NEAR 프로토콜이 무엇인지 알아둘 필요가 있습니다.

배움을 통해 우리는 새로운 환경에 대해 인식하고, 또한 그 작동 원리를 이해할 수 있게 됩니다. 배경을 이해하면 이해할수록 앞으로의 과정이 더욱 흥미로워질 수 있으니 아래 과정들을 건너뛰지 마시고 꼭 정주행하시기 바랍니다.

​​We wish you much LUCK and JOY!!
Web3.0이란?
Web3가 무엇인지 이해하기 위해서는 우선 Web1과 Web2가 무엇인지 알아볼 필요가 있습니다.


Web 1.0: 정적 웹 (Static Web)
정적 웹(Static Web)이라고도 불리는 Web 1.0은 1990년대의 인터넷 환경으로, 정보의 열람만 가능하고 상호작용은 불가능(하거나 극히 제한된)한 형태입니다. 이러한 환경에서, 개인이 직접 본인의 페이지를 만들거나, 웹상에 의견을 남기는 것은 바람직하지 못한 행동으로 간주되었습니다 

또한 데이터를 필터링할 수 있는 알고리즘 자체가 존재하지 않았기 때문에 각자가 필요로 하는 정보를 찾기가 매우 어려웠습니다. Web 1.0은 마치  좁은 일방통행 도로와 같아 한 쪽에서 소수의 선택된 사람들이 정보를 생성하면, 반대편에서는 그렇게 만들어진 정보를 일방적으로 수용할 수 밖에 없었습니다. 

이러한 Web 1.0의 모습은 뉴스, 신문, 그리고 블로그를 생각하면 쉽게 떠올릴 수 있을 것입니다. 이 시대의 컨텐츠는 특정 개인 또는 단체에 의해 생산되는 것이었으며, 사용자들은 검색이 아닌 카테고리의 형태를 통해서 컨텐츠들에 접근할 수 있었습니다.
Web 2.0: 소셜 웹(Social Web)과 참여형 웹 (Participative Web)
소셜 미디어(Web2.0)를 통해 사람들은 인터넷 환경에서 더욱 많은 상호작용을 할 수 있게 되었습니다. JavaScript, HTML5, CSS3 등 웹기술의 진전과 함께 이를 활용하여 수많은 스타트업들이 상호작용이 가능한 웹 플랫폼(유튜브, 페이스북, 위키피디아 등)을 세상에 선보였기 때문입니다. 

이렇듯 Web 2.0은  ‘소셜 네트워킹'과 더불어 ‘사용자 제작 컨텐츠'에 새 장을 열어주었으며 우리가 지금 다양한 플랫폼, 애플리케이션을 통해 컨텐츠를 배포하고 공유할 수 있는 토대가 되었습니다.
Web 3.0: Blockchain
Wikipedia에 따르면, 우리가 현재 생각하는 Web3는 1999년 팀 버너스 리 (Tim Berners-Lee)가 주창한 시맨틱 웹 (semantic web)과는 다른 개념이라는 것을 알 수 있습니다.[18] 이는 2006년 버너스 리가 시맨틱 웹을  Web3.0의 구성 요소로써 언급한 것을 보면 더욱 명확해지는데, 우리가 Web3를 블록체인의 맥락에서 이야기하는 것과 차이가 있습니다.[19] 

"Web3"는 이더리움 (Ethereum)의 co-founder이자 폴카닷 (Polkadot)의 founder인 개빈 우드 (Gavin Wood)가 2014년 처음 사용한 용어로, "블록체인을 기반으로 하는 탈중앙화된 온라인 생태계"로 정의할 수 있습니다.[1] 이러한 Web3 개념은 2021년 대두되기 시작하여[20] 2021년 말에 이르러서는 암호화폐 (cryptocurrency) 열성팬들의 관심, 그리고 전문가와 기업들의 투자가 동반되며 중요한 키워드로 급부상하게 됩니다.[5][6] a16z 로 더욱 익숙한 벤처 캐피탈 Andreessen Horowitz의 임원들이 2021년 10월 워싱턴 D.C.에 방문하여, 의회와 백악관에서 고위 공직자들과 함께 Web3에 관한 미팅을 가진 사실 또한 이런 관심을 잘 드러내고 있습니다[21] 
그렇다면 Web3 애플리케이션에 블록체인이 필요한 이유는 무엇일까?
정보 기술 산업의 성장과 함께 정보와 데이터의 저장, 관리, 사용 등 다양한 정보 처리 기술이 발전되어 왔습니다. 우리가 사용하고 있는 각종 기계 장치, 인공지능(AI) 등 우리 주위의 많은 것들이 방대한 정보와 데이터를 기반으로 하고 있으며 정보화 사회에서 원본 데이터의 중요성은 더욱 높아지고 있습니다. 당장 지금 뿐만 아니라 다음 세대를 위해서라도 원본 데이터를 어떻게 보존할 것인가는 매우 중요한 문제입니다.

원본 데이터가 유실되거나, 조작된다면 어떻게 될까요? 심지어 특정 조직이 정보 접근 권한을 통제해서 사용자들에게 전달되는 경험이 조작된다면?

위와 같은 문제를 해결하기 위해 블록체인 기술이 개발됐습니다.


Web 애플리케이션 아키텍처 : 
Web3 애플리케이션의 구조를 더 잘 이해하기 위해서는 기본적인 Web2 애플리케이션의 구조를 살펴볼 필요가 있습니다. Web2 애플리케이션은 다음과 같이 구성됩니다:

 	Account: ID, 비밀번호, 액세스 토큰 등을 통한 계정 보안
 	Frontend: 웹, 앱 또는 CLI(Command Line Interface)를 통한 유저 인터랙션
 	Backend: NodeJS, Java, Sprint, .NET 등을 통한 요청 데이터 처리 및 데이터 업데이트
 	Data: 중앙화된 데이터베이스로의 데이터 저장

Web3 애플리케이션 아키텍처 :
Web3 애플리케이션 또한 Web2 애플리케이션과 유사한 구조를 가지고 있습니다.

 	Account: 개인 키(Private Key)를 통한 지갑(Wallet) 보안
 	Frontend: Web2와 유사한 프론트엔드
 	Backend: 스마트 컨트랙트(Web2의 백엔드와 유사)
 	Data: 블록체인을 통한 데이터 저장/보안



시중의 많은 자료들에서 Web3, 블록체인 관련한 개념이 혼용되거나 오용되어 이해가 쉽지 않은 경우들이 있습니다. NCD 과정을 통해 LNC가 제공하는 정보가 조금 더 Web3의 이해에 도움이 되고, 앞으로 이 분야에서 전개해 나갈 커리어에도 보탬이 되었으면 합니다.

이제 여러분은 LNC의 NEAR Certified Developer 프로그램을 통해블록체인의기본 원리와 함께 NEAR 프로토콜에서 Web3 애플리케이션을 개발하는 방법을 배우게 될 것입니다. Let’s Begin!
NEAR 프로토콜이란?
NEAR는 사용자 친화적(User-friendly)이며, 친환경적인(Eco-friendly) 블록체인으로 효율성(Efficiency), 보안성(Security), 그리고 무한한 확장성(Infinite Scalability)을 달성할 수 있도록 설계되었습니다.

NEAR와 관련해 몇 가지 중요한 키워드가 있습니다 :


 	레이어 1 (Layer 1)
 	샤딩 (Sharding)
 	지분증명 (Proof of stake)

 
NEAR에서 애플리케이션을 구축해야 하는 이유는?


 	쉬운 사용성


 	

 	HRA(Human Readable Account) 사용: 복잡한 알파벳, 숫자가 아닌 learn.near, tom.near 와 같이 읽기 쉽고 기억하기 편한 계정명 지원 
 	복잡한 설치가 필요 없는 웹 기반의 지갑 사용




 	

 	Function Call key 등, 여러 키를 사용하여 애플리케이션 권한 부여 가능




 	빠른 속도와 에너지 효율성(친환경)


 	

 	≒ 1초의  거래속도




 	

 	탄소 중립 네트워크 인증 (Carbon-Neutral Network) 




 	

 	비트코인 대비 현저히 낮은 전력 소비량: 비트코인에서 3분간 사용하는 에너지 = NEAR에서 1년  동안 사용하는 에너지




 	개발자 친화적 환경


 	

 	JavaScript와 Rust 등 일반적인 프로그래밍 언어 지원




 	

 	각 애플리케이션 유형에 대한 문서와 다양한 예제 제공




 	

 	개발자에게 거래 수수료 30% 반환




 	

 	8억 달러 규모의 그랜트 프로그램 운영



더 알아보기:
Web3와 NEAR 프로토콜에 대해 이전보다 (조금은) 더 잘 이해하게 되었을 것입니다. 이보다 더욱 블록체인, Web3, NEAR에 대해 깊이 알고 싶으신 분들은 다음 자료를 읽어보시는 것을 추천드립니다:


 	NEAR 프로토콜이란?
 	Web3 및 NEAR 기본 사항
 	Figment Learn Pathway
 	NEAR 101

기타 관련 자료:

 	토큰 이코노미 시리즈 (Token Economic series)
 	비트코인의 역사 (The history of Bitcoin)
 	마스터링 비트코인 (Mastering Bitcoin)
 	이더리움 황서 (Ethereum Yellow Paper)

마스터링 이더리움 (Mastering Ethereum)

### NEAR Certified Developer 소개

시작하기에 앞서
성공적으로 NEAR Certified Developer 프로그램을 이수하기 위해 다음 사항들을 바로 진행해주시기 바랍니다.

1단계:

 	 공식 텔레그램 커뮤니티에 입장하기
– LNC 공식 텔레그램방에 입장하시면 커뮤니티 멤버들로부터 NEAR 관련 팁을 받아보실 수 있습니다.
– LNC 프로필을 LNC 커뮤니티 봇과 연동해주시기 바랍니다.
 	 Learn NEAR 공식 트위터 팔로우하기 https://twitter.com/LearnNear
 	 테스트넷 계정 생성하기  – YourName.testnet – https://wallet.testnet.near.org/
 	 계정 모니터링을 위한 텔레그램 봇 추가하기: 

메인넷:  https://t.me/nearwatchbot

테스트넷:  https://t.me/LNC_testenet_watcher_bot
NEAR Certified Developer
NEAR Certified Developer(NCD)는 웹 개발자들을 위한 스마트 컨트랙트 학습 프로그램으로 NEAR 프로토콜을 활용하여 스마트 컨트랙트를 설계, 개발, 테스트하고 배포하는 방법을 배울 수 있습니다. 모든 과정을 완수하면, NEAR가 인증한 개발자(NCD)임을 나타내는 인증서를 발부해 드립니다. 
Welcome
NEAR의 멤버가 되신 여러분을 환영합니다! 여러분들은 앞으로 NCD 프로그램과 함께 스마트 컨트랙트 플랫폼인 NEAR 프로토콜을 활용하여 탈중앙화 애플리케이션(dApp)을 구축하는 방법을 배우게 될 것입니다.

NCD 프로그램은 (L)Earn 코스의 일환으로, 가이드에 따라 모든 코스를 수행하면 수료증과 함께 수료에 따른 보상을 지급 받을 수 있습니다.

유의사항

전문가 수준까지는 아니더라도 최소한 NodeJS 프로젝트를 클론(Clone)하고, 의존성모듈(Dependencies)을 다운로드하고, 스크립트(script)를 실행할 수 있는 등 기본 소양을 갖추고 있어야만 해당 프로그램을 수강하실 수 있습니다.

 

 	기본 JavaScript 클라이언트 및 서버 측 개발 (참고링크: (1), (2))
 	기본 터미널 컨트롤 (참고링크: (1), (2))
 	기본 Git 커맨드 (참고링크: (1), (2)) 

개요
NEAR Certified Developer 프로그램에서 여러분들은 다음과 같은 주제들을 학습하게 됩니다:


 	인류 역사의 맥락에서 Web 3.0 이해하기
 	Rust와 JavaScript에서 컨트랙트 코드 읽기
 	Rust와 JavaScript를 사용하여 컨트랙트 작성하기
 	단위 테스트와 시뮬레이션을 통해 컨트랙트 테스트하기
 	컨트랙트와 합리적인 사용자 인터페이스(UI) 배포하기

NCD 프로그램을 성공적으로 이수하기 위해 하루 2시간 이상 참여를 권장 드립니다. 웹 개발 경력이 3년 미만인 개발자의 경우 이수를 위해 일 4-6 시간이 소요될 수 있으니 이점 참고 부탁드립니다.
문의사항
궁금하신 내용은 LNC 공식 텔레그램 방 Tech Discussion에 질문하시면 됩니다. 해당 커뮤니티 멤버들로부터 NEAR와 관련한 팁을 포함해 다양한 도움을 받아보실 수 있습니다. 
과제


 	과제는 StepN 레슨에 첨부되어 있습니다.

다음 단계

 	NEAR Fortified Developer: LNC Barrel의 인큐베이팅을 통해 NEAR 메인넷에 본인의 Web3 애플리케이션을 정식 출시하실 수 있습니다.  

녹화본
공개 가능한 모든 녹화본은 이벤트 후 24~48시간 이내에 아래 YouTube 재생 목록에 게시됩니다.

YouTube 재생 목록 확인하기


                
                        
                            NCD Registration
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Native Language*
			
				
				English
			
			
				
				Chinese
			
			
				
				Russian
			
			
				
				Vietnamese
			
			
				
				Korean
			
			
				
				
			Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account*

### Tips & Best Practices

In this video, we will be discussing tips and best practices in NEAR Rust smart contract development.

We will cover:
- Redundant State assertion
- Missing Zero Value Checks
- .take()
- require!
- Two step ownership process
- Tautological expressions
- JSON types
- Lack of Pausability
- Two factor Authentication

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Tips and Best Practices for NEAR Smart Contract Development and Security
Section Overview: In this video, the speaker provides tips and best practices for NEAR smart contract development and security. The topics covered include state assertions, missing zero value checks, unchecked attached deposit, usage of take, require statements, tautological expressions, and two-step ownership transfer.
State Assertions in Initializers

 	Use init macro instead of state assertions in initializers to prevent anyone from calling initializer again.

Missing Zero Value Checks

 	Always cover cases where we get zero inside arguments or during calculation to avoid crashes or panic. Assert that the value is not zero because operations performed on zero are redundant.

Unchecked Attached Deposit

 	Functions marked as payable can accept the attached deposit since there is no check that prevents it. Always check attach deposit or be sure that we are planning to do something with that money; otherwise, it increases the possibility of someone accidentally sending money to our contract which is not good.

Usage of Take

 	Be careful when using takes on option and lazy option types because it deletes the value and replaces it with none. Prefer using get instead for those types.

Require Statements

 	Use assert or required statements to ensure conditions are met before proceeding with a function call. Required does not include any rust-specific data in the Panic message hence it decreases the decode size and obscures the exact place of error so it might be more useful for us to use in production setting especially if the project is closed Source maybe we want to obscure the exact place of error.

Tautological Expressions

 	Avoid tautological expressions such as checking whether an unsigned integer is less than zero since by definition cannot be less than zero. The only thing we need to check is whether the number does not equal zero.

Two-Step Ownership Transfer

 	Use two-step ownership transfer to ensure that the new owner accepts the transfer before it takes place. This helps prevent accidental transfers and ensures that both parties are aware of the transfer.

Implementing a Two-Step Ownership Process
Section Overview: This section discusses the importance of implementing a two-step ownership process to decrease the possibility of human error.
Two-Step Ownership Process

 	The two-step ownership process involves the owner proposing a new owner through a propose function, and then accepting ownership.
 	It is easy to implement and decreases the possibility of human error.

Implementing Safety Measures in Contracts
Section Overview: This section discusses the lack of guarantee that contracts are safe, secure, and bug-free. It also suggests implementing safety measures in contracts to prevent damage control.
Safety Measures

 	Implement pause functionality in contracts to prevent users from losing money or hackers from exploiting protocols further.
 	Pause functionality can be implemented by having a state variable keeping track of status, creating a function called toggle pause to flip is posed from false to true and vice versa, and asserting whether it's post is false at the beginning of each function gaming encapsulated in a separate function.
 	By implementing safety measures such as pause functionality, we can prevent severe logical mistakes.

Understanding JSON Types
Section Overview: This section explains what JSON types are and why they are important when accepting data from users.
JSON Types

 	Neo has two types: regular types and JSON types.
 	JSON types are usually denoted with a capital U (e.g., U128 for unsigned integer).
 	When we accept data from users, we take data in the JSON serialized format and then deserialize it into regular unsigned integers if we accept unsigned integer.
 	We should use JSON types as types for values which may be larger than the max safe integer (i.e., 2^53 - 1).
 	To prevent logical mistakes, we should input and output data in string format and accept JSON type unsigned integers.
 	By accepting and returning values using JSON types, we can ensure that our value is correct and not getting truncated or causing any weird behavior.

Best Practices for Accepting and Returning Values
Section Overview: This section provides best practices for accepting and returning values to ensure that our value is correct.
Best Practices

 	To be completely safe, we should accept and return values using JSON types.
 	If the value is larger than the max safe integer, it might cause issues in a web app on the front end.
 	During serialization of this value, we get a correct value back because we are serializing it into a JSON type.

### Step



### Logical Issues

In this video, we will be going over logical vulnerabilities in NEAR Rust smart contracts

We will cover:

- Fungible token logical bug
- Storage deposit logical bug

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Introduction
Section Overview: In this video, the speaker will discuss different logical vulnerabilities that can be encountered in a project. They explain that logical vulnerabilities are difficult to support and require a solid understanding of the project.
Understanding Logical Vulnerabilities
Section Overview: The speaker explains that logical vulnerabilities occur when functions are combined in unexpected ways. They suggest zooming out to look at the contract as a whole and building attack scenarios to test the project.

 	Logical vulnerabilities require a solid understanding of the project.
 	Combining functions can lead to unexpected logical vulnerabilities.
 	Building attack scenarios is helpful for testing projects.

Case Study: Custom NEP-141 Token
Section Overview: The speaker discusses an incident where funds were drained from a custom NEP-141 token contract due to a logical vulnerability. They explain how copying code from existing standards and adding tweaks can lead to issues if checks are not added.

 	A hacker drained funds from a custom NEP-141 token contract due to a logical vulnerability.
 	Copying code from existing standards and adding tweaks can lead to issues if checks are not added.
 	Attackers may exploit contracts by using their own account as both sender and receiver during token transfer.
 	The root cause of the issue was not reentrancy, but rather an oversight in checking whether sender and receiver accounts were the same.

Logical Bugs in Smart Contracts
Section Overview: In this section, the speaker discusses two case studies of logical bugs found in smart contracts during audits. The first case study involves a check that should have been implemented to prevent an exploit, while the second case study involves a failure to check whether a specified account was registered or not.
Case Study 1: Preventing Exploits

 	A logical bug was found in a smart contract where the sender and receiver were not checked to ensure they were not the same.
 	This allowed attackers to mint additional tokens by transferring tokens from themselves to their own account.
 	The root cause of the exploit was that there was no check preventing Center from being equal to receiver.
 	The function should have checked whether Center equals receiver and prevented the transfer if they were equal.

Case Study 2: Failure to Check Account Registration

 	Another logical bug was found in a smart contract where storage deposits were allowed without checking whether the specified account was registered or not.
 	Although there was a check, it wasn't done in the right place, allowing anyone to write any user's data.
 	Attackers could override existing users' accounts with super low deposits by exploiting this vulnerability.
 	The issue arose because count ID could be anything and wasn't coming from either caller or predecessor account ID.

### Race Condition

Welcome back to another video in the NEAR Rust Smart Contract Security series. In this video, we'll discuss how Race Condition/Reentrancy in NEAR Smart contracts

Here's what we'll cover:

- What is Race condition in NEAR Smart contracts
- How to avoid it in smart contracts
- How to write integration tests for it
- How we can exploit it using an exploit contract
- How we can exploit it using batch calls

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Introduction to Race Condition Vulnerabilities
Section Overview: In this section, the speaker introduces race condition vulnerabilities in NEAR and explains why they are called "race conditions" instead of "re-entrancy."
What are Race Condition Vulnerabilities?

 	A race condition vulnerability can occur due to a delay between an external call and its callback.
 	During this delay period, anyone can call any function inside the contract, which can lead to unexpected behavior.

Example Scenario

 	The speaker presents an example scenario involving an external swapping contract that swaps NEAR for tokens.
 	A user calls the deposit function with 100 NEAR and then calls the swap function with 100 NEAR to swap for 200 tokens.
 	After a two-block delay, the callback is executed to decrease the user's balance to zero since all their NEAR was spent on swapping.

Exploiting Race Condition Vulnerabilities
Section Overview: In this section, the speaker explains how attackers can exploit race condition vulnerabilities in NEAR contracts.
Exploiting Race Conditions

 	An attacker can call the swap function twice with 100 NEAR each time before the first callback is executed.
 	The external swapping contract will swap 100 NEAR for 200 tokens twice and increase the attacker's balance in the external contract to 400 tokens.
 	When the first callback is executed after a two-block delay, it decreases the attacker's balance by 100 NEAR. However, when the second callback tries to do exactly the same thing, it fails because there is no more balance left to decrease.
 	Since changes were not reverted in the external contract, attackers still have access to their tokens.

Example Code Walkthrough
Section Overview: In this section, we see an example of how race condition vulnerabilities can be exploited in NEAR contracts.
Example Code

 	The speaker presents an example of a victim contract and an exploit contract that can be used to exploit race condition vulnerabilities.
 	The example involves calling the swap function twice with 100 NEAR each time before the first callback is executed, leading to an increase in the attacker's balance in the external contract.

Deposit Contract Overview
Section Overview: This section provides an overview of the deposit contract and its functions.
User Near Map

 	The user near map lets us track ballet internal balances of users.
 	We use a seeking contract address to make an external call.

Deposit Near Function

 	The deposit near function allows users to deposit some near.
 	We assert that attached deposit is bigger than or equal to one year.
 	If it's the first time a user tries to deposit something, we directly insert it inside of the map.
 	If a user already had some money, we add it on top.

Staking Function

 	We stake some near for certain validators that users pass.
 	Here we get just the new deposit and ensure that the user exists and checks that amount is lower or equal to the near deposit so that users do not try to play the system.
 	Then we call an external sticking contract to do that.

View Functions

 	We have view functions such as view near deposits and withdrawal near here if a user wants to withdraw without staking.

Staking Contract Overview
Section Overview: This section provides an overview of the staking contract and its functions.
Allow List & Staking Map

 	We have an allow list only letting deposit contract calls take place so that users cannot just call stake as they lack in this contract.
 	We also have a staking map keeping track of users' balances so that we can keep track of how much each validator has been staked by each user.

Taking Function

 	The taking function gets caller, checks allow list ensuring only deposit contracts can call it.
 	If it's the first time a user stakes, we directly insert it into a mapping.
 	If it wasn't the first time, we add on top.

Withdrawal Stake Function

 	The withdrawal stake function lets users withdraw stake from a validator.
 	We ensure that the amount that the user chooses to withdraw is not zero and check that the beneficiary's stake is bigger or equal to the amount so that users cannot play the system.

View Stake Function

 	We have a view stake function to view current stake over a user.

Exploitable Contracts Overview
Section Overview: This section provides an overview of exploitable contracts and how they can be exploited.
Vulnerable Contract Trading

 	In this contract, we have just vulnerable contract rate trading here we have stake so its state comes from deposit from here and then we just initialize defaults.

Exploit Function

 	Here we are exploiting everything.

### Denial of Service

In this video, we will be going over Denial of Service (DoS) issues in NEAR Rust Smart Contracts

Here's what we will cover:

We will cover:
- Unverified Acount/Logical DoS
- Log Bombing
- Storage Bloating
- Prepaid Gas Exceeding

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Denial of Service
Section Overview: In this section, the speaker explains how smart contracts can be exploited to cause denial of service. Logical vulnerabilities such as prepaid gas exceeding log event Bombay and unverified accounts are discussed.
Unverified Accounts

 	Unverified accounts can cause panic and lead to denial of service.
 	It is advised to use account ID type when accepting accounts.
 	Using version 4.00 will automatically enforce validity.

Upchain Registry Case Study

 	Octopus Network's upchain registry had a logical denial of service due to how they handled accounts.
 	App chain teams submit metadata for verification and voting.
 	Octopus Network team did not verify the validity of options, causing critical functionality to stop working.

Conclusion

 	The whole or parts of the protocol stop functioning during a denial of service attack.
 	Logical vulnerabilities such as prepaid gas exceeding log event Bombay and unverified accounts can cause denial of service.

Root Cause of the Issue
Section Overview: The root cause of the issue was due to the lack of validation for option ID, which caused panic and made it impossible to conclude what's happening.
Validation for Option ID

 	Lack of validation for option ID caused panic and made it impossible to conclude what's happening.
 	Adding validation to option ID will prevent it from becoming top chain ID in queue.

Storage Bloating
Section Overview: Storage is not free in Near, so we have to pay for storage. If cost per storage right is more expensive than smart contract gain per storage right, then it opens up a possibility for malicious actors to block the storage with dummy data and cause service costs.
Vulnerability Calculation

 	Cost per storage right in Near is 30 per right divided by 100000.
 	We always have to keep track of our free balance and charge users a basic amount of storage deposit.
 	To understand whether a certain function is vulnerable, we have to do some calculations.
 	If contract gain is smaller than cost per storage right in Near, then the function is vulnerable.

Attack Cost Estimation

 	We can estimate the cost or an attack on a vulnerable function by calculating initial storage costs as starting point.
 	We calculate current storage and divide it by storage written every time attacker called this function.
 	At the end, we multiply number of rights by attacker spent per right to get an idea how much overall money attack has to spend.

### Access Control

In this video, we will be discussing access control issues in Near smart contracts, such as missing access control, incorrect near_bindgen usage, signer_account_id usage, public callbacks, and lack of separation of privileges.

Here's what we will cover:

Missing access control:
If you forget to put the onlyOwner modifier in a function, anyone can access it on-chain. We should always have ownership checks on important functions to prevent denial of service attacks.

Incorrect near_bindgen usage:
Near_bindgen is a macro that generates necessary code to be a valid Near contract and exposes intended functions to be callable on-chain. If we don't know what it does behind the scenes, it might introduce some risky issues for us. For instance, if we put near_bindgen on the implementation of a trait for the current contract, every function inside of that trait implementation will be public.

Signer_account_id usage:
Signer_account_id is different from predecessor account_id. Predecessor is the direct caller of the contract, while signer is the signer of the transaction. Using signer_account_id in access control, especially on important functions, can lead to phishing attacks, where malicious actors trick users into signing transactions that transfer funds to them.

Public callbacks:
Callbacks should be accessible on-chain, but if we don't put any access control on them, they can be exploited. We should ensure that the caller of a callback is the contract itself.

Lack of separation of privileges:
Having one private key rule the whole protocol is bad for decentralization purposes and risk management. To prevent centralization of privileges and minimize risk, each protocol should consider implementing role-based access control with different participants for each role.

By the end of this video, you'll have a better understanding of access control issues in Near smart contracts and how to prevent them. So, let's dive in!

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Introduction
Section Overview: The speaker introduces the topic of smart contract security and mentions that this section will focus on access control issues and incorrect usage of near banking.
Missing Access Control

 	If only modifier is forgotten, anyone can access the function.
 	Ownership checks should be added to important functions to ensure only the owner can access them.

Incorrect Near Banking Usage

 	Near banking macro generates necessary code for a valid near contract and exposes intended functions to be callable on chain.
 	Putting nearby gun on implementation of a trade for current contract makes every function inside of that trade implementation public.
 	Always be aware where we should be putting new Bangin in our contracts or at least if we not sure just do cargo expand and explore the code just in case.

Usage of Signer Account ID

 	Predecessor is the direct caller of the contract while signer account ID is the signer of the transaction.
 	If signer account ID is used, whoever called contract A is going to be basically a signer of the whole transaction.

Malicious Actors and Phishing Attacks
Section Overview: This section discusses how a malicious actor can use phishing attacks to exploit a user's account ID and transfer funds from a victim contract to their own account.
Exploiting User Account IDs

 	A malicious actor can create a phishing web page to trick the user into signing cross-chain transactions.
 	The user may not realize that the contract they are signing actually calls another contract that tries to do bad things on the victim contract.
 	If the signer account ID is used, then during ownership checks, it will appear as if the user initiated the cross-contract call.
 	To prevent this, users should be careful not to use cyber accountability in their applications, especially on important functions.

Public Callbacks and Access Control
Section Overview: This section explains how public callbacks can lead to exploitation of contracts and how access control can prevent this.
Preventing Exploitation of Contracts

 	Public callbacks should be accessible on chain but must have access control implemented.
 	If no access control is put in place, anyone can call these functions directly, leading to exploitation of contracts.
 	To ensure that only the contract itself calls a callback function, we can use private modifiers or search for current accountability with predecessor account ID.
 	Private modifiers should be added to all callbacks.

Lack of Separation of Privileges
Section Overview: This section discusses why lack of separation of privileges is bad for centralization purposes and risk management.
Risks Associated with Lack of Separation of Privileges

 	If one private key rules an entire protocol, then losing or leaking that key could compromise the entire protocol.
 	To prevent centralization and minimize risk, each protocol should implement role-based access control with different participants for each role.
 	Each role must also be governed by multi-sig with different participants set for each role.
 	Ideally, a protocol should have a role governed by DAO responsible for crucial operations.

Conclusion
This transcript discusses the risks associated with phishing attacks, public callbacks, and lack of separation of privileges in smart contracts. It emphasizes the importance of access control and implementing role-based access control to minimize risk and prevent centralization.

### Step



### Crates With Known Vulnerabilities

Welcome back to the NEAR Rust Smart Contract Security course. In this video, we'll cover two important topics:

1. Crates with known vulnerabilities and how to mitigate them
2. Handy rust tools

Dependency management and monitoring is critical in ensuring the security of your Rust projects. In this video, we'll discuss the Rust Advisory database and the cargo audit tool. We'll show you how to traverse your project's dependency tree to identify any vulnerable crates and discuss best practices for managing these vulnerabilities. We'll also touch on Rust tools like Rust Miri Interpreter, Cargo Geiger, Cargo Tarpaulin, and more that can help you detect and prevent issues like memory leaks and unsafe code.

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Introduction to Cargo Audit
Section Overview: In this section, the speaker introduces the importance of dependency management and monitoring in Rust projects. They explain that just like in JavaScript, where we scan for vulnerabilities in our packages, we should do the same thing in Rust. The speaker then introduces cargo audit as a tool for traversing dependency trees to find any vulnerable crates.
Why Use Cargo Audit?

 	Dependency management and monitoring is important in Rust projects.
 	Cargo audit can be used to traverse dependency trees and find vulnerable crates.
 	Cargo audit reports vulnerabilities found and provides solutions for upgrading to higher versions.

Integrating Cargo Audit into CI/CD Pipelines

 	It is recommended to integrate cargo audit into CI/CD pipelines.
 	Upgrading all dependencies may not always be necessary or feasible, especially if it comes inside of core crates used to build applications.

Rust Tools for Dependency Management
Section Overview: In this section, the speaker briefly introduces some handy rust tools for dependency management.
Handy Rust Tools

 	Rust advisory database publishes all publicly known vulnerabilities inside of rust crate.
 	Other tools include:

 	cargo-audit
 	rust-miri interpreter
 	cargo geiger
 	cardboard tarpaulin
 	rust analyzer
 	cargo fast-hack
 	memory leak detection tools



Understanding Macros

 	It's a good idea to expand your macros at least know how they were built and what they actually produced back.

Conclusion
The speaker recommends using cargo audit by default every time you build or integrating it into CI/CD pipelines. They also suggest going deeper inside which crates we use and whether it's actually exploitable. Finally, the speaker mentions that they plan to release a separate course covering some fuzzing and other cool stuff.

### Stack Overflow/OOM/Index OOB

Welcome back to another video in the NEAR Rust Smart Contract Security series. In this video, we'll discuss how to handle Stack Overflow, Index Out of Bounds, and Out of Memory issues in Rust.

Here's what we'll cover:

- What is Index Out of Bounds and how it affects Rust programs
- How to prevent Index Out of Bounds using the get() method
- What is Stack Overflow and how it impacts Rust programs
- How to prevent Stack Overflow by avoiding recursive functions and other best practices
- What is Out of Memory issue and how to avoid it
- How to handle Out of Memory issues by carefully managing unbounded data types and input from users

Index Out of Bounds is a common issue in Rust programming where we try to access an element inside a Vector or Array via an index that is larger than the length of the data structure. In this video, we'll discuss how to handle this issue and avoid program crashes using the get() method.

Stack Overflow can be a serious issue that can lead to program crashes and other issues. We'll discuss the causes of Stack Overflow and the best practices to prevent it, including avoiding recursive functions.

Out of Memory issues can be another major problem in Rust programs, which can occur when unbounded data types are used or when input from users is not properly managed. We'll discuss the best practices to avoid Out of Memory issues, including managing input from users and carefully managing data types.

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Rust: Handling Index Out of Bounds, Stack Overflow, and Out of Memory Issues
Section Overview: In this video, the presenter discusses how to handle index out of bounds, stack overflow, and out of memory issues in Rust. They explain what causes these issues and provide examples of how to handle them gracefully.
Index Out of Bounds Issue

 	Accessing an element inside a vector or array with an index larger than the array length -1 or vector length minus one will result in a panic.
 	To handle these errors gracefully, use get() which returns an option type with None if there is an index out of bounds issue.

Stack Overflow

 	Occurs when we exhaust memory on the call stack available to us.
 	Recursive functions are main candidates for causing stack overflow.
 	Example using factorial calculation function that can lead to stack overflow if inputting a super large value.

Out of Memory Issues

 	Occurs when unbounded data types such as arrays or vectors are used without checking buffer length.
 	Always be careful when getting data from users to ensure they cannot fill all vectors to cause out-of-memory issues.
 	Example using pushing a letter repeated u-size Max times into a vector that exceeds available memory.

Code Examples
Section Overview: The presenter provides code examples demonstrating how to handle index out of bounds, stack overflow, and out-of-memory issues in Rust.
Handling Index Out Of Bounds Issue

 	Vector example where accessing an element under the index 9 results in panic.
 	Using get() method instead handles errors gracefully.

Handling Out Of Memory Issues

 	Example using a vector of strings where pushing a letter repeated u-size Max times exceeds available memory and causes a crash.

Handling Stack Overflow

 	Example using factorial calculation function that can lead to stack overflow if inputting a super large value.

Lecture Summary
Section Overview: In this lecture, the program crashes due to a fatal runtime error stack overflow.
Program Crash

 	The program crashes due to a fatal runtime error stack overflow.
 	A board back is received, indicating that the program crashed without any unwinding.

That's all for this lecture.

### Floating Point Issues

Welcome back. In this video on Rust NEAR smart contract security, we'll dive into the floating point issues in Rust.

We'll cover:

- The different rounding methods available in Rust and why it's crucial to specify the rounding direction to avoid logical or calculation mistakes.
- The real-world scenario where rounding issues could have allowed malicious actors to steal funds from Solana projects, and how this issue was discovered and prevented.
- The impact of dividing before multiplying in Rust and the precision loss or incorrect value that can result from this action.
- Different examples and scenarios where division before multiplication can result in incorrect values.
- Best practices for preventing floating point issues in Rust smart contracts to ensure the security and integrity of your code.

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Plotting Point Issues in Rust
Section Overview: In this section, we learn about plotting point issues in Rust. We discuss why it is important to specify rounding direction and not divide before multiplication.
Rounding Direction

 	There are several ways to round floating points, including round, seal, and floor.
 	It is crucial to specify rounding direction to avoid calculation mistakes.
 	A real-world scenario in SPL ending contract in Solana could have allowed malicious actors to steal funds for many projects due to unspecified rounding directions.
 	To avoid such scenarios, always be careful about specifying the rounding direction.

Division Before Multiplication

 	If we try to divide before multiplying, we may have precision loss or even total incorrect value returned.
 	Depending on whether we use floating-point numbers or non-floating-point numbers or convert them at the end, there can be different outcomes.
 	When operating with non-floating-point numbers upon division, we get the floored value.
 	In all cases discussed here, it is better to multiply first and then divide by B.

Code Example
Section Overview: In this section, we see a code example that emulates all of the scenarios discussed earlier.
Code Example

 	The code example demonstrates all of the scenarios discussed earlier using functions that emulate each case.

 	Divide before multiplying with non-floating-point numbers
 	Multiply first and then divide by B with non-floating-point numbers
 	Divide first with floating-point numbers
 	Multiply first and then divide by B with floating-point numbers
 	Convert everything at the end from floating point number to unsigned integer



Note: The speaker made a mistake while presenting one of the examples but corrected it later.
Rounding and Division
Section Overview: This section covers the use of rounding functions in Rust, including Round, Seal, and Floor. It also discusses the importance of correctly ordering multiplication and division operations.
Rounding Functions

 	Round rounds to the nearest integer.
 	Seal rounds up to the nearest integer.
 	Floor rounds down to the nearest integer.
 	Use Floor instead of Seal or Round if you don't want to give users additional money.

Multiplication and Division Order
 

 	Incorrectly dividing before multiplying can lead to incorrect results.
 	Always multiply before dividing for correct results.

Examples
 

 	When operating with unsigned integers, values may be rounded incorrectly.
 	Operating in floating number space is necessary for accurate calculations.
 	Converting values to signed integers at the end of a calculation can result in incorrect rounding.

Conclusion
This section covered how to properly round numbers using Rust's built-in functions, as well as the importance of correctly ordering multiplication and division operations.

### Casting Overflow

In this video, we'll explore the techniques and best practices for preventing casting overflows and division by zero in Rust, tailored to both developers and security auditors.

We'll cover:

- What is casting overflow and why it matters for smart contract security
- How to prevent silent casting overflow using the "as" keyword
- How to prevent panicking casting overflow using custom casting methods
- What is division by zero and how it can impact smart contract security
- How to prevent division by zero by ensuring the denominator is never zero

Casting overflow can lead to major logical errors and calculation mistakes in your smart contracts, which can have severe security implications. Division by zero can also cause your smart contract to break, making it vulnerable to potential attacks. By following the techniques and best practices covered in this video, you can ensure the security and integrity of your Rust smart contracts.

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Casting Overflows and Division by Zero in Rust
Section Overview: This video discusses casting overflows and division by zero in Rust. It explains what happens when casting is attempted from a larger type to a smaller type, the two types of casting overflow (silent and panicking), and how to prevent division by zero.
Casting Overflow

 	Casting overflow occurs when casting is attempted from a larger type that holds a value greater than the maximum value of the smaller type.
 	Silent casting overflow occurs when using the as keyword, causing no panic but wrapping around the type, which can cause logical errors or calculation mistakes.
 	Panicking casting overflow occurs when using custom casting methods on types, resulting in panic instead of wrapping around the type.
 	Use primitive types crate for custom types such as u128, 256, and 512.

Division by Zero

 	To prevent division by zero, ensure that denominator is always not zero before performing a division operation.
 	Attempting to divide any number by zero will result in panic.

Overall this video provides an overview of how to handle casting overflows and division by zero in Rust.

### Integer Overflow

In Rust, integer overflows and underflows can occur when a calculation produces a result that is too large or small to be stored in the data type, leading to severe logical errors in the program. As a developer or security auditor, it's essential to understand these issues and how to prevent them in Rust programs.

In this video, we'll explore the techniques and best practices for preventing integer overflows and underflows in Rust, tailored to both developers and security auditors.

We'll cover:

- What are integer overflows and underflows and how they occur in Rust programs
- How integer overflows and underflows can lead to security vulnerabilities and how to identify them in code during security audits
- How to enable overflow checks in cargo.toml to catch integer overflows
- The use of checked math functions like checked_add, checked_sub, checked_mul, and checked_div to prevent overflows and underflows.
- The use of saturating math functions like saturating_add, saturating_sub, saturating_mul, and saturating_div to prevent overflows and underflows
- Examples of how to use these techniques in Rust programs to prevent integer overflows and underflows, including how to handle the option type returned by checked math functions and how to use saturating math functions to gracefully handle overflows and underflows

By the end of this video, you'll have a solid understanding of integer overflows and underflows in Rust and be equipped with the knowledge to prevent them using a variety of techniques and best practices, whether you're a developer or security auditor. You'll also be able to identify and prevent security vulnerabilities related to integer overflows and underflows in Rust programs, making your code more secure and reliable.

Code and slide deck :

https://github.com/timurguvenkaya/near-sc-security-course
Integer Overflows and Underflows in Rust
Section Overview: This video discusses integer overflows and underflows in Rust, their consequences, and how to prevent them using various techniques.
Consequences of Integer Overflows and Underflows

 	An integer overflow or underflow occurs when a calculation produces a result that is too large or small to be stored in the data type.
 	This can lead to severe logical errors in the program.
 	Rust catches integer overflows during runtime if a program is compiled in debug mode. In release mode, however, overflows are silenced unless overflow checks are enabled.

Preventing Integer Overflows and Underflows
Overflow Checks

 	To enable overflow checks, set overflow-checks = true in cargo.toml.
 	When an overflow occurs with overflow checks enabled, Rust throws a panic instead of letting an incorrect value being used within the program.

Checkmates

 	Checkmates returns an option type instead of returning the value itself.
 	If we receive none means that we got an integer overflow or underflow.
 	We can gracefully handle that case if we got none back instead of having a plus b.

Saturating Maths

 	Saturating maths returns the numerical bounds if we get an overflow or underflow.
 	In addition multiplication if the type is u8 upon or flow we get 255 which is u8 Max and in subtraction division in case of underflow we get u in eight mid which is zero.

Examples
Example 1: Underflow Function
 

 	The function subtracts B from A where A is taken as input from the user and B is supplied as 6.
 	When compiled without any overflow checks, it will return -1 but since it's using unsigned integers it will wrap around to 255 (u8 max).

Example 2: Overflow and Underflow Prevention Techniques
 

 	Two functions are used to demonstrate the use of overflow and underflow prevention techniques.
 	The first function uses checkmates to subtract B from A, while the second function uses saturating maths to add B to A.
 	When an overflow or underflow occurs, we receive none back, which can be gracefully handled.

Overflow Prevention Example
Section Overview: In this section, we learn about overflow prevention in Rust. We have two functions: one that subtracts and checks for underflow, and another that adds using saturating math.
Functions

 	The first function subtracts B from A and checks for underflow.
 	The second function adds A to B using saturating math.

Examples

 	We subtract 6 from 5, which results in an underflow. We check if the value is none and print a message if it is.
 	We add 250 to 10, which results in an overflow. Since we are using saturating math, we get the maximum value that the type can hold (255).

Conclusion
Section Overview: This video covered overflow prevention in Rust through examples of subtraction with underflow checking and addition with saturating math.
Key Takeaways

 	Rust provides built-in support for preventing overflows.
 	Saturating math returns the maximum value that the type can hold when an overflow occurs.
 	Underflow checking ensures that values do not go below their minimum limit.

### Unrecoverable Errors

In Rust, errors can be handled through two types of errors: recoverable and unrecoverable. Unrecoverable errors occur when something goes wrong in the program that cannot be handled gracefully, and the program must terminate.

In this video, we'll take a deep dive into unrecoverable errors in Rust and explore the use of the unwrap and expect macros, as well as the panic! and assert! macros for handling these types of errors.

We'll cover:

- What are unrecoverable errors in Rust and how they differ from recoverable errors
- How to use the unwrap to unwrap an Option or Result value, and what happens if the value is None or an Err
- How to use the expect to provide a custom error message when using unwrap
- Different panicking macros

By the end of this video, you'll have a solid understanding of unrecoverable errors in Rust and be equipped with the knowledge to handle them in your own Rust programs and spot them during auditing

Code and slide deck:

https://github.com/timurguvenkaya/near-sc-security-course
Unwrap, Expect and Panicking Macros
In this video, the presenter discusses how to use unwrap and expect to get values back from option and result types. They also cover panicking macros such as panic, unreachable, unimplemented, todo, assert, assert equal and assert not equal.
Using Unwrap and Expect

 	unwrap is used to unwrap option and result types to get values back. However, an unwrap will throw a panic if it gets None back from the option type or error from the result type.
 	expect works in exactly the same way as unwrap, but we can also pass a custom panic message.
 	Both unwrap and expect are great when used in tests or when we are confident that we won't get None or Error back.

Panicking Macros

 	Panicking macros are macros which throw panic. There are several of them such as panic, unreachable, unimplemented, todo, assert, assert equal, assert not equal and their debug variants.
 	We should always be aware which macros cause panic to either avoid them altogether in production or implement some safeguards so that they won't cause severe issues.
 	Leaving todo macro in production code might lead to some malicious actors abusing it if they find the path to the place where todo macro is used.
 	The presenter provides an example where different panicking macros are reached depending on user input.

Code Examples

 	The presenter provides a simple example of using unwrap and expect with file open.
 	The presenter provides an example of using different panicking macros depending on user input.

Overall, the video provides a good overview of how to use unwrap and expect with option and result types, as well as an introduction to panicking macros. The code examples provided help illustrate these concepts in practice.

### Recoverable Errors

In Rust, errors are handled through two types of errors: recoverable and unrecoverable.
While unrecoverable errors are usually the result of a bug in the program and cause the program to panic, recoverable errors allow the program to gracefully handle the error and continue executing.

In this video, we'll dive into recoverable errors in Rust and learn how to use the Result type to handle errors in a safe and efficient way.

We'll cover:
- What are recoverable errors in Rust and how they differ from unrecoverable errors
- The Result type and how it is used to handle recoverable errors
- How to use the match expression to handle different types of errors
- The ? operator and how it can simplify error handling code.

By the end of this video, you'll have a solid understanding of recoverable errors in Rust and be equipped with the knowledge to handle them in your own Rust programs.

Code and slide deck : https://github.com/timurguvenkaya/near-sc-security-course
Introduction to Error Handling in Rust
Section Overview: In this section, the instructor introduces error handling in Rust and explains the differences between recoverable and unrecoverable errors.
Recoverable vs Unrecoverable Errors

 	Recoverable errors can be handled in some way, allowing the program to continue execution.
 	Unrecoverable errors are those that the program cannot handle or recover from, and they will cause the program to terminate.

Risks of Panics

 	Panics are also known as unrecoverable errors and can lead to data loss or corruption.
 	Panics can cause a whole program crash, which can lead to denial of service.

Importance of Handling Errors

 	It's important to avoid panic whenever possible and handle recoverable errors in a controlled and predictable way.

Example of Recoverable Error Handling
Section Overview: In this section, the instructor provides an example of how to handle a recoverable error using Rust's match keyword.
Example Code for Recoverable Error Handling

 	Use match keyword to match on both error and success cases when handling a recoverable error.
 	Use question mark operator inside the main function to propagate the error outside.

More Examples of Error Handling in Rust
Section Overview: In this section, the instructor provides additional examples of how to handle errors using Rust's match keyword and question mark operator.
Example Code for Using Match Keyword

 	Use match keyword with result type when opening a file.


 	Return file metadata if everything is all right, otherwise print an error message and exit the process.

Example Code for Using Question Mark Operator

 	Use question mark operator to propagate errors outside of a function.
 	Print built-in error message if file cannot be opened.

Conclusion
Section Overview: In this section, the instructor concludes the video by summarizing the key points covered in this section.

 	Error handling is an important aspect of programming in Rust.
 	Recoverable errors can be handled using Rust's match keyword or question mark operator.
 	Unrecoverable errors, or panics, should be avoided whenever possible.
 	Handling errors in a controlled and predictable way is crucial for ensuring program stability.

### Examples

Some Examples built on top of mintbase.js

















simple-marketplace
















A Simple Marketplace where you can list NFTS, filter by store, and buy NFTS that are available built with Next.js + mintbase.js + Apollo Github Docs: https://github.com/Mintbase/examples/tree/main/simple-marketplace Live Demo: https://examples-simple-marketplace.vercel.app/​



















































simple-minter
















A Simple Minter example, where you can mint NFTS to your store. built with Next.js + mintbase.js + Apollo Github Docs: https://github.com/Mintbase/examples/tree/main/simple-minter​
















Live Demo: https://examples-simple-minter.vercel.app/​

### Build Ideas

Not sure what to build? Start here!

















Integrations 















 	



Integrate Mintbase NFTs with other web2 platforms like canva, figma, shopify















 	



Integrate Mintbase NFTs with existing NEAR dapps like astro or roketo, or your own


















Apps 















 	



Social (e.g. minsta, mint your photo and the last photographer becomes the owner of the new mints) 















 	



Unlockables / Gated Content (e.g. a stock app where only license holders can download assets)















 	



Create your own minter, market, or redeeming systems that do something unique















 	



Utilize the NEARCON tickets within your app















 	



News (utilize permanent web storage for podcasts, video, and news feeds)















 	



Voting or polling app open to or weighted based on NFT holdings















 	



Market that only pulls in select stores, gateway for niche markets, example: Only Mintbase stores that are in the Berlin nightclub scene.















 	



Build your own auction site















 	



Build a music streaming app, only import NFTs with with the metata/animation_type = “audio/mpeg”















 	



Build a 3d gaming asset app, only import NFTs with with the metata/animation_type = “model/gltf-binary”















 	



Enable private sales. Let's say you want to sell a ticket with a discounted price to a friend.


















Wildcard















 	



Trigger mintbase js calls from iOT device, maybe bring your DJI drone in? 















 	



Zero knowledge research and implementation















 	



Identity solutions, not soulbound tokens, we love the transfer function, but validating initial issuance through provenance and KYC leveling for accounts would be fun to dive into. 















 	



Up to you, go nuts…


















Research
















We need zero knowledge for NFTs on NEAR. Eventually even perceptions should be NFTs where the redeemer should not have to expose their identity to claim.

### Store management

Managing minters






















// change methods
function batch_change_minters(grant: Array<string>, revoke: Array<string>);

// view methods
function check_is_minter(account_id: string): boolean;
function list_minters(): Array<string>;





















While batch_change_minters allows you to grant and/or revoke minting rights of multiple accounts at the same time (requiring the usual yoctoNEAR authentication), check_is_minter allows you to check if a specific NEAR account is a minter on the NFT contract, while list_minters returns a list of currently allowed minters. The owner of a store cannot be revoked from minting.
















Transferring ownership of your store




















function transfer_store_ownership(new_owner: string, keep_old_minters: boolean);




















If you decide you want to get rid of your NFT contract, e.g. to benefit a friend or to transfer it to a DAO, use transfer_store_ownership. The new owner will be added to the minters, and minter retention may be toggled with keep_old_minters.
















To prevent fraud and people loosing NFTs they purchased, the deletion of a store is not possible!

### Minting and burning

Minting
















To mint tokens, you can use the nft_batch_mint method:























function nft_batch_mint(
  owner_id: string,
 metadata: TokenMetadata,
 num_to_mint: number,
 royalty_args: RoyaltyArgs | null,
 split_owners: PayoutsMap | null
);

type PayoutsMap = Record<string, number>;
type RoyaltyArgs = {
 split_between: PayoutsMap;
 percentage: number;
};



















 	



To learn more about TokenMetadata, refer to the corresponding standard​















 	



Due to gas limitations, you cannot mint more than 125 tokens at once.















 	



The PayoutsMap maps from NEAR account IDs to percentages, where each percentage is expressed as an integer between 0 and 10000 (inclusive), where 10000 is equivalent to 100%















 	



As with the PaymoutsMap, the percentage in RoyaltyArgs is expressed as a number between 0 and 10000















 	



Any allowed minter can call this, once they have verified their identity by attaching at least one yoctoNEAR to this method call. You may wish to attach more to cover required storage deposits, as minting increases storage requirements for the contract. The method will not check if sufficient deposits have been made, and it is the responsibility of the store owner and minters to keep their smart contracts sufficiently funded!


















Burning
















To burn tokens, you can use the nft_batch_burn method:





















function nft_batch_burn(token_ids: Array<string>);





















This will remove the token from the on-chain storage! This means you can no longer use methos such as nft_token with this token ID, but storage requirements are being decreased by burning. To verify your identity, you are required to attach one yoctoNEAR to the method call.

### Batched methods

Batch transfers
















To simplify sending lots of tokens to different people, e.g. to do airdrops, we define nft_batch_transfer:




















function nft_batch_transfer(token_ids: Array<[string, string]>);




















The first string is the token ID (must always parse to a u64), and then second string must be a valid NEAR account. This is not currently hardcapped, but will fail if you run out of gas while doing so. As with nft_transfer, you will need to deposit one yoctoNEAR to prove your identity to the contract.

















Batch approvals
















To simply listing lots of tokens on a market (or any other usecase you may come up with), we define nft_batch_approve:



















function nft_batch_approve(
 token_ids: Array<string>,
 account_id: string,
 msg: string | null
);



















As with nft_approve, you will need to deposit one yoctoNEAR to prove your identity to the contract.

### Standards

Mintbase follows the NEAR Non-fungible token standards:


















 	NEP-171: Core Functionality
 	NEP-177: Metadata
 	NEP-178: Approval Management
 	NEP-181: Enumeration
 	NEP-199: Royalties and Payouts\
 	Events (v1.0.0)


















See more: https://nomicon.io/Standards/Tokens/NonFungibleToken/






Coming from Ethereum




A comparison on NEP-171 and ERC-721

















NEP-171 Token Standard
















This is the non-fungible token standard on NEAR. It was carefully designed with input from several experienced developers and creators, and includes native support for royalty payments.
















Introduction




















In the three years since ERC-721 was ratified by the Ethereum community, Non-Fungible Tokens have proven themselves as an incredible new opportunity across a wide array of disciplines: collectibles, art, gaming, finance, virtual reality, real estate, and more.








​








This standard builds off the lessons learned in this early experimentation, and pushes the possibilities further by harnessing unique attributes of the NEAR blockchain:







 	



an asynchronous, sharded runtime, meaning that two contracts can be executed at the same time in different shards









 	



a storage staking model that separates gas fees from the storage demands of the network, enabling greater on-chain storage (see Metadata extension) and ultra-low transaction fees










Read more https://nomicon.io/Standards/Tokens/NonFungibleToken/Core#motivation​



















The NEP-171 is about the equivalent of the ERC721. It's just a guideline to enabling other platforms to interoperate with assets, giving them confidence the nft_transfer and ownerhip verification.
















Anytime you see the nft_ in front of a function, this is help indexer identify what's going on. In Ethereum land, every contract indexes on its own chaos.



















Core Functionality | NEAR Protocol Specification



















Royalties
















We took it a step further and added a payouts system which gives marketplaces less excuses by giving the, easy access to royalty expectations.


Royalties and Payouts

### Marketplace 2.0

Mintbase is introducing a new marketplace contract that enables arbitrary accounts to collect the market fee when a token is sold with a registered referral id.

















Affiliate Program
















No need to build an indexer or deploy market contracts, just focus on your market ui.



















































List a token
















Listing a token to the marketplace requires two function calls. The first to reserve storage in the contract for the listing and other to authorize the marketplace to transfer the token once sold.
















Storage deposit
















The new market requires a 0.01N storage deposit per listing. This amount is transferred back when the token is sold or it's unlisted from the marketplace.















 	



Method: deposit_storage















 	



Receiver Id: the market contract address















 	



Arguments: none















 	



Deposit: 0.01N















 	



Gas: 200 TGas






















near call <market-contract> deposit_storage '{}' --deposit 0.01 --accountId <your-account>h





















Authorize the market















 	



Method: nft_approve















 	



Receiver Id: the token contract address















 	



Arguments: 




- account_id: the market contract address



- token_id: the token id


- msg: a stringified object that contains price expressed in yoctoNEAR


e.g "{"price":"500000000000000000000000"}"














 	



Deposit: 1 yoctoNEAR















 	



Gas: 200 TGas






















near call <nft-contract> nft_approve '{"account_id": <market-contract>, "token_id": <token-id>, "msg": "{\"price\":\"<amount-yocto>\"}"}' --depositYocto 1 --accountId <your-account>




















Buy a token
















Once an account is registered for collecting fees (see above) it can start collecting market fees for being a referral.
















Buy















 	



Method: buy















 	



Receiver Id: the market address















 	



Arguments: 




- nft_contract_id: the token contract address





- token_id: the token id





- referrer_id (optional): the account address that will collect the market fee


⚠️ Note that the referrer_id has to be registered first by Mintbase (see above




- Deposit: the token listing price




- Gas: 200 TGas








































near call <market-contract> buy '{"nft_contract_id": <nft-contract>, "token_id": <token-id>, "referrer_id": <referrer-id>}' --depositYocto <price-yocto> --accountId <your-account>

### Core Addresses

Source code for all Mintbase contracts can be found in this GitHub repository (https://github.com/Mintbase/mintbase-core)
















Mainnet Deployments


























Type



Address










Factory









mintbase1.near











​Marketplace 2.0​









simple.market.mintbase1.near











Original Marketplace (Deprecating)









market.mintbase1.near











Stores









*.mintbase1.near, excluding market




























Testnet Deployments


























Type



Address










Factory









mintspace2.testnet











​Marketplace 2.0​









market-v2-beta.mintspace2.testnet











Original Marketplace (Deprecating)









market.mintspace2.testnet











Stores









*.mintspace2.testnet, excluding market

### NEAR CLI

Install NEAR CLI (https://github.com/near/near-cli)


















npm install -g near-cli
Fetch token data from CLI



























near view dip3.mintspace2.testnet nft_tokens '{"from_index": "0", "limit": 10}'




















Get the NFTs owned by account



















near view dip3.mintspace2.testnet nft_tokens_for_owner '{"account_id":"testbase.testnet"




Batch Transactions








Install Loop













Install something like loop so you can run on transaction and that can keep running behind the scenes while you make a sandwich.
https://github.com/Miserlou/Loop















Using the NEAR CLI




















NEAR CLI | NEAR Documentation
















Log into the account that has the permission needed to execute what you need




















near login




















Find the Transaction Data Needed














1. Go on the mintbase UI and find a transaction you want to loop through, let's do Multiply
































































2. Initiate the transaction, but click "More Information" on the Approve Page.
















​





















































3. Then click the function name `nft_batch_mint` to reveal the code





















































Run a Loop on the Command line














1. Create a local file called mass_mint










2. Replace the obvious fields formatted like so below

#!/bin/bash

near call nearcon2.mintbase1.near nft_batch_mint "{
\"owner_id\": \"nearcon2.near\",
\"metadata\": {
\"extra\": \"ticket\",
\"reference\": \"dfnswq0LaXwNgGzqdW0-YPJLtTxc-fhQlLk8k1UCcJw\"
},
\"num_to_mint\": 25,
\"royalty_args\": {
\"split_between\":{
\"nearcon2.near\":6667,
\"unchain-fund.sputnik-dao.near\":3333
},
\"percentage\":300
},
\"split_owners\": {
\"nearcon2.near\":8000,
\"unchain-fund.sputnik-dao.near\":2000
}
}" --accountId nearcon2.near --gas 280000000000000 --amount 0.00000000000000000000001















3. Then run the loop











loop 'bash mass_mint.sh' --for-duration 1h --every 5s
(Un) Delisting NFTs





How to programmatically delist NFTs from our marketplace


We are currently working on adding delisting token functionality to our suite of Launchpad features, however if you wish to (un)delist tokens from the Mintbase simple market contract you can do this programmatically as follows:












1. Export variables for near env (mainnet or testnet), your *.mintbase1.near contract address and account. Note the list of tokens must be a comma delimited list of strings wrapped in double quotes "".





















$ export NEAR_ENV="mainnet"
$ export TOKEN_CONTRACT_ACCOUNT="example.mintbase1.near"
$ export OWNER_ACCCOUNT="myaccount.near"
$ export TOKENS_TO_UNLIST='"11","12"'




















2. Run the following command (You will have to be authenticated as the OWNER_ACCOUNT for this to work)




















near call simple.market.mintbase1.near unlist "{\"nft_contract_id\":\"${TOKEN_CONTRACT_ACCOUNT}\", \"token_ids\":[${TOKENS_TO_UNLIST}]}" --accountId=$TOKEN_CONTRACT_OWNER --depositYocto=1

### MintbaseJS

When we write to a blockchain, we are making a transaction. Any transaction we do on Mintbse (mint, burn, transfer, and make offer) you can do either talking directly to the contract via NEAR CLI , MintbaseJS, or ever using a ui tool like Nearblocks.








Mintbase uses MintbaseJS for all of our transactions on both the market and minter including mint, transfer, burn, sell, buy, so if we can use it, so can you.
















The best documentation to go off of is the typescript docs as this library will change rapidly. If something is broken please make sure you have the latest and run see if the type are matching. Please create issue on Github to help us make it better.









⚠️⚠️ In active development ⚠️⚠️
This package is under active development. Expect breaking changes often.
Mintbase API
General purpose Mintbase API for interacting with NEAR, Arweave and other supported blockchains and decentralized file storage systems.
See the types documentation








General purpose Mintbase API for interacting with NEAR, Arweave and other supported blockchains and decentralized file storage systems.
















See the types documentation
Table of Contents









 	Mintbase API
 	Table of Contents
 	Install
 	Getting Started
 	Support
 	Examples
 	License

Install
$ npm install mintbase
Getting started
Initializing and Connecting Mintbase Wallet
Acquire an API key in the Developer tab on Mintbase
import { Wallet, Chain, Network } from 'mintbase'

// Connect and fetch details
async function connect() {
const { data: walletData, error } = await new Wallet().init({
networkName: Network.testnet,
chain: Chain.near,
apiKey: API_KEY,
})

const { wallet, isConnected } = walletData

if (isConnected) {
const { data: details } = await wallet.details()

/*
accountId: "qwerty.testnet"
allowance: "0.25"
balance: "365.77"
contractName: "mintbase13.testnet"
*/
}
}

connect()
Here's an example of a button to connect to the wallet.
<Button onClick={() => wallet.connect({ requestSignIn: true })}>Login</Button>
Examples
Bootstrap your app with Create Mintbase App (React + Typescript)
Support








Open an issue!
















or ask in our developer telegram








 

### Metadata

For tokens created on Mintbase all metadata lives on Arweave, a permanent, cheap, and decentralized storage platform. We use the reference to get the entire metadata block on Arweave (title, description, media) to save on space.
type TokenMetadata = {
title: string|null, // ex. "Arch Nemesis: Mail Carrier" or "Parcel #5055"
description: string|null, // free-form description
media: string|null, // URL to associated media, preferably to decentralized, content-addressed storage
media_hash: string|null, // Base64-encoded sha256 hash of content referenced by the `media` field. Required if `media` is included.
copies: number|null, // number of copies of this set of metadata in existence when token was minted.
issued_at: number|null, // When token was issued or minted, Unix epoch in milliseconds
expires_at: number|null, // When token expires, Unix epoch in milliseconds
starts_at: number|null, // When token starts being valid, Unix epoch in milliseconds
updated_at: number|null, // When token was last updated, Unix epoch in milliseconds
extra: string|null, // anything extra the NFT wants to store on-chain. Can be stringified JSON.
reference: string|null, // URL to an off-chain JSON file with more info.
reference_hash: string|null // Base64-encoded sha256 hash of JSON from reference field. Required if `reference` is included.
}
Get metadata from chain
If you are using the NEAR CLI via command line on mainnet, you can see that Mintbase tokens will only return the reference field from metadata:
export NEAR_ENV=mainnet
near view nearcon2.mintbase1.near nft_token '{"token_id": "204"}'
Returns
{
token_id: '30',
owner_id: 'nearcon2.near',
approved_account_ids: { 'market.mintbase1.near': 10 },
metadata: {
title: null,
description: null,
media: null,
media_hash: null,
copies: 20,
issued_at: null,
expires_at: null,
starts_at: null,
updated_at: null,
extra: 'ticket',
reference: 'dfnswq0LaXwNgGzqdW0-YPJLtTxc-fhQlLk8k1UCcJw',
// New Contracts have the full url to fetch the metadata so might look like
// reference: 'https://arweave.net/dfnswq0LaXwNgGzqdW0-YPJLtTxc-fhQlLk8k1UCcJw',
reference_hash: null
},
royalty: {
split_between: {
'nearcon2.near': { numerator: 6000 },
'unchain-fund.sputnik-dao.near': { numerator: 4000 }
},
percentage: { numerator: 5000 }
},
split_owners: null,
minter: 'nearcon2.near',
loan: null,
composeable_stats: { local_depth: 0, cross_contract_children: 0 },
origin_key: null
}
Take the reference dfnswq0LaXwNgGzqdW0-YPJLtTxc-fhQlLk8k1UCcJw and stick it on the end of an arweave node base uri like `https://arweave.net`
So....
https://arweave.net/dfnswq0LaXwNgGzqdW0-YPJLtTxc-fhQlLk8k1UCcJw
returns
"media": "https://arweave.net/c2g92YvhcnbB5JBePIrK48uX5mPw6gcbhvfvabQkSGM",
"media_hash": "c2g92YvhcnbB5JBePIrK48uX5mPw6gcbhvfvabQkSGM",
"tags": [
"nearcon"
],
"title": "General Admission",
"description": "The holder of this NFT will gain general admission entry to all days of NEARCON 2022. If you can't make this event, transfer it on to a colleague, sell it on secondary markets, hold an open Twitter contest (best answer gets this NFT), or even auction it off to the highest bidder. Welcome to the new world of fluid, borderless digital assets. On the day of NEARCON, please make sure it's on an easily accessible mobile account for redeeming. Checking in with a ledger is possible, but much quicker if you are already connected to a wallet.",
"extra": [
{
"trait_type": "website",
"display_type": "website",
"value": "https://nearcon.org/"
},
{
"trait_type": "Start Date",
"value": 1662850800,
"display_type": "date"
},
{
"trait_type": "End Date",
"value": 1663110000,
"display_type": "date"
},
{
"trait_type": "location",
"value": "Cais da Viscondessa, 1200-109 Lisboa, Portugal"
},
{
"trait_type": "place_id",
"value": "ChIJKSi2xoQ0GQ0R2xH3l2OH5W0"
},
{
"trait_type": "zoom",
"value": 14
},
{
"trait_type": "latitude",
"value": 38.7053168
},
{
"trait_type": "longitude",
"value": -9.1549384
},
{
"trait_type": "type",
"display_type": "type",
"value": "general_admissions"
},
{
"trait_type": "access",
"display_type": "access",
"value": "daypass"
},
{
"trait_type": "NEARCON",
"display_type": "NEARCON",
"value": "2"
}
],
"store": "nearcon2.mintbase1.near",
"type": "NEP171",
"category": "ticket"
}
 
Find the Metadata via the UI
If we inspect our thing page:
https://www.mintbase.io/thing/nGr-c_UfzHr515RPqVJfQNdFV1Eivo0as2RGOo-2Z24:hellovirtualworld.mintbase1.near
If you scroll down to Details, you'll see transaction hash



Combine the Storage Gateway with Transaction Hash
https://arweave.net/nGr-c_UfzHr515RPqVJfQNdFV1Eivo0as2RGOo-2Z24
{
"category": "vr",
"description": "Credits to Mozilla for creating this model",
"copies": 1,
"media_hash": "zRHjE6nUSHUN4YB3FWx__57EWNpIAOUenf4_gddCArg",
"lock": null,
"visibility": "safe",
"youtube_url": null,
"animation_url": "https://arweave.net/bUj-aADWZ1RV9Od4QYx-99oAOcVbvRcep3Fdg9OpCP8",
"animation_hash": "bUj-aADWZ1RV9Od4QYx-99oAOcVbvRcep3Fdg9OpCP8",
"document": null,
"document_hash": null,
"royalty": {
"microchipgnu.near": 10000
},
"royalty_perc": 0.1,
"split_revenue": {
"3xr.near": 5000,
"microchipgnu.near": 5000
},
"tags": [

],
"media": "https://arweave.net/zRHjE6nUSHUN4YB3FWx__57EWNpIAOUenf4_gddCArg",
"extra": [
{
"trait_type": "website",
"value": ""
},
{
"trait_type": "asset_places",
"value": "[ { \"position\": { \"x\": -5.6, \"y\": 1.5, \"z\": 5 }, \"rotation\": { \"_x\": 0, \"_y\": 1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -5.6, \"y\": 1.5, \"z\": 3 }, \"rotation\": { \"_x\": 0, \"_y\": 1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -5.6, \"y\": 1.5, \"z\": 1 }, \"rotation\": { \"_x\": 0, \"_y\": 1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -5.6, \"y\": 1.5, \"z\": -1 }, \"rotation\": { \"_x\": 0, \"_y\": 1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -5.6, \"y\": 1.5, \"z\": -3 }, \"rotation\": { \"_x\": 0, \"_y\": 1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 5, \"y\": 1.5, \"z\": 6.65 }, \"rotation\": { \"_x\": 0, \"_y\": 3.141592653589793, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 3, \"y\": 1.5, \"z\": 6.65 }, \"rotation\": { \"_x\": 0, \"_y\": 3.141592653589793, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 1, \"y\": 1.5, \"z\": 6.65 }, \"rotation\": { \"_x\": 0, \"_y\": 3.141592653589793, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -1, \"y\": 1.5, \"z\": 6.65 }, \"rotation\": { \"_x\": 0, \"_y\": 3.141592653589793, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -3, \"y\": 1.5, \"z\": 6.65 }, \"rotation\": { \"_x\": 0, \"_y\": 3.141592653589793, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": -6 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": -4 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": -2 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": 0 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": 2 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 8.3, \"y\": 1.5, \"z\": 0 }, \"rotation\": { \"_x\": 0, \"_y\": -1.5707963267948966, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -3, \"y\": 1.5, \"z\": -7.2 }, \"rotation\": { \"_x\": 0, \"_y\": 0, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": -1, \"y\": 1.5, \"z\": -7.2 }, \"rotation\": { \"_x\": 0, \"_y\": 0, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 2, \"y\": 1.5, \"z\": -7.2 }, \"rotation\": { \"_x\": 0, \"_y\": 0, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 4, \"y\": 1.5, \"z\": -7.2 }, \"rotation\": { \"_x\": 0, \"_y\": 0, \"_z\": 0, \"_order\": \"XYZ\" } }, { \"position\": { \"x\": 6, \"y\": 1.5, \"z\": -7.2 }, \"rotation\": { \"_x\": 0, \"_y\": 0, \"_z\": 0, \"_order\": \"XYZ\" } } ]"
},
{
"trait_type": "3xr_frame_color",
"value": "#472558"
}
],
"title": "First Gallery 3XR template #1",
"store": "hellovirtualworld.mintbase1.near",
"external_url": "https://mintbase.io/store/hellovirtualworld.mintbase1.near",
"type": "NEP171"
}
As you can see from the above example, merging the JSON response from Arweave produces a complete picture of token metadata while saving storage costs on-chain.
Note that our indexer data already provides pre-resolved metadata from Arweave (currently only for Mintbase contracts).

### GraphQL

Our indexes make NFT data highly available and query-able.

















After a transaction has been confirmed by the chain, our indexer organizes the data so you can pull it quickly to show on your site. 
















Want to know which NFTs are owned by nate.near? Our GraphQL endpoints are the fastest and most flexible way to get information from Mintbase. 
















Read more about our GraphQL endpoints to get started.









This is our preferred option as it is probably the most flexible option and allows an easy schema exploration.
















Endpoints


























Network



Endpoint










mainnet









https://interop-mainnet.hasura.app/v1/graphql











testnet









https://interop-testnet.hasura.app/v1/graphql




























Use GraphiQL































































Network



URL










mainnet









https://cloud.hasura.io/public/graphiql?endpoint=https%3A%2F%2Finterop-mainnet.hasura.app%2Fv1%2Fgraphql











testnet









https://cloud.hasura.io/public/graphiql?endpoint=https%3A%2F%2Finterop-testnet.hasura.app%2Fv1%2Fgraphql













































The queries and relationships are extensible, we suggest just clicking around the tree to make the queries and it will become easy over time. 

































Examples
















1. Get NFTs owned by an account, notice the burned_timestamp if null indicates it has not been burned yet
















Query Formatting
















Find all the different entities and parameters for interacting with the API.
















Core Entities















 	



nft_tokens: Gets data on single tokens















 	



mb_views_nft_metadata_unburned: The token type (metadata wrapper)















 	



nft_metadata: Indexed metadata















 	



nft_contracts: Stores/contracts deployed















 	



nft_listings: Marketplace listings















 	



offers: Offers made to market listings















 	



mb_store_minters: Allowed mintings accounts 















 	



nft_earnings: Historical earnings per account


















Aggregated Entities
















Query Parameters
















Pagination Parameters
















offset: position where it should start the results ex: offset : 12  it will render results from 12 > 
















Query Examples
















GetStoreNfts









































GetStoreDataById









































 GetRoyaltiesInfo










































GetTokensSplitbyMetadataId









































Demo

### Getting Started

Let's get you to build your own NFT Market!

















Get an API Key
















For transactions using MintbaseJS, get a developer key here
















Using Boilerplate Examples















 	



Simple Marketplace​















 	



​Simple Minter​


















Mintbase Tools














1.​ Learn to read data from our real-time graphQL indexer: Ex: Who owns what token now.










2.​ Learn to write data to the blockchain: Creating transactions like mint, transfer, and make offers.










3. Dive into the open-source rust smart contract factory.










4. Deploy and check everything on testnet https://testnet.mintbase.io​














​
















Most of our repositories are open source with either the MIT License or the GPL-3.0 License. Mintbase is a tool in the public domain, as such anyone can view and contribute to every aspect of the protocol.

### Step



### Как зарабатывать nLEARNs на LNC

После авторизации перейдите в Гайды:



Есть раскрывающийся список гайдов, но если вы проигнорируете раскрывающийся список и нажмете на саму кнопку «Гайды», вы попадете на страницу «Все гайды».

Вы можете нажать «Далее», чтобы увидеть больше гайдов.


 6 пунктов на странице — это очень мало; 24 лучше, не нужно так часто нажимать «Далее».
По мере того, как вы зарабатываете и получаете nLearns, вы можете посетить страницу «Курсы».



В раскрывающемся списке есть несколько курсов. Наиболее полезным из них является Курс для сертифицированных разработчиков. Нажав на него, вы попадете на страницу, где вы можете оплатить курс nLearns (см. об оплате обучения) и пройти его.



Если Вы закончите курс к концу дня, вы получите больше nLearns , чем заплатили. Если вы пройдете курс сертифицированного разработчика, вы даже сможете получить NEAR!



Нет конкретной суммы, которую вы заработаете, потому что это зависит от того, насколько полным, уникальным и творческим будет ваш проект. Точных критериев нет, но кажется, что если вы сделаете фронтенд для демо, вы заработаете больше, чем тот же проект без него. Забудьте о сравнении с другими: оно только порождает зависть и ненависть. Старайтесь!

Наконец, nLearns может претендовать на статус NEAR. Правда, у него есть некоторые ограничения:

Это вкладка (L)Earn и нажмите «Обменять на N». Или просто посетите эту страницу.



Погашение происходит 15-го числа каждого месяца, поэтому, когда окно открыто, нажмите на ссылку:



Страница вывода



Вы можете продолжить оттуда. При первом погашении вам необходимо заполнить некоторые формы. Это довольно сложный процесс, просто следуйте инструкциям. Сначала вам нужно заполнить ее один раз, затем перезагрузить страницу (и форма изменится) затем заполнить вторую форму для погашения.

После первого выкупа это всего лишь одно нажатие кнопки.

Видите название? Если у вас есть (L)Earner NFT, вы можете использовать окно вывода раньше. Просто отчеканьте NFT сейчас!

Перейдите на страницу:



Залогиньтесь и заминтите:



 
Если он у вас уже есть, вы можете нажать кнопку «У меня есть (LEarner Nft»), чтобы перейти к досрочному погашению.
Что касается минта, смотрите ниже:



Кнопка «Сгенерировать» меняет картинку на что-то другое. Продолжайте нажимать на нее, пока не будете удовлетворены изображением.

Затем придумайте имя вашей NFT. Предпочтительно имя, содержащее менее 32 «символов» («символов», потому что это не обязательно английские символы).

В настоящее время выпущено 340 (L)Earner NFT. Общее количество NFT составляет 10 000, так что создайте свой заранее!

И еще одна причина для ранней чеканки заключается в том, что цена увеличивается с увеличением числа чеканки. Первые 250 выпущенных NFT стоят 2 NEAR. 10 000-й NFT будет стоить 10 NEAR!
Наконец, не обманывайте и не фармите nLearns. Вы здесь, чтобы учится, а не заниматься фармом.

### NEAR NFT на Mintbase

Посетите Mintbase на mintbase.io.



Вы можете искать конкретные NFT или посетить «рынок» (вкладка), чтобы купить случайный NFT.



Найдя NFT, щелкнув по нему и перенаправившись на страницу NFT, вы можете нажать кнопку «купить».



Конечно, если вы хотите купить более одного, вы можете изменить количество. 

Для получения дополнительной информации посетите эту страницу

### NEAR NFT на PARAS

Посетите Paras на paras.id.



 PARAS имеет множество особенностей, многие из которых мы не знаем. Но в качестве основы вы можете искать случайный NFT на вкладке «Рынок»:



добавьте несколько фильтров (оранжевые круги) или вы можете посетить определенную коллекцию и найти в ней NFT.

На главной странице вы видите список лучших коллекций, которые вы можете посетить и найти NFT для покупки.



После входа в систему найдите NFT, который вы хотите купить, нажмите «Подробнее»: (это обязательно, не нажимайте на изображение, это ничего не делает для купить на момент написания)



Вы попадете во всплывающее окно, где вы можете купить NFT



Самый простой способ - просто нажать синюю кнопку и купить:



А если вы хотите купить чьито NFT, вы можете «купить на вторичном рынке»:



Вы видите список владельцев, продающих свои NFT. По умолчанию он указан с ценой от низкой к высокой, поэтому самые дешевые из них самые верхние.



Вы знаете, что делать

### NEAR NFT в кошельке

Если Вы получили несколько NFT, вы увидите их на вкладке «Предметы коллекционирования». Зайдите в неё, чтобы увидеть ваши NFT.
P.S. Для загрузки некоторых изображений требуется некоторое время, вы можете подождать, пока они загрузятся, или просто проигнорировать их, щелкните на NFT чтобы взаимодействовать с ним.


Нажав на слова или изображение (если загружено) NFT, вы попадаете на страницу NFT. Она содержит больше информации о NFT, а также включает кнопку «Передать», если вы хотите отправить этот NFT кому-то другому.



Просто введите адрес кошелька (который вы используете при получении NEAR).
Иногда контракт не оптимизирован, поэтому вы не можете перевести свой NFT напрямую из веб-кошелька, потому что для этого требуется более 30 TGas. ((L)Earner NFT — это пример, для передачи которого требуется около 80-90 TGas). Как можно передать её — использовать Near-Cli, но это неудобно для пользователя и, скорее всего, вам не нужно об этом знать.
Далее, давайте поговорим о том, как вы могли бы тратить и зарабатывать NEAR.

### Отправка, получение, стэйкинг NEAR

Отправка NEAR
Чтобы отправить NEAR, просто нажмите кнопку «Отправить» на главной странице. Введите количество:


ПОЖАЛУЙСТА, НЕ используйте "MAX". Вам нужно немного денег для транзакций, а «MAX» оставит вас без средств на транзакции.
Затем введите идентификатор учетной записи. Это может быть 64-значное случайное число , что-то вроде wabinab.near или даже subaccount.wabinab.near.



На следующей странице просто нажмите «Подтвердить и отправить».



Будь то 64-значный адрес или явный адрес, такой как wabinab.near, вы можете получать NEAR откуда угодно, даже от людей, отправляющих с Binance! Он будет правильно перенаправлен.
Стэйкинг
Если вы когда-либо пользовались услугами банка, «стэйкинг» похож на «сберегательный счет». Исключение лишь в том , что вы не можете просто взять свои деньги в любое время, когда захотите.
Перейдите на вкладку «Стейкинг» и выберите «Стейкинг моих токенов»:



Затем выберите учетную запись валидатора, которому вы отправите свои средства.
Технический термин «учетная запись» — «валидаторы». Если кто-то произносит технический термин «валидаторы», вы знаете, что он означает «учетная запись».

Вам может быть сложно, потому что, делая выбор, вы не знаете, заслуживают ли они доверия или нет. По собственному опыту вы можете убедиться в надежности, посетив этот сайт, на нем можно посмотреть как большую сумму ставок, так и большое количество участников.


Красный кружок показывает столбец; количество стейкеров с этим валидатором, а оранжевый кружок показывает столбец: общее количество NEAR у валидатора. Затем комиссия пула: сколько процентов забирает валидатор. Так что, если это 1%, а вы внесли 1 NEAR, вы получите только 0,99 NEAR, когда вы отмените стэйкинг.

Судя по изображению выше, «astro-stakers.poolv1.near», «zavodil.poolv1.near», «epic.poolv1.near» — хорошие валидаторы для стэйкинга.

Большое количество NEAR, большое количество участников и низкая комиссия пула.

Что касается отмены стэйкинга, вы можете отменить все, нажав кнопку «Отменить стэйкинг».



 

Затем вам будет предложено выбрать, с какой учетной записи вы хотите отменить стэйкинг. Здесь у нас есть только одна учетная запись (валидатор). Выберите эту учетную запись (валидатор). Нажмите кнопку «Отменить стэйкинг». Вуаля! Подождите от 2 до 2,5 дней до окончания периода отмены стэйкинга, и здесь появится скрытая кнопка "Вывод":



Нажмите её



 

### НАЧАЛО: как создать кошелек NEAR

Посмотрите эту статью: https://learnnear.club/near-wallets/#Creating_A_NEAR_Wallet

Есть некоторое отличие: некоторые люди используют неявные адреса (например, адреса somename.near), если вы не создаете учетную запись через linkdrop, то изначально создаются 64-символьные адреса, только после создания кошелька, вы можете добавить собственный адрес. (Вам нужно будет заплатить 0,1 NEAR за индивидуальный адрес)



Страница near кошелька (на момент написания статьи) — wallet.near.org.

### Отправка, получение, стэйкинг NEAR



### Отправка, получение, стэйкинг NEAR



### Step



### How to (L)Earn at Learn NEAR Club

After logging in, visit the Guides:

It has a dropdown from the guides, but if you ignore the dropdown and clicking on the “Guide” button itself, you’d be taken to “All Guides” page.
You could click “next” to find more items.



In my opinion, 6 items per page is very little; 24 sounds more better, don’t have to click “next” that often.

As you (L)Earn more and get some nLearns, you could visit the “Courses” page.

In the dropdown, there are some courses to work with. The most useful is Near Certified Developer Course, and clicking on that (don’t click on the popup on Near Certified Developer Gallery), you’d be taken to a page where you can stake some nLearns (see of paying school fee) and participate.

Don’t worry, you also (L)Earn: by the end of the day, if you manage to finish the course, you get more money than you pay. If you pass the Certified Developer Course, you can even get some NEAR!

There’s no specific amount saying how much you (L)Earn because it depends on how complete, how unique, how creative your project is. The exact criteria one don’t know, but it seems that if you make a frontend to demo, you (L)Earn more than the same project without one (needs clarification). And forget about comparing with others: it only breeds jealousy and hatred. Do your best!
Lastly is nLearns can be claim to NEAR. Albeit, it has some restrictions:
This is the (L)Earn tab and click “Redeem to N”. Or just visit this page.

Redeem is on the 15th of every month, so when the window’s open, click on the link:

Redeem page:

And you can proceed on from there. The first time you redeem, you need to fill in some forms. It’s quite complicated process, but just follow the instructions. You need to fill it one time first, then reload the page (and the form will change), and fill in the second form to redeem.
After the first redeem, it’s only a single button click after that.
And see the title? If you have a (L)Earner NFT, you get to redeem earlier. Just “Mint Yours Now”!
Go to the page:

Login and mint:



If you already have one, you can clik on the “I have (L)Earner Nft” button to proceed for early redeem.

As for minting, you scroll down to here:

And the “Generate” button changes the picture to something else. Keep clicking on it until you’re satisfy with the image.
Then, the “Name you (L)Earner” is just giving it a name. Preferably, a name with less than 32 “characters” (“symbols” because it’s not necessarily English characters).
Currently, there are 340 minted (L)Earner NFTs. The total amount of NFTs is 10,000, so mint yours early!
And another reason to mint early is, price increases with higher minting number. The first 250 NFTs being minted costs 2 NEAR. The 10,000th NFT will cost 10 NEAR!


Finally, don’t cheat and farm nLearns. You’re here to (L)Earn, not to Farm.

### NEAR NFTs at Mintbase

Visit Mintbase at mintbase.io.

You could search for specific NFTs or you could visit the “marketplace” (tab) for a random NFT to buy.

Upon finding an NFT, clicking on it and get redirected to the NFT page, you can click on the “buy” button to buy.

Of course, if you want to buy more than one, you could change the amount. It should be straightforward, just follow the displays. You can do it!
For more info, visit this page

### NEAR NFTS at Paras

Visit Paras at paras.id.

Paras have lots of features that even I don’t know about. But as a basic, you could search for random NFT on the “Market” tab:

and add some filters (orange circles); or you could visit a specific collection and search that collection for an NFT.
On the home page, you see a list of top collections which you can visit and find an NFT to buy.

After login (top right corner, you know how to login right?) and find an NFT you want to buy, click on the “See details”: (this is a must, don’t click on the image, it does nothing to buy as of writing)

And you’d be taken to a popup that you can buy

The easiest is just to click the blue button and buy:

While if you want to buy second-hand NFTs, you can “buy from secondary marketplace”:

And you’d shown a list of second-hand owners selling their NFTs. By default, it’s listed with price from low to high, so the top ones are the cheapest.


Then you know what to do, straightforward.

### NEAR NFTs at wallet

If you manage to have some NFTs, you’d see them in the Collectibles tab. Click on that to see your NFTs.


P.S. Some Images takes a while to load, you could wait for it to load, or just ignore it and click on the wordings to interact with the NFT.


Clicking on the words or the image (if loaded) of the NFT, you bring yourself to the NFT page. It has more information about the NFT, and also include a “Transfer” button if you want to send that NFT to someone else.

Just enter the wallet address (which you use the same address when Receiving NEAR).


Sometimes, the contract isn’t optimized, so you cannot transfer your NFT directly from web wallet because it requires more than 30 TGas to do so. ((L)Earner NFTs is an example that requires about 80-90 TGas for transfer). The way to do this is using near-cli to transfer, which isn’t user-friendly and most probably you don’t need to know about it.

Next, let’s speak of some way you could spend and earn NEAR.

### Send, Receive, and Stake NEAR

Send NEAR
To send NEAR, just click the “send” button on the front page, Enter an amount:



PLEASE DO NOT “Use Max”. You need some money for transactions, and “use max” is a stupid button that locks you with no money inside your wallet.

Then, enter the account ID. It could be a 64-digit random number, or it could be something like wabinab.near or even subaccount.wabinab.near.

And the next page, just click “Confirm and Send”.

Receive NEAR
Just click on the receive button and you’d be taken to your wallet address page.

Whether it’s the 64-digit address or an explicit address like wabinab.near, you can receive from anywhere, even from people are sending from Binance! It’ll redirect correctly.

Staking

If you ever used a bank, “staking” is like the “saving accounts”; except you cannot simply take out your money at any time you want, and it’s more difficult to use than simply moving your money to your saving accounts.

Click on the Staking tab and choose Stake my Tokens:

Then select an account you’d like to stake with.


The technical term for “account” is “validators”. If anyone says the technical term “validators”, you know it means “account”.


You may find it difficult, because making choice, you don’t know whether they are trustworthy or not. From one’s experience, you can know trustworthiness by visiting this site, then check for both high stake amount AND high number of stakers.


The circle in red shows the column for “number of stakers with this account” and circle in orange shows the column for “total number of NEAR staked with this account”. Then, Pool Fees is, whatever your interest earned, how much does the account eat away (ignoring exceptions)? So if it’s 1%, and your interest is 1 NEAR, you only get 0.99 NEAR when you unstake you money.
Based on the image above, “astro-stakers.poolv1.near”, “zavodil.poolv1.near”, “epic.poolv1.near” are some good accounts to stake with.
So, high stake amount, high number of stakers, and low pool fees.
As for unstake, you could unstake everything by clicking the “Unstake” button.

Then, you’d ask to choose which account you’d want to unstake from. Here, we only have one account (validator) to unstake from. Choose that account (validator). Click the “Unstake” button. Voilà! Just wait for about 2 to 2.5 (two and a half) days before the unstaking period is finish, and a hidden button will be displayed here:

for you to click.

### START HERE: How to Create a NEAR Wallet

Check this article first: https://learnnear.club/near-wallets/#Creating_A_NEAR_Wallet.
There are some difference though: since there are some people taking advantage of the implicit addresses (i.e. somename.near addresses), if you’re not creating an account via linkdrop, you are immediately given the 64-character addresses initially. Then, only after you wallet is created, you can add a custom address. (You’d need to pay 0.1 NEAR for a custom address)

### Mainnet Launch



### Beta teat Phase 2



### Security Audit by partner company



### Step



### Step



### Step



### Deploying your Smart Contract on the blockchain

A smart contract is a program that works on the blockchain. This feature differs it from any other program. To deploy our smart contract on the NEAR blockchain we need to do the following steps:

 	add your account name to the file ‘src/config.js’ (when you created an account on the Testnet you got the name of your account). The first line should be changed from 
 	const CONTRACT_NAME = process.env.CONTRACT_NAME || 'myFirstSmartContract.YOUR-NAME.testnet'

to your account name like this:
     const CONTRACT_NAME = 'tilek.testnet'

 	save all the changes you made
 	write the command in the Terminal “near dev-deploy”. After you run this command your code will be deployed on the blockchain. And can see the deployment process in the console like in the screenshot below.
 	In the console, you will see the development account like this dev-1647338452503-81261679306903. NEAR CLI deploys our smart contract under the specific account on the blockchain and we will use this development account to call functions and save data.



Now let’s see how our smart contract works. Call your smart contract function with this command (don’t forget to change the development account on yours):

example
$ near view dev-1647338452503-81261679306903 hello
You should get a result like this:

Log [dev-1647338452503-81261679306903]: Hi, there! You have written your first Smart Contract on NEAR!

Congratulations! You have created your first smart contract on NEAR blockchain!

Keep on learning!

Leave your feedback here


                
                        
                            Course feedback
                            
                         
 
                        How did you like the course?*
			
				
				Good
			
			
				
				OK
			
			
				
				Not impressed
			
			
				
				IDK, I am bot
			What did you like MOST?*What did you like LEAST?*CAPTCHA

### Writing your first Smart Contract

The code of the Smart Contact lives in the folder `/contract/assembly` under the file called “index.ts”.  We will be writing our code in AssemblyScript programming language. 



“index.ts” file already has some example code for you. You can simply delete all lines of code as we will write our code ourselves.

Firstly, we will write in the editor this line of code:
import { logging } from 'near-sdk-as'
‘near-sdk-as’ is a library that was developed by NEAR team to write code in Assembly Script. It contains some classes that we can use in our code. In this case we import ‘logging’ class:

 	‘logging’ class records logs to the NEAR blockchain.

Quiz:

What code editor or IDE is the best to write and deploy smart contracts on NEAR?

Atom.

VS Code.

Sublime Text.

User can choose and work with any IDE mentioned above.

Next let’s write this function:
//view function
export function hello(): bool {
  logging.log("Hi, there! You have written your first Smart Contract on NEAR!");
  return true;
}
This function with the name “hello” performs a basic operation on the blockchain. It returns a boolean value and logs our greeting in the console.

### Create a testnet account and set up your IDE

If you don’t have a testnet account you can easily create it following this link:

https://testnet.mynearwallet.com/create

I assume that you don't have any programming experience. That's why I will briefly explain why we need it. IDE (or an integrated development environment) is software for building applications that combines common developer tools. We need it to write our smart contract code and we will be using it for interacting with our smart contract. There are a lot of different IDEs. You can use the one that you like. Here in this article, I will use VS Code. 

You can download VS Code under the following link https://code.visualstudio.com/.

Now it's time to install NEAR-CLI. NEAR-CLI is a command line interface that allows you to interact with NEAR blockchain. Use the following guide to install it.

https://docs.NEAR.org/docs/tools/NEAR-cli#setup

Ideally, you need to have some practice to learn how to use Terminal and basic commands with NEAR CLI before going further. Try to make some basic commands to understand how it works:

 	near login  command to connect your testnet account
 	near state  yourAccountName.testnet’ to get basic info on your account state
 	near send  to send coins on the testnet

Now to finish our set up we create a blank project using the following command:
npx create-near-app myFirstSmartContract
This command will create an empty NEAR project called “myFirstSmartContract” with all necessary dependencies. Open the project folder and we are ready for writing our smart contract. In the project folder “myFirstSmartContract”, you can find many files but don’t be afraid most of them you don’t need because they are used to simplify your life and you can focus on your Smart Contract code.

You can find more details under the following link:

https://github.com/NEAR/create-NEAR-app

And also you can find some details in README file. It is located in the project folder.

### Accept payment in NEAR

Accept direct payment to account
You can direct users to pay directly to your .near account. It works like a charm if you just want to accept donations, etc.

However it gets harder if you want to detect payment and allow to do smth else like give users corresponding number of in-game currency. You can use some blockchain indexer, e.g. https://github.com/near/near-indexer-for-explorer. Easiest way to use it would be to query one of publicly available Postgres instances.

So the recommended way to accept payment is to use a smart contract. In this case your smart contract can have logic which verifies sender, amount and other parameters and automatically updates state of user's account accordingly (e.g. sends user a NFT for sword they just purchased).
Accept payment in smart contract
Every function call to a smart contract can have some payment in NEAR tokens attached.

There is a guest book example that allows to attach donation to a message.

Amount of NEAR tokens can be specified for every contract call like this:

    contract.addMessage(
      { text: message.value },
      // Maximum amount of gas allocated to operation, 30 * 10**12 is a good default
      BOATLOAD_OF_GAS,
      // Amount is specified as an integer number of yoctoNEAR (i.e. 1 / 10**24 NEAR)
      Big(donation.value || '0').times(Big(10).pow(24)).toFixed()
    ).then(() => {
        // ...
    });

In smart contract number of tokens attached is represented by storage.attachedDeposit property. Note that this balance is returned back to user if transactions fails.

Smart contract can verify this balance and perform actions accordingly, e.g.:

export function purchaseItem(itemId: string): void {
  const itemPrice = storage.get<u128>("itemPrice:" + itemId);
  assert(itemPrice, `item ${itemId} is not listed for sale`);
  assert(context.attachedDeposit >= itemPrice!, `item ${itemId} costs ${itemPrice!} which is more than attached ${context.attachedDeposit}`);
  // Update owner for purchased item and remove it from sale
  storage.set("itemOwner:" + itemId, context.contractName);
  storage.delete("itemPrice:" + itemId);
}

More lessons coming soon!

Please let us know your thoughts about this course
                 
 
                        How did you like the course?*
			
				
				Good
			
			
				
				OK
			
			
				
				Not impressed
			
			
				
				IDK, I am bot
			What did you like MOST?*What did you like LEAST?*CAPTCHAPhoneThis field is for validation purposes and should be left unchanged.

### How to store game state on NEAR

Smart contracts
Blockchain state is managed by smart contracts: https://docs.near.org/docs/develop/contracts/overview User can submit function call transactions which are calling smart contract method which is then able to modify account state. These are somewhat similar to stored procedures in SQL databases.

Smart contract storage model in AssemblyScript is somewhat similar to localStorage in JS. You call storage.set to write value for a given key and storage.get (and it's type variations like storage.getPrimitive) to retrive it. For example to implement a simple counter:

import { storage, logging } from "near-sdk-as";

export function incrementCounter(value: i32): void {
  const newCounter = storage.getPrimitive<i32>("counter", 0) + value;
  storage.set<i32>("counter", newCounter);
  logging.log("Counter is now: " + newCounter.toString());
}

export function getCounter(): i32 {
  return storage.getPrimitive<i32>("counter", 0);
}

export function resetCounter(): void {
  storage.set<i32>("counter", 0);
  logging.log("Counter is reset!");
}

Connect to smart contract client-side:

const contract = new Contract(account, CONTRACT_NAME, {
    viewMethods: ["getCounter"],
    changeMethods: ["incrementCounter", "resetCounter"],
    sender: account.accountId
});

With such smart contract client code can submit transactions to manipulate counter, e.g.:

document.querySelector('#plus').addEventListener('click', () => {
  contract.incrementCounter({value}).then(updateUI);
});

It's possible to retrive current counter value as well:

const counterValue = await contract.getCounter();

See full counter example here: https://examples.near.org/counter
Limitations
Each operation executed on blockchain costs some "gas": https://docs.near.org/docs/concepts/gas Gas is an approximate measure of how much compute given operation uses when executed on chain and exists to manage supply and demand for execution on blockchain. Gas is paid in NEAR tokens by whoever submits a transaction.

Another limitation is that you have to lock certain number of NEAR tokens to pay for storage. See here https://docs.near.org/docs/concepts/storage-staking

This is exists to account for limited real world storage and create incentive to free unused storage.
Structuring storage around gas limits
There is only limited amount of gas available to every operation. This means the amount of storage that can be modified at once is also limited. You can overcome it by splitting game state into multiple chunks.

For example NEAR Lands splits map into smaller squares using Chunk model and takes tracks which ones were recently changed using ChunkMap model

Sometimes user can perform a lot of actions in quick sequence (e.g. place multiple tiles in a raw). For this reason it is important to batch multiple operations in single transactions. Check this implementation of setTiles method designed to update multiple tiles at once.

Another interesting game to study for performance optimizations is Berry Club. See GitHub: https://github.com/evgenykuzyakov/berryclub

### How to login with NEAR

Please complete the following as soon as possible  It is essential for the success of this program to coordinate our activities and this will help us do just that.
Immediately:
1. Please join us on a dedicated Telegram Group
- Join LNC Official Telegram group to get P2P help and get tips with NEAR

2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear

3. Create a testnet account  - YourName.testnet - https://wallet.testnet.near.org/

4.  Add our Telegram bot to monitor your accounts:
Mainent:  https://t.me/nearwatchbot
Testnet:  https://t.me/LNC_testenet_watcher_bot

Configure connection to NEAR blockchain:

const APP_KEY_PREFIX = 'near-lands:'
const near = await connect({
    nodeUrl: 'https://rpc.mainnet.near.org',
    walletUrl: 'https://wallet.near.org',
    networkId: 'default',
    // Specify where to store the signing keys
    keyStore: new keyStores.BrowserLocalStorageKeyStore(window.localStorage, APP_KEY_PREFIX)
})


Get current user account:

const walletConnection = new WalletConnection(near, APP_KEY_PREFIX)
let account;
if (walletConnection.isSignedIn()) {
    // Logged in account, can write as user signed up through wallet
    account = walletConnection.account();
} else {
    // Contract account, normally only gonna work in read only mode
    account = new Account(near.connection, CONTRACT_NAME);
}

### NCDL2 Contributor Feedback

Please let us know how did the process work for you

### NEAR 认证开发者（一级）之后的更多步骤

如果您已经完成了演示项目，您可以注册：

NEAR 认证开发者 (二级) 测试网应用开发课程，如果你想要进一步完善你的项目并且在 Learn NEAR Club 的帮助下来获取你的项目的最初的100位用户，

或者

NEAR 认证开发者 (二级) 贡献者 课程，如果你想要加入 NEAR 生态的现有项目。

祝你愉快得边学边挣！
现在，是时候提交最终作业了！

### NEAR 认证开发者（一级）之后的更多步骤



### NEAR 认证开发者（一级）之后的更多步骤

如果您参与了演示项目，请注册NEAR 认证开发者 (一级/核实)课程以安排面试并获得卓越证书。还可将您的名字包含在NEAR 认证开发者名录中


 

### 第 6 步 - 演示 web3 - NEAR 认证开发者（一级）

学习演示智能合约项目。



✨ 此步骤的目标是向他人展示您的工作。



📗 核心活动

 	使用幻灯片和视频记录您的演示
 	周五用5-10分钟向学习小组展示你的工作
 	庆祝自己完成了课程！恭喜你，你做到了！

### 第 5 步 - 部署 web3 - NEAR 认证开发者（一级）

学习将智能合约部署到TestNet。



✨ 今天的目标是部署合约并验证其是否有效。




 	当我们在NEAR上说“应用”时，通常是指有以下行为的软件：

 	（a）控制链上数据和行为的智能合约（如NFT合约）
 	（b）控制链下数据和行为并与智能合约进行通信的应用（如web应用）



在这个星期，我们研究了许多合约和应用程序，现在我们将部署它们。

MainNet的部署超出了课程的范围，因此我们将重点关注TestNet，以及作为额外活动，您可以在私下构建的LocalNet上部署。 在TestNet上运行的所有内容都应在MainNet上同样有效。 实际上，这是TestNet的唯一目的：在我们将合约发布到MainNet上之前，为我们提供工作的完整预览。
📗 核心活动

 	填写下面的表格，以预约您的演示时间。您必须（与团队一起或独自一人）参与演示项目的开发从而获得证书。如果只有您一个人参加演示，那么在下面的表格中填写您个人的信息即可。 如果您有一个团队，在下面的表格中请填入团队所有人员的信息（仅需提交一份表格）。预约您的演示时间
为了获得证书，您必须在课程的最后进行您的演示。如果您现在还没有准备好演示，那么欢迎您在下个月的最后一个周五进行演示。

 	将至少一个应用部署到TestNet

 	选择您在第1天和第2天看到的合约和应用程序中的任何一个（或多个）。部署时，应用程序是用Rust还是AssemblyScript编写都没有关系。所有合约代码都编译为WebAssembly，并部署到链上以在Wasm兼容虚拟机中运行。 对于大多数应用程序，您将使用诸如yarn dev之类的命令，但是您也可以使用NEAR CLInear dev-deploy 轻松部署应用程序到Testnet（或者如果您已经有了Mainnet帐户，则使用near deploy ）。


 	验证已经部署的应用

 	使用NEAR Explorer验证部署（找到合约被部署到目标账户的凭证）
 	使用NEAR CLI 的命令near state <contract-account> ，成功部署后的code_hash返回值将不是默认值（全1）


 	验证使用你的应用

 	使用NEAR Explorer 验证部署（在您的帐户 上查找与已部署合约的目标账户相关联的交易记录）



📘 奖励活动
如果您还有时间和精力，还有更多内容等待您

 	安装nearup 获得一个本地节点运行。 具体步骤为：

 	安装nearup和nearcore依赖
 	编译nearcore（这可能需要很长时间）
 	运行nearup（使用刚刚编译的nearcore二进制文件）


 	确保您通过阅读nearup文档（代码仓库的README）了解配置的详细信息。
 	您最终将使用4节点LocalNet 要创建帐户，您必须在验证节点之一的机器上找到的验证节点密钥（下面是MacOS的目录形式）




这是LocalNet keystore在文件系统中的样子：
/Users/sherif/.near/localnet
├── node0
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json  <-- open one of these files
├── node1
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json
├── node2
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json
└── node3
    ├── config.json
    ├── data
    ├── genesis.json
    ├── node_key.json
    └── validator_key.json



📙 深入探索
如果您感到无所畏惧，那么您可以在一天中做完这些



现在该准备demo了！

                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### 第 4 步 - 测试 web3 - NEAR 认证开发者（一级）

学习编写智能合约的单元测试和模拟测试。



✨ 今天的目标是为你的合约编写一些测试。✨



📗 核心活动

 	在下面的资源部分中，选择AssemblyScript或Rust

 	为CORE Activity中的每个合约编写3-5个单元测试



📘 奖励活动
如果您还有时间和精力，还有更多内容等待您

如果您需要更多的挑战，请考虑以下事项：

 	查找没有单元测试的合约（有很多）并编写它们
 	从合约中删除一些（或全部）现有的单元测试并重写它们。
 	看看这个挑战问题，对您来说可能很有趣

 	Scavenger Hunt Challenge #4


 	从零开始（或只是模板代码），然后尝试使用测试驱动的方法（TDD）编写合约。

📙 深入探索
如果您感到无所畏惧，那么您可以在一天中做完这些

模拟测试是一项不断发展演进的工作，我们为您提供了一些示例帮助。 了解NEAR上的模拟测试的关键在于测试Wasm二进制文件。 这意味着相同的模拟测试将同时适用于Rust和AssemblyScript。

实际上，可以对已编译的Rust或已编译的AssemblyScript合约使用完全相同的模拟测试。 一旦您考虑到模拟测试使用的是相同的链上虚拟机，就很容易理解。因此您在模拟测试中所做的一切都应该在1：1的链上虚拟机上重复。

注意，模拟测试必须用Rust写。以下示例可以帮助您更清楚地了解：

 	NEARly Neighbors
 	Workshop on Cross-contract Calls




What is a new idea — what Satoshi figured out — is how to independently agree upon a history of events without central coordination. He found a way to implement a decentralised timestamping scheme that:

 	a) doesn’t require a time-stamping company or server,
 	b) doesn’t require a newspaper or any other physical medium as proof, and
 	c) can keep the ticks more-or-less constant, even when operating in an environment of ever-faster CPU clock times.

– Gigi in Bitcoin is Time



🎯 资源
请记住：

 	您需要编译并测试每个合约
 	您应该尽可能了解合约中的每一行代码

AssemblyScript
如果你想专注于AssemblyScript，打开AssemblyScript的合约列表

对于至少3份被标记为CORE Activity的合约

 	a) 为每个合约编写3-5个_新的_单元测试，不管它是否已经有单元测试
 	b) 验证测试如预期通过(测试可以通过命令行运行)




单元测试是由as-pect提供的，语法类似于RSpec。这个库有很好的文档，但有时它本身的测试用例可能是帮助您快速学习的最佳资源。

near.dev 上几乎所有的示例都包括单元测试。


Rust
如果您打算专注于Rust，请打开Rust合约列表

对于至少3份被标记为CORE Activity的合约

 	a) 为每个合约编写3-5个_新的_单元测试，不管它是否已经有单元测试
 	b) 验证测试如预期通过(测试可以通过命令行运行)




单元测试是Rust语言的一部分。

您可以通过Rust by Example 或 “the book” 阅读更多有关单元测试的内容。

如果您想看到一些更好的例子，所有NEAR的核心合约 都包括单元测试。 例如，您会注意到 whitelist合约，包括 test_utils，会以独立文件的形式为所有单元测试导入MockedBlockchain上下文。

### 第 3 步 - 编写 web3 - NEAR 认证开发者（一级）

学习如何在合约中对资金，身份和所有权进行控制。



✨ 今天的目标是编写可编译的合约。✨



确保克隆（clone）每个代码仓库（repository）并在本地编译。让每个应用程序运行起来，与阅读代码一样重要，因为今天您将专注于理解所有组件的工作方式。

如果由于某种原因而卡在一个应用程序上，只需在微信群或者Discord中寻求帮助并立即继续。如果可能的话，请不要等到其他人答复后再继续，否则您会浪费时间。
📗 核心活动
在下面的资源部分中，选择AssemblyScript或Rust

 	阅读您所选的语言中标记为“CORE Activity”的3个应用程序




如果您想要明确的步骤，则可以按以下方式来仔细研究每个合约或dApp：

 	从 步骤2的合约 或步骤3的dApp（见下文）中选择任何合约
 	在本地克隆代码仓库（如果使用Windows，则可使用Gitpod）
 	确保您可以找到合约源代码，并且可以将合约编译为.wasm文件
 	测试合约，从而确保合约代码可以正确工作。您可以使用NEAR CLI命令或运行现有的单元测试或模拟测试。如果有dApp的话，甚至可以使用网页界面来执行测试。核心思想是，当你改动代码时，确保你能注意到对合约的改动的影响。
 	对合约做一点小的修改。不需要做大的改动，简单的就行。
 	重新编译并重新测试（重复步骤3和4）
 	您所做的更改是否按预期运行了？ 还是出了什么错？
 	需要帮助时，可寻求帮助
 	不断重复6-7-8，直到您的信心增强……直到您认为自己了解合约并可以控制合约
 	删除合约代码并重写它，您可以参考你笔记（您做笔记了吧？）。当然，您也可以只重写合约的一小部分。

📘 奖励活动
如果您还有时间去探索，那么您可以进行以下活动。

您看到的应用程序越多，您将对NEAR能做到的事有更多的了解。

 	阅读您所选择的语言的所有应用程序，而不仅仅是3个
 	还要通读另一种语言的所有应用程序。
 	看看这个小挑战，对您来说可能很有趣

 	Scavenger Hunt Challenge #3


 	用您喜欢的语言编写一个脚本，该脚本可以自动完成一些乏味的工作。 您将在您已经阅读过的其他项目中找到一些启发。

 	编译一个合约
 	部署合约 (是否初始化可选)
 	调用合约方法



📙 深入探索
如果您感到无所畏惧，那么您可能会在一天中做完这些

AssemblyScript

 	在AssemblyScript工作坊中完成这些挑战

 	#1. 寻物游戏是一个AssemblyScript的例子
 	#2. 调试挑战 有一些未通过的测试用例需要修复


 	完成这些挑战，然后以一些有趣的方式修改合约

 	#3. 开发生命周期挑战将引导您部署一个合约


 	查看NEAR提供的便利的数据结构。这些都是NEAR Storage的封装，如文档所示

 	near-sdk-as 中的 collections
 	collection 性能


 	查看AssemblyScript实现的同质化和非同质化通证合约

 	FT：同质化通证
 	NFT：非同质化通证



Rust

 	完成Rust合约工作坊 （基于 berryclub） ，尝试修复失败的测试并参与绘制一些有意思的去中心化图片
 	查看NEAR提供的便利的数据结构。这些都是NEAR Storage的封装，[如文档所示

 	near-sdk-rs 中的 collections
 	collection 性能


 	查看Rust实现的同质和非同质通证合约

 	FT：同质化通证
 	NFT：非同质化通证


 	查看berryclub合约




To call methods, and methods, and methods, signing transactions in this petty pace from day to day, to the last token of recorded block height;

And all our ledgers have hard forked on their way to a dusty death. Out, out, brief consensus!

web 3’s but a walking shadow, a poor player, that struts and frets his hour upon the internet, and then gossips no more.

It is a tale told by a HODLer, full of sound and fury, signifying nothing.

– Willmoon Shakeschain



🎯 资源
请记住：

 	您需要构建（并运行测试）每个dApp（“去中心化应用”）
 	您应该尝试理解合约中的每一行代码

AssemblyScript
如果您打算专注于AssemblyScript，请打开AssemblyScript合约列表

您应该至少阅读3个标记为CORE Activity合约。


Rust
如果这是您第一次在计算机上使用Rust时，请参考文档的介绍。 "3步Rust安装"将帮助您安装所需的软件。

如果您打算专注于Rust，请打开Rust合约列表

您应该至少阅读3个标记为CORE Activity合约。

您可以阅读有关Rust合约的更多信息


没有合约
即使不使用合约，也可以使用NEAR构建应用程序。 以下是一些示例：不使用合约的应用示例

### 第 2 步 - 阅读 web3 - NEAR 认证开发者（一级）

学习阅读能够控制资金，身份和所有权的合约



✨ 今天的目标是阅读尽可能多的合约。✨



一开始可能会不知所措，如下技巧可能会帮助到你：

可以考虑多次快速阅读而不是一次性的慢慢阅读。阅读How to survey ?可以让您明白为什么和怎样去做。

尝试弄清楚如何获得合约代码。 然后快速阅读代码。 希望您尽可能多的阅读合约代码。 探索这些合约的“目的”（why is it?）和“编码”（what is it?）

 	AssemblyScript合约 是以.ts结尾的文件，通常是main.ts或index.ts
 	Rust合约 位于名为lib.rs的文件中。

📗 核心活动

 	在下面的资源部分中，选择AssemblyScript或Rust

 	查看您所选的语言中标记为CORE Activity的3份合约



📘 奖励活动：
如果您还有时间去探索，那么您可以进行以下活动。

 	克隆（clone）所选语言的 starter 库并按照说明进行操作

 	AssemblyScript
 	Rust (仍在开发中)



您阅读得越多越好，所以如果可以的话，继续阅读下去。记住要把注意力集中在阅读上，先不去考虑有关编译和运行相关的问题，因为这会分散您的注意力。明天，您就可以编译和运行所有东西。

 	阅读您所选择的语言的所有合约，而不仅仅是3份
 	还要阅读其他语言的所有合约。
 	看看下面这些小的挑战，您可能会在它们中获得乐趣

 	Scavenger Hunt Challenge #1
 	Scavenger Hunt Challenge #2



📙 深入探索
如果您感到无所畏惧，那么您可能会在一天中做完这些

 	查看所有核心合约 和观看相关的在线合约评价视频
 	查看Illia的合约仓库
 	查看所有的Rainbow Hackathon的合约提交




没人人比我们所有人加到一起更聪明。

– 肯尼斯·布兰查德



并不是我很聪明，我只是和问题相处得比较久一点。

– 爱因斯坦



🎯 资源
请记住：对于今天的活动

 	您无需编译和测试每个合约
 	您无需了解每一行代码
 	您应该像欣赏艺术品或听音乐一样自在地阅读合约，而不必担心每笔着色或者每个音符

AssemblyScript
如果您打算专注于AssemblyScript，请打开AssemblyScript合约列表

您应该至少阅读3份标记为CORE Activity的合约。


Rust
如果您打算专注于Rust，请打开Rust合约列表

您应该至少阅读3份标记为CORE Activity的合约。

您可以阅读更多有关Rust合约的基础知识，也可以选择观看视频以了解Rust合约。




 

### 第 1 步 - 认识 web3 - NEAR 认证开发者（一级）

第 1 步 - 认识 web3 - NEAR 认证开发者（一级）
学会在更大的历史背景下理解当下正在发生的事情



✨ 我们的目标是学会看清我们现在生活的这个新世界✨



请在步骤1之前尽可能多地完成这些核心活动。你完成的越多，你越清楚我们接下来一起要经历怎样的旅程。如果你准备得更充分，接下来的学习体验也会更有趣。

祝你好运，享受学习的快乐吧!
📗 核心活动
⛏️ 做一做 (~1 小时)

 	[ 10 分钟 ] 阅读并通过测验 什么是NEAR 指导
 	[ 30 分钟 ] 浏览 NEAR大学网页

 	NEAR概述
 	NEAR学院
 	Figment Learn Pathway



🙈 看一看 (~10 小时 @ 1倍速)

 	[ 40 分钟 ] 历史情景下的P2P货币 Context
 	[ 60 分钟 ] 比特币和即将到来的基础设施反转
 	[ 35 分钟 ] 金钱作为一种内容类型和科技大拱门
 	[ 50 分钟 ] 应用:今天和2025年
 	[ 90 分钟 ] NEAR 101

 	浏览PPT
 	观看录播


 	[ 4.5 小时 ] 通证经济学系列

🙉 听一听 (~4 小时 @ 1倍速)

 	[ 60 分钟 ] 比特币史前史和密码朋克
 	[ 90 分钟 ] 比特币的历史
 	[ 90 分钟 ] Altcoins, 一段失败的历史

📘 奖励活动
如果你有时间四处转转，这里还有一些小玩意给你。

📜 读一读

 	比特币就是时间
 	比特币：一种点对点电子现金系统
 	以太坊黄皮书
 	nakamotoinstitute.org Literature上的任何资料




换一个角度思考，等于增加80点智商

 	艾伦·凯 (Alan Kay)




充满热情，等于增加25点智商

 	来自一名老师

### 介绍 - NEAR认证开发者（一级）

第一步
请尽快完成以下内容 加入社区并和我们的活动保持一致，这将帮助我们共同获得成功。

请马上

 	加入我们专属的微信群和Discord群组

 	加入微信群：添加 NearKat 的微信（账号：yanMsrr），并说明想要加入 "NEAR课程群";
 	加入Discord：使用此邀请链接 https://discord.gg/BHRZFbCVcS ;
 	在群组里，使用您的 NEAR 帐户作为微信群名片 和 Discord 名称 – YourName.NEAR


 	关注Twitter上的Learn NEAR：https://twitter.com/LearnNear
 	创建一个测试网账户 – YourName.testnet – https://wallet.testnet.near.org/

NEAR认证开发者
本课程为Web开发者提供了一个获得结业证书的机会，该证书代表了在 NEAR 平台上设计、开发、测试和部署智能合约的能力。
欢迎
很高兴你能加入我们。我们将共同学习在智能合约平台NEAR上构建去中心化的应用程序。

这个报告介绍了截至2020年12月，这些所谓的“一层”平台在行业中的情况。研究清楚地表明：NEAR在开发者心目中占有一席之地。

这是一门 NEAR L2E（Learn-to-Earn）课程，也就是说：我们付钱让您完成课程。
在开始第一步之前
在本周开始之前,请先确保您熟悉一些基础知识。尽管您不需要成为这些技术的专家，但您需要会克隆 NodeJS 项目、下载其依赖的库，并运行一些脚本。

 	基本的 JavaScript 客户端和服务器端开发（见这里和这里)
 	基本终端控制（见这里和这里）
 	基本的 git 命令（见这里和这里）。

概述
在本课程中，我们将练习：

 	在人类历史背景下理解 Web 3
 	阅读用 Rust 和 AssemblyScript 写的合约代码
 	用 Rust 和 AssemblyScript 编写合约
 	用单元测试和模拟测试测试合约
 	部署合约和用户界面

本课程将包括大量的听、看、读和写的内容。 建议每天至少投入2小时，最多可能需要4-6小时，尤其是对于Web开发经验少于三年的开发者。
工作协议

 	我们将在 每月最后一个星期五上午11点（美国东部时间） 举行 60分钟的在线Demo Day
 	我们鼓励您在演示项目中以小组形式工作
 	我们每天都会和我们的小团体见面，共同进步，分享困惑，一起提高！
 	我们同意尽我们最大的能力完成活动
 	我们同意为在月底前 完成演示项目（demo） 而努力

问题
有任何问题，欢迎随时在课程的微信群中提问。

或者如果你更喜欢使用Discord，所有问题可以发布到2个Discord 频道之一：

 	#help 问题反馈：一般问题、日程安排、帐户问题等
 	#step-#（如step-1, step-2等） 课后作业支持，疑难解答，每个步骤的一些相关主题等

作业

 	每个步骤的课程都有附加作业




完成一级课程后，你还可以参与：

 	NEAR认证开发者（二级）：测试网项目 ，目标是“让您的web3应用程序在NEAR 测试网上拥有100个用户”
 	NEAR认证开发者（二级）：贡献者，目标是开始参与 NEAR 生态项目开发
 	作为我们社区的新成员，冒险仍将继续

课程录像
所有公开可用的录像都将在活动结束后的 24-48 小时内发布在这里。

第 1 期：2021年2月22日 - 2月26日

 	第 1 天 - 欢迎和启动幻灯片和录像
 	第 5 天 - 项目演示录像

第 2 期：2021年3月8日 - 3月12日

 	第 1 天 - 欢迎和启动幻灯片和录像
 	第 5 天 - 项目演示录像

第 3 期：2021年3月22日 - 3月26日

 	第 1 天 - 欢迎和启动幻灯片和录像
 	第 5 天 - 项目演示录像

第 4 期：2021年4月5日 - 4月9日

 	第 1 天 - 欢迎和启动幻灯片和录像
 	第 5 天 - 项目演示录像

第 5 期：2021年4月19日 - 4月23日

 	第 5 天 - 项目演示录像

第 6 期：

 	第 5 天 - 项目演示录像

常见问题
1. 这个要多少钱？

并不收费，事实上我们付钱给你完成这门课程。

2. 我是否需要成为软件开发者才能参加本课程？

不需要，但也不是那么容易，你应该预计每天花 10 小时，不是开玩笑。

 	如果您是刚从培训机构毕业或拥有不到 3 年专业经验的初级软件开发者，您应该预计每天花 4-6 小时。
 	如果您是具有 5 年或以上专业经验的高级软件开发者，则每天应该预计花大约 2-4 小时。
 	如果您是一位经验丰富的区块链开发者，那么您每天工作大约 1 小时就可以跟上本课程的进度。

3. 我需要 Mac 吗？

MacOS 和 Linux 的开发体验最佳。 使用Windows可能具有挑战性，但如果您愿意尝试，请加入我们！

4. 我怎么知道我是否胜出？

在这里我们不计输赢。欢迎加入。

5. 币价什么时候涨上天？！

请不要问这种问题

6. 你介意我作弊吗？

不，实际上我们鼓励作弊。让我们弄清楚一件事：如果你认真学习，那么有所收获的最快方法就是与其他人交流、提出问题、找到答案、找到更多答案、复制示例代码、打破常规，最后，如果幸运的话，你会学到一些新东西。

只要您对自己所做的事情诚实，这里永远欢迎您。

但是不要把他人的工作占为己有，因为那是蹩脚的。

7. 我还有一百个问题

太棒了。这里有一份真正的常见问题



NCDL1注册

姓名 *

首先，你叫什么名字？

电子邮件 *

我们应该使用哪个电子邮件地址与您联系？

母语 *

English

中文

Русский

Tiếng Việt

其他

GitHub *

您的 GitHub 个人资料网址

角色*

酷，作为 NEAR 社区的一部分，您将扮演什么角色？

我将成为应用程序开发者

我是机器人

我将成为核心贡献者

我将成为一名非技术型企业家

其他

技术

告诉我们您的技术经验

JavaScript 全栈

前端

后端

Rust 开发者

其他

NEAR帐户*

项目演示时间*

选择适合你的演示时间 - 该月的最后一个星期五 - 您必须使用 NEAR 开发并交付简单的演示项目



                
                        
                            NCD Registration
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Native Language*
			
				
				English
			
			
				
				Chinese
			
			
				
				Russian
			
			
				
				Vietnamese
			
			
				
				Korean
			
			
				
				
			Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account*

### Введение в Раст

Скачать презентацию (PDF)
Полезные ссылки:

 	Официальный сайт - https://www.rust-lang.org/
 	Как установить - https://www.rust-lang.org/tools/install
 	Электронная книга на Английском - https://doc.rust-lang.org/book/
 	Электронная книга на Русcком - https://doc.rust-lang.ru/book
 	Стандартная библиотека - https://doc.rust-lang.org/std/

 

### Step



### Bước 6: Demo ứng dụng của bạn - NEAR Certificated Developer (NCD)

Chúng ta đã qua những hướng dẫn về việc xây dựng, kiểm thử và triển khai smart contract trên NEAR. Tiếp theo đây sẽ là thời gian bạn thực sự xây dựng một ứng dụng của riêng mình! 
Xây dựng ứng dụng Web3 của bạn
Trong phần này, bạn sẽ cần:

Lựa chọn cho mình một ý tưởng về ứng dụng Web3
Xây dựng smart contract
Kiểm thử và deploy smart contract lên testnet
Kết nối với frontend

Trình bày ứng dụng trong DEMO Day
Và cuối cùng, mục đích chính trong phần này là trình bày kết quả công việc của bạn cho người khác.



Bạn hãy chuẩn bị toàn bộ phần trình bày của bạn với slide hoặc video
Trình bày và demo về ứng dụng của bạn trong 5-10 phút với team LNC và NEAR Vietnam Hub vào thứ 6 (Lịch cụ thể team sẽ trao đổi trong nhóm Discord).
Chúc mừng bạn đã thực hiện tốt chương trình học của mình, welcome bạn đã tới đây! Happy BUIDLing! 




Thảo luận, nhận hỗ trợ tại các kênh xã hội của chúng tôi 

Tham gia vào kênh Discord của NEAR Vietnam Developer:Thảo luận, nhận hỗ trợ bằng tiếng Việt tại kênh Discord: https://discord.gg/brxxhdQc2Z
Follow Twitter của Learn NEAR : https://twitter.com/LearnNear
Follow Twitter của NEAR Việt Nam Hub: https://twitter.com/NearVietnamHub
Tham gia group telegram của LearnNEAR Club: https://t.me/LearnNEARClub
Tham gia group Telegram của NEAR Vietnam Developer: https://t.me/neardev_vncommuity 

### Bước 5: Triển khai ứng dụng Web3 - NEAR Certificated Developer

Chúng ta đã trải qua rất nhiều các bước để phát triển và kiểm thử smart contract. Giờ là lúc deploy chúng lên network để những người dùng khác có thể sử dụng smart contract của bạn.

Hiện tại NEAR có nhiều network khác nhau, một trong số chúng là:

 	mainnet
 	testnet

Trong bài này, LNC sẽ hướng dẫn bạn các deploy một smart contract lên mạng NEAR testnet, việc deploy smart contract lên mainnet cũng sẽ tương tự.
Triển khai smart contract lên testnet
Đầu tiên, bạn cần phải đảm bảo near-cli đã sẵn sàng trên máy tính của bạn với câu lệnh:
$ near --version

Bước 1: Build smart contract

NEAR sử dụng wasm cho smart contract của mình, vì vậy trước khi triển khai smart contract bạn cần build ra file .wasm. Trở lại với project counter contract LNC đã hướng dẫn bạn xây dựng trong những bài trước, để build smart contract bạn dùng lệnh:
$ npm run build:contract

Sau khi build thành công, bạn sẽ thấy file /contract/build/contract.wasm trong project của mình.

Bước 2: Deploy contract lên testnet

Với testnet, NEAR hỗ trợ 2 cách để deploy smart contract:

 	near dev-deploy: Tự động tạo một account dev và deploy smart contract lên đó, dùng cho việc deploy và test nhanh smart contract trên testnet
 	near deploy: Deploy lên một account mà bạn đã tạo từ trước


 	near dev-deploy

Câu lệnh:
$ near dev-deploy <route_to_wasm>

Trong project hướng dẫn, chúng ta có file /contract/build/contract.wasm được build trước đó. Bạn có thể chạy câu lệnh:
$ near dev-deploy contract/build/contract.wasm

NEAR sẽ tự động tạo account dev và deploy smart contract của bạn lên đó.



Ở đây contract đã được deploy lên account dev-1667173869138-29253364925009

 	near deploy

Với near deploy, smart contract sẽ deploy lên một account cụ thể. Để có thể thực hiện được, đầu tiên bạn cần đăng nhập trên near-cli
$ near login

Chọn account bạn muốn đăng nhập trên ví NEAR



Ở đây, LNC chọn account nearvietnamhub.testnet

Tạo sub account cho contract
$ near create-account <sub account> --masterAccount <master account> --initialBalance 5

Sub Account là một tài khoản được tạo bởi tài khoản chính, như một phần bổ sung cho tài khoản chính. Tuy nhiên Sub Account vẫn sẽ là một account độc lập, không bị quản lý bởi tài khoản chính.
Vd: example.nearvietnamhub.testnet, nft.nearvietnamhub.testnet, counter.nearvietnamhub.testnet v…v



Tạo sub account thành công và thực hiện deploy contract với câu lệnh:
$ near deploy <accountId> <route_to_wasm>



Deploy thành công contract lên sub account: counter.nearvietnamhub.testnet
Tương tác với smart contract qua near-cli
near-cli có 2 methods để tương tác với smart contract:

View methods

View methods là phương thức gọi đến function view của contract
$ near view <contractId> <methodName>

Chúng ta có thể test thử với counter contract



Call methods

Call methods những phương thức thực hiện cả thao tác đọc và ghi. Đối với những phương thức này, chúng ta cần chỉ định tài khoản đang được sử dụng để thực hiện call, vì tài khoản đó sẽ sử dụng để tính phí GAS cho giao dịch.
$ near call <contractId> <methodName> <jsonArgs> --accountId <yourAccount> [--deposit <amount>] [--gas <GAS>]

Vd:



Sau khi thực hiện thành công, chúng ta kiểm tra lại number



number đã tăng lên một đơn vị.
Hoạt động bổ sung
Bạn có thể tiếp tục các hoạt động sau để hiểu sâu hơn cách triển khai smart contract trên NEAR:

 	Build và deploy các contract đã đọc ở Bước 2
 	Thực hiện gọi các function còn lại của counter contract

Tài nguyên:

 	Deploy smart contract: https://docs.near.org/develop/deploy
 	NEAR CLI: https://docs.near.org/tools/near-cli

 

### Bước 4: Kiểm thử ứng dụng Web3 - NEAR Certificated Developer

Trong quá trình phát triển smart contract, bạn sẽ muốn kiểm tra xem các chức năng có hoạt động đúng như mong đợi hay không và hơn thế nữa, contract có hoạt động một cách an toàn hay không. NEAR đã phát triển các công cụ để kiểm thử đáp ứng những nhu cầu trên cho bạn.

Về cơ bản, sẽ có hai loại kiểm thử bạn có thể thực hiện:

 	Unit Tests để test các tính năng riêng lẻ, được viết bằng chính ngôn ngữ lập trình của smart contract và thực thi tại local.
 	Integration Tests để kiểm tra cách smart contract của bạn hoạt động trong môi trường thực tế. Bạn có thể viết integration tests với Rust hoặc Javascript (Typescript). Integrations test thường sẽ thực hiện trong Sandbox hoặc mạng NEAR testnet.

Để chắc chắn smart contract có thể hoạt động tốt trong môi trường thực tế, LNC khuyên bạn nên thực hiện cả hai loại tests. Mỗi loại đều phù hợp để phát hiện ra các loại lỗi khác nhau trong quá trình smart contract hoạt động.
Kiểm thử smart contract
Quay trở lại với counter smart contract mà LNC đã hướng dẫn bạn xây dựng trong phần trước. Trong bài này, LNC sẽ hướng dẫn bạn cách viết tests cho chính contract này. Chúng ta cùng bắt đầu nhé.
Bước 1: Review cấu hình và setup ban đầu cho việc kiểm thử
Bạn truy cập file /integration-tests/src/main.ava.ts



Ở đây, LNC đã cấu hình sẵn cho việc kiểm thử. Chúng ta cùng duyệt qua một vài thông tin chính:

 	test khai báo một test module với Worker sandbox và lưu trữ 1 danh sách accounts sẽ thực hiện cho việc test trong context.
 	Chúng ta sẽ có test.berforeEach() thực hiện trước khi bắt đầu test và test.afterEach() thực hiện sau khi test.
 	Bạn sẽ cần chú ý nhiều hơn đến test.beforeEach(). Ở đây, LNC khai báo init Worker, tạo sub account từ root và deploy contract lên account này. Việc thực hiện sẽ giống như trong môi trường testnet, mainnet, vì vậy bạn có thể biết chính xác smart contract của mình hoạt động như nào trên thực tế.

Bước 2: Viết test các chức năng

 	Lấy giá trị ban đầu của number



Contract đánh dấu get_number là view function, vì vậy ở đây chúng ta gọi view từ contract.

 	Tăng và giảm giá trị của number





Với increase_number, decrease_number, bạn cần thực hiện dùng một account để call đến contract.

 	Test người dùng deposit NEAR vào contract



 	Test private function



Do private function chỉ cho phép chính tài khoản lưu contract gọi. Vì vậy ở đây chúng ta thay đổi từ root sang contract.

Toàn bộ souce code cho phần tests bạn có thể kiểm tra [ ở đây ]

Bước 3. Thực hiện kiểm thử

Thực hiện test với câu lệnh
$ npm run build:contract && npm run test

Và kết quả:


Hoạt động bổ sung
Để hiểu rõ hơn về tests bạn có thể thực hiện thêm các yêu cầu sau:

 	Viết thêm tests với các trường hợp xảy ra lỗi trong contract
 	Đọc hiểu thêm về module tests trong các contract đã đọc ở bài 2 của NEAR Certificated Developer level 1
 	Viết thêm unit tests, integration tests cho các contract bạn đã đọc trong bài 2 của NEAR Certificated Developer level 1
 	Viết tests bằng Rust theo hướng dẫn [ Tại đây ]

Tài nguyên

 	NEAR Unit tests: https://docs.near.org/develop/testing/unit-test
 	NEAR Integration tests: https://docs.near.org/develop/testing/integration-test

### Bước 3: Viết ứng dụng Web3 - NEAR Certificated Developer

Qua các bài học trước đây, chắc hẳn bạn cũng đang rất muốn biết làm sao để có thể xây dựng được ứng dụng Web3 của mình trên NEAR. Không để bạn chờ lâu, chúng ta cùng bắt đầu ngay nhé!
Để bạn dễ tiếp cận hơn, trong bài này LNC sẽ hướng dẫn bạn xây dựng smart contract với ngôn ngữ lập trình Javascript (Typescript) - một ngôn ngữ lập trình rất phổ biến hiện nay.
Cài đặt môi trường
Trước khi bắt đầu, máy tính của bạn cần phải sẵn sàng với đầy đủ môi trường và công cụ phục vụ cho việc xây dựng smart contract trên NEAR:

 	Git: https://git-scm.com/
 	NodeJs và npm: https://nodejs.org/en/
 	NEAR CLI: https://github.com/near/near-cli
 	Visual Studio Code: https://code.visualstudio.com/
 	Tạo một ví NEAR testnet: https://wallet.testnet.near.org/

Để chắc chắn mọi thứ đã sẵn sàng, bạn hãy kiểm tra với các câu lệnh:
$ git --version
$ node -v
$ npm -v
$ near --version

Clone template project
Ở đây, LNC đã tạo sẵn một template để bạn có thể bắt đầu ngay vào việc code smart contract thay vì phải cấu hình những thông số, thư viện phức tạp.
$ git clone <https://github.com/nearvndev/near-ts-template.git>
$ cd near-ts-template && npm install

Cấu trúc project template
Project template đã chia làm các project nhỏ hơn:

 	/contract Project cho smart contract
 	/frontend Project reactjs cho frontend
 	/integration-tests Project thực hiện integration tests

Trong bài hôm nay, chúng ta sẽ tập trung vào việc xây dựng smart contract. Vì vậy bạn hãy chú ý đến folder /contract nhiều hơn nhé.
Hướng dẫn xây dựng smart contract trên NEAR
Để có thể bạn có thể bắt đầu xây dựng smart contract trên NEAR một cách đơn giản nhất, LNC sẽ hướng dẫn bạn xây dựng một counter smart contract với những chức năng đơn giản sau:

 	Smart contract khởi đầu với 1 số nguyên bằng 0
 	Cho phép user có thể lấy giá trị của số hiện tại
 	Cho phép user có thể tăng, giảm giá trị của số hiện tại
 	Cho phép owner của contract có thể reset lại số về 0
 	Và nhiều tính năng thú vị khác nữa…

Bước 1: Tìm hiểu về class Contract

Bạn hãy mở near-ts-template với Visual Studio Code và truy cập file /contract/src/contract.ts



Ở đây chúng ta có:

 	NearBindgen: Dùng để đánh dấu đây là class chính cho smart contract, khác với những class khác trong project.
 	call, view, near: được import sẵn từ SDK cho các chức năng của smart contract

Bước 2: Khởi tạo state của contract

Khai báo một property num = 0, có kiểu dữ liệu Number trong Contract.



Bước 3: Xây dựng các chức năng

View, Call function:



Ở đây chúng ta có 3 function mới get_number, increase_number, decrease_number

 	get_number: Đây là một hàm chỉ lấy data từ contract mà không thay đổi gì cả, vì vậy nó được đánh dầu bởi @view({})
 	increase_number, decrease_number: Thay đổi data trong contract vì vậy chúng ta cần đánh dấu nó với @call({}). Với call function, khi gọi sẽ cần ký bởi account của người dùng, vì vậy chúng ta có thể lấy được accountId này thông qua near.predecessorAccountId() hoặc near.singerAccountId()

Private function:

Vậy nếu tôi muốn có một function chỉ cho phép owner của contract gọi thì sao?

Rất đơn giản, chúng ta chỉ cần đánh dấu function với @call({privateFunction: true})

Vd: Ở đây chúng ta có thêm function reset_number



Payable function:

Để người dùng có thể deposit NEAR vào contract cho các nghiệp vụ như donate, mua NFT hoặc thanh toán v…v. Bạn có thể đánh dấu function với @call({payableFunction: true})

Vd: Ở đây chúng ta có thể khai báo 1 function cho phép deposit NEAR và lấy được số lương NEAR đã deposit của ngời dùng.



Sau khi xây dựng hết các chức năng, bạn sẽ có một Contract với nội dung: [ Kiểm tra tại đây ]
Build contract
NEAR sử dụng wasm cho contract, vì vậy bạn sẽ cần build contract của mình từ Javascript sang WebAssembly. Cách thực hiện rất đơn giản, bạn hãy chạy câu lệnh:
$ npm run build:contract

Sau khi build thành công, bạn có thể nhìn thấy file /contract/build/contract.wasm trong projects. Đến đây, LNC chúc mừng bạn đã xây dựng được smart contract đầu tiên của mình với NEAR.
Hoạt động bổ sung

 	Bài hướng dẫn tập trung vào xây dựng contract với ngôn ngữ lập trình Javascript, nếu bạn yêu thích Rust hơn, bạn có thể tham khảo hướng dẫn [ tại đây ]
 	Bạn có thể thoả sức sáng tạo bằng cách sửa hoặc viết lại chức năng nào đó của những contract bạn đã đọc trong Bước 2

Tài nguyên
Một vài tài liệu và hướng dẫn để nâng cao kiến thức cho bạn:

 	NEAR Javascript SDK: https://docs.near.org/tools/near-sdk-js
 	NEAR Rust SDK: https://docs.near.org/tools/near-sdk-rs
 	Non-fungible Token: https://nomicon.io/Standards/Tokens/NonFungibleToken/
 	Fungible Token: https://nomicon.io/Standards/Tokens/FungibleToken/
 	Multi Token: https://nomicon.io/Standards/Tokens/MultiToken/

### Bước 2: Đọc hiểu ứng dụng Web3 - NEAR Certificated Developer

Trong phần trước bạn đã tìm hiểu về Web3, kiến trúc ứng dụng Web3 và giới thiệu về Near Protocol. Để chuẩn bị xây dựng ứng dụng Web3 trên Near trong những bài tiếp theo, ở bài này bạn sẽ tập trung vào học cách đọc các contract. Cùng tìm hiểu xem những contract đó quản lý tiền, tài sản, danh tính và quyền sở hữu như thế nào nhé!
Để học tốt bài này
Mục tiêu bài học hôm nay là bạn cố gắng để đọc được nhiều smart contract nhất có thể. Với mỗi contract hoặc project hãy đặt những câu hỏi:

 	Mục đích của contract này là để làm gì?
 	Nó đang được viết như thế nào?
 	Tại sao nó lại được viết như vậy?

Lưu ý:

 	Có rất nhiều contract với các ngôn ngữ lập trình Javascript, Rust, Assembly Script. Bạn hãy chọn ngôn ngữ phù hợp với chính mình nhé.
 	Bạn không cần phải build hay test bất kì contract nào
 	Bạn cũng không cần hiểu toàn bộ từng dòng code
 	Bạn hãy tập trung đọc những gì cơ bản nhất của contract, liên kết nghiệp vụ của contract với những dòng code.

Đến đây, có thể bạn vẫn chưa thực sự hiểu rõ mình nên làm thế nào? bắt đầu từ đâu? Không sao cả, LNC sẽ hướng dẫn bạn cách đọc một project cơ bản nhất nhé!. Chúng ta cùng bắt đầu với…
Hello NEAR projects - Javascript
Github project: https://github.com/nearvndev/hello-near-ts.git

Hello NEAR là một dApps đơn giản dùng để lưu trữ một lời chào lên NEAR và hiển thị cho người dùng. Ứng dụng gồm 2 phần chính:

 	Một smart contract cho phép lưu trữ và thay đổi một lời chào
 	Giao diện web đơn giản hiển thị lời chào và cho phép người dùng thay đổi

Ở đây chúng ta sẽ tập trung vào đọc project Hello NEAR với ngôn ngữ lập trình Javascript.

Cấu trúc của project gồm:

 	Code frontend - ReactJs trong folder /frontend
 	Code smart contract trong folder /contract

Contract
Bạn truy cập vào file /contract/src/contract.ts



Trong contract lúc này có class HelloNear đại diện cho smart contract:

 	Smart contract lưu trữ một biến greeting có giá trị ban đầu là “Hello”
 	Function get_greeting được đánh dấu @view({}), tức là function này chỉ đọc data trong blockchain, hoàn toàn không mất phí giao dịch. get_greeting trả lại giá trị greeting đang lưu trữ.
 	Function set_greeting được đánh dấu @call({}), function thay đổi giá trị đang lưu trữ trên blockchain vì vậy khi gọi function sẽ mất phí giao dịch. set_greeting lưu lại giá trị greeting mới do người dùng nhập vào.

Rất đơn giản đúng không, nhiệm vụ của bạn sẽ là đọc thật nhiều contract nhất có thể trong danh sách dưới đây và hoàn thành bài tập cuối bài nhé!
Hoạt động chính
Đọc hiểu các contract theo ngôn ngữ mà bạn yêu thích, hãy bắt đầu từ những contract cơ bản đến nâng cao nhé:

 	Danh sách contract cơ bản viết bằng Javascript, Rust, Assembly Script: [ List Example Contracts ]
 	Danh sách contract nâng cao viết bằng Assembly Script: [ OPEN the list of AssemblyScript contracts ]
 	Danh sách contract nâng cao viết bằng Rust: [ OPEN the list of Rust contracts ]

### Bước 1: Hiểu về Web 3 - NEAR Certificated Developer

Trước khi bắt đầu với việc học xây dựng ứng dụng Web3 mà ở đây chúng ta sẽ bắt đầu với NEAR Protocol, chúng ta cần hiểu rõ hơn về khái niệm Web3, kiến trúc ứng dụng Web3 và NEAR Protocol.

Mục đích của việc học chính là giúp chúng ta nhìn thấy một thế giới mới, nơi mà chúng ta đang sống và tồn tại. Học cũng sẽ vui hơn nếu bạn có sự chuẩn bị trước đó tốt hơn, vì vậy đừng bỏ qua bước trước đó nhé!

Chúc bạn nhiều may mắn và niềm vui!
Web3 là gì?

Để hình dung rõ hơn về Web3, chúng ta sẽ cùng điểm qua lịch sử với Web1, Web2 nhé.
Web 1.0: Static web
Web 1.0, còn được gọi là Static Web, là internet đầu tiên và đáng tin cậy nhất trong những năm 1990 mặc dù chỉ cung cấp quyền truy cập vào các thông tin hạn chế với ít hoặc không có sự tương tác của người dùng. Trước đây, việc tạo ra các trang người dùng hoặc thậm chí là bình luận trên các bài viết không phải là một việc đáng để làm.

Web 1.0 không có các thuật toán để sàng lọc các trang internet, điều này khiến người dùng vô cùng khó khăn trong việc tìm kiếm các thông tin liên quan. Nói một cách đơn giản, nó giống như đường cao tốc một chiều với lối đi nhỏ hẹp, nơi việc tạo nội dung được thực hiện bởi một số ít người được chọn và thông tin chủ yếu đến từ các thư mục.

Chúng ta có thể liên tưởng đến các sản phẩm Web 1.0 như những trang tin tức, báo chí, blog hiện nay. Nội dung trên các trang này do một người hoặc một tổ chức tạo ra và được tổ chức theo danh mục nội dung để người dùng có thể truy cập dữ liệu.
Web 2.0: Social web và Participative web
Mạng xã hội, hay Web 2.0, đã làm cho internet trở nên có tính tương tác hơn rất nhiều nhờ vào những tiến bộ trong công nghệ web như Javascript, HTML5, CSS3, v.v., cho phép các công ty khởi nghiệp xây dựng nền tảng web tương tác như YouTube, Facebook, Wikipedia và nhiều nền tảng khác nữa.

Điều này đã mở đường phát triển cho cả mạng xã hội và việc sản xuất nội dung do người dùng tạo vì hiện có thể phân phối và chia sẻ dữ liệu giữa các nền tảng và ứng dụng khác nhau.
Web 3.0: Semantic Web
Web 3.0 là giai đoạn tiếp theo của quá trình phát triển web sẽ làm cho internet trở nên thông minh hơn hoặc xử lý thông tin với trí thông minh gần giống con người thông qua sức mạnh của các hệ thống AI có thể chạy các chương trình thông minh để hỗ trợ người dùng.

Tim Berners-Lee đã nói rằng Semantic Web có nghĩa là tương tác "một cách tự động" với các hệ thống, con người và thiết bị gia đình. Như vậy, quá trình tạo nội dung và ra quyết định sẽ có sự tham gia của cả con người và máy móc. Điều này sẽ cho phép tạo ra và phân phối nội dung phù hợp nhất một cách thông minh đến thẳng mọi người dùng internet.
Vậy tại sao ứng dụng Web3 lại cần có blockchain?
Như chúng ta đã biết, ngành công nghệ thông tin phát triển những công nghệ để lưu trữ, quản lý và sử dụng thông tin. AI cần rất nhiều dữ liệu để có thể hỗ trợ người dùng tốt hơn, máy móc cần nhiều thông tin để có thể hiểu nhu cầu của người dùng hơn, phục vụ tốt hơn. Dữ liệu cần được lưu trữ lâu dài, chính xác với dữ liệu gốc để mang lại kiến thức cho các thế hệ tiếp theo v…v

Sẽ thế nào nếu các dữ liệu gốc bị mất hoặc bị chỉnh sửa, bị hack hoặc bị chặn quyền truy cập bởi một tổ chức nào đó dẫn đến các công nghệ Web 3.0 hoạt động sai, làm ảnh hưởng đến trải nghiệm của người dùng?

Vì vậy công nghệ blockchain được phát triển để giải quyết vấn đề này.
Kiến trúc ứng dụng Web 3
Để hiểu hơn về kiến trúc của một ứng dụng Web3, ở đây mình có kiến trúc của cơ bản của ứng dụng Web2. Gồm các phần:

 	Tài khoản người dùng, bảo mật với user name, password, access token v..v
 	Frontend (Web, App, CLI) tương tác với người dùng.
 	Backend (NodeJs, Java Sprint, .Net v..v) xử lý request từ user theo nghiệp vụ và cập nhật dữ liệu vào database.
 	Data được lưu trữ trong database tập trung.



Tương tự với kiến trúc ứng dụng Web3:
Các bạn có thể thấy những điểm tương đồng giữa kiến trúc của ứng dụng Web2 và Web3.

 	Tài khoản người dùng, ở đây là Ví, bảo mật với private key.
 	Có frontend tương tự Web2.
 	Backend là các smart contract.
 	Dữ liệu được lưu trữ và bảo mật bởi blockchain.



 
Chúng ta đã nghe quá nhiều những lời quảng cáo, marketing của các dự án về Web3, đôi khi cũng bị hiểu nhầm ứng dụng Web3 là ứng dụng blockchain. Hi vọng qua những nội dung chia sẻ của LNC về Web3, các bạn đã phần nào hiểu chính xác hơn về Web3 và xây dựng được lộ trình phát triển cho bản thân mình trong lĩnh vực công nghệ này.
Tại NEAR Certificated Developer level 1, LNC sẽ mang đến cho các bạn những kiến thức cơ bản về blockchain, học cách đọc hiểu, xây dựng và phát triển ứng dụng Web3 trên NEAR Protocol. Chúng ta cùng bắt đầu nhé!
NEAR Protocol là gì?
NEAR là một blockchain thân thiện với người dùng và môi trường, được xây dựng để hoạt động hiệu quả, bảo mật và có khả năng mở rộng vô hạn.

Nhắc đến NEAR chúng ta có các keywords:

 	Layer 1
 	Sharded
 	Proof of stake

Tại sao nên xây dựng ứng dụng trên NEAR?

 	Dễ dàng sử dụng

 	NEAR sử dụng tên tài khoản dễ đọc, dễ nhớ…vbidev.near, uit.near
 	Ví web-base, user không cần cài đặt phức tạp
 	Sử dụng nhiều keys để cấp quyền ứng dụng


 	Nhanh và thân thiện với môi trường

 	Tốc độ xử lý giao dịch ~1s
 	Network được chứng nhận carbon-neutral
 	Năng lượng tiêu thụ trong 3p của Bitcoin bằng một năm của NEAR


 	Thân thiện với lập trình viên

 	Ngôn ngữ lập trình phổ biến Javascript, Rust, Assembly Script
 	Tài liệu đầy đủ cùng với rất nhiều example cho từng loại ứng dụng
 	30% phí giao dịch trả lại cho developer
 	Grants program 800M$



Tài liệu bổ sung:
Qua bài học này, chúng ta đã phần nào hiểu rõ hơn về Web3 và Near protocol. Để có thể hiểu sâu hơn về công nghệ blockchain, web3 và Near, LNC khuyến khích bạn đọc thêm các tài liệu sau:

 	NEAR là gì?
 	Cơ bản về Web3 và NEAR.
 	Figment Learn Pathway
 	NEAR 101

Và một vài kiến thức liên quan khác:

 	Token Economic series
 	The history of Bitcoin
 	Mastering Bitcoin
 	Ethereum Yellow Paper
 	Mastering Ethereum

### Giới thiệu - Chứng chỉ nhà phát triển NEAR (NCD)

Để LearnNEARClub và Near Vietnam Hub có thể hỗ trợ bạn trong quá trình học và xây dựng project demo cuối khoá, bạn hay tham gia cùng chúng tôi ngay từ bây giờ nhé!
Bước đầu tiên:

 	Tham gia vào kênh Discord của NEAR Vietnam Developer:
Thảo luận, nhận hỗ trợ bằng tiếng Việt tại kênh Discord: https://discord.gg/brxxhdQc2Z
 	Follow Twitter của Learn NEAR : https://twitter.com/LearnNear
 	Follow Twitter của NEAR Việt Nam Hub: https://twitter.com/NearVietnamHub
 	Tham gia group telegram của LearnNEAR Club: https://t.me/LearnNEARClub
 	Tạo ví testnet ở link sau: YourName.testnet – https://wallet.testnet.near.org/

NEAR Certified Developer
Khóa học này là cơ hội để các lập trình viên web có thể nhận được chứng chỉ sau khi hoàn thành khóa học. Thông quan việc bạn có khả năng thiết kế, lập trình, kiểm thử, deploy smart contracts trên nền tảng NEAR.
Trước khi bắt đầu
Trước khi bắt đầu khóa học, bạn cần phải trang bị những kiến thức cơ bản liên quan dưới đây, có thể tham khảo, không bắt buộc:

 	JavaScript client and server side cơ bản (Tham khảo here and here)
 	Sử dụng cơ bản terminal control (Tham khảo here and here )
 	Biết sử dụng git commands (Tham khảo here and here).

Tổng quát
Trong khóa học này chúng ta sẽ thực hiện:

 	Nhận thức về web3 trong bối cảnh lịch sử phát triển blockchain.
 	Đọc hiểu về code của của contract Javascript, Rust và AssemblyScript (AS).
 	Lập trình contract sử dụng Javascript, Rust và AS
 	Kiểm thử contract bằng việc Unit tests và Integration tests
 	Deploy contract và tương tác với contract

Bạn sẽ cần dành ra ít nhất 2 giờ một ngày, hoặc có thể lên đến 4-6 giờ phụ thuộc vào kinh nghiệm lập trình của bạn.
Điều khoản

 	Chúng ta sẽ gặp nhau khoảng 60 phút vào ngày thứ 6 cuối cùng mỗi tháng trong ngày DEMO DAY Live Session.
 	LNC khuyến khích bạn xây dựng project cuối khoá cùng với nhóm của mình.
 	LNC sẽ gặp những nhóm nhỏ hàng ngày để sắp xếp kiểm tra tiến độ, chia sẻ và cổ vũ các bạn thực hành.
 	Chúng ta sẽ đồng ý hoàn thành các hoạt động trong khả năng của mình.
 	Chúng ta đồng ý hoàn thành một project demo vào cuối tháng.

Hỏi đáp và trả lời
Đừng ngại đặt câu hỏi và thảo luận tại channel Discord của NEAR Việt Nam Developer, mục #thảo-luận-chung
FAQ

 	Khóa học này giá trị bao nhiêu ? Đừng quá quan tâm, khóa học này là MIỄN PHÍ và BẠN NHẬN ĐƯỢC THÊM TIỀN KHI HOÀN THÀNH NÓ.
 	Tôi có cần là một kỹ sư phần mềm để có thể tham gia khóa học?  Không cần. Nhưng nó không dễ, bạn sẽ phải bỏ ra 10h một ngày để học để có thể hiểu rõ các kiến thức mà LNC chia sẻ.Bạn sẽ cần bỏ ra 4-6 giờ/ngày nếu bạn là một junior software developer. Bạn sẽ cần bỏ ra 2-4 giờ/ngày nếu bạn là một senior software developerTuy nhiên bạn chỉ cần 1 giờ/ngày nếu bạn là 1 blockchain developer
 	Sử dụng máy tính gì để học ? Nên sử dụng MacOS hoặc Linux, Windows cũng được nhưng sẽ phức tạp hơn chút
 	Khi nào thì tôi biết rằng mình sẽ chiến thắng ? Sẽ không có thắng cuộc, mà chỉ có những kiến thức học được. Bể học là vô biên.
 	Khi nào thì NEAR to the moon? Đừng hỏi. Hãy tập trung vào việc học
 	Bạn có quan tâm tới việc bị cheat không ?
Không, sự thật là chúng tôi cổ vũ nó. Hãy xuất phát từ sự hiếu học, xuất phát từ sự ham học hỏi thì may mắn, thành công sẽ đến với bạn. Chúng tôi hoan nghênh sự có mặt của bạn ở đây. Đừng làm bất cứ điều gì khiến bản thân mình cảm thấy xấu hổ, mất tự tin.
 	Tôi có hàng tỷ câu hỏi thì sao?
Đừng ngại ngùng, Xem thêm ở đây: a real FAQ

### Course Feedback

Please HELP us make this course better - submit your feedback by clicking this button bellow!


                
                        
                            Course feedback
                            
                         
 
                        How did you like the course?*
			
				
				Good
			
			
				
				OK
			
			
				
				Not impressed
			
			
				
				IDK, I am bot
			What did you like MOST?*What did you like LEAST?*CAPTCHA

### Unit Testing

https://youtu.be/H4iiy11N84A

 

You can find more on AssemblyScript tests here(https://github.com/jtenner/as-pect).

### Functions - Calling them from the CLI

https://youtu.be/Hf70sMkI5bo

### Setting up and deploying the smart contract

https://youtu.be/px2AwgMxOOc

 

More about AssemblyScript can be found here (https://www.assemblyscript.org/).

### Functions: Ending the Game

https://youtu.be/UYvo__xvxgs

### Functions: Creating and Joining a Game

https://youtu.be/FMM9G17__W4

### Use case Introduction and Writing your First Class

https://youtu.be/N-RCBPC7_0I

### Part 4 - Test in Prod

If you were able to see your art in the explorer, you've already made the history on Testnet. It's now persistent on chain. The next step is to use it with the real app.
Build for real
Your current contract doesn't actually issue cross-contract calls to berry club, so you need to re-compile it with a compilation feature.

./build_for_real.sh

Now redeploy your contract

./deploy.sh

Game on.
Buy some 🥑
The first thing we'll need is to buy some avocados to draw in the berry club. Your contract has a helper method buy_avocado to do this.

./call.sh buy_avocado '{}'

You should see a log message like this:

	Log [test-12331.testnet]: Purchased 15001.500 Avocado tokens for 50.000 NEAR


50 NEAR is enough to get you 15000 🥑 and this is enough to draw 15000 pixels.
Open Berry Club on the Testnet
test.berryclub.io

You should see a board. It might be messy, because everyone shares the same board. You can login with your testnet account using web-wallet. This will display your name and your avocado balance.

Keep this tab open.
Let's render your art

./call.sh render_art '{}'

You should see it rendered on the board in the browser. You should also see your account ID in the list on the right. If you hover over your account ID in the list, it will highlight your pixels.
Iterate
Now try drawing other primitives by using ./call.sh

Remember, if you modify the code, then you need to recompile and redeploy the contract.

Enjoy!

### Part 3 - Deploy to testnet

Recompile the contract
You've modified the code to fix tests and implemented your art, so we need to rebuild.

./build.sh

Every time you modify code of your contract you may want to recompile the contract. The resulting binary is be located at res/berry_bot.wasm
Deploying the contract
Accounts in NEAR Protocol can also contain one contract. The contract has full access to the account it belongs. But a new transaction can only be initiated by signing this transaction with an access key (this stops Skynet and singularity). A transaction may call a method on the contract by name and pass arguments.

To deploy a contract, we need to issue a transaction. I wrote a convenient script to deploy the contract to your account stored in $ACCOUNT_ID. (All it does is near deploy $ACCOUNT_ID res/berry_bot.wasm)

./deploy.sh

You should see something like this:

Starting deployment. Account id: test-12331.testnet, node: https://rpc.testnet.near.org, helper: https://helper.testnet.near.org, file: res/berry_bot.wasm
Transaction Id 7jxk9ANig8wJ1BqFennJN4pSuVaMn9n3HjaeKfDYfsDY
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/7jxk9ANig8wJ1BqFennJN4pSuVaMn9n3HjaeKfDYfsDY
Done deploying to test-12331.testnet


NOTE: You can re-deploy your contract multiple times, so long as you have access key on the account. Every time you've modified the code and want to change the contract on-chain you need to recompile and redeploy.
Call the contract
To call <METHOD_NAME> on your contract with arguments <ARGS> issue the following command:

near call $ACCOUNT_ID --accountId=$ACCOUNT_ID --gas=300000000000000 <METHOD_NAME> <ARGS>


 	<METHOD_NAME> is a public method name that you want to call from the contract
 	<ARGS> are JSON encoded arguments to the method, e.g. '{"left": 10, "top": 20, "width": 10, "height": 5, "color": 16711680}'

Since bash needs to keep JSON in one string, we recommend to wrap args with ' when passing it, e.g. '{}'

For example to draw you art, you need to call the following:

near call $ACCOUNT_ID --accountId=$ACCOUNT_ID --gas=300000000000000 render_art '{}'

If everything works well, then you should see your art rendered in logs, e.g.:

Scheduling a call: test-12331.testnet.render_art({})
Receipts: B3odJ16wnajwsrUbw2PVZyY2QDCbwFJsTAXvsWTaGGZV, 7FMyKSgszNgGhCBYv7Sg7jVS2b2LzTJ4w8e9T1fTEDWV
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: .................XXXXXXX..........................
	Log [test-12331.testnet]: ..............XXX.......XXX.......................
	Log [test-12331.testnet]: ............XX.............XX.....................
	Log [test-12331.testnet]: ...........X.................X....................
	Log [test-12331.testnet]: ..........X...................X...................
	Log [test-12331.testnet]: .........X.......XXXXXXX.......X..................
	Log [test-12331.testnet]: ........X......XXX.....XXX......X.................
	Log [test-12331.testnet]: .......X......X...........X......X................
	Log [test-12331.testnet]: .......X.....X.............X.....X................
	Log [test-12331.testnet]: ......X.....X...............X.....X...............
	Log [test-12331.testnet]: ......X....X......XXXXX......X....X...............
	Log [test-12331.testnet]: ......X....X.....XX...XX.....X....X...............
	Log [test-12331.testnet]: .....X....XX....X.......X....XX....X..............
	Log [test-12331.testnet]: .....X....X....XX.......XX....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....XX.......XX....X....X..............
	Log [test-12331.testnet]: .....X....XX....X.......X....XX....X..............
	Log [test-12331.testnet]: ......X....X.....XX...XX.....X....X...............
	Log [test-12331.testnet]: ......X....X......XXXXX......X....X...............
	Log [test-12331.testnet]: ......X.....X...............X.....X...............
	Log [test-12331.testnet]: .......X.....X.............X.....X................
	Log [test-12331.testnet]: .......X......X...........X......X................
	Log [test-12331.testnet]: ........X......XXX.....XXX......X.................
	Log [test-12331.testnet]: .........X.......XXXXXXX.......X..................
	Log [test-12331.testnet]: ..........X...................X...................
	Log [test-12331.testnet]: ...........X.................X....................
	Log [test-12331.testnet]: ............XX.............XX.....................
	Log [test-12331.testnet]: ..............XXX.......XXX.......................
	Log [test-12331.testnet]: .................XXXXXXX..........................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
Transaction Id ZWv4Ac2Qqvs8cA1CT1AHE6ovNXUGT7SCuLiDQFmSqv3
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/ZWv4Ac2Qqvs8cA1CT1AHE6ovNXUGT7SCuLiDQFmSqv3
''


You can also click the explorer link to see this on chain, e.g Target

There is a helper script that let you call methods on your contract easier ./call.sh.

./call.sh <METHOD_NAME> <ARGS>

An example of a command to render a red rectangle

./call.sh render_rect '{"left": 10, "top": 20, "width": 10, "height": 5, "color": 16711680}'

Or to render your art

./call.sh render_art '{}'

### Part 2 - Let's draw

In this part you'll need to implement a new method that will draw something complex. To do this, you can use rectangle and circle primitives and later merge them into one image.

Run

./draw_art.sh

You should see a preview of the art. Right now it renders a target with three circles.

00 ..................................................
01 ..................................................
02 ..................................................
03 ..................................................
04 ..................................................
05 .................XXXXXXX..........................
06 ..............XXX.......XXX.......................
07 ............XX.............XX.....................
08 ...........X.................X....................
09 ..........X...................X...................
10 .........X.......XXXXXXX.......X..................
11 ........X......XXX.....XXX......X.................
12 .......X......X...........X......X................
13 .......X.....X.............X.....X................
14 ......X.....X...............X.....X...............
15 ......X....X......XXXXX......X....X...............
16 ......X....X.....XX...XX.....X....X...............
17 .....X....XX....X.......X....XX....X..............
18 .....X....X....XX.......XX....X....X..............
19 .....X....X....X.........X....X....X..............
20 .....X....X....X.........X....X....X..............
21 .....X....X....X.........X....X....X..............
22 .....X....X....XX.......XX....X....X..............
23 .....X....XX....X.......X....XX....X..............
24 ......X....X.....XX...XX.....X....X...............
25 ......X....X......XXXXX......X....X...............
26 ......X.....X...............X.....X...............
27 .......X.....X.............X.....X................
28 .......X......X...........X......X................
29 ........X......XXX.....XXX......X.................
30 .........X.......XXXXXXX.......X..................
31 ..........X...................X...................
32 ...........X.................X....................
33 ............XX.............XX.....................
34 ..............XXX.......XXX.......................
35 .................XXXXXXX..........................
36 ..................................................
37 ..................................................
38 ..................................................
39 ..................................................
40 ..................................................
41 ..................................................
42 ..................................................
43 ..................................................
44 ..................................................
45 ..................................................
46 ..................................................
47 ..................................................
48 ..................................................
49 ..................................................
test art::tests::draw_art ... ok


Now, open file src/art.rs and modify the implementation of method internal_render_art at line 26.

You can draw whatever you want and debug it using ./draw_art.sh. But note, that too many pixels might lead to performance issues.

Once you are satisfied with your art preview, it's time to try it for real.

### Part 1 - Fix my code

Guess what, I made a bunch of errors in the implementation and you need to fix them. Good thing, that I've added unit tests before I broke the code.

Run unit tests

./test.sh

You'll see a failed test. E.g.

running 1 test
test rect::tests::test_rect_complex ... FAILED

failures:

---- rect::tests::test_rect_complex stdout ----

00 ..................................................
01 ..................................................
02 ..................................................
03 .....XXXX.........................................
04 .....XXXX.........................................
05 .....XXXX.........................................
06 .....XXXX.........................................
07 ..................................................
08 ..................................................
09 ..................................................
10 ..................................................
11 ..................................................
12 ..................................................
13 ..................................................
14 ..................................................
15 ..................................................
16 ..................................................
17 ..................................................
18 ..................................................
19 ..................................................
20 ..................................................
21 ..................................................
22 ..................................................
23 ..................................................
24 ..................................................
25 ..................................................
26 ..................................................
27 ..................................................
28 ..................................................
29 ..................................................
30 ..................................................
31 ..................................................
32 ..................................................
33 ..................................................
34 ..................................................
35 ..................................................
36 ..................................................
37 ..................................................
38 ..................................................
39 ..................................................
40 ..................................................
41 ..................................................
42 ..................................................
43 ..................................................
44 ..................................................
45 ..................................................
46 ..................................................
47 ..................................................
48 ..................................................
49 ..................................................
thread 'rect::tests::test_rect_complex' panicked at 'assertion failed: `(left == right)`
  left: `".....XXXX......"`,
 right: `"..............."`: Line 3', src/rect.rs:90:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


It means the test test_rect_complex has failed and the assert at file src/rect.rs line 90 failed. Open the file and try to figure out what went wrong. Once you figured out what is wrong, try rerunning tests.

Repeat the process of fixing the implementation (not tests) to resolve all bugs.

Once all unit tests are fixed, you're ready to move to the part 2.

### Preparation

Please complete the following as soon as possible  It is essential for the success of this program to coordinate our activities and this will help us do just that.
Immediately:
1. Please join us on a dedicated Telegram Group
- Join LNC Official Telegram group to get P2P help and get tips with NEAR

2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear

3. Create a testnet account  - YourName.testnet - https://wallet.testnet.near.org/

4.  Add our Telegram bot to monitor your accounts:
Mainent:  https://t.me/nearwatchbot
Testnet:  https://t.me/LNC_testenet_watcher_bot

Install required tools
NOTE: This process is for Unix-like system, e.g. Linux or Mac OS. Windows installation process is different and covered in README_Windows.md.
Install Rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

Add wasm target to your toolchain:

rustup target add wasm32-unknown-unknown

Install near-cli
See near-cli installation docs
Install git
See installation guide from github.
Prepare workshop repo and verify tools installation
Clone the workshop repository

git clone https://github.com/evgenykuzyakov/workshop
cd workshop

It should clone the repository to a local folder workshop.
Compile the contract

./build.sh

If you have successfully installed Rust and wasm32 target, then ./build.sh should compile the contract into res/berry_bot.wasm.

   Compiling autocfg v1.0.0
   Compiling proc-macro2 v1.0.9
   Compiling unicode-xid v0.2.0
   ...
   Compiling near-vm-logic v2.0.0
   Compiling near-sdk v2.0.0
   Compiling berry-bot v0.1.0 (workshop)
    Finished release [optimized] target(s) in 43.13s


You can check that the contract is present in res/berry_bot.wasm

test res/berry_bot.wasm && echo "OK" || echo "BAD :("

I hope you see OK
Setup NEAR account
Register a new account on testnet.
You can create a new account using NEAR Testnet Wallet It'll create a new account for you on the NEAR Testnet. The full account ID will be something like alice.testnet

As a Security Method for this workshop I'd recommend to use either Recovery Phrase or Email Recovery.
Authorize your account with near-cli
To allow using your account with near-cli you need to login from the terminal.

near login

This should open a new browser tab in the NEAR Testnet web-wallet and ask you give full access to your account. It's fine to do, since we're talking about Testnet account. You'll need access from command line and near-cli for this workshop.

Once you authorized it in the browser, the command line should automatically succeed.

You should see something like this in the console:

Logged in as [ alice.testnet ] with public key [ ed25519:HP3oxy... ] successfully


Store your account ID into local variable
To help with this workshop let's store your account ID into ACCOUNT_ID variable in bash. Replace <YOUR_ACCOUNT_ID> with your actual account ID that you created in the wallet, e.g. alice.testnet.

export ACCOUNT_ID=<YOUR_ACCOUNT_ID>

Verification
Let's verify that you've successfully created the account and added it to near-cli.

Run the following:

near call --accountId=$ACCOUNT_ID workshop.testnet hello

If it succeeded then you've successfully completed your account setup. You should see something like this:

Scheduling a call: workshop.testnet.hello()
Receipt: 5rKUqv4t9JVQryvyfrgrFr8R48iV4sFX7nD56KUv6Vhb
	Log [workshop.testnet]: Hello, test-12331.testnet!
Transaction Id 8D2L4AdhbZ3CqWXMpRURsyqUTNJaBJDcFQsN4W8vU4y7
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/8D2L4AdhbZ3CqWXMpRURsyqUTNJaBJDcFQsN4W8vU4y7
'Hello, test-12331.testnet!'


Congrats!

### Часть 4 - Тестируем в продакшене

Если вы увидели ваш рисунок в block explorer, то вы уже оставили свой отпечаток в истории сети NEAR Protocol testnet. Эти логи теперь сохранены в блокчейне навсегда.

Следующий шаг - нарисовать его в настоящем приложении.
Скомпилируем в продакшен
На самом деле, сейчас ваш смарт-контракт не вызвает методы в смарт-контракте berry club. Чтобы это исправить, нужно перекомпилировать его со специальной compilation feature for_real:

./build_for_real.sh

Теперь обновите смарт-контракт на вашем аккаунте:

./deploy.sh

Поехали!
Купите немного 🥑
Первое, что нужно сделать - это прикупить немного авокадо. Авакадо нужно, чтобы рисовать в контракте berry club. Вызовите вспомогательный метод buy_avocado на вашем смарт-контракте:

./call.sh buy_avocado '{}'

Вы должны увидеть следующее:

	Log [test-12331.testnet]: Purchased 15001.500 Avocado tokens for 50.000 NEAR


50 NEAR достаточно чтобы купить 15000 🥑 и этого хватит чтобы нарисовать 15000 точек.
Откройте Berry Club на Testnet
test.berryclub.io

Вы должны увидеть холст 50x50. Он может быть немного "грязный", потому что на нем рисуют все юзеры (одновременно и по очереди).

Оставьте открытой эту вкладку в браузере.
Нарисуйте ваш рисунок

./call.sh render_art '{}'

Вы должны увидеть его на холсте в браузере, а так же в логах в терминале. А также ваш аккаунт должен появиться в списке справа от холста. Если вы наведете курсор на своq аккаунт в списке, то это должно подсветить и ваш рисунок, и ваши точки.
Конец или нет?
Теперь можете попробовать нарисовать другие примитивы использую ./call.sh

Или можете изменить ваш рисунок в коде и попробовать нарисовать его заного.

ВАЖНО! Помните, если вы изменили код, то его нужно перекомпилировать и добавить заново на аккаунт.

Удачи!


                
                        
                            Course feedback
                            
                         
 
                        How did you like the course?*
			
				
				Good
			
			
				
				OK
			
			
				
				Not impressed
			
			
				
				IDK, I am bot
			What did you like MOST?*What did you like LEAST?*CAPTCHA

### Часть 3 - Запускаем на testnet

Перекомпилируйте смарт контракт
После того как вы исправили код и добавили ваш рисунок, нужно перекомпилировать смарт контракт.

./build.sh

Каждый раз, когда вы изменяете код контракта, вам нужно будет перекомпилировать контракт. Результатом служит код файле res/berry_bot.wasm
Добавляем контракт на аккаунт
Аккаунты в NEAR Protocol также могут содержать смарт контракт. Смарт контракт имеет полный доступ к аккаунту, на котором он расположен. Но новые транзакции могут быть созданы только пользователями, у которых есть ключ доступа к аккаунту (Это останавливает Skynet и сингулярность). Транзакция может вызвать метод на смарт контракте и передать параметры.

Чтобы добавить смарт контракт к аккаунту, нужно создать транзакцию. Я добавил скрипт, который позволяет добавить смарт контракт (или заменить текущий) на ваш аккаунт из переменной $ACCOUNT_ID. (Все что он делает это near deploy $ACCOUNT_ID res/berry_bot.wasm)

./deploy.sh

Вы должны увидеть что-то подобное

Starting deployment. Account id: test-12331.testnet, node: https://rpc.testnet.near.org, helper: https://helper.testnet.near.org, file: res/berry_bot.wasm
Transaction Id 7jxk9ANig8wJ1BqFennJN4pSuVaMn9n3HjaeKfDYfsDY
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/7jxk9ANig8wJ1BqFennJN4pSuVaMn9n3HjaeKfDYfsDY
Done deploying to test-12331.testnet


Смарт контракт можно изменять много раз. Каждый раз когда вы изменили код контракта и хотите изменить его на вашем аккаунте, то его нужно перекомпилировать и добавить к аккаунту заного (используя ./deploy.sh).
Вызов смарт контракта
Чтобы вызвать метод <МЕТОД> на вашем смарт контракте с параметрами <ПАРАМЕТРЫ>, вызовите следующую команду:

near call $ACCOUNT_ID --accountId=$ACCOUNT_ID --gas=300000000000000 <МЕТОД> <ПАРАМЕТРЫ>


 	<МЕТОД> - это публичный метод в коде контракта, объявленный с помощью pub fn
 	<ПАРАМЕТРЫ> - это параметры метода, сериализованные с помощью JSON, например '{"left": 10, "top": 20, "width": 10, "height": 5, "color": 16711680}'

Так как bash должен получить параметры одной строкой, то рекомендуется оборачивать параметры в ', например '{}'

Например, чтобы нарисовать ваш рисунок, нужно вызвать следующее:

near call $ACCOUNT_ID --accountId=$ACCOUNT_ID --gas=300000000000000 render_art '{}'

Если все работает как надо, то вы увидете ваш рисунок в логах, например:

Scheduling a call: test-12331.testnet.render_art({})
Receipts: B3odJ16wnajwsrUbw2PVZyY2QDCbwFJsTAXvsWTaGGZV, 7FMyKSgszNgGhCBYv7Sg7jVS2b2LzTJ4w8e9T1fTEDWV
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: .................XXXXXXX..........................
	Log [test-12331.testnet]: ..............XXX.......XXX.......................
	Log [test-12331.testnet]: ............XX.............XX.....................
	Log [test-12331.testnet]: ...........X.................X....................
	Log [test-12331.testnet]: ..........X...................X...................
	Log [test-12331.testnet]: .........X.......XXXXXXX.......X..................
	Log [test-12331.testnet]: ........X......XXX.....XXX......X.................
	Log [test-12331.testnet]: .......X......X...........X......X................
	Log [test-12331.testnet]: .......X.....X.............X.....X................
	Log [test-12331.testnet]: ......X.....X...............X.....X...............
	Log [test-12331.testnet]: ......X....X......XXXXX......X....X...............
	Log [test-12331.testnet]: ......X....X.....XX...XX.....X....X...............
	Log [test-12331.testnet]: .....X....XX....X.......X....XX....X..............
	Log [test-12331.testnet]: .....X....X....XX.......XX....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....X.........X....X....X..............
	Log [test-12331.testnet]: .....X....X....XX.......XX....X....X..............
	Log [test-12331.testnet]: .....X....XX....X.......X....XX....X..............
	Log [test-12331.testnet]: ......X....X.....XX...XX.....X....X...............
	Log [test-12331.testnet]: ......X....X......XXXXX......X....X...............
	Log [test-12331.testnet]: ......X.....X...............X.....X...............
	Log [test-12331.testnet]: .......X.....X.............X.....X................
	Log [test-12331.testnet]: .......X......X...........X......X................
	Log [test-12331.testnet]: ........X......XXX.....XXX......X.................
	Log [test-12331.testnet]: .........X.......XXXXXXX.......X..................
	Log [test-12331.testnet]: ..........X...................X...................
	Log [test-12331.testnet]: ...........X.................X....................
	Log [test-12331.testnet]: ............XX.............XX.....................
	Log [test-12331.testnet]: ..............XXX.......XXX.......................
	Log [test-12331.testnet]: .................XXXXXXX..........................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
	Log [test-12331.testnet]: ..................................................
Transaction Id ZWv4Ac2Qqvs8cA1CT1AHE6ovNXUGT7SCuLiDQFmSqv3
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/ZWv4Ac2Qqvs8cA1CT1AHE6ovNXUGT7SCuLiDQFmSqv3
''


Можно также посмотреть этот рисунок в block explorer, например Мишень

Чтобы легче вызвать методы я добавил вспомогательный скрипт ./call.sh.

./call.sh <МЕТОД> <ПАРАМЕТРЫ>

Например, команда, чтобы нарисовать красный прямоугольник:

./call.sh render_rect '{"left": 10, "top": 20, "width": 10, "height": 5, "color": 16711680}'

Или команда, чтобы нарисовать ваш рисунок

./call.sh render_art '{}'

### Часть 2 - Порисуем

В этой части вам нужно будет изменить новый метод в смарт контракте, чтобы нарисовать что-то посложнее. Чтобы это сделать, можно использовать примитивы прямоугольника и окружности, а потом соединить их в одну картинку.

Выполните

./draw_art.sh

Вы должны увидеть текстовое изображение вашего рисунка. Сейчас это мишень с тремя окружностями.

00 ..................................................
01 ..................................................
02 ..................................................
03 ..................................................
04 ..................................................
05 .................XXXXXXX..........................
06 ..............XXX.......XXX.......................
07 ............XX.............XX.....................
08 ...........X.................X....................
09 ..........X...................X...................
10 .........X.......XXXXXXX.......X..................
11 ........X......XXX.....XXX......X.................
12 .......X......X...........X......X................
13 .......X.....X.............X.....X................
14 ......X.....X...............X.....X...............
15 ......X....X......XXXXX......X....X...............
16 ......X....X.....XX...XX.....X....X...............
17 .....X....XX....X.......X....XX....X..............
18 .....X....X....XX.......XX....X....X..............
19 .....X....X....X.........X....X....X..............
20 .....X....X....X.........X....X....X..............
21 .....X....X....X.........X....X....X..............
22 .....X....X....XX.......XX....X....X..............
23 .....X....XX....X.......X....XX....X..............
24 ......X....X.....XX...XX.....X....X...............
25 ......X....X......XXXXX......X....X...............
26 ......X.....X...............X.....X...............
27 .......X.....X.............X.....X................
28 .......X......X...........X......X................
29 ........X......XXX.....XXX......X.................
30 .........X.......XXXXXXX.......X..................
31 ..........X...................X...................
32 ...........X.................X....................
33 ............XX.............XX.....................
34 ..............XXX.......XXX.......................
35 .................XXXXXXX..........................
36 ..................................................
37 ..................................................
38 ..................................................
39 ..................................................
40 ..................................................
41 ..................................................
42 ..................................................
43 ..................................................
44 ..................................................
45 ..................................................
46 ..................................................
47 ..................................................
48 ..................................................
49 ..................................................
test art::tests::draw_art ... ok


Откройте файл src/art.rs и измените метод internal_render_art начиная со строки 26.

Можете нарисовать, что хотите и тестировать это, выполняя ./draw_art.sh. Но если вы будете использовать слишком много точек, то это может негативно отразиться на производительности.

Когда вы закончите рисовать в текстовом режиме, то можно будет попробовать это по-настоящему.

### Часть 1 - Баги

Какая неудача! Я сделал пару ошибок пока писал этот смарт контракт, и вам надо их исправить. Плюс в том, что я добавил тесты, которые работают.

Запустите тесты

./test.sh

Вы должны увидеть нерабочий тест, например:

running 1 test
test rect::tests::test_rect_complex ... FAILED

failures:

---- rect::tests::test_rect_complex stdout ----

00 ..................................................
01 ..................................................
02 ..................................................
03 .....XXXX.........................................
04 .....XXXX.........................................
05 .....XXXX.........................................
06 .....XXXX.........................................
07 ..................................................
08 ..................................................
09 ..................................................
10 ..................................................
11 ..................................................
12 ..................................................
13 ..................................................
14 ..................................................
15 ..................................................
16 ..................................................
17 ..................................................
18 ..................................................
19 ..................................................
20 ..................................................
21 ..................................................
22 ..................................................
23 ..................................................
24 ..................................................
25 ..................................................
26 ..................................................
27 ..................................................
28 ..................................................
29 ..................................................
30 ..................................................
31 ..................................................
32 ..................................................
33 ..................................................
34 ..................................................
35 ..................................................
36 ..................................................
37 ..................................................
38 ..................................................
39 ..................................................
40 ..................................................
41 ..................................................
42 ..................................................
43 ..................................................
44 ..................................................
45 ..................................................
46 ..................................................
47 ..................................................
48 ..................................................
49 ..................................................
thread 'rect::tests::test_rect_complex' panicked at 'assertion failed: `(left == right)`
  left: `".....XXXX......"`,
 right: `"..............."`: Line 3', src/rect.rs:90:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


Это значит test_rect_complex не работает. И assert в файле src/rect.rs строка 90 неверный. Откройте этот файл и пропробуйте разобраться, что пошло не так. После того как вы найдете ошибку и исправите ее, перезапустите тесты.

Повторяйте этот процесс, пока не исправите все ошибки в коде (не в тестах).

Как только все ошибки исправлены, и тесты работают, можно переходить к Часть 2.

### Step



### Подготовка

Установка
Описанный процесс походит для систем Unix, например Linux или Mac OS. Процесс установки для Windows описан тут README_Windows.md (на английском).
Установить Rustup:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

Добавить wasm target:

rustup target add wasm32-unknown-unknown

Установить near-cli
Документация по установке на английском: near-cli installation docs

Если npm уже установлена, то можно установить near-cli:

npm install -g near-cli

Установить git
Документация по установке на английском: installation guide от github.
Подготовка репозитория и проверка установки
Склонируйте репозиторий

git clone https://github.com/evgenykuzyakov/workshop
cd workshop

Это создаст локальную папку workshop.
Скомпилируйте смарт контракт

./build.sh

Если Rust и wasm32 были успешно установлены, то ./build.sh должен скомпилировать контракт в файл res/berry_bot.wasm.

   Compiling autocfg v1.0.0
   Compiling proc-macro2 v1.0.9
   Compiling unicode-xid v0.2.0
   ...
   Compiling near-vm-logic v2.0.0
   Compiling near-sdk v2.0.0
   Compiling berry-bot v0.1.0 (workshop)
    Finished release [optimized] target(s) in 43.13s


Проверим, что файл существует res/berry_bot.wasm

test res/berry_bot.wasm && echo "OK" || echo "BAD :("

Надеюсь это OK
Настройка аккаунта в NEAR
Регистрация нового аккаунта для testnet.
Создайте новый аккаунт используя NEAR Testnet Wallet Web-wallet создаст новый аккаунт на тестовый сети testnet и добавит 200 тестовых NEAR токенов на этот аккаунт. Запомните свой полный account ID, например alice.testnet

В качестве метода восстановления/Security Method для этого семинара рекомендуется использовать Мнемоническую фразу/Recovery Phrase или Электронная почта/Email Recovery.
Авторизуйте свой аккаунт в near-cli
Чтобы использовать свой аккаунт в near-cli, нужно добавить новый ключ в web-wallet:

near login

Это команда откроет новую вкладку в браузере с NEAR Testnet web-wallet и запросит полный доступ/full access к вашему аккаунту. Для этого семинара вам понадобится полный доступ из near-cli.

Как только вы разрешите доступ в браузере, командая строка должна успешно завершиться.

Вы должны увидеть что-то подобное в терминале:

Logged in as [ alice.testnet ] with public key [ ed25519:HP3oxy... ] successfully


Сохраните ваше имя использователя в локальную переменную
Для упрощения, сохраните ваше имя использователя в переменную ACCOUNT_ID в bash. Замените <ИМЯ_ПОЛЬЗОВАТЕЛЯ> на ваше настоящее имя использователя (account ID который вы создали в web-wallet), например alice.testnet.

export ACCOUNT_ID=<ИМЯ_ПОЛЬЗОВАТЕЛЯ>

Проверка
Проверим, что вы успешно создали аккаунт и добавили доступ в near-cli.

Выполните эту команду:

near call --accountId=$ACCOUNT_ID workshop.testnet hello

Вы должны увидеть что-то подобное:

Scheduling a call: workshop.testnet.hello()
Receipt: 5rKUqv4t9JVQryvyfrgrFr8R48iV4sFX7nD56KUv6Vhb
	Log [workshop.testnet]: Hello, test-12331.testnet!
Transaction Id 8D2L4AdhbZ3CqWXMpRURsyqUTNJaBJDcFQsN4W8vU4y7
To see the transaction in the transaction explorer, please open this url in your browser
https://explorer.testnet.near.org/transactions/8D2L4AdhbZ3CqWXMpRURsyqUTNJaBJDcFQsN4W8vU4y7
'Hello, test-12331.testnet!'


Поздравляем!

### NEAR AssemblyScript Contract Deployment

https://youtu.be/Iz2JOUeDunQ

### A NEAR AssemblyScript Contract Walkthrough

https://youtu.be/cEpNYTJ6BrQ

### A sneak peek into the Contract Imports



### Бэрри Бот Семинар - Lesson - 2052



### Бэрри Бот семинар



### Berry Bot семинар

2021-02-05 [RUS] Berry Bot Workshop

### Day 5 - Demo web3  NCDL1C1 Copy



### Day 4 - Deploying web3  NCDL1C1 Copy



### Day 3 - Testing web3  NCDL1C1 Copy



### Day 2 - Writing web 3  NCDL1C1 Copy



### Day 1 - Reading web3  NCDL1C1 Copy



### Days Before Start- Perceiving web  NCDL1C1 Copy



### Course Info  NCDL1C1 Copy



### Dapp/Contract security review Copy

Dapp/Contract security review by NEAR community 

### Collect beta users feedback Copy

Get 100 testnet users
Collect feedback
Polish UX and smart contract update

### Dapp release on Testnet Copy

Dapp release on NEAR testnet

UAT by NCD team

### Smart Contract on Testnet Copy

Deploy smart contract on testnet
Schedule a call with NEAR DevRel engineer for tech consultation if needed

### UX prototype Copy

Create and submit UX diagram for your project.
Schedule weekly 30 min review sessions.

### NCDL2 Contributor Application

Please submit brief info about yourself in the form bellow:



Once done please schedule a call and let's see how LNC can help you: https://calendly.com/sasha-near/30min

### Further Steps after NEAR Certified Developer

If you think your NCD Demo was success and you are willing to bring your project to thousands of users on NEAR Mainnet try to apply

NEAR Fortified Developer accretor program.

OR
You can apply for job at NEAR ecosystem project
Happy (L)Earning!

 

### Step 6 - Demo web3 NEAR Certified Developer

Learn to demonstrate smart contract projects.



 The goal for this Step is to demonstrate your work to others. 




 CORE Activities


 	Capture your demonstration using slides and video
 	Present your work for 5-10 mins to the group on NCD Demo Live session - every last Friday!
 	Celebrate a program well done and welcome to this side of that!

👉 Recommendations:

 	Ideally the project shall be useful for NEAR users and/or other NEAR projects
 	A live Dapp with simple UI/UX is worth more than slides
 	Be ready to go through your code and tests and highlight the most interesting parts
 	DO NOT just fork an NEAR example repo!
 	For refence check other (L)Earners  project at this 📺YT list and GH repos


                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### Step 5 - Deploying web3 NEAR Certified Developer

We have gone through a lot of steps to develop and test smart contracts. Now it's time to deploy them to NEAR blockchain so that other users can use your smart contract.

There are many different networks on NEAR, one of which is:

 	mainnet
 	testnet ✔

In this lesson, LNC will guide you through deploying a smart contract to the NEAR Testnet, deploying a smart contract to the mainnet will also be the same.
Deploy smart contract to testnet
First, you need to make sure the near-cli is ready on your computer with the command:

$ near --version

Step 1: Build smart contract

NEAR uses WASM so before deploying the smart contract you need to build the .wasm file. To build smart contract, use the following command:

$ npm run build:contract

After successful build, you will see the file in /contract/build/contract.wasm.

Step 2: Deploy contract to testnet

In Testnet Network, there are 2 ways to deploy smart contracts:

 	near dev-deploy: Automatically create a dev account and deploy smart contract on it, used for deploying and quickly testing smart contract on testnet
 	near deploy: Deploy to an account you created earlier

Using “near dev-deploy”

Command:

$ near dev-deploy <path_to_wasm_file>

To deploy our contract.wasm, run the following command: 

$ near dev-deploy contract/build/contract.wasm

NEAR will automatically create a random dev account and deploy your smart contract to the testnet.



Here the contract has been deployed to account dev-1667173869138-29253364925009

The account is stored in the .near-credentials folder under your home directory.

Using “near deploy”

With near deploy, smart contract will be deployed to a specific account. You will need sign in the account to near-cli first:

$ near login

On your NEAR Wallet, choose the account you want to sign in to.



In this case, LNC chooses the account nearvietnamhub.testnet

Create a sub account for contract

$ create-account near <sub-account> --masterAccount <master account> --initialBalance 5

Sub-account is an account created by the main account. Subaccount remains as a standalone account, not managed by the main account.

Ex: example.nearvietnamhub.testnet , nft.nearvietnamhub.testnet, counter.nearvietnamhub.testnet etc.



After successfully creating a sub account, deploy the contract with the following command:

$ near deploy <sub-account> <path_to_wasm_file>



Deploy successful contract to sub account: counter.nearvietnamhub.testnet
Interaction with smart contract via near-cli
The near-cli has 2 commands to interact with smart contract:

View command

View command is a method called to view function of contract, which is free to use, and won’t cost any gas:

$ near view <contractId> <methodName>

We can test it with counter contract



Call command

Call command can perform both read and write. For these methods, we need to specify the account that is being used to make the call, as that account will be used to charge gas for the transaction.

$ near call <contractId> <methodName> <jsonArgs> --accountId <yourAccount> [--deposit<amount>] [--gas<GAS>]

e.g.:



After successful execution, check the counter value again



The counter has increased to one.
Extra-activities
To gain a deeper understanding of how to deploy smart contracts on NEAR, you can:

 	Build and deploy contracts you have read in Step 2 of the course
 	Call the remaining functions of counter contract

Resources

 	Deploy smart contract: https://docs.near.org/develop/deploy
 	NEAR CLI: https://docs.near.org/tools/near-cli
 	Call methods have params with NEAR-CLI: https://docs.near.org/tools/near-cli
 	Building a Web frontend for your smart contract: https://docs.near.org/develop/integrate/frontend
 	near-api-js: https://docs.near.org/tools/near-api-js/quick-reference
 	Quickly build apps backed by the NEAR blockchain with create-near-app: https://github.com/near/create-near-app

It’s time to prepare for your demos!

                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### Step 4 - Testing web3  NEAR Certified Developer

You should always verify all functions perform as expected and operate safely. NEAR has developed tools to test and meet these needs for you.

Basically, there are two types of tests you can do:

 	Unit Tests to test individual features are written in the smart contract's programming language and executed locally.
 	Integration Tests to check how your smart contract works in the real environment. You can write integration tests with Rust or JavaScript (Typescript). Integrations Tests will usually be done in Sandbox or NEAR testnet network.

To make sure smart contracts can work well in the real environment, LNC recommends doing both types of tests. Each type is suitable for detecting different types of errors during the smart contract operation.
Smart contract test
Go back to the counter smart contract that LNC instructed you to build in the previous section. In this article, LNC will teach you how to write tests for that contract itself. - Let's begin
Step 1: Review the initial configuration and setup for the test
Access the file /integration-tests/src/main.ava.ts



Let's review some important information:

 	test declares a test module with Worker sandbox and stores a list of accounts that will perform the test in the context.
 	test.berforeEach() function will be executed before we start the test and the test.afterEach() function will be executed after the test.
 	Pay more attention at test.beforeEach(). In this function, LNC declares an init Worker, creates a sub-account from root, and deploys a contract to this account. You will be able to see exactly how your smart contract operates in action because the implementation will be the same whether it is used on the testnet or the mainnet.

Step 2: Write test methods

 	 Get the initial value of number


Get the current counter value with view method get_number.

 	 Increase and decrease the value of number




increase_number, decrease_number are call methods, so you need to use an account to call to the contract.

 	 Test NEAR deposits from user account into the contract


 	 Private function test:



because the private function only allows method call from contract account itself so we use contract.call.
While this works correctly, it is worth to emphasize that usually the `private` function is used as a callback of another function, e.g. `stake()`, rather than be called by the contract account itself directly.


The entire source code for the tests section can be checked [ here ]

 
Step 3. Run the test
Run a test with the command

$ npm run build:contract && npm run test

Result:


Resources

 	NEAR Unit tests: https://docs.near.org/develop/testing/unit-test
 	NEAR Integration tests: https://docs.near.org/develop/testing/integration-test

### Step 3 - Build a Web3 application NEAR Certified Developer

You've shown a strong interest in learning how to build your Web3 application on NEAR in previous lessons. We won't keep you waiting long; let's begin!

To make this article more understandable, LNC will walk you through the process of creating smart contracts using the JavaScript programming language (using Typescript), which is a popular programming language today.
Environment Settings
Before starting, your computer needs to be ready with the full environment and tools for building smart contracts on NEAR:

 	Git: https://git-scm.com/
 	NodeJs and npm: https://nodejs.org/en/
 	NEAR CLI: https://github.com/near/near-cli
 	Visual Studio Code: https://code.visualstudio.com/
 	Create a NEAR testnet wallet: https://testnet.mynearwallet.com/

To make sure everything is ready, check the following command:

$ git --version
$ node -v
$ npm -v
$ near --version

Note: You will need to know how to use the command line first.

Suggested keyword to learn more:  How to use the command line in Windows/ Linux / macOS
Clone template project
At this point, LNC has created a template so that you can start immediately with the code smart contract instead of having to configure complex parameters and libraries.

$ git clone https://github.com/nearvndev/near-ts-template.git

$ cd near-ts-template && npm install

Note: Another way you can use create-near-app to bootstrap a new project! Super easy to use! 
Project template structure
The project template has been divided into smaller projects:

 	/contract - project’s smart contract
 	/frontend - ReactJS frontend
 	/integration-tests -  integration tests

In this lesson, we will focus on building smart contracts. So please pay more attention to the folder /contract.
Instructions for building smart contract on NEAR
LNC will walk you through creating a counter smart contract with the following basic functions to make it as easy as possible for you to begin building smart contracts on NEAR:

 	Counter smart contract starts with an integer equal to 0
 	Allows the user to be able to get the value of the current number
 	Allows the user to increase or decrease the value of the current number
 	Allow the owner of the contract to reset the number to zero
 	And many more exciting features…

Step 1: Learn about the Contract class

Open near-ts-template with Visual Studio Code and go to /contract/src/contract.ts



We have

 	NearBindgen: Used to annotate this as the main class for smart contract, different from other classes in the project.
 	call, view, near: imported from NEAR-SDK-JS to interact with smart contract functions

Step 2: Initialize the contract state

Declare a property num = 0, with data type number in the contract.



Step 3: Build Functions

View, Call function:



We have 3 new functions get_number, increase_number, decrease_number

 	get_number: This is a function that only gets data from the contract without changing anything, so it is annotated with @view({})
 	increase_number, decrease_number: These functions change the data in the contract so we need to annotate it with @call({}). With call function, the call will need to be signed by the user's account, so we can get accountId via near.predecessorAccountId() or near.singerAccountId()

Private function:

So, what if we want a function that only the contract's owner can access?

Really simple, just annotate the function with @call({privateFunction: true})

Ex: we can add the function reset_number which set the counter to 0 and only the contract owner can call this method.



Payable function:

In order to allow users to deposit NEAR to the contract for operations such as donation, purchase NFT or payment, etc. You can mark the function with @call({payableFunction: true})

For example, declare a function that allows users to deposit NEAR and get the amount of NEAR deposited by users.



After building all the functions, you will have a contract with the content: [Check here]
Build contract
NEAR uses WASM for contracts, so you will need to compile the contract code from Javascript to WebAssembly. Very simple, run the following command:

$ npm run build:contract

After the build is completed, Check the file in /contract/build/contract.wasm. 

Congrats! You have successfully created a new NEAR-based smart contract.
Extra-activities

 	View Guest-book JS example - function with params: https://github.com/near-examples/guest-book-js
 	View more dApps example on both Javascript/Rust in https://docs.near.org/tutorials/welcome 
 	Be creative by modifying or rewriting certain functions of the contracts, do whatever you want, #createWithoutLimits

Resource
The tutorial focuses on building contracts with Javascript, if you prefer Rust, you can refer to the tutorial [ here ]

Extra resources and guides to improve your knowledge:

 	NEAR Javascript SDK: https://docs.near.org/tools/near-sdk-js
 	NEAR Rust SDK: https://docs.near.org/tools/near-sdk-rs
 	Non-fungible Token: https://nomicon.io/Standards/Tokens/NonFungibleToken/
 	Fungible Token: https://nomicon.io/Standards/Tokens/FungibleToken/
 	Multi Token: https://nomicon.io/Standards/Tokens/MultiToken/

Rust
If this is your first time using Rust on your computer, please follow this Intro to Rust in our docs. The “3-Step Rust Installation” will help you install the required software.
If you intend to focus on Rust, [ OPEN the list of dApps using Rust ]
You should read a minimum of 3 applications marked as CORE Activity.
You can read more about Rust contract basics as well.


No Contract
It’s possible to build applications with NEAR that do not use a contract.
Here are some examples of these: [ OPEN the list of apps using NO CONTRACT ]

### Step 2 - Reading web3 NEAR Certified Developer

In the previous section, you learned about Web3, the Web3 application architecture, and an overview of the NEAR Protocol. In this lesson, you'll concentrate on mastering contract reading in order to get ready to build Web3 applications on NEAR in the following lessons. Let's find out how those contracts manage money, property, identity, and ownership!
To fully grasp this lesson
The goal of today's lesson is to try to read as many smart contracts as you can. For each contract or project, ask the following questions:

 	What is the purpose of this contract?
 	How is it being written?
 	Why is it written like that?

Caution:

 	With JavaScript/TypeScript and Rust programming languages, there are numerous contracts. Choose a language that suits you.
 	You don't need to build or test any contracts
 	You also don't need to understand the entire code line
 	Focus on reading the most basic parts of the contract and linking the contract's purposes to the code.

You might not fully comprehend what you should do at this point. Where to start? No problem; LNC will show you how to read the most basic project. We begin with
Hello NEAR projects - JavaScript
GitHub project: https://github.com/near-examples/hello-near-js

Hello NEAR is a simple dApp used to store a greeting up close and visible to the user. The application consists of 2 main parts:

 	A smart contract allows you to store and change the greeting
 	Simple web interface that displays greetings and allows users to change

We will focus on reading the project Hello NEAR with Javascript programming language.

The structure of the project includes:

 	Frontend - ReactJs in folder/frontend
 	smart contract code in folder/contract

Contract
Go to file/contract/src/contract.ts

In the contract, there is a HelloNear class representing the smart contract:

 	Smart contract stores a greeting variable whose initial value is “Hello”
 	The get_greeting function is marked @view({}), i.e., it only reads data in the blockchain, with absolutely no transaction fees. get_greeting returns the stored greeting value.
 	The function set_greeting is marked @call(), changing the value stored on the blockchain, so there will be a transaction fee when calling the function. set_greeting stores the new greeting value entered by the user.

Your task will be to read as many contracts as you can from the list below and then finish the final assignment.
More Activity
Read the contracts in your favorite language, starting from the basic ones to the more advanced ones here: https://docs.near.org/tutorials/welcome

### Step 1 - Perceiving web3 - NEAR Certified Developer

Before we start learning how to build a Web3 application with NEAR Protocol, we need to understand better Web3 concepts, Web3 application architecture, and NEAR Protocol.

Learning is meant to open our eyes to the new environment in which we live and function. Don't skip the previous step because better preparation makes it more enjoyable as well.

We wish you much luck and joy!
What is Web3?
To better visualize Web3, we'll go through history together with Web1 and Web2.


Web 1.0: Static web
Web 1.0, also known as the Static Web, was the first and most reliable internet in the 1990s, despite providing only limited access to information with little or no user interaction. Previously, creating user pages or even comments on articles was not a good thing to do.

Web 1.0 does not have algorithms for screening internet pages, which makes it extremely difficult for users to find relevant information. Simply put, it's like a one-way highway with a narrow driveway, where content creation is done by a handful of selected people and information mostly comes from directories.

We can think of Web 1.0 products as news sites, newspapers, or blogs. The content on these pages is created by a person or an organization and organized by content categories so that users can access the data.
Web 2.0: Social Web and Participative Web
Social media, or Web 2.0, has made the internet much more interactive thanks to advances in web technology such as JavaScript, HTML5, CSS3, etc., allowing startups to build interactive web platforms such as YouTube, Facebook, Wikipedia, and more.

This has paved the way for both social networking and the production of user-generated content, which can now distribute and share data between different platforms and applications.
Web 3.0 in blockchain
According to Wikipedia, Web3 in blockchain is distinct from Tim Berners-Lee's 1999 concept for a semantic web.[18] In 2006, Berners-Lee described the semantic web as a component of Web 3.0, which is different from the meaning of Web3 in blockchain contexts.[19]

The term "Web3" was coined by Polkadot founder and Ethereum co-founder Gavin Wood in 2014, referring to a "decentralized online ecosystem based on blockchain."[1] In 2021, the idea of Web3 gained popularity.[20] Particular interest spiked toward the end of 2021, largely due to interest from cryptocurrency enthusiasts and investments from high-profile technologists and companies.[5][6] Executives from venture capital firm Andreessen Horowitz traveled to Washington, D.C., in October 2021 to lobby for the idea as a potential solution to questions about regulation of the web, with which policymakers have been grappling.[21]
So why is blockchain necessary for the Web3 application?
As we know, the information technology industry develops technologies for storing, managing and using information. AI requires a large amount of data to support users more effectively, just as machines require a large amount of data to better understand and meet their needs. To pass on knowledge to future generations, the data should be stored thoroughly, precisely with the original data.

What if the original data is lost or edited, hacked, or access is blocked by an organization, resulting in Web 3.0 technologies misbehaving and compromising the user experience?

So blockchain technology was developed to solve this problem.


Web Application Architecture 3
To better understand the architecture of a Web3 application, here is the architecture of a basic Web2 application. Composed of the following parts:

 	User account, security with username, password, access token, etc.
 	The front end (web, app, or command line interface) interacts with users.
 	The backend (NodeJS, Java, Sprint,.NET, etc.) handle the user's request in accordance with the operation and update the database's data.
 	The data is stored in a centralized database.

Web3 application architecture:

You can see the similarities between the architectures of Web2 and Web3.

 	The user account, Wallet, is secured with a private key.
 	Has a Web2-like front-end.
 	Smart contract in web3 is kind of like Web2’s backend.
 	The data is stored and secured by blockchain.



We've heard far too much promotion and marketing for projects involving Web3, which is occasionally confused with blockchain applications. The information provided by LNC about  Web3 should have helped you comprehend it a little better and create a career path for yourself in this field.

You will learn the fundamentals of blockchain at NEAR Certificated Developer from LNC, along with how to read, build, and develop Web3 applications on NEAR Protocol. - Let's begin
What is NEAR Protocol?
NEAR is a user-friendly and environmentally friendly blockchain designed to be efficient, secure, and infinitely scalable.

Regarding NEAR, here are some important keywords:

 	Layer 1
 	Sharded
 	Proof of stake

Why should I build applications on NEAR?

 	Easy to use 

 	NEAR uses account names that are easy to read and easy to remember such as learn.near, vbidev.near, nearvietnamhub.near
 	Web-based wallet, no complex installation required
 	Use multiple keys to grant application permissions


 	Fast and environmentally friendly 

 	Transactions are processed in about one second.
 	Carbon-Neutral Network certification
 	The energy used by Bitcoin in 3 minutes is equal to a year's worth of NEAR.


 	Developer friendly 

 	Common programming languages include JavaScript and Rust.
 	Complete documentation and numerous examples are provided for each type of application.
 	30% transaction fee returned to the developer
 	$800M Grants Program



Additional Resources:
We now have a slightly better understanding of Web3 and the NEAR Protocol. To gain a deeper understanding of blockchain technology, web3, and NEAR, LNC encourages you to read the following materials:

 	What is NEAR?
 	Web3 and NEAR basics
 	NEAR 101

And some other relevant knowledge:

 	Token Economic series
 	The history of Bitcoin
 	Mastering Bitcoin
 	Ethereum Yellow Paper
 	Mastering Ethereum

### Intro - NEAR Certified Developer

First Steps
Please complete the following as soon as possible  It is essential for the success of this program to coordinate our activities and this will help us do just that.
Immediately:
1. Please join us on a dedicated Telegram group
- Join LNC Official Telegram group to get P2P help and get tips with NEAR
- Connect you LNC profile to LNC Community bot
2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear
3. Create a testnet account  - YourName.testnet - https://testnet.mynearwallet.com/

4. Add our Telegram bot to monitor your accounts:

Mainent:  https://t.me/nearwatchbot

Testnet:  https://t.me/LNC_testenet_watcher_bot

NEAR Certified Developer
This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR protocol

Welcome
Glad you could join us. We will be working together to learn to build decentralized applications on the smart contract platform known as NEAR Protocol.
This is a (L)Earn course, meaning: we pay you to complete the course.

Before Step 1
Please make sure you are familiar with a few of these basics before the week starts. Although you do not need to be an expert in these technologies, you should have no problem cloning a NodeJS project, downloading its dependencies and running a few scripts.


 	Basic JavaScript client and serverside development (see here and here)
 	Basic terminal control (see here and here )
 	Basic git commands (see here and here).

Overview
During this course we will practice:


 	perceiving web 3 in the context of human history
 	reading contract code in Rust and JavaScript
 	writing contracts using Rust and JavaScript
 	testing contracts using unit and simulation tests
 	deploying contracts and a sensible user interface

The course will include lots of listening, watching, reading and writing.
A minimum of 2 hours per day is recommended but up to 4-6 hours per day is likely, especially for developers with less than three years web development experience.

Questions
All questions should be posted to LNC Official Telegram group Tech Dicsussion in to get P2P help and get tips with NEAR

Assignments

 	Assignments are attached to StepN lessons



Next Step


 	NEAR Fortified Developer with a goal "Bring your web3 application on NEAR mainnet" via incubating at LNC Barrel




Recordings
All publicly available recordings will be posted here within 24-48 hours of the event.
Check this YouTube playlist




                
                        
                            NCD Registration
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Native Language*
			
				
				English
			
			
				
				Chinese
			
			
				
				Russian
			
			
				
				Vietnamese
			
			
				
				Korean
			
			
				
				
			Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account*

### Dapp/Contract security review

Dapp/Contract security review by LNC Pro P2P Review

### Collect beta users feedback

Get 100 testnet users
Collect feedback via LNC Pro Beta Test
Polish UX and update smart contract

### Dapp release on Testnet

Dapp release on NEAR testnet

User Acceptance Test by LNC team

### Smart Contract on Testnet

Deploy smart contract on testnet
Schedule a call with NEAR DevRel engineer for tech consultation if needed

### UX prototype

Create and submit UX diagram for your project.
Schedule weekly 30 min review sessions.

### BUILD With NEAR Part-3: Deploy your contract and Write Unit Tests

https://youtu.be/DwtZTf3aNis

### Build with NEAR Part-2: Learn to write your own Smart Contract (AssemblyScript)

https://youtu.be/mDZAI_BqAdg

### Build With NEAR - Introduction and Setting up the NEAR SDK

First Steps
Please complete the following as soon as possible  It is essential for the success of this program to coordinate our activities and this will help us do just that.
Immediately:
1. Please join us on a dedicated Telegram group
- Join LNC Official Telegram group to get P2P help and get tips with NEAR
- Connect you LNC profile to LNC Community bot
2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear
3. Create a testnet account  - YourName.testnet - https://wallet.testnet.near.org/

4. Add our Telegram bot to monitor your accounts:

Mainent:  https://t.me/nearwatchbot

Testnet:  https://t.me/LNC_testenet_watcher_bot
Now, tell us about you:

                
                        
                            Build with NEAR Registration
                            
                         
 
                        Name*First off, what's your name? Email*Which email address should we use to contact you?
                            
                        Native Language*
			
				
				English
			
			
				
				Chinese
			
			
				
				Russian
			
			
				
				Vietnamese
			
			
				
				
			Github*Your GitHub profile url Role*Cool, which role(s) will you play as part of the  NEAR community?
								
								I am bot
							
								
								I will be an application developer
							
								
								I will be a core contributor
							
								
								I will be a non-technical entrepreneur
							
								
								Other
							TechTell us about your technical experience
			
				
				JavaScript Full Stack
			
			
				
				Front End
			
			
				
				Back End
			
			
				
				Rust developer
			
			
				
				
			NEAR Account* PhoneThis field is for validation purposes and should be left unchanged.
          
            
            
            
            
            
            
            
            
            
        
                        
                        

Let's Start
Here is a link where you can find the necessary installation links. 
Ensure that you have installed NEAR CLI as well as the NEAR-SDK-AS. More info​
Here is where you can find the repo that we worked with: Repo​
Here is where you can find the various Collections defined by NEAR which would help with the contracts: https://near.github.io/near-sdk-as/index.html
 

https://youtu.be/zY6RLPC5MHo

 

### Days after NCDL1C6

If you participated in Demo project please Enroll to NEAR Certified Developer Level1 Verified course to schedule an interview and get Certificate on Excellence and included in NEAR Certified Developers directory 


 

### Day 0 - Perceiving web NCDL1C6

Learn to make sense of what is actually going on right now in the larger context of history.




 The goal is to learn to see this new world we are now living in. 


Please complete as many of these core activities as possible before day 1. The more of this you finish, the clearer your picture of our time together will be. Of learning experience will be more fun as well if you are better prepared.
Good luck and have fun!


 CORE Activities

 Something to do (~1 hr)


 	[ 10 mins ] CREATE your first NEAR account
 	[ 30 mins ] REVIEW the NEAR University page

 	NEAR in a Nutshell
 	NEAR Academy
 	Figment Learn Pathway


 	[ 10 mins ] READ “Getting Started” with NEAR 

 Something to see (~10 hrs @ 1x speed)


 	[ 40 mins ] Peer-to-Peer Money in a Historical Context
 	[ 60 mins ] Bitcoin and the coming Infrastructure Inversion
 	[ 35 mins ] Money as a Content Type and the Grand Arc of Technology
 	[ 50 mins ] Applications: Today & 2025
 	[ 90 mins ] NEAR 101

 	Review the slides
 	Watch a recording


 	[ 4.5 hrs ] Token Economics Series

 Something to hear (~4 hrs @ 1x speed)


 	[ 60 mins ] Bitcoin’s Pre-History and the Cypherpunks
 	[ 90 mins ] The History of Bitcoin
 	[ 90 mins ] Altcoins, A History of Failure


 BONUS Activities
If you have the time to look around the corner, here’s a little more for you.


 Something to read


 	Bitcoin is Time
 	Bitcoin: A Peer-to-Peer Electronic Cash System
 	Ethereum Yellow Paper
 	Anything on nakamotoinstitute.org Literature




Perspective is worth 80 IQ points

– Alan Kay



Being enthusiastic is worth 25 IQ points

– a teacher, probably

### Day 5 - Demo web3 NCDL1C6

Learn to demonstrate smart contract projects.



 The goal for today is to demonstrate your work to others. 




 CORE Activities


 	Capture your demonstration using slides and video
 	Present your work for 5-10 mins to the group on Friday
 	Celebrate a week well done and welcome to this side of that!

### Day 4 - Deploying web3 NCDL1C6

Learn to deploy smart contracts to TestNet




 The goal for today is to deploy your contracts and verify they work. 


When we say “application” on NEAR we usually mean software that has been written to define:


 	software that has been written to define

 	(a) on-chain data and behavior controlled by smart contracts (eg. NFT contract)
 	(b) off-chain data and behavior communicating with smart contracts (eg. web app)



We have looked at many contracts and applications this week and now we will deploy them.
Deploying to MainNet is out of scope so we will focus on TestNet and, as bonus activity, LocalNet where you can build in private. Anything that runs on TestNet should work just as well on MainNet. This is the only purpose of TestNet, in fact: to provide a full preview of our work before we take it live on MainNet.


 CORE Activities


 	Reserve your demo spot by completing the form below. You must participate (with a team or by yourself) in the development of a demo to earn a certificate.If your demo is solo (just you) then please fill out the form below with your information. If your demo is team (you and others) then fill out the form below ONLY ONCE and include all the names of people on the team.[ REGISTER for your demo slot ]
To earn your certificate of completion, you MUST deliver a demonstration of your work at the end of this week (tomorrow). If you are not ready for a demo tomorrow then you are welcome to wait until the next time we run this course and deliver a demo on that Friday - Demo Day

 	Watch this orientation video about today’s challenge.
 	Deploy at least one application to TestNet

 	Choose any one (or more) of the contracts and applications you saw on Day 1 and Day 2. It doesn’t matter, when deploying, whether the application is written in Rust or AssemblyScript. All contract code is compiled to WebAssembly and deployed to the network to be run inside a Wasm-compatible virtual machine.
You will use a command like yarn dev for most applications but you can just as easily deploy an application using NEAR CLI with near dev-deploy for TestNet (or near deploy if you have already created an account).


 	Verify the application was deployed

 	Use NEAR Explorer to verify the deployment (find evidence of the deployment to the target account to which the contract was deployed)
 	Use NEAR CLI to issue the command near state <contract-account> and notice that the code_hash is not the default value of all 1s


 	Verify your use of the application

 	Use NEAR Explorer to verify the deployment (find a record of any transactions related to your account or related the target account to which the contract was deployed)




 BONUS Activities
If you have the time to look around the corner, here’s a little more for you.



 	Install nearup and get a local node running. This will include:

 	installing nearup and nearcore prerequisites
 	compiling nearcore (this can take a long while)
 	running nearup with reference to the previously compiled nearcore binary


 	Make sure you read through the nearup documentation (the README of the repository) for details on setup.
 	You will end up with a 4-node LocalNet. To create an account you will have to use one of the node validator keys which you will find in your home directory (below is from MacOS)



This is what the filesystem will look like for your LocalNet keystore

/Users/sherif/.near/localnet
├── node0
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json  <-- open one of these files
├── node1
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json
├── node2
│   ├── config.json
│   ├── data
│   ├── genesis.json
│   ├── node_key.json
│   └── validator_key.json
└── node3
    ├── config.json
    ├── data
    ├── genesis.json
    ├── node_key.json
    └── validator_key.json



 Going Deeper
If you’re feeling fearless, here’s about as far as you might take this road in a day



It’s time to prepare for your demos!

                
                        
                            Demo submission
                            
                         
 
                        
            
            
                        
                            nCaptcha Transaction
                        
                        
                            
                        Project name* Email*
                            
                        Demo Day date*January 31, 2025December 27, 2024January 26, 2024February 26, 2024March 29, 2024December 22, 2023November 24, 2023October  27, 2023September 29, 2023August 25, 2023July 28, 2023June 30, 2023May 26, 2023April 28, 2023March 31, 2023February 17, 2023January 27, 2023December 23, 2022November 25, 2022October 28, 2022September 30, 2022August 26, 2022Project team members*Demo project GitHub Repo*
                    
                Dapp link*
                    
                Link to your live application

### Day 3 - Testing web3  NCDL1C6

Day 3
Testing web 3
Learn to write unit and simulation tests for smart contracts.




 The goal for today is to write tests that pass for your contracts. 




 CORE Activities


 	In the Resources section below choose AssemblyScript or Rust

 	WRITE 3-5 unit tests for each contract listed as CORE Activity




 BONUS Activities
If you have the time to look around the corner, here’s a little more for you.


If you want a few more ideas for this challenge, consider the following:


 	Find a contract that has no unit tests (there are many) and write them
 	Remove some (or all) of the existing unit tests from a contract and rewrite them.
 	Check out this little puzzle, it may be fun for you

 	Scavenger Hunt Challenge #4


 	Start from a blank document (or just boilerplate) and try to test-drive (TDD) a contract.


 Going Deeper
If you’re feeling fearless, here’s about as far as you might take this road in a day


While simulation tests are an evolving work in progress, we do have a few examples which can help you. The key to understanding simulation tests on NEAR is that you’re testing the Wasm binary. This means the same simulation test configuration will work for Rust and AssemblyScript.
In fact, the exact same simulation tests can be used against a compiled Rust or compiled AssemblyScript contract. Maybe this is obvious once you consider that simulation tests are using the same on-chain virtual machine so everything you do in a simulation test should be 1:1 repeatable on-chain.
Heads up, simulation tests must be written in Rust. The examples below will make that clear.


 	NEARly Neighbors has simulation tests
 	Workshop on Cross-contract Calls has simulation tests




What is a new idea — what Satoshi figured out — is how to independently agree upon a history of events without central coordination. He found a way to implement a decentralised timestamping scheme that:

 	a) doesn’t require a time-stamping company or server,
 	b) doesn’t require a newspaper or any other physical medium as proof, and
 	c) can keep the ticks more-or-less constant, even when operating in an environment of ever-faster CPU clock times.

– Gigi in Bitcoin is Time



 Resources
REMEMBER: For today’s activity


 	You DO need to build (and run tests, if available) for each contract
 	You should TRY to understand EVERY line of code in the contract

AssemblyScript
If you intend to focus on AssemblyScript, [ OPEN the list of AssemblyScript contracts ]
For a minimum of 3 contracts marked as CORE Activity


 	a) Write 3-5 new unit tests for each contract whether or not it already has unit tests
 	b) Verify the tests pass as expected (tests can be run via command line)



Unit testing is provided by as-pect and the syntax resembles RSpec. The library is well documented but sometimes the tests for the testing library might be the best source of examples to help you learn quickly.
Almost all of the examples available on near.dev include unit tests.


Rust
If you intend to focus on Rust, [ OPEN the list of Rust contracts ]
For a minimum of 3 contracts marked as CORE Activity


 	a) Write 3-5 new unit tests for each contract whether or not it already has unit tests
 	b) Verify the tests pass as expected (tests can be run via IDE or command line)



Unit testing is included as part of the Rust language.
You can read more about unit tests in Rust by Example or “the book”.
All of NEAR’s Core Contracts include unit tests if you want to see some good examples. You will notice the whitelist contract, for example, includes a test_utils import that sets up the MockedBlockchain context for unit tests in a separate file

### Day 2 - Writing web3 NCDL1C6

Learn to write contracts that control money, identity and ownership.




 The goal for today is to write contracts that compile. 


Make sure you clone every repository and build it locally. Getting each application running is as important as reading the code because today you will be focused on understanding how all the moving parts work.
If you get stuck on one application for some reason, just ask for help in Discord and MOVE ON immediately. If possible, don’t wait for someone to reply before you continue or you will lose time.


 CORE Activities

In the Resources section below choose AssemblyScript or Rust


 	REVIEW all 3 applications labeled as CORE Activity for your language



If you prefer to have specific steps, you could do something like this to study each contract or dApp carefully:


 	Pick any contract from Day 1 (see Day 1 page) or dApp from Day 2 (see below)
 	Clone the repo locally (or in Gitpod if using Windows)
 	Make sure you can find the contract source code and that you can compile the contract to a .wasm file
 	Test the contract somehow so you know it’s working. You can do this using NEAR CLI commands or by running existing unit or simulation tests, or even by using a web interface if the dApp has one. The KEY idea here is to make sure you will NOTICE a change to the contract if you make one
 	Make any small change to the contract. Not a big change, but something simple.
 	Rebuild and retest (repeat steps 3 & 4)
 	Did the change you made work as expected? Or did you break something?
 	Ask for help if you need it
 	Keep repeating 6-7-8 until your confidence increases… until you believe you understand the contract and can control it
 	Delete the contract and write it again from your notes (you took notes right?). You can also just rewrite small parts of the contract, of course.


 BONUS Activities
If you have the time to look around the corner, here’s a little more for you.


The more applications you see, the more ideas you will have about what is possible with NEAR.


 	Read through ALL the applications for your language of choice, not just 3
 	Read through all the applications from the OTHER language as well.
 	Check out this little puzzle, it may be fun for you

 	Scavenger Hunt Challenge #3


 	Write a script in your favorite language that automates some of the tedious bits. You will find some inspiration among the other projects you’ve already seen.

 	compiling a contract
 	deploying (and optionally initializing) a contract
 	exercising contract methods




 Going Deeper
If you’re feeling fearless, here’s about as far as you might take this road in a day


AssemblyScript


 	Complete these challenges in the AssemblyScript workshop

 	#1. scavenger hunt through several AssemblyScript projects
 	#2. debugging challenge to fix a few failing unit tests with broken contracts


 	Complete this challenge then modify the contract in some interesting ways

 	#3. a development lifecycle challenge to guide you through deploying a contract


 	Review some of NEAR’s data “convenience” structures. These are all wrappers for NEAR Storage as seen in docs

 	collections in near-sdk-as
 	collection performance


 	Review Fungible and Non-fungible Token contracts in AssemblyScript

 	FT
 	NFT



Rust


 	Complete this guided workshop on Rust contracts (based on berryclub) to fix failing tests and draw some sweet decentralized pictures
 	Review some of NEAR’s data “convenience” structures. These are all wrappers for NEAR Storage as seen in docs

 	collections in near-sdk-rs
 	collection performance


 	Review Fungible and Non-fungible Token contracts in Rust

 	FT
 	NFT


 	Review berryclub contracts




To call methods, and methods, and methods, signing transactions in this petty pace from day to day, to the last token of recorded block height;

And all our ledgers have hard forked on their way to a dusty death. Out, out, brief consensus!

web 3’s but a walking shadow, a poor player, that struts and frets his hour upon the internet, and then gossips no more.

It is a tale told by a HODLer, full of sound and fury, signifying nothing.

– Willmoon Shakeschain



 Resources
REMEMBER: For today’s activity


 	You DO need to build (and run tests, if available for) each dApp (“decentralized app”)
 	You should TRY to understand EVERY line of code in the contract

AssemblyScript
If you intend to focus on AssemblyScript, [ OPEN the list of dApps using AssemblyScript ]
You should review a minimum of 3 applications marked as CORE Activity.


Rust
If this is your first time using Rust on your computer, please follow this Intro to Rust in our docs. The “3-Step Rust Installation” will help you install the required software.
If you intend to focus on Rust, [ OPEN the list of dApps using Rust ]
You should read a minimum of 3 applications marked as CORE Activity.
You can read more about Rust contract basics as well.


No Contract
It’s possible to build applications with NEAR that do not use a contract.
Here are some examples of these: [ OPEN the list of apps using NO CONTRACT ]

### Day 1 - Reading web3 NCDL1C6

Learn to read contracts that control money, identity and ownership.




 The goal for today is to read as many contracts as you can. 


Sometimes people aren’t sure how to complete this activity. These tips may help.
Consider that it is better to read many times quickly and NOT just one time slowly. Read How to survey? to better understand why and how you can do this
Try to figure out how to get to the contract code. Then move to quickly read the code. You want to see as much as you can. Ask yourself about the “purpose” of the contract (why is it?) and “code” (what is it?)


 	AssemblyScript contracts are files that end in .ts, usually main.ts or index.ts
 	Rust contracts are always in a file named lib.rs.


 CORE Activities


 	In the Resources section below choose AssemblyScript or Rust

 	REVIEW all 3 contracts labeled as CORE Activity for your language




 BONUS Activities
If you have the time to look around the corner, here’s a little more for you.



 	Clone the starter repository for your language of choice and follow the instructions

 	AssemblyScript
 	Rust (still under development)



The more you read the better so keep going if you can. Remember to focus on READING and avoid the temptation to build and run everything along the way because it’s a distraction at this point. You can build and run everything tomorrow.


 	Read ALL the contracts for your language of choice, not just 3
 	Read all the contracts from the OTHER language as well.
 	Check out these little puzzles, they may be fun for you

 	Scavenger Hunt Challenge #1
 	Scavenger Hunt Challenge #2




 Going Deeper
If you’re feeling fearless, here’s about as far as you might take this road in a day



 	Review all core-contracts and watch related Live Contract Review videos
 	Review Illia’s contract repo
 	Review all Rainbow Hackathon contract submissions




None of us is as smart as all of us

– Ken Blanchard



It is not that I’m so smart. But I stay with the questions much longer.

– Albert Einstein



 Resources
REMEMBER: For today’s activity


 	You do NOT need to build and test each contract
 	You do NOT need to understand every line of code
 	You SHOULD simply read through the contracts as if you are looking at art or listening to music without worring about every dot or note

AssemblyScript
If you intend to focus on AssemblyScript, [ OPEN the list of AssemblyScript contracts ]
You should read a minimum of 3 contracts marked as CORE Activity.


Rust
If you intend to focus on Rust, [ OPEN the list of Rust contracts ]
You should read a minimum of 3 contracts marked as CORE Activity.
You can read more about Rust contract basics or watch a video as well.




 

### Intro - NCD Level1 NCDL1C6

First Steps
Please complete the following as soon as possible and before the first day of the course. It is essential for the success of this program to coordinate our activities and this will help us do just that.
Immediately:
1. Please join us on a dedicated Discord server.
- USE this invitation link https://discord.gg/6F8Z3zZJ
2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear


NEAR Certified Developer
This course is an opportunity for web developers to earn a Certificate of Completion that represents the ability to design, develop, test and deploy smart contracts on the NEAR platform.

Welcome
Glad you could join us. We will be working together over the next week to learn to build decentralized applications on the smart contract platform known as NEAR Protocol.
Here’s a report of what’s happening in the industry with these so-called “layer 1” platforms as of Dec 2020. The research makes it clear: NEAR is here.
This is a NEAR L2E (Learn-to-Earn) course, meaning: we pay you to complete the course.

Before Day 1
Please make sure you are familiar with a few of these basics before the week starts. Although you do not need to be an expert in these technologies, you should have no problem cloning a NodeJS project, downloading its dependencies and running a few scripts.


 	Basic JavaScript client and serverside development (see here and here)
 	Basic terminal control (see here and here )
 	Basic git commands (see here and here).

Overview
During this course we will practice:


 	perceiving web 3 in the context of human history
 	reading contract code in Rust and AssemblyScript
 	writing contracts using Rust and AssemblyScript
 	testing contracts using unit and simulation tests
 	deploying contracts and a sensible user interface

The course will include lots of listening, watching, reading and writing. A minimum of 2 hours per day is recommended but up to 4-6 hours per day is likely, especially for developers with less than three years web development experience.

Working Agreement
Please make sure to share your availability as soon as possible, as per first steps above, so that we can properly coordinate the following details before Day 1


 	We will meet for 60 mins on Monday and Friday for kickoff and demos, respectively
 	We will meet for 30 mins Wednesday for Q&A session
 	We will break up into small-groups a, b, c … etc. depending on cohort size, 3-5 people per group
 	We will meet with our small-group every day to align on progress, share confusion and promote aha! moments to the cohort
 	We agree to complete activities on a daily basis to the best of our ability
 	We agree to work towards a group project demo by the end of the week

Questions
All questions should be posted to 1 of 3 channels:


 	#help
questions re: general logistics, general schedule, account issues, etc
 	#small-group-X (small-group-a, small-group-b, etc)
pairing requests, comments on progress, encouragement, cries for help and mercy, etc
 	#day-# (day-0, day-1, etc.)
assignment support, confusion re: some topic for the day, etc

Assignments

 	Assignments are attached to DayN lessons




Next Steps

 	NEAR Certified Developer Level 2  Bring your web3 application on NEAR TestNet to 100 users
 	The adventure continues as a new member of our community 




Recordings
All publicly available recordings will be posted here within 24-48 hours of the event.
Cohort 1: Feb 22 - Feb 26, 2021


 	Day 1 - Welcome and Kickoff slides and recording
 	Day 5 - Demos

Cohort 2: Mar 8 - Mar 12, 2021


 	Day 1 - Welcome and Kickoff slides and recording
 	Day 5 - Demos

Cohort 3: Mar 22 - Mar 26, 2021


 	Day 1 - Welcome and Kickoff slides and recording
 	Day 5 - Demos

Cohort 4: Apr 5 - Apr 9, 2021


 	Day 1 - Welcome and Kickoff slides and recording
 	Day 5 - Demos

Cohort 5: Apr 19 - Apr 23, 2021


 	forthcoming




FAQ
1. How much does this cost?
Nothing, in fact we pay you to complete this course.

2. Do I need to be a software developer to take this course?
No, you do not, but it won’t be easy and you should budget 10 hours per day, no joke.


 	If you are a junior software developer who recently graduated from a bootcamp or has less than 3 years professional experience, you should budget 4-6 hours per day.
 	If you are an senior software developer with 5 years of professional experience or more, you should budget about 2-4 hours per day.
 	If you are an experienced blockchain developer then you will likely be able to keep up with this course with about 1 hour per day of work.

3. Do I need a Mac?
MacOS and Linux will be the easiest operating systems to use.
Windows may prove challenging but if you’re ok with that, please join us.

4. How do I know if I’m winning?
There’s no such thing as winning here because we’re all lost. Welcome, friend.

5. When moon?!
Please don’t.

6. Do you care if I cheat?
No, in fact cheating is encouraged. Let’s get one thing straight: if you’re serious about learning, the fastest way from here to there is to meet people, ask questions, look at some answers, look at even more answers, copy some examples, break things and finally, if you’re lucky, learn something new.
As long as you’re honest about what you’re doing, you’re always welcome here.
Just don’t take credit for others people’s work because that’s lame.

7. I have zero time for all this. Can I just binge on some deep work on my own?
Hell yes! Here you go:


 	NEAR in a Nutshell covers everything that is NEAR on a single page
 	NEAR Live Contract Review covers our core contracts, among others
 	NEAR Live App Review covers app development patterns
 	NEAR Core Overview covers the nearcore code base
 	Learn NEAR landing page for educational content

8. I have one hundred more questions.
That’s awesome. Here is a real FAQ

### Project proposal

Submit one page PDF proposal for your NEAR project and schedule review call
Book your call at CalenD

### Day 5 - Demo web3 NCDL1C5



### Day 4 - Deploying web3 NCDL1C5



### Day 3 - Testing web3  NCDL1C5



### Day 2 - Writing web 3  NCDL1C5



### Day 1 - Reading web3  NCDL1C5



### Days Before Start- Perceiving web  NCDL1C5

First Steps
Please complete the following as soon as possible and before the first day of the course. It is essential for the success of this program to coordinate our activities and this will help us do just that.

Immediately:

1. Please join us on a dedicated Discord server.
- USE this invitation link https://discord.gg/azCzTZqM

2. Follow Learn NEAR on Twitter https://twitter.com/LearnNear

### test

test

### Verification Interview

If you are interested in earning the L1V - NEAR Verified Developer Certification then please schedule a 60 minute coding interview with Sherif. More details about the NEAR Certified Developer program.
The code review will include either (a) your own project or (b) any other NEAR contract or project (my choice) to read, edit, test, deploy and discuss.
To earn the L1V certificate you must be able to demonstrate the skills we learned this week: reading, writing, testing and deploying contracts to the NEAR platform.
To prepare, I would recommend reading all the code in all the projects in the https://github.com/Learn-NEAR organization and make sure you understand what it is doing.
Please use this link to schedule 60 minutes
https://calendly.com/nearly-sherif/ncd-l1vi
Looking forward to your interview.

### Day 5 - Demo web3 NCDL1C4



### Day 4 - Deploying web3 NCDL1C4



### Day 3 - Testing web3  NCDL1C4



### Day 2 - Writing web 3  NCDL1C4



### Day 1 - Reading web3  NCDL1C4



### Days Before Start- Perceiving web  NCDL1C4

First Steps
Please complete the following as soon as possible and before the first day of the course. It is essential for the success of this program to coordinate our activities and this will help us do just that.

Immediately:

1. Please join us on a dedicated Discord server.
- USE this invitation link https://discord.gg/Gar5RcbQ

2. Please share your availability to help us coordinate a few meetings.
- watch this 90 second intro https://www.loom.com/share/68dfb3a398be443cbfd2389bcb138ce6 to see how this works
- ADD your availability here https://lettucemeet.com/l/8EGw9

### Course Info  NCDL1C3 NCDL1C4



### Day 5 - Demo web3  NCDL1C3 Copy



### Day 4 - Deploying web3  NCDL1C3 Copy



### Day 3 - Testing web3  NCDL1C3 Copy



### Day 2 - Writing web 3  NCDL1C3 Copy



### Day 1 - Reading web3  NCDL1C3 Copy



### Days Before Start- Perceiving web  NCDL1C3 Copy



### Course Info  NCDL1C3 Copy



### Day 5 - Demo web3  NCDL1C3



### Day 4 - Deploying web3  NCDL1C3



### Day 3 - Testing web3  NCDL1C3



### Day 2 - Writing web 3  NCDL1C3



### Day 1 - Reading web3  NCDL1C3



### Days Before Start- Perceiving web  NCDL1C3



### Course Info  NCDL1C3



### Day 5 - Demo web3  NCDL1C2



### Day 4 - Deploying web3  NCDL1C2



### Day 3 - Testing web3  NCDL1C2



### Day 2 - Writing web 3  NCDL1C2



### Day 1 - Reading web3  NCDL1C2



### Days Before Start- Perceiving web  NCDL1C2



### Course Info  NCDL1C2



### Day 5 - Demo web3  NCDL1C1



### Day 4 - Deploying web3  NCDL1C1



### Day 3 - Testing web3  NCDL1C1



### Day 2 - Writing web 3  NCDL1C1



### Day 1 - Reading web3  NCDL1C1



### Days Before Start- Perceiving web  NCDL1C1



### Course Info  NCDL1C1



### What's next?

TBD

### Day 5 - Demo web3



### Day 4 - Deploying web3



### Day 3 - Testing web3



### Course Info



### Day 2 - Writing web 3



### Day 1 - Reading web3



### Days Before Start- Perceiving web 3




## Docs

### Protocol

The RPC API enables you to retrieve the current genesis and protocol configuration.

Genesis Config

Returns current genesis configuration.


method: EXPERIMENTAL_genesis_config
params: none

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_genesis_config"
}
```




```js
const response = await near.connection.provider.experimental_genesisConfig();
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_genesis_config
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "protocol_version": 29,
    "genesis_time": "2020-07-31T03:39:42.911378Z",
    "chain_id": "testnet",
    "genesis_height": 10885359,
    "num_block_producer_seats": 100,
    "num_block_producer_seats_per_shard": [100],
    "avg_hidden_validator_seats_per_shard": [0],
    "dynamic_resharding": false,
    "protocol_upgrade_stake_threshold": [4, 5],
    "protocol_upgrade_num_epochs": 2,
    "epoch_length": 43200,
    "gas_limit": 1000000000000000,
    "min_gas_price": "5000",
    "max_gas_price": "10000000000000000000000",
    "block_producer_kickout_threshold": 80,
    "chunk_producer_kickout_threshold": 90,
    "online_min_threshold": [90, 100],
    "online_max_threshold": [99, 100],
    "gas_price_adjustment_rate": [1, 100],
    "runtime_config": {
      "storage_amount_per_byte": "90949470177292823791",
      "transaction_costs": {
        "action_receipt_creation_config": {
          "send_sir": 108059500000,
          "send_not_sir": 108059500000,
          "execution": 108059500000
        },
        "data_receipt_creation_config": {
          "base_cost": {
            "send_sir": 4697339419375,
            "send_not_sir": 4697339419375,
            "execution": 4697339419375
          },
          "cost_per_byte": {
            "send_sir": 59357464,
            "send_not_sir": 59357464,
            "execution": 59357464
          }
        },
        "action_creation_config": {
          "create_account_cost": {
            "send_sir": 99607375000,
            "send_not_sir": 99607375000,
            "execution": 99607375000
          },
          "deploy_contract_cost": {
            "send_sir": 184765750000,
            "send_not_sir": 184765750000,
            "execution": 184765750000
          },
          "deploy_contract_cost_per_byte": {
            "send_sir": 6812999,
            "send_not_sir": 6812999,
            "execution": 6812999
          },
          "function_call_cost": {
            "send_sir": 2319861500000,
            "send_not_sir": 2319861500000,
            "execution": 2319861500000
          },
          "function_call_cost_per_byte": {
            "send_sir": 2235934,
            "send_not_sir": 2235934,
            "execution": 2235934
          },
          "transfer_cost": {
            "send_sir": 115123062500,
            "send_not_sir": 115123062500,
            "execution": 115123062500
          },
          "stake_cost": {
            "send_sir": 141715687500,
            "send_not_sir": 141715687500,
            "execution": 102217625000
          },
          "add_key_cost": {
            "full_access_cost": {
              "send_sir": 101765125000,
              "send_not_sir": 101765125000,
              "execution": 101765125000
            },
            "function_call_cost": {
              "send_sir": 102217625000,
              "send_not_sir": 102217625000,
              "execution": 102217625000
            },
            "function_call_cost_per_byte": {
              "send_sir": 1925331,
              "send_not_sir": 1925331,
              "execution": 1925331
            }
          },
          "delete_key_cost": {
            "send_sir": 94946625000,
            "send_not_sir": 94946625000,
            "execution": 94946625000
          },
          "delete_account_cost": {
            "send_sir": 147489000000,
            "send_not_sir": 147489000000,
            "execution": 147489000000
          }
        },
        "storage_usage_config": {
          "num_bytes_account": 100,
          "num_extra_bytes_record": 40
        },
        "burnt_gas_reward": [3, 10],
        "pessimistic_gas_price_inflation_ratio": [103, 100]
      },
      "wasm_config": {
        "ext_costs": {
          "base": 264768111,
          "contract_compile_base": 35445963,
          "contract_compile_bytes": 216750,
          "read_memory_base": 2609863200,
          "read_memory_byte": 3801333,
          "write_memory_base": 2803794861,
          "write_memory_byte": 2723772,
          "read_register_base": 2517165186,
          "read_register_byte": 98562,
          "write_register_base": 2865522486,
          "write_register_byte": 3801564,
          "utf8_decoding_base": 3111779061,
          "utf8_decoding_byte": 291580479,
          "utf16_decoding_base": 3543313050,
          "utf16_decoding_byte": 163577493,
          "sha256_base": 4540970250,
          "sha256_byte": 24117351,
          "keccak256_base": 5879491275,
          "keccak256_byte": 21471105,
          "keccak512_base": 5811388236,
          "keccak512_byte": 36649701,
          "log_base": 3543313050,
          "log_byte": 13198791,
          "storage_write_base": 64196736000,
          "storage_write_key_byte": 70482867,
          "storage_write_value_byte": 31018539,
          "storage_write_evicted_byte": 32117307,
          "storage_read_base": 56356845750,
          "storage_read_key_byte": 30952533,
          "storage_read_value_byte": 5611005,
          "storage_remove_base": 53473030500,
          "storage_remove_key_byte": 38220384,
          "storage_remove_ret_value_byte": 11531556,
          "storage_has_key_base": 54039896625,
          "storage_has_key_byte": 30790845,
          "storage_iter_create_prefix_base": 0,
          "storage_iter_create_prefix_byte": 0,
          "storage_iter_create_range_base": 0,
          "storage_iter_create_from_byte": 0,
          "storage_iter_create_to_byte": 0,
          "storage_iter_next_base": 0,
          "storage_iter_next_key_byte": 0,
          "storage_iter_next_value_byte": 0,
          "touching_trie_node": 16101955926,
          "promise_and_base": 1465013400,
          "promise_and_per_promise": 5452176,
          "promise_return": 560152386,
          "validator_stake_base": 911834726400,
          "validator_total_stake_base": 911834726400
        },
        "grow_mem_cost": 1,
        "regular_op_cost": 3856371,
        "limit_config": {
          "max_gas_burnt": 200000000000000,
          "max_gas_burnt_view": 200000000000000,
          "max_stack_height": 16384,
          "initial_memory_pages": 1024,
          "max_memory_pages": 2048,
          "registers_memory_limit": 1073741824,
          "max_register_size": 104857600,
          "max_number_registers": 100,
          "max_number_logs": 100,
          "max_total_log_length": 16384,
          "max_total_prepaid_gas": 300000000000000,
          "max_actions_per_receipt": 100,
          "max_number_bytes_method_names": 2000,
          "max_length_method_name": 256,
          "max_arguments_length": 4194304,
          "max_length_returned_data": 4194304,
          "max_contract_size": 4194304,
          "max_length_storage_key": 4194304,
          "max_length_storage_value": 4194304,
          "max_promises_per_function_call_action": 1024,
          "max_number_input_data_dependencies": 128
        }
      },
      "account_creation_config": {
        "min_allowed_top_level_account_length": 0,
        "registrar_account_id": "registrar"
      }
    },
    "validators": [
      {
        "account_id": "node0",
        "public_key": "ed25519:7PGseFbWxvYVgZ89K1uTJKYoKetWs7BJtbyXDzfbAcqX",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node1",
        "public_key": "ed25519:6DSjZ8mvsRZDvFqFxo8tCKePG96omXW7eVYVSySmDk8e",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node2",
        "public_key": "ed25519:GkDv7nSMS3xcqA45cpMvFmfV1o4fRF6zYo1JRR6mNqg5",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node3",
        "public_key": "ed25519:ydgzeXHJ5Xyt7M1gXLxqLBW1Ejx6scNV5Nx2pxFM8su",
        "amount": "1000000000000000000000000000000"
      }
    ],
    "transaction_validity_period": 86400,
    "protocol_reward_rate": [1, 10],
    "max_inflation_rate": [1, 20],
    "total_supply": "1031467299046044096035532756810080",
    "num_blocks_per_year": 31536000,
    "protocol_treasury_account": "near",
    "fishermen_threshold": "10000000000000000000",
    "minimum_stake_divisor": 10
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_genesis_config method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Protocol Config

Returns most recent protocol configuration or a specific queried block. Useful for finding current storage and transaction costs.


method: EXPERIMENTAL_protocol_config
params:

finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_protocol_config",
  "params": {
    "finality": "final"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_protocol_config 
  params:='{
    "finality": "final"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "protocol_version": 45,
    "genesis_time": "2020-07-31T03:39:42.911378Z",
    "chain_id": "testnet",
    "genesis_height": 42376888,
    "num_block_producer_seats": 200,
    "num_block_producer_seats_per_shard": [200],
    "avg_hidden_validator_seats_per_shard": [0],
    "dynamic_resharding": false,
    "protocol_upgrade_stake_threshold": [4, 5],
    "epoch_length": 43200,
    "gas_limit": 1000000000000000,
    "min_gas_price": "5000",
    "max_gas_price": "10000000000000000000000",
    "block_producer_kickout_threshold": 80,
    "chunk_producer_kickout_threshold": 90,
    "online_min_threshold": [90, 100],
    "online_max_threshold": [99, 100],
    "gas_price_adjustment_rate": [1, 100],
    "runtime_config": {
      "storage_amount_per_byte": "10000000000000000000",
      "transaction_costs": {
        "action_receipt_creation_config": {
          "send_sir": 108059500000,
          "send_not_sir": 108059500000,
          "execution": 108059500000
        },
        "data_receipt_creation_config": {
          "base_cost": {
            "send_sir": 4697339419375,
            "send_not_sir": 4697339419375,
            "execution": 4697339419375
          },
          "cost_per_byte": {
            "send_sir": 59357464,
            "send_not_sir": 59357464,
            "execution": 59357464
          }
        },
        "action_creation_config": {
          "create_account_cost": {
            "send_sir": 99607375000,
            "send_not_sir": 99607375000,
            "execution": 99607375000
          },
          "deploy_contract_cost": {
            "send_sir": 184765750000,
            "send_not_sir": 184765750000,
            "execution": 184765750000
          },
          "deploy_contract_cost_per_byte": {
            "send_sir": 6812999,
            "send_not_sir": 6812999,
            "execution": 6812999
          },
          "function_call_cost": {
            "send_sir": 2319861500000,
            "send_not_sir": 2319861500000,
            "execution": 2319861500000
          },
          "function_call_cost_per_byte": {
            "send_sir": 2235934,
            "send_not_sir": 2235934,
            "execution": 2235934
          },
          "transfer_cost": {
            "send_sir": 115123062500,
            "send_not_sir": 115123062500,
            "execution": 115123062500
          },
          "stake_cost": {
            "send_sir": 141715687500,
            "send_not_sir": 141715687500,
            "execution": 102217625000
          },
          "add_key_cost": {
            "full_access_cost": {
              "send_sir": 101765125000,
              "send_not_sir": 101765125000,
              "execution": 101765125000
            },
            "function_call_cost": {
              "send_sir": 102217625000,
              "send_not_sir": 102217625000,
              "execution": 102217625000
            },
            "function_call_cost_per_byte": {
              "send_sir": 1925331,
              "send_not_sir": 1925331,
              "execution": 1925331
            }
          },
          "delete_key_cost": {
            "send_sir": 94946625000,
            "send_not_sir": 94946625000,
            "execution": 94946625000
          },
          "delete_account_cost": {
            "send_sir": 147489000000,
            "send_not_sir": 147489000000,
            "execution": 147489000000
          }
        },
        "storage_usage_config": {
          "num_bytes_account": 100,
          "num_extra_bytes_record": 40
        },
        "burnt_gas_reward": [3, 10],
        "pessimistic_gas_price_inflation_ratio": [103, 100]
      },
      "wasm_config": {
        "ext_costs": {
          "base": 264768111,
          "contract_compile_base": 35445963,
          "contract_compile_bytes": 216750,
          "read_memory_base": 2609863200,
          "read_memory_byte": 3801333,
          "write_memory_base": 2803794861,
          "write_memory_byte": 2723772,
          "read_register_base": 2517165186,
          "read_register_byte": 98562,
          "write_register_base": 2865522486,
          "write_register_byte": 3801564,
          "utf8_decoding_base": 3111779061,
          "utf8_decoding_byte": 291580479,
          "utf16_decoding_base": 3543313050,
          "utf16_decoding_byte": 163577493,
          "sha256_base": 4540970250,
          "sha256_byte": 24117351,
          "keccak256_base": 5879491275,
          "keccak256_byte": 21471105,
          "keccak512_base": 5811388236,
          "keccak512_byte": 36649701,
          "log_base": 3543313050,
          "log_byte": 13198791,
          "storage_write_base": 64196736000,
          "storage_write_key_byte": 70482867,
          "storage_write_value_byte": 31018539,
          "storage_write_evicted_byte": 32117307,
          "storage_read_base": 56356845750,
          "storage_read_key_byte": 30952533,
          "storage_read_value_byte": 5611005,
          "storage_remove_base": 53473030500,
          "storage_remove_key_byte": 38220384,
          "storage_remove_ret_value_byte": 11531556,
          "storage_has_key_base": 54039896625,
          "storage_has_key_byte": 30790845,
          "storage_iter_create_prefix_base": 0,
          "storage_iter_create_prefix_byte": 0,
          "storage_iter_create_range_base": 0,
          "storage_iter_create_from_byte": 0,
          "storage_iter_create_to_byte": 0,
          "storage_iter_next_base": 0,
          "storage_iter_next_key_byte": 0,
          "storage_iter_next_value_byte": 0,
          "touching_trie_node": 16101955926,
          "promise_and_base": 1465013400,
          "promise_and_per_promise": 5452176,
          "promise_return": 560152386,
          "validator_stake_base": 911834726400,
          "validator_total_stake_base": 911834726400
        },
        "grow_mem_cost": 1,
        "regular_op_cost": 3856371,
        "limit_config": {
          "max_gas_burnt": 200000000000000,
          "max_gas_burnt_view": 200000000000000,
          "max_stack_height": 16384,
          "initial_memory_pages": 1024,
          "max_memory_pages": 2048,
          "registers_memory_limit": 1073741824,
          "max_register_size": 104857600,
          "max_number_registers": 100,
          "max_number_logs": 100,
          "max_total_log_length": 16384,
          "max_total_prepaid_gas": 300000000000000,
          "max_actions_per_receipt": 100,
          "max_number_bytes_method_names": 2000,
          "max_length_method_name": 256,
          "max_arguments_length": 4194304,
          "max_length_returned_data": 4194304,
          "max_contract_size": 4194304,
          "max_length_storage_key": 4194304,
          "max_length_storage_value": 4194304,
          "max_promises_per_function_call_action": 1024,
          "max_number_input_data_dependencies": 128
        }
      },
      "account_creation_config": {
        "min_allowed_top_level_account_length": 0,
        "registrar_account_id": "registrar"
      }
    },
    "transaction_validity_period": 86400,
    "protocol_reward_rate": [1, 10],
    "max_inflation_rate": [1, 20],
    "num_blocks_per_year": 31536000,
    "protocol_treasury_account": "near",
    "fishermen_threshold": "340282366920938463463374607431768211455",
    "minimum_stake_divisor": 10
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_protocol_config method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Tools

Welcome! The NEAR ecosystem has a complete set of tools for you to make the most out of the NEAR network.
In this page you will find:

Wallets to handle your assets.
Explorers to quickly obtain information from the blockchain.
Websites to simplify creating and participating on governance projects.
Developer tools to deploy and interact with contracts such as the NEAR CLI and NEAR JavaScript API.

### Skeleton and Rust Architecture

In this article, you'll learn about the basic architecture behind the NFT contract that you'll develop while following this "Zero to Hero" series.
You'll discover the contract's layout and you'll see how the Rust files are structured in order to build a feature-complete smart contract.
infoSkeleton Contract
You can find the skeleton contract in our [GitHub repository](https://github.com/near-examples/nft-tutorial/tree/main/nft-contract-skeleton)

infoNew to Rust?
If you are new to Rust and want to dive into smart contract development, our [Quick-start guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) is a great place to start.


Introduction
This tutorial presents the code skeleton for the NFT smart contract and its file structure.
Once every file and functions have been covered, we will guide you through the process of building the mock-up contract to confirm that your Rust setup works.

File structure
Following a regular Rust project, the file structure for this smart contract has:
nft-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
└── src
    ├── approval.rs
    ├── enumeration.rs
    ├── lib.rs
    ├── metadata.rs
    ├── mint.rs
    ├── nft_core.rs
    ├── events.rs
    └── royalty.rs

The file Cargo.toml defines the code dependencies
The src folder contains all the Rust source files


Source files
Here is a brief description of what each source file is responsible for:



File
Description




approval.rs
Has the functions that controls the access and transfers of non-fungible tokens


enumeration.rs
Contains the methods to list NFT tokens and their owners


lib.rs
Holds the smart contract initialization functions


metadata.rs
Defines the token and metadata structure


mint.rs
Contains token minting logic


nft_core.rs
Core logic that allows you to transfer NFTs between users.


royalty.rs
Contains payout-related functions


events.rs
Contains events related structures



tipxplore the code in our [GitHub repository](https://github.com/near-examples/nft-tutorial/).


approval.rs

This allows people to approve other accounts to transfer NFTs on their behalf.

This file contains the logic that complies with the standard's approvals management extension. Here is a breakdown of the methods and their functions:



Method
Description




nft_approve
Approves an account ID to transfer a token on your behalf.


nft_is_approved
Checks if the input account has access to approve the token ID.


nft_revoke
Revokes a specific account from transferring the token on your behalf.


nft_revoke_all
Revokes all accounts from transferring the token on your behalf.


nft_on_approve
This callback function, initiated during nft_approve, is a cross contract call to an external contract.




You'll learn more about these functions in the approvals section of the Zero to Hero series.

enumeration.rs

This file provides the functions needed to view information about NFTs, and follows the standard's enumeration extension.




Method
Description




nft_total_supply
Returns the total amount of NFTs stored on the contract


nft_tokens
Returns a paginated list of NFTs stored on the contract regardless of their owner.


nft_supply_for_owner
Allows you view the total number of NFTs owned by any given user


nft_tokens_for_owner
Returns a paginated list of NFTs owned by any given user




You'll learn more about these functions in the enumeration section of the tutorial series.

lib.rs

This file outlines what information the contract stores and keeps track of.




Method
Description




new_default_meta
Initializes the contract with default metadata so the user doesn't have to provide any input.


new
Initializes the contract with the user-provided metadata.



infoKeep in mind
The initialization functions (`new`, `new_default_meta`) can only be called once.


You'll learn more about these functions in the minting section of the tutorial series.

metadata.rs

This file is used to keep track of the information to be stored for tokens, and metadata.
In addition, you can define a function to view the contract's metadata which is part of the standard's metadata extension.




Name
Description




TokenMetadata
This structure defines the metadata that can be stored for each token (title, description, media, etc.).


Token
This structure outlines what information will be stored on the contract for each token.


JsonToken
When querying information about NFTs through view calls, the return information is stored in this JSON token.


nft_metadata
This function allows users to query for the contact's internal metadata.




You'll learn more about these functions in the minting section of the tutorial series.

mint.rs

Contains the logic to mint the non-fungible tokens




Method
Description




nft_mint
This function mints a non-fungible token.





nft_core.rs

Core logic that allows to transfer NFTs between users.




Method
Description




nft_transfer
Transfers an NFT to a receiver ID.


nft_transfer_call
Transfers an NFT to a receiver and calls a function on the receiver ID's contract. The function returns true if the token was transferred from the sender's account.


nft_token
Allows users to query for the information about a specific NFT.


nft_on_transfer
Called by other contracts when an NFT is transferred to your contract account via the nft_transfer_call method. It returns true if the token should be returned back to the sender.


nft_resolve_transfer
When you start the nft_transfer_call and transfer an NFT, the standard also calls a method on the receiver's contract. If the receiver needs you to return the NFT to the sender (as per the return value of the nft_on_transfer method), this function allows you to execute that logic.




You'll learn more about these functions in the core section of the tutorial series.

royalty.rs

Contains payout-related functions.




Method
Description




nft_payout
This view method calculates the payout for a given token.


nft_transfer_payout
Transfers the token to the receiver ID and returns the payout object that should be paid for a given balance.




You'll learn more about these functions in the royalty section of the tutorial series.

events.rs

Contains events-related structures.




Method
Description




EventLogVariant
This enum represents the data type of the EventLog.


EventLog
Interface to capture data about an event.


NftMintLog
An event log to capture token minting.


NftTransferLog
An event log to capture token transfer.




You'll learn more about these functions in the events section of the tutorial series.

Building the skeleton
If you haven't cloned the main repository yet, open a terminal and run:
git clone https://github.com/near-examples/nft-tutorial/
Next, go to the nft-contract-skeleton/ folder and build the contract with cargo-near:
cd nft-tutorial
cd nft-contract-skeleton/
cargo near build
Since this source is just a skeleton you'll get many warnings about unused code, such as:
   Compiling nft_contract_skeleton v0.1.0 (/Users/near-examples/Documents/my/projects/near/examples/nft-tutorial/nft-contract-basic)
 │ warning: unused imports: `LazyOption`, `LookupMap`, `UnorderedMap`, `UnorderedSet`
 │  --> src/lib.rs:3:29
 │   |
 │ 3 | use near_sdk::collections::{LazyOption, LookupMap, UnorderedMap, UnorderedSet};
 │   |                             ^^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^^^^  ^^^^^^^^^^^^
 │   |
 │   = note: `#[warn(unused_imports)]` on by default
 │
 │ warning: unused import: `Base64VecU8`
 │  --> src/lib.rs:4:28
 │   |
 │ 4 | use near_sdk::json_types::{Base64VecU8, U128};
 │   |

 │ warning: `nft_contract_skeleton` (lib) generated 48 warnings (run `cargo fix --lib -p nft_contract_skeleton` to apply 45 suggestions)
 │     Finished release [optimized] target(s) in 11.01s
 ✓ Contract successfully built!
Don't worry about these warnings, you're not going to deploy this contract yet.
Building the skeleton is useful to validate that your Rust toolchain works properly and that you'll be able to compile improved versions of this NFT contract in the upcoming tutorials.

Conclusion
You've seen the layout of this NFT smart contract, and how all the functions are laid out across the different source files.
Using yarn, you've been able to compile the contract, and you'll start fleshing out this skeleton in the next Minting tutorial.
noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.76.0`
- near-sdk-rs: `5.1.0`
- cargo-near: `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### Pre-deployed Contract

Create your first non-fungible token by using a pre-deployed NFT smart contract which works exactly as the one you will build on this tutorial.

Prerequisites
To complete this tutorial successfully, you'll need a NEAR Wallet and NEAR CLI

Using the NFT contract
Minting an NFT token on NEAR is a simple process that involves calling a smart contract function.
To interact with the contract you will need to first login to your NEAR account through near-cli.

Setup
Log in to your newly created account with near-cli by running the following command in your terminal:
near account import-account using-web-wallet network-config testnet
Set an environment variable for your account ID to make it easy to copy and paste commands from this tutorial:
export NEARID=YOUR_ACCOUNT_NAME

Minting your NFTs
We have already deployed an NFT contract to nft.examples.testnet which allows users to freely mint tokens. Let's use it to mint our first token.
Run this command in your terminal, remember to replace the token_id with a string of your choice. This string will uniquely identify the token you mint.

  

  ```bash
  near call nft.examples.testnet nft_mint '{"token_id": "TYPE_A_UNIQUE_VALUE_HERE", "receiver_id": "'$NEARID'", "metadata": { "title": "GO TEAM", "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "copies": 1}}' --gas 100000000000000 --deposit 0.1 --accountId $NEARID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction nft.examples.testnet nft_mint json-args '{"token_id": "TYPE_A_UNIQUE_VALUE_HERE", "receiver_id": "'$NEARID'", "metadata": { "title": "GO TEAM", "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "copies": 1}}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NEARID network-config testnet sign-with-keychain send
    ```
  


Example response: 


```json
Log [nft.examples.testnet]: EVENT_JSON:{"standard":"nep171","version":"nft-1.0.0","event":"nft_mint","data":[{"owner_id":"benjiman.testnet","token_ids":["TYPE_A_UNIQUE_VALUE_HERE"]}]}
Transaction Id 8RFWrQvAsm2grEsd1UTASKpfvHKrjtBdEyXu7WqGBPUr
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/8RFWrQvAsm2grEsd1UTASKpfvHKrjtBdEyXu7WqGBPUr
''
```



tipou can also replace the `media` URL with a link to any image file hosted on your web server.


Querying your NFT
To view tokens owned by an account you can call the NFT contract with the following near-cli command:

  

  ```bash
  near view nft.examples.testnet nft_tokens_for_owner '{"account_id": "'$NEARID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only nft.examples.testnet nft_tokens_for_owner json-args '{"account_id": "'$NEARID'"}' network-config testnet now
  ```
  


Example response: 


```json
[
  {
    "token_id": "Goi0CZ",
    "owner_id": "bob.testnet",
    "metadata": {
      "title": "GO TEAM",
      "description": "The Team Goes",
      "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/",
      "media_hash": null,
      "copies": 1,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
```



Congratulations! You just minted your first NFT token on the NEAR blockchain! 🎉
Now try going to your NEAR Wallet and view your NFT in the "Collectibles" tab.

Final remarks
This basic example illustrates all the required steps to call an NFT smart contract on NEAR and start minting your own non-fungible tokens.
Now that you're familiar with the process, you can jump to Contract Architecture and learn more about the smart contract structure and how you can build your own NFT contract from the ground up.
Happy minting! 🪙
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli-rs: `0.11.0`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### NFT Zero to Hero

In this Zero to Hero series, you'll find a set of tutorials that will cover every aspect of a non-fungible token (NFT) smart contract.
You'll start by minting an NFT using a pre-deployed contract and by the end you'll end up building a fully-fledged NFT smart contract that supports every extension.

Prerequisites
To complete these tutorials successfully, you'll need:

Rust
A Testnet wallet
NEAR-CLI
cargo-near

infoNew to Rust?
If you are new to Rust and want to dive into smart contract development, our [Quick-start guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) is a great place to start


Overview
These are the steps that will bring you from Zero to Hero in no time! 💪



Step
Name
Description




1
Pre-deployed contract
Mint an NFT without the need to code, create, or deploy a smart contract.


2
Contract architecture
Learn the basic architecture of the NFT smart contract and compile code.


3
Minting
Flesh out the skeleton so the smart contract can mint a non-fungible token.


4
Upgrade a contract
Discover the process to upgrade an existing smart contract.


5
Enumeration
Explore enumeration methods that can be used to return the smart contract's states.


6
Core
Extend the NFT contract using the core standard which allows token transfer.


7
Events
The events extension, allowing the contract to react on certain events.


8
Approvals
Expand the contract allowing other accounts to transfer NFTs on your behalf.


9
Royalty
Add NFT royalties allowing for a set percentage to be paid out to the token creator.


10
Marketplace
Learn about how common marketplaces operate on NEAR and dive into some of the code that allows buying and selling NFTs.




Next steps
Ready to start? Jump to the Pre-deployed Contract tutorial and begin your learning journey!
If you already know about non-fungible tokens and smart contracts, feel free to skip and jump directly to the tutorial of your interest. The tutorials have been designed so you can start at any given point!

### Intermediate concepts (cross-contract calls and more)

Intermediate concepts
This chapter will go a bit faster than the previous ones.
We're going to be covering an important part of smart contract development: cross-contract calls.
Cross-contract calls
A cross-contract call is when a smart contract calls another smart contract. For instance, if alice.near calls contract A, and contract A makes a call to contract B.
NEAR has asynchronous transactions, and some cross-contract calls will have callbacks in order to determine the result of the call. This works a bit different from other blockchains, as we'll explain more in this chapter.
Access keys
Last chapter covered access keys, and we implemented a login system where a user "logs in" by adding a function-call access key to their account which is tied to the crossword puzzle dApp.
Login is a common use case for access keys, but let's think bigger!
Remember the two (smaller, gray) function-call access keys from the keychain illustration?

    
    Art by alcantara_gabriel.near

### What is Data Infrastructure?

NEAR offers ready-to-use solutions to access and monitor on-chain data easily. This is very useful to automate actions based on specific events, cache data to reduce latency, gather usage data of the blockchain, and even study user preferences.

In NEAR you will find three main solutions to access and monitor on-chain data: Data APIs, BigQuery Public Dataset and NEAR Lake. Each of these solutions is designed to fit different needs and use cases, and can be used in combination to create a complete data infrastructure for your application.

Data APIs
Members of the NEAR community have built a set of APIs to access and monitor on-chain data. These APIs are designed to be easy to use and can be accessed from any application through a simple API call.

User assets: Easily track all the assets that a user or a contract holds
Monitor transactions: Get all the transactions of a user, a contract or a specific token
Track on-chain events: Get all the events emitted by a contract, or a specific event type


BigQuery: Public Dataset
A large dataset with on-chain data publicly available on Google Cloud Platform. Obtain near real-time blockchain data using simple SQL queries. All the data, zero setup.

Instant insights: Historic on-chain data queried at scale. No need to run your own infrastructure.
Cost-effective: Eliminate the need to store and process bulk NEAR Protocol data. Query as little or as much data as you like.
As easy as SQL: No prior experience with blockchain technology is required. Just bring a general knowledge of SQL to unlock insights.


NEAR Lake
A solution that watches over the NEAR network and stores all the events for your easy access.

Cost-efficient solution: Cost-efficient solution for building self-hosted indexers in Rust, JavaScript, Python, Go and other languages
Streamlined data management: Use NEAR Lake Framework to stream blocks to your server directly from NEAR Lake


Conclusion
Data infrastructure is a key component of any blockchain application. It allows developers to access and monitor on-chain data easily, which is essential for building applications that interact with the blockchain.
NEAR offers a range of solutions to help developers build robust data infrastructure for their applications, including Data APIs, BigQuery Public Dataset, and NEAR Lake. By using these solutions in combination, developers can create a complete data infrastructure that meets their specific needs and use cases.

### Hello WebApp

In this guide we will show you how to quickly spin up a frontend where users can login using their wallets and interact with a contract.
tipearching to integrate NEAR in your App?
If you already have an application and want to integrate NEAR into it, we recommend you to first go through this guide and then check our documentation on [integrating NEAR to a frontend](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/./integrate-contracts.md)


Create NEAR App
If you already have Node.js installed, simply run:
  npx create-near-app@latest
Use the interactive menu to set up:

A Web App.
NextJs (Classic).

tipsing pnpm
While you can use our app with any package manager, we recommend you to skip the installation step and manually install the dependencies using `pnpm i`.

Once the folder is ready - and all dependencies installed - you can start the development server using pnpm. 
pnpm dev
Visit http://localhost:3000 in your browser to view the dApp. Note that since the dApp uses NextJS the app might take longer to load the pages on first visit.

 The app is not starting? 

Make sure you are using **node >= v18**, you can easily switch versions using `nvm use 18`



Landing Page
Once the app starts you will see the landing page, rendering a navigation bar that allows users to login using their NEAR wallet. You can then navigate to the docs or the Near Integration page (which we will do).

Landing page of Hello NEAR Gateway
Go ahead and sign in with your NEAR account. If you don't have one, you can create one on the fly.

Under the Hood
Next.js uses a template system, where each page is a React component.
Our app's template is defined at ./src/pages/_app.js. It does two things:

Initializes a wallet selector, and stores it in context so other components can access it later.
Renders the navigation menu and the page's content.


When initializing the wallet you can choose to create a function call access key for a specific contract for the application to use. This allows the application to sign non-payable methods on behalf of the user so they are not required to manually sign each transaction.
const wallet = new Wallet({
  createAccessKeyFor: HelloNearContract,
  networkId: NetworkId,
});
This example additionally includes the option to login with Metamask and other EVM wallets. Further information on how to add EVM wallets to your application can be found in the Ethereum Wallets on NEAR documentation.

What is the wallet selector?

The wallet selector is a modal that allows users to select their preferred Near wallet to login. Our application creates a new instance of the wallet selector then stores it in the apps context so it can be accessed by other components.




The navigation bar implements buttons to login and logout users with their Near wallet.
The code for the navigation bar can be found at ./src/components/navigation.js. The login and logout buttons are implemented by using the signIn and signOut methods from the wallet selector previously initialized:


Interacting with NEAR
Now that you understand how the landing page works, we can move to the Near Integration page, which retrieves a greeting from the hello.near-examples.testnet contract.

View of the Near Integration page
Login if you haven't done it yet and you will see a simple form that allows you to store a greeting in the smart contract.

Under the Hood
We retrieve the wallet we initialized earlier via the useContext hook. The wallet allows us to interact with the smart contract through viewMethod and callMethod.

viewMethod is used to call functions that are read-only
callMethod is used to call functions that modify the state of the contract 


On load, the first useEffect hook will call the contract's get_greeting method and set the greeting state to the result.
If the user is logged in, the user will be able to use the saveGreeting function which will call the contract's set_greeting method and then update the greeting.

Moving Forward
That's it for our quickstart tutorial. You have now seen a fully functional frontend that can talk with NEAR contracts and render Web3 components.

### Choose your Dev Environment

The environments in which you can develop Components are divided into two categories:

Web Tools: Online tools that allow you to quickly start building and sharing components.
Local Tools: Tools that allow you to develop and test components locally.

tipandling collaborations
If you plan to collaborate with multiple people, we recommend you to check [this repository template](https://github.com/near-examples/bos-components) which automatically deploys components each time a PR is merged. 


Web Tools
The quickest way to start building NEAR Components is by using one of the online tools. They are great for taking your first steps, while they let you find other developers and components in the NEAR ecosystem.
Jutsu.ai
Jutsu.ai is a web IDE made for NEAR developers. It contains examples and tutorials to help onboarding you.

Local Tools
If you want to collaborate with a team or work on a larger project, you will likely want more version control, automated testing and deployment, and other workflows. For this, the NEAR ecosystem offers a set of tools to easily develop and test your components entirely locally.
NEAR VSCode Extension
The NEAR VSCode Extension integrates with the VSCode IDE to help you develop, preview and deploy components all within VSCode.
BOS Loader
A CLI tool to preview local components in NEAR BOS. A perfect companion to the BOS CLI.
BOS CLI
A command line utility that simplifies local component development for NEAR BOS.
BOS Workspace
A comprehensive toolset for simplifying the local development of NEAR components and applications, featuring hot reload, TypeScript support, multi-app management, and a local gateway.
Além
A web3 JavaScript/TypeScript library to create web3 applications for Near BOS. It's developer-friendly and uses React patterns, making it easy to organize files and write code. Access the Além Docs to get to know more.

### RPC Statistics

warning
Please be advised that these tools and services will be discontinued soon.

Inspect your RPC Usage in the Statistics Tab:

infoData defaults to the last 30 days.
Currently the statistics page show the usage data across all projects and API keys within an organization set on Pagoda Console.

Aggregated key metrics available at the top of the dashboard are

Total Request Volume
Request Success Rate
Total failed request
Average Latency

Set a Time Period
Data is sent with UTC time to the browser and the browser adjusts to the user’s timezone.

Last 15 Minutes is the last complete 15 minutes. This updates every few seconds.
Last 1 Hour is the last fully completed hour; from 00 to 59 minutes and 59 seconds.
Last 24 Hours is the last fully completed 24 consecutive hours.
Last 7 Days is the previous 7 days from the current time. Each data point groups one hour’s worth of data. The most recent hour is partial data for the current hour and updates every few seconds.
Last 30 Days is the previous 30 days from the current time. Each data point groups one hour’s worth of data. The most recent hour is partial data for the current hour and updates every few seconds.

Requests breakdowns
Multiple breakdowns are available in the statistics page

Requests can be broken down by

Requests Methods
Requests Status
Aggregated status display breakdown by requests methods

We are working to include more detailed breakdown by each requests and more interactive dashboard that enable clickthrough from the charts
Network Status
Check the Pagoda Status page for the latest service information across all networks and subscribe to updates based on your service choice and needs.

### RPC Setup

warning
Please be advised that these tools and services will be discontinued soon.

In order to use the RPC API you will need to setup the correct RPC endpoints:

POST for all RPC methods
JSON RPC 2.0
`- Endpoint URL varies by network

testnet: https://near-testnet.api.pagoda.co/rpc/v1/
mainnet: https://near-mainnet.api.pagoda.co/rpc/v1/


note
We are working on supporting historical data access in the next phase.

API Keys
When accessing the NEAR network via a node provider, API services like Pagoda require an API key, which allows developers to monitor personal apps and access usage metrics.
tipor the best development experience, we recommend that you [sign up for a free API key](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/pagoda/rpc/get-keys.md).

With a dedicated API key, developers are able to:

Access higher request throughput and increased concurrent requests
Query data from Enhanced APIs, gaining access to free processed data for NFT, FT and NEAR balances, ownership, and metadata
Utilize dedicated, individualized usage metrics

Test your API keys
To quickly test your API keys and connection, try a simple request from your command line:
curl -X POST -H 'x-api-key:<YOUR-API-KEY>' -H 'Content-Type: application/json' -d '{"jsonrpc": "2.0", "id":"dontcare","method":"status","params":[] }' https://near-testnet.api.pagoda.co/rpc/v1/
Postman Setup
An easy way to test the queries in this documentation page is to use an API request tool such as Postman.
You only need to configure two things:


Make sure you add a header with a key of Content-Type and value of application/json.



Then select the Body tab and choose the raw radio button and ensure JSON is the selected format.



After that is set up, just copy/paste the JSON object example snippets below into the body of your request, on Postman, and click send.
Command-line Setup
NEAR CLI

If you don’t yet have near-cli installed on your machine, follow the near-cli installation instructions.
Set your RPC URL:
export NEAR_CLI_TESTNET_RPC_SERVER_URL=https://near-testnet.api.pagoda.co/rpc/v1/
Configure your API key:
near set-api-key $NEAR_CLI_TESTNET_RPC_SERVER_URL <your API Key>

HTTPie Setup
If you prefer to use a command line interface, we have provided RPC examples you can use with HTTPie.
Please note that params take either an object or array passed as a string.
http post https://near-testnet.api.pagoda.co/rpc/v1/ jsonrpc=2.0 id=dontcare method=network_info params:='[]'
JavaScript Setup
All of the queries listed in this documentation page can be called using near-api-js.
tipor `near-api-js` installation and setup please refer to `near-api-js` [quick reference documentation](https://docs.near.org/tools/near-api-js/quick-reference#install).

Add the following code to get started:
const { connect, keyStores } = require("near-api-js");

// Can be an empty object if not signing transactions

const keyStore = new keyStores.BrowserLocalStorageKeyStore();

const RPC_API_ENDPOINT = 'https://near-testnet.api.pagoda.co/rpc/v1/';
const API_KEY = '<YOUR-API-KEY>';

const ACCOUNT_ID = 'account.near';

const config = {
    networkId: 'testnet',
    keyStore,
    nodeUrl: RPC_API_ENDPOINT,
    headers: { 'x-api-key': API_KEY },
};

// Example: Fetching account status

async function getState(accountId) {
    const near = await connect(config);
    const account = await near.account(accountId);
    const state = await account.state();
    console.log(state);
}

getState(ACCOUNT_ID);
infoAll JavaScript code snippets require a `near` object. For examples of how to instantiate, [click here](https://docs.near.org/tools/near-api-js/quick-reference#connect).

Rust Setup
You can use the near-jsonrpc-client-rs library to communicate with the Pagoda RPC endpoints via JSONRPC.
Example of asynchronously fetching the latest block using tokio:
use near_jsonrpc_client::{auth, methods, JsonRpcClient};
use near_primitives::types::{BlockReference, Finality};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = JsonRpcClient::connect("https://near-testnet.api.pagoda.co/rpc/v1/")
        .header(auth::ApiKey::new("<YOUR-API-KEY>")?);

    let request = methods::block::RpcBlockRequest {
        block_reference: BlockReference::Finality(Finality::Final),
    };

    let response = client.call(request).await?;

    println!("{:?}", response);

    Ok(())
}

Using block_id param

The block_id param can take either the block number (e.g. 27912554) or the block hash (e.g. '3Xz2wM9rigMXzA2c5vgCP8wTgFBaePucgUmVYPkMqhRL' ) as an argument.
::caution
The block IDs of transactions shown in NEAR Explorer are not necessarily the block ID of the executed transaction. Transactions may execute a block or two after its recorded, and in some cases, can take place over several blocks. Due to this, it is important to check subsequent blocks to be sure all results related to the queried transaction are discovered.
::


Using finality param
The finality param has two options: optimistic and final.

optimistic uses the latest block recorded on the node that responded to your query (<1 second delay after the transaction is submitted)
final is for a block that has been validated on at least 66% of the nodes in the network (usually takes 2 blocks / approx. 2 second delay)

### Pagoda RPC API

warning
Please be advised that these tools and services will be discontinued and stop serving traffic on December 9th, 2024.

Overview
The Pagoda RPC provides you with instant access to maintenance free, scalable NEAR infrastructure, powering you on the fastest path from ideas to launch.
Developers can interact with on-chain data and send different types of transactions to the network by utilizing the RPC endpoints.
In addition to the powerful node infrastructure, we also created the Pagoda RPC Stats page so that you can have visibility into your RPC usage and performances and take control of your project from the infrastructure level. What’s more? You can subscribe to the alerts from our Status page so that you can follow the health of Pagoda RPC real time. All accessible via Pagoda Console.
Setup
API Keys

Getting API keys
Testing your API keys

Tools

Postman setup
Command-line (CLI) setup
JavaScript setup
Rust setup


RPC Endpoints - Quick Links



API
Description




Access Keys
Retrieve information about an account's access keys.


Accounts / Contracts
View details about accounts and contracts as well as perform contract calls.


Block / Chunk
Query the network and get details about specific blocks or chunks.


Gas
Get gas price for a specific block or hash.


Protocol
Retrieve current genesis and protocol configuration.


Network
Return status information for nodes and validators.


Transactions
Send transactions and query their status.



tipYou can access the JSON RPC 2.0 endpoints using [Postman](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/pagoda/rpc/setup.md#postman-setup),
[JavaScript](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/pagoda/rpc/setup.md#javascript-setup), [Rust](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/pagoda/rpc/setup.md#rust-setup), and [CLI](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/pagoda/rpc/setup.md#command-line-setup).

### Get Pagoda API Keys

warning
Please be advised that these tools and services will be discontinued soon.



Register an account on Pagoda Console:



Create a blank project



Give your project a cool name



Grab your API Key
Click the API Tab and you will see your API key already generated for you and ready to use, remember to switch networks for MainNet using the button on top, you can also navigate through your different projects there.



Connect to Pagoda RPC Node
Follow the instructions on the screen to set up your Pagoda RPC Access, we have created a quick setup guide for all NEAR tools.

https://near-testnet.api.pagoda.co/rpc/v1/
https://near-mainnet.api.pagoda.co/rpc/v1/




You can use this line of code for a quick test
curl -X POST -H 'x-api-key:<YOUR-API-KEY>' -H 'Content-Type: application/json' -d '{"jsonrpc": "2.0", "id":"dontcare","method":"status","params":[] }' https://near-testnet.api.pagoda.co/rpc/v1/



Congrats! You are connected!

### NEAR Enhanced API

warning
Please be advised that these tools and services will be discontinued soon.


Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Try out our newly released Enhanced APIs - Balances (in Beta) and get what you need for all kinds of balances and token information at ease.
Call Enhanced APIs using the endpoint in the API URL box, varies by Network.

https://near-testnet.api.pagoda.co/eapi/v1
https://near-mainnet.api.pagoda.co/eapi/v1

Grab your API keys and give it a try! We will be adding more advanced Enhanced APIs in our offering, so stay tuned. Get the data you need without extra processing, NEAR Blockchain data query has never been easier!
We would love to hear from you on the data APIs you need, please leave feedback using the widget in the lower-right corner.
Base URLs:

https://near-testnet.api.pagoda.co/eapi/v1

Authentication

API Key (apiKey)

Parameter Name: x-api-key, in: header. Use Pagoda DevConsole API key here


Non Fungible Tokens
Get NFT

Code samples




```shell
# You can also use wget
curl -X GET https://near-testnet.api.pagoda.co/eapi/v1/NFT/{contract_account_id}/{token_id} 
  -H 'Accept: application/json' 
  -H 'x-api-key: API_KEY'

```





```http
GET https://near-testnet.api.pagoda.co/eapi/v1/NFT/{contract_account_id}/{token_id} HTTP/1.1
Host: near-testnet.api.pagoda.co
Accept: application/json

```





```javascript

const headers = {
  'Accept':'application/json',
  'x-api-key':'API_KEY'
};

fetch('https://near-testnet.api.pagoda.co/eapi/v1/NFT/{contract_account_id}/{token_id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

```





```ruby
require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'x-api-key' => 'API_KEY'
}

result = RestClient.get 'https://near-testnet.api.pagoda.co/eapi/v1/NFT/{contract_account_id}/{token_id}',
  params: {
  }, headers: headers

p JSON.parse(result)

```





```python

headers = {
  'Accept': 'application/json',
  'x-api-key': 'API_KEY'
}

r = requests.get('https://near-testnet.api.pagoda.co/eapi/v1/NFT/{contract_account_id}/{token_id}', headers = headers)

print(r.json())

```





```php

### webhooks

warning
Please be advised that these tools and services will be discontinued soon.

Overview
How cool would it be to have your lights turn on or your favorite song on spotify to play when someone bought your NFT on NEAR? 
With the Pagoda Console and IFTTT you can do both in minutes with zero code!
What will we be doing?
Using a combination of the Pagoda Console and IFTTT we will turn on our lights when a successful transaction has been processed. 
We will be using the webhook trigger to allow the pagoda console to call an endpoint on IFTTT which will then turn on our HUE Lights 
What is IFTTT?
IFTTT stands for "If This Then That". It's a platform (at ifttt.com) that provides a variety of services each with their own collection of applets within it that provide some unique functionality. 

If This
It starts with the "If This" Trigger. For example time could be your trigger, so if it's 10pm you can write your own script to turn off your lights. Or something more random like, liking a song on spotify could add the music video to a youtube playlist. 
There are a lot of triggers on this service, but just to name some examples 

Time
Temperature 
Webhooks (what we'll be using)

Then That
Next comes the "Then That" action. An action is what happens when your trigger has been tripped. For example, turning out the lights at 10pm OR turning them on when you mint an NFT on NEAR. 
Step 1: Getting the webhook address
We will be setting up a webhook trigger so after you make an account on ifttt.com You will see this page.... 

Go to the Services Tab and search for "webhook"

Click on the webhooks icon and then you'll be sent to this page...

Click on the "Documentation Button". This should open up a new tab....

Leave that page alone for now we'll come back to it. This is essentially where we get the webhook address we will call for our "IF". 
Step 2: Setting up your Trigger
Hit the Create Button on the upper right corner of the screen..

Next click on the "If This" Button...

Again search for webhooks ...

Select the Receive a Web Request trigger...

let's call this "on_transaction" then select create trigger 

Step 3: Select your Action
You for this tutorial you will need to have:

Hue Account
Hue Lights

Next click on Then That ...

Search for Hue

Select Turn On Lights 

Select the lights of your choosing but I will simply do all lights. 
If you haven't already create and connect your Hue Account

After you do this simply hit Create Action Then you'll be redirected here... 

As you can see you can add more than one trigger or action if you'd like. But for now we'll stick to the one. Hit Continue
Step 4: Setting up your endpoint
Once you hit Continue you'll be redirected here...

take note of the name "on_transaction" and copy it.. then hit the Finish button...
Next go back to the documentation tab we opened up earlier
Where it says {event} replace everything even the curly braces with "on_transaction"

to 

copy that entire line and head on over to console.pagoda.co 
Step 5: Integrating Webhook into Pagoda Console
Once at console.pagoda.co, you should be greeted by the log-in page. Select the Non-fungible Token (NFT) project to start exploring the NFT contract

Hit the "Deploy and Explore Contract" Button. This will create a dev account for you and deploy the pre written NFT smart contract onto that account for you. 

Head to the Alerts section 

And select + New Alert

You should see this page...

Select the suggested contract which should be dev account that was created. 

infoYou can use any contract running on mainnet or testnet for an alert. We'll just use this NFT testnet example for this guide.  

Under "Select Condition" hit "Successful Transaction". This means that for any successful transaction an alert will be sent. In this case for any successful method call the lights will turn on. If you want to, you can select "function call" for a specific method to be the trigger. 
But for now, we'll keep it easy and select any Successful Action. 

We're almost done! Under destination select webhooks. Now that webhook we created earlier go ahead and copy and paste it into here. Then hit "Create"
tipon't forget to remove the `{}` around the name of your event! `ifttt.com/trigger/...`, not `ifttt.com/{trigger}/...`


Remember to hit the "+ Create Alert" button on this page...

Now head on over to the "Contracts" Section.

Select the contract we just created and navigate to the "Interact" tab to connect your wallet. 

Now here is the part we've all been waiting for... Turn on the (hue) lights! 
Select the new_default_metadata function (we are choosing this one because we have to initialize our contract, this is still a transaction which will trigger our new webhook). Fill in the owner_id field with your wallet account name and hit send transaction 

Wrapping up
And that's it! You've just triggered something in the real world with an event that happened on the NEAR Blockchain. Hopefully this inspires you to create your own webhook using IFTTT and the Pagoda Console. 
We'd love to see what you create! Tag @PagodaPlatform on Twitter with a novel implementation of a webhook and trigger and we might retweet it. 
Happy hacking!

### setup

warning
Please be advised that these tools and services will be discontinued soon.

Setting up E-mail alerts


Navigate to console.pagoda.co and log-in 


Navigate to the Alerts tab



Select a target address for the alert to listen to



Select one of the following conditions to listen for



Select email as the destination to send alerts to and enter an email address to send the alert to



This email address will need to be verified before it can be used as a valid alert destination. 



Be sure that the email destination is toggled on as shown below and click "Create Alert" to finish setting up your email alert



Setting up Telegram alerts
Follow the steps above to begin setting-up telegram alerts. When selecting the destination select Telegram and follow these steps to authorize Alerts

Private Message Alerts


On the device that is logged into the telegram click "Open Telegram" or scan the QR code. 



by Telegram. Hit "Send Message" to continue 



Once inside the chat, hit "Start" to begin receiving alerts at this destination 



Group message alerts
For group chats, add PagodaDevConsoleBot and copy the message you see in your on-screen modal and send it in the chat that includesPagodaDevConsoleBot to authorize the group chat destination

Setting up Event Log Alerts
You can listen to on-chain events occurring to contracts that follow NEPs standards like NEP-171 (NFTs), NEP-141 (fungible tokens), or NEP-145 (storage management). All NEAR NEPs can be found on the Nomicon NEAR site. 
To set-up an alert for an event, for example nft_transfer from NEP-171 version 1.1.0: 

Follow the steps above to begin setting up an alert.
Select the "Event Logged" condition,
Type the event name nft_transfer,
The standard nep171, and
Add the version 1.1.0 as seen below



Note that input fields are case sensitive, and the standards field must be written in the format nep123 not NEP-123

Setting up Function Call Specific Alerts
More generally, Pagoda Console makes it easy to generate alerts based on specific function calls. Simply follow the steps above, select the "Function Called" condition, and type the method name exactly as it appears in the contract code or the contract's ABI

### intro

warning
Please be advised that these tools and services will be discontinued and stop serving traffic on December 9th, 2024.


Pagoda Alerts & Triggers are designed to notify, and automated responses to important events that occur on the NEAR blockchain. Behind the scenes, Alerts are powered by  many mini-indexers, “Alertexersâ€, that stream blockchain data in real-time, enabling developers to know what’s happening to their dApp before their users do.
Alerts are broken into three parts: 

The NEAR address the alert should listen to (account or contract)
The event condition (success & failed actions, account drains, and more)
The alert destination (e-mail, Telegram, webhooks)

Alerts can be set-up to listen for the following five conditions: 

Successful Actions
Failed Actions
Event Logged
Function Called
Account Balance Change

Setup

E-mail alerts
Telegram alerts
Event Log Alerts
Function Call Specific Alerts


See an example on how to set up alerts using webhooks.

### NEAR - Your Gateway to an Open Web

NEAR is dedicated to providing the best developer experience possible for building an open web. This mission is next to impossible to achieve without feedback and contributions from people like you. 🫵
Get involved! 👉 please select one of the options above or contribute to one of the essential developer repositories listed below ðŸ™
infoContact Us
- [Developer Hub](https://neardevhub.org/)
- [Telegram Support](https://t.me/neardev)
- [Discord](https://near.chat)
- [Zulip](https://near.zulipchat.com)


📠Docs



Website
Description
Repo




docs.near.org
NEAR Developer Documentation
near/docs


nomicon.io
NEAR Protocol Specification Documentation
near/neps


near-nodes.io
NEAR Node Documentation (Validator, RPC, Archival)
near/node-docs




â›“ï¸ Protocol



Name
Description
Repo
Latest Release




nearcore
Reference implementation of NEAR Protocol
near/nearcore



NEPs
NEAR Protocol Specifications and Standards
near/neps
âž–




🚀 Decentralized Frontend Stack

Create decentralized frontend components by storing it's source code on the blockchain 🤯.




Name
Description
Repo
Latest Release




👉 GATEWAY


near-discovery
near.org Gateway
near/near-discovery



near.social
near.social Gateway
NearSocial/viewer
âž–


near-discovery-components
Core components / primitives for near.org
near/near-discovery-components
âž–


👉 EXECUTION ENVIRONMENT


VM
B.O.S. Virtual Machine
nearsocial/VM



BWE
B.O.S. Web Engine (WIP replacement for VM)
near/bos-web-engine
âž–


👉 DATABASE


B.O.S. Database
Smart contract hosting frontend source code & user data
nearsocial/social-db
âž–




ðŸ› ï¸ Dev Tools



Name
Description
Repo
Latest Release




create-near-app
Easy fullstack dApp deployment tool
near/create-near-app



cargo-near
Cargo extension for building smart contracts and ABI schemas on NEAR
near/cargo-near



BOS VSCode Ext.
VSCode extension for building B.O.S. components
near/near-vscode



BOS Loader
Simplifying multiple component local development
near/bos-loader




💻 CLI



Name
Description
Repo
Latest Release




near-cli-rs
Rust based CLI for interacting w/ NEAR
near/near-cli-rs



BOS CLI
CLI for simplifying local development on BOS
bos-cli-rs/bos-cli-rs




🔑 Wallet / Auth



Name
Description
Repo
Latest Release




wallet-selector
Wallet integration tool for NEAR
near/wallet-selector



web3-onboard
Wallet integration tool for multichain
blocknative/web3-onboard



FastAuth Signer
Authenticate and sign transactions w/ FastAuth
near/fast-auth-signer
âž–


mpc-recovery
Create and restore accounts w/ OIDC protocol
near/mpc-recovery
âž–


iDOS
Decentralized identity, storage, and verification
idos-network/idos-sdk-js
âž–



🔌 API



Name
Description
Repo
Latest Release




near-api-js
API tool for frontend & backend JS libraries
near/near-api-js




📠Smart Contracts



Name
Description
Repo
Latest Release




near-sdk-js
Create smart contracts w/ JavaScript
near/near-sdk-js



near-sdk-rs
Create smart contracts w/ Rust
near/near-sdk-rs



Keypom
Customizable key creation for NFT/FT drops
keypom/keypom




🧪 Testing



Name
Description
Repo
Latest Release




workspaces-js
Testing sandbox written in JS
near/workspaces-js



workspaces-rs
Testing sandbox written in Rust
near/workspaces-rs




🔎 Blockchain Data Indexing



Name
Description
Repo
Latest Release




QueryApi
Build custom indexers and query with GraphQL endpoints
near/queryapi
âž–


near-lake-indexer
Built on NEAR Indexer that stores JSON in AWS S3 bucket
near/near-lake-indexer



near-lake-framework-rs
Stream blocks from NEAR Lake into your server
near/near-lake-framework-rs



near-lake-framework-js
Stream blocks from NEAR Lake into your server
near/near-lake-framework-js
âž–

### Fungible tokens

Introduction
Please see the spec for the fungible token standard and an example implementation for reference details.
One notable aspect of the standard is that method names are prefixed with ft_. This will be a helpful convention when querying for transactions related to fungible tokens.
Get balance
Using the abstraction of the NEAR CLI tool, we can check the balance of a user's account with near view:
near view ft.demo.testnet ft_balance_of '{"account_id": "mike.testnet"}'
Returns:
View call: ft.demo.testnet.ft_balance_of({"account_id": "mike.testnet"})
'1000000'
Alternatively, you can call a contract function using the query RPC endpoint. Below is an example using HTTPie:
http post https://rpc.testnet.near.org jsonrpc=2.0 id=ftbalance method=query 
params:='{
  "request_type": "call_function",
  "finality": "final",
  "account_id": "ft.demo.testnet",
  "method_name": "ft_balance_of",
  "args_base64": "eyJhY2NvdW50X2lkIjogIm1pa2UudGVzdG5ldCJ9"
}'
Returns:
HTTP/1.1 200 OK
Alt-Svc: clear
Via: 1.1 google
access-control-allow-origin:
content-length: 176
content-type: application/json
date: Thu, 27 May 2021 12:53:38 GMT

{
    "id": "dontcare",
    "jsonrpc": "2.0",
    "result": {
        "block_hash": "3mvNHpZAsXiJ6SuHU1mbLVB4iXCfh5i5d41pnkaSoaJ5",
        "block_height": 49282350,
        "logs": [],
        "result": [ 34, 49, 48, 48, 48, 48, 48, 48, 34 ]
    }
}
As mentioned earlier, the result is an array of bytes. There are various ways to convert bytes into a more human-readable form such as the dtool CLI.
dtool a2h '[34,49,48,48,48,48,48,48,34]' | dtool h2s
Returns:
"1000000"
Note: The fungible token balance of the account mike.testnet is 1000000 wrapped in double-quotes. This is because of an issue with JSON serialization. Amounts given in arguments and results must be serialized as Base-10 strings, e.g. "100". This is done to avoid JSON limitation of max integer value of 2**53, which can certainly happen with fungible tokens.
Get info about the FT
You can get name, decimals, icon and other parameters by calling the next function:

using NEAR CLI:

near view <contract_account_id> ft_metadata
Result:
View call: ft.demo.testnet.ft_metadata()
{
  spec: 'ft-1.0.0',
  name: 'Example Token Name',
  symbol: 'MOCHI',
  icon: null,
  reference: null,
  reference_hash: null,
  decimals: 24
}

with JSON RPC call:

http post https://rpc.testnet.near.org jsonrpc=2.0 id=ftmetadata method=query 
  params:='{
    "request_type": "call_function",
    "finality": "final",
    "account_id": "<contract_account_id>",
    "method_name": "ft_metadata",
    "args_base64": ""
  }'
Example response:
HTTP/1.1 200 OK
Alt-Svc: clear
Via: 1.1 google
access-control-allow-origin:
content-length: 604
content-type: application/json
date: Wed, 02 Jun 2021 15:51:17 GMT

{
  "id": "ftmetadata",
  "jsonrpc": "2.0",
  "result": {
      "block_hash": "B3fu3v4dmn19B6oqjHUXN3k5NhdP9EW5kkjyuFUDpa1r",
      "block_height": 50061565,
      "logs": [],
      "result": [ 123, 34, 115, 112, 101, 99, 34, 58, 34, 102, 116, 45, 49, 46, 48, 46, 48, 34, 44, 34, 110, 97, 109, 101, 34, 58, 34, 69, 120, 97, 109, 112, 108, 101, 32, 84, 111, 107, 101, 110, 32, 78, 97, 109, 101, 34, 44, 34, 115, 121, 109, 98, 111, 108, 34, 58, 34, 77, 79, 67, 72, 73, 34, 44, 34, 105, 99, 111, 110, 34, 58, 110, 117, 108, 108, 44, 34, 114, 101, 102, 101, 114, 101, 110, 99, 101, 34, 58, 110, 117, 108, 108, 44, 34, 114, 101, 102, 101, 114, 101, 110, 99, 101, 95, 104, 97, 115, 104, 34, 58, 110, 117, 108, 108, 44, 34, 100, 101, 99, 105, 109, 97, 108, 115, 34, 58, 50, 52, 125 ]
  }
}
Decoded result in this case is:
{
    "spec": "ft-1.0.0",
    "name": "Example Token Name",
    "symbol": "MOCHI",
    "icon": null,
    "reference": null,
    "reference_hash": null,
    "decimals": 24
}
Simple transfer
To follow this guide, please check the step by step instructions on how to create a transaction first.
In order to send a fungible token to an account, the receiver must have a storage deposit. This is because each smart contract on NEAR must account for storage used, and each account on a fungible token contract is a key-value pair, taking up a small amount of storage. For more information, please see how storage works in NEAR. To check if account has deposited the storage for this FT do the following:
Get storage balance of the account. storage_balance_of function returns the amount of deposited storage or null if there is no deposit.

using NEAR CLI:

near view <contract_account_id> storage_balance_of '{"account_id": "<user_account_id>"}'
Result:
View call: ft.demo.testnet.storage_balance_of({"account_id": "serhii.testnet"})
null

with JSON RPC call:

http post https://rpc.testnet.near.org jsonrpc=2.0 id=storagebalanceof method=query 
  params:='{
     "request_type": "call_function",
     "finality": "final",
     "account_id": "ft.demo.testnet",
     "method_name": "storage_balance_of",
     "args_base64": "eyJhY2NvdW50X2lkIjogInNlcmhpaS50ZXN0bmV0In0K"
  }'
Example response:
HTTP/1.1 200 OK
Alt-Svc: clear
Via: 1.1 google
access-control-allow-origin:
content-length: 173
content-type: application/json
date: Wed, 02 Jun 2021 14:22:01 GMT
{
  "id": "storagebalanceof",
  "jsonrpc": "2.0",
  "result": {
      "block_hash": "EkM2j4yxRVoQ1TCqF2KUb7J4w5G1VsWtMLiycq6k3f53",
      "block_height": 50054247,
      "logs": [],
      "result": [ 110, 117, 108, 108 ]
  }
}
Decoded result in this case is null.
Get the minimum storage required for FT. (The storage used for an account's key-value pair.)

using NEAR CLI:

near view <contract_account_id> storage_balance_bounds`
Result:
View call: ft.demo.testnet.storage_balance_bounds()
{ min: '1250000000000000000000', max: '1250000000000000000000' }

with JSON RPC call

http post https://rpc.testnet.near.org jsonrpc=2.0 id=storagebalancebounds method=query 
  params:='{
      "request_type": "call_function",
      "finality": "final",
      "account_id": "<contract_account_id>",
      "method_name": "storage_balance_bounds",
      "args_base64": ""
  }'
Example response:
HTTP/1.1 200 OK
Alt-Svc: clear
Via: 1.1 google
access-control-allow-origin:
content-length: 357
content-type: application/json
date: Wed, 02 Jun 2021 15:42:49 GMT

{
  "id": "storagebalancebounds",
  "jsonrpc": "2.0",
  "result": {
      "block_hash": "Fy3mBqwj5nvUDha3X7G61kmUeituHASEX12oCASrChEE",
      "block_height": 50060878,
      "logs": [],
      "result": [ 123, 34, 109, 105, 110, 34, 58, 34, 49, 50, 53, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 34, 44, 34, 109, 97, 120, 34, 58, 34, 49, 50, 53, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 34, 125 ]
  }
}
Decoded result should look similar to:
  {
    "min": "1250000000000000000000",
    "max": "1250000000000000000000"
  }
Basic fungible tokens are simple smart contracts that don't have variable storage as compared to a smart contract that might store free-form text, for instance. The only storage needed is for an accounts key-value pair, which will always be covered by the 1250000000000000000000 yoctoⓃ storage balance.
If there is not enough deposit for the storage or returned value is null - you should deposit more storage with the next command:

using NEAR CLI, don't forget to convert from yoctoⓃ to Ⓝ:


  

  ```bash
  near call  storage_deposit '{"account_id": ""}' --accountId  --deposit 
  ```
  

  

    ```bash
    near contract call-function as-transaction  storage_deposit json-args '{"account_id": ""}' prepaid-gas '100.0 Tgas' attached-deposit ' NEAR' sign-as  network-config testnet sign-with-keychain send
    ```
  

Result example:
Scheduling a call: ft.demo.testnet.storage_deposit() with attached 0.125 NEAR
Transaction Id 9CMrMMt3UzeU63FFrUyFb1gNGuHXxvKfHqYJzyFTAk6z
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/9CMrMMt3UzeU63FFrUyFb1gNGuHXxvKfHqYJzyFTAk6z
{ total: '1250000000000000000000', available: '0' }


with JSON RPC call:
At the top of this section is a link detailing how to construct a transaction without the full abstraction of the near-api-js library. For this and future examples that use the RPC method broadcast_tx_commit we will provide a JSON-like object meant to act similar to pseudocode, only imparting high-level details of a transaction. This code block below is the first example of this, detailing what goes into the transaction discussed currently, involving the method storage_deposit.


Transaction: {
    block_hash: `456…abc`,
    signer_ public_key: "ed25519:789…def",
    nonce: 123,
    receiver_   actions: [
        FunctionCall(
            FunctionCallAction {
                method_name: storage_deposit,
                args: `{"account_id": "robertyan.near"}`,
                gas: 300000000000000,
                deposit: 1250000000000000000000,
            },
        ),
    ]
}
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
  params:='["DgAAAHNlcmhpaS50ZXN0bmV0AEKEp54fyVkp8dJE2l/m1ErjdhDGodBK8ZF6JLeHFMeZi/qoVEgrAAAPAAAAZnQuZGVtby50ZXN0bmV0JYbWPOu0P9T32vtUKnZSh+EaoboQqg0/De2i8Y+AjHIBAAAAAg8AAABzdG9yYWdlX2RlcG9zaXQCAAAAe30AQHoQ81oAAAAAILSd2XlDeBoAAAAAAAAAZF7+s4lcHOzy+re59VErt7LcZkPMMUVgOJV8LH5TsLBBv+8h/5tZ6+HFwxSp605A4c46oS9Jw4KBRXZD07lKCg=="]'


**Example Response:**

```json
{
  "id": "myid",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "serhii.testnet",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "e30=",
                  "deposit": "125000000000000000000000",
                  "gas": 100000000000000,
                  "method_name": "storage_deposit"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "4urgFabknn1myZkjTYdb1BFSoEimP21k9smCUWoSggA7",
        "receiver_id": "ft.demo.testnet"
      },
      {
        "predecessor_id": "ft.demo.testnet",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "123750000000000000000000"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "7neJYE45vXnQia1LQqWuAfyTRXHy4vv88JaULa5DnNBd",
        "receiver_id": "serhii.testnet"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "19200274886926125000"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "2c59u2zYj41JuhMfPUCKjNucmYfz2Jt83JLWP6VyQn1S",
        "receiver_id": "serhii.testnet"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18587201427159524319124"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "kaYatRKxcC1NXac69WwTqg6K13oXq2yEuy4LLZtsV2G",
        "receiver_id": "serhii.testnet"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "6Gz6P8N3F447kRc7kkxEhuZRZTzfuTUEagye65bPVGb",
        "id": "4urgFabknn1myZkjTYdb1BFSoEimP21k9smCUWoSggA7",
        "outcome": {
          "executor_id": "ft.demo.testnet",
          "gas_burnt": 4258977405434,
          "logs": [],
          "receipt_ids": [
            "7neJYE45vXnQia1LQqWuAfyTRXHy4vv88JaULa5DnNBd",
            "kaYatRKxcC1NXac69WwTqg6K13oXq2yEuy4LLZtsV2G"
          ],
          "status": {
            "SuccessValue": "eyJ0b3RhbCI6IjEyNTAwMDAwMDAwMDAwMDAwMDAwMDAiLCJhdmFpbGFibGUiOiIwIn0="
          },
          "tokens_burnt": "425897740543400000000"
        },
        "proof": []
      },
      {
        "block_hash": "J6YXMnLPfLEPyvL3fWdhWPzpWAeW8zNY2CwAFwAg9tfr",
        "id": "7neJYE45vXnQia1LQqWuAfyTRXHy4vv88JaULa5DnNBd",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 223182562500,
          "logs": [],
          "receipt_ids": [
            "2c59u2zYj41JuhMfPUCKjNucmYfz2Jt83JLWP6VyQn1S"
          ],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "22318256250000000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "D6tGfHwKh21PqzhBTsdKCsTtZvXFDkmH39dQiQBoGN3w"
          }
        ]
      },
      {
        "block_hash": "HRRF7N1PphZ46eN5g4DjqEgYHBYM76yGiXSTYWsfMGoy",
        "id": "2c59u2zYj41JuhMfPUCKjNucmYfz2Jt83JLWP6VyQn1S",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      },
      {
        "block_hash": "J6YXMnLPfLEPyvL3fWdhWPzpWAeW8zNY2CwAFwAg9tfr",
        "id": "kaYatRKxcC1NXac69WwTqg6K13oXq2yEuy4LLZtsV2G",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "1uVJZ8vNQpHMwPA38DYJjk9PpvnHDhsDcMxrTXcwf1s"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": "eyJ0b3RhbCI6IjEyNTAwMDAwMDAwMDAwMDAwMDAwMDAiLCJhdmFpbGFibGUiOiIwIn0="
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "e30=",
            "deposit": "125000000000000000000000",
            "gas": 100000000000000,
            "method_name": "storage_deposit"
          }
        }
      ],
      "hash": "6sDUF1f5hebpybUbipNJer5ez13EY4HW1VBJEBqZjCEm",
      "nonce": 47589658000011,
      "public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN",
      "receiver_id": "ft.demo.testnet",
      "signature": "ed25519:31PfuinsVvM1o2CmiZbSguFkZKYqAtkf5PHerfexhDbC3SsJWDzRFBpoUYTNDJddhKeqs93GQ3SHtUyqaSYhhQ9X",
      "signer_id": "serhii.testnet"
    },
    "transaction_outcome": {
      "block_hash": "5XiuxzTpyw6p2NTD5AqrZYNW7SHvpj8MhUCyn1x2KSQR",
      "id": "6sDUF1f5hebpybUbipNJer5ez13EY4HW1VBJEBqZjCEm",
      "outcome": {
        "executor_id": "serhii.testnet",
        "gas_burnt": 2427959010878,
        "logs": [],
        "receipt_ids": [
          "4urgFabknn1myZkjTYdb1BFSoEimP21k9smCUWoSggA7"
        ],
        "status": {
          "SuccessReceiptId": "4urgFabknn1myZkjTYdb1BFSoEimP21k9smCUWoSggA7"
        },
        "tokens_burnt": "242795901087800000000"
      },
      "proof": []
    }
  }
}
```


Transfer the tokens:

using NEAR CLI:


  

  ```bash
  near call  ft_transfer '{"receiver_id": "", "amount": "1"}' --accountId  --amount 0.000000000000000000000001
  ```
  

  

    ```bash
    near contract call-function as-transaction  ft_transfer json-args '{"receiver_id": "", "amount": "1"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as  network-config testnet sign-with-keychain send
    ```
  

Result example:
Scheduling a call: berryclub.ek.near.ft_transfer({"receiver_id": "volovyk.near", "amount": "1"}) with attached 0.000000000000000000000001 NEAR
Receipt: GDeE3Kv1JHgs71A22NEUbgq55r2Hvcnis8gCMyJtQ2mx
    Log [berryclub.ek.near]: Transfer 1 from serhii.near to volovyk.near
Transaction Id 3MkWKbXVP8wyy4pBofELqiE1pwx7ie2v3SKCwaobNcEe
To see the transaction in the transaction explorer, please open this url in your browser
https://nearblocks.io/txns/3MkWKbXVP8wyy4pBofELqiE1pwx7ie2v3SKCwaobNcEe
''

with JSON RPC call:

Transaction representation:
Transaction: {
    block_hash: `456…abc`,
    signer_ public_key: "ed25519:789…def",
    nonce: 123,
    receiver_   actions: [
        FunctionCall(
            FunctionCallAction {
                method_name: ft_transfer,
                args: `{"receiver_id": "volovyk.near", "amount": "1"}`,
                gas: 300000000000000,
                deposit: 1,
            },
        ),
    ]
}
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
  params:='["CwAAAHNlcmhpaS5uZWFyAAmQpgZcJM5nMc6f3tqmw/YI4eAvc84ZgsKMRRRzhY/6CQAAAAAAAAARAAAAYmVycnljbHViLmVrLm5lYXLLWPIiUOElkDF3u4hLAMJ0Sjeo1V338pDdHIp70va3ewEAAAACCwAAAGZ0X3RyYW5zZmVyKwAAAHsicmVjZWl2ZXJfaWQiOiJ2b2xvdnlrLm5lYXIiLCJhbW91bnQiOiIxIn0AQHoQ81oAAAEAAAAAAAAAAAAAAAAAAAAA7fDOZQt3zCtdS05Y8XaZFlwO/Gd5wkkNAHShzDiLQXk4Q4ixpraLPMJivs35PZD0gocXl1iGFbQ46NG3VllzCA=="]'
To get details of this transaction:
http post https://archival-rpc.mainnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_tx_status 
  params:='["2Fy4714idMCoja7QLdGAbQZHzV2XEnUdwZX6yGa46VMX", "serhii.near"]' id=myid


**Example Response:**

```json
{
  "id": "myid",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "serhii.near",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJyZWNlaXZlcl9pZCI6InZvbG92eWsubmVhciIsImFtb3VudCI6IjEifQ==",
                  "deposit": "1",
                  "gas": 100000000000000,
                  "method_name": "ft_transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.near",
            "signer_public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM"
          }
        },
        "receipt_id": "ExhYcvwAUb3Jpm38pSQ5oobwJAouBqqDZjbhavKrZtur",
        "receiver_id": "berryclub.ek.near"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18418055677558685763688"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.near",
            "signer_public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM"
          }
        },
        "receipt_id": "EAPh8XrBMqm6iuVH5jsfemz4YqUxWsV8Mz241cw5tjvE",
        "receiver_id": "serhii.near"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "6Re4NTkKzD7maKx3MuoxzYVHQKqjgnXW8rNjGjeVx8YC",
        "id": "ExhYcvwAUb3Jpm38pSQ5oobwJAouBqqDZjbhavKrZtur",
        "outcome": {
          "executor_id": "berryclub.ek.near",
          "gas_burnt": 6365774114160,
          "logs": [
            "Transfer 1 from serhii.near to volovyk.near"
          ],
          "receipt_ids": [
            "EAPh8XrBMqm6iuVH5jsfemz4YqUxWsV8Mz241cw5tjvE"
          ],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "636577411416000000000"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "2eUmWnLExsH5jb6mALY9jTC8FiQH4FcuxQ16tn7RfkYr"
          },
          {
            "direction": "Right",
            "hash": "266d5QfDKXNbAWJgXMJXgLP97VwoMiC4Qyt8wH7xcs1Q"
          },
          {
            "direction": "Right",
            "hash": "EkJAuJigdVSZj41yGXSZYAtDV7Xwe2Hv9Xsqcv6LUZvq"
          }
        ]
      },
      {
        "block_hash": "3XMoeEdm1zE64aByFuWCrZaxfbvsjMHRFcL8Wsp95vyt",
        "id": "EAPh8XrBMqm6iuVH5jsfemz4YqUxWsV8Mz241cw5tjvE",
        "outcome": {
          "executor_id": "serhii.near",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "EGC9ZPJHTbmCs3aQDuCkFQboGLBxU2uzrSZMsp8WonDu"
          },
          {
            "direction": "Right",
            "hash": "EsBd1n7bDAphA3HY84DrrKd1GP1VugeNiqFCET2S5sNG"
          },
          {
            "direction": "Left",
            "hash": "H4q3ByfNB7QH9QEuHN3tcGay7tjhsZwjXx3sq3Vm3Lza"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZWNlaXZlcl9pZCI6InZvbG92eWsubmVhciIsImFtb3VudCI6IjEifQ==",
            "deposit": "1",
            "gas": 100000000000000,
            "method_name": "ft_transfer"
          }
        }
      ],
      "hash": "2Fy4714idMCoja7QLdGAbQZHzV2XEnUdwZX6yGa46VMX",
      "nonce": 10,
      "public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM",
      "receiver_id": "berryclub.ek.near",
      "signature": "ed25519:5eJPGirNkBUbMeyRfEA4fgi1FtkgGk8pmbbkmiz3Faf6zrANpBsCs5bZd5heSTvQ6b3fEPLSPCPi2iwD2XJT93As",
      "signer_id": "serhii.near"
    },
    "transaction_outcome": {
      "block_hash": "EAcwavyaeNWZnfhYP2nAWzeDgMiuiyRHfaprFqhXgCRF",
      "id": "2Fy4714idMCoja7QLdGAbQZHzV2XEnUdwZX6yGa46VMX",
      "outcome": {
        "executor_id": "serhii.near",
        "gas_burnt": 2428041740436,
        "logs": [],
        "receipt_ids": [
          "ExhYcvwAUb3Jpm38pSQ5oobwJAouBqqDZjbhavKrZtur"
        ],
        "status": {
          "SuccessReceiptId": "ExhYcvwAUb3Jpm38pSQ5oobwJAouBqqDZjbhavKrZtur"
        },
        "tokens_burnt": "242804174043600000000"
      },
      "proof": [
        {
          "direction": "Right",
          "hash": "GatQmy7fW5uXRJRSg7A315CWzWWcQCGk4GJXyW3cjw4j"
        },
        {
          "direction": "Right",
          "hash": "89WJwAetivZLvAkVLXUt862o7zJX7YYt6ZixdWebq3xv"
        },
        {
          "direction": "Right",
          "hash": "CH3wHSqYPJp35krLjSgJTgCFYnv1ymhd9bJpjXA31VVD"
        }
      ]
    }
  }
}
```


You can get the same info later by the transaction hash from the previous call:

using NEAR Explorer: https://nearblocks.io



with JSON RPC call

  http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_tx_status 
  params:='[ "2Fy4714idMCoja7QLdGAbQZHzV2XEnUdwZX6yGa46VMX", "sender.testnet"]'
Let's create test transaction that should fail and investigate the response. We will try to send more tokens that are available on this account:

using NEAR CLI:


  

  ```bash
  near call  ft_transfer '{"receiver_id": "", "amount": "10000000000"}' --accountId  --amount 0.000000000000000000000001
  ```
  

  

    ```bash
    near contract call-function as-transaction  ft_transfer json-args '{"receiver_id": "", "amount": "1"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as  network-config testnet sign-with-keychain send
    ```
  


with JSON RPC call:

Transaction representation:
Transaction: {
    block_hash: `456…abc`,
    signer_ public_key: "ed25519:789…def",
    nonce: 123,
    receiver_   actions: [
        FunctionCall(
            FunctionCallAction {
                method_name: ft_transfer,
                args: `{"receiver_id":"volovyk.near","amount":"10000000000000000000"}`,
                gas: 300000000000000,
                deposit: 1,
            },
        ),
    ]
}
  http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
  params:='["DgAAAHNlcmhpaS50ZXN0bmV0AEKEp54fyVkp8dJE2l/m1ErjdhDGodBK8ZF6JLeHFMeZofqoVEgrAAAgAAAAZGV2LTE2MjMzMzM3OTU2MjMtMjEzOTk5NTk3NzgxNTm8Xq8BTIi6utG0424Gg7CknYzLH8RH/A409jq5o0zi7gEAAAACCwAAAGZ0X3RyYW5zZmVyPwAAAHsicmVjZWl2ZXJfaWQiOiJkZXYtMTYyMzMzMzkxNjM2OC01ODcwNzQzNDg3ODUzMyIsImFtb3VudCI6IjEifQBAehDzWgAAAQAAAAAAAAAAAAAAAAAAAABCwjqayKdpWgM6PE0ixzm/Gy0EtdpxVn0xehMTBReVfVAKIBTDPoPSaOdT8fAhk343F5uOMfSijhTqU2mWV3oD"]'
To get details of this transaction:
http post https://archival-rpc.mainnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_tx_status 
  params:='["CKHzodHvFw4C87PazsniycYZZHm37CEWLE2u8VUUMU7r", "serhii.near"]' id=myid


**Example Response:**

```json
{
  "id": "myid",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "serhii.near",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJyZWNlaXZlcl9pZCI6InZvbG92eWsubmVhciIsImFtb3VudCI6IjEwMDAwMDAwMDAwMDAwMDAwMDAwIn0=",
                  "deposit": "1",
                  "gas": 100000000000000,
                  "method_name": "ft_transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.near",
            "signer_public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM"
          }
        },
        "receipt_id": "5bdBKwS1RH7wm8eoG6ZeESdhNpj9HffUcf8RoP6Ng5d",
        "receiver_id": "berryclub.ek.near"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "1"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "system",
            "signer_public_key": "ed25519:11111111111111111111111111111111"
          }
        },
        "receipt_id": "Td3QxpKhMdi8bfVeMiQZwNS1VzPXceQdn6xdftoC8k6",
        "receiver_id": "serhii.near"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18653463364152698495356"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.near",
            "signer_public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM"
          }
        },
        "receipt_id": "DwLMVTdqv9Z4g9QC4AthTXHqqeJVAH4s1tFXHQYMArW7",
        "receiver_id": "serhii.near"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "DTruWLgm5Y56yDrxUipvYqKKm8F7hxVQTarNQqe147zs",
        "id": "5bdBKwS1RH7wm8eoG6ZeESdhNpj9HffUcf8RoP6Ng5d",
        "outcome": {
          "executor_id": "berryclub.ek.near",
          "gas_burnt": 4011776278642,
          "logs": [],
          "receipt_ids": [
            "Td3QxpKhMdi8bfVeMiQZwNS1VzPXceQdn6xdftoC8k6",
            "DwLMVTdqv9Z4g9QC4AthTXHqqeJVAH4s1tFXHQYMArW7"
          ],
          "status": {
            "Failure": {
              "ActionError": {
                "index": 0,
                "kind": {
                  "FunctionCallError": {
                    "ExecutionError": "Smart contract panicked: The account doesn't have enough balance"
                  }
                }
              }
            }
          },
          "tokens_burnt": "401177627864200000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "6GHrA42oMEF4g7YCBpPw9EakkLiepTHnQBvaKtmsenEY"
          },
          {
            "direction": "Right",
            "hash": "DCG3qZAzf415twXfHmgBUdB129g2iZoQ4v8dawwBzhSh"
          }
        ]
      },
      {
        "block_hash": "F9xNWGhJuYW336f3qVaDDAipsyfpudJHYbmt5in3MeMT",
        "id": "Td3QxpKhMdi8bfVeMiQZwNS1VzPXceQdn6xdftoC8k6",
        "outcome": {
          "executor_id": "serhii.near",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "CJNvis1CoJmccshDpPBrk3a7fdZ5HnMQuy3p2Kd2GCdS"
          },
          {
            "direction": "Left",
            "hash": "4vHM3fbdNwXGMp9uYzVKB13abEM6qdPUuZ9rfrdsaDzc"
          }
        ]
      },
      {
        "block_hash": "F9xNWGhJuYW336f3qVaDDAipsyfpudJHYbmt5in3MeMT",
        "id": "DwLMVTdqv9Z4g9QC4AthTXHqqeJVAH4s1tFXHQYMArW7",
        "outcome": {
          "executor_id": "serhii.near",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "BR3R7tjziEgXMiHaJ7VuuXCo2yBHB2ZzsoxobPhPjFeJ"
          },
          {
            "direction": "Left",
            "hash": "4vHM3fbdNwXGMp9uYzVKB13abEM6qdPUuZ9rfrdsaDzc"
          }
        ]
      }
    ],
    "status": {
      "Failure": {
        "ActionError": {
          "index": 0,
          "kind": {
            "FunctionCallError": {
              "ExecutionError": "Smart contract panicked: The account doesn't have enough balance"
            }
          }
        }
      }
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZWNlaXZlcl9pZCI6InZvbG92eWsubmVhciIsImFtb3VudCI6IjEwMDAwMDAwMDAwMDAwMDAwMDAwIn0=",
            "deposit": "1",
            "gas": 100000000000000,
            "method_name": "ft_transfer"
          }
        }
      ],
      "hash": "CKHzodHvFw4C87PazsniycYZZHm37CEWLE2u8VUUMU7r",
      "nonce": 12,
      "public_key": "ed25519:eLbduR3uJGaAHLXeGKEfo1fYmYFKkLyR1R8ZPCxrJAM",
      "receiver_id": "berryclub.ek.near",
      "signature": "ed25519:63MC3f8m5jeycpy97G9XaCwmJLx4YHRn2x5AEJDiYYzZ3TzdzWsrz8dgaz2kHR2jsWh35aZoL97tw1RRTHK6ZQYq",
      "signer_id": "serhii.near"
    },
    "transaction_outcome": {
      "block_hash": "7YUgyBHgmbGy1edhaWRZeBVq9zzbnzrRGtVRQS5PpooW",
      "id": "CKHzodHvFw4C87PazsniycYZZHm37CEWLE2u8VUUMU7r",
      "outcome": {
        "executor_id": "serhii.near",
        "gas_burnt": 2428084223182,
        "logs": [],
        "receipt_ids": [
          "5bdBKwS1RH7wm8eoG6ZeESdhNpj9HffUcf8RoP6Ng5d"
        ],
        "status": {
          "SuccessReceiptId": "5bdBKwS1RH7wm8eoG6ZeESdhNpj9HffUcf8RoP6Ng5d"
        },
        "tokens_burnt": "242808422318200000000"
      },
      "proof": [
        {
          "direction": "Right",
          "hash": "Agyg5P46kSVa4ptG9spteHpZ5c8XkvfbmDN5EUXhC1Wr"
        },
        {
          "direction": "Right",
          "hash": "3JDKkLCy5bJaAU3exa66sotTwJyGwyChxeNJgKReKw34"
        },
        {
          "direction": "Right",
          "hash": "7GXEmeQEJdd4c2kgN7NoYiF2bkjzV4bNkMmkhpK14NTz"
        }
      ]
    }
  }
}
```


Was the fungible token transfer successful?

Look for result » transaction_outcome » outcome » see if SuccessReceiptId is a key
if SuccessReceiptId is not a key, this fungible token transfer has failed.
If it does have that key, get the value, which is a receipt ID
Loop through result » receipts_outcome until you find an object that ID (from above) under the id key
in that object check outcome » status » (see if SuccessValue is a key)
If SuccessValue is a key, fungible token transfer succeeded, if not, it failed.

To determine how many fungible tokens were transferred, look at:

result » transaction » actions » FunctionCall » args
then take the args and base64 decode it, that will give you a JSON payload and look for the amount key
It will contain a stringified number that represents the number of fungible tokens that were successfully transferred

Transfer and call
If the idea of a fungible token using "transfer and call" is new, please review the comments above the function in the Nomicon spec. Also, see a similar idea from EIP-677.
For this example we will build and deploy FT contracts from near-sdk-rs/examples/fungible-token.
Let's call ft_transfer_call function on ft contract (receiver) and examine successful and unsuccessful scenarios.
Successful transfer and call
Let's send 10 N to DEFI contract that requires only 9 N.


using NEAR CLI

  

  ```bash
  near call  ft_transfer_call '{"receiver_id": "", "amount": "10", "msg": "take-my-money"}' --accountId  --amount 0.000000000000000000000001
  ```
  

  

    ```bash
    near contract call-function as-transaction  ft_transfer_call json-args '{"receiver_id": "", "amount": "10", "msg": "take-my-money"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as  network-config testnet sign-with-keychain send
    ```
  



with JSON RPC call


Transaction representation:
Transaction: {
    block_hash: `456…abc`,
    signer_ public_key: "ed25519:789…def",
    nonce: 123,
    receiver_   actions: [
        FunctionCall(
            FunctionCallAction {
                method_name: ft_transfer_call,
                args: `{"receiver_id":"dev-1623693121955-71667632531176","amount":"10","msg":"take-my-money"}`,
                gas: 300000000000000,
                deposit: 1,
            },
        ),
    ]
}
  http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
  params:='["DgAAAHNlcmhpaS50ZXN0bmV0AEKEp54fyVkp8dJE2l/m1ErjdhDGodBK8ZF6JLeHFMeZqPqoVEgrAAAgAAAAZGV2LTE2MjMzMzM3OTU2MjMtMjEzOTk5NTk3NzgxNTn9j4g2IJ8nGQ38i3+k+4WBAeJL1xP7ygQhC7CrvEG4NQEAAAACEAAAAGZ0X3RyYW5zZmVyX2NhbGxWAAAAeyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzNjkzMTIxOTU1LTcxNjY3NjMyNTMxMTc2IiwiYW1vdW50IjoiMTAiLCJtc2ciOiJ0YWtlLW15LW1vbmV5In0AQHoQ81oAAAEAAAAAAAAAAAAAAAAAAAAANY2lHqJlAJYNDGEQiUNnmfiBV44Q1sdg45xNlNvlROOM+AtN1z3PSJqM6M6jAKXUwANoQTzFqXhIMHIjIPbTAA=="]'
To get details of this transaction:
http post https://archival-rpc.testnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_tx_status 
    params:='["5n1kwA3TQQyFTkddR2Jau3H1Pt8ebQNGaov6aCQ6TDp1", "serhii.testnet"]' id=myid


**Example Response:**

```json
{
  "id": "myid",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "serhii.testnet",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzNjkzMTIxOTU1LTcxNjY3NjMyNTMxMTc2IiwiYW1vdW50IjoiMTAiLCJtc2ciOiJ0YWtlLW15LW1vbmV5In0=",
                  "deposit": "1",
                  "gas": 100000000000000,
                  "method_name": "ft_transfer_call"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "Hw6z8kJ7CSaC6SgyQzcmXzNX9gq1gaAnLS169qgyZ2Vk",
        "receiver_id": "dev-1623333795623-21399959778159"
      },
      {
        "predecessor_id": "dev-1623333795623-21399959778159",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJzZW5kZXJfaWQiOiJzZXJoaWkudGVzdG5ldCIsImFtb3VudCI6IjEwIiwibXNnIjoidGFrZS1teS1tb25leSJ9",
                  "deposit": "0",
                  "gas": 70000000000000,
                  "method_name": "ft_on_transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [
              {
                "data_id": "EiDQi54XHfdD1KEcgiNzogXxXuwTpzeQfmyqVwbq7H4D",
                "receiver_id": "dev-1623333795623-21399959778159"
              }
            ],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "EB69xtJiLRh9RNzAHgBGmom8551hrK2xSRreqbjvJgu5",
        "receiver_id": "dev-1623693121955-71667632531176"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "13116953530949529501760"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "AkwgvxUspRgy255fef2hrEWMbrMWFtnTRGduSgDRdSW1",
        "receiver_id": "serhii.testnet"
      },
      {
        "predecessor_id": "dev-1623333795623-21399959778159",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJzZW5kZXJfaWQiOiJzZXJoaWkudGVzdG5ldCIsInJlY2VpdmVyX2lkIjoiZGV2LTE2MjM2OTMxMjE5NTUtNzE2Njc2MzI1MzExNzYiLCJhbW91bnQiOiIxMCJ9",
                  "deposit": "0",
                  "gas": 5000000000000,
                  "method_name": "ft_resolve_transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [
              "EiDQi54XHfdD1KEcgiNzogXxXuwTpzeQfmyqVwbq7H4D"
            ],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "4Tc8MsrJZSMpNZx7u4jSqxr3WhRzqxaNHxLJFqz8tUPR",
        "receiver_id": "dev-1623333795623-21399959778159"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "761030677610514102464"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "9rxcC9o8x4RX7ftsDCfxK8qnisYv45rA1HGPxhuukWUL",
        "receiver_id": "serhii.testnet"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "2137766093631769060520"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "H7YWFkvx16Efy2keCQ7BQ67BMEsdgdYLqJ99G4H3dR1D",
        "receiver_id": "serhii.testnet"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "B9yZz1w3yzrqQnfBFAf17S4TLaHakXJWqmFDBbFxaEiZ",
        "id": "Hw6z8kJ7CSaC6SgyQzcmXzNX9gq1gaAnLS169qgyZ2Vk",
        "outcome": {
          "executor_id": "dev-1623333795623-21399959778159",
          "gas_burnt": 20612680932083,
          "logs": [
            "Transfer 10 from serhii.testnet to dev-1623693121955-71667632531176"
          ],
          "receipt_ids": [
            "EB69xtJiLRh9RNzAHgBGmom8551hrK2xSRreqbjvJgu5",
            "4Tc8MsrJZSMpNZx7u4jSqxr3WhRzqxaNHxLJFqz8tUPR",
            "H7YWFkvx16Efy2keCQ7BQ67BMEsdgdYLqJ99G4H3dR1D"
          ],
          "status": {
            "SuccessReceiptId": "4Tc8MsrJZSMpNZx7u4jSqxr3WhRzqxaNHxLJFqz8tUPR"
          },
          "tokens_burnt": "2061268093208300000000"
        },
        "proof": []
      },
      {
        "block_hash": "7Z4LHWksvw7sKYKwpQfjEMG8oigjtRXKa3EopN7hS2v7",
        "id": "EB69xtJiLRh9RNzAHgBGmom8551hrK2xSRreqbjvJgu5",
        "outcome": {
          "executor_id": "dev-1623693121955-71667632531176",
          "gas_burnt": 3568066327145,
          "logs": [
            "Sender @serhii.testnet is transferring 10 tokens using ft_on_transfer, msg = take-my-money"
          ],
          "receipt_ids": [
            "AkwgvxUspRgy255fef2hrEWMbrMWFtnTRGduSgDRdSW1"
          ],
          "status": {
            "SuccessValue": "IjEi"
          },
          "tokens_burnt": "356806632714500000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "5X2agUKpqmk7QkUZsDQ4R4HdX7zXeuPYpVAfvbmF5Gav"
          }
        ]
      },
      {
        "block_hash": "CrSDhQNn72K2Qr1mmoM9j3YHCo3wfZdmHjpHJs74WnPk",
        "id": "AkwgvxUspRgy255fef2hrEWMbrMWFtnTRGduSgDRdSW1",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "4WG6hF5fTAtM7GSqU8mprrFwRVbChGMCV2NPZEjEdnc1"
          }
        ]
      },
      {
        "block_hash": "CrSDhQNn72K2Qr1mmoM9j3YHCo3wfZdmHjpHJs74WnPk",
        "id": "4Tc8MsrJZSMpNZx7u4jSqxr3WhRzqxaNHxLJFqz8tUPR",
        "outcome": {
          "executor_id": "dev-1623333795623-21399959778159",
          "gas_burnt": 6208280264404,
          "logs": [
            "Refund 1 from dev-1623693121955-71667632531176 to serhii.testnet"
          ],
          "receipt_ids": [
            "9rxcC9o8x4RX7ftsDCfxK8qnisYv45rA1HGPxhuukWUL"
          ],
          "status": {
            "SuccessValue": "Ijki"
          },
          "tokens_burnt": "620828026440400000000"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "BzT8YhEDDWSuoGGTBzH2Cj5GC4c56uAQxk41by4KVnXi"
          }
        ]
      },
      {
        "block_hash": "3Q2Zyscj6vG5nC2vdoYfcBHU9RVaAwoxHsHzAKVcAHZ6",
        "id": "9rxcC9o8x4RX7ftsDCfxK8qnisYv45rA1HGPxhuukWUL",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      },
      {
        "block_hash": "7Z4LHWksvw7sKYKwpQfjEMG8oigjtRXKa3EopN7hS2v7",
        "id": "H7YWFkvx16Efy2keCQ7BQ67BMEsdgdYLqJ99G4H3dR1D",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "61ak42D3duBBunCz3w4xXxoEeR2N7oav5e938TnmGFGN"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": "Ijki"
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzNjkzMTIxOTU1LTcxNjY3NjMyNTMxMTc2IiwiYW1vdW50IjoiMTAiLCJtc2ciOiJ0YWtlLW15LW1vbmV5In0=",
            "deposit": "1",
            "gas": 100000000000000,
            "method_name": "ft_transfer_call"
          }
        }
      ],
      "hash": "5n1kwA3TQQyFTkddR2Jau3H1Pt8ebQNGaov6aCQ6TDp1",
      "nonce": 47589658000040,
      "public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN",
      "receiver_id": "dev-1623333795623-21399959778159",
      "signature": "ed25519:256qp2jAGXhhw2t2XfUAjWwzz3XcD83DH2v9THwDPsZjCLWHU8QJd6cuA773NP9yBmTd2ZyYiFHuxVEkYqnbsaSb",
      "signer_id": "serhii.testnet"
    },
    "transaction_outcome": {
      "block_hash": "96k8kKzFuZWxyiUnT774Rg7DC3XDZNuxhxD1qEViFupd",
      "id": "5n1kwA3TQQyFTkddR2Jau3H1Pt8ebQNGaov6aCQ6TDp1",
      "outcome": {
        "executor_id": "serhii.testnet",
        "gas_burnt": 2428149065268,
        "logs": [],
        "receipt_ids": [
          "Hw6z8kJ7CSaC6SgyQzcmXzNX9gq1gaAnLS169qgyZ2Vk"
        ],
        "status": {
          "SuccessReceiptId": "Hw6z8kJ7CSaC6SgyQzcmXzNX9gq1gaAnLS169qgyZ2Vk"
        },
        "tokens_burnt": "242814906526800000000"
      },
      "proof": []
    }
  }
}
```


Now, let's try to follow the steps described in the previous section and determine if these transactions was successful. In addition to being successful, let's analyze the various receipts in the series of cross-contract calls to determine how many fungible tokens were transferred. This will be the most complex case we'll look at.

Check that result » transaction_outcome » outcome » status has SuccessReceiptId as a key. If not, no fungible tokens were transferred.
Take the value of the SuccessReceiptId key. In the case above it's Hw6z8kJ7CSaC6SgyQzcmXzNX9gq1gaAnLS169qgyZ2Vk.
Now, under result » receipts loop through the array until you find a receipt where the receipt_id matches the value from step 2. (Note that in the receipt, under Actions there's an element mentioning calling the method_name: "ft_transfer_call".) On the same level of JSON, there's an args key. That's a base64-encoded value of the arguments passed to the method. When decoded it is:

{"receiver_id":"dev-1623693121955-71667632531176","amount":"10","msg":"take-my-money"}

Loop through result » receipts_outcome until finding the object where id is equal to the value from step 2. Similar to step 1, this object will also contain a status field that should contain the key SuccessReceiptId. Again, if this isn't there no fungible tokens were transferred, otherwise get the value of the SuccessReceiptId. In the above example, this value is 4Tc8MsrJZSMpNZx7u4jSqxr3WhRzqxaNHxLJFqz8tUPR.
Similar to the previous step, loop through the result » receipts_outcome until you find the object where the id matches the value from step 4. In that object check that outcome » status has the SuccessValue field. This SuccessValue represents how many fungible tokens the receiving contract is "returning" to the fungible token contract. Note that in the example above the value is Ijki, which is the base64-encoded version of "9". At this point, we know that 10 fungible tokens were sent (from step 3) and 9 were taken.

For additional clarity, let's take a look at one more optional aspect. In step 4 we isolated an obeject in result » receipts_outcome. There's an array of receipt_ids that's particularly interesting. The first element in the array is the receipt ID EB69xtJiLRh9RNzAHgBGmom8551hrK2xSRreqbjvJgu5. If we loop through the result » receipts_outcome and find this as the value for the id key, we'll see what happened in the function ft_on_transfer which takes place in the contract receiving the fungible tokens. In this object the status » SuccessValue is IjEi which is the base64-encoded value of "1".
In summary:

A user called the fungible token contract with the method ft_transfer_call specifying the receiver account, how many tokens to send, and custom info.
The receiver account implemented ft_on_transfer, returning "1" to the callback function on the fungible token contract.
The fungible token contract's callback is ft_resolve_transfer and receives this value of "1". It knows that 1 token was returned, so subtracts that from the 10 it intended to send. It then returns to the user how many tokens were used in this back-and-forth series of cross-contract calls: "9".

Failed transfer and call
Let's try to send more tokens than the account has:

using NEAR CLI


  

  ```bash
  near call  ft_transfer_call '{"receiver_id": "", "amount": "1000000000", "msg": "take-my-money"}' --accountId  --amount 0.000000000000000000000001
  ```
  

  

    ```bash
    near contract call-function as-transaction  ft_transfer_call json-args '{"receiver_id": "", "amount": "1000000000", "msg": "take-my-money"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as  network-config testnet sign-with-keychain send
    ```
  

Transaction representation:
Transaction: {
    block_hash: `456…abc`,
    signer_ public_key: "ed25519:789…def",
    nonce: 123,
    receiver_   actions: [
        FunctionCall(
            FunctionCallAction {
                method_name: ft_transfer_call,
                args: `{"receiver_id":"dev-1623333916368-58707434878533","amount":"1000000000","msg":"take-my-money"}`,
                gas: 300000000000000,
                deposit: 1,
            },
        ),
    ]
}

with JSON RPC call

  http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
  params:='["DgAAAHNlcmhpaS50ZXN0bmV0AEKEp54fyVkp8dJE2l/m1ErjdhDGodBK8ZF6JLeHFMeZn/qoVEgrAAAgAAAAZGV2LTE2MjMzMzM3OTU2MjMtMjEzOTk5NTk3NzgxNTnrbOQ93Wv9xxBwmq4yDYrssCpwKSI2bzjNNCCCHMZKNwEAAAACEAAAAGZ0X3RyYW5zZmVyX2NhbGxeAAAAeyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzMzMzOTE2MzY4LTU4NzA3NDM0ODc4NTMzIiwiYW1vdW50IjoiMTAwMDAwMDAwMCIsIm1zZyI6InRha2UtbXktbW9uZXkifQBAehDzWgAAAQAAAAAAAAAAAAAAAAAAAABQh3k+7zG2m/Yz3O/FBrvLaBwR/5YRB5FbFnb27Nfu6BW/Wh77RFH7+ktBwGLBwFbJGxiumIcsqBiGXgg1EPMN"]'
To get details of this transaction:
http post https://archival-rpc.testnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_tx_status 
    params:='["FQsh44pvEsK8RS9AbK868CmGwfhUU2pUrizkQ6wCWTsB", "serhii.testnet"]' id=myid


**Example response**:

```json
{
  "id": "myid",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "serhii.testnet",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzMzMzOTE2MzY4LTU4NzA3NDM0ODc4NTMzIiwiYW1vdW50IjoiMTAwMDAwMDAwMCIsIm1zZyI6InRha2UtbXktbW9uZXkifQ==",
                  "deposit": "1",
                  "gas": 100000000000000,
                  "method_name": "ft_transfer_call"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "83AdQ16bpAC7BEUyF7zoRsAgeNW7HHmjhZLvytEsrygo",
        "receiver_id": "dev-1623333795623-21399959778159"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "1"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "system",
            "signer_public_key": "ed25519:11111111111111111111111111111111"
          }
        },
        "receipt_id": "Euy4Q33DfvJTXD8HirE5ACoXnw9PMTQ2Hq47aGyD1spc",
        "receiver_id": "serhii.testnet"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18681184841157733814920"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "serhii.testnet",
            "signer_public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN"
          }
        },
        "receipt_id": "6ZDoSeV3gLFS2NXqMCJGEUR3VwBpSxBEPjnEEaAQfmXL",
        "receiver_id": "serhii.testnet"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "BohRBwqjRHssDVS9Gt9dj3SYuipxHA81xXFjRVLqgGeb",
        "id": "83AdQ16bpAC7BEUyF7zoRsAgeNW7HHmjhZLvytEsrygo",
        "outcome": {
          "executor_id": "dev-1623333795623-21399959778159",
          "gas_burnt": 3734715409940,
          "logs": [],
          "receipt_ids": [
            "Euy4Q33DfvJTXD8HirE5ACoXnw9PMTQ2Hq47aGyD1spc",
            "6ZDoSeV3gLFS2NXqMCJGEUR3VwBpSxBEPjnEEaAQfmXL"
          ],
          "status": {
            "Failure": {
              "ActionError": {
                "index": 0,
                "kind": {
                  "FunctionCallError": {
                    "ExecutionError": "Smart contract panicked: The account doesn't have enough balance"
                  }
                }
              }
            }
          },
          "tokens_burnt": "373471540994000000000"
        },
        "proof": []
      },
      {
        "block_hash": "4BzTmMmTjKvfs6ANS5gmJ6GQzhqianEGWq7SaxSfPbdC",
        "id": "Euy4Q33DfvJTXD8HirE5ACoXnw9PMTQ2Hq47aGyD1spc",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "5ipmcdgTieQqFXWQFCwcbZhFtkHE4PL4nW3mknBchpG6"
          }
        ]
      },
      {
        "block_hash": "4BzTmMmTjKvfs6ANS5gmJ6GQzhqianEGWq7SaxSfPbdC",
        "id": "6ZDoSeV3gLFS2NXqMCJGEUR3VwBpSxBEPjnEEaAQfmXL",
        "outcome": {
          "executor_id": "serhii.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "9tcjij6M8Ge4aJcAa97He5nw8pH7PF8ZjRHVahBZD2VW"
          }
        ]
      }
    ],
    "status": {
      "Failure": {
        "ActionError": {
          "index": 0,
          "kind": {
            "FunctionCallError": {
              "ExecutionError": "Smart contract panicked: The account doesn't have enough balance"
            }
          }
        }
      }
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZWNlaXZlcl9pZCI6ImRldi0xNjIzMzMzOTE2MzY4LTU4NzA3NDM0ODc4NTMzIiwiYW1vdW50IjoiMTAwMDAwMDAwMCIsIm1zZyI6InRha2UtbXktbW9uZXkifQ==",
            "deposit": "1",
            "gas": 100000000000000,
            "method_name": "ft_transfer_call"
          }
        }
      ],
      "hash": "FQsh44pvEsK8RS9AbK868CmGwfhUU2pUrizkQ6wCWTsB",
      "nonce": 47589658000031,
      "public_key": "ed25519:5UfEFyve3RdqKkWtALMreA9jzsAGDgCtwEXGNtkGeruN",
      "receiver_id": "dev-1623333795623-21399959778159",
      "signature": "ed25519:2cPASnxKtCoQtZ9NFq63fg8RzpjvmmE8hL4s2jk8zuhnBCD3AnYQ6chZZrUBGwu7WrsGuWUyohP1bEca4vfbsorC",
      "signer_id": "serhii.testnet"
    },
    "transaction_outcome": {
      "block_hash": "FwHUeqmYpvgkL7eBrUUAEMCuaQshcSy5vm4AHchebhK1",
      "id": "FQsh44pvEsK8RS9AbK868CmGwfhUU2pUrizkQ6wCWTsB",
      "outcome": {
        "executor_id": "serhii.testnet",
        "gas_burnt": 2428166952740,
        "logs": [],
        "receipt_ids": [
          "83AdQ16bpAC7BEUyF7zoRsAgeNW7HHmjhZLvytEsrygo"
        ],
        "status": {
          "SuccessReceiptId": "83AdQ16bpAC7BEUyF7zoRsAgeNW7HHmjhZLvytEsrygo"
        },
        "tokens_burnt": "242816695274000000000"
      },
      "proof": []
    }
  }
}
```


Let's examine this response.

result » transaction_outcome » outcome » status » SuccessReceiptId is 83AdQ16bpAC7BEUyF7zoRsAgeNW7HHmjhZLvytEsrygo
check result » receipts_outcome » 0 » outcome » status and find Failure status there

tipot a question?
 Ask it on StackOverflow!

### Implicit Accounts

Background
Implicit accounts work similarly to Bitcoin/Ethereum accounts.

They allow you to reserve an account ID before it's created by generating a ED25519 key-pair locally.
This key-pair has a public key that maps to the account ID.
The account ID is a lowercase hex representation of the public key.
An ED25519 Public key contains 32 bytes that maps to 64 characters account ID.
The corresponding secret key allows you to sign transactions on behalf of this account once it's created on chain.

infoYou can find the implicit accounts specification [here](https://nomicon.io/DataStructures/Account.html#implicit-account-ids).

Creating an account locally
For the purpose of this demo, we'll use the betanet network.
Set betanet network
export NEAR_ENV=betanet
Generating the Implicit account
near account create-account fund-later use-auto-generation save-to-folder ~/.near-credentials/implicit
Example Output
The file "~/.near-credentials/testnet/8bca86065be487de45e795b2c3154fe834d53ffa07e0a44f29e76a2a5f075df8.json" was saved successfully

Here is your console command if you need to script it or re-run:
    near account create-account fund-later use-auto-generation save-to-folder ~/.near-credentials/implicit
Using the Implicit Account
We can export our account ID to a bash env variable:
export ACCOUNT="8bca86065be487de45e795b2c3154fe834d53ffa07e0a44f29e76a2a5f075df8"
Assuming you've received tokens on your new account, you can transfer from it using the following command:


  

  ```bash
  near send $ACCOUNT  
  ```
  

  

  ```bash
  near tokens $ACCOUNT send-near  ' NEAR' network-config testnet sign-with-keychain send
  ```
  

Transferring to the implicit account
Let's say someone gives you their account ID 0861ea8ddd696525696ccf3148dd706c4fda981c64d8a597490472594400c223. You can just transfer to it by running:


  

  ```bash
  near send  0861ea8ddd696525696ccf3148dd706c4fda981c64d8a597490472594400c223 
  ```
  

  

  ```bash
  near tokens send-near 0861ea8ddd696525696ccf3148dd706c4fda981c64d8a597490472594400c223 ' NEAR' network-config testnet sign-with-keychain send
  ```
  

BONUS: Converting public key using python (for learning purposes)
For this flow we'll use python3 (with version 3.5+) with base58 library.
You can install this library with pip3:
pip3 install --user base58
Start python3 interpreter:
python3
The first thing is to get the data part from the public key (without ed25519: prefix). Let's store it in a variable pk58:
pk58 = 'BGCCDDHfysuuVnaNVtEhhqeT4k9Muyem3Kpgq2U1m9HX'
Now let's import base58:

Finally, let's convert our base58 public key representation to bytes and then to hex:
base58.b58decode(pk58).hex()
Output:
'98793cd91a3f870fb126f66285808c7e094afcfc4eda8a970f6648cdf0dbd6de'
This gives us the same account ID as near-cli, so this is encouraging.
tipot a question?
 Ask it on StackOverflow!

### Integrator FAQ

Orientation
What is a good project summary for NEAR?
NEAR is a sharded, public, proof-of-stake blockchain and smart contract platform. It is built in Rust and contracts compile to WASM. It is conceptually similar to Ethereum 2.0.
What's special about NEAR?
NEAR is the blockchain for builders.
If you understand the basics of web development, you can write, test and deploy scalable decentralized applications in minutes on the most developer-friendly blockchain without having to learn new tools or languages.
Is NEAR open source?
Yes. Have a look at our GitHub organization.
How are cryptographic functions used?
We support both secp256k1 and ed25519 for account keys and ed25519 for signing transactions. We currently use the ed25519_dalek and sha2 libraries for crypto.
Do you have any on-chain governance mechanisms?
NEAR does not have any on-chain governance at the moment. Any changes to state or state transition function must be done through a hard fork.
Do you have a bug-bounty program?
Our plan is to have a transparent Bug Bounty program with clear guidelines for paying out to those reporting issues. Payments will likely be based on publicly available rankings provided by protocol developers based on issue severity.
What contracts should we be aware of right now?
We have developed a number of initial contracts with ones in bold being most mature at time of writing

Staking Pool / Delegation contract
Lockup / Vesting contract
Whitelist Contract
Staking Pool Factory
Multisig contract

Do you have a cold wallet implementation (ie. Ledger)?
https://github.com/near/near-ledger-app
Validators
What is the process for becoming a validator?
Validation is permissionless and determined via auction. Parties who want to become a validator submit a special transaction to the chain one day ahead which indicates how many tokens they want to stake. An auction is run which determines the minimum necessary stake to get a validation seat during the next epoch and, if the amount submitted is greater than the minimum threshold, the submitter will validate at least one shard during the next epoch.
How long does a validator remain a validator?
A validator will stop being a validator for the following reasons:

Not producing enough blocks or chunks.
Not getting elected in the auction for next epoch because their stake is not large enough.
Getting slashed.
Otherwise a validator will remain a validator indefinitely.

Validator election happens in epochs. The Nightshade whitepaper introduces epochs this way: "the maintenance of the network is done in epochs" where an epoch is a period of time on the order of half a day.
At the beginning of each epoch, some computation produces a list of validators for the very next epoch.
The input to this computation includes all accounts that have "raised their hand to be a validator"
by submitting a special transaction (StakeAction)
expressing the commitment of some amount of tokens over the system's staking threshold,
as well as validators from the previous epoch.
The output of this computation is a list of the validators for the very next epoch.
What is the penalty for misbehaving validators?
Validators are not slashed for being offline but they do miss out on the rewards of validating. Validators who miss too many blocks or chunks will be removed from the validation set in the next auction and not get any reward (but, again, without slashing).
Any foul play on the part of the validator that is detected by the system may result in a "slashing event" where the validator is marked as out of integrity and forfeits their stake (according to some formula of progressive severity). The slashed stake is burnt.
What is the mechanism for delegating stake to validators?
NEAR supports separate validation keys that can be used in smart contracts to delegate stake. Delegation is done via smart contract which allows for a validator to define a custom way to collect stake, manage it and split rewards. This also allows validators to provide leverage or derivatives on stake. Delegated stake will be slashed like any other stake if the node misbehaves.
If a validator misbehaves the funds of the delegators are also slashed. There is no waiting period for delegators to withdraw their stake.
Does a validator control funds that have been delegated to them?
Delegation is custodial (you are transferring funds to a different account, the smart contract that implements staking pool). We provide a reference implementation being security reviewed and tested by 100 validators at time of writing.
We allow validators to write and deploy new contracts but it is up to users to decide if they want to delegate. Validators can compete for delegation by choosing different logic and conditions around tax optimization, etc.
Currently no slashing but will be added as we add shards into the system. At some point validators will be able to add an option to shield delegators from slashing (similar to Tezos model).
How do we get the balance of an account after it has delegated funds?
One would need to query the staking pool contract to get balance.
Nodes
Can a node be configured to archive all blockchain data since genesis?
v
Yes. Start the node using the following command:
./target/release/near run --archive
Can a node be configured to expose an RPC (ex: HTTP) interface?
Yes. All nodes expose this interface by default which can be configured by setting the value of listen_addr:port in the node's config.json file.
Can a node be gracefully terminated and restarted (using archived data on disk to continue syncing)?
Yes.
Does a node expose an interface for retrieving health telemetry in a structured format (ex: JSON) over RPC?
Yes. GET /status and GET /health provide this interface.

/status: block height, syncing status, peer count, etc
/health: success/failure if node is up running & progressing

Can a node be started using a Dockerfile without human supervision?
Yes.
docker run <port mapping> <mount data folder> <ENV vars> nearprotocol/nearcore:latest
See nearcore/scripts/nodelib.py for different examples of configuration.
What is the source of truth for current block height exposed via API?

MainNet

https://nearblocks.io
https://rpc.mainnet.near.org/status

TestNet

https://testnet.nearblocks.io
https://rpc.testnet.near.org/status


How old can the referenced block hash be before it's invalid?
There is a genesis parameter which can be discovered for any network using:
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_genesis_config
# in the line above, testnet may be replaced with mainnet or betanet
It's 43200 seconds or ~12 hours. You can view the live configuration for epoch_length using the protocol_config RPC endpoint.
In the response we find transaction_validity_period": 86400 (and since it takes about 1 second to produce a block, this period is about 24 hrs)
Blockchain
How will the network will be bootstrapped?
Distribution at genesis will be spread among the NEAR team, our contributors, project partners (ie. contributor, beta applications, infrastructure developers, etc.) and the NEAR foundation (with many portions of that segregated for post-MainNet distribution activity and unavailable to stake so the foundation isn’t able to control the network).
There will be auctions occurring on the platform after launch which will allocate large amounts of tokens over the next 2 years. Additionally we are planning to run TestNet where any validator who participates will receive rewards in real tokens. We are planning to onboard at least 50 separate entities to be validators at launch.
What is the network upgrade process?
We are currently upgrading via restarting with a new genesis block.
Which consensus algorithm does NEAR use?
NEAR is a sharded proof-of-stake blockchain.
You can read more in our Nightshade whitepaper.

A few relevant details have been extracted here for convenience:
[Since NEAR is a sharded blockchain, there are challenges that need to be overcome] including state validity and data
availability problems. Nightshade is the solution NEAR Protocol is built upon that addresses these issues.
Nightshade uses the heaviest chain consensus. Specifically when a block producer produces a block (see section 3.3), they can collect signatures from other block producers and validators attesting to the previous block. The weight of a block is then the cumulative stake of all the signers whose signatures are included in the block. The weight of a chain is the sum of the block weights.
On top of the heaviest chain consensus we use a finality gadget that uses the attestations to finalize the blocks. To reduce the complexity of the system, we use a finality gadget that doesn’t influence the fork choice rule in any way, and instead only introduces extra slashing conditions, such that once a block is finalized by the finality gadget, a fork is impossible unless a very large percentage of the total stake is slashed.

How does on-chain transaction finality work?
Finality is deterministic, and requires at least 3 blocks as well as (2/3 +1) signatures of the current validator set.
In a normal operation, we expect this to happen right at 3 blocks but it is not guaranteed.
Finality will be exposed via RPC when querying block or transaction.
Our definition of finality is BOTH:

Block has quorum pre-commit from the finality gadget. See details of the finality gadget [here]
At least 120 blocks (2-3 minutes) built on top of the block of interest. This is relevant in case of invalid state transition in some shard and provides enough time for state change challenges. In case all shards are tracked and some mechanics to pause across nodes is employed, this is not needed. We recommend exchanges track all shards.

Accounts
How are addresses generated?
Please check out the spec here on accounts https://nomicon.io/DataStructures/Account.html.
What is the balance record-keeping model on the NEAR platform?
NEAR uses an Account-based model. All users and contracts are associated with at least 1 account. Each account lives on a single shard. Each account can have multiple keys for signing transactions.
You can read more about NEAR accounts here
How are user accounts represented on-chain?
Users create accounts with human-readable names (eg alice) which can contain multiple keypairs with individual permissions. Accounts can be atomically and securely transferred between parties as a native transaction on the network. Permissions are programmable with smart contracts as well. For example, a lock up contract is just an account with permission on the key that does not allow to transfer funds greater than those unlocked.
Is there a minimum account balance?
To limit on-chain "dust", accounts (and contracts) are charged a refundable deposit for storing data on the chain. This means that if the balance of the account does not have enough balance to cover an increased deposit for additional storage of data, storing additional data will fail. Also, any user can remove their own account and transfer left over balance to another (beneficiary) account.
There will be a restoration mechanism for accounts removed (or slept) in this way implemented in the future.
How many keys are used?
An account can have arbitrarily many keys, as long as it has enough tokens for their storage.
Which balance look-ups exist? What is required?
We have an RPC method for viewing account.
The JS implementation is here. Note that in this RPC interface you can specify the finality requirement (whether to query the latest state or finalized state).
For custody purposes, it is recommended not to rely on latest state but only what is finalized.
Fees
What is the fee structure for on-chain transactions?
NEAR uses a gas-based model where prices are generally deterministically adjusted based on congestion of the network.
We avoid making changes that are too large through re-sharding by changing number of available shards (and thus throughput).
Accounts don’t have associated resources. Gas amount is predetermined for all transactions except function calls. For function call transactions the user (or more likely the developer) attaches the required amount of gas. If some gas is left over after the function call, it is converted back to NEAR and refunded to the original funding account.
How do we know how much gas to add to a transaction?

See reference documentation here: https://nomicon.io/Economics/
See API documentation for discovering gas price via RPC here.

The issuer of a transaction should attach some amount of gas by taking a guess at budget which will get the transaction processed. The contract knows how much to fund different cross contract calls. Gas price is calculated and fixed per block, but may change from block to block depending on how full / busy the block is. If blocks become more than half full then gas price increases.
We're also considering adding a max gas price limit.
Transactions
How do we follow Tx status?
See related RPC interface for fetching transaction status here.
How are transactions constructed and signed?
Transactions are a collection of related data that is composed and cryptographically signed by the sender using their private key. The related public key is part of the transaction and used for signature verification. Only signed transactions may be sent to the network for processing.
Transactions can be constructed and signed offline. Nodes are not required for signing. We are planning to add optional recent block hash to help prevent various replay attacks.
See transactions in the concepts section of our documentation.
How is the hash preimage generated? Which fields does the raw transaction consist of?
For a transaction, we sign the hash of the transaction. More specifically, what is signed is the sha256 of the transaction object serialized in borsh (https://github.com/near/borsh).
How do transactions work on the NEAR platform?
A Transaction is made up of one or more Actions. An action can (currently) be one of 8 types: CreateAccount,
DeployContract, FunctionCall, Transfer, Stake, AddKey, DeleteKey and DeleteAccount. Transactions are composed by a sender and then signed using the private keys of a valid NEAR account to create a SignedTransaction. This signed transaction is considered ready to send to the network for processing.
Transactions are received via our JSON-RPC endpoint and routed to the shared where the sender account lives. This "home shard" for the sender account is then responsible for processing the transaction and generating related receipts to be applied across the network.
Once received by the network, signed transactions are verified (using the embedded public key of the signer) and transformed into a collection of Receipts, one per action. Receipts are of two types: Action Receipt is the most common and represents almost all actions on the network while Data Receipt handles the very special case of "a FunctionCallAction which includes a Promise". These receipts are then propagated and applied across the network according to the "home shard" rule for all affected receiver accounts.
These receipts are then propagated around the network using the receiver account's "home shard" since each account lives on one and only one shard. Once located on the correct shard, receipts are pulled from a nonce-based queue.
Receipts may generate other, new receipts which in turn are propagated around the network until all receipts have been applied. If any action within a transaction fails, the entire transaction is rolled back and any unburnt fees are refunded to the proper accounts.
For more detail, see specs on Transactions, Actions, Receipts
How does NEAR serialize transactions?
We use a simple binary serialization format that's deterministic: https://borsh.io
Additional Resources


Whitepaper

General overview at The Beginner's Guide to the NEAR Blockchain
NEAR Whitepaper



Github

https://www.github.com/near



tipot a question?
 Ask it on StackOverflow!

### Exchange Integration

Integration Reference

Balance Changes
Accounts
Fungible Tokens
Implicit Accounts

Transaction Reference Links

Basics
Specifications
Constructing Transactions

Blocks and Finality
Some important pieces of information regarding blocks and finality include:

Expected block time is around 1s and expected time to finality is around 2s. The last final block can be queried by
specifying {"finality": "final"} in the block query. For example, to get the latest final block on mainnet, one can run

http post https://rpc.mainnet.near.org method=block params:='{"finality":"final"}' id=123 jsonrpc=2.0


Block height are not necessarily continuous and certain heights may be skipped if, for example, a block producer for that height is offline. For example, after a block at height 100 is produced, the block at height 101 may be skipped. When block at height 102 is produced, its previous block is the block at height 100.


Some blocks may not include new chunks if, for example, the previous chunk producer is offline. Even though in the RPC
return result every block will have non-empty chunks field, it does not imply that there is a new chunk included in the block.
The way to tell whether the chunk is included in the block is to check whether height_included in the chunk is the same
as the height of the block.


Running an Archival Node
Please refer to configuration changes required in config.json for archival node by referring to the documentation on Run an Archival Node.
Staking and Delegation

https://github.com/nearprotocol/stakewars
https://github.com/near/core-contracts

tipot a question?
 Ask it on StackOverflow!

### Create Transactions

To construct & process transactions you will need our API JavaScript library: near-api-js. There are many ways to create transactions but for this example we'll show you two ways to create a simple token transfer transaction.

HIGH LEVEL - easiest way to create a transaction
LOW LEVEL - performs the exact same transaction as above, but deconstructs the entire process for those curious about each step

At the core, all transactions require the following:

signerId (account ID of the transaction originator)
signerPublicKey
receiverId (account ID of the transaction recipient)
nonceForPublicKey (each time a key is used the nonce value should be incremented by 1)
actions ( [click here] for supported arguments)
blockHash (a current block hash (within 24hrs) to prove the transaction was recently created)

See Transaction Class for a more in depth outline.

HIGH LEVEL -- Create a transaction
Setup

Clone the transaction-examples repository by running:

git clone https://github.com/near-examples/transaction-examples.git

Follow setup instructions

Imports
In send-tokens-easy.js we use two dependencies:

NEAR API JavaScript library
dotenv (used to load environment variables for private key)

const nearAPI = require("near-api-js");
const { connect, KeyPair, keyStores, utils } = nearAPI;
require("dotenv").config();
The second line above deconstructs several utilities from nearAPI that you will use to interact with the blockchain.

connect - create a connection to NEAR passing configuration variables
KeyPair - creates a keyPair from the private key you'll provide in an .env file
keyStores - stores the keyPair that you will create from the private key and used to sign Transactions
utils - used to format NEAR amounts


Next, you'll need to enter the accountId of the sender and receiver, as well as the networkId (betanet, testnet, or mainnet).
const sender = "sender.testnet";
const receiver = "receiver.testnet";
const networkId = "testnet";
Formatting Token Amounts
When sending NEAR tokens (Ⓝ) during a transaction, the amount needs to be converted into Yocto Ⓝ or (10^-24).

To perform this you will use the near-api-js method parseNearAmount() (located in utils/format)

const amount = nearAPI.utils.format.parseNearAmount("1.5");
Create a Key Store
In order to sign transactions you will need to create a "Key Store" that will hold a full access key to sign your transactions. There are several ways to accomplish this, but for this example we will use a private key stored in either an .env file in your project or an environment variable exported globally.

If you created the account using near-cli or ran near login in your terminal, your private key can be found in the your machine's keychain.
If you created an account using NEAR Wallet, your key will be found in your browser's Local Storage.

In your browser's dev tools... Application >> Storage >> Local Storage


// sets up an empty keyStore object in memory using near-api-js
const keyStore = new keyStores.InMemoryKeyStore();
// creates a keyPair from the private key provided in your .env file
const keyPair = KeyPair.fromString(process.env.SENDER_PRIVATE_KEY);
// adds the key you just created to your keyStore which can hold multiple keys (must be inside an async function)
await keyStore.setKey(networkId, sender, keyPair);
Setting up a connection to NEAR
Now create a connection to NEAR using a configuration object that will contain your networkId setup earlier as well as your keyStore.
// configuration used to connect to NEAR
const prefix = (networkId === "testnet") ? "testnet" : "www";

const config = {
  networkId,
  keyStore,
  nodeUrl: `https://rpc.${networkId}.near.org`,
  walletUrl: `https://wallet.${networkId}.near.org`,
  helperUrl: `https://helper.${networkId}.near.org`,
  explorerUrl: `https://${prefix}.nearblocks.io`,
};

// connect to NEAR! :)
const near = await connect(config);
// create a NEAR account object
const senderAccount = await near.account(sender);
You'll notice the last line uses your NEAR connection to create a senderAccount object that you'll use to perform the transaction.

Now that everything is setup, creating the transaction is a single line of code.
const result = await senderAccount.sendMoney(receiver, amount);
This simple command constructs, signs, and sends a token transfer transaction on the NEAR blockchain. There is no need to create a result variable aside from inspecting the response details from your transaction and even create a link to NearBlocks Explorer to view a GUI version of the transaction details.

LOW LEVEL -- Create a Transaction
Setup

Clone the transaction-examples repository by running:

git clone https://github.com/near-examples/transaction-examples.git

Follow setup instructions


Imports
In send-tokens-deconstructed.js we use three dependencies:

NEAR API JavaScript library
js-sha256 (cryptographic hashing algorithm)
dotenv (used to load environment variables)

const nearAPI = require("near-api-js");
const sha256 = require("js-sha256");
require("dotenv").config();


Next, you'll need to enter the accountId of the sender and receiver, as well as the networkId (betanet, testnet, or mainnet).
const sender = "sender.testnet";
const receiver = "receiver.testnet";
const networkId = "testnet";

Formatting Token Amounts
When sending NEAR tokens (Ⓝ) during a transaction, the amount needs to be converted into Yocto Ⓝ or (10^-24).

To perform this you will use the near-api-js method parseNearAmount() (located in utils/format)

const amount = nearAPI.utils.format.parseNearAmount("1.5");

Setting up a connection to NEAR
In this example, we will create a NEAR RPC provider that allows us to interact with the chain via RPC endpoints.
const provider = new nearAPI.providers.JsonRpcProvider(
  `https://rpc.${networkId}.near.org`
);

Access Keys
To sign a transaction to send NEAR Ⓝ, we will need a FullAccess key to the sender's account.

If you created the account using near-cli or ran near login in your terminal, your private key can be found in your machine's keychain.
If you created an account using NEAR Wallet, your key will be found in your browser's Local Storage.

In your browser's dev tools... Application >> Storage >> Local Storage


Once you have access to the private key of the sender's account, create an environment variable SENDER_PRIVATE_KEY or hard code it as a string on line 18 of send-tokens.js.

With this privateKey, we can now construct a keyPair object to sign transactions.

const privateKey = process.env.SENDER_PRIVATE_KEY;
const keyPair = nearAPI.KeyPair.fromString(privateKey);

Transaction Requirements
As stated before, all transactions require six parts:

signerId
signerPublicKey
receiverId
nonceForPublicKey
actions
blockHash

1 signerId

The signerId is the account ID of the transaction originator.
This value is passed as a string (ex. 'example.testnet' or 'bob.near')

2 signerPublicKey

The signerPublicKey is required to be an object with two key value pairs: keyType and data.

PublicKey = {
  keyType: 0,
  data: Uint8Array(32)[
    (190,
    150,
    152,
    145,
    232,
    248,
    128,
    151,
    167,
    165,
    128,
    46,
    20,
    231,
    103,
    142,
    39,
    56,
    152,
    46,
    135,
    1,
    161,
    180,
    94,
    212,
    195,
    201,
    73,
    190,
    70,
    242)
  ],
};

This can be constructed by calling getPublicKey() using the keyPair we setup earlier.

const publicKey = keyPair.getPublicKey();
3 receiverId

The receiverId is the account ID of the transaction recipient.
This value is passed as a string (ex. 'example.testnet' or 'bob.near')
The certain cases, the signerId and the receiverId can be the same account.

4 nonceForPublicKey

A unique number or nonce is required for each transaction signed with an access key.
To ensure a unique number is created for each transaction, the current nonce should be queried and then incremented by 1.
Current nonce can be retrieved using the provider we created earlier.

const accessKey = await provider.query(
  `access_key/${sender}/${publicKey.toString()}`,
  ""
);

now we can create a unique number for our transaction by incrementing the current nonce.

const nonce = ++accessKey.nonce;
5 actions

There are currently eight supported Action types. [see here]
For this example, we are using Transfer
This transfer action can be created using the imported nearAPI object and the formatted Ⓝ amount created earlier.

const actions = [nearAPI.transactions.transfer(amount)];
[click here] to view source for transfer().
6 blockHash

Each transaction requires a current block hash (within 24hrs) to prove that the transaction was created recently.
Hash must be converted to an array of bytes using the base_decode method found in nearAPI.

const recentBlockHash = nearAPI.utils.serialize.base_decode(
  accessKey.block_hash
);
[click here] to view source for base_decode().

Constructing the Transaction
With all of our required arguments, we can construct the transaction.

Using nearAPI, we call on createTransaction() to perform this task.

const transaction = nearAPI.transactions.createTransaction(
  sender,
  publicKey,
  receiver,
  nonce,
  actions,
  recentBlockHash
);
[click here] to view source code for the Transaction class

Sign Transaction
Now that the transaction is created, we sign it before sending it to the NEAR blockchain. At the lowest level, there are four steps to this process.

Using nearAPI, we call on serialize() to serialize the transaction in Borsh.

const serializedTx = nearAPI.utils.serialize.serialize(
  nearAPI.transactions.SCHEMA.Transaction,
  transaction
);

Hash the serialized transaction using a sha256 cryptographic hashing algorithm.

const serializedTxHash = new Uint8Array(sha256.sha256.array(serializedTx));

Create a signature with the keyPair.

const signature = keyPair.sign(serializedTxHash);

Construct the signed transaction using near-api-js SignedTransaction class.

const signedTransaction = new nearAPI.transactions.SignedTransaction({
  transaction,
  signature: new nearAPI.transactions.Signature({
    keyType: transaction.publicKey.keyType,
    data: signature.signature,
  }),
});
Send Transaction
Final step is to encode and send the transaction.

First we serialize transaction into Borsh, and store the result as signedSerializedTx. (required for all transactions)
Then we send the transaction via RPC call using the sendJsonRpc() method nested inside near.

// encodes transaction to serialized Borsh (required for all transactions)
const signedSerializedTx = signedTransaction.encode();
// sends transaction to NEAR blockchain via JSON RPC call and records the result
const result = await provider.sendJsonRpc("broadcast_tx_commit", [
  Buffer.from(signedSerializedTx).toString("base64"),
]);
Transaction Results
Detailed transaction results of the transaction are returned in the following format:
{
  status: { SuccessValue: '' },
  transaction: {
    signer_    public_key: 'ed25519:8RazSLHvzj4TBSKGUo5appP7wVeqZNQYjP9hvhF4ZKS2',
    nonce: 57,
    receiver_    actions: [ [Object] ],
    signature: 'ed25519:2sK53w6hybSxX7qWShXz6xKnjnYRUW7Co3evEaaggNW6pGSCNPvx7urY4akwnzAbxZGwsKjx8dcVm73qbitntJjz',
    hash: 'EgGzB73eFxCwZRGcEyCKedLjvvgxhDXcUtq21SqAh79j'
  },
  transaction_outcome: {
    proof: [ [Object] ],
    block_hash: 'J6cFDzAFkuknHMCEYW2uPQXDvCfSndkJmADVEWJbtTwV',
        outcome: {
      logs: [],
      receipt_ids: [Array],
      gas_burnt: 223182562500,
      tokens_burnt: '22318256250000000000',
      executor_      status: [Object]
    }
  },
  receipts_outcome: [
    {
      proof: [Array],
      block_hash: 'FSS7UzTpMr4mUm6aw8MmzP6Q7wnQs35VS8vYm1R461dM',
            outcome: [Object]
    },
    {
      proof: [Array],
      block_hash: '4XBio5dM5UGYjJgzZjgckfVgMZ9uKGbTkt8zZi5webxw',
            outcome: [Object]
    }
  ]
}
Transaction Results:  {
  signer_  public_key: 'ed25519:8RazSLHvzj4TBSKGUo5appP7wVeqZNQYjP9hvhF4ZKS2',
  nonce: 57,
  receiver_  actions: [ { Transfer: [Object] } ],
  signature: 'ed25519:2sK53w6hybSxX7qWShXz6xKnjnYRUW7Co3evEaaggNW6pGSCNPvx7urY4akwnzAbxZGwsKjx8dcVm73qbitntJjz',
  hash: 'EgGzB73eFxCwZRGcEyCKedLjvvgxhDXcUtq21SqAh79j'
}
For detailed information on transaction receipts [click here]

To view the transaction in NearBlocks Explorer, enter the hash located under transaction / Transaction Results.
In addition, you can create a link in JS using the networkId and result.transaction.hash.

const prefix = (networkId === "testnet") ? "testnet." : "";
const transactionLink = `https://${prefix}nearblocks.io/txns/${result.transaction.hash}`;
tipot a question?
Ask it on StackOverflow!

Happy Coding! 🚀

### Balance changes

Prerequisites

NEAR Account
NEAR-CLI
Credentials for sender account stored locally by running near login

Native NEAR (Ⓝ)

Balance changes on accounts can be tracked by using our changes RPC endpoint. You can test this out by sending tokens to an account using NEAR-CLI and then viewing the changes made.

Send Tokens

Send tokens using near send



  

  ```bash
  near send sender.testnet receiver.testnet 1
  ```
  

  

  ```bash
  near tokens sender.testnet send-near receiver.testnet '1 NEAR' network-config testnet sign-with-keychain send
  ```
  


You should see a result in your terminal that looks something like this:

Sending 1 NEAR to receiver.testnet from sender.testnet
Transaction Id 4To336bYcoGc3LMucJPMk6fMk5suKfCrdNotrRtTxqDy
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/4To336bYcoGc3LMucJPMk6fMk5suKfCrdNotrRtTxqDy
View Balance Changes

Open the transaction URL in NearBlocks Explorer and copy the BLOCK HASH.
Using the BLOCK HASH and the accountId, query the changes RPC endpoint to view changes.

Example Query using HTTPie:
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare 
    method=EXPERIMENTAL_changes 
    'params:={
        "block_id": "CJ24svU3C9FaULVjcNVnWuVZjK6mNaQ8p6AMyUDMqB37",
        "changes_type": "account_changes",
        "account_ids": ["sender.testnet"]
    }'

**Example Response:**

```json
{
  "id": "dontcare",
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "BRgE4bjmUo33jmiVBcZaWGkSLVeL7TTi4ZxYTvJdPbB9",
    "changes": [
      {
        "cause": {
          "tx_hash": "4To336bYcoGc3LMucJPMk6fMk5suKfCrdNotrRtTxqDy",
          "type": "transaction_processing"
        },
        "change": {
          "account_id": "sender.testnet",
          "amount": "11767430014412510000000000",
          "code_hash": "11111111111111111111111111111111",
          "locked": "0",
          "storage_paid_at": 0,
          "storage_usage": 806
        },
        "type": "account_update"
      }
    ]
  }
}
```


Alternatively, you can view account balances by querying view_account which only requires an accountId.
Example HTTPie Request:
  http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_account",
    "finality": "final",
    "account_id": "sender.testnet"
  }'
Example Response:
{
  "id": "dontcare",
  "jsonrpc": "2.0",
  "result": {
    "amount": "11767430683960197500000000",
    "block_hash": "HUiscpNyoyR5z1UdnZhAJLNz1G8UjBrFTecSYqCrvdfW",
    "block_height": 50754977,
    "code_hash": "11111111111111111111111111111111",
    "locked": "0",
    "storage_paid_at": 0,
    "storage_usage": 806
  }
}
Note: Gas prices can change between blocks. Even for transactions with deterministic gas cost the cost in NEAR could also be different. You can query the gas price for recent blocks using the gas_price RPC endpoint.

tipot a question?
 Ask it on StackOverflow!

### Accounts

Introduction
Please see the documentation for accounts for basic information.

For exchanges, NEAR supports implicit account creation which allows the creation of accounts without paying for transactions.
You can create an implicit account by following the steps in this guide.
Accounts must have enough tokens to cover its storage which currently costs 0.0001 NEAR per byte. This equates to a minimum balance of 0.00182 NEAR for an account with one access key. You can query the live storage price using the protocol-config RPC endpoint. For more details on storage fees see this section of the economics paper.

Transfer from Function Call
NEAR allows transfers to happen within a function call. More importantly, when an account is deployed with some contract, it is possible that the only way to transfer tokens from that account is through a function call. Therefore, exchanges need to support transfers through function calls as well. We recommend the following approach:
Exchange can query block by height to get blocks on each height, and for every block,
query its chunk to obtain the transactions included in the block. For each transaction,
query its status to see the receipts generated from
transactions. Since exchanges are only interested in transfers to their addresses, they only need to filter receipts that
only contain Transfer action and whose predecessor_id is not system (receipts with predecessor_id equal to system
are refunds). Then, to check whether the receipt succeeds, it is sufficient
to look for the receipt_id in receipts_outcome and see if its status is SuccessValue.
Alternatively, exchange can use the indexer framework
to help index on-chain data which include receipts. An example usage of the indexer can be found here.
Below we include examples from the contracts that are likely to be used to perform transfers through function calls.
Example of transfer from a lockup contract
A contract evgeny.lockup.near is deployed and we can check its owner by

  

  ```bash
  near view evgeny.lockup.near get_owner_account_id
  # View call: evgeny.lockup.near.get_owner_account_id()
  # 'evgeny.near'
  ```
  

  

  ```bash
  near contract call-function as-read-only evgeny.lockup.near get_owner_account_id json-args '{}' network-config testnet now
  # View call: evgeny.lockup.near.get_owner_account_id()
  # 'evgeny.near'
  ```
  

Now we want to transfer some unlocked tokens (1 NEAR) with the following call

  

  ```bash
  near call evgeny.lockup.near transfer '{"amount":"1000000000000000000000000", "receiver_id": "evgeny.near"}' --accountId=evgeny.near
  ```
  

  

    ```bash
    near contract call-function as-transaction evgeny.lockup.near transfer json-args '{"amount":"1000000000000000000000000", "receiver_id": "evgeny.near"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as evgeny.near network-config testnet sign-with-keychain send
    ```
  

Note: the response below can be obtained by hitting the RPC with the transaction hash and NEAR account like this:
http post https://rpc.testnet.near.org jsonrpc=2.0 id=txstatus method=EXPERIMENTAL_tx_status 
  params:='[ "GXP8YaSonoN2eBY6dB3FbMN2NyYD2JeJJvKdvbL4Jmb2", "evgeny.near"]'

**Example Response:**

```json
{
  "id": "123",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "evgeny.near",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJhbW91bnQiOiIxMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIiwicmVjZWl2ZXJfaWQiOiJldmdlbnkubmVhciJ9",
                  "deposit": "0",
                  "gas": 100000000000000,
                  "method_name": "transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "evgeny.near",
            "signer_public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq"
          }
        },
        "receipt_id": "CyJL22SYqt26qgh2XVnk9MGfvzgyiiq5Lny7DdbTdTWU",
        "receiver_id": "evgeny.lockup.near"
      },
      {
        "predecessor_id": "evgeny.lockup.near",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "1000000000000000000000000"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "evgeny.near",
            "signer_public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq"
          }
        },
        "receipt_id": "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC",
        "receiver_id": "evgeny.near"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "19200274886926125000"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "evgeny.near",
            "signer_public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq"
          }
        },
        "receipt_id": "J1bBKH43nXHYg4NuS97R1PFzdZchrJboVAdRsK5NRrAv",
        "receiver_id": "evgeny.near"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18655658845681462514128"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "evgeny.near",
            "signer_public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq"
          }
        },
        "receipt_id": "6PFaxnNvK5r6qxBq5WfV9uGjoNM6qjhHwLehLP1qak9d",
        "receiver_id": "evgeny.near"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "9boEKq9G1UFsEuzmuQrxh5dkRc8xsv8PSPGEkYiTyRLj",
        "id": "CyJL22SYqt26qgh2XVnk9MGfvzgyiiq5Lny7DdbTdTWU",
        "outcome": {
          "executor_id": "evgeny.lockup.near",
          "gas_burnt": 3574640311481,
          "logs": [
            "Transferring 1000000000000000000000000 to account @evgeny.near"
          ],
          "receipt_ids": [
            "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC",
            "6PFaxnNvK5r6qxBq5WfV9uGjoNM6qjhHwLehLP1qak9d"
          ],
          "status": {
            "SuccessReceiptId": "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC"
          },
          "tokens_burnt": "357464031148100000000"
        },
        "proof": []
      },
      {
        "block_hash": "7qn4BjmMD4QbyVvMa8QEzm7h5YuhoGTFTgLeNMUp85UQ",
        "id": "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC",
        "outcome": {
          "executor_id": "evgeny.near",
          "gas_burnt": 223182562500,
          "logs": [],
          "receipt_ids": ["J1bBKH43nXHYg4NuS97R1PFzdZchrJboVAdRsK5NRrAv"],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "22318256250000000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "AwHdk5dushTSXHFBt3R5MiexjiXybwdnEaB7L9iJ5F6t"
          }
        ]
      },
      {
        "block_hash": "46788Ay85YGnQaH5tfbboQNWJs3gyXsPbcWzRyxqw56K",
        "id": "J1bBKH43nXHYg4NuS97R1PFzdZchrJboVAdRsK5NRrAv",
        "outcome": {
          "executor_id": "evgeny.near",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      },
      {
        "block_hash": "7qn4BjmMD4QbyVvMa8QEzm7h5YuhoGTFTgLeNMUp85UQ",
        "id": "6PFaxnNvK5r6qxBq5WfV9uGjoNM6qjhHwLehLP1qak9d",
        "outcome": {
          "executor_id": "evgeny.near",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "9RRJpH5VdDxsHpp323EshcAauV5wUNDyW9FpEJBRXXq8"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJhbW91bnQiOiIxMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIiwicmVjZWl2ZXJfaWQiOiJldmdlbnkubmVhciJ9",
            "deposit": "0",
            "gas": 100000000000000,
            "method_name": "transfer"
          }
        }
      ],
      "hash": "GXP8YaSonoN2eBY6dB3FbMN2NyYD2JeJJvKdvbL4Jmb2",
      "nonce": 6,
      "public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq",
      "receiver_id": "evgeny.lockup.near",
      "signature": "ed25519:4nfzTMpQJKCY3KaqUTFig4Xy9uxwbMeQpMJjtNKsXmwiVqgcVSWRguZEgZM8L2x1jvdpZHsYjLCxc9cSBamXuXPH",
      "signer_id": "evgeny.near"
    },
    "transaction_outcome": {
      "block_hash": "4u7maz2U43W4DPxqQE8KoRNi5dTRHrAsKsFk2qDQsQEw",
      "id": "GXP8YaSonoN2eBY6dB3FbMN2NyYD2JeJJvKdvbL4Jmb2",
      "outcome": {
        "executor_id": "evgeny.near",
        "gas_burnt": 2428086459116,
        "logs": [],
        "receipt_ids": ["CyJL22SYqt26qgh2XVnk9MGfvzgyiiq5Lny7DdbTdTWU"],
        "status": {
          "SuccessReceiptId": "CyJL22SYqt26qgh2XVnk9MGfvzgyiiq5Lny7DdbTdTWU"
        },
        "tokens_burnt": "242808645911600000000"
      },
      "proof": []
    }
  }
}
```

As we can see, there are four receipts generated in this function call. If we apply the criteria mentioned above, we can
find in receipts field this object
{
  "predecessor_id": "evgeny.lockup.near",
  "receipt": {
    "Action": {
      "actions": [
        {
          "Transfer": {
            "deposit": "1000000000000000000000000"
          }
        }
      ],
      "gas_price": "186029458",
      "input_data_ids": [],
      "output_data_receivers": [],
      "signer_id": "evgeny.near",
      "signer_public_key": "ed25519:BVRTxEEMx3gFceSgJtnvPFbSnPDwwUzHe6KGduRh5Byq"
    }
  },
  "receipt_id": "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC",
  "receiver_id": "evgeny.near"
}
which contains only Transfer action and whose predecessor_id is not system. Now we can check the status of the
execution by looking for the same receipt id EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC in receipts_outcome field
of the rpc return result, this leads us to this execution outcome
{
  "block_hash": "7qn4BjmMD4QbyVvMa8QEzm7h5YuhoGTFTgLeNMUp85UQ",
  "id": "EvHfj4fUyVuLBRKNdCZmFGr4WfqwYf7YCbzFsRGFTFJC",
  "outcome": {
    "executor_id": "evgeny.near",
    "gas_burnt": 223182562500,
    "logs": [],
    "receipt_ids": ["J1bBKH43nXHYg4NuS97R1PFzdZchrJboVAdRsK5NRrAv"],
    "status": {
      "SuccessValue": ""
    },
    "tokens_burnt": "22318256250000000000"
  },
  "proof": [
    {
      "direction": "Right",
      "hash": "AwHdk5dushTSXHFBt3R5MiexjiXybwdnEaB7L9iJ5F6t"
    }
  ]
}
and its status contains SuccessValue, which indicates that the receipt has succeeded. Therefore we know that
1000000000000000000000000 yoctoNEAR, or 1 NEAR has been successfully transferred.
Example of transfer from a multisig contract
Multisig contract, as the name suggests, uses multiple signatures to confirm a transaction and therefore, actions performed
by the multisig contract involve multiple transactions. In the following example, we will show how a transfer is done from
a multisig contract that requires two confirmations.

First step: add_request_and_confirm. This initiates the action that the multisig contract wants to perform with one
confirmation. The multisig contract multisigtest.testnet wants to transfer 1 NEAR to bowen and it first
sends a transaction that calls add_request_and_confirm with a request

{
  "request": {
    "receiver_id": "bowen",
    "actions": [
      {
        "type": "Transfer",
        "amount": "1000000000000000000000000"
      }
    ]
  }
}
that indicates it wants to transfer 1 NEAR to bowen. Notice that this transaction only records the action
but does not perform the actual transfer. The transaction result is as follows:

**Example Response:**

```json
{
  "id": "123",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "3069687780141648922140"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "multisigtest.testnet",
            "signer_public_key": "ed25519:JDewsbE7nz6orFD4zJ3mVzqhfcaoSD6Hmi5as3AHHiTt"
          }
        },
        "receipt_id": "4qgDptd7Wm6vswAhWMCsVpTjBEkmLJEUxSNVQS1wu3rD",
        "receiver_id": "multisigtest.testnet"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "6uJWHTvUrtFQAurUyfuAfy9EdoR9FhLodGh44aHJta6m",
        "id": "94LiYwKJEDherHMNg9fqLy9ShFTDiQiUN3nDaGmLZwth",
        "outcome": {
          "executor_id": "multisigtest.testnet",
          "gas_burnt": 8024094920263,
          "logs": [],
          "receipt_ids": ["4qgDptd7Wm6vswAhWMCsVpTjBEkmLJEUxSNVQS1wu3rD"],
          "status": {
            "SuccessValue": "OA=="
          },
          "tokens_burnt": "802409492026300000000"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "GedzmwRkxA5VkT8GLBCnrPUmnEhWPXadPmiq4Ho1s9pH"
          },
          {
            "direction": "Right",
            "hash": "GirkzdS9YpsAz5fXuL5T3rXd93aRcnXNAdXYi241qpWK"
          }
        ]
      },
      {
        "block_hash": "4JyQ6guJKeWZxxXrKndLDuSa5URuirmBi6RzsbKYFsBE",
        "id": "4qgDptd7Wm6vswAhWMCsVpTjBEkmLJEUxSNVQS1wu3rD",
        "outcome": {
          "executor_id": "multisigtest.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      }
    ],
    "status": {
      "SuccessValue": "OA=="
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZXF1ZXN0Ijp7InJlY2VpdmVyX2lkIjoiYm93ZW4iLCJhY3Rpb25zIjpbeyJ0eXBlIjoiVHJhbnNmZXIiLCJhbW91bnQiOiIxMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIn1dfX0=",
            "deposit": "0",
            "gas": 30000000000000,
            "method_name": "add_request_and_confirm"
          }
        }
      ],
      "hash": "FGREJkC1e8y95Rc35iD1LVRiDy1WcAZhAxxkSinfb2mL",
      "nonce": 10,
      "public_key": "ed25519:JDewsbE7nz6orFD4zJ3mVzqhfcaoSD6Hmi5as3AHHiTt",
      "receiver_id": "multisigtest.testnet",
      "signature": "ed25519:3NUKXd4uj2eEBqGQtRAxkTFW7UfG44tjvQNNHBDvN9ZswTTMRsDrMJSd1U3GqWF7QToqWQR9J8atNEVTemSWYw41",
      "signer_id": "multisigtest.testnet"
    },
    "transaction_outcome": {
      "block_hash": "6uJWHTvUrtFQAurUyfuAfy9EdoR9FhLodGh44aHJta6m",
      "id": "FGREJkC1e8y95Rc35iD1LVRiDy1WcAZhAxxkSinfb2mL",
      "outcome": {
        "executor_id": "multisigtest.testnet",
        "gas_burnt": 2428204963618,
        "logs": [],
        "receipt_ids": ["94LiYwKJEDherHMNg9fqLy9ShFTDiQiUN3nDaGmLZwth"],
        "status": {
          "SuccessReceiptId": "94LiYwKJEDherHMNg9fqLy9ShFTDiQiUN3nDaGmLZwth"
        },
        "tokens_burnt": "242820496361800000000"
      },
      "proof": [
        {
          "direction": "Right",
          "hash": "AsNAQabPFkmaugRGhCbzcEcR8Gnd22WXxPM2fb2cwHiv"
        },
        {
          "direction": "Right",
          "hash": "GirkzdS9YpsAz5fXuL5T3rXd93aRcnXNAdXYi241qpWK"
        }
      ]
    }
  }
}
```


Second step: confirm. A second transaction is sent to confirm the transfer. This transaction takes the request id
returned by the first transaction and does the actual transfer. The transaction result is as follows


**Example Response:**

```json
{
  "id": "123",
  "jsonrpc": "2.0",
  "result": {
    "receipts": [
      {
        "predecessor_id": "multisigtest.testnet",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "1000000000000000000000000"
                }
              }
            ],
            "gas_price": "451542320",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "multisigtest.testnet",
            "signer_public_key": "ed25519:BmVX32jhvEd8d8outiQdjf66GGYV3pb7kaxrKTdNisCz"
          }
        },
        "receipt_id": "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy",
        "receiver_id": "bowen"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "78458115804795000000"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "multisigtest.testnet",
            "signer_public_key": "ed25519:BmVX32jhvEd8d8outiQdjf66GGYV3pb7kaxrKTdNisCz"
          }
        },
        "receipt_id": "6SxC9GfYdjqm7Ao5EAw51XUAjgoN8Lj2X9xJfxjDQYXd",
        "receiver_id": "multisigtest.testnet"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "112870156274913516718240"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "multisigtest.testnet",
            "signer_public_key": "ed25519:BmVX32jhvEd8d8outiQdjf66GGYV3pb7kaxrKTdNisCz"
          }
        },
        "receipt_id": "CHfzz6NLcQMyiLHBQoczhgm5BFjLVfv9B7eCyXKLhhcT",
        "receiver_id": "multisigtest.testnet"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "9JEiMrZ1SpAUEbQswde3Diptzwy35Vrvd41VZWG9hYVE",
        "id": "FfuhYhsgFL7sLC8pk1tuRnMHJdqycE6gEcfgZLW9fmFB",
        "outcome": {
          "executor_id": "multisigtest.testnet",
          "gas_burnt": 10109796553814,
          "logs": [],
          "receipt_ids": [
            "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy",
            "CHfzz6NLcQMyiLHBQoczhgm5BFjLVfv9B7eCyXKLhhcT"
          ],
          "status": {
            "SuccessReceiptId": "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy"
          },
          "tokens_burnt": "1010979655381400000000"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "9e2UcG6qBRahBh3V2Z8bGJLh5c4jXfZdP3WBJkCpJCfj"
          }
        ]
      },
      {
        "block_hash": "4LkVfqyhhrxDdVFmow6NxLf1jTaj6XVr7CVcUxxySd1R",
        "id": "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy",
        "outcome": {
          "executor_id": "bowen",
          "gas_burnt": 223182562500,
          "logs": [],
          "receipt_ids": ["6SxC9GfYdjqm7Ao5EAw51XUAjgoN8Lj2X9xJfxjDQYXd"],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "22318256250000000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "FFWaWUFt6sNx5XNHzGYsYBSYFWtGPoww5XQz1QmLVc8i"
          }
        ]
      },
      {
        "block_hash": "G6LDdnAa2b38TB4KZ89HAyVgfgyiRPDDgSxoZypbUYpx",
        "id": "6SxC9GfYdjqm7Ao5EAw51XUAjgoN8Lj2X9xJfxjDQYXd",
        "outcome": {
          "executor_id": "multisigtest.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      },
      {
        "block_hash": "4LkVfqyhhrxDdVFmow6NxLf1jTaj6XVr7CVcUxxySd1R",
        "id": "CHfzz6NLcQMyiLHBQoczhgm5BFjLVfv9B7eCyXKLhhcT",
        "outcome": {
          "executor_id": "multisigtest.testnet",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "DpDYAEKZTtSomgyeNcJ2i4qjvfqnCtf1CXa83Cz5wvEy"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJyZXF1ZXN0X2lkIjo4fQ==",
            "deposit": "0",
            "gas": 250000000000000,
            "method_name": "confirm"
          }
        }
      ],
      "hash": "Fu39vwxC4mu9ks1DZA5Cib63RnBMHpFonk2DcbpioEYc",
      "nonce": 9,
      "public_key": "ed25519:BmVX32jhvEd8d8outiQdjf66GGYV3pb7kaxrKTdNisCz",
      "receiver_id": "multisigtest.testnet",
      "signature": "ed25519:2raQq7t3cmzSL2krE2xaNqXhAw7cKMoXrBjT2ZhAGfCVtGwzbbQ8zkB17vrCSFZDbFmPWSJpoqsw8qPZZiorwSzS",
      "signer_id": "multisigtest.testnet"
    },
    "transaction_outcome": {
      "block_hash": "9JEiMrZ1SpAUEbQswde3Diptzwy35Vrvd41VZWG9hYVE",
      "id": "Fu39vwxC4mu9ks1DZA5Cib63RnBMHpFonk2DcbpioEYc",
      "outcome": {
        "executor_id": "multisigtest.testnet",
        "gas_burnt": 2427972426482,
        "logs": [],
        "receipt_ids": ["FfuhYhsgFL7sLC8pk1tuRnMHJdqycE6gEcfgZLW9fmFB"],
        "status": {
          "SuccessReceiptId": "FfuhYhsgFL7sLC8pk1tuRnMHJdqycE6gEcfgZLW9fmFB"
        },
        "tokens_burnt": "242797242648200000000"
      },
      "proof": [
        {
          "direction": "Right",
          "hash": "B6hN48qeVP8J3hP8XGcANShM264QkNjgJAfMtsuknqex"
        }
      ]
    }
  }
}
```

Notice that similar to the transfer from lockup contract, there is also one receipt in the receipts field that meet
our requirements:
{
  "predecessor_id": "multisigtest.testnet",
  "receipt": {
    "Action": {
      "actions": [
        {
          "Transfer": {
            "deposit": "1000000000000000000000000"
          }
        }
      ],
      "gas_price": "451542320",
      "input_data_ids": [],
      "output_data_receivers": [],
      "signer_id": "multisigtest.testnet",
      "signer_public_key": "ed25519:BmVX32jhvEd8d8outiQdjf66GGYV3pb7kaxrKTdNisCz"
    }
  },
  "receipt_id": "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy",
  "receiver_id": "bowen"
}
and we can find its outcome in receipts_outcome:
{
  "block_hash": "4LkVfqyhhrxDdVFmow6NxLf1jTaj6XVr7CVcUxxySd1R",
  "id": "DZbHTEf3i3XznK4oJHQfcrteoiCL6WykRiA8vsn4LmAy",
  "outcome": {
    "executor_id": "bowen",
    "gas_burnt": 223182562500,
    "logs": [],
    "receipt_ids": ["6SxC9GfYdjqm7Ao5EAw51XUAjgoN8Lj2X9xJfxjDQYXd"],
    "status": {
      "SuccessValue": ""
    },
    "tokens_burnt": "22318256250000000000"
  },
  "proof": [
    {
      "direction": "Right",
      "hash": "FFWaWUFt6sNx5XNHzGYsYBSYFWtGPoww5XQz1QmLVc8i"
    }
  ]
}
which indicates that the transaction is successful.
tipot a question?
 Ask it on StackOverflow!

### RPC Endpoints

The RPC API enables you to send transactions and query their status.

Send transaction

Sends transaction.
Returns the guaranteed execution status and the results the blockchain can provide at the moment.


method: send_tx
params: 

signed_tx_base64: SignedTransaction encoded in base64
[Optional] wait_until: the required minimal execution level. Read more here. The default value is EXECUTED_OPTIMISTIC.


Using send_tx with wait_until = NONE is equal to legacy broadcast_tx_async method.
Using send_tx with finality wait_until = EXECUTED_OPTIMISTIC is equal to legacy broadcast_tx_commit method.
Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "send_tx",
  "params": {
    "signed_tx_base64": "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDwAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldNMnL7URB1cxPOu3G8jTqlEwlcasagIbKlAJlF5ywVFLAQAAAAMAAACh7czOG8LTAAAAAAAAAGQcOG03xVSFQFjoagOb4NBBqWhERnnz45LY4+52JgZhm1iQKz7qAdPByrGFDQhQ2Mfga8RlbysuQ8D8LlA6bQE=",
    "wait_until": "INCLUDED_FINAL"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=send_tx 
    params:='{
      "signed_tx_base64": "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDwAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldNMnL7URB1cxPOu3G8jTqlEwlcasagIbKlAJlF5ywVFLAQAAAAMAAACh7czOG8LTAAAAAAAAAGQcOG03xVSFQFjoagOb4NBBqWhERnnz45LY4+52JgZhm1iQKz7qAdPByrGFDQhQ2Mfga8RlbysuQ8D8LlA6bQE=",
      "wait_until": "EXECUTED"
    }'
```

```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=send_tx 
    params:='{
      "signed_tx_base64": "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDwAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldNMnL7URB1cxPOu3G8jTqlEwlcasagIbKlAJlF5ywVFLAQAAAAMAAACh7czOG8LTAAAAAAAAAGQcOG03xVSFQFjoagOb4NBBqWhERnnz45LY4+52JgZhm1iQKz7qAdPByrGFDQhQ2Mfga8RlbysuQ8D8LlA6bQE="
    }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "final_execution_status": "FINAL",
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "signer_id": "sender.testnet",
      "public_key": "ed25519:Gowpa4kXNyTMRKgt5W7147pmcc2PxiFic8UHW9rsNvJ6",
      "nonce": 13,
      "receiver_id": "receiver.testnet",
      "actions": [
        {
          "Transfer": {
            "deposit": "1000000000000000000000000"
          }
        }
      ],
      "signature": "ed25519:7oCBMfSHrZkT7tzPDBxxCd3tWFhTES38eks3MCZMpYPJRfPWKxJsvmwQiVBBxRLoxPTnXVaMU2jPV3MdFKZTobH",
      "hash": "ASS7oYwGiem9HaNwJe6vS2kznx2CxueKDvU9BAYJRjNR"
    },
    "transaction_outcome": {
      "proof": [],
      "block_hash": "9MzuZrRPW1BGpFnZJUJg6SzCrixPpJDfjsNeUobRXsLe",
      "id": "ASS7oYwGiem9HaNwJe6vS2kznx2CxueKDvU9BAYJRjNR",
      "outcome": {
        "logs": [],
        "receipt_ids": ["BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh"],
        "gas_burnt": 223182562500,
        "tokens_burnt": "22318256250000000000",
        "executor_id": "sender.testnet",
        "status": {
          "SuccessReceiptId": "BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh"
        }
      }
    },
    "receipts_outcome": [
      {
        "proof": [],
        "block_hash": "5Hpj1PeCi32ZkNXgiD1DrW4wvW4Xtic74DJKfyJ9XL3a",
        "id": "BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh",
        "outcome": {
          "logs": [],
          "receipt_ids": ["3sawynPNP8UkeCviGqJGwiwEacfPyxDKRxsEWPpaUqtR"],
          "gas_burnt": 223182562500,
          "tokens_burnt": "22318256250000000000",
          "executor_id": "receiver.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      },
      {
        "proof": [],
        "block_hash": "CbwEqMpPcu6KwqVpBM3Ry83k6M4H1FrJjES9kBXThcRd",
        "id": "3sawynPNP8UkeCviGqJGwiwEacfPyxDKRxsEWPpaUqtR",
        "outcome": {
          "logs": [],
          "receipt_ids": [],
          "gas_burnt": 0,
          "tokens_burnt": "0",
          "executor_id": "sender.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by broadcast_tx_commit method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      INVALID_TRANSACTION
      200
      An error happened during transaction execution
      
        
          See error.cause.info for details, likely a field in the transaction was invalid
          If error.cause.info is ShardCongested, resubmit the identical transaction after a delay. (Consider adding a priority fee once [NEP-541](https://github.com/near/NEPs/pull/541) is released.)
          If error.cause.info is ShardStuck, you may also resubmit the identical transaction after a delay
        
      
    
    
      TIMEOUT_ERROR
      408
      Transaction was routed, but has not been recorded on chain in 10 seconds.
      
        
           Resubmit the request with the identical transaction (in NEAR Protocol unique transactions apply exactly once, so if the previously sent transaction gets applied, this request will just return the known result, otherwise, it will route the transaction to the chain once again)
          Check that your transaction is valid
          Check that the signer account id has enough tokens to cover the transaction fees (keep in mind that some tokens on each account are locked to cover the storage cost)
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Transaction Status

Queries status of a transaction by hash and returns the final transaction result.


method: tx
params:

tx_hash (see NearBlocks Explorer for a valid transaction hash)
sender_account_id (used to determine which shard to query for transaction)
[Optional] wait_until: the required minimal execution level. Read more here. The default value is EXECUTED_OPTIMISTIC.


A Transaction status request with wait_until != NONE will wait until the transaction appears on the blockchain.
If the transaction does not exist, the method will wait until the timeout is reached.
If you only need to check whether the transaction exists, use wait_until = NONE, it will return the response immediately.
Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "tx",
  "params": {
    "tx_hash": "6zgh2u9DqHHiXzdy9ouTP7oGky2T4nugqzqt9wJZwNFm",
    "sender_account_id": "sender.testnet",
    "wait_until": "EXECUTED"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=tx 
    params:='{"tx_hash": "6zgh2u9DqHHiXzdy9ouTP7oGky2T4nugqzqt9wJZwNFm", "sender_account_id": "sender.testnet"}'
```




Example Result:


```json
{
  "jsonrpc": "2.0",
  "result": {
    "final_execution_status": "FINAL",
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "signer_id": "sender.testnet",
      "public_key": "ed25519:Gowpa4kXNyTMRKgt5W7147pmcc2PxiFic8UHW9rsNvJ6",
      "nonce": 15,
      "receiver_id": "receiver.testnet",
      "actions": [
        {
          "Transfer": {
            "deposit": "1000000000000000000000000"
          }
        }
      ],
      "signature": "ed25519:3168QMdTpcwHvM1dmMYBc8hg9J3Wn8n7MWBSE9WrEpns6P5CaY87RM6k4uzyBkQuML38CZhU18HzmQEevPG1zCvk",
      "hash": "6zgh2u9DqHHiXzdy9ouTP7oGky2T4nugqzqt9wJZwNFm"
    },
    "transaction_outcome": {
      "proof": [
        {
          "hash": "F7mL76CMdfbdZ3xCehVGNh1fCyaR37gr3MeGX3EZkiVf",
          "direction": "Right"
        }
      ],
      "block_hash": "ADTMLVtkhsvzUxuf6m87Pt1dnF5vi1yY7ftxmNpFx7y",
      "id": "6zgh2u9DqHHiXzdy9ouTP7oGky2T4nugqzqt9wJZwNFm",
      "outcome": {
        "logs": [],
        "receipt_ids": ["3dMfwczW5GQqXbD9GMTnmf8jy5uACxG6FC5dWxm3KcXT"],
        "gas_burnt": 223182562500,
        "tokens_burnt": "22318256250000000000",
        "executor_id": "sender.testnet",
        "status": {
          "SuccessReceiptId": "3dMfwczW5GQqXbD9GMTnmf8jy5uACxG6FC5dWxm3KcXT"
        }
      }
    },
    "receipts_outcome": [
      {
        "proof": [
          {
            "hash": "6h95oEd7ih62KXfyPT4zsZYont4qy9sWEXc5VQVDhqtG",
            "direction": "Right"
          },
          {
            "hash": "6DnibgZk1T669ZprcehUy1GpCSPw1kjzXRGu69nSaUNn",
            "direction": "Right"
          }
        ],
        "block_hash": "GgFTVr33r4MrpAiHc9mr8TZqLnpZAX1BaZTNvhBnciy2",
        "id": "3dMfwczW5GQqXbD9GMTnmf8jy5uACxG6FC5dWxm3KcXT",
        "outcome": {
          "logs": [],
          "receipt_ids": ["46KYgN8ddxs4Qy8C7BDQH49XUfcYZsaQmAvdU1nfcL9V"],
          "gas_burnt": 223182562500,
          "tokens_burnt": "22318256250000000000",
          "executor_id": "receiver.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      },
      {
        "proof": [
          {
            "hash": "CD9Y7Bw3MSFgaPZzpc1yP51ajhGDCAsR61qXcMNcRoHf",
            "direction": "Left"
          }
        ],
        "block_hash": "EGAgKuW6Bd6QKYSaxAkx2pPGmnjrjAcq4UpoUiqMXvPH",
        "id": "46KYgN8ddxs4Qy8C7BDQH49XUfcYZsaQmAvdU1nfcL9V",
        "outcome": {
          "logs": [],
          "receipt_ids": [],
          "gas_burnt": 0,
          "tokens_burnt": "0",
          "executor_id": "sender.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by tx method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      INVALID_TRANSACTION
      200
      An error happened during transaction execution
      
        
          See error.cause.info for details
        
      
    
    
      UNKNOWN_TRANSACTION
      200
      The requested transaction is not available on the node since it might have not been recorded on the chain yet or has been garbage-collected
      
        
          Try again later
          If the transaction had been submitted more than 5 epochs ago, try to send your request to an archival node
          Check the transaction hash
        
      
    
    
      TIMEOUT_ERROR
      408
      It was unable to wait for the transaction status for reasonable time
      
        
          Send a request to a different node
          Try again later
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Transaction Status with Receipts

Queries status of a transaction by hash, returning the final transaction result and details of all receipts.


method: EXPERIMENTAL_tx_status
params:

tx_hash (see NearBlocks Explorer for a valid transaction hash)
sender_account_id (used to determine which shard to query for transaction)
[Optional] wait_until: the required minimal execution level. Read more here. The default value is EXECUTED_OPTIMISTIC.


A Transaction status request with wait_until != NONE will wait until the transaction appears on the blockchain.
If the transaction does not exist, the method will wait until the timeout is reached.
If you only need to check whether the transaction exists, use wait_until = NONE, it will return the response immediately.
Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_tx_status",
  "params": {
    "tx_hash": "HEgnVQZfs9uJzrqTob4g2Xmebqodq9waZvApSkrbcAhd",
    "sender_account_id": "bowen",
    "wait_until": "EXECUTED"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_tx_status params:='{"tx_hash": "HEgnVQZfs9uJzrqTob4g2Xmebqodq9waZvApSkrbcAhd", "sender_account_id": "bowen"}' id=dontcare
```




Example response:


```json
{
  "id": "123",
  "jsonrpc": "2.0",
  "result": {
    "final_execution_status": "FINAL",
    "receipts": [
      {
        "predecessor_id": "bowen",
        "receipt": {
          "Action": {
            "actions": [
              {
                "FunctionCall": {
                  "args": "eyJhbW91bnQiOiIxMDAwIiwicmVjZWl2ZXJfaWQiOiJib3dlbiJ9",
                  "deposit": "0",
                  "gas": 100000000000000,
                  "method_name": "transfer"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "bowen",
            "signer_public_key": "ed25519:2f9Zv5kuyuPM5DCyEP5pSqg58NQ8Ct9uSRerZXnCS9fK"
          }
        },
        "receipt_id": "FXMVxdhSUZaZftbmPJWaoqhEB9GrKB2oqg9Wgvuyvom8",
        "receiver_id": "evgeny.lockup.m0"
      },
      {
        "predecessor_id": "evgeny.lockup.m0",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "1000"
                }
              }
            ],
            "gas_price": "186029458",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "bowen",
            "signer_public_key": "ed25519:2f9Zv5kuyuPM5DCyEP5pSqg58NQ8Ct9uSRerZXnCS9fK"
          }
        },
        "receipt_id": "3Ad7pUygUegMUWUb1rEazfjnTaHfptXCABqKQ6WNq6Wa",
        "receiver_id": "bowen"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "19200274886926125000"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "bowen",
            "signer_public_key": "ed25519:2f9Zv5kuyuPM5DCyEP5pSqg58NQ8Ct9uSRerZXnCS9fK"
          }
        },
        "receipt_id": "5DdQg9pfoJMX1q6bvhsjyyRihzA3sb9Uq5K1J7vK43Ze",
        "receiver_id": "bowen"
      },
      {
        "predecessor_id": "system",
        "receipt": {
          "Action": {
            "actions": [
              {
                "Transfer": {
                  "deposit": "18663792669276228632284"
                }
              }
            ],
            "gas_price": "0",
            "input_data_ids": [],
            "output_data_receivers": [],
            "signer_id": "bowen",
            "signer_public_key": "ed25519:2f9Zv5kuyuPM5DCyEP5pSqg58NQ8Ct9uSRerZXnCS9fK"
          }
        },
        "receipt_id": "FDp8ovTf5uJYDFemW5op6ebjCT2n4CPExHYie3S1h4qp",
        "receiver_id": "bowen"
      }
    ],
    "receipts_outcome": [
      {
        "block_hash": "HuqYrYsC7h2VERFMgFkqaNqSiFuTH9CA3uJr3BkyNxhF",
        "id": "FXMVxdhSUZaZftbmPJWaoqhEB9GrKB2oqg9Wgvuyvom8",
        "outcome": {
          "executor_id": "evgeny.lockup.m0",
          "gas_burnt": 3493189769144,
          "logs": ["Transferring 1000 to account @bowen"],
          "receipt_ids": [
            "3Ad7pUygUegMUWUb1rEazfjnTaHfptXCABqKQ6WNq6Wa",
            "FDp8ovTf5uJYDFemW5op6ebjCT2n4CPExHYie3S1h4qp"
          ],
          "status": {
            "SuccessReceiptId": "3Ad7pUygUegMUWUb1rEazfjnTaHfptXCABqKQ6WNq6Wa"
          },
          "tokens_burnt": "349318976914400000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "5WwHEszBcpfrHnt2VTvVDVnEEACNq5EpQdjz1aW9gTAa"
          }
        ]
      },
      {
        "block_hash": "DJ6oK5FtPPSwksS6pKdEjFvHWAaSVocnVNLoyi8aYk1k",
        "id": "3Ad7pUygUegMUWUb1rEazfjnTaHfptXCABqKQ6WNq6Wa",
        "outcome": {
          "executor_id": "bowen",
          "gas_burnt": 223182562500,
          "logs": [],
          "receipt_ids": ["5DdQg9pfoJMX1q6bvhsjyyRihzA3sb9Uq5K1J7vK43Ze"],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "22318256250000000000"
        },
        "proof": [
          {
            "direction": "Right",
            "hash": "CXSXmKpDU8R3UUrBAsffWMeGfKanKqEHCQrHeZkR3RKT"
          },
          {
            "direction": "Right",
            "hash": "2dNo7A1VHKBmMA86m1k3Z9DVXwWgQJGkKGRg8wUR3co9"
          }
        ]
      },
      {
        "block_hash": "9cjUoqAksMbs7ZJ4CXiuwm8vppz9QctTwGmgwZ5mDmUA",
        "id": "5DdQg9pfoJMX1q6bvhsjyyRihzA3sb9Uq5K1J7vK43Ze",
        "outcome": {
          "executor_id": "bowen",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": []
      },
      {
        "block_hash": "DJ6oK5FtPPSwksS6pKdEjFvHWAaSVocnVNLoyi8aYk1k",
        "id": "FDp8ovTf5uJYDFemW5op6ebjCT2n4CPExHYie3S1h4qp",
        "outcome": {
          "executor_id": "bowen",
          "gas_burnt": 0,
          "logs": [],
          "receipt_ids": [],
          "status": {
            "SuccessValue": ""
          },
          "tokens_burnt": "0"
        },
        "proof": [
          {
            "direction": "Left",
            "hash": "A2Ry6NCeuK8WhRCWc41hy6uddadc5nLJ1NBX5wVYo3Yb"
          },
          {
            "direction": "Right",
            "hash": "2dNo7A1VHKBmMA86m1k3Z9DVXwWgQJGkKGRg8wUR3co9"
          }
        ]
      }
    ],
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "actions": [
        {
          "FunctionCall": {
            "args": "eyJhbW91bnQiOiIxMDAwIiwicmVjZWl2ZXJfaWQiOiJib3dlbiJ9",
            "deposit": "0",
            "gas": 100000000000000,
            "method_name": "transfer"
          }
        }
      ],
      "hash": "HEgnVQZfs9uJzrqTob4g2Xmebqodq9waZvApSkrbcAhd",
      "nonce": 77,
      "public_key": "ed25519:2f9Zv5kuyuPM5DCyEP5pSqg58NQ8Ct9uSRerZXnCS9fK",
      "receiver_id": "evgeny.lockup.m0",
      "signature": "ed25519:5v1hJuw5RppKGezJHBFU6z3hwmmdferETud9rUbwxVf6xSBAWyiod93Lezaq4Zdcp4zbukDusQY9PjhV47JVCgBx",
      "signer_id": "bowen"
    },
    "transaction_outcome": {
      "block_hash": "9RX2pefXKw8M4EYjLznDF3AMvbkf9asAjN8ACK7gxKsa",
      "id": "HEgnVQZfs9uJzrqTob4g2Xmebqodq9waZvApSkrbcAhd",
      "outcome": {
        "executor_id": "bowen",
        "gas_burnt": 2428026088898,
        "logs": [],
        "receipt_ids": ["FXMVxdhSUZaZftbmPJWaoqhEB9GrKB2oqg9Wgvuyvom8"],
        "status": {
          "SuccessReceiptId": "FXMVxdhSUZaZftbmPJWaoqhEB9GrKB2oqg9Wgvuyvom8"
        },
        "tokens_burnt": "242802608889800000000"
      },
      "proof": [
        {
          "direction": "Right",
          "hash": "DXf4XVmAF5jnjZhcxi1CYxGPuuQrcAmayq9X5inSAYvJ"
        }
      ]
    }
  }
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_tx_status method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      INVALID_TRANSACTION
      200
      An error happened during transaction execution
      
        
          See error.cause.info for details
        
      
    
    
      UNKNOWN_TRANSACTION
      200
      The requested transaction is not available on the node since it might have not been recorded on the chain yet or has been garbage-collected
      
        
          Try again later
          If the transaction had been submitted more than 5 epochs ago, try to send your request to an archival node
          Check the transaction hash
        
      
    
    
      TIMEOUT_ERROR
      408
      It was unable to wait for the transaction status for reasonable time
      
        
          Send a request to a different node
          Try again later
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Receipt by ID

Fetches a receipt by it's ID (as is, without a status or execution outcome)


method: EXPERIMENTAL_receipt
params:

receipt_id (see NearBlocks Explorer for a valid receipt id)


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_receipt",
  "params": { "receipt_id": "2EbembRPJhREPtmHCrGv3Xtdm3xoc5BMVYHm3b2kjvMY" }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=EXPERIMENTAL_receipt params:='{"receipt_id": "2EbembRPJhREPtmHCrGv3Xtdm3xoc5BMVYHm3b2kjvMY"}' id=dontcare
```




Example response:


```json
{
  "id": "dontcare",
  "jsonrpc": "2.0",
  "result": {
    "predecessor_id": "bohdan.testnet",
    "receipt": {
      "Action": {
        "actions": [
          {
            "Transfer": {
              "deposit": "1000000000000000000000000"
            }
          }
        ],
        "gas_price": "103000000",
        "input_data_ids": [],
        "output_data_receivers": [],
        "signer_id": "bohdan.testnet",
        "signer_public_key": "ed25519:DhC7rPNTBwWJtmVXs1U1SqJztkn9AWbj6jCmQtkrg3TA"
      }
    },
    "receipt_id": "2EbembRPJhREPtmHCrGv3Xtdm3xoc5BMVYHm3b2kjvMY",
    "receiver_id": "frol.testnet"
  }
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_receipt method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_RECEIPT
      200
      The receipt with the given receipt_id was never observed on the node
      
        
          Check the provided receipt_id is correct
          Send a request on a different node
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  

Transaction Execution Levels
All the methods listed above have wait_until request parameter, and final_execution_status response value.
They correspond to the same enum TxExecutionStatus.
See the detailed explanation for all the options:
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TxExecutionStatus {
  /// Transaction is waiting to be included into the block
  None,
  /// Transaction is included into the block. The block may be not finalized yet
  Included,
  /// Transaction is included into the block +
  /// All non-refund transaction receipts finished their execution.
  /// The corresponding blocks for tx and each receipt may be not finalized yet
  #[default]
  ExecutedOptimistic,
  /// Transaction is included into finalized block
  IncludedFinal,
  /// Transaction is included into finalized block +
  /// All non-refund transaction receipts finished their execution.
  /// The corresponding blocks for each receipt may be not finalized yet
  Executed,
  /// Transaction is included into finalized block +
  /// Execution of all transaction receipts is finalized, including refund receipts
  Final,
}

Deprecated methods
[deprecated] Send transaction (async)

Consider using send_tx instead
Sends a transaction and immediately returns transaction hash.


method: broadcast_tx_async
params: [SignedTransaction encoded in base64]

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "broadcast_tx_async",
  "params": [
    "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDwAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldNMnL7URB1cxPOu3G8jTqlEwlcasagIbKlAJlF5ywVFLAQAAAAMAAACh7czOG8LTAAAAAAAAAGQcOG03xVSFQFjoagOb4NBBqWhERnnz45LY4+52JgZhm1iQKz7qAdPByrGFDQhQ2Mfga8RlbysuQ8D8LlA6bQE="
  ]
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_async 
    params:='[
        "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDwAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldNMnL7URB1cxPOu3G8jTqlEwlcasagIbKlAJlF5ywVFLAQAAAAMAAACh7czOG8LTAAAAAAAAAGQcOG03xVSFQFjoagOb4NBBqWhERnnz45LY4+52JgZhm1iQKz7qAdPByrGFDQhQ2Mfga8RlbysuQ8D8LlA6bQE="
    ]'
```



Example response:
{
  "jsonrpc": "2.0",
  "result": "6zgh2u9DqHHiXzdy9ouTP7oGky2T4nugqzqt9wJZwNFm",
  "id": "dontcare"
}
Final transaction results can be queried using Transaction Status
or NearBlocks Explorer using the above result hash returning a result similar to the example below.

What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by broadcast_tx_async method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
  


[deprecated] Send transaction (await)

Consider using send_tx instead
Sends a transaction and waits until transaction is fully complete. (Has a 10 second timeout)


method: broadcast_tx_commit
params: [SignedTransaction encoded in base64]

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "broadcast_tx_commit",
  "params": [
    "DgAAAHNlbmRlci50ZXN0bmV0AOrmAai64SZOv9e/naX4W15pJx0GAap35wTT1T/DwcbbDQAAAAAAAAAQAAAAcmVjZWl2ZXIudGVzdG5ldIODI4YfV/QS++blXpQYT+bOsRblTRW4f547y/LkvMQ9AQAAAAMAAACh7czOG8LTAAAAAAAAAAXcaTJzu9GviPT7AD4mNJGY79jxTrjFLoyPBiLGHgBi8JK1AnhK8QknJ1ourxlvOYJA2xEZE8UR24THmSJcLQw="
  ]
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=broadcast_tx_commit 
    params:='[
        "DwAAAG5lYXJrYXQudGVzdG5ldABuTi5L1rwnlb35hc9tn5WELkxfiGfGh1Q5aeGNQDejo0QAAAAAAAAAEAAAAGpvc2hmb3JkLnRlc3RuZXSiWAc6W9KlqXS5fK+vjFRDV5pAxHRKU0srKX/cmdRTBgEAAAADAAAAoe3MzhvC0wAAAAAAAAB9rOE9zc5zQYLL1j6VTh3I4fQbERs6I07gJfrAC6jo8DB4HolR9Xps3v4qrZxkgZjwv6wB0QOROM4UEbeOaBoB"
    ]'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "final_execution_status": "FINAL",
    "status": {
      "SuccessValue": ""
    },
    "transaction": {
      "signer_id": "sender.testnet",
      "public_key": "ed25519:Gowpa4kXNyTMRKgt5W7147pmcc2PxiFic8UHW9rsNvJ6",
      "nonce": 13,
      "receiver_id": "receiver.testnet",
      "actions": [
        {
          "Transfer": {
            "deposit": "1000000000000000000000000"
          }
        }
      ],
      "signature": "ed25519:7oCBMfSHrZkT7tzPDBxxCd3tWFhTES38eks3MCZMpYPJRfPWKxJsvmwQiVBBxRLoxPTnXVaMU2jPV3MdFKZTobH",
      "hash": "ASS7oYwGiem9HaNwJe6vS2kznx2CxueKDvU9BAYJRjNR"
    },
    "transaction_outcome": {
      "proof": [],
      "block_hash": "9MzuZrRPW1BGpFnZJUJg6SzCrixPpJDfjsNeUobRXsLe",
      "id": "ASS7oYwGiem9HaNwJe6vS2kznx2CxueKDvU9BAYJRjNR",
      "outcome": {
        "logs": [],
        "receipt_ids": ["BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh"],
        "gas_burnt": 223182562500,
        "tokens_burnt": "22318256250000000000",
        "executor_id": "sender.testnet",
        "status": {
          "SuccessReceiptId": "BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh"
        }
      }
    },
    "receipts_outcome": [
      {
        "proof": [],
        "block_hash": "5Hpj1PeCi32ZkNXgiD1DrW4wvW4Xtic74DJKfyJ9XL3a",
        "id": "BLV2q6p8DX7pVgXRtGtBkyUNrnqkNyU7iSksXG7BjVZh",
        "outcome": {
          "logs": [],
          "receipt_ids": ["3sawynPNP8UkeCviGqJGwiwEacfPyxDKRxsEWPpaUqtR"],
          "gas_burnt": 223182562500,
          "tokens_burnt": "22318256250000000000",
          "executor_id": "receiver.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      },
      {
        "proof": [],
        "block_hash": "CbwEqMpPcu6KwqVpBM3Ry83k6M4H1FrJjES9kBXThcRd",
        "id": "3sawynPNP8UkeCviGqJGwiwEacfPyxDKRxsEWPpaUqtR",
        "outcome": {
          "logs": [],
          "receipt_ids": [],
          "gas_burnt": 0,
          "tokens_burnt": "0",
          "executor_id": "sender.testnet",
          "status": {
            "SuccessValue": ""
          }
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by broadcast_tx_commit method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      INVALID_TRANSACTION
      200
      An error happened during transaction execution
      
        
          See error.cause.info for details, likely a field in the transaction was invalid
          If error.cause.info is ShardCongested, resubmit the identical transaction after a delay. (Consider adding a priority fee once [NEP-541](https://github.com/near/NEPs/pull/541) is released.)
          If error.cause.info is ShardStuck, you may also resubmit the identical transaction after a delay
        
      
    
    
      TIMEOUT_ERROR
      408
      Transaction was routed, but has not been recorded on chain in 10 seconds.
      
        
           Resubmit the request with the identical transaction (in NEAR Protocol unique transactions apply exactly once, so if the previously sent transaction gets applied, this request will just return the known result, otherwise, it will route the transaction to the chain once again)
          Check that your transaction is valid
          Check that the signer account id has enough tokens to cover the transaction fees (keep in mind that some tokens on each account are locked to cover the storage cost)
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Setup

In order to use the RPC API you will need to setup the correct RPC endpoints.

RPC Endpoint Setup

POST for all methods
JSON RPC 2.0
`- endpoint URL varies by network:

mainnet https://rpc.mainnet.near.org
testnet https://rpc.testnet.near.org
betanet https://rpc.betanet.near.org (may be unstable)
localnet http://localhost:3030


Limits

Maximum number of requests per IP: 600 req/min


Querying Historical Data
Querying historical data (older than 5 epochs or ~2.5 days), you may get responses that the data is not available anymore. In that case, archival RPC nodes will come to your rescue:

mainnet https://archival-rpc.mainnet.near.org
testnet https://archival-rpc.testnet.near.org

You can see this interface defined in nearcore here.
Limits

Maximum number of requests per IP: 600 req/min


Postman Setup
An easy way to test the queries in this documentation page is to use an API request tool such as Postman.
You only need to configure two things:


Make sure you add a header with a key of Content-Type and value of application/json.



Then select the Body tab and choose the raw radio button and ensure JSON is the selected format.



After that is set up, just copy/paste the JSON object example snippets below into the body of your request, on Postman, and click send.

JavaScript Setup
All of the queries listed in this documentation page can be called using near-api-js.

For near-api-js installation and setup please refer to near-api-js quick reference documentation.
All JavaScript code snippets require a near object. For examples of how to instantiate, click here.


HTTPie Setup
If you prefer to use a command line interface, we have provided RPC examples you can use with HTTPie. Please note that params take
either an object or array passed as a string.
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=network_info params:='[]'

Using block_id param

The block_id param can take either the block number (e.g. 27912554) or the block hash (e.g. '3Xz2wM9rigMXzA2c5vgCP8wTgFBaePucgUmVYPkMqhRL' ) as an argument.
::caution
The block IDs of transactions shown in NearBlocks Explorer are not necessarily the block ID of the executed transaction. Transactions may execute a block or two after its recorded, and in some cases, can take place over several blocks. Due to this, it is important to check subsequent blocks to be sure all results related to the queried transaction are discovered.
::


Using finality param
The finality param has two options: optimistic and final.

optimistic uses the latest block recorded on the node that responded to your query (< 1 second delay after the transaction is submitted)
final is for a block that has been validated on at least 66% of the nodes in the network (usually takes 2 blocks / approx. 2 second delay)

### RPC Providers

There are multiple RPC providers from which you can choose from. These providers will work as intermediaries to help you interact with the NEAR network.
You'll experience different latency levels depending on the provider's location. You can potentially use multiple providers for redundancy and
balancing.
tipIf you want to use a custom RPC provider with NEAR Wallet Selector, [check this example](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/integrate-contracts.md#setting-customs-rpc-endpoints).


Mainnet



Provider
Endpoint Root




NEAR
https://rpc.mainnet.near.org


Pagoda
https://rpc.mainnet.pagoda.co


1RPC
https://1rpc.io/near


All That Node
https://near-mainnet-rpc.allthatnode.com:3030


ankr.com
https://rpc.ankr.com/near


BlockPI Network
https://near.blockpi.network/v1/rpc/public


dRPC
https://near.drpc.org


fast-near web4
https://rpc.web4.near.page


FASTNEAR
https://free.rpc.fastnear.com


Gateway.fm
https://rpc.near.gateway.fm/


GetBlock
https://getblock.io/nodes/near/


Lava Network
https://near.lava.build


Lavender.Five Nodes
https://near.lavenderfive.com/


NodeReal
https://nodereal.io/api-marketplace/near-rpc


NOWNodes
https://near.nownodes.io/


OMNIA
https://endpoints.omniatech.io/v1/near/mainnet/public


QuickNode
-


Seracle
https://api.seracle.com/saas/baas/rpc/near/mainnet/public/


Zeeve
-



Testnet



Provider
Endpoint Root




NEAR
https://rpc.testnet.near.org


Pagoda
https://rpc.testnet.pagoda.co


FASTNEAR
https://test.rpc.fastnear.com



RPC Failover
In near-api-js you can use FailoverRpcProvider to automatically switch RPC providers when one provider is experiencing downtime, or implement an RPC selection widget that allows users to add their own RPC provider.
As a user, if a dApp or wallet doesn't support RPC failover and the primary provider is down, you can use an RPC Selector browser extension to redirect all requests to an RPC provider of your choice.

### Protocol

The RPC API enables you to retrieve the current genesis and protocol configuration.

Genesis Config

Returns current genesis configuration.


method: EXPERIMENTAL_genesis_config
params: none

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_genesis_config"
}
```




```js
const response = await near.connection.provider.experimental_genesisConfig();
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_genesis_config
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "protocol_version": 29,
    "genesis_time": "2020-07-31T03:39:42.911378Z",
    "chain_id": "testnet",
    "genesis_height": 10885359,
    "num_block_producer_seats": 100,
    "num_block_producer_seats_per_shard": [100],
    "avg_hidden_validator_seats_per_shard": [0],
    "dynamic_resharding": false,
    "protocol_upgrade_stake_threshold": [4, 5],
    "protocol_upgrade_num_epochs": 2,
    "epoch_length": 43200,
    "gas_limit": 1000000000000000,
    "min_gas_price": "5000",
    "max_gas_price": "10000000000000000000000",
    "block_producer_kickout_threshold": 80,
    "chunk_producer_kickout_threshold": 90,
    "online_min_threshold": [90, 100],
    "online_max_threshold": [99, 100],
    "gas_price_adjustment_rate": [1, 100],
    "runtime_config": {
      "storage_amount_per_byte": "90949470177292823791",
      "transaction_costs": {
        "action_receipt_creation_config": {
          "send_sir": 108059500000,
          "send_not_sir": 108059500000,
          "execution": 108059500000
        },
        "data_receipt_creation_config": {
          "base_cost": {
            "send_sir": 4697339419375,
            "send_not_sir": 4697339419375,
            "execution": 4697339419375
          },
          "cost_per_byte": {
            "send_sir": 59357464,
            "send_not_sir": 59357464,
            "execution": 59357464
          }
        },
        "action_creation_config": {
          "create_account_cost": {
            "send_sir": 99607375000,
            "send_not_sir": 99607375000,
            "execution": 99607375000
          },
          "deploy_contract_cost": {
            "send_sir": 184765750000,
            "send_not_sir": 184765750000,
            "execution": 184765750000
          },
          "deploy_contract_cost_per_byte": {
            "send_sir": 6812999,
            "send_not_sir": 6812999,
            "execution": 6812999
          },
          "function_call_cost": {
            "send_sir": 2319861500000,
            "send_not_sir": 2319861500000,
            "execution": 2319861500000
          },
          "function_call_cost_per_byte": {
            "send_sir": 2235934,
            "send_not_sir": 2235934,
            "execution": 2235934
          },
          "transfer_cost": {
            "send_sir": 115123062500,
            "send_not_sir": 115123062500,
            "execution": 115123062500
          },
          "stake_cost": {
            "send_sir": 141715687500,
            "send_not_sir": 141715687500,
            "execution": 102217625000
          },
          "add_key_cost": {
            "full_access_cost": {
              "send_sir": 101765125000,
              "send_not_sir": 101765125000,
              "execution": 101765125000
            },
            "function_call_cost": {
              "send_sir": 102217625000,
              "send_not_sir": 102217625000,
              "execution": 102217625000
            },
            "function_call_cost_per_byte": {
              "send_sir": 1925331,
              "send_not_sir": 1925331,
              "execution": 1925331
            }
          },
          "delete_key_cost": {
            "send_sir": 94946625000,
            "send_not_sir": 94946625000,
            "execution": 94946625000
          },
          "delete_account_cost": {
            "send_sir": 147489000000,
            "send_not_sir": 147489000000,
            "execution": 147489000000
          }
        },
        "storage_usage_config": {
          "num_bytes_account": 100,
          "num_extra_bytes_record": 40
        },
        "burnt_gas_reward": [3, 10],
        "pessimistic_gas_price_inflation_ratio": [103, 100]
      },
      "wasm_config": {
        "ext_costs": {
          "base": 264768111,
          "contract_compile_base": 35445963,
          "contract_compile_bytes": 216750,
          "read_memory_base": 2609863200,
          "read_memory_byte": 3801333,
          "write_memory_base": 2803794861,
          "write_memory_byte": 2723772,
          "read_register_base": 2517165186,
          "read_register_byte": 98562,
          "write_register_base": 2865522486,
          "write_register_byte": 3801564,
          "utf8_decoding_base": 3111779061,
          "utf8_decoding_byte": 291580479,
          "utf16_decoding_base": 3543313050,
          "utf16_decoding_byte": 163577493,
          "sha256_base": 4540970250,
          "sha256_byte": 24117351,
          "keccak256_base": 5879491275,
          "keccak256_byte": 21471105,
          "keccak512_base": 5811388236,
          "keccak512_byte": 36649701,
          "log_base": 3543313050,
          "log_byte": 13198791,
          "storage_write_base": 64196736000,
          "storage_write_key_byte": 70482867,
          "storage_write_value_byte": 31018539,
          "storage_write_evicted_byte": 32117307,
          "storage_read_base": 56356845750,
          "storage_read_key_byte": 30952533,
          "storage_read_value_byte": 5611005,
          "storage_remove_base": 53473030500,
          "storage_remove_key_byte": 38220384,
          "storage_remove_ret_value_byte": 11531556,
          "storage_has_key_base": 54039896625,
          "storage_has_key_byte": 30790845,
          "storage_iter_create_prefix_base": 0,
          "storage_iter_create_prefix_byte": 0,
          "storage_iter_create_range_base": 0,
          "storage_iter_create_from_byte": 0,
          "storage_iter_create_to_byte": 0,
          "storage_iter_next_base": 0,
          "storage_iter_next_key_byte": 0,
          "storage_iter_next_value_byte": 0,
          "touching_trie_node": 16101955926,
          "promise_and_base": 1465013400,
          "promise_and_per_promise": 5452176,
          "promise_return": 560152386,
          "validator_stake_base": 911834726400,
          "validator_total_stake_base": 911834726400
        },
        "grow_mem_cost": 1,
        "regular_op_cost": 3856371,
        "limit_config": {
          "max_gas_burnt": 200000000000000,
          "max_gas_burnt_view": 200000000000000,
          "max_stack_height": 16384,
          "initial_memory_pages": 1024,
          "max_memory_pages": 2048,
          "registers_memory_limit": 1073741824,
          "max_register_size": 104857600,
          "max_number_registers": 100,
          "max_number_logs": 100,
          "max_total_log_length": 16384,
          "max_total_prepaid_gas": 300000000000000,
          "max_actions_per_receipt": 100,
          "max_number_bytes_method_names": 2000,
          "max_length_method_name": 256,
          "max_arguments_length": 4194304,
          "max_length_returned_data": 4194304,
          "max_contract_size": 4194304,
          "max_length_storage_key": 4194304,
          "max_length_storage_value": 4194304,
          "max_promises_per_function_call_action": 1024,
          "max_number_input_data_dependencies": 128
        }
      },
      "account_creation_config": {
        "min_allowed_top_level_account_length": 0,
        "registrar_account_id": "registrar"
      }
    },
    "validators": [
      {
        "account_id": "node0",
        "public_key": "ed25519:7PGseFbWxvYVgZ89K1uTJKYoKetWs7BJtbyXDzfbAcqX",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node1",
        "public_key": "ed25519:6DSjZ8mvsRZDvFqFxo8tCKePG96omXW7eVYVSySmDk8e",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node2",
        "public_key": "ed25519:GkDv7nSMS3xcqA45cpMvFmfV1o4fRF6zYo1JRR6mNqg5",
        "amount": "1000000000000000000000000000000"
      },
      {
        "account_id": "node3",
        "public_key": "ed25519:ydgzeXHJ5Xyt7M1gXLxqLBW1Ejx6scNV5Nx2pxFM8su",
        "amount": "1000000000000000000000000000000"
      }
    ],
    "transaction_validity_period": 86400,
    "protocol_reward_rate": [1, 10],
    "max_inflation_rate": [1, 20],
    "total_supply": "1031467299046044096035532756810080",
    "num_blocks_per_year": 31536000,
    "protocol_treasury_account": "near",
    "fishermen_threshold": "10000000000000000000",
    "minimum_stake_divisor": 10
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_genesis_config method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Protocol Config

Returns most recent protocol configuration or a specific queried block. Useful for finding current storage and transaction costs.


method: EXPERIMENTAL_protocol_config
params:

finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_protocol_config",
  "params": {
    "finality": "final"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_protocol_config 
  params:='{
    "finality": "final"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "protocol_version": 45,
    "genesis_time": "2020-07-31T03:39:42.911378Z",
    "chain_id": "testnet",
    "genesis_height": 42376888,
    "num_block_producer_seats": 200,
    "num_block_producer_seats_per_shard": [200],
    "avg_hidden_validator_seats_per_shard": [0],
    "dynamic_resharding": false,
    "protocol_upgrade_stake_threshold": [4, 5],
    "epoch_length": 43200,
    "gas_limit": 1000000000000000,
    "min_gas_price": "5000",
    "max_gas_price": "10000000000000000000000",
    "block_producer_kickout_threshold": 80,
    "chunk_producer_kickout_threshold": 90,
    "online_min_threshold": [90, 100],
    "online_max_threshold": [99, 100],
    "gas_price_adjustment_rate": [1, 100],
    "runtime_config": {
      "storage_amount_per_byte": "10000000000000000000",
      "transaction_costs": {
        "action_receipt_creation_config": {
          "send_sir": 108059500000,
          "send_not_sir": 108059500000,
          "execution": 108059500000
        },
        "data_receipt_creation_config": {
          "base_cost": {
            "send_sir": 4697339419375,
            "send_not_sir": 4697339419375,
            "execution": 4697339419375
          },
          "cost_per_byte": {
            "send_sir": 59357464,
            "send_not_sir": 59357464,
            "execution": 59357464
          }
        },
        "action_creation_config": {
          "create_account_cost": {
            "send_sir": 99607375000,
            "send_not_sir": 99607375000,
            "execution": 99607375000
          },
          "deploy_contract_cost": {
            "send_sir": 184765750000,
            "send_not_sir": 184765750000,
            "execution": 184765750000
          },
          "deploy_contract_cost_per_byte": {
            "send_sir": 6812999,
            "send_not_sir": 6812999,
            "execution": 6812999
          },
          "function_call_cost": {
            "send_sir": 2319861500000,
            "send_not_sir": 2319861500000,
            "execution": 2319861500000
          },
          "function_call_cost_per_byte": {
            "send_sir": 2235934,
            "send_not_sir": 2235934,
            "execution": 2235934
          },
          "transfer_cost": {
            "send_sir": 115123062500,
            "send_not_sir": 115123062500,
            "execution": 115123062500
          },
          "stake_cost": {
            "send_sir": 141715687500,
            "send_not_sir": 141715687500,
            "execution": 102217625000
          },
          "add_key_cost": {
            "full_access_cost": {
              "send_sir": 101765125000,
              "send_not_sir": 101765125000,
              "execution": 101765125000
            },
            "function_call_cost": {
              "send_sir": 102217625000,
              "send_not_sir": 102217625000,
              "execution": 102217625000
            },
            "function_call_cost_per_byte": {
              "send_sir": 1925331,
              "send_not_sir": 1925331,
              "execution": 1925331
            }
          },
          "delete_key_cost": {
            "send_sir": 94946625000,
            "send_not_sir": 94946625000,
            "execution": 94946625000
          },
          "delete_account_cost": {
            "send_sir": 147489000000,
            "send_not_sir": 147489000000,
            "execution": 147489000000
          }
        },
        "storage_usage_config": {
          "num_bytes_account": 100,
          "num_extra_bytes_record": 40
        },
        "burnt_gas_reward": [3, 10],
        "pessimistic_gas_price_inflation_ratio": [103, 100]
      },
      "wasm_config": {
        "ext_costs": {
          "base": 264768111,
          "contract_compile_base": 35445963,
          "contract_compile_bytes": 216750,
          "read_memory_base": 2609863200,
          "read_memory_byte": 3801333,
          "write_memory_base": 2803794861,
          "write_memory_byte": 2723772,
          "read_register_base": 2517165186,
          "read_register_byte": 98562,
          "write_register_base": 2865522486,
          "write_register_byte": 3801564,
          "utf8_decoding_base": 3111779061,
          "utf8_decoding_byte": 291580479,
          "utf16_decoding_base": 3543313050,
          "utf16_decoding_byte": 163577493,
          "sha256_base": 4540970250,
          "sha256_byte": 24117351,
          "keccak256_base": 5879491275,
          "keccak256_byte": 21471105,
          "keccak512_base": 5811388236,
          "keccak512_byte": 36649701,
          "log_base": 3543313050,
          "log_byte": 13198791,
          "storage_write_base": 64196736000,
          "storage_write_key_byte": 70482867,
          "storage_write_value_byte": 31018539,
          "storage_write_evicted_byte": 32117307,
          "storage_read_base": 56356845750,
          "storage_read_key_byte": 30952533,
          "storage_read_value_byte": 5611005,
          "storage_remove_base": 53473030500,
          "storage_remove_key_byte": 38220384,
          "storage_remove_ret_value_byte": 11531556,
          "storage_has_key_base": 54039896625,
          "storage_has_key_byte": 30790845,
          "storage_iter_create_prefix_base": 0,
          "storage_iter_create_prefix_byte": 0,
          "storage_iter_create_range_base": 0,
          "storage_iter_create_from_byte": 0,
          "storage_iter_create_to_byte": 0,
          "storage_iter_next_base": 0,
          "storage_iter_next_key_byte": 0,
          "storage_iter_next_value_byte": 0,
          "touching_trie_node": 16101955926,
          "promise_and_base": 1465013400,
          "promise_and_per_promise": 5452176,
          "promise_return": 560152386,
          "validator_stake_base": 911834726400,
          "validator_total_stake_base": 911834726400
        },
        "grow_mem_cost": 1,
        "regular_op_cost": 3856371,
        "limit_config": {
          "max_gas_burnt": 200000000000000,
          "max_gas_burnt_view": 200000000000000,
          "max_stack_height": 16384,
          "initial_memory_pages": 1024,
          "max_memory_pages": 2048,
          "registers_memory_limit": 1073741824,
          "max_register_size": 104857600,
          "max_number_registers": 100,
          "max_number_logs": 100,
          "max_total_log_length": 16384,
          "max_total_prepaid_gas": 300000000000000,
          "max_actions_per_receipt": 100,
          "max_number_bytes_method_names": 2000,
          "max_length_method_name": 256,
          "max_arguments_length": 4194304,
          "max_length_returned_data": 4194304,
          "max_contract_size": 4194304,
          "max_length_storage_key": 4194304,
          "max_length_storage_value": 4194304,
          "max_promises_per_function_call_action": 1024,
          "max_number_input_data_dependencies": 128
        }
      },
      "account_creation_config": {
        "min_allowed_top_level_account_length": 0,
        "registrar_account_id": "registrar"
      }
    },
    "transaction_validity_period": 86400,
    "protocol_reward_rate": [1, 10],
    "max_inflation_rate": [1, 20],
    "num_blocks_per_year": 31536000,
    "protocol_treasury_account": "near",
    "fishermen_threshold": "340282366920938463463374607431768211455",
    "minimum_stake_divisor": 10
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_protocol_config method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Network

The RPC API enables you to query status information for nodes and validators.

Node Status

Returns general status of a given node (sync status, nearcore node version, protocol version, etc), and the current set of validators.


method: status
params: []

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "status",
  "params": []
}
```




```js
const response = await near.connection.provider.status();
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=status params:='[]' id=dontcare
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "version": {
      "version": "1.14.0-rc.1",
      "build": "effa3b7a-modified"
    },
    "chain_id": "testnet",
    "protocol_version": 35,
    "latest_protocol_version": 35,
    "rpc_addr": "0.0.0.0:3030",
    "validators": [
      {
        "account_id": "node3",
        "is_slashed": false
      },
      {
        "account_id": "node0",
        "is_slashed": false
      },
      {
        "account_id": "staked.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "01node.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "node2",
        "is_slashed": false
      },
      {
        "account_id": "dokia.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "node1",
        "is_slashed": false
      },
      {
        "account_id": "lowfeevalidation.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "sl1sub.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "zainy.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "chorus-one.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "thepassivetrust.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "certusone.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "joe1.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "bisontrails.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "valeraverim.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "lunanova.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "bazilik.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "dsrvlabs.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "kronos.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "nodeasy.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "kytzu.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "bitcat.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "pool_easy2stake.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "fresh_lockup.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "staking-power.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "syncnode.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "inotel.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "zpool.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "aquarius.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "cloudpost.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "staked.pool.6fb1358",
        "is_slashed": false
      },
      {
        "account_id": "moonlet.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "jazza.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "orangeclub.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "blazenet.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "pathrock.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "stakin.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "northernlights.stakingpool",
        "is_slashed": false
      },
      {
        "account_id": "alexandruast.pool.f863973.m0",
        "is_slashed": false
      },
      {
        "account_id": "top.pool.f863973.m0",
        "is_slashed": false
      }
    ],
    "sync_info": {
      "latest_block_hash": "44kieHwr7Gg5r72V3DgU7cpgV2aySkk5qbBCdvwens8T",
      "latest_block_height": 17774278,
      "latest_state_root": "3MD3fQqnm3JYa9UQgenEJsR6UHoWuHV4Tpr4hZY7QwfY",
      "latest_block_time": "2020-09-27T23:59:38.008063088Z",
      "syncing": false
    },
    "validator_account_id": "nearup-node8"
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by status method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Network Info

Returns the current state of node network connections (active peers, transmitted data, etc.)


method: network_info
params: none

Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "network_info",
  "params": []
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=network_info params:='[]' id=dontcare
```




Example response:


```json
{
  "jsonrpc": "2.0",
  "result": {
    "active_peers": [
      {
        "id": "ed25519:GkDv7nSMS3xcqA45cpMvFmfV1o4fRF6zYo1JRR6mNqg5",
        "addr": "35.193.24.121:24567",
        "account_id": null
      }
    ],
    "num_active_peers": 34,
    "peer_max_count": 40,
    "sent_bytes_per_sec": 17754754,
    "received_bytes_per_sec": 492116,
    "known_producers": [
      {
        "account_id": "node0",
        "addr": null,
        "peer_id": "ed25519:7PGseFbWxvYVgZ89K1uTJKYoKetWs7BJtbyXDzfbAcqX"
      }
    ]
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by network_info method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Validation Status

Queries active validators on the network returning details and the state of
validation on the blockchain.


method: validators
params: ["block hash"], [block number], {"epoch_id": "epoch id"},
{"block_id": block number}, {"block_id": "block hash"}, or
[null] for the latest block

Note: If you want the latest block hash, block number and epoch id,
you will need to query from the last block in an epoch. You can also query
validators endpoint for past epochs if you input block hash, block number
or epoch id of the past epoch that you want.
Example:
input: [block number]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": [17791098]
}
```







```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=validators params:='[17791098]' id=dontcare
```



input: ["block hash"]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": ["FiG2nMjjue3YdgYAyM3ZqWXSaG6RJj5Gk7hvY8vrEoGw"]
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=validators params:='["FiG2nMjjue3YdgYAyM3ZqWXSaG6RJj5Gk7hvY8vrEoGw"]' id=dontcare
```



input: {"block_id": "block hash"}



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": {
    "block_id": "FiG2nMjjue3YdgYAyM3ZqWXSaG6RJj5Gk7hvY8vrEoGw"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=validators 
  params:='{
    "block_id": "FiG2nMjjue3YdgYAyM3ZqWXSaG6RJj5Gk7hvY8vrEoGw"
  }'
```



input: {"block_id": block number}



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": {
    "block_id": 17791098
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=validators 
  params:='{
    "block_id": 17791098
  }`
```



input: {"epoch_id": "epoch id"}



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": {
    "epoch_id": "8hJSZNNyimPvsCA1v3dMr3Hg5ucYeLUbTvEfhr6jaWJy"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=validators 
  params:='{
    "epoch_id": "8hJSZNNyimPvsCA1v3dMr3Hg5ucYeLUbTvEfhr6jaWJy"
  }`
```



input: [null]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "validators",
  "params": [null]
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=validators params:='[null]' id=dontcare
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "current_validators": [
      {
        "account_id": "01node.pool.f863973.m0",
        "public_key": "ed25519:3iNqnvBgxJPXCxu6hNdvJso1PEAc1miAD35KQMBCA3aL",
        "is_slashed": false,
        "stake": "176429739989396285019500901780",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "alexandruast.pool.f863973.m0",
        "public_key": "ed25519:A3XJ3uVGxSi9o2gnG2r8Ra3fqqodRpL4iuLTc6fNdGUj",
        "is_slashed": false,
        "stake": "151430394143736014372434860532",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "aquarius.pool.f863973.m0",
        "public_key": "ed25519:8NfEarjStDYjJTwKUgQGy7Z7UTGsZaPhTUsExheQN3r1",
        "is_slashed": false,
        "stake": "130367563121508828296664196836",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "bazilik.pool.f863973.m0",
        "public_key": "ed25519:3pDJwDQ6Y5B9QeW1jz8KunhZH4D4GQG86reTmrRfdD7c",
        "is_slashed": false,
        "stake": "169013447850997135034919151338",
        "shards": [0],
        "num_produced_blocks": 211,
        "num_expected_blocks": 213
      },
      {
        "account_id": "bisontrails.pool.f863973.m0",
        "public_key": "ed25519:8g4P5EXyp2b2pfVMHY1QLfkRcY59hjPfWrFCKUWX3RmR",
        "is_slashed": false,
        "stake": "184162578269044826045352223479",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "bitcat.pool.f863973.m0",
        "public_key": "ed25519:9mtnwPQyyap1QNH9ag6r4the7Jkkpdyt9HUF5G1dWxKx",
        "is_slashed": false,
        "stake": "135215509376418353124295451543",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "blazenet.pool.f863973.m0",
        "public_key": "ed25519:DiogP36wBXKFpFeqirrxN8G2Mq9vnakgBvgnHdL9CcN3",
        "is_slashed": false,
        "stake": "137364229255641651855065314186",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "certusone.pool.f863973.m0",
        "public_key": "ed25519:CKW7f41Kn8YCDPzaGLs1MrPb9h3BjQmHhbei6Ff6nRRF",
        "is_slashed": false,
        "stake": "176644821310043228577017742667",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "chorus-one.pool.f863973.m0",
        "public_key": "ed25519:6LFwyEEsqhuDxorWfsKcPPs324zLWTaoqk4o6RDXN7Qc",
        "is_slashed": false,
        "stake": "110397600457815316527526651811",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 213
      },
      {
        "account_id": "cloudpost.pool.f863973.m0",
        "public_key": "ed25519:AVVLmJDG8z6UgmW9fmJGVFTdYxxfnqXH6c7FVQmhE6dp",
        "is_slashed": false,
        "stake": "136597929514591130855076834167",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "dokia.pool.f863973.m0",
        "public_key": "ed25519:935JMz1vLcJxFApG3TY4MA4RHhvResvoGwCrQoJxHPn9",
        "is_slashed": false,
        "stake": "220445043066799898276306006919",
        "shards": [0],
        "num_produced_blocks": 426,
        "num_expected_blocks": 426
      },
      {
        "account_id": "dsrvlabs.pool.f863973.m0",
        "public_key": "ed25519:61ei2efmmLkeDR1CG6JDEC2U3oZCUuC2K1X16Vmxrud9",
        "is_slashed": false,
        "stake": "161508967845718247649113721019",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "fresh_lockup.pool.f863973.m0",
        "public_key": "ed25519:7CMFLtEohojtxBkmj9Jb6AGgbphb1zvxymHzpzuyCjfG",
        "is_slashed": false,
        "stake": "193574159400241036715020269158",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "inotel.pool.f863973.m0",
        "public_key": "ed25519:C55jH1MCHYGa3tzUyZZdGrJmmCLP22Aa4v88KYpn2xwZ",
        "is_slashed": false,
        "stake": "178598870951670469578754984993",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "jazza.pool.f863973.m0",
        "public_key": "ed25519:85cPMNVrqUz8N7oWbbvWbUuamHcJNe49uRbaSzftLCz9",
        "is_slashed": false,
        "stake": "155762349362951827286303475797",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "joe1.pool.f863973.m0",
        "public_key": "ed25519:G3SxwzmiEZSm3bHnTLtxJvm3NvT1TLQcWuV1iod6i6NJ",
        "is_slashed": false,
        "stake": "129230772267511696840933436174",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "kronos.pool.f863973.m0",
        "public_key": "ed25519:3i2pertqzF8xqkJ4BrE4t4r67YiYYrUKCktbqvDgjzuQ",
        "is_slashed": false,
        "stake": "144544279093485390569527924033",
        "shards": [0],
        "num_produced_blocks": 202,
        "num_expected_blocks": 213
      },
      {
        "account_id": "kytzu.pool.f863973.m0",
        "public_key": "ed25519:61tgPZpy8tqFeAwG4vtf2ZKCRoENiP2A1TJVWEwnbxZU",
        "is_slashed": false,
        "stake": "113758432843198726378418342568",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "lowfeevalidation.pool.f863973.m0",
        "public_key": "ed25519:EXyjSMGSnk5uGphF3gVV1jCudaAudbW8imoEccYEJg3V",
        "is_slashed": false,
        "stake": "113685537557977098595863252617",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "lunanova.pool.f863973.m0",
        "public_key": "ed25519:2fZ59qfo9QHNLijoht9cwUb9enSNcnRmXbQn1gKZxvkw",
        "is_slashed": false,
        "stake": "172903039219549397267702571804",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "moonlet.pool.f863973.m0",
        "public_key": "ed25519:3e1nVCVGNS3yr6CcUvpDAs3BhiWtyM9uTBWkyVR5Xn3K",
        "is_slashed": false,
        "stake": "140599784944681716744261599779",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "node0",
        "public_key": "ed25519:7PGseFbWxvYVgZ89K1uTJKYoKetWs7BJtbyXDzfbAcqX",
        "is_slashed": false,
        "stake": "1907234923845608896091985071588",
        "shards": [0],
        "num_produced_blocks": 3614,
        "num_expected_blocks": 3616
      },
      {
        "account_id": "node1",
        "public_key": "ed25519:6DSjZ8mvsRZDvFqFxo8tCKePG96omXW7eVYVSySmDk8e",
        "is_slashed": false,
        "stake": "1906065501889463342906704128820",
        "shards": [0],
        "num_produced_blocks": 3613,
        "num_expected_blocks": 3614
      },
      {
        "account_id": "node2",
        "public_key": "ed25519:GkDv7nSMS3xcqA45cpMvFmfV1o4fRF6zYo1JRR6mNqg5",
        "is_slashed": false,
        "stake": "1840271519773089248112279578450",
        "shards": [0],
        "num_produced_blocks": 3615,
        "num_expected_blocks": 3615
      },
      {
        "account_id": "node3",
        "public_key": "ed25519:ydgzeXHJ5Xyt7M1gXLxqLBW1Ejx6scNV5Nx2pxFM8su",
        "is_slashed": false,
        "stake": "1247270566437910246525604113433",
        "shards": [0],
        "num_produced_blocks": 2335,
        "num_expected_blocks": 2342
      },
      {
        "account_id": "nodeasy.pool.f863973.m0",
        "public_key": "ed25519:25Dhg8NBvQhsVTuugav3t1To1X1zKiomDmnh8yN9hHMb",
        "is_slashed": false,
        "stake": "131652957125263756523827257067",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "northernlights.stakingpool",
        "public_key": "ed25519:CsMecqKCfagnebMB3ha1uRubay5Z4V85req23bNAJSG3",
        "is_slashed": false,
        "stake": "159669819380982417675619400525",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "orangeclub.pool.f863973.m0",
        "public_key": "ed25519:HezFeSzcwuR5wvkqccgMCMnpf1eQkVCfk52tXZEdKZHz",
        "is_slashed": false,
        "stake": "143971234567521206686862639104",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "pathrock.pool.f863973.m0",
        "public_key": "ed25519:G138GdQsU7PdFLD6X88NmTLAEDR7agPcq9HLZqGpegkm",
        "is_slashed": false,
        "stake": "125204431569306697735287326827",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "pool_easy2stake.pool.f863973.m0",
        "public_key": "ed25519:8nzKxvmyeauQRehWkby8GfWNLgqPiF5FCRFSD75M1Rwh",
        "is_slashed": false,
        "stake": "176893731686620703671521068552",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "sl1sub.pool.f863973.m0",
        "public_key": "ed25519:3URBpNUjNAMzugQH1rdSKMtwFM8AwHaJgZk5Z6YtnfFL",
        "is_slashed": false,
        "stake": "155741680601335529540438949153",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 213
      },
      {
        "account_id": "staked.pool.6fb1358",
        "public_key": "ed25519:684rMbuVYYgL2CkmYgC1weLh3erd2bwrmtQtJJhWzPwj",
        "is_slashed": false,
        "stake": "126911347639167461321544980789",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "staked.pool.f863973.m0",
        "public_key": "ed25519:D2afKYVaKQ1LGiWbMAZRfkKLgqimTR74wvtESvjx5Ft2",
        "is_slashed": false,
        "stake": "140558085958535444819294942478",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "stakin.pool.f863973.m0",
        "public_key": "ed25519:GvddxjaxBCqGGB4kMNWNFtvozU1EEZ2jrnggKZW8LaU4",
        "is_slashed": false,
        "stake": "122221693837484004905170552626",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "staking-power.pool.f863973.m0",
        "public_key": "ed25519:4s79F6Fdjgb3rHXPLwaXZG4Hq7Za8nogUu3vXEamRBQo",
        "is_slashed": false,
        "stake": "113293334165305165414435157738",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "syncnode.pool.f863973.m0",
        "public_key": "ed25519:FUAVDkmLhuTbKYv4GWuWv9ogjKzRatLd5ZBMKXRy7WqE",
        "is_slashed": false,
        "stake": "133414422809248011010747790387",
        "shards": [0],
        "num_produced_blocks": 212,
        "num_expected_blocks": 212
      },
      {
        "account_id": "thepassivetrust.pool.f863973.m0",
        "public_key": "ed25519:4NccD2DNJpBkDmWeJ2GbqPoivQ93qcKiR4PHALJKCTod",
        "is_slashed": false,
        "stake": "162714097201953456968339272308",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "top.pool.f863973.m0",
        "public_key": "ed25519:FR5qxAsP8GgXDN96pappLtWMywiqWsPVqT3HLE3YaUx",
        "is_slashed": false,
        "stake": "164760602493727447176131601464",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "valeraverim.pool.f863973.m0",
        "public_key": "ed25519:3686ABqNUZc1qhLWLHg5xZpBzrWPiUCMNZxcCNmg3e2s",
        "is_slashed": false,
        "stake": "191733144511459134091274432419",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "zainy.pool.f863973.m0",
        "public_key": "ed25519:37KfhBNYjqpaUVh3ft5kPcFn3xK1eVvtDZJCQQVCGnzQ",
        "is_slashed": false,
        "stake": "113441017844444454951489924484",
        "shards": [0],
        "num_produced_blocks": 213,
        "num_expected_blocks": 213
      },
      {
        "account_id": "zpool.pool.f863973.m0",
        "public_key": "ed25519:ETFRFNHfvd6fpj74MGYYQp3diY8WB4bFmWMxjTB2yY4V",
        "is_slashed": false,
        "stake": "140932616764414290525265048028",
        "shards": [0],
        "num_produced_blocks": 120,
        "num_expected_blocks": 212
      }
    ],
    "next_validators": [
      {
        "account_id": "01node.pool.f863973.m0",
        "public_key": "ed25519:3iNqnvBgxJPXCxu6hNdvJso1PEAc1miAD35KQMBCA3aL",
        "stake": "177341160716540400974121040893",
        "shards": [0]
      },
      {
        "account_id": "alexandruast.pool.f863973.m0",
        "public_key": "ed25519:A3XJ3uVGxSi9o2gnG2r8Ra3fqqodRpL4iuLTc6fNdGUj",
        "stake": "152212670433756011274558210225",
        "shards": [0]
      },
      {
        "account_id": "aquarius.pool.f863973.m0",
        "public_key": "ed25519:8NfEarjStDYjJTwKUgQGy7Z7UTGsZaPhTUsExheQN3r1",
        "stake": "131041030638338742265060835987",
        "shards": [0]
      },
      {
        "account_id": "bazilik.pool.f863973.m0",
        "public_key": "ed25519:3pDJwDQ6Y5B9QeW1jz8KunhZH4D4GQG86reTmrRfdD7c",
        "stake": "169886556654364796730036727847",
        "shards": [0]
      },
      {
        "account_id": "bisontrails.pool.f863973.m0",
        "public_key": "ed25519:8g4P5EXyp2b2pfVMHY1QLfkRcY59hjPfWrFCKUWX3RmR",
        "stake": "185113946165399113822995097304",
        "shards": [0]
      },
      {
        "account_id": "bitcat.pool.f863973.m0",
        "public_key": "ed25519:9mtnwPQyyap1QNH9ag6r4the7Jkkpdyt9HUF5G1dWxKx",
        "stake": "135914020962862866419944507506",
        "shards": [0]
      },
      {
        "account_id": "blazenet.pool.f863973.m0",
        "public_key": "ed25519:DiogP36wBXKFpFeqirrxN8G2Mq9vnakgBvgnHdL9CcN3",
        "stake": "138073840925159254185212483041",
        "shards": [0]
      },
      {
        "account_id": "certusone.pool.f863973.m0",
        "public_key": "ed25519:CKW7f41Kn8YCDPzaGLs1MrPb9h3BjQmHhbei6Ff6nRRF",
        "stake": "177557353126393581856047095474",
        "shards": [0]
      },
      {
        "account_id": "chorus-one.pool.f863973.m0",
        "public_key": "ed25519:6LFwyEEsqhuDxorWfsKcPPs324zLWTaoqk4o6RDXN7Qc",
        "stake": "110967904880664326100649881128",
        "shards": [0]
      },
      {
        "account_id": "cloudpost.pool.f863973.m0",
        "public_key": "ed25519:AVVLmJDG8z6UgmW9fmJGVFTdYxxfnqXH6c7FVQmhE6dp",
        "stake": "137303582563490110045159846741",
        "shards": [0]
      },
      {
        "account_id": "dokia.pool.f863973.m0",
        "public_key": "ed25519:935JMz1vLcJxFApG3TY4MA4RHhvResvoGwCrQoJxHPn9",
        "stake": "221583843027440134728813179120",
        "shards": [0]
      },
      {
        "account_id": "dsrvlabs.pool.f863973.m0",
        "public_key": "ed25519:61ei2efmmLkeDR1CG6JDEC2U3oZCUuC2K1X16Vmxrud9",
        "stake": "162343309156672629963246208215",
        "shards": [0]
      },
      {
        "account_id": "fresh_lockup.pool.f863973.m0",
        "public_key": "ed25519:7CMFLtEohojtxBkmj9Jb6AGgbphb1zvxymHzpzuyCjfG",
        "stake": "194574146707912827852030100603",
        "shards": [0]
      },
      {
        "account_id": "inotel.pool.f863973.m0",
        "public_key": "ed25519:C55jH1MCHYGa3tzUyZZdGrJmmCLP22Aa4v88KYpn2xwZ",
        "stake": "179521497218882663562358374377",
        "shards": [0]
      },
      {
        "account_id": "jazza.pool.f863973.m0",
        "public_key": "ed25519:85cPMNVrqUz8N7oWbbvWbUuamHcJNe49uRbaSzftLCz9",
        "stake": "156567004141558073310769195719",
        "shards": [0]
      },
      {
        "account_id": "joe1.pool.f863973.m0",
        "public_key": "ed25519:G3SxwzmiEZSm3bHnTLtxJvm3NvT1TLQcWuV1iod6i6NJ",
        "stake": "129898367221448376460128575495",
        "shards": [0]
      },
      {
        "account_id": "kronos.pool.f863973.m0",
        "public_key": "ed25519:3i2pertqzF8xqkJ4BrE4t4r67YiYYrUKCktbqvDgjzuQ",
        "stake": "145291600307308103830278523851",
        "shards": [0]
      },
      {
        "account_id": "kytzu.pool.f863973.m0",
        "public_key": "ed25519:61tgPZpy8tqFeAwG4vtf2ZKCRoENiP2A1TJVWEwnbxZU",
        "stake": "114346099616381729581424582943",
        "shards": [0]
      },
      {
        "account_id": "lowfeevalidation.pool.f863973.m0",
        "public_key": "ed25519:EXyjSMGSnk5uGphF3gVV1jCudaAudbW8imoEccYEJg3V",
        "stake": "114272827178534171015566175242",
        "shards": [0]
      },
      {
        "account_id": "lunanova.pool.f863973.m0",
        "public_key": "ed25519:2fZ59qfo9QHNLijoht9cwUb9enSNcnRmXbQn1gKZxvkw",
        "stake": "173796241314359640924313305613",
        "shards": [0]
      },
      {
        "account_id": "moonlet.pool.f863973.m0",
        "public_key": "ed25519:3e1nVCVGNS3yr6CcUvpDAs3BhiWtyM9uTBWkyVR5Xn3K",
        "stake": "141326111231422084384405939935",
        "shards": [0]
      },
      {
        "account_id": "node0",
        "public_key": "ed25519:7PGseFbWxvYVgZ89K1uTJKYoKetWs7BJtbyXDzfbAcqX",
        "stake": "1917087533938315356792420553580",
        "shards": [0]
      },
      {
        "account_id": "node1",
        "public_key": "ed25519:6DSjZ8mvsRZDvFqFxo8tCKePG96omXW7eVYVSySmDk8e",
        "stake": "1915912070849706566898523265362",
        "shards": [0]
      },
      {
        "account_id": "node2",
        "public_key": "ed25519:GkDv7nSMS3xcqA45cpMvFmfV1o4fRF6zYo1JRR6mNqg5",
        "stake": "1849778202731933988446605407109",
        "shards": [0]
      },
      {
        "account_id": "node3",
        "public_key": "ed25519:ydgzeXHJ5Xyt7M1gXLxqLBW1Ejx6scNV5Nx2pxFM8su",
        "stake": "1253713857932062021626652303305",
        "shards": [0]
      },
      {
        "account_id": "nodeasy.pool.f863973.m0",
        "public_key": "ed25519:25Dhg8NBvQhsVTuugav3t1To1X1zKiomDmnh8yN9hHMb",
        "stake": "132333065508677559475570461579",
        "shards": [0]
      },
      {
        "account_id": "northernlights.stakingpool",
        "public_key": "ed25519:CsMecqKCfagnebMB3ha1uRubay5Z4V85req23bNAJSG3",
        "stake": "160494659810582810750858869593",
        "shards": [0]
      },
      {
        "account_id": "orangeclub.pool.f863973.m0",
        "public_key": "ed25519:HezFeSzcwuR5wvkqccgMCMnpf1eQkVCfk52tXZEdKZHz",
        "stake": "144714977470413958038055754809",
        "shards": [0]
      },
      {
        "account_id": "pathrock.pool.f863973.m0",
        "public_key": "ed25519:G138GdQsU7PdFLD6X88NmTLAEDR7agPcq9HLZqGpegkm",
        "stake": "125851226796631921571804668732",
        "shards": [0]
      },
      {
        "account_id": "pool_easy2stake.pool.f863973.m0",
        "public_key": "ed25519:8nzKxvmyeauQRehWkby8GfWNLgqPiF5FCRFSD75M1Rwh",
        "stake": "177807549352374182247265978294",
        "shards": [0]
      },
      {
        "account_id": "sl1sub.pool.f863973.m0",
        "public_key": "ed25519:3URBpNUjNAMzugQH1rdSKMtwFM8AwHaJgZk5Z6YtnfFL",
        "stake": "156546228606913052982706314599",
        "shards": [0]
      },
      {
        "account_id": "staked.pool.6fb1358",
        "public_key": "ed25519:684rMbuVYYgL2CkmYgC1weLh3erd2bwrmtQtJJhWzPwj",
        "stake": "127566960646771620637977634520",
        "shards": [0]
      },
      {
        "account_id": "staked.pool.f863973.m0",
        "public_key": "ed25519:D2afKYVaKQ1LGiWbMAZRfkKLgqimTR74wvtESvjx5Ft2",
        "stake": "141284196855966747583242721111",
        "shards": [0]
      },
      {
        "account_id": "stakin.pool.f863973.m0",
        "public_key": "ed25519:GvddxjaxBCqGGB4kMNWNFtvozU1EEZ2jrnggKZW8LaU4",
        "stake": "122853080560791799567241762038",
        "shards": [0]
      },
      {
        "account_id": "staking-power.pool.f863973.m0",
        "public_key": "ed25519:4s79F6Fdjgb3rHXPLwaXZG4Hq7Za8nogUu3vXEamRBQo",
        "stake": "113878597697173990840757447344",
        "shards": [0]
      },
      {
        "account_id": "syncnode.pool.f863973.m0",
        "public_key": "ed25519:FUAVDkmLhuTbKYv4GWuWv9ogjKzRatLd5ZBMKXRy7WqE",
        "stake": "134103630138795323490241660174",
        "shards": [0]
      },
      {
        "account_id": "thepassivetrust.pool.f863973.m0",
        "public_key": "ed25519:4NccD2DNJpBkDmWeJ2GbqPoivQ93qcKiR4PHALJKCTod",
        "stake": "163554668234785516757420218799",
        "shards": [0]
      },
      {
        "account_id": "top.pool.f863973.m0",
        "public_key": "ed25519:FR5qxAsP8GgXDN96pappLtWMywiqWsPVqT3HLE3YaUx",
        "stake": "165611741467072665024638629174",
        "shards": [0]
      },
      {
        "account_id": "valeraverim.pool.f863973.m0",
        "public_key": "ed25519:3686ABqNUZc1qhLWLHg5xZpBzrWPiUCMNZxcCNmg3e2s",
        "stake": "192723621295992295990275575014",
        "shards": [0]
      },
      {
        "account_id": "zainy.pool.f863973.m0",
        "public_key": "ed25519:37KfhBNYjqpaUVh3ft5kPcFn3xK1eVvtDZJCQQVCGnzQ",
        "stake": "114027175849273464802110072969",
        "shards": [0]
      },
      {
        "account_id": "zpool.pool.f863973.m0",
        "public_key": "ed25519:ETFRFNHfvd6fpj74MGYYQp3diY8WB4bFmWMxjTB2yY4V",
        "stake": "141660662431449802378487016195",
        "shards": [0]
      }
    ],
    "current_fishermen": [
      {
        "account_id": "staked.stakingpool",
        "public_key": "ed25519:5VmCXxWepj22uFoKmrxk6DTiFa3fuTzDcwGxM8uUErpr",
        "stake": "5957256918881889179239884296"
      },
      {
        "account_id": "bisontrails.stakingpool",
        "public_key": "ed25519:ED2v5KtScbk6aNjGcTn1YMDUu3EXfD5HPt1x6RiYBypk",
        "stake": "7679439354334034871130713908"
      },
      {
        "account_id": "cryptium.stakingpool",
        "public_key": "ed25519:2usUkjmKWxQw7QUeFfELHCEqS2UxjwsRqnCkA5oQ6A2B",
        "stake": "6484546971716985483357166277"
      },
      {
        "account_id": "buildlinks3.pool.f863973.m0",
        "public_key": "ed25519:Cfy8xjSsvVquSqo7W4A2bRX1vkLPycLgyCvFNs3Rz6bb",
        "stake": "81221864655530313350540629757"
      },
      {
        "account_id": "mmm.pool.f863973.m0",
        "public_key": "ed25519:3jEqDDKaJEg1r8UGu2x2dC55BXE7i26yNFQzvfJkkHkf",
        "stake": "80030001196381772535600000000"
      }
    ],
    "next_fishermen": [
      {
        "account_id": "staked.stakingpool",
        "public_key": "ed25519:5VmCXxWepj22uFoKmrxk6DTiFa3fuTzDcwGxM8uUErpr",
        "stake": "5957256918881889179239884296"
      },
      {
        "account_id": "bisontrails.stakingpool",
        "public_key": "ed25519:ED2v5KtScbk6aNjGcTn1YMDUu3EXfD5HPt1x6RiYBypk",
        "stake": "7679439354334034871130713908"
      },
      {
        "account_id": "cryptium.stakingpool",
        "public_key": "ed25519:2usUkjmKWxQw7QUeFfELHCEqS2UxjwsRqnCkA5oQ6A2B",
        "stake": "6484546971716985483357166277"
      },
      {
        "account_id": "buildlinks3.pool.f863973.m0",
        "public_key": "ed25519:Cfy8xjSsvVquSqo7W4A2bRX1vkLPycLgyCvFNs3Rz6bb",
        "stake": "81221864655530313350540629757"
      },
      {
        "account_id": "mmm.pool.f863973.m0",
        "public_key": "ed25519:3jEqDDKaJEg1r8UGu2x2dC55BXE7i26yNFQzvfJkkHkf",
        "stake": "80030001196381772535600000000"
      }
    ],
    "current_proposals": [
      {
        "account_id": "kytzu.pool.f863973.m0",
        "public_key": "ed25519:61tgPZpy8tqFeAwG4vtf2ZKCRoENiP2A1TJVWEwnbxZU",
        "stake": "114346100195275968419224582943"
      },
      {
        "account_id": "nodeasy.pool.f863973.m0",
        "public_key": "ed25519:25Dhg8NBvQhsVTuugav3t1To1X1zKiomDmnh8yN9hHMb",
        "stake": "132333066144809013154670461579"
      },
      {
        "account_id": "thepassivetrust.pool.f863973.m0",
        "public_key": "ed25519:4NccD2DNJpBkDmWeJ2GbqPoivQ93qcKiR4PHALJKCTod",
        "stake": "163554672455685458970920218837"
      }
    ],
    "prev_epoch_kickout": [],
    "epoch_start_height": 17754191,
    "epoch_height": 321
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by validators method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_EPOCH
      200
      An epoch for the provided block can't be found in a database
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
          Check that the requested block is the last block of some epoch
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Maintenance Windows

The RPC API enables you to query future maintenance windows for a specific validator in current epoch

Maintenance windows

The maintenance windows for a specific validator are future block height ranges in current epoch, in which the validator does not need produce block or chunk
If the provided account is not a validator, then it will return the range from now to the end of the epoch.


method: EXPERIMENTAL_maintenance_windows
params:

account_id


example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_maintenance_windows",
  "params": {
    "account_id": "node0"
  }
}
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_maintenance_windows 
  params:='{
    "account_id": "node0"
  }'
```




Example response:

The result will be a list of future maintenance windows in current epoch.
For example a window `[1028, 1031]` includes 1028, 1029 and 1030.

```json
{
    "jsonrpc": "2.0",
    "result": [
        [
            1028,
            1031
        ],
        [
            1034,
            1038
        ],
    ],
    "id": "dontcare"
}
```



What Could Go Wrong??
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}
Here is the exhaustive list of the error variants that can be returned by maintenance_windows method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### NEAR RPC API

The RPC API allows you to communicate directly with the NEAR network. For example,
tools such as near-api-js are just abstractions making RPC calls.

RPC Providers
There are multiple RPC providers which you can choose from. These providers will work as intermediaries to help you interact with the NEAR network.

NEAR RPC - Quick Links



API
Description




Access Keys
Retrieve information about an account's access keys.


Accounts / Contracts
View details about accounts and contracts as well as perform contract calls.


Block / Chunk
Query the network and get details about specific blocks or chunks.


Gas
Get gas price for a specific block or hash.


Protocol
Retrieve current genesis and protocol configuration.


Network
Return status information for nodes and validators.


Transactions
Send transactions and query their status.



tipou can access the JSON RPC 2.0 endpoints using [Postman](/api/rpc/setup#postman-setup),
[JavaScript](/api/rpc/setup#javascript-setup), and [HTTPie](/api/rpc/setup#httpie-setup).

### Gas

The RPC API enables you to query the gas price for a specific block or hash.

Gas Price

Returns gas price for a specific block_height or block_hash.

Using [null] will return the most recent block's gas price.



method: gas_price
params: [block_height], ["block_hash"], or [null]

[block_height]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "gas_price",
  "params": [17824600]
}
```




```js
const response = await near.connection.provider.gasPrice(17824600);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=gas_price params:='[17824600]' id=dontcare
```



["block_hash"]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "gas_price",
  "params": ["AXa8CHDQSA8RdFCt12rtpFraVq4fDUgJbLPxwbaZcZrj"]
}
```




```js
const response = await near.connection.provider.gasPrice(
  "AXa8CHDQSA8RdFCt12rtpFraVq4fDUgJbLPxwbaZcZrj"
);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=gas_price params:='["AXa8CHDQSA8RdFCt12rtpFraVq4fDUgJbLPxwbaZcZrj"]' id=dontcare
```



[null]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "gas_price",
  "params": [null]
}
```




```js
const response = await near.connection.provider.gasPrice(null);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=gas_price params:='[null]' id=dontcare
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "gas_price": "100000000"
  },
  "id": "dontcare"
}
```



What could go wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by gas_price method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Accounts / Contracts

The RPC API enables you to view details about accounts and contracts as well as perform contract calls.

View account

Returns basic account information.


method: query
params:

request_type: view_account
finality OR block_id
account_id: "example.testnet"


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "view_account",
    "finality": "final",
    "account_id": "nearkat.testnet"
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "view_account",
  finality: "final",
  account_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_account",
    "finality": "final",
    "account_id": "nearkat.testnet"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "amount": "399992611103597728750000000",
    "locked": "0",
    "code_hash": "11111111111111111111111111111111",
    "storage_usage": 642,
    "storage_paid_at": 0,
    "block_height": 17795474,
    "block_hash": "9MjpcnwW3TSdzGweNfPbkx8M74q1XzUcT1PAN8G5bNDz"
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by view_account request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to find the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View account changes

Returns account changes from transactions in a given account.


method: EXPERIMENTAL_changes
params:

changes_type: account_changes
account_ids: ["example.testnet"]
finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes",
  "params": {
    "changes_type": "account_changes",
    "account_ids": ["your_account.testnet"],
    "block_id": 19703467
  }
}
```




```js
const response = await near.connection.provider.experimental_changes({
  changes_type: "account_changes",
  account_ids: ["nearkat.testnet"],
  block_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes 
  params:='{
    "changes_type": "account_changes",
    "account_ids": ["your_account.testnet"],
    "block_id": 19703467
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "6xsfPSG89s6fCMShxxxQTP6D4ZHM9xkGCgubayTDRzAP",
    "changes": [
      {
        "cause": {
          "type": "transaction_processing",
          "tx_hash": "HLvxLKFM7gohFSqXPp5SpyydNEVpAno352qJJbnddsz3"
        },
        "type": "account_update",
        "change": {
          "account_id": "your_account.testnet",
          "amount": "499999959035075000000000000",
          "locked": "0",
          "code_hash": "11111111111111111111111111111111",
          "storage_usage": 182,
          "storage_paid_at": 0
        }
      },
      {
        "cause": {
          "type": "receipt_processing",
          "receipt_hash": "CPenN1dp4DNKnb9LiL5hkPmu1WiKLMuM7msDjEZwDmwa"
        },
        "type": "account_update",
        "change": {
          "account_id": "your_account.testnet",
          "amount": "499999959035075000000000000",
          "locked": "0",
          "code_hash": "11111111111111111111111111111111",
          "storage_usage": 264,
          "storage_paid_at": 0
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View contract code

Returns the contract code (Wasm binary) deployed to the account. Please note that the returned code will be encoded in base64.


method: query
params:

request_type: view_code
finality OR block_id
account_id: "guest-book.testnet",


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "view_code",
    "finality": "final",
    "account_id": "guest-book.testnet"
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "view_code",
  finality: "final",
  account_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_code",
    "finality": "final",
    "account_id": "guest-book.testnet"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "code_base64": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=",
    "hash": "7KoFshMQkdyo5iTx8P2LbLu9jQpxRn24d27FrKShNVXs",
    "block_height": 17814234,
    "block_hash": "GT1D8nweVQU1zyCUv399x8vDv2ogVq71w17MyR66hXBB"
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by view_code request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      NO_CONTRACT_CODE
      200
      The account does not have any contract deployed on it
      
        
          Use different account
          Specify a different block or retry if you request the latest state
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to find the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View contract state

Returns the state (key value pairs) of a contract based on the key prefix (base64 encoded). Pass an empty string for prefix_base64 if you would like to return the entire state. Please note that the returned state will be base64 encoded as well.


method: query
params:

request_type: view_state
finality OR block_id
account_id: "guest-book.testnet",
prefix_base64: ""


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "view_state",
    "finality": "final",
    "account_id": "guest-book.testnet",
    "prefix_base64": ""
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "view_state",
  finality: "final",
  account_  prefix_base64: "",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_state",
    "finality": "final",
    "account_id": "guest-book.testnet",
    "prefix_base64": ""
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "values": [
      {
        "key": "bTo6MA==",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJqb3NoZm9yZC50ZXN0bmV0IiwidGV4dCI6ImhlbGxvIn0=",
        "proof": []
      },
      {
        "key": "bTo6MQ==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiY2hhZG9oIiwidGV4dCI6ImhlbGxvIGVyeWJvZHkifQ==",
        "proof": []
      },
      {
        "key": "bTo6MTA=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoic2F0b3NoaWYudGVzdG5ldCIsInRleHQiOiJIaWxsbyEifQ==",
        "proof": []
      },
      {
        "key": "bTo6MTE=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidmFsZW50aW5lc29rb2wudGVzdG5ldCIsInRleHQiOiJIaSEifQ==",
        "proof": []
      },
      {
        "key": "bTo6MTI=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJobngudGVzdG5ldCIsInRleHQiOiJoZWxsbyJ9",
        "proof": []
      },
      {
        "key": "bTo6MTM=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJobngudGVzdG5ldCIsInRleHQiOiJzZCJ9",
        "proof": []
      },
      {
        "key": "bTo6MTQ=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiamdoZy50ZXN0bmV0IiwidGV4dCI6IktoZyJ9",
        "proof": []
      },
      {
        "key": "bTo6MTU=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiYWNjb3VudC50ZXN0bmV0IiwidGV4dCI6IldoZW4gSUNPPyJ9",
        "proof": []
      },
      {
        "key": "bTo6MTY=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiYWNjb3VudC50ZXN0bmV0IiwidGV4dCI6IlRlc3QgMiJ9",
        "proof": []
      },
      {
        "key": "bTo6MTc=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidGVzdC1kcm9wLTEwLnRlc3RuZXQiLCJ0ZXh0IjoiRnJlZSBtZXNzYWdlcyBhcmUgdGhlIGJlc3QifQ==",
        "proof": []
      },
      {
        "key": "bTo6MTg=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidGVzdC1kcm9wLTEwLnRlc3RuZXQiLCJ0ZXh0IjoiV2hlbiBJQ08/In0=",
        "proof": []
      },
      {
        "key": "bTo6MTk=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidGVzdC1kcm9wLTEwLnRlc3RuZXQiLCJ0ZXh0IjoiV2hlbiBJQ08/In0=",
        "proof": []
      },
      {
        "key": "bTo6Mg==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoibnVsbCIsInRleHQiOiJ1bmRlZmluZWQifQ==",
        "proof": []
      },
      {
        "key": "bTo6MjA=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidGVzdC04NDEudGVzdG5ldCIsInRleHQiOiJXaGVuIElDTz8ifQ==",
        "proof": []
      },
      {
        "key": "bTo6MjE=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidGVzdC04NDEudGVzdG5ldCIsInRleHQiOiJoZXkgaGV5IGhleSJ9",
        "proof": []
      },
      {
        "key": "bTo6MjI=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiam9zaGZvcmQudGVzdG5ldCIsInRleHQiOiJoaSJ9",
        "proof": []
      },
      {
        "key": "bTo6MjM=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiam9zaGZvcmQudGVzdG5ldCIsInRleHQiOiJoaSB4MiJ9",
        "proof": []
      },
      {
        "key": "bTo6MjQ=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoibWFzdGVydGh5c2VsZi50ZXN0bmV0IiwidGV4dCI6ImhhbmRzaGFrZS5oYWNrbWVkb21haW4vICJ9",
        "proof": []
      },
      {
        "key": "bTo6MjU=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJtYXN0ZXJ0aHlzZWxmLnRlc3RuZXQiLCJ0ZXh0IjoiSGVsbG8gQ29zbW9zLCBob21lLmNvc21hdHJpeGNvbm5lY3Rpb25zLyJ9",
        "proof": []
      },
      {
        "key": "bTo6MjY=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJtYXN0ZXJ0aHlzZWxmLnRlc3RuZXQiLCJ0ZXh0IjoiYnVpbGQsIGJ1aWxkLCBidWlsZCBpIGNhbWUgdG8gYnVpbGQgYSBicmlkZ2UgaW4gUEVBQ0UsIHNvIGNvbWUgbGV0cyBidWlsZC4uLnNvbmcgYnkgXCJOYWhrbyBCZWFyXCIgIn0=",
        "proof": []
      },
      {
        "key": "bTo6Mjc=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJtYXN0ZXJ0aHlzZWxmLnRlc3RuZXQiLCJ0ZXh0IjoiYnVpbGQgYSBicmlkZ2UgKGh0dHBzOi8vd3d3Lmdvb2dsZS5jb20vdXJsP3NhPXQmcmN0PWomcT0mZXNyYz1zJnNvdXJjZT13ZWImY2Q9JmNhZD1yamEmdWFjdD04JnZlZD0yYWhVS0V3ajA0ZGlnMTlqckFoV05tbGtLSGR5X0FnUVEzeXd3QUhvRUNBVVFBZyZ1cmw9aHR0cHMlM0ElMkYlMkZ3d3cueW91dHViZS5jb20lMkZ3YXRjaCUzRnYlM0Rlb1RYNWZmOVplMCZ1c2c9QU92VmF3MFoxZzFIMkZzeF85d3FJSmg5RTk2UCkifQ==",
        "proof": []
      },
      {
        "key": "bTo6Mjg=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJtYXN0ZXJ0aHlzZWxmLnRlc3RuZXQiLCJ0ZXh0IjoiaHR0cDovL3RyaXBweS7wn42EbWFnaWMvIn0=",
        "proof": []
      },
      {
        "key": "bTo6Mjk=",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJtYXN0ZXJ0aHlzZWxmLnRlc3RuZXQiLCJ0ZXh0IjoiaHR0cDovL3VuaXRlLnJhaW5ib3d0cmliZXMvIn0=",
        "proof": []
      },
      {
        "key": "bTo6Mw==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiam9zaGZvcmQudGVzdG5ldCIsInRleHQiOiJobW1tbW1tIn0=",
        "proof": []
      },
      {
        "key": "bTo6MzA=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiZXhlbXBsYXJ5LnRlc3RuZXQiLCJ0ZXh0IjoiaGVsbG8ifQ==",
        "proof": []
      },
      {
        "key": "bTo6MzE=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiYWRpMjMudGVzdG5ldCIsInRleHQiOiJobW0ifQ==",
        "proof": []
      },
      {
        "key": "bTo6MzI=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiYWRpMjMudGVzdG5ldCIsInRleHQiOiJ3aGF0In0=",
        "proof": []
      },
      {
        "key": "bTo6MzM=",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoidmxhZGJhc2gudGVzdG5ldCIsInRleHQiOiJIaSJ9",
        "proof": []
      },
      {
        "key": "bTo6NA==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoibnVsbCIsInRleHQiOiIgIn0=",
        "proof": []
      },
      {
        "key": "bTo6NQ==",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJ0ZXN0YWNjb3VudDEudGVzdG5ldCIsInRleHQiOiJ0ZXN0In0=",
        "proof": []
      },
      {
        "key": "bTo6Ng==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiZXVnZW5ldGhlZHJlYW0iLCJ0ZXh0IjoibnVsbCJ9",
        "proof": []
      },
      {
        "key": "bTo6Nw==",
        "value": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiZGVtby50ZXN0bmV0IiwidGV4dCI6Ikkgb25seSB3cml0ZSBmcmVlIG1lc3NhZ2VzLiJ9",
        "proof": []
      },
      {
        "key": "bTo6OA==",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJqb3NoZm9yZC50ZXN0bmV0IiwidGV4dCI6IkkgcHJlZmVyIHByZW1pdW0gbWVzc2FnZXMifQ==",
        "proof": []
      },
      {
        "key": "bTo6OQ==",
        "value": "eyJwcmVtaXVtIjp0cnVlLCJzZW5kZXIiOiJuZXdsZWRnZXIzLnRlc3RuZXQiLCJ0ZXh0IjoiTGVkZ2VyIn0=",
        "proof": []
      },
      {
        "key": "bTpsZW4=",
        "value": "MzQ=",
        "proof": []
      }
    ],
    "proof": [],
    "block_height": 17814234,
    "block_hash": "GT1D8nweVQU1zyCUv399x8vDv2ogVq71w17MyR66hXBB"
  },
  "id": "dontcare"
}
```


**Note**: Currently, the response includes a `proof` field directly in the
`result`, and a `proof` fields on each element of the `values` list.  In
the future, the `result.proof` will be included only if the result is **not empty**,
and the `proof` field will be removed from all `values`. When parsing the result, you
should accept objects with or without these fields set.



Heads up
There is a limitation on default RPC nodes. You won't be able to get the contract state if it is too big. The default limit of for contract state is 50kb of state size. You're able to change the limits if you run your own RPC node with adjusted trie_viewer_state_size_limit value in config.json

What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by view_state request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      NO_CONTRACT_CODE
      200
      The account does not have any contract deployed on it
      
        
          Query and account with contract deployed
          Specify a different block or retry if you request the latest state
        
      
    
    
      TOO_LARGE_CONTRACT_STATE
      200
      The requested contract state is too large to be returned from this node (the default limit is 50kb of state size)
      
        
          Send the request to a node with larger limits in order to view the requested state
          Spin up your own node where you can increase the limits to view state
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to find the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View contract state changes

Returns the state change details of a contract based on the key prefix (encoded to base64). Pass an empty string for this param if you would like to return all state changes.


method: EXPERIMENTAL_changes
params:

changes_type: data_changes
account_ids: ["example.testnet"],
key_prefix_base64: "base64 encoded key value",
finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes",
  "params": {
    "changes_type": "data_changes",
    "account_ids": ["guest-book.testnet"],
    "key_prefix_base64": "",
    "block_id": 19450732
  }
}
```




```js
const response = await near.connection.provider.experimental_changes({
  changes_type: "data_changes",
  account_ids: ["guest-book.testnet"],
  key_prefix_base64: "",
  block_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes 
  params:='{
    "changes_type": "data_changes",
    "account_ids": ["guest-book.testnet"],
    "key_prefix_base64": "",
    "block_id": 19450732
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "6U8Yd4JFZwJUNfqkD4KaKgTKmpNSmVRTSggpjmsRWdKY",
    "changes": [
      {
        "cause": {
          "type": "receipt_processing",
          "receipt_hash": "9ewznXgs2t7vRCssxW4thgaiwggnMagKybZ7ryLNTT2z"
        },
        "type": "data_update",
        "change": {
          "account_id": "guest-book.testnet",
          "key_base64": "bTo6Mzk=",
          "value_base64": "eyJwcmVtaXVtIjpmYWxzZSwic2VuZGVyIjoiZmhyLnRlc3RuZXQiLCJ0ZXh0IjoiSGkifQ=="
        }
      },
      {
        "cause": {
          "type": "receipt_processing",
          "receipt_hash": "9ewznXgs2t7vRCssxW4thgaiwggnMagKybZ7ryLNTT2z"
        },
        "type": "data_update",
        "change": {
          "account_id": "guest-book.testnet",
          "key_base64": "bTpsZW4=",
          "value_base64": "NDA="
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View contract code changes

Returns code changes made when deploying a contract. Change is returned is a base64 encoded WASM file.


method: EXPERIMENTAL_changes
params:

changes_type: contract_code_changes
account_ids: ["example.testnet"],
finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes",
  "params": {
    "changes_type": "contract_code_changes",
    "account_ids": ["dev-1602714453032-7566969"],
    "block_id": 20046655
  }
}
```




```js
const response = await near.connection.provider.experimental_changes({
  changes_type: "contract_code_changes",
  account_ids: ["dev-1602714453032-7566969"],
  block_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes 
  params:='{
    "changes_type": "contract_code_changes",
    "account_ids": ["dev-1602714453032-7566969"],
    "block_id": 20046655
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "3yLNV5zdpzRJ8HP5xTXcF7jdFxuHnmKNUwWcok4616WZ",
    "changes": [
      {
        "cause": {
          "type": "receipt_processing",
          "receipt_hash": "CEm3NNaNdu9cijh9NvZMM1srbtEYSsBVwGbZxFQYKt5B"
        },
        "type": "contract_code_update",
        "change": {
          "account_id": "dev-1602714453032-7566969",
          "code_base64": "AGFzbQEAAAABpAM3YAF/AGAAAX9gAn9+AGADf35+AGAEf35+fgF+YAZ/fn5+fn4BfmADf35+AX5gAn9+AX5gAn9/AX9gAn9/AGADf39/AX9gAX8BfmACfn4AYAF+AX5gAX4AYAABfmADfn5+AGAAAGAIfn5+fn5+fn4BfmAJfn5+fn5+fn5+AX5gAn5+AX5gA35+fgF+YAd+fn5+fn5+AGAEfn5+fgBgCX5+fn5+fn5+fgBgBX5+fn5+AX5gA39/fwBgAX8Bf2ACf3wAYAR/f39+AGAFf39/fn8AYAV/f39/fwBgBH9/f38AYAN/f38BfmADf39+AGACf38BfmAFf39/f38Bf2AEf39/fwF/YAZ/f39/f38AYAV/f35/fwBgBH9+f38Bf2ACf34Bf2AHf35+f39+fwBgBX9/f39+AGAEf35+fgBgCX9+fn5+fn5+fgF+YAp/fn5+fn5+fn5+AX5gCH9+fn5+fn5+AGAFf35+fn4AYAp/fn5+fn5+fn5+AGAHf39/f39/fwBgBH98f38Bf2AGf39/f39..."
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Call a contract function

Allows you to call a contract method as a view function.


method: query
params:

request_type: call_function
finality OR block_id
account_id: "example.testnet"
method_name: name_of_a_example.testnet_method (example view methods
args_base64: method_arguments_base_64_encoded


Example (get_num):



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "call_function",
    "finality": "final",
    "account_id": "dev-1588039999690",
    "method_name": "get_num",
    "args_base64": "e30="
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "call_function",
  finality: "final",
  account_  method_name: "get_num",
  args_base64: "e30=",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "call_function",
    "finality": "final",
    "account_id": "dev-1588039999690",
    "method_name": "get_num",
    "args_base64": "e30="
  }'
```



Example (get_account_staked_balance):
The args_base64 in this example is decoded as {"account_id":"dev-1588039999690"}.  The account_id would likely be the validator and not the same account for this particular view function.



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "call_function",
    "finality": "final",
    "account_id": "dev-1588039999690",
    "method_name": "get_account_staked_balance",
    "args_base64": "eyJhY2NvdW50X2lkIjoiZGV2LTE1ODgwMzk5OTk2OTAifQ=="
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "call_function",
  finality: "final",
  account_  method_name: "get_account_staked_balance",
  args_base64: "eyJhY2NvdW50X2lkIjoiZGV2LTE1ODgwMzk5OTk2OTAifQ==",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "call_function",
    "finality": "final",
    "account_id": "dev-1588039999690",
    "method_name": "get_account_staked_balance",
    "args_base64": "eyJhY2NvdW50X2lkIjoiZGV2LTE1ODgwMzk5OTk2OTAifQ=="
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "result": [48],
    "logs": [],
    "block_height": 17817336,
    "block_hash": "4qkA4sUUG8opjH5Q9bL5mWJTnfR4ech879Db1BZXbx6P"
  },
  "id": "dontcare"
}
```

**Note**: `[48]` is an array of bytes, to be specific it is an ASCII code of `0`.`near-sdk-rs` and `near-sdk-js` return JSON-serialized results.



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by call_function request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      NO_CONTRACT_CODE
      200
      The requested contract_code has not been found while viewing
      
        
          Check the public_key
          Specify a different block or retry if you request the latest state
        
      
    
    
      CONTRACT_EXECUTION_ERROR
      200
      The execution of the view function call failed (crashed, run out of the default 200 TGas limit, etc)
      
        
          Check error.cause.info for more details
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to find the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Block / Chunk

The RPC API enables you to query the network and get details about specific blocks or chunks.

Block details

Queries network and returns block for given height or hash. You can also use finality param to return latest block details.

Note: You may choose to search by a specific block or finality, you can not choose both.

method: block
params:

finality OR block_id


finality example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "block",
  "params": {
    "finality": "final"
  }
}
```




```js
const response = await near.connection.provider.block({
  finality: "final",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=block 
  params:='{
    "finality": "final"
  }'
```



[block_id]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "block",
  "params": {
    "block_id": 17821130
  }
}
```




```js
const response = await near.connection.provider.block({blockId: 17821130});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=block 
  params:='{
    "block_id": 17821130
  }'
```



[block_hash]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "block",
  "params": {
    "block_id": "7nsuuitwS7xcdGnD9JgrE22cRB2vf2VS4yh1N9S71F4d"
  }
}
```




```js
const response = await near.connection.provider.block(
  {blockId: "7nsuuitwS7xcdGnD9JgrE22cRB2vf2VS4yh1N9S71F4d"}
);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=block 
  params:='{
    "block_id": "7nsuuitwS7xcdGnD9JgrE22cRB2vf2VS4yh1N9S71F4d"
  }'
```




Example response:


```json
{
  "jsonrpc": "2.0",
  "result": {
    "author": "bitcat.pool.f863973.m0",
    "header": {
      "height": 17821130,
      "epoch_id": "7Wr3GFJkYeCxjVGz3gDaxvAMUzXuzG8MjFXTFoAXB6ZZ",
      "next_epoch_id": "A5AdnxEn7mfHieQ5fRxx9AagCkHNJz6wr61ppEXiWvvh",
      "hash": "CLo31YCUhzz8ZPtS5vXLFskyZgHV5qWgXinBQHgu9Pyd",
      "prev_hash": "2yUTTubrv1gJhTUVnHXh66JG3qxStBqySoN6wzRzgdVD",
      "prev_state_root": "5rSz37fySS8XkVgEy3FAZwUncX4X1thcSpuvCgA6xmec",
      "chunk_receipts_root": "9ETNjrt6MkwTgSVMMbpukfxRshSD1avBUUa4R4NuqwHv",
      "chunk_headers_root": "HMpEoBhPvThWZvppLwrXQSSfumVdaDW7WfZoCAPtjPfo",
      "chunk_tx_root": "7tkzFg8RHBmMw1ncRJZCCZAizgq4rwCftTKYLce8RU8t",
      "outcome_root": "7tkzFg8RHBmMw1ncRJZCCZAizgq4rwCftTKYLce8RU8t",
      "chunks_included": 1,
      "challenges_root": "11111111111111111111111111111111",
      "timestamp": 1601280114229875635,
      "timestamp_nanosec": "1601280114229875635",
      "random_value": "ACdUSF3nehbMTwT7qjUB6Mm4Ynck5TVAWbNH3DR1cjQ7",
      "validator_proposals": [],
      "chunk_mask": [true],
      "gas_price": "100000000",
      "rent_paid": "0",
      "validator_reward": "0",
      "total_supply": "1042339182040791154864822502764857",
      "challenges_result": [],
      "last_final_block": "AaxTqjYND5WAKbV2UZaFed6DH1DShN9fEemtnpTsv3eR",
      "last_ds_final_block": "2yUTTubrv1gJhTUVnHXh66JG3qxStBqySoN6wzRzgdVD",
      "next_bp_hash": "3ZNEoFYh2CQeJ9dc1pLBeUd1HWG8657j2c1v72ENE45Q",
      "block_merkle_root": "H3912Nkw6rtamfjsjmafe2uV2p1XmUKDou5ywgxb1gJr",
      "approvals": [
        "ed25519:4hNtc9vLhn2PQhktWtLKJV9g8SBfpm6NBT1w4syNFqoKE7ZMts2WwKA9x1ZUSBGVKYCuDGEqogLvwCF25G7e1UR3",
        "ed25519:2UNmbTqysMMevVPqJEKSq57hkcxVFcAMdGq7CFhpW65yBKFxYwpoziiWsAtARusLn9Sy1eXM7DkGTXwAqFiSooS6",
        "ed25519:4sumGoW9dnQCsJRpzkd4FQ5NSJypGQRCppWp7eQ9tpsEcJXjHZN8GVTCyeEk19WmbbMEJ5KBNypryyHzaH2gBxd4",
        "ed25519:3fP2dri6GjYkmHgEqQWWP9GcoQEgakbaUtfr3391tXtYBgxmiJUEymRe54m7D8bQrSJ3LhKD8gTFT7qqdemRnizR",
        "ed25519:3mwdqSWNm6RiuZAoZhD6pqsirC2cL48nEZAGoKixpqbrsBpAzqV3W2paH4KtQQ4JPLvk5pnzojaint2kNBCcUyq1",
        "ed25519:D4hMnxqLyQW4Wo29MRNMej887GH46yJXDKNN4es8UDSi9shJ9Y4FcGqkxdV4AZhn1yUjwN5LwfgAgY6fyczk5L3",
        null,
        "ed25519:4WCVm4dn88VJxTkUgcvdS7vs34diBqtQY4XWMRctSN1NpbgdkwwVyxg7d2SbGC22SuED7w4nrToMhcpJXrkhkDmF",
        "ed25519:JqtC7TFP7U14s7YhRKQEqwbc2RUxoctq75mrBdX91f7DuCWsPpe6ZTTnfHPmuJPjTzFHVZTsaQJWzwfSrrgNpnc",
        "ed25519:ngGUpWc2SyHmMCkWGTNNNfvZAJQ5z7P92JCmDqB7JW3j8fNH6LobvFFXb2zVdssibJKgnjwBj8CRe6qiZtuYQZM",
        "ed25519:5kzW6RbjukyJZiw9NTzTPPsQdoqN6EecafjVFEoWmTxQ4uSv1uSXhQYcHK2eq4m84oMmPABQDz2mm73Qx8mDdCQX",
        "ed25519:5wHnuuxwJJiZ4bXNq5cESnr4YovFU2yaUcuHRDUw3DnLoxkqc15CsegoyUSQKEwtCZ4yETv8Z9QcD6Wr9zHV4AUk",
        "ed25519:3F9XzWBxto31e8RAcBShAJBzJPgSJQsWbPXR38AfQnJn6AiveGz3JjebQm9Ye63BrnNA57QrPshwknxpzSrcNEZW",
        "ed25519:2g5s4SKsHt9PMdekkDqVtwwtz14v4edhqdBX1MYA8tB6nDpj3vDCDCTy9pEU8dX31PoQe5ygnf88aTZukMBMK1Yt",
        "ed25519:3Xz4jqhdyS3qs6xTmWdgjwt5gJraU5czMA89hPhmvbAN4aA7SUKL1HkevpmutRQqqxe7c7uCFeGiDHvDcxhhmD8W",
        null,
        "ed25519:55xs3vwPEys39egf9Z8SNyn1JsHPRMgj9HCX1GE7GJsVTcAuutQUCo91E12ZdXkuToYRXb9KzoT8n9XQRCNuLpwY",
        null,
        "ed25519:28JrFw7KnhnQPN89qZnnw17KDBjS6CDN7zB1hTg7KGg8qQPoCzakz9DNnaSnx39ji7e2fQSpZt4cNJaD7K7Yu7yo",
        "ed25519:41hAr5qhtvUYpdD2NK9qqTVnpG325ZoAiwrcmk1MJH7fdpxm7oSKXvXZqh7bTmPhv61hH2RpHnhcGuN4QqLzK2zt",
        "ed25519:4QacMsQ5FJgvecAYDFq8QBh19BBjh4qU8oeD5bV7p6Zhhu3e6r2iSHTvDBU2Q62RZAaWQQkkEwDUC9rsXdkGVhAt",
        "ed25519:27smtCZ3WobEvBuD5DggY6kkGxjB9qRVY6kPixgwqvBT1eKbRVoV8cLj1z51S8RTcp7YzAr1vhHJUHgksatR9Udz",
        "ed25519:4wspCWoAbhYxb3th2eX6ZXvKep1Fsco7mFP5zBodXBR8Wr344ANXSUCri3gUgNCCSoQ2CKSdqDEsvE6Y2jQ9hmbB",
        "ed25519:46XpYf9ZB9gjDfdnJLHqqhYJpQCuvCgB9tzKWS88GANMCb2j9BM3KXyjaEzynSsaPK8VrKFXQuTsTzgQSeo9cWGW",
        null,
        "ed25519:Y5ehsrhEpTRGjG6fHJHsEXj2NYPGMmKguiJHXP7TqsCWHBvNzaJbieR7UDp78hJ1ib7C18J5MB2kCzTXBCF9c3b",
        "ed25519:3P9363Dc8Kqvgjt3TsNRncUrncCHid7aSRnuySjF4JYmQbApkAxomyMu8xm9Rgo3mj9rqXb16PM7Xjn7hKP6TyVr",
        null,
        null,
        "ed25519:65ATjGsigZ3vMp7sGcp1c4ptxoqhHPkBeAaZ5GWJguVDLyrRLPJrtXhLGjH9DpXd7CZswjyMYq5aRtorLnmmJ7GW",
        null,
        "ed25519:5SvqSViXbtsLoFMdtCufyyDgZnrEK7LheFi38X5M2ic17gfV5cz37r85RyixjUv98MbAmgVdmkxVFDGfSbeoHW7X",
        null,
        null,
        "ed25519:2n3fQiBEiDKkB84biXWyQmvnupKX7B8faugY37jVi8hVXuWLggJmaEjqub511RCYwFnwW1RBxYpuJQ455KaniCd4",
        "ed25519:2K9xKFLJ2fW74tddXtghFGFurKWomAqaJmkKYVZKHQT6zHe5wNSYT3vzMotLQcez5JD1Ta57N9zQ4H1RysB2s5DZ",
        null,
        null,
        "ed25519:3qeCRtcLAqLtQ2YSQLcHDa26ykKX1BvAhP9jshLLYapxSEGGgZJY8sU72p9E78AkXwHP3X2Eq74jvts7gTRzNgMg",
        null,
        "ed25519:2czSQCF8wBDomEeSdDRH4gFoyJrp2ppZqR6JDaDGoYpaFkpWxZf2oGDkKfQLZMbfvU6LXkQjJssVHcLCJRMzG8co"
      ],
      "signature": "ed25519:58sdWd6kxzhQdCGvHzxqvdtDLJzqspe74f3gytnqdxDLHf4eesXi7B3nYq2YaosCHZJYmcR4HPHKSoFm3WE4MbxT",
      "latest_protocol_version": 35
    },
    "chunks": [
      {
        "chunk_hash": "EBM2qg5cGr47EjMPtH88uvmXHDHqmWPzKaQadbWhdw22",
        "prev_block_hash": "2yUTTubrv1gJhTUVnHXh66JG3qxStBqySoN6wzRzgdVD",
        "outcome_root": "11111111111111111111111111111111",
        "prev_state_root": "HqWDq3f5HJuWnsTfwZS6jdAUqDjGFSTvjhb846vV27dx",
        "encoded_merkle_root": "9zYue7drR1rhfzEEoc4WUXzaYRnRNihvRoGt1BgK7Lkk",
        "encoded_length": 8,
        "height_created": 17821130,
        "height_included": 17821130,
        "shard_id": 0,
        "gas_used": 0,
        "gas_limit": 1000000000000000,
        "rent_paid": "0",
        "validator_reward": "0",
        "balance_burnt": "0",
        "outgoing_receipts_root": "H4Rd6SGeEBTbxkitsCdzfu9xL9HtZ2eHoPCQXUeZ6bW4",
        "tx_root": "11111111111111111111111111111111",
        "validator_proposals": [],
        "signature": "ed25519:4iPgpYAcPztAvnRHjfpegN37Rd8dTJKCjSd1gKAPLDaLcHUySJHjexMSSfC5iJVy28vqF9VB4psz13x2nt92cbR7"
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong??
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by block method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Changes in Block

Returns changes in block for given block height or hash. You can also use finality param to return latest block details.

Note: You may choose to search by a specific block or finality, you can not choose both.

method: EXPERIMENTAL_changes_in_block
params:

finality OR block_id


finality



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes_in_block",
  "params": {
    "finality": "final"
  }
}
```




```js
const response = await near.connection.provider.experimental_changes_in_block({
  finality: "final",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes_in_block 
  params:='{
    "finality": "final"
  }'
```



[block_id]



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes_in_block",
  "params": {
    "block_id": 17821135
  }
}
```




```js
const response = await near.connection.provider.experimental_changes_in_block(
  17821135
);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes_in_block 
  params:='{
    "block_id": 17821135
  }'
```



block_hash



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes_in_block",
  "params": {
    "block_id": "81k9ked5s34zh13EjJt26mxw5npa485SY4UNoPi6yYLo"
  }
}
```




```js
const response = await near.connection.provider.experimental_changes_in_block(
  "81k9ked5s34zh13EjJt26mxw5npa485SY4UNoPi6yYLo"
);
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes_in_block 
  params:='{
    "block_id": "81k9ked5s34zh13EjJt26mxw5npa485SY4UNoPi6yYLo"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "81k9ked5s34zh13EjJt26mxw5npa485SY4UNoPi6yYLo",
    "changes": [
      {
        "type": "account_touched",
        "account_id": "lee.testnet"
      },
      {
        "type": "contract_code_touched",
        "account_id": "lee.testnet"
      },
      {
        "type": "access_key_touched",
        "account_id": "lee.testnet"
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong??
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes_in_block method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


Chunk Details

Returns details of a specific chunk. You can run a block details query to get a valid chunk hash.


method: chunk
params:

chunk_id OR block_id, shard_id


chunk_id example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "chunk",
  "params": {"chunk_id": "EBM2qg5cGr47EjMPtH88uvmXHDHqmWPzKaQadbWhdw22"}
}
```




```js
const response = await near.connection.provider.chunk({
  chunk_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=chunk params:='{"chunk_id": "EBM2qg5cGr47EjMPtH88uvmXHDHqmWPzKaQadbWhdw22"}' id=dontcare
```



block_id, shard_id example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "chunk",
  "params": {"block_id": 58934027, "shard_id": 0}
}
```




```js
const response = await near.connection.provider.chunk({
  block_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 method=chunk params:='{"block_id": 58934027, "shard_id": 0}' id=dontcare
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "author": "bitcat.pool.f863973.m0",
    "header": {
      "chunk_hash": "EBM2qg5cGr47EjMPtH88uvmXHDHqmWPzKaQadbWhdw22",
      "prev_block_hash": "2yUTTubrv1gJhTUVnHXh66JG3qxStBqySoN6wzRzgdVD",
      "outcome_root": "11111111111111111111111111111111",
      "prev_state_root": "HqWDq3f5HJuWnsTfwZS6jdAUqDjGFSTvjhb846vV27dx",
      "encoded_merkle_root": "9zYue7drR1rhfzEEoc4WUXzaYRnRNihvRoGt1BgK7Lkk",
      "encoded_length": 8,
      "height_created": 17821130,
      "height_included": 17821130,
      "shard_id": 0,
      "gas_used": 0,
      "gas_limit": 1000000000000000,
      "rent_paid": "0",
      "validator_reward": "0",
      "balance_burnt": "0",
      "outgoing_receipts_root": "H4Rd6SGeEBTbxkitsCdzfu9xL9HtZ2eHoPCQXUeZ6bW4",
      "tx_root": "11111111111111111111111111111111",
      "validator_proposals": [],
      "signature": "ed25519:4iPgpYAcPztAvnRHjfpegN37Rd8dTJKCjSd1gKAPLDaLcHUySJHjexMSSfC5iJVy28vqF9VB4psz13x2nt92cbR7"
    },
    "transactions": [],
    "receipts": []
  },
  "id": "dontcare"
}
```



What Could Go Wrong??
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by chunk method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      UNKNOWN_CHUNK
      200
      The requested chunk can't be found in a database
      
        
          Check that the requested chunk is legit
          If the chunk had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_SHARD_ID
      200
      Provided shard_id does not exist
      
        
          Provide shard_id for an existing shard
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested chunk is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Access Keys

The RPC API enables you to retrieve information about an account's access keys.

View access key
Returns information about a single access key for given account.
If permission of the key is FunctionCall, it will return more details such as the allowance, receiver_id, and method_names.

method: query
params:

request_type: view_access_key
finality OR block_id
account_id: "example.testnet"
public_key: "example.testnet's public key"





```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "view_access_key",
    "finality": "final",
    "account_id": "client.chainlink.testnet",
    "public_key": "ed25519:H9k5eiU4xXS3M4z8HzKJSLaZdqGdGwBG49o7orNC4eZW"
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "view_access_key",
  finality: "final",
  account_  public_key: "ed25519:H9k5eiU4xXS3M4z8HzKJSLaZdqGdGwBG49o7orNC4eZW",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_access_key",
    "finality": "final",
    "account_id": "client.chainlink.testnet",
    "public_key": "ed25519:H9k5eiU4xXS3M4z8HzKJSLaZdqGdGwBG49o7orNC4eZW"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "nonce": 85,
    "permission": {
      "FunctionCall": {
        "allowance": "18501534631167209000000000",
        "receiver_id": "client.chainlink.testnet",
        "method_names": ["get_token_price"]
      }
    },
    "block_height": 19884918,
    "block_hash": "GGJQ8yjmo7aEoj8ZpAhGehnq9BSWFx4xswHYzDwwAP2n"
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by view_access_key request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      UNKNOWN_ACCESS_KEY
      200
      The requested public_key has not been found while viewing since the public key has not been created or has been already deleted
      
        
          Check the public_key
          Specify a different block or retry if you request the latest state
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to found the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View access key list
You can query all access keys for a given account.

method: query
params:

request_type: view_access_key_list
finality OR block_id
account_id: "example.testnet"


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "query",
  "params": {
    "request_type": "view_access_key_list",
    "finality": "final",
    "account_id": "example.testnet"
  }
}
```




```js
const response = await near.connection.provider.query({
  request_type: "view_access_key_list",
  finality: "final",
  account_});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=query 
  params:='{
    "request_type": "view_access_key_list",
    "finality": "final",
    "account_id": "example.testnet"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "keys": [
      {
        "public_key": "ed25519:2j6qujbkPFuTstQLLTxKZUw63D5Wu3SG79Gop5JQrNJY",
        "access_key": {
          "nonce": 17,
          "permission": {
            "FunctionCall": {
              "allowance": "9999203942481156415000",
              "receiver_id": "place.meta",
              "method_names": []
            }
          }
        }
      },
      {
        "public_key": "ed25519:46etzhzZHN4NSQ8JEQtbHCX7sT8WByS3vmSEb3fbmSgf",
        "access_key": {
          "nonce": 2,
          "permission": {
            "FunctionCall": {
              "allowance": "9999930655034196535000",
              "receiver_id": "dev-1596616186817-8588944",
              "method_names": []
            }
          }
        }
      },
      {
        "public_key": "ed25519:4F9TwuSqWwvoyu7JVZDsupPhC7oYbYNsisBV2yQvyXFn",
        "access_key": {
          "nonce": 0,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:4bZqp6nm1btr92UfKbyADDzJ4oPK9JetHXqEYqbYZmkD",
        "access_key": {
          "nonce": 2,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:6ZPzX7hS37jiU9dRxbV1Waf8HSyKKFypJbrnZXzNhqjs",
        "access_key": {
          "nonce": 2,
          "permission": {
            "FunctionCall": {
              "allowance": "9999922083697042955000",
              "receiver_id": "example.testnet",
              "method_names": []
            }
          }
        }
      },
      {
        "public_key": "ed25519:81RKfuo7mBbsaviTmBsq18t6Eq4YLnSi3ye2CBLcKFUX",
        "access_key": {
          "nonce": 8,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:B4W1oAYTcG8GxwKev8jQtsYWkGwGdqP24W7eZ6Fmpyzc",
        "access_key": {
          "nonce": 0,
          "permission": {
            "FunctionCall": {
              "allowance": "10000000000000000000000",
              "receiver_id": "dev-1594144238344",
              "method_names": []
            }
          }
        }
      },
      {
        "public_key": "ed25519:BA3AZbACoEzAsxKeToFd36AVpPXFSNhSMW2R6UYeGRwM",
        "access_key": {
          "nonce": 0,
          "permission": {
            "FunctionCall": {
              "allowance": "10000000000000000000000",
              "receiver_id": "new-corgis",
              "method_names": []
            }
          }
        }
      },
      {
        "public_key": "ed25519:BRyHUGAJjRKVTc9ZqXTTSJnFmSca8WLj8TuVe1wXK3LZ",
        "access_key": {
          "nonce": 17,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:DjytaZ1HZ5ZFmH3YeJeMCiC886K1XPYeGsbz2E1AZj2J",
        "access_key": {
          "nonce": 31,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:DqJn5UCq6vdNAvfhnbpdAeuui9a6Hv9DKYDxeRACPUDP",
        "access_key": {
          "nonce": 0,
          "permission": "FullAccess"
        }
      },
      {
        "public_key": "ed25519:FFxG8x6cDDyiErFtRsdw4dBNtCmCtap4tMTjuq3umvSq",
        "access_key": {
          "nonce": 0,
          "permission": "FullAccess"
        }
      }
    ],
    "block_height": 17798231,
    "block_hash": "Gm7YSdx22wPuciW1jTTeRGP9mFqmon69ErFQvgcFyEEB"
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by view_access_key_list request type:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      INVALID_ACCOUNT
      200
      The requested account_id is invalid
      
        
          Provide a valid account_id
        
      
    
    
      UNKNOWN_ACCOUNT
      200
      The requested account_id has not been found while viewing since the account has not been created or has been already deleted
      
        
          Check the account_id
          Specify a different block or retry if you request the latest state
        
      
    
    
      UNAVAILABLE_SHARD
      200
      The node was unable to find the requested data because it does not track the shard where data is present
      
        
          Send a request to a different node which might track the shard
        
      
    
    
      NO_SYNCED_BLOCKS
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View access key changes (single)
Returns individual access key changes in a specific block. You can query multiple keys by passing an array of objects containing the account_id and public_key.

method: EXPERIMENTAL_changes
params:

changes_type: single_access_key_changes
keys: [{ account_id, public_key }]
finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes",
  "params": {
    "changes_type": "single_access_key_changes",
    "keys": [
      {
        "account_id": "example-acct.testnet",
        "public_key": "ed25519:25KEc7t7MQohAJ4EDThd2vkksKkwangnuJFzcoiXj9oM"
      }
    ],
    "finality": "final"
  }
}
```




```js
const response = await near.connection.provider.experimental_changes({
  changes_type: "single_access_key_changes",
  keys: [
    {
      account_      public_key: "ed25519:25KEc7t7MQohAJ4EDThd2vkksKkwangnuJFzcoiXj9oM",
    },
  ],
  finality: "final",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes 
  params:='{
    "changes_type": "single_access_key_changes",
    "keys": [
      {
        "account_id": "example-acct.testnet",
        "public_key": "ed25519:25KEc7t7MQohAJ4EDThd2vkksKkwangnuJFzcoiXj9oM"
      }
    ],
    "finality": "final"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "4kvqE1PsA6ic1LG7S5SqymSEhvjqGqumKjAxnVdNN3ZH",
    "changes": [
      {
        "cause": {
          "type": "transaction_processing",
          "tx_hash": "HshPyqddLxsganFxHHeH9LtkGekXDCuAt6axVgJLboXV"
        },
        "type": "access_key_update",
        "change": {
          "account_id": "example-acct.testnet",
          "public_key": "ed25519:25KEc7t7MQohAJ4EDThd2vkksKkwangnuJFzcoiXj9oM",
          "access_key": {
            "nonce": 1,
            "permission": "FullAccess"
          }
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes_in_block method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details
        
      
    
  


View access key changes (all)
Returns changes to all access keys of a specific block. Multiple accounts can be quereied by passing an array of account_ids.

method: EXPERIMENTAL_changes
params:

changes_type: all_access_key_changes
account_ids: [ "example.testnet", "example2.testnet"]
finality OR block_id


Example:



```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_changes",
  "params": {
    "changes_type": "all_access_key_changes",
    "account_ids": ["example-acct.testnet"],
    "block_id": "4kvqE1PsA6ic1LG7S5SqymSEhvjqGqumKjAxnVdNN3ZH"
  }
}
```




```js
const response = await near.connection.provider.experimental_changes({
  changes_type: "all_access_key_changes",
  account_ids: "example-acct.testnet",
  finality: "final",
});
```




```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_changes 
  params:='{
    "changes_type": "all_access_key_changes",
    "account_ids": ["example-acct.testnet"],
    "block_id": "4kvqE1PsA6ic1LG7S5SqymSEhvjqGqumKjAxnVdNN3ZH"
  }'
```




Example response: 


```json
{
  "jsonrpc": "2.0",
  "result": {
    "block_hash": "4kvqE1PsA6ic1LG7S5SqymSEhvjqGqumKjAxnVdNN3ZH",
    "changes": [
      {
        "cause": {
          "type": "transaction_processing",
          "tx_hash": "HshPyqddLxsganFxHHeH9LtkGekXDCuAt6axVgJLboXV"
        },
        "type": "access_key_update",
        "change": {
          "account_id": "example-acct.testnet",
          "public_key": "ed25519:25KEc7t7MQohAJ4EDThd2vkksKkwangnuJFzcoiXj9oM",
          "access_key": {
            "nonce": 1,
            "permission": "FullAccess"
          }
        }
      },
      {
        "cause": {
          "type": "receipt_processing",
          "receipt_hash": "CetXstu7bdqyUyweRqpY9op5U1Kqzd8pq8T1kqfcgBv2"
        },
        "type": "access_key_update",
        "change": {
          "account_id": "example-acct.testnet",
          "public_key": "ed25519:96pj2aVJH9njmAxakjvUMnNvdB3YUeSAMjbz9aRNU6XY",
          "access_key": {
            "nonce": 0,
            "permission": "FullAccess"
          }
        }
      }
    ]
  },
  "id": "dontcare"
}
```



What Could Go Wrong?
When API request fails, RPC server returns a structured error response with a limited number of well-defined error variants, so client code can exhaustively handle all the possible error cases. Our JSON-RPC errors follow verror convention for structuring the error response:
{
    "error": {
        "name": <ERROR_TYPE>,
        "cause": {
            "info": {..},
            "name": <ERROR_CAUSE>
        },
        "code": -32000,
        "data": String,
        "message": "Server error",
    },
    "id": "dontcare",
    "jsonrpc": "2.0"
}

Heads up
The fields code, data, and message in the structure above are considered legacy ones and might be deprecated in the future. Please, don't rely on them.

Here is the exhaustive list of the error variants that can be returned by EXPERIMENTAL_changes method:

  
    
      
        ERROR_TYPE
        error.name
      
      ERROR_CAUSEerror.cause.name
      Status Code
      Reason
      Solution
    
  
  
    
      HANDLER_ERROR
      UNKNOWN_BLOCK
      200
      The requested block has not been produced yet or it has been garbage-collected (cleaned up to save space on the RPC node)
      
        
          Check that the requested block is legit
          If the block had been produced more than 5 epochs ago, try to send your request to an archival node
        
      
    
    
      NOT_SYNCED_YET
      200
      The node is still syncing and the requested block is not in the database yet
      
        
          Wait until the node finish syncing
          Send a request to a different node which is synced
        
      
    
    
      REQUEST_VALIDATION_ERROR
      PARSE_ERROR
      400
      Passed arguments can't be parsed by JSON RPC server (missing arguments, wrong format, etc.)
      
        
          Check the arguments passed and pass the correct ones
          Check error.cause.info for more details
        
      
    
    
      INTERNAL_ERROR
      INTERNAL_ERROR
      500
      Something went wrong with the node itself or overloaded
      
        
          Try again later
          Send a request to a different node
          Check error.cause.info for more details

### Tools

Welcome! The NEAR ecosystem has a complete set of tools for you to make the most out of the NEAR network.
In this page you will find:

Wallets to handle your assets.
Explorers to quickly obtain information from the blockchain.
Websites to simplify creating and participating on governance projects.
Developer tools to deploy and interact with contracts such as the NEAR CLI and NEAR JavaScript API.

### Wallets

Supported Wallets
Here's a range of user-friendly wallets that support the NEAR blockchain:


HERE Wallet: Non-custodial mobile wallet with a friendly user interface and advanced features.


Meteor Wallet: Both a browser and extension wallet, with advanced NFT features.


Mintbase Wallet: A passkey meta-transaction, browser wallet, with advanced NFT and AI features. If you're looking to integrate Mintbase Wallet into your applications, check this tutorial to get started.


MyNearWallet: A browser based wallet that offers the same UI and features of wallet.near.org.


NEAR Mobile: A non-custodial wallet that is easy to use and well designed to manage your crypto wherever you go.


Nightly Wallet: A mobile and extension wallet, with support for multiple ecosystems.


Sender Wallet: Security-audited mobile & extension wallet with 1M+ users, supporting NEAR & Aurora.


WELLDONE Wallet: A multi-chain extension wallet that gives you control over all your assets from a single platform.

### wallet-selector

Wallet Selector
An easy-to-navigate modal that allows users to select their preferred wallet to easily interact with the NEAR protocol.
Launched in March 2022 by the NEAR Foundation, this simple modal will appear whenever users are given the option to “Connect Wallet†to the NEAR blockchain.

Initial screen of Wallet Selector

Framework agnostic
React / Next.js and Angular variations of the Guest Book dApp can be found in the examples directory. Developers can use these to gain a concrete understanding of how to integrate NEAR Wallet Selector into their own dApp.
Unlocking the wallet ecosystem
Wallet Selector makes it easy for users to interact with dApps by providing an abstraction over various wallets and wallet types within the NEAR ecosystem.
info
You can check the current list of supported wallets in the README.md file of near/wallet-selector repository.

Thanks to NEAR’s open and inclusive approach, other wallet developers can contribute to the NEAR ecosystem by following the documentation and instructions on the NEAR Github repository on how to add a new wallets to the Wallet Selector.
tipTo learn more on how to include new wallets for Wallet Selector you can check the listing criteria for third party wallets on this [link](https://github.com/near/wallet-selector/blob/main/CONTRIBUTING.md#listing-criteria-for-third-party-wallet-on-wallet-selector).


Install
The easiest way to use NEAR Wallet Selector is to install the core package from the NPM registry, some packages may require near-api-js v0.44.2 or above check them at packages.
npm install near-api-js@^0.44.2
npm install @near-wallet-selector/core
Next, you'll need to install the wallets you want to support:
npm install 
  @near-wallet-selector/near-wallet 
  @near-wallet-selector/my-near-wallet 
  @near-wallet-selector/sender 
  @near-wallet-selector/nearfi 
  @near-wallet-selector/here-wallet 
  @near-wallet-selector/math-wallet 
  @near-wallet-selector/nightly 
  @near-wallet-selector/meteor-wallet 
  @near-wallet-selector/ledger 
  @near-wallet-selector/wallet-connect 
  @near-wallet-selector/nightly-connect 
  @near-wallet-selector/default-wallets 
  @near-wallet-selector/coin98-wallet
Setup Wallet Selector
Optionally, you can install our modal-ui or modal-ui-js package for a pre-built interface that wraps the core API and presents the supported wallets:
npm install @near-wallet-selector/modal-ui
Then use it in your dApp:

const selector = await setupWalletSelector({
  network: "testnet",
  modules: [setupNearWallet()],
});

const modal = setupModal(selector, {
  contractId: "test.testnet",
});

modal.show();
infoRequired CSS

To integrate the Wallet Selector, you also need to include the required CSS:

```

```


API Reference
The API reference of the selector can be found here
Wallet API
Sign in
// NEAR Wallet.
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  const accounts = await wallet.signIn({ contractId: "test.testnet" });
})();
Sign out
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  await wallet.signOut();
})();
Get accounts
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  const accounts = await wallet.getAccounts();
  console.log(accounts); // [{ accountId: "test.testnet" }]
})();
Verify Owner
// MyNearWallet
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  await wallet.verifyOwner({
    message: "Test message",
  });
})();
Sign and send transaction
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  await wallet.signAndSendTransaction({
    actions: [
      {
        type: "FunctionCall",
        params: {
          methodName: "addMessage",
          args: { text: "Hello World!" },
          gas: "30000000000000",
          deposit: "10000000000000000000000",
        },
      },
    ],
  });
})();
Sign and send transactions
(async () => {
  const wallet = await selector.wallet("my-near-wallet");
  await wallet.signAndSendTransactions({
    transactions: [
      {
        receiverId: "guest-book.testnet",
        actions: [
          {
            type: "FunctionCall",
            params: {
              methodName: "addMessage",
              args: { text: "Hello World!" },
              gas: "30000000000000",
              deposit: "10000000000000000000000",
            },
          },
        ],
      },
    ],
  });
})();

### NEAR SDK

The NEAR SDK is a library that allow to develop smart contracts. Currently, there exist two versions of NEAR SDK: one for Rust and one for JavaScript.
tipant to build a smart contract?

The best place to start learning is our [QuickStart Guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md)



  
    
  
  
    
  


Smart Contracts on NEAR
This is how a smart contract written in Rust and JavaScript using the NEAR SDK looks like:

  

    ```js
    @NearBindgen({})
    class HelloNear {
      greeting: string = 'Hello';

      @view({}) // This method is read-only and can be called for free
      get_greeting(): string {
        return this.greeting;
      }

      @call({}) // This method changes the state, for which it cost gas
      set_greeting({ greeting }: { greeting: string }): void {
        near.log(`Saving greeting ${greeting}`);
        this.greeting = greeting;
      }
    }

    ```

  

  

    ```rust
    #[near(contract_state)]
    pub struct Contract {
        greeting: String,
    }

    impl Default for Contract {
        fn default() -> Self {
            Self { greeting: "Hello".to_string(), }
        }
    }

    #[near]
    impl Contract {
        pub fn get_greeting(&self) -> String {
            self.greeting.clone()
        }

        pub fn set_greeting(&mut self, greeting: String) {
            self.greeting = greeting;
        }
    }
    ```

  


tipWant to build a smart contract? Check our [QuickStart Guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md)



🎉 Ready to start developing?
Start from our Smart Contract QuickStart Guide, and let it guide you through all our documentation on building smart contracts

Want to See Examples?
We have a section dedicated to tutorials and examples that will help you understand diverse use cases and how to implement them
tipIf you are new to smart contracts, we recommend you start with our [Smart Contract QuickStart Guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) before moving to the examples



Searching for the Reference Docs
If you need to find a specific function signature, or understand the SDK struct/classes, please visit the SDK specific pages:

Rust SDK
JavaScript SDK

tipIf you are new to smart contracts, we recommend you start with our [Smart Contract QuickStart Guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) before moving to the reference documentation

### Indexing Solutions on NEAR

Indexing Solutions on NEAR
Here's a quick overview of Indexer projects on the NEAR ecosystem:


BigQuery: Blockchain data indexing in NEAR Public Lakehouse is for anyone wanting to understand blockchain data.


NEAR Lake Framework: a companion library to NEAR Lake. It allows you to build your own indexer that watches a stream of blocks from a NEAR Lake data source and allows you to create your own logic to process that data. Keep in mind this is the one you want to use for future projects, instead of the Indexer Framework. Read why it is better.


Indexer.xyz Multichain Indexer: Indexer.xyz is an application layer that you can build your NFT or DeFi applications entirely on top of. In addition to raw transaction indexing, Indexer.xyz provides you with a standardized GraphQL API layer to easily tap into transactions across contracts and chains.


Pagoda NEAR Lake: with this fully managed solution by Pagoda Inc., you don't need to run your own NEAR Lake Nodes and AWS S3 buckets.


The Graph: development tools to process blockchain events and make the resulting data easily available via a GraphQL API, known individually as a subgraph. Graph Node is able to process NEAR events, which means that NEAR developers can build subgraphs to index their smart contracts.


GetBlock: developer tools offering a simple and reliable API access to multiple blockchains including NEAR Protocol.


NearBlocks: build precise & reliable dApps with NearBlocks APIs.


Octopus Network NEAR Indexer: an indexing solution based on NEAR Lake framework.


Covalent: for Aurora EVM indexing, Covalent provides a unified API bringing visibility to billions of Web3 data points.


NEAR Indexer Framework: a micro-framework providing you with a "live" stream of blocks. Useful to handle on-chain real-time events.


NEAR Indexer for Explorer: an indexer built on top of the indexer microframework. It watches and stores all events/data from the blockchain to a PostgreSQL database.
You can clone the GitHub repository and customize your own indexer solution.


SubQuery: is an end to end multi-blockchain indexing solution that provides NEAR developers with fast, flexible, universal, open source and decentralized APIs for web3 projects. The NEAR starter project provides a template for developers to get up and running within minutes.

### FastNEAR API

A fast RPC for the NEAR blockchain, based on Redis and LMDB.
About FastNEAR
Fast-Near aims to provide the fastest RPC implementation for NEAR Protocol using high-performance storage backends:

in-memory storage in Redis.
SSD optimized storage using LMDB.

It is optimized for view call performance and ease of deploy and scaling. 
infoNote about data sync
FastNear doesn't sync with the NEAR blockchain on its own. Data needs to be loaded either from [NEAR Lake](https://github.com/near/near-lake-indexer) or from [Near State Indexer](https://github.com/vgrichina/near-state-indexer).


FastNEAR API
The FastNEAR API server provides a low-latency RPC API for wallets and explorers.
Supported APIs
Public Key

Public Key to Account ID mapping.
Full Access Public Key to Account ID mapping.
Any Public Key to Account ID mapping.

Account ID

Account ID to delegated staking pools (validators).
Account ID to fungible tokens (FT contracts).
Account ID to non-fungible tokens (NFT contracts).

Token ID

Token ID to top 100 accounts by balance (for FT contracts).

tip1 API

[Click here](https://github.com/fastnear/fastnear-api-server-rs?tab=readme-ov-file#api-v1) to see the complete list of API endpoints and usage examples.

### Explorer

An Explorer allows you to quickly obtain information from the blockchain through a friendly user interface.
These useful tools enable for example to:

 	Search for a transactions and its receipts.
 	Check all the interactions in a smart contract.
 	See the balance of an account.
 	View block creations in real time




NearBlocks
Created by the community, NearBlocks enables to check accounts and transactions with an interface similar to etherscan.


Main page of NearBlocks



Nearscope
Nearscope provides a NEAR node validator and delegator explorer.


Main page of Nearscope



DappLooker
DappLooker lets you analyze and query NEAR blockchain data, build dashboards to visualize data and share with your community.


Main page of DappLooker



Pikespeak
Pikespeak provides access to real-time and historical data on the NEAR Protocol.


Main page of Pikespeak
NEARCatalog
NEARCatalog provides access to trending decentralized applications (DApps) on the NEAR Protocol.

Main page of NEARCatalog

### ethereum-wallets

How to integrate Ethereum Wallets to Near DApps?
In this article we will describe how to add EVM wallets support to your Near app, which is already uses the Near Wallet Selector.
To integrate Metamask and other EVM wallets you will need to:

Update the Wallet Selector and add the Web3Modal libraries (wagmi, web3wallet, @near-wallet-selector/ethereum-wallets)
Create configurations so the Ethereum wallets can communicate with our Near RPCs
Create a Web3Modal and connect it to the Near Wallet Selector
Initialize the Ethereum Wallets 

We will show how we added Ethereum Wallets support to our Hello Near Examples. Let's go step-by-step with it!
infoAuroraLabs team has worked on this feature almost for a year now. You can learn more about it from [NEP-518](https://github.com/near/NEPs/issues/518).

tipThis article was created by the AuroraLabs team, and appeared originally in the [official Aurora documentation](https://doc.aurora.dev/dev-reference/eth-wallets)



1. Update Wallet Selector libraries
Lets start by updating the package.json, adding all the necessary libraries to support Ethereum wallets.

Wallet Selector Packages
In your package.json, add the @near-wallet-selector/ethereum-wallets package, and update all wallet selector packages to version 8.9.13 or above:
  "dependencies": {
    ...
    "@near-wallet-selector/core": "^8.9.13",
    // highlight-next-line
    "@near-wallet-selector/ethereum-wallets": "^8.9.13",
    "@near-wallet-selector/here-wallet": "^8.9.13",
    "@near-wallet-selector/modal-ui": "^8.9.13",
    "@near-wallet-selector/my-near-wallet": "^8.9.13",
    ...
    }

Add Web3Modal libraries
Web3Modal (also known as AppKit) is a standard way to integrate multiple wallets in Ethereum community.
It is based on [wagmi] hooks library for React. We will describe the React integration here, but if you are on another platform - just go here, and try using specific instructions suitable for you to install it.
npm install @web3modal/wagmi wagmi viem @tanstack/react-query

2. Add Near chain config with our RPCs
We updated the config file of our repo to add the chain information necessary for Metamask to communicate with our RPC.
<Github fname="config.js" language="js"
url="https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/config.js"
start="6" end="20" />

3. Add Web3Modal
First, let's create a new file to handle the Web3Modal (i.e. the modal shown when selecting the Ethereum Wallets on the Wallet Selector), and all the configs needed to setup the Ethereum Wallets.
<Github fname="web3modal.js" language="js"
url="https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/web3modal.js" />

   Metadata 

  You can pass a `metadata` object to the `walletConnect` connector. This object will be displayed in the EVM wallets, like MetaMask.

  ```js title="source/wallets/web3modal.js"
  const url = "http://localhost:3000";

  const metadata = {
    name: "Onboard to NEAR Protocol with EVM Wallet",
    description: "Discover NEAR Protocol with Ethereum and NEAR wallets.",
    url: url,
    icons: [`${url}/icon.svg`],
  };
  ```

  This tracks the app requesting the connection on the WalletConnect side. See more [here](https://wagmi.sh/core/api/connectors/walletConnect#metadata).


tipMake sure to call `reconnect(wagmiConfig)` in your code, to persist the connection between the app and the wallet when the user refreshes the page



Get projectId
Notice that the modal uses a projectId, which refers to your unique project on Reown. Let's get the Web3Modal projectId for your project:

Go to Cloud Reown.
Register there.
Create a project on Cloud Reown.
You can copy your projectId:


tipYou can read more about the `projectId` and how it works [here](https://docs.reown.com/appkit/react/core/installation#cloud-configuration).



4. Setup Wallet Selector
The last step is to add the Ethereum Wallets selector to your Near Wallet Selector. Let's find your setupWalletSelector call and add setupEthereumWallets there:

<Github fname="web3modal.js" language="js" start="42" end="53" metastring="{10}"
url="https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js" />

5. Use It!
That is it! Just re-build your project and click on login! You should see Ethereum Wallets option in your Near Selector:

And after click to be able to choose the EVM wallet of your taste:


Resources


Source code of the project above


Example of the EVM account on the Near Testnet to see what happens in reality on-chain during the execution.


Details about how does it work are in NEP-518


Recording of the Near Devs call with the EthWallets presentation.

### NEAR CLI

The NEAR Command Line Interface (CLI) is a tool that enables to interact with the NEAR network directly from the shell. Among other things, the NEAR CLI enables you to:

Login with a NEAR account
Deploy a contract
Interact and query information from a deployed contract


Installation

  

  ```bash
  npm install -g near-cli-rs@latest
  ```
  
  

  ```
  $ cargo install near-cli-rs
  ```
  
  

  ```bash
  curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh
  ```
  
  

  ```bash
  irm https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.ps1 | iex
  ```
  


Configuration file
The directory with access keys and available connection networks are defined in the configuration file (near-cli/config.toml), which is located depending on the operating system in the following places:

macOS: $HOME/Library/Application Support (e.g. /Users/Alice/Library/Application Support)
Linux: $XDG_CONFIG_HOME or $HOME/.config (e.g. /home/alice/.config)
Windows: {FOLDERID*RoamingAppData} (e.g. C:UsersAliceAppDataRoaming)

You can learn more about working with the configuration file here.
tipustom RPC
You can setup a custom [RPC server](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/api/rpc/providers) by changing the `rpc_url` parameter in `near-cli` settings:

```bash
near config edit-connection testnet --key rpc_url --value https://archival-rpc.testnet.near.org/
```


Interactive mode
To use the near-cli simply run the following in your terminal.
$ near
You should then see the following. Use the arrow keys and hit enter or simply type out one of the available options to select an option


::important
We provide examples only of the most used commands. Such commands may have two versions - a full one and a short one. If you want to explore all options provided by near-cli use the interactive mode described above.
::


Account
This option will allow you to manage, control, and retrieve information on your accounts.
Summary
view-account-summary - view properties for an account.

  

    ```bash
    export ACCOUNT_ID=bob.testnet
    near account view-account-summary $ACCOUNT_ID network-config testnet now
    ```
  
  

    ```bash
    export ACCOUNT_ID=bob.testnet
    near state $ACCOUNT_ID --networkId testnet
    ```
  


Import
import-account - import existing account (a.k.a. "sign in").

  

  ```bash
  near account import-account using-web-wallet network-config testnet
  ```
  
  

  ```bash
  near login --networkId testnet
  ```
  


Export
export-account - export existing account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near account export-account $ACCOUNT_ID using-web-wallet network-config testnet
  ```
  


Create
create-account - create a new account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near account create-account sponsor-by-faucet-service $ACCOUNT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  
  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near create-account $ACCOUNT_ID --useFaucet --networkId testnet
  ```
  


Delete
delete-account - delete an account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export BENEFICIARY_ID=alice.testnet

  near account delete-account $ACCOUNT_ID beneficiary $BENEFICIARY_ID network-config testnet sign-with-keychain send
  ```
  
  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export BENEFICIARY_ID=alice.testnet

  near delete-account $ACCOUNT_ID $BENEFICIARY_ID --networkId testnet
  ```
  


Keys
Showing, adding and removing account keys.
List keys
list-keys - view a list of keys for an account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near account list-keys $ACCOUNT_ID network-config testnet now
  ```
  

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near list-keys $ACCOUNT_ID --networkId testnet
  ```
  


Add key
add-key - add an access key to an account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near account add-key $ACCOUNT_ID grant-full-access use-manually-provided-public-key ed25519:CXqAs8c8kZz81josLw82RQsnZXk8CAdUo7jAuN7uSht2 network-config testnet sign-with-keychain send
  ```

  
  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near add-key $ACCOUNT_ID ed25519:CXqAs8c8kZz81josLw82RQsnZXk8CAdUo7jAuN7uSht2 --networkId testnet
  ```
  


Delete key
delete-keys - delete an access key from an account.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near account delete-keys $ACCOUNT_ID public-keys ed25519:HdkFZFEPoWfgrrLK3R4t5dWtNoLC8WymBzhCXoP3zrjh network-config testnet sign-with-keychain send
  ```
  
  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near delete-key $ACCOUNT_ID ed25519:HdkFZFEPoWfgrrLK3R4t5dWtNoLC8WymBzhCXoP3zrjh --networkId testnet
  ```
  


Tokens
This will allow you to manage your token assets such as NEAR, FTs and NFTs.
Send NEAR
send-near - transfers NEAR to a specified recipient in units of NEAR or yoctoNEAR.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export RECEIVER_ID=alice.testnet
  near tokens $ACCOUNT_ID send-near $RECEIVER_ID '0.5 NEAR' network-config testnet sign-with-keychain send
  ```
  
  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export RECEIVER_ID=alice.testnet

  near send-near $ACCOUNT_ID $RECEIVER_ID 0.5 --networkId testnet
  ```
  


Send FT
send-ft - transfer Fungible Tokens to a specified user.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export RECEIVER_ID=alice.testnet
  export FT_CONTRACT_ID=0c97251cd1f630c444dbusdt.testnet

  near tokens $ACCOUNT_ID send-ft $FT_CONTRACT_ID $RECEIVER_ID amount-ft '1 USDT' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' network-config testnet sign-with-keychain send
  ```
  


Send NFT
send-nft - transfers NFTs between accounts.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export RECEIVER_ID=alice.testnet
  export NFT_CONTRACT_ID=nft.examples.testnet

  near tokens $ACCOUNT_ID send-nft $NFT_CONTRACT_ID $RECEIVER_ID 1 --prepaid-gas '100.0 Tgas' --attached-deposit '1 yoctoNEAR' network-config testnet sign-with-keychain send
  ```
  


View NEAR balance
view-near-balance - view the balance of NEAR tokens.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  near tokens $ACCOUNT_ID view-near-balance network-config testnet now
  ```

  


View FT balance
view-ft-balance - view the balance of Fungible Tokens.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export FT_CONTRACT_ID=0c97251cd1f630c444dbusdt.testnet
  near tokens $ACCOUNT_ID view-ft-balance $FT_CONTRACT_ID network-config testnet now
  ```
  


View NFT balance
view-nft-assets - view the balance of NFT tokens.

  

  ```bash
  export ACCOUNT_ID=bob.testnet
  export NFT_CONTRACT_ID=nft.examples.testnet
  near tokens $ACCOUNT_ID view-nft-assets $NFT_CONTRACT_ID network-config testnet now
  ```
  


Contract
This option allows you to manage and interact with your smart contracts.
Call
call-function - execute function (contract method).

  

  ```bash
  # View method
  export CONTRACT_ID=nft.examples.testnet
  near contract call-function as-read-only $CONTRACT_ID nft_tokens json-args '{"from_index": "0", "limit": 2}' network-config testnet now

  # Call method
  export ACCOUNT_ID=bob.testnet
  near contract call-function as-transaction $CONTRACT_ID nft_mint json-args '{"metadata": {"copies": 1, "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "title": "GO TEAM"}, "receiver_id": "bob.testnet", "token_id": "5895"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $ACCOUNT_ID network-config testnet sign-with-keychain send
  ```
  
  

  ```bash
  # View method
  export CONTRACT_ID=nft.examples.testnet
  near view $CONTRACT_ID nft_tokens '{"from_index": "0", "limit": 2}' --networkId testnet

  # Call method
  export ACCOUNT_ID=bob.testnet
  near call $CONTRACT_ID nft_mint '{"metadata": {"copies": 1, "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "title": "GO TEAM"}, "receiver_id": "bob.testnet", "token_id": "5896"}' --deposit 0.1 --useAccount $ACCOUNT_ID --networkId testnet
  ```
  


Deploy
deploy - add a new contract code.

  

  ```bash
  export CONTRACT_ID=contract.testnet
  near contract deploy $CONTRACT_ID use-file ../target/near/contract.wasm without-init-call network-config testnet sign-with-keychain send
  ```
  
  

  ```bash
  export CONTRACT_ID=contract.testnet
  near deploy $CONTRACT_ID ../target/near/contract.wasm --networkId testnet
  ```
  


Inspect
inspect - get a list of available function names.

  

  ```bash
  export CONTRACT_ID=nft.examples.testnet
  near contract view-storage $CONTRACT_ID all as-text network-config testnet now
  ```
  
  

  ```bash
  export CONTRACT_ID=nft.examples.testnet
  near storage $CONTRACT_ID --finality final --utf8 --networkId testnet
  ```
  


Transaction
Operate transactions.
View status
view-status - view a transaction status.

  

  ```bash
  near transaction view-status BFrVVtjqD2p1zYX1UCvn4nJpy7zPHpY5cTgQaKCZjBvw network-config testnet
  ```
  
  

  ```bash
  near tx-status BFrVVtjqD2p1zYX1UCvn4nJpy7zPHpY5cTgQaKCZjBvw --networkId testnet
  ```
  


Config
Manage the connection parameters inside the config.toml file for near-cli.
This will allow you to change or modify the network connections for your CLI.
Show connections
show-connections - show a list of network connections.

  

  ```bash
  near config show-connections
  ```
  


Edit connection
edit-connection - edit a network connection.

  

  ```bash
  near config edit-connection testnet --key rpc_url --value https://test.rpc.fastnear.com
  ```
  



:::important
We provide examples only of the most used commands. If you want to explore all options provided by near-cli use the interactive mode.
::

### NFT minter

NFT Minter


This is a Next.js 14 frontend minter example that includes a simple interface from which you can mint nfts easily

tipintbase Templates
This is part of the [Mintbase Templates](https://templates.mintbase.xyz/), a collection of templates that you can use to scaffold your own project


Project Walkthrough
This is a simple minter example built on top of Next.js 14 using some of @mintbase-js packages.
NOTE: As a standard on Mintbase as we use the latest versions of Next.js we recommend using pnpm, but the package manager is up to your personal choice.
if you dont have a store you can deploy a new contract on our launchpad

Pre-Setup
If you would like the minter to use your own NFT contract you can easily deploy one through the mintbase market UI, additionally if you want to open up minting to be available for any person you will need to connect it to a proxy contract
Deploying a Near Contract on Mintbase:

Login on Mintbase and access Contracts Page
Click on New Contract
Choose Store Name (this will be the contract address to add on your minsta instance, this need to be added on the process.env.NEXT_PUBLIC_NFT_CONTRACT_ADDRESS environment variable) and Store Symbol
Proceed to transaction.
Succeeded
Go to Contract Settings


Add Proxy Minter Contract

Under Contract Settings go to Minters
add 0.drop.proxy.mintbase.near (this is the contract address that need to be added on process.env.NEXT_PUBLIC_PROXY_MINTER_CONTRACT_ADDRESS), and click Add Minters.
Proceed to transaction.
Succeeded


Step 1: Get the wallet connection
This method will get the wallet instance used to send the mint transaction. To learn more about this, you can check our guide at Wallet Connection Guide.
 const getWallet = async () => {
    try {
      return await selector.wallet();
    } catch (error) {
      console.error("Failed to retrieve the wallet:", error);
      throw new Error("Failed to retrieve the wallet");
    }
  };

Step 2: Use the onSubmit method
Get all the form data and use the onSubmit method to handle the minting process
const onSubmit = async (data: SubmitData) => {
    const wallet = await getWallet();

    const reference = await uploadReference({
       typeof data?.title === "string" ? data.title : "",
      media: data?.media as unknown as File,
    });

    const file = uploadFile(data?.media as unknown as File);

    await handleMint(
      reference.id,
      file,
      activeAccountId as string,
      wallet,
      reference.media_url as string,
      data.title
    );
  };

Step 3: Upload the NFT reference
The nft reference represents the offchain data which permanently stored on IPFS on Arweave in this case you can use @mintbase-js/data to easily upload it to arweave.
In this not only are we uploading an offchain JSON object which contains the media as well as the title but also uploading a separate media file to be included onchain.
Learn more about how references work here
const reference = await uploadReference({
     typeof data?.title === "string" ? data.title : "",
    media: data?.media as unknown as File,
  });

  const file = uploadFile(data?.media as unknown as File);

Step 4: Handling the mint
Here we start by configuring the callback which is the link and params to where the user will be redirected after minting after signing the mint transaction on the wallet.
In this case a number of params are included to be able to show a better success page.
The argument for calling the contracts "mint" function is then built. This transaction will be sent to the proxy contract which then calls the nft contracts nft_batch_mint method
   async function handleMint(
    reference: string,
    media: Promise<ArweaveResponse>,
    activeAccountId: string,
    wallet: Wallet,
    mediaUrl: string,
    nftTitle: string
  ) {
    const callbackArgs = {
      contractAddress: MintbaseWalletSetup.contractAddress.toString(),
      amount: 1,
      ref: `${reference}`,
      mediaUrl: mediaUrl,
       nftTitle,
    };

    if (reference) {
      await wallet.signAndSendTransaction({
        signerId: activeAccountId,
        receiverId: proxyAddress,
        callbackUrl: cbUrl(reference, callbackArgs),
        actions: [
          {
            type: "FunctionCall",
            params: {
              methodName: "mint",
              args: {
                metadata: JSON.stringify({
                  reference,
                  media: (await media).id,
                }),
                nft_contract_              },
              gas: "200000000000000",
              deposit: "10000000000000000000000",
            },
          },
        ],
      });
    }
  }

  return { form, onSubmit, preview, setPreview };
};

This sums up the blockchain portion of the code

Setup
In the minter/src/config/setup.ts file, we define several key configurations for interacting with the Mintbase platform. This setup is crucial for ensuring that our application communicates correctly with Mintbase smart contracts.

ENV Variables


proxyAddress: This is the address of the proxy contract on Mintbase. It is either taken from the environment variable NEXT_PUBLIC_PROXY_CONTRACT_ADDRESS or defaults to "0.minsta.proxy.mintbase.testnet" if the environment variable is not set.


contractAddress: The address of the minting contract. Similar to proxyAddress, it is sourced from NEXT_PUBLIC_MINT_CONTRACT_ADDRESS or defaults to "test122212.mintspace2.testnet".


network: Indicates the blockchain network we are interacting with. It defaults to "testnet" if NEXT_PUBLIC_NETWORK is not specified in the environment.


callbackUrl: A URL used for callbacks, constructed dynamically based on the network variable. If we are on the testnet, it uses the testnet URL; otherwise, it defaults to the mainnet URL.


To customize these configurations for different environments, you can set the following environment variables in your .env file:
NOTE: the env variables need to have the NEXT_PUBLIC_ on the variable name due to be available for the browser to process

NEXT_PUBLIC_PROXY_CONTRACT_ADDRESS: Your proxy contract address on Mintbase.
NEXT_PUBLIC_MINT_CONTRACT_ADDRESS: Your mint contract address on Mintbase.
NEXT_PUBLIC_NETWORK: The network you want to interact with ("testnet" or "mainnet").

after that you can run
pnpm install
pnpm dev

Extending
This project is setup using Next.js + @mintbase/js
You can use this project as a reference to build your own, and use or remove any library you think it would suit your needs.
infoGet in touch
You can get in touch with the mintbase team using the following channels:

- Support: [Join the Telegram](https://t.me/mintdev)
- Twitter: [@mintbase](https://twitter.com/mintbase)

### marketplace

Set ENV variables
Once that's done, copy the .env.example file in this directory to .env.local (which will be ignored by Git):
cp .env.example .env.local
if you use windows without powershell or cygwin:
copy .env.example .env.local
To get your api key visit :
Mintbase Developers Page for Mainnet:
Mintbase Developers Page for testnet:
NEXT_PUBLIC_DEVELOPER_KEY=your_mintbase_api_key
NEXT_PUBLIC_NETWORK could be testnet or mainnet
NEXT_PUBLIC_NETWORK=testnet
NEXT_PUBLIC_STORES is your store's ids
NEXT_PUBLIC_STORES=latium.mintspace2.testnet,mufasa.mintspace2.testnet
NEXT_PUBLIC_AFFILIATE_ACCOUNT is your near account where your should get your market fee
NEXT_PUBLIC_AFFILIATE_ACCOUNT=your_near_account.near
Extending
This project is setup using Next.js + @mintbase/js
You can use this project as a reference to build your own, and use or remove any library you think it would suit your needs.
infoGet in touch
You can get in touch with the mintbase team using the following channels:

- Support: [Join the Telegram](https://t.me/mintdev)
- Twitter: [@mintbase](https://twitter.com/mintbase)

### Onchain Blog

Blogchain


Blogchain makes your content unstoppable. Transform your blogs into smart contracts and posts into NFTs.

tipintbase Templates
This is part of the [Mintbase Templates](https://templates.mintbase.xyz/), a collection of templates that you can use to scaffold your own project


Project Walkthrough
Within the framework of blogchain, every blog manifests as an nft contract deployed from the Mintbase contract factory, while each individual blog post is uniquely represented as a non-fungible token (NFT).
NOTE: As a standard on Mintbase as we use the latest versions of Next.js we recommend using pnpm, but the package manager is up to your personal choice.

Run the project
# install
pnpm i
#run project
pnpm run dev

Create a Blog (deploy contract)
Step 1: check if the contract (blog) name already exists
Using @mintbase-js/data checkStoreName method we can check if the store already exists.
const { data: checkStore } = await checkStoreName(
  data.name,
  NEAR_NETWORKS.TESTNET
);

if (checkStore?.nft_contracts.length === 0) {
  (...)
}

Step 2: if contract name doesn't exist execute the deploy contract action with the instantiated wallet
Create deploy contract args using mintbase-js/sdk deployContract method. This will deploy an NFT contract from the mintbase contract factory
const wallet = await selector.wallet();

const deployArgs = deployContract({
  name: data.name,
  ownerId: activeAccountId,
  factoryContractId: MINTBASE_CONTRACTS.testnet,
  metadata: {
    symbol: "",
  },
});
We can then execute the deploy contract by passing in the wallet. If you wan't to learn about wallet connection check out the wallet starter template
  await execute({ wallet }, deployArgs);

Create a Blog Post (mint an NFT)
Step 1: call storage method to upload file inserted by the user to arweave
Using @mintbase-js/storage uploadReference method we upload the nft image to arweave.
const metadata = {
   data.title,
  media: data.media,
};
const referenceJson = await uploadReference(metadata);
const reference = referenceJson.id;

Step 2: mint the nft in the contract (blog)
Create mint args using mintbase-js/sdk mint method.
const wallet = await selector.wallet();

const mintCall = mint({
  noMedia: true,
  metadata: {
    reference: reference,
     data.title,
    description: postContent,
    extra: "blogpost",
  },
  contractAddress: data.contract,
  ownerId: activeAccountId,
});
We can then execute the mint nft method
  await execute({ wallet }, mintCall);
noteWe populate the 'extra' field with the value 'blogpost' to subsequently filter the displayed NFTs and blogs in blogchain, ensuring that only blogs are included.


Get Data
Get blog posts (nfts) from a blog (smart contract)
Using Mintbase GraphQL Indexer we can fetch the nfts from a specific smart contract - to filter by blog post we use 'blogpost' as an extra field as explained in the previous step.
export const GET_BLOG_POSTS =
`
query GET_BLOG_POSTS($contractId: String!) {
    mb_views_nft_tokens(
      where: {extra: {_eq: "blogpost"}, _and: {nft_contract_    ) {
      metadata_id
      title
      description
      media
      minted_timestamp
    }
  }
  `;

Get user blog posts (nfts)
export const GET_USER_POSTS =
`
query GET_USER_POSTS($accountId: String!) {
    mb_views_nft_tokens(
      where: {extra: {_eq: "blogpost"}, _and: {nft_contract_owner_    ) {
      metadata_id
      title
      description
      media
      minted_timestamp
    }
  }
  `;

Get user blogs (smart contracts)
export const GET_USER_BLOGS =
`
query GET_USER_BLOGS($accountId: String!) {
    nft_contracts(where: {owner_      id
    }
  }
  `;

Get latest blogs (smart contracts)
export const GET_LATEST_UPDATED_BLOGS =
`
query GET_LATEST_UPDATED_BLOGS {
  mb_views_nft_metadata(
    where: {extra: {_eq: "blogpost"}}
    distinct_on: [nft_contract_id, nft_contract_created_at]
    limit: 6
    order_by: [{nft_contract_created_at: desc}, {nft_contract_  ) {
    nft_contract_id
    nft_contract_owner_id
  }
  }
  `;

Get latest blog posts (nfts)
export const GET_LATEST_POSTS =
`
query GET_LATEST_POSTS {
    mb_views_nft_tokens(
      where: {extra: {_eq: "blogpost"}}
      limit: 10
      order_by: {minted_timestamp: desc}
    ) {
    metadata_id
    title
    description
    media
    minted_timestamp
    minter
    nft_contract_id
    }
  }`;

Get blog post (nft) data
export const GET_POST_METADATA =
`
query GET_POST_METADATA($metadataId: String!) {
    mb_views_nft_tokens(where: {metadata_      metadata_id
      title
      description
      media
      minted_timestamp
      minter
      nft_contract_id
    }
  }`;
Presently, this template exclusively functions within the testnet environment. To transition to a different network the configuration must be changed in <MintbaseWalletContextProvider> and every 'testnet' instance.

Extending
This project is setup using Next.js + @mintbase/js
You can use this project as a reference to build your own, and use or remove any library you think it would suit your needs.
infoGet in touch
You can get in touch with the mintbase team using the following channels:

- Support: [Join the Telegram](https://t.me/mintdev)
- Twitter: [@mintbase](https://twitter.com/mintbase)

### Minting NFT Front-end

NFT Minting Front-end

In this tutorial you'll learn how to create a simple NFT front-end and mint a "Go Team" NFT on the NEAR blockchain straight from your web browser.

App Overview
The app is fairly simple: the user signs in and hits the Mint NFT button. Once the user hits the mint button, a "Go Team" NFT is minted and sent to their NEAR Wallet.

Smart Contract code
The code for the NFT smart contract can be found in the Zero to Hero NFT tutorial's  GitHub repository, under the main branch.
The contract methods used in this application are as follows:

nft_mint: Function used to mint tokens.
check_token: Custom function created to check for the existence of a token. This helps to ensure one token per user.

Front-end
The front-end of the contract was implemented using create-near-app. React Bootstrap was used for the styling of the application.
To bootstrap your React front-end, run the following command on your terminal:
npx create-near-app --frontend react --contract rust
Then, simply import the contract files from the main branch, and you'll have the needed structure to run the application.
Start
Upon mounting the application's components, the app checks for the existence of a non-fungible token.

If no prior NFT has been minted, the mint button will be available for use.
Mint button
Here is the function behind the mint button. The meta data has been filled out for the user already:

token_id is set by the user's account id,
and the media link is hard-coded to a goteam-gif.gif hosted on IPFS.


After hitting the Mint NFT button the user will be able to check out the newly minted NFT at wallet.testnet.near.org, under the Wallet's Collectibles tab.
Final remarks
You can find the complete application repository on GitHub to clone and run.
In the configuration folder you can see that this smart contract has been deployed to nft-frontend-simple-mint.blockhead.testnet:

You can also check out the explorer link here to see how many individuals have been minting their own Go Team NFTs. Happy Minting!
tiplone and run this example from https://github.com/near-examples/nft-tutorial-frontend

### Minting NFTs

In this tutorial you'll learn how to easily create your own NFTs without doing any software development by using a readily-available smart contract and a decentralized storage solution like IPFS.
Overview
This article will guide you in setting up an NFT smart contract, and show you how to build, test and deploy your NFT contract on NEAR.
Once the contract is deployed, you'll learn how to mint non-fungible tokens from media files stored on IPFS and view them in your Wallet.
Prerequisites
To complete this tutorial successfully, you'll need:

Rust toolchain
A NEAR account
NEAR command-line interface (near-cli)

Wallet
To store your non-fungible tokens you'll need a NEAR Wallet.
If you don't have one yet, you can create one easily by following these instructions.

Tip: for this tutorial we'll use a testnet wallet account. The testnet network is free and there's no need to deposit funds.

Once you have your Wallet account, you can click on the Collectibles tab where all your NFTs will be listed:


IPFS
The InterPlanetary File System (IPFS) is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. IPFS uses content-addressing to uniquely identify each file in a global namespace connecting all computing devices.
Uploading the image
To upload the NFT image, you should use a decentralized storage provider such as IPFS.
noteThis example uses IPFS, but you could use a different solution like Filecoin, Arweave, or a regular centralized Web2 hosting.

Once you have uploaded your file to IPFS, you'll get a unique CID for your content, and a URL like:
https://bafyreiabag3ztnhe5pg7js4bj6sxuvkz3sdf76cjvcuqjoidvnfjz7vwrq.ipfs.dweb.link/
Non-fungible Token contract
This repository includes an example implementation of a non-fungible token contract which uses near-contract-standards and simulation tests.
Clone the NFT repository
In your terminal run the following command to clone the NFT repo:
git clone https://github.com/near-examples/NFT
Explore the smart contract
The source code for this contract can be found in nft/src/lib.rs. This contract contains logic which follows the NEP-171 standard (NEAR Enhancement Proposal) and the implementation of this standard which can be found here.
At first, the code can be a bit overwhelming, but if we only consider the aspects involved with minting, we can break it down into 2 main categories - the contract struct and the minting process.
Contract Struct
The contract keeps track of two pieces of information - tokens and metadata. For the purpose of this tutorial we will only deal with the tokens field.
#[near(contract_state)]
#[derive(PanicOnDefault)]
pub struct Contract {
    tokens: NonFungibleToken,
    metadata: LazyOption<NFTContractMetadata>,
}
The tokens are of type NonFungibleToken which come from the core standards. There are several fields that make up the struct but for the purpose of this tutorial, we'll only be concerned with the owner_by_id field. This keeps track of the owner for any given token.
pub struct NonFungibleToken {
    // owner of contract
    pub owner_
    // keeps track of the owner for any given token ID.
    pub owner_by_
    ...
}
Now that we've explored behind the scenes and where the data is being kept, let's move to the minting functionality.
Minting
In order for a token to be minted you will need to call the nft_mint function. There are three arguments that are passed to this function:

token_id
receiver_id
token_metadata

This function executes self.tokens.mint which calls the mint function in the core standards creating a record of the token with the owner being receiver_id.
#[payable]
pub fn nft_mint(
    &mut self,
    token_    receiver_    token_metadata: TokenMetadata,
) -> Token {
    self.tokens.mint(token_id, receiver_id, Some(token_metadata))
}
This creates that record by inserting the token into the owner_by_id data structure that we mentioned in the previous section.
self.owner_by_id.insert(&token_id, &owner_id);
Building the contract
To build your contract run the following command in your terminal which builds your contract using Rust's cargo.
./scripts/build.sh
This will generate WASM binaries into your res/ directory. This WASM file is the smart contract we'll be deploying onto the NEAR blockchain.

Tip: If you run into errors make sure you have Rust installed and are in the root directory of the NFT example.

Testing the contract
Written in the smart contract there are pre-written tests that you can run. Run the following command in your terminal to perform these simple tests to verify that your contract code is working.
cargo test -- --nocapture

Note: the more complex simulation tests aren't performed with this command but you can find them in tests/sim.

Using the NFT contract
Now that you have successfully built and tested the NFT smart contract, you're ready to deploy it
and start using it mint your NFTs.
Deploying the contract
This smart contract will be deployed to your NEAR account. Because NEAR allows the ability to upgrade contracts on the same account, initialization functions must be cleared.

Note: If you'd like to run this example on a NEAR account that has had prior contracts deployed, please use the near-cli command near delete and then recreate it in Wallet. To create (or recreate) an account, please follow the directions in Test Wallet or (NEAR Wallet if we're using mainnet).

Log in to your newly created account with near-cli by running the following command in your terminal.


  

  ```bash
  near login --networkId testnet
  ```
  

  

  ```bash
  near account import-account using-web-wallet network-config testnet
  ```
  

To make this tutorial easier to copy/paste, we're going to set an environment variable for your account ID. In the command below, replace YOUR_ACCOUNT_NAME with the account name you just logged in with including the .testnet (or .near for mainnet):
export ID=YOUR_ACCOUNT_NAME
Test that the environment variable is set correctly by running:
echo $ID
Verify that the correct account ID is printed in the terminal. If everything looks correct you can now deploy your contract.
In the root of your NFT project run the following command to deploy your smart contract.
near deploy $ID res/non_fungible_token.wasm

Example response: 


```bash
Starting deployment. Account Transaction Id E1AoeTjvuNbDDdNS9SqKfoWiZT95keFrRUmsB65fVZ52
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/E1AoeTjvuNbDDdNS9SqKfoWiZT95keFrRUmsB65fVZ52
Done deploying to ex-1.testnet
```



Minting your NFTs
A smart contract can define an initialization method that can be used to set the contract's initial state.
In our case, we need to initialize the NFT contract before usage. For now, we'll initialize it with the default metadata.

Note: each account has a data area called storage, which is persistent between function calls and transactions.
For example, when you initialize a contract, the initial state is saved in the persistent storage.


  

  ```bash
  near call $ID new_default_meta '{"owner_id": "'$ID'"}' --accountId $ID
  ```
  

  

    ```bash
    near contract call-function as-transaction $ID new_default_meta json-args '{"owner_id": "'$ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $ID network-config testnet sign-with-keychain send
    ```
  


Tip: you can find more info about the NFT metadata at nomicon.io.

You can then view the metadata by running the following view call:

  

  ```bash
  near view $ID nft_metadata
  ```
  

  

    ```bash
    near contract call-function as-read-only $ID nft_metadata json-args '{}' network-config testnet now
    ```
  


Example response: 


```json
{
  "spec": "nft-1.0.0",
  "name": "Example NEAR non-fungible token",
  "symbol": "EXAMPLE",
  "icon": "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 288 288'%3E%3Cg id='l' data-name='l'%3E%3Cpath d='M187.58,79.81l-30.1,44.69a3.2,3.2,0,0,0,4.75,4.2L191.86,103a1.2,1.2,0,0,1,2,.91v80.46a1.2,1.2,0,0,1-2.12.77L102.18,77.93A15.35,15.35,0,0,0,90.47,72.5H87.34A15.34,15.34,0,0,0,72,87.84V201.16A15.34,15.34,0,0,0,87.34,216.5h0a15.35,15.35,0,0,0,13.08-7.31l30.1-44.69a3.2,3.2,0,0,0-4.75-4.2L96.14,186a1.2,1.2,0,0,1-2-.91V104.61a1.2,1.2,0,0,1,2.12-.77l89.55,107.23a15.35,15.35,0,0,0,11.71,5.43h3.13A15.34,15.34,0,0,0,216,201.16V87.84A15.34,15.34,0,0,0,200.66,72.5h0A15.35,15.35,0,0,0,187.58,79.81Z'/%3E%3C/g%3E%3C/svg%3E",
  "base_uri": null,
  "reference": null,
  "reference_hash": null
}
```



Now let's mint our first token! The following command will mint one copy of your NFT. Replace the media url with the one you uploaded to IPFS earlier:

  

  ```bash
  near call $ID nft_mint '{"token_id": "0", "receiver_id": "'$ID'", "token_metadata": { "title": "Some Art", "description": "My NFT media", "media": "https://bafkreiabag3ztnhe5pg7js4bj6sxuvkz3sdf76cjvcuqjoidvnfjz7vwrq.ipfs.dweb.link/", "copies": 1}}' --accountId $ID --deposit 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $ID nft_mint json-args '{"token_id": "0", "receiver_id": "'$ID'", "token_metadata": { "title": "Some Art", "description": "My NFT media", "media": "https://bafkreiabag3ztnhe5pg7js4bj6sxuvkz3sdf76cjvcuqjoidvnfjz7vwrq.ipfs.dweb.link/", "copies": 1}}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $ID network-config testnet sign-with-keychain send
    ```
  


Example response: 


```json
{
  "token_id": "0",
  "owner_id": "dev-xxxxxx-xxxxxxx",
  "metadata": {
    "title": "Some Art",
    "description": "My NFT media",
    "media": "https://bafkreiabag3ztnhe5pg7js4bj6sxuvkz3sdf76cjvcuqjoidvnfjz7vwrq.ipfs.dweb.link/",
    "media_hash": null,
    "copies": 1,
    "issued_at": null,
    "expires_at": null,
    "starts_at": null,
    "updated_at": null,
    "extra": null,
    "reference": null,
    "reference_hash": null
  },
  "approved_account_ids": {}
}
```



To view tokens owned by an account you can call the NFT contract with the following near-cli command:

  

  ```bash
  near view $ID nft_tokens_for_owner '{"account_id": "'$ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $ID nft_tokens_for_owner json-args '{"account_id": "'$ID'"}' network-config testnet now
    ```
  


Example response: 


```json
[
  {
    "token_id": "0",
    "owner_id": "dev-xxxxxx-xxxxxxx",
    "metadata": {
      "title": "Some Art",
      "description": "My NFT media",
      "media": "https://bafkreiabag3ztnhe5pg7js4bj6sxuvkz3sdf76cjvcuqjoidvnfjz7vwrq.ipfs.dweb.link/",
      "media_hash": null,
      "copies": 1,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
```





Tip: after you mint your first non-fungible token, you can view it in your Wallet:



Congratulations! You just minted your first NFT token on the NEAR blockchain! 🎉
Final remarks
This basic example illustrates all the required steps to deploy an NFT smart contract, store media files on IPFS,
and start minting your own non-fungible tokens.
Now that you're familiar with the process, you can check out our NFT Example and learn more about the smart contract code and how you can transfer minted tokens to other accounts.
Finally, if you are new to Rust and want to dive into smart contract development, our Quick-start guide is a great place to start.
Happy minting! 🪙
Blockcraft - a Practical Extension
If you'd like to learn how to use Minecraft to mint NFTs and copy/paste builds across different worlds while storing all your data on-chain, be sure to check out our Minecraft tutorial
Versioning for this article
At the time of this writing, this example works with the following versions:

cargo: cargo 1.54.0 (5ae8d74b3 2021-06-22)
rustc: rustc 1.54.0 (a178d0322 2021-07-26)
near-cli: 2.1.1

### Create NFTs in Minecraft

In this tutorial you'll learn how to take your custom Minecraft creations and mint the schematics into NFTs on the NEAR blockchain!

Overview
This tutorial will run you through minting Minecraft structures of any size onto the NEAR blockchain. It will allow you to copy and paste the designs into your own worlds. For this, we will be using WorldEdit to download and read the schematics and we'll put them on-chain using IPFS.
Prerequisites
infoIt is recommended that you first complete the introductory **[minting NFTs tutorial](/tutorials/nfts/minting-nfts)**

To complete this tutorial successfully, you'll need:

A Minecraft account
WorldEdit installed
A NEAR account
NEAR command-line interface (near-cli)

Creating a Schematic
In this section, we'll be creating the Minecraft schematic to put on chain.
Setup

Once you have WorldEdit installed and Minecraft loaded up, let's check if WorldEdit is working properly by running:

//pos1
If WorldEdit is properly installed, it should output First position set to (X, Y, Z). where X, Y, and Z are coordinates.
For this tutorial, we will be minting a small village house. To follow along, choose any structure that you'd like to mint as shown below:

You'll then want to choose the boundaries of the structure that you'd like to copy. We will turn these into schematics which will be placed on chain for you or others to download and paste in your own worlds.

To do this, we'll need to outline the boundaries of the build using WorldEdit. Stand in the bottom left corner of your build and run:

//pos1

You can then move to the top right corner and run:

//pos2
Setting these two positions has now created a cube around your build.

We can now copy the contents of that build by running:

//copy
The output should look something like this:

infoTIP
Remember to note the position of your player when copying. If you copy the build and lets say you're standing on the roof, when you paste the build it will paste the build in a way that will result in you standing on the roof.

Sanity Check
We can check and see if our build is fine by pasting what we just copied elsewhere in our world.

Go to a location that you would like to paste the build and run:

//paste
In the example below, we pasted the village house floating above a coral reef biome. You should also see a response notifying you that the clipboard has been pasted. (See example below)

Creating the Schematics File
When you're happy with the build you've just copied and pasted, it's time to create the schematic file that we'll mint into an NFT. To do this we'll run a WorldEdit command that will save the schematic file on our local machine.

To do this, run the command schematic save FILE_NAME replacing FILE_NAME with a name of your choosing.

This will save the file to your Minecraft folder with under minecraft/config/worldedit/schematics witha .schem extension.

Now test your file by loading the schematic we just saved using schematic load FILE_NAME.

This will load the schematic to our clipboard and we're free to paste it in our world.
Minting the Schematic
In this section, we'll mint the schematics file, we've just created and put it on the blockchain using IPFS and web3.storage. In order to proceed, you need to locate the FILE_NAME.schem we created in the last section. This file can be found in your Minecraft folder under minecraft/config/worldedit/schematics. The location of your minecraft folder differs depending on your OS.
Uploading the schematic
To upload the schematic, we are going to use the free web3.storage service built for storing off-chain data.
Web3.storage offers free decentralized storage and bandwidth on IPFS and Filecoin.
Steps


Register an account and log in to web3.storage either via email or your GitHub.


Go to the Files section, and click on the Upload more Files button.



Once you have uploaded your file, you'll get a unique CID for your content, and a URL similar to:
https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/


infoSee the [web3.storage docs](https://docs.web3.storage/) for information on uploading multiple files and available API endpoints.

Interacting With the Contract
NEAR has already deployed a contract to the account nft.examples.testnet which allows users to freely mint tokens. This is the account we'll be interacting with to mint our NFTs. Alternatively, if you've deployed a contract when following the original tutorial, you can use that as well.
infoWe'll be using the IPFS link we got in step three of the uploading process above as the media value when calling `nft_mint`.


Run the following command and replace the receiver_id field and the --accountId flag with the account ID you're logged into with NEAR CLI:


  

  ```bash
  near call nft.examples.testnet nft_mint '{"token_id": "my-token-unique-id", "receiver_id": "YOUR_ACCOUNT", "metadata": { "title": "YOUR NFT TITLE", "description": "YOUR NFT DESCRIPTION", "media": "https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/", "copies": 1}}' --accountId YOUR_ACCOUNT --deposit 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction nft.examples.testnet nft_mint json-args '{"token_id": "my-token-unique-id", "receiver_id": "YOUR_ACCOUNT", "metadata": { "title": "YOUR NFT TITLE", "description": "YOUR NFT DESCRIPTION", "media": "https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/", "copies": 1}}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as YOUR_ACCOUNT network-config testnet sign-with-keychain send
    ```
  


Be sure to replace the title, description and media URL with your own.


Example response: 


```json
{
  "token_id": "0",
  "owner_id": "YOUR_ACCOUNT",
  "metadata": {
    "title": "My awesome Minecraft NFT",
    "description": "Custom log cabin",
    "media": "https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/",
    "media_hash": null,
    "copies": 1,
    "issued_at": null,
    "expires_at": null,
    "starts_at": null,
    "updated_at": null,
    "extra": null,
    "reference": null,
    "reference_hash": null
  },
  "approved_account_ids": {}
}
```




To view tokens owned by an account on the example-nft contract, you can call the contract with the following near-cli command:


  

  ```bash
  near view nft.examples.testnet nft_tokens_for_owner '{"account_id": "YOUR_ACCOUNT"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only nft.examples.testnet nft_tokens_for_owner json-args '{"account_id": "YOUR_ACCOUNT"}' network-config testnet now
    ```
  


Example response: 


```json
[
  {
    "token_id": "0",
    "owner_id": "YOUR_ACCOUNT",
    "metadata": {
      "title": "Some Art",
      "description": "My NFT media",
      "media": "https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/",
      "media_hash": null,
      "copies": 1,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
```



Using the Village Schematic
Now that you've uploaded your schematic to the blockchain, all someone would need to do to paste it in their own world would be to download the *.schem file associated with the IPFS link we minted the NFT with and place it in their schematics folder.
As a test, we've minted an NFT that contains the village schematic we've been working with so that you can download it and paste it in your world.
Getting the Schematics File
The first thing you'll need to do is view the metadata for the token we've minted that contains the IPFS link to the village schematic. We've minted a token with the ID village-schematic under the account village-schematic.testnet.

To get the media link, run the following command:


  

  ```bash
  near view nft.examples.testnet nft_tokens_for_owner '{"account_id": "village-schematic.testnet"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only nft.examples.testnet nft_tokens_for_owner json-args '{"account_id": "village-schematic.testnet"}' network-config testnet now
    ```
  


Expected response: 


```bash
[
  {
    token_    owner_    metadata: {
       'Village Schematic',
      description: 'Blockcraft Village Schematic Tutorial NFT',
      media: 'https://bafybeidadhfilezx23dcdaueo3bjuafqeehokw33vyepkjtppigorrhbpy.ipfs.dweb.link/',
      media_hash: null,
      copies: 1,
      issued_at: null,
      expires_at: null,
      starts_at: null,
      updated_at: null,
      extra: null,
      reference: null,
      reference_hash: null
    },
    approved_account_ids: {}
  }
]
```




You can then take the media link and paste it into your browser. It should send you to a page that looks similar to this:



If you click on the file called village-house.schem, it will download the file.
You can then copy the schematics file and paste it into your minecraft/config/worldedit/schematics folder.

Loading the Schematics File in Minecraft

After you've pasted the schematics file into the minecraft/config/worldedit/schematics folder, you can then load the schematic into your clipboard by running the following command in your minecraft world:

//schematics load village-house

You can now paste the file anywhere in your world by simply using the //paste command and voila! You should see something similar to this:


Congratulations! You've just learned how to mint a Mincraft schematic NFT and load it into your world!
Versioning for this article
At the time of this writing, this example works with the following versions:

near-cli: 2.1.1

### Customizing the NFT Contract

In this tutorial, you'll learn how to take the existing NFT contract you've been working with and modify it to meet some of the most common needs in the ecosystem. This includes:

Lazy Minting NFTs
Creating Collections
Restricting Minting Access
Highly Optimizing Storage
Hacking Enumeration Methods


Introduction
Now that you have a deeper understanding of basic NFT smart contracts, we can start to get creative and implement more unique features. The basic contract works really well for simple use-cases but as you begin to explore the potential of NFTs, you can use it as a foundation to build upon.
A fun analogy would be that you now have a standard muffin recipe and it's now up to you to decide how to alter it to create your own delicious varieties, may I suggest blueberry perhaps.
Below we've created a few of these new varieties by showing potential solutions to the problems outlined above. As we demonstrate how to customize the basic NFT contract, we hope it activates your ingenuity thus introducing you to what's possible and helping you discover the true potential of NFTs. 💪

NFT Collections and Series
NFT Collections help solve two common problems when dealing with the basic NFT contract:

Storing repeated data.
Organizing data and code.

The concept of a collection in the NFT space has a very loose meaning and can be interpreted in many different ways. In our case, we'll define a collection as a set of tokens that share similar metadata. For example, you could create a painting and want 100 identical copies to be put for sale. In this case, all one hundred pieces would be part of the same collection. Each piece would have the same artist, title, description, media etc.
One of the biggest problems with the basic NFT contract is that you store similar data many times. If you mint NFTs, the contract will store the metadata individually for every single token ID. We can fix this by introducing the idea of NFT series, or NFT collection.
A series can be thought of as a bucket of token IDs that all share similar information. This information is specified when the series is created and can be the metadata, royalties, price etc. Rather than storing this information for every token ID, you can simply store it once in the series and then associate token IDs with their respective buckets.

Restricted Access
Currently, the NFT contract allows anyone to mint NFTs. While this works well for some projects, the vast majority of dApps and creators want to restrict who can create NFTs on the contract. This is why you'll introduce an allowlist functionality for both series and for NFTs. You'll have two data structures customizable by the contract owner:

Approved Minters
Approved Creators

If you're an approved minter, you can freely mint NFTs for any given series. You cannot, however, create new series.
On the other hand, you can also be an approved creator. This allows you to define new series that NFTs can be minted from. It's important to note that if you're an approved creator, you're not automatically an approved minter as well. Each of these permissions need to be given by the owner of the contract and they can be revoked at any time.

Lazy Minting
Lazy minting allows users to mint on demand. Rather than minting all the NFTs and spending $NEAR on storage, you can instead mint the tokens when they are purchased. This helps to avoid burning unnecessary Gas and saves on storage for when not all the NFTs are purchased. Let's look at a common scenario to help solidify your understanding:
Benji has created an amazing digital painting of the famous Go Team gif. He wants to sell 1000 copies of it for 1 $NEAR each. Using the traditional approach, he would have to mint each copy individually and pay for the storage himself. He would then need to either find or deploy a marketplace contract and pay for the storage to put 1000 copies up for sale. He would need to burn Gas putting each token ID up for sale 1 by 1.
After that, people would purchase the NFTs, and there would be no guarantee that all or even any would be sold. There's a real possibility that nobody buys a single piece of his artwork, and Benji spent all that time, effort and money on nothing.
Lazy minting would allow the NFTs to be automatically minted on-demand. Rather than having to purchase NFTs from a marketplace, Benji could specify a price on the NFT contract and a user could directly call the nft_mint function whereby the funds would be distributed to Benji's account directly.
Using this model, NFTs would only be minted when they're actually purchased and there wouldn't be any upfront fee that Benji would need to pay in order to mint all 1000 NFTs. In addition, it removes the need to have a separate marketplace contract.
With this example laid out, a high level overview of lazy minting is that it gives the ability for someone to mint "on-demand" - they're lazily minting the NFTs instead of having to mint everything up-front even if they're unsure if there's any demand for the NFTs. With this model, you don't have to waste Gas or storage fees because you're only ever minting when someone actually purchases the artwork.

New Contract File Structure
Let's now take a look at how we've implemented solutions to the issues we've discussed so far.
In your locally cloned example of the nft-tutorial check out the main branch and be sure to pull the most recent version.
git checkout main && git pull
You'll notice that there's a folder at the root of the project called nft-series. This is where the smart contract code lives. If you open the src folder, it should look similar to the following:
src
├── approval.rs
├── enumeration.rs
├── events.rs
├── internal.rs
├── lib.rs
├── metadata.rs
├── nft_core.rs
├── owner.rs
├── royalty.rs
├── series.rs

Differences
You'll notice that most of this code is the same, however, there are a few differences between this contract and the basic NFT contract.
Main Library File
Starting with lib.rs, you'll notice that the contract struct has been modified to now store the following information.
pub owner_+ pub approved_minters: LookupSet<AccountId>,
+ pub approved_creators: LookupSet<AccountId>,
pub tokens_per_owner: LookupMap<AccountId, UnorderedSet<TokenId>>,
pub tokens_by_- pub token_metadata_by_+ pub series_by_pub metadata: LazyOption<NFTContractMetadata>,
As you can see, we've replaced token_metadata_by_id with series_by_id and added two lookup sets:

series_by_id: Map a series ID (u64) to its Series object.
approved_minters: Keeps track of accounts that can call the nft_mint function.
approved_creators: Keeps track of accounts that can create new series.


Series Object
In addition, we're now keeping track of a new object called a Series.
pub struct Series {
    // Metadata including title, num copies etc.. that all tokens will derive from
    metadata: TokenMetadata,
    // Royalty used for all tokens in the collection
    royalty: Option<HashMap<AccountId, u32>>,
    // Set of tokens in the collection
    tokens: UnorderedSet<TokenId>,
    // What is the price of each token in this series? If this is specified, when minting,
    // Users will need to attach enough $NEAR to cover the price.
    price: Option<Balance>,
    // Owner of the collection
    owner_}
This object stores information that each token will inherit from. This includes:

The metadata.
The royalties.
The price.


:::caution
If a price is specified, there will be no restriction on who can mint tokens in the series. In addition, if the copies field is specified in the metadata, only that number of NFTs can be minted. If the field is omitted, an unlimited amount of tokens can be minted.
::

We've also added a field tokens which keeps track of all the token IDs that have been minted for this series. This allows us to deal with the potential copies cap by checking the length of the set. It also allows us to paginate through all the tokens in the series.

Creating Series
series.rs is a new file that replaces the old minting logic. This file has been created to combine both the series creation and minting logic into one.

The function takes in a series ID in the form of a u64, the metadata, royalties, and the price for tokens in the series. It will then create the Series object and insert it into the contract's series_by_id data structure. It's important to note that the caller must be an approved creator and they must attach enough $NEAR to cover storage costs.

Minting NFTs
Next, we'll look at the minting function. If you remember from before, this used to take the following parameters:

Token ID
Metadata
Receiver ID
Perpetual Royalties

With the new and improved minting function, these parameters have been changed to just two:

The series ID
The receiver ID.

The mint function might look complicated at first but let's break it down to understand what's happening. The first thing it does is get the series object from the specified series ID. From there, it will check that the number of copies won't be exceeded if one is specified in the metadata.
It will then store the token information on the contract as explained in the minting section of the tutorial and map the token ID to the series. Once this is finished, a mint log will be emitted and it will ensure that enough deposit has been attached to the call. This amount differs based on whether or not the series has a price.
Required Deposit
As we went over in the minting section of this tutorial, all information stored on the contract costs $NEAR. When minting, there is a required deposit to pay for this storage. For this contract, a series price can also be specified by the owner when the series is created. This price will be used for all NFTs in the series when they are minted. If the price is specified, the deposit must cover both the storage as well as the price.
If a price is specified and the user attaches more deposit than what is necessary, the excess is sent to the series owner. There is also no restriction on who can mint tokens for series that have a price. The caller does not need to be an approved minter.
If no price was specified in the series and the user attaches more deposit than what is necessary, the excess is refunded to them. In addition, the contract makes sure that the caller is an approved minter in this case.
infoNotice how the token ID isn't required? This is because the token ID is automatically generated when minting. The ID stored on the contract is `${series_id}:${token_id}` where the token ID is a nonce that increases each time a new token is minted in a series. This not only reduces the amount of information stored on the contract but it also acts as a way to check the specific edition number.



View Functions
Now that we've introduced the idea of series, more view functions have also been added.
infoNotice how we've also created a new struct `JsonSeries` instead of returning the regular `Series` struct. This is because the `Series` struct contains an `UnorderedSet` which cannot be serialized.

The common practice is to return everything **except** the `UnorderedSet` in a separate struct and then have entirely different methods for accessing the data from the `UnorderedSet` itself.



The view functions are listed below.

get_series_total_supply: Get the total number of series currently on the contract.

Arguments: None.




get_series: Paginate through all the series in the contract and return a vector of JsonSeries objects.

Arguments: from_index: String | null, limit: number | null.





get_series_details: Get the JsonSeries details for a specific series.

Arguments: `




nft_supply_for_series: View the total number of NFTs minted for a specific series.

Arguments: `




nft_tokens_for_series: Paginate through all NFTs for a specific series and return a vector of JsonToken objects.

Arguments: `




infoNotice how with every pagination function, we've also included a getter to view the total supply. This is so that you can use the `from_index` and `limit` parameters of the pagination functions in conjunction with the total supply so you know where to end your pagination.


Modifying View Calls for Optimizations
Storing information on-chain can be very expensive. As you level up in your smart contract development skills, one area to look into is reducing the amount of information stored. View calls are a perfect example of this optimization.
For example, if you wanted to relay the edition number for a given NFT in its title, you don't necessarily need to store this on-chain for every token. Instead, you could modify the view functions to manually append this information to the title before returning it.
To do this, here's a way of modifying the nft_token function as it's central to all enumeration methods.

For example if a token had a title "My Amazing Go Team Gif" and the NFT was edition 42, the new title returned would be "My Amazing Go Team Gif - 42". If the NFT didn't have a title in the metadata, the series and edition number would be returned in the form of Series {} : Edition {}.
While this is a small optimization, this idea is extremely powerful as you can potentially save on a ton of storage. As an example: most of the time NFTs don't utilize the following fields in their metadata.

issued_at
expires_at
starts_at
updated_at

As an optimization, you could change the token metadata that's stored on the contract to not include these fields but then when returning the information in nft_token, you could simply add them in as null values.

Owner File
The last file we'll look at is the owner file found at owner.rs. This file simply contains all the functions for getting and setting approved creators and approved minters which can only be called by the contract owner.
infoThere are some other smaller changes made to the contract that you can check out if you'd like. The most notable are:
- The `Token` and `JsonToken` objects have been [changed](https://github.com/near-examples/nft-tutorial/blob/main/nft-series/src/metadata.rs#L40) to reflect the new series IDs.
- All references to `token_metadata_by_id` have been [changed](https://github.com/near-examples/nft-tutorial/blob/main/nft-series/src/enumeration.rs#L23) to `tokens_by_id`
- Royalty functions [now](https://github.com/near-examples/nft-tutorial/blob/main/nft-series/src/royalty.rs#L43) calculate the payout objects by using the series' royalties rather than the token's royalties.


Building the Contract
Now that you hopefully have a good understanding of the contract, let's get started building it. Run the following build command to compile the contract to wasm.
cargo near build

Deployment and Initialization
Next, you'll deploy this contract to the network.

  

  ```bash
  export NFT_CONTRACT_ID=
  near create-account $NFT_CONTRACT_ID --useFaucet
  ```
  

  

  ```bash
  export NFT_CONTRACT_ID=
  near account create-account sponsor-by-faucet-service $NFT_CONTRACT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Check if this worked correctly by echoing the environment variable.
echo $NFT_CONTRACT_ID
This should return your <accountId>. The next step is to initialize the contract with some default metadata.
cargo near deploy $NFT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
If you now query for the metadata of the contract, it should return our default metadata.

  

  ```bash
  near view $NFT_CONTRACT_ID nft_metadata '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_metadata json-args {} network-config testnet now
  ```
  


Creating The Series
The next step is to create two different series. One will have a price for lazy minting and the other will simply be a basic series with no price. The first step is to create an owner sub-account that you can use to create both series

  

  ```bash
  export SERIES_OWNER=owner.$NFT_CONTRACT_ID

  near create-account $SERIES_OWNER --use-account $NFT_CONTRACT_ID --initial-balance 3 --network-id testnet
  ```
  

  

  ```bash
  export SERIES_OWNER=owner.$NFT_CONTRACT_ID

  near account create-account fund-myself $SERIES_OWNER '3 NEAR' autogenerate-new-keypair save-to-keychain sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Basic Series
You'll now need to create the simple series with no price and no royalties. If you try to run the following command before adding the owner account as an approved creator, the contract should throw an error.

  

  ```bash
  near call $NFT_CONTRACT_ID create_series '{"id": 1, "metadata": {"title": "SERIES!", "description": "testing out the new series contract", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}}' --gas 100000000000000 --deposit 1 --accountId $SERIES_OWNER --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID create_series json-args '{"id": 1, "metadata": {"title": "SERIES!", "description": "testing out the new series contract", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}}' prepaid-gas '100.0 Tgas' attached-deposit '1 NEAR' sign-as $SERIES_OWNER network-config testnet sign-with-keychain send
  ```
  

The expected output is an error thrown: ExecutionError: 'Smart contract panicked: only approved creators can add a type. If you now add the series owner as a creator, it should work.

  

  ```bash
  near call $NFT_CONTRACT_ID add_approved_creator '{"account_id": "'$SERIES_OWNER'"}' --gas 100000000000000 --accountId $SERIES_OWNER --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID add_approved_creator json-args '{"account_id": "'$SERIES_OWNER'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  


  

  ```bash
  near call $NFT_CONTRACT_ID create_series '{"id": 1, "metadata": {"title": "SERIES!", "description": "testing out the new series contract", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}}' --gas 100000000000000 --deposit 1 --accountId $SERIES_OWNER --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID create_series json-args '{"id": 1, "metadata": {"title": "SERIES!", "description": "testing out the new series contract", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}}' prepaid-gas '100.0 Tgas' attached-deposit '1 NEAR' sign-as $SERIES_OWNER network-config testnet sign-with-keychain send
  ```
  

If you now query for the series information, it should work!

  

  ```bash
  near view $NFT_CONTRACT_ID get_series '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID get_series json-args {} network-config testnet now
  ```
  

Which should return something similar to:
[
  {
    series_    metadata: {
       'SERIES!',
      description: 'testing out the new series contract',
      media: 'https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif',
      media_hash: null,
      copies: null,
      issued_at: null,
      expires_at: null,
      starts_at: null,
      updated_at: null,
      extra: null,
      reference: null,
      reference_hash: null
    },
    royalty: null,
    owner_  }
]

Series With a Price
Now that you've created the first, simple series, let's create the second one that has a price of 1 $NEAR associated with it.

  

  ```bash
  near call $NFT_CONTRACT_ID create_series '{"id": 2, "metadata": {"title": "COMPLEX SERIES!", "description": "testing out the new contract with a complex series", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "price": "500000000000000000000000"}' --gas 100000000000000 --deposit 1 --accountId $SERIES_OWNER --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID create_series json-args '{"id": 2, "metadata": {"title": "COMPLEX SERIES!", "description": "testing out the new contract with a complex series", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "price": "500000000000000000000000"}' prepaid-gas '100.0 Tgas' attached-deposit '1 NEAR' sign-as $SERIES_OWNER network-config testnet sign-with-keychain send
  ```
  

If you now paginate through the series again, you should see both appear.

  

  ```bash
  near view $NFT_CONTRACT_ID get_series '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID get_series json-args {} network-config testnet now
  ```
  


Which has
[
  {
    series_    metadata: {
       'SERIES!',
      description: 'testing out the new series contract',
      media: 'https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif',
      media_hash: null,
      copies: null,
      issued_at: null,
      expires_at: null,
      starts_at: null,
      updated_at: null,
      extra: null,
      reference: null,
      reference_hash: null
    },
    royalty: null,
    owner_  },
  {
    series_    metadata: {
       'COMPLEX SERIES!',
      description: 'testing out the new contract with a complex series',
      media: 'https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif',
      media_hash: null,
      copies: null,
      issued_at: null,
      expires_at: null,
      starts_at: null,
      updated_at: null,
      extra: null,
      reference: null,
      reference_hash: null
    },
    royalty: null,
    owner_  }
]

Minting NFTs
Now that you have both series created, it's time to now mint some NFTs. You can either login with an existing NEAR wallet using near login or you can create a sub-account of the NFT contract. In our case, we'll use a sub-account.

  

  ```bash
  export BUYER_ID=buyer.$NFT_CONTRACT_ID

  near create-account $BUYER_ID --use-account $NFT_CONTRACT_ID --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  export BUYER_ID=buyer.$NFT_CONTRACT_ID

  near account create-account fund-myself $BUYER_ID '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Lazy Minting
The first workflow you'll test out is lazy minting NFTs. If you remember, the second series has a price associated with it of 1 $NEAR. This means that there are no minting restrictions and anyone can try and purchase the NFT. Let's try it out.
In order to view the NFT in the NEAR wallet, you'll want the receiver_id to be an account you have currently available in the wallet site. Let's export it to an environment variable. Run the following command but replace YOUR_ACCOUNT_ID_HERE with your actual NEAR account ID.
export NFT_RECEIVER_ID=YOUR_ACCOUNT_ID_HERE
Now if you try and run the mint command but don't attach enough $NEAR, it should throw an error.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"id": "2", "receiver_id": "'$NFT_RECEIVER_ID'"}' --gas 100000000000000 --accountId $BUYER_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"id": "2", "receiver_id": "'$NFT_RECEIVER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
  ```
  

Run the command again but this time, attach 1.5 $NEAR.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"id": "2", "receiver_id": "'$NFT_RECEIVER_ID'"}' --gas 100000000000000 --deposit 1.5 --accountId $BUYER_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"id": "2", "receiver_id": "'$NFT_RECEIVER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '1.5 NEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
  ```
  

This should output the following logs.
Receipts: BrJLxCVmxLk3yNFVnwzpjZPDRhiCinNinLQwj9A7184P, 3UwUgdq7i1VpKyw3L5bmJvbUiqvFRvpi2w7TfqmnPGH6
    Log [nft_contract.testnet]: EVENT_JSON:{"standard":"nep171","version":"nft-1.0.0","event":"nft_mint","data":[{"owner_id":"benjiman.testnet","token_ids":["2:1"]}]}
Transaction Id FxWLFGuap7SFrUPLskVr7Uxxq8hpDtAG76AvshWppBVC
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/FxWLFGuap7SFrUPLskVr7Uxxq8hpDtAG76AvshWppBVC
''
If you check the explorer link, it should show that the owner received on the order of 0.59305 $NEAR.


Becoming an Approved Minter
If you try to mint the NFT for the simple series with no price, it should throw an error saying you're not an approved minter.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"id": "1", "receiver_id": "'$NFT_RECEIVER_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $BUYER_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"id": "1", "receiver_id": "'$NFT_RECEIVER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
  ```
  

Go ahead and run the following command to add the buyer account as an approved minter.

  

  ```bash
  near call $NFT_CONTRACT_ID add_approved_minter '{"account_id": "'$BUYER_ID'"}' --gas 100000000000000 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID add_approved_minter json-args '{"account_id": "'$BUYER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

If you now run the mint command again, it should work.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"id": "1", "receiver_id": "'$NFT_RECEIVER_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $BUYER_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"id": "1", "receiver_id": "'$NFT_RECEIVER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
  ```
  


Viewing the NFTs in the Wallet
Now that you've received both NFTs, they should show up in the NEAR wallet. Open the collectibles tab and search for the contract with the title NFT Series Contract and you should own two NFTs. One should be the complex series and the other should just be the simple version. Both should have - 1 appended to the end of the title because the NFTs are the first editions for each series.

Hurray! You've successfully deployed and tested the series contract! GO TEAM!.

Conclusion
In this tutorial, you learned how to take the basic NFT contract and iterate on it to create a complex and custom version to meet the needs of the community. You optimized the storage, introduced the idea of collections, created a lazy minting functionality, hacked the enumeration functions to save on storage, and created an allowlist functionality.
You then built the contract and deployed it on chain. Once it was on-chain, you initialized it and created two sets of series. One was complex with a price and the other was a regular series. You lazy minted an NFT and purchased it for 1.5 $NEAR and then added yourself as an approved minter. You then minted an NFT from the regular series and viewed them both in the NEAR wallet.
Thank you so much for going through this journey with us! I wish you all the best and am eager to see what sorts of neat and unique use-cases you can come up with. If you have any questions, feel free to ask on our Discord or any other social media channels we have. If you run into any issues or have feedback, feel free to use the Feedback button on the right.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### Marketplace

In this tutorial, you'll learn the basics of an NFT marketplace contract where you can buy and sell non-fungible tokens for $NEAR. In the previous tutorials, you went through and created a fully fledged NFT contract that incorporates all the standards found in the NFT standard.

Introduction
Throughout this tutorial, you'll learn how a marketplace contract could work on NEAR. This is meant to be an example as there is no canonical implementation. Feel free to branch off and modify this contract to meet your specific needs.
cd market-contract/
This folder contains both the actual contract code and dependencies as outlined below.
market-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
└── src
    ├── external.rs
    ├── internal.rs
    ├── lib.rs
    ├── nft_callbacks.rs
    ├── sale.rs
    └── sale_views.rs

Understanding the contract
At first, the contract can be quite overwhelming but if you strip away all the fluff and dig into the core functionalities, it's actually quite simple. This contract was designed for only one thing - to allow people to buy and sell NFTs for NEAR. This includes the support for paying royalties, updating the price of your sales, removing sales and paying for storage.
Let's go through the files and take note of some of the important functions and what they do.

lib.rs
This file outlines what information is stored on the contract as well as some other crucial functions that you'll learn about below.
Initialization function
The first function you'll look at is the initialization function. This takes an owner_id as the only parameter and will default all the storage collections to their default values.


Storage management model
Next, let's talk about the storage management model chosen for this contract. On the NFT contract, users attached $NEAR to the calls that needed storage paid for. For example, if someone was minting an NFT, they would need to attach x amount of NEAR to cover the cost of storing the data on the contract.
On this marketplace contract, however, the storage model is a bit different. Users will need to deposit $NEAR onto the marketplace to cover the storage costs. Whenever someone puts an NFT for sale, the marketplace needs to store that information which costs $NEAR. Users can either deposit as much NEAR as they want so that they never have to worry about storage again or they can deposit the minimum amount to cover 1 sale on an as-needed basis.
You might be thinking about the scenario when a sale is purchased. What happens to the storage that is now being released on the contract? This is why we've introduced a storage withdrawal function. This allows users to withdraw any excess storage that is not being used. Let's go through some scenarios to understand the logic. The required storage for 1 sale is 0.01 NEAR on the marketplace contract.
Scenario A

Benji wants to list his NFT on the marketplace but has never paid for storage.
He deposits exactly 0.01 NEAR using the storage_deposit method. This will cover 1 sale.
He lists his NFT on the marketplace and is now using up 1 out of his prepaid 1 sales and has no more storage left. If he were to call storage_withdraw, nothing would happen.
Dorian loves his NFT and quickly purchases it before anybody else can. This means that Benji's sale has now been taken down (since it was purchased) and Benji is using up 0 out of his prepaid 1 sales. In other words, he has an excess of 1 sale or 0.01 NEAR.
Benji can now call storage_withdraw and will be transferred his 0.01 NEAR back. On the contract's side, after withdrawing, he will have 0 sales paid for and will need to deposit storage before trying to list anymore NFTs.

Scenario B

Dorian owns one hundred beautiful NFTs and knows that he wants to list all of them.
To avoid having to call storage_deposit everytime he wants to list an NFT, he calls it once. Since Dorian is a baller, he attaches 10 NEAR which is enough to cover 1000 sales. Then he lists his 100 NFTs and now he has an excess of 9 NEAR or 900 sales.
Dorian needs the 9 NEAR for something else but doesn't want to take down his 100 listings. Since he has an excess of 9 NEAR, he can easily withdraw and still have his 100 listings. After calling storage_withdraw and being transferred 9 NEAR, he will have an excess of 0 sales.

With this behavior in mind, the following two functions outline the logic.


In this contract, the storage required for each sale is 0.01 NEAR but you can query that information using the storage_minimum_balance function. In addition, if you wanted to check how much storage a given account has paid, you can query the storage_balance_of function.
With that out of the way, it's time to move onto the sale.rs file where you'll look at how NFTs are put for sale.

sale.rs
This file is responsible for the internal marketplace logic.
Listing logic
In order to put an NFT on sale, a user should:

Approve the marketplace contract on an NFT token (by calling nft_approve method on the NFT contract)
Call the list_nft_for_sale method on the marketplace contract.

nft_approve
This method has to be called by the user to approve our marketplace, so it can transfer the NFT on behalf of the user. In our contract, we only need to implement the nft_on_approve method, which is called by the NFT contract when the user approves our contract.
In our case, we left it blank, but you could implement it to do some additional logic when the user approves your contract.

list_nft_for_sale
The list_nft_for_sale method lists an nft for sale, for this, it takes the id of the NFT contract (nft_contract_id), the token_id to know which token is listed, the approval_id, and the price in yoctoNEAR at which we want to sell the NFT.

The function first checks if the user has enough storage available, and makes two calls in parallel to the NFT contract. The first is to check if this marketplace contract is authorized to transfer the NFT. The second is to make sure that the caller (predecessor) is actually the owner of the NFT, otherwise, anyone could call this method to create fake listings. This second call is mostly a measure to avoid spam, since anyways, only the owner could approve the marketplace contract to transfer the NFT.
Both calls return their results to the process_listing function, which executes the logic to store the sale object on the contract.
process_listing
The process_listing function will receive if our marketplace is authorized to list the NFT on sale, and if this was requested by the NFTs owner. If both conditions are met, it will proceed to check if the user has enough storage, and store the sale object on the contract.


Sale object
It's important to understand what information the contract is storing for each sale object. Since the marketplace has many NFTs listed that come from different NFT contracts, simply storing the token ID would not be enough to distinguish between different NFTs. This is why you need to keep track of both the token ID and the contract by which the NFT came from. In addition, for each listing, the contract must keep track of the approval ID it was given to transfer the NFT. Finally, the owner and sale conditions are needed.


Removing sales
In order to remove a listing, the owner must call the remove_sale function and pass the NFT contract and token ID. Behind the scenes, this calls the internal_remove_sale function which you can find in the internal.rs file. This will assert one yoctoNEAR for security reasons.


Updating price
In order to update the list price of a token, the owner must call the update_price function and pass in the contract, token ID, and desired price. This will get the sale object, change the sale conditions, and insert it back. For security reasons, this function will assert one yoctoNEAR.


Purchasing NFTs
For purchasing NFTs, you must call the offer function. It takes an nft_contract_id and token_id as parameters. You must attach the correct amount of NEAR to the call in order to purchase. Behind the scenes, this will make sure your deposit is greater than the list price and call a private method process_purchase which will perform a cross-contract call to the NFT contract to invoke the nft_transfer_payout function. This will transfer the NFT using the approval management standard that you learned about and it will return the Payout object which includes royalties.
The marketplace will then call resolve_purchase where it will check for malicious payout objects and then if everything went well, it will pay the correct accounts.


sale_view.rs
The final file is sale_view.rs file. This is where some of the enumeration methods are outlined. It allows users to query for important information regarding sales.

Deployment and Initialization
Next, you'll deploy this contract to the network.

  

  ```bash
  export MARKETPLACE_CONTRACT_ID=
  near create-account $MARKETPLACE_CONTRACT_ID --useFaucet
  ```
  

  

  ```bash
  export MARKETPLACE_CONTRACT_ID=
  near account create-account sponsor-by-faucet-service $MARKETPLACE_CONTRACT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Using the build script, deploy the contract as you did in the previous tutorials:
cargo near deploy $MARKETPLACE_CONTRACT_ID with-init-call new json-args '{"owner_id": "'$MARKETPLACE_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

Minting and approving
Let's mint a new NFT token and approve a marketplace contract:

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"token_id": "token-1", "metadata": {"title": "My Non Fungible Team Token", "description": "The Team Most Certainly Goes :)", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"token_id": "token-1", "metadata": {"title": "My Non Fungible Team Token", "description": "The Team Most Certainly Goes :)", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  


  

  ```bash
  near call $NFT_CONTRACT_ID nft_approve '{"token_id": "token-1", "account_id": "'$MARKETPLACE_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_approve json-args '{"token_id": "token-1", "account_id": "'$MARKETPLACE_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  


Listing NFT on sale

  

  ```bash
  near call $MARKETPLACE_CONTRACT_ID list_nft_for_sale '{"nft_contract_id": "'$NFT_CONTRACT_ID'", "token_id": "token-1", "approval_id": 0, "msg": "{"sale_conditions": "1"}"}' --gas 300000000000000 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $MARKETPLACE_CONTRACT_ID list_nft_for_sale json-args '{"nft_contract_id": "'$NFT_CONTRACT_ID'", "token_id": "token-1", "approval_id": 0, "msg": "{"sale_conditions": "1"}"}' prepaid-gas '300.0 Tgas' attached-deposit '0 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  


Total supply
To query for the total supply of NFTs listed on the marketplace, you can call the get_supply_sales function. An example can be seen below.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_supply_sales '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_supply_sales json-args {} network-config testnet now
  ```
  



Total supply by owner
To query for the total supply of NFTs listed by a specific owner on the marketplace, you can call the get_supply_by_owner_id function. An example can be seen below.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_supply_by_owner_id '{"account_id": "'$NFT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_supply_by_owner_id json-args '{"account_id": "'$NFT_CONTRACT_ID'"}' network-config testnet now
  ```
  


Total supply by contract
To query for the total supply of NFTs that belong to a specific contract, you can call the get_supply_by_nft_contract_id function. An example can be seen below.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_supply_by_nft_contract_id '{"nft_contract_id": "'$NFT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_supply_by_nft_contract_id json-args '{"nft_contract_id": "'$NFT_CONTRACT_ID'"}' network-config testnet now
  ```
  


Query for listing information
To query for important information for a specific listing, you can call the get_sale function. This requires that you pass in the nft_contract_token. This is essentially the unique identifier for sales on the market contract as explained earlier. It consists of the NFT contract followed by a DELIMITER followed by the token ID. In this contract, the DELIMITER is simply a period: ..  An example of this query can be seen below.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_sale '{"nft_contract_token": "'$NFT_CONTRACT_ID'.token-1"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_sale json-args '{"nft_contract_token": "'$NFT_CONTRACT_ID'.token-1"}' network-config testnet now
  ```
  

In addition, you can query for paginated information about the listings for a given owner by calling the get_sales_by_owner_id function.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_sales_by_owner_id '{"account_id": "'$NFT_CONTRACT_ID'", "from_index": "0", "limit": 5}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_sales_by_owner_id json-args '{"account_id": "'$NFT_CONTRACT_ID'", "from_index": "0", "limit": 5}' network-config testnet now
  ```
  

Finally, you can query for paginated information about the listings that originate from a given NFT contract by calling the get_sales_by_nft_contract_id function.

  

  ```bash
  near view $MARKETPLACE_CONTRACT_ID get_sales_by_nft_contract_id '{"nft_contract_id": "'$NFT_CONTRACT_ID'", "from_index": "0", "limit": 5}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $MARKETPLACE_CONTRACT_ID get_sales_by_nft_contract_id json-args '{"nft_contract_id": "'$NFT_CONTRACT_ID'", "from_index": "0", "limit": 5}' network-config testnet now
  ```
  


Conclusion
In this tutorial, you learned about the basics of a marketplace contract and how it works. You went through the lib.rs file and learned about the initialization function in addition to the storage management model.
You went through the NFTs listing process. In addition, you went through some important functions needed after you've listed an NFT. This includes removing sales, updating the price, and purchasing NFTs.
Finally, you went through the enumeration methods found in the sale_view file. These allow you to query for important information found on the marketplace contract.
You should now have a solid understanding of NFTs and marketplaces on NEAR. Feel free to branch off and expand on these contracts to create whatever cool applications you'd like. In the next tutorial, you'll learn how to take the existing NFT contract and optimize it to allow for:

Lazy Minting
Creating Collections
Allowlisting functionalities
Optimized Storage Models

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### Events

In this tutorial, you'll learn about the events standard and how to implement it in your smart contract.

Understanding the use case
Have you ever wondered how the wallet knows which NFTs you own and how it can display them in the collectibles tab? Originally, an indexer used to listen for any functions calls starting with nft_ on your account. These contracts were then flagged on your account as likely NFT contracts.
When you navigated to your collectibles tab, the wallet would then query all those contracts for the list of NFTs you owned using the nft_tokens_for_owner function you saw in the enumeration tutorial.

The problem
This method of flagging contracts was not reliable as each NFT-driven application might have its own way of minting or transferring NFTs. In addition, it's common for apps to transfer or mint many tokens at a time using batch functions.

The solution
A standard was introduced so that smart contracts could emit an event anytime NFTs were transferred, minted, or burnt. This event was in the form of a log. No matter how a contract implemented the functionality, an indexer could now listen for those standardized logs.
As per the standard, you need to implement a logging functionality that gets fired when NFTs are transferred or minted. In this case, the contract doesn't support burning so you don't need to worry about that for now.
It's important to note the standard dictates that the log should begin with "EVENT_JSON:". The structure of your log should, however, always contain the 3 following things:

standard: the current name of the standard (e.g. nep171)
version: the version of the standard you're using (e.g. 1.0.0)
event: a list of events you're emitting.

The event interface differs based on whether you're recording transfers or mints. The interface for both events is outlined below.
Transfer events:

Optional - authorized_id: the account approved to transfer on behalf of the owner.
old_owner_id: the old owner of the NFT.
new_owner_id: the new owner that the NFT is being transferred to.
token_ids: a list of NFTs being transferred.
Optional - memo: an optional message to include with the event.

Minting events:

owner_id: the owner that the NFT is being minted to.
token_ids: a list of NFTs being transferred.
Optional - memo: an optional message to include with the event.


Examples
In order to solidify your understanding of the standard, let's walk through three scenarios and see what the logs should look like.
Scenario A - simple mint
In this scenario, Benji wants to mint an NFT to Mike with a token ID "team-token" and he doesn't include a message. The log should look as follows.
EVENT_JSON:{
  "standard": "nep171",
  "version": "1.0.0",
  "event": "nft_mint",
  "data": [
    {"owner_id": "mike.testnet", "token_ids": ["team-token"]}
  ]
}
Scenario B - batch mint
In this scenario, Benji wants to perform a batch mint. He will mint an NFT to Mike, Damian, Josh, and Dorian. Dorian, however, will get two NFTs. Each token ID will be "team-token" followed by an incrementing number. The log is as follows.
EVENT_JSON:{
  "standard": "nep171",
  "version": "1.0.0",
  "event": "nft_mint",
  "data": [
    {"owner_id": "mike.testnet", "token_ids": ["team-token0"]},
    {"owner_id": "damian.testnet", "token_ids": ["team-token1"]},
    {"owner_id": "josh.testnet", "token_ids": ["team-token2"]}
    {"owner_id": "dorian.testnet", "token_ids": ["team-token3", "team-token4"]},
  ]
}
Scenario C - transfer NFTs
In this scenario, Mike is transferring both his team tokens to Josh. The log should look as follows.
EVENT_JSON:{
  "standard": "nep171",
  "version": "1.0.0",
  "event": "nft_transfer",
  "data": [
    {"old_owner_id": "mike.testnet", "new_owner_id": "josh.testnet", "token_ids": ["team-token", "team-token0"], "memo": "Go Team!"}
  ]
}

Modifications to the contract
At this point, you should have a good understanding of what the end goal should be so let's get to work! Open the repository and create a new file in the nft-contract-basic/src directory called events.rs. This is where your log structs will live.
If you wish to see the finished code of the events implementation, that can be found on the nft-contract-events folder.
Creating the events file
Copy the following into your file. This will outline the structs for your EventLog, NftMintLog, and NftTransferLog. In addition, we've added a way for EVENT_JSON: to be prefixed whenever you log the EventLog.

This requires the serde_json package which you can easily add to your nft-contract-skeleton/Cargo.toml file:


Adding modules and constants
Now that you've created a new file, you need to add the module to the lib.rs file. In addition, you can define two constants for the standard and version that will be used across our contract.


Logging minted tokens
Now that all the tools are set in place, you can now implement the actual logging functionality. Since the contract will only be minting tokens in one place, open the nft-contract-basic/src/mint.rs file and navigate to the bottom of the file. This is where you'll construct the log for minting. Anytime someone successfully mints an NFT, it will now correctly emit a log.


Logging transfers
Let's open the nft-contract-basic/src/internal.rs file and navigate to the internal_transfer function. This is the location where you'll build your transfer logs. Whenever an NFT is transferred, this function is called and so you'll correctly be logging the transfers.

This solution, unfortunately, has an edge case which will break things. If an NFT is transferred via the nft_transfer_call function, there's a chance that the transfer will be reverted if the nft_on_transfer function returns true. Taking a look at the logic for nft_transfer_call, you can see why this is a problem.
When nft_transfer_call is invoked, it will:

Call internal_transfer to perform the actual transfer logic.
Initiate a cross-contract call and invoke the nft_on_transfer function.
Resolve the promise and perform logic in nft_resolve_transfer.

This will either return true meaning the transfer went fine or it will revert the transfer and return false.


If you only place the log in the internal_transfer function, the log will be emitted and the indexer will think that the NFT was transferred. If the transfer is reverted during nft_resolve_transfer, however, that event should also be emitted. Anywhere that an NFT could be transferred, we should add logs. Replace the nft_resolve_transfer with the following code.

In addition, you need to add an authorized_id and memo to the parameters for nft_resolve_transfer as shown below.
tipWe will talk more about this [`authorized_id`](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/nfts/./5-approval.md) in the following chapter.



The last step is to modify the nft_transfer_call logic to include these new parameters:

With that finished, you've successfully implemented the events standard and it's time to start testing.

Deploying the contract
For the purpose of readability and ease of development, instead of redeploying the contract to the same account, let's create an account and deploy to that instead. You could have deployed to the same account as none of the changes you implemented in this tutorial would have caused errors.
Deployment
Next, you'll deploy this contract to the network.

  

  ```bash
  export EVENTS_NFT_CONTRACT_ID=
  near create-account $EVENTS_NFT_CONTRACT_ID --useFaucet
  ```
  

  

  ```bash
  export EVENTS_NFT_CONTRACT_ID=
  near account create-account sponsor-by-faucet-service $EVENTS_NFT_CONTRACT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Using the cargo-near, deploy and initialize the contract as you did in the previous tutorials:
cargo near deploy $EVENTS_NFT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$EVENTS_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

Minting
Next, you'll need to mint a token. By running this command, you'll mint a token with a token ID "events-token" and the receiver will be your new account. In addition, you're passing in a map with two accounts that will get perpetual royalties whenever your token is sold.

  

  ```bash
  near call $EVENTS_NFT_CONTRACT_ID nft_mint '{"token_id": "events-token", "metadata": {"title": "Events Token", "description": "testing out the new events extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$EVENTS_NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $EVENTS_NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $EVENTS_NFT_CONTRACT_ID nft_mint json-args '{"token_id": "events-token", "metadata": {"title": "Events Token", "description": "testing out the new events extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$EVENTS_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $EVENTS_NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

You can check to see if everything went through properly by looking at the output in your CLI:
Doing account.functionCall()
Receipts: F4oxNfv54cqwUwLUJ7h74H1iE66Y3H7QDfZMmGENwSxd, BJxKNFRuLDdbhbGeLA3UBSbL8UicU7oqHsWGink5WX7S
    Log [events.goteam.examples.testnet]: EVENT_JSON:{"standard":"nep171","version":"1.0.0","event":"nft_mint","data":[{"owner_id":"events.goteam.examples.testnet","token_ids":["events-token"]}]}
Transaction Id 4Wy2KQVTuAWQHw5jXcRAbrz7bNyZBoiPEvLcGougciyk
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/4Wy2KQVTuAWQHw5jXcRAbrz7bNyZBoiPEvLcGougciyk
''
You can see that the event was properly logged!

Transferring
You can now test if your transfer log works as expected by sending benjiman.testnet your NFT.

  

  ```bash
  near call $EVENTS_NFT_CONTRACT_ID nft_transfer '{"receiver_id": "benjiman.testnet", "token_id": "events-token", "memo": "Go Team :)", "approval_id": 0}' --gas 100000000000000 --depositYocto 1 --accountId $EVENTS_NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $EVENTS_NFT_CONTRACT_ID nft_transfer json-args '{"receiver_id": "benjiman.testnet", "token_id": "events-token", "memo": "Go Team :)", "approval_id": 0}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $EVENTS_NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

This should return an output similar to the following:
Doing account.functionCall()
Receipts: EoqBxrpv9Dgb8KqK4FdeREawVVLWepEUR15KPNuZ4fGD, HZ4xQpbgc8EfU3PiV72LvfXb2f3dVC1n9aVTbQds9zfR
    Log [events.goteam.examples.testnet]: Memo: Go Team :)
    Log [events.goteam.examples.testnet]: EVENT_JSON:{"standard":"nep171","version":"1.0.0","event":"nft_transfer","data":[{"authorized_id":"events.goteam.examples.testnet","old_owner_id":"events.goteam.examples.testnet","new_owner_id":"benjiman.testnet","token_ids":["events-token"],"memo":"Go Team :)"}]}
Transaction Id 4S1VrepKzA6HxvPj3cK12vaT7Dt4vxJRWESA1ym1xdvH
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/4S1VrepKzA6HxvPj3cK12vaT7Dt4vxJRWESA1ym1xdvH
''
Hurray! At this point, your NFT contract is fully complete and the events standard has been implemented.

Conclusion
Today you went through the events standard and implemented the necessary logic in your smart contract. You created events for minting and transferring NFTs. You then deployed and tested your changes by minting and transferring NFTs.
In the next tutorial, you'll look at the basics of a marketplace contract and how it was built.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Events standard: [NEP297 extension](https://nomicon.io/Standards/Tokens/NonFungibleToken/Event), version `1.1.0`

### Royalty

In this tutorial you'll continue building your non-fungible token (NFT) smart contract, and learn how to implement perpetual royalties into your NFTs. This will allow people to get a percentage of the purchase price when an NFT is sold.
Introduction
By now, you should have a fully fledged NFT contract, except for the royalties support.
To get started, go to the nft-contract-approval/ folder from our GitHub repository, or continue your work from the previous tutorials.
cd nft-contract-approval/
tipf you wish to see the finished code for this _Royalty_ tutorial, you can find it in the `nft-contract-royalty` folder.


Thinking about the problem
In order to implement the functionality, you first need to understand how NFTs are sold. In the previous tutorial, you saw how someone with an NFT could list it on a marketplace using the nft_approve function by passing in a message that could be properly decoded. When a user purchases your NFT on the marketplace, what happens?
Using the knowledge you have now, a reasonable conclusion would be to say that the marketplace transfers the NFT to the buyer by performing a cross-contract call and invokes the NFT contract's nft_transfer method. Once that function finishes, the marketplace would pay the seller for the correct amount that the buyer paid.
Let's now think about how this can be expanded to allow for a cut of the pay going to other accounts that aren't just the seller.

Expanding the current solution
Since perpetual royalties will be on a per-token basis, it's safe to assume that you should be changing the Token and JsonToken structs. You need some way of keeping track of what percentage each account with a royalty should have. If you introduce a map of an account to an integer, that should do the trick.
Now, you need some way to relay that information to the marketplace. This method should be able to transfer the NFT exactly like the old solution but with the added benefit of telling the marketplace exactly what accounts should be paid what amounts. If you implement a method that transfers the NFT and then calculates exactly what accounts get paid and to what amount based on a passed-in balance, that should work nicely.
This is what the royalty standards outlined. Let's now move on and modify our smart contract to introduce this behavior.

Modifications to the contract
The first thing you'll want to do is add the royalty information to the structs. Open the nft-contract-approval/src/metadata.rs file and add royalty to the Token struct:
pub royalty: HashMap<AccountId, u32>,
Second, you'll want to add royalty to the JsonToken struct as well:
pub royalty: HashMap<AccountId, u32>,

Internal helper function
royalty_to_payout
To simplify the payout calculation, let's add a helper royalty_to_payout function to src/internal.rs. This will convert a percentage to the actual amount that should be paid. In order to allow for percentages less than 1%, you can give 100% a value of 10,000. This means that the minimum percentage you can give out is 0.01%, or 1. For example, if you wanted the account benji.testnet to have a perpetual royalty of 20%, you would insert the pair "benji.testnet": 2000 into the payout map.

If you were to use the royalty_to_payout function and pass in 2000 as the royalty_percentage and an amount_to_pay of 1 NEAR, it would return a value of 0.2 NEAR.

Royalties
nft_payout
Let's now implement a method to check what accounts will be paid out for an NFT given an amount, or balance. Open the nft-contract/src/royalty.rs file, and modify the nft_payout function as shown.

This function will loop through the token's royalty map and take the balance and convert that to a payout using the royalty_to_payout function you created earlier. It will give the owner of the token whatever is left from the total royalties. As an example:
You have a token with the following royalty field:
Token {
    owner_    royalty: {
        "benji": 1000,
        "josh": 500,
        "mike": 2000
    }
}
If a user were to call nft_payout on the token and pass in a balance of 1 NEAR, it would loop through the token's royalty field and insert the following into the payout object:
Payout {
    payout: {
        "benji": 0.1 NEAR,
        "josh": 0.05 NEAR,
        "mike": 0.2 NEAR
    }
}
At the very end, it will insert damian into the payout object and give him 1 NEAR - 0.1 - 0.05 - 0.2 = 0.65 NEAR.
nft_transfer_payout
Now that you know how payouts are calculated, it's time to create the function that will transfer the NFT and return the payout to the marketplace.


Perpetual royalties
To add support for perpetual royalties, let's edit the src/mint.rs file. First, add an optional parameter for perpetual royalties. This is what will determine what percentage goes to which accounts when the NFT is purchased. You will also need to create and insert the royalty to be put in the Token object:

Next, you can use the CLI to query the new nft_payout function and validate that it works correctly.
Adding royalty object to struct implementations
Since you've added a new field to your Token and JsonToken structs, you need to edit your implementations accordingly. Move to the nft-contract/src/internal.rs file and edit the part of your internal_transfer function that creates the new Token object:

Once that's finished, move to the nft-contract-approval/src/nft_core.rs file. You need to edit your implementation of nft_token so that the JsonToken sends back the new royalty information.


Deploying the contract
As you saw in the previous tutorial, adding changes like these will cause problems when redeploying. Since these changes affect all the other tokens and the state won't be able to automatically be inherited by the new code, simply redeploying the contract will lead to errors. For this reason, you'll create a new account again.
Deployment and initialization
Next, you'll deploy this contract to the network.

  

  ```bash
  export ROYALTY_NFT_CONTRACT_ID=
  near create-account $ROYALTY_NFT_CONTRACT_ID --useFaucet
  ```
  

  

  ```bash
  export ROYALTY_NFT_CONTRACT_ID=
  near account create-account sponsor-by-faucet-service $ROYALTY_NFT_CONTRACT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Using the cargo-near, deploy and initialize the contract as you did in the previous tutorials:
cargo near deploy $ROYALTY_NFT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$ROYALTY_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
Minting
Next, you'll need to mint a token. By running this command, you'll mint a token with a token ID "royalty-token" and the receiver will be your new account. In addition, you're passing in a map with two accounts that will get perpetual royalties whenever your token is sold.

  

  ```bash
  near call $ROYALTY_NFT_CONTRACT_ID nft_mint '{"token_id": "royalty-token", "metadata": {"title": "Royalty Token", "description": "testing out the new royalty extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$ROYALTY_NFT_CONTRACT_ID'", "perpetual_royalties": {"benjiman.testnet": 2000, "mike.testnet": 1000, "josh.testnet": 500}}' --gas 100000000000000 --deposit 0.1 --accountId $ROYALTY_NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $ROYALTY_NFT_CONTRACT_ID nft_mint json-args '{"token_id": "royalty-token", "metadata": {"title": "Royalty Token", "description": "testing out the new royalty extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$ROYALTY_NFT_CONTRACT_ID'", "perpetual_royalties": {"benjiman.testnet": 2000, "mike.testnet": 1000, "josh.testnet": 500}}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $ROYALTY_NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

You can check to see if everything went through properly by calling one of the enumeration functions:

  

  ```bash
  near view $ROYALTY_NFT_CONTRACT_ID nft_tokens_for_owner '{"account_id": "'$ROYALTY_NFT_CONTRACT_ID'", "limit": 10}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $ROYALTY_NFT_CONTRACT_ID nft_tokens_for_owner json-args '{"account_id": "'$ROYALTY_NFT_CONTRACT_ID'", "limit": 10}' network-config testnet now
  ```
  

This should return an output similar to the following:
[
  {
    "token_id": "royalty-token",
    "owner_id": "royalty.goteam.examples.testnet",
    "metadata": {
      "title": "Royalty Token",
      "description": "testing out the new royalty extension of the standard",
      "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif",
      "media_hash": null,
      "copies": null,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {},
    "royalty": {
      "josh.testnet": 500,
      "benjiman.testnet": 2000,
      "mike.testnet": 1000
    }
  }
]
Notice how there's now a royalty field that contains the 3 accounts that will get a combined 35% of all sales of this NFT? Looks like it works! Go team :)
NFT payout
Let's calculate the payout for the "royalty-token" NFT, given a balance of 100 yoctoNEAR. It's important to note that the balance being passed into the nft_payout function is expected to be in yoctoNEAR.

  

  ```bash
  near view $ROYALTY_NFT_CONTRACT_ID nft_payout '{"token_id": "royalty-token", "balance": "100", "max_len_payout": 100}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $ROYALTY_NFT_CONTRACT_ID nft_payout json-args '{"token_id": "royalty-token", "balance": "100", "max_len_payout": 100}' network-config testnet now
  ```
  

This command should return an output similar to the following:
{
  payout: {
    'josh.testnet': '5',
    'royalty.goteam.examples.testnet': '65',
    'mike.testnet': '10',
    'benjiman.testnet': '20'
  }
}
If the NFT was sold for 100 yoctoNEAR, josh would get 5, Benji would get 20, mike would get 10, and the owner, in this case royalty.goteam.examples.testnet would get the rest: 65.
Conclusion
At this point you have everything you need for a fully functioning NFT contract to interact with marketplaces.
The last remaining standard that you could implement is the events standard. This allows indexers to know what functions are being called and makes it easier and more reliable to keep track of information that can be used to populate the collectibles tab in the wallet for example.
inforemember
If you want to see the finished code from this tutorial, you can go to the `nft-contract-royalty` folder.

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Enumeration standard: [NEP181](https://nomicon.io/Standards/Tokens/NonFungibleToken/Enumeration), version `1.0.0`
- Royalties standard: [NEP199](https://nomicon.io/Standards/Tokens/NonFungibleToken/Payout), version `2.0.0`

### Approvals

In this tutorial you'll learn the basics of an approval management system which will allow you to grant others access to transfer NFTs on your behalf.
This is the backbone of all NFT marketplaces and allows for some complex yet beautiful scenarios to happen. If you're joining us for the first time, feel free to clone this repository and go to the nft-contract-basic/ folder to follow along.
cd nft-contract-basic/
tipf you wish to see the finished code for this _Approval_ tutorial, you can find it in the `nft-contract-approval/` folder.


Introduction
Up until this point you've created a smart contract that allows users to mint and transfer NFTs as well as query for information using the enumeration standard. As we've been doing in the previous tutorials, let's break down the problem into smaller, more digestible, tasks.
Let's first define some of the end goals that we want to accomplish as per the approval management extension of the standard. We want a user to have the ability to:

Grant other accounts access to transfer their NFTs on a per token basis.
Check if an account has access to a specific token.
Revoke a specific account the ability to transfer an NFT.
Revoke all other accounts the ability to transfer an NFT.

If you look at all these goals, they are all on a per token basis. This is a strong indication that you should change the Token struct which keeps track of information for each token.

Allow an account to transfer your NFT
Let's start by trying to accomplish the first goal. How can you grant another account access to transfer an NFT on your behalf?
The simplest way that you can achieve this is to add a list of approved accounts to the Token struct. When transferring the NFT, if the caller is not the owner, you could check if they're in the list.
Before transferring, you would need to clear the list of approved accounts since the new owner wouldn't expect the accounts approved by the original owner to still have access to transfer their new NFT.

The problem
On the surface, this would work, but if you start thinking about the edge cases, some problems arise. Often times when doing development, a common approach is to think about the easiest and most straightforward solution. Once you've figured it out, you can start to branch off and think about optimizations and edge cases.
Let's consider the following scenario. Benji has an NFT and gives two separate marketplaces access to transfer his token. By doing so, he's putting the NFT for sale (more about that in the marketplace integrations section). Let's say he put the NFT for sale for 1 NEAR on both markets. The tokens list of approved account IDs would look like the following:
Token: {
    owner_    approved_accounts_ids: [marketplace A, marketplace B]
}
Josh then comes along and purchases the NFT on marketplace A for 1 NEAR. This would take the sale down from the marketplace A and clear the list of approved accounts. Marketplace B, however, still has the token listed for sale for 1 NEAR and has no way of knowing that the token was purchased on marketplace A by Josh. The new token struct would look as follows:
Token: {
    owner_    approved_accounts_ids: []
}
Let's say Josh is low on cash and wants to flip this NFT and put it for sale for 10 times the price on marketplace B. He goes to put it for sale and for whatever reason, the marketplace is built in a way that if you try to put a token up for sale twice, it keeps the old sale data. This would mean that from marketplace B's perspective, the token is still for sale for 1 NEAR (which was the price that Benji had originally listed it for).
Since Josh approved the marketplace to try and put it for sale, the token struct would look as follows:
Token: {
    owner_    approved_accounts_ids: [marketplace A, marketplace B]
}
If Mike then comes along and purchases the NFT for only 1 NEAR on marketplace B, the marketplace would go to try and transfer the NFT and since technically, Josh approved the marketplace and it's in the list of approved accounts, the transaction would go through properly.

The solution
Now that we've identified a problem with the original solution, let's think about ways that we can fix it. What would happen now if, instead of just keeping track of a list of approved accounts, you introduced a specific ID that went along with each approved account. The new approved accounts would now be a map instead of a list. It would map an account to its approval id.
For this to work, you need to make sure that the approval ID is always a unique, new ID. If you set it as an integer that always increases by 1 whenever u approve an account, this should work. Let's consider the same scenario with the new solution.
Benji puts his NFT for sale for 1 NEAR on marketplace A and marketplace B by approving both marketplaces. The "next approval ID" would start off at 0 when the NFT was first minted and will increase from there. This would result in the following token struct:
Token: {
    owner_    approved_accounts_ids: {
        marketplace A: 0
        marketplace B: 1
    }
    next_approval_}
When Benji approved marketplace A, it took the original value of next_approval_id which started off at 0. The marketplace was then inserted into the map and the next approval ID was incremented. This process happened again for marketplace B and the next approval ID was again incremented where it's now 2.
Josh comes along and purchases the NFT on marketplace A for 1 NEAR. Notice how the next approval ID stayed at 2:
Token: {
    owner_    approved_accounts_ids: {}
    next_approval_}
Josh then flips the NFT because he's once again low on cash and approves marketplace B:
Token: {
    owner_    approved_accounts_ids: {
        marketplace B: 2
    }
    next_approval_}
The marketplace is inserted into the map and the next approval ID is incremented. From marketplace B's perspective it stores its original approval ID from when Benji put the NFT up for sale which has a value of 1. If Mike were to go and purchase the NFT on marketplace B for the original 1 NEAR sale price, the NFT contract should panic. This is because the marketplace is trying to transfer the NFT with an approval ID 1 but the token struct shows that it should have an approval ID of 2.

Expanding the Token and JsonToken structs
Now that you understand the proposed solution to the original problem of allowing an account to transfer your NFT, it's time to implement some of the logic. The first thing you should do is modify the Token and JsonToken structs to reflect the new changes. Let's switch over to the nft-contract-basic/src/metadata.rs file:

You'll then need to initialize both the approved_account_ids and next_approval_id to their default values when a token is minted. Switch to the nft-contract-basic/src/mint.rs file and when creating the Token struct to store in the contract, let's set the next approval ID to be 0 and the approved account IDs to be an empty map:


Approving accounts
Now that you've added the support for approved account IDs and the next approval ID on the token level, it's time to add the logic for populating and changing those fields through a function called nft_approve. This function should approve an account to have access to a specific token ID. Let's move to the nft-contract-basic/src/approval.rs file and edit the nft_approve function:

The function will first assert that the user has attached at least one yoctoNEAR (which we'll implement soon). This is both for security and to cover storage. When someone approves an account ID, they're storing that information on the contract. As you saw in the minting tutorial, you can either have the smart contract account cover the storage, or you can have the users cover that cost. The latter is more scalable and it's the approach you'll be working with throughout this tutorial.
After the assertion comes back with no problems, you get the token object and make sure that only the owner is calling this method. Only the owner should be able to allow other accounts to transfer their NFTs. You then get the next approval ID and insert the passed in account into the map with the next approval ID. If it's a new approval ID, storage must be paid. If it's not a new approval ID, no storage needs to be paid and only attaching 1 yoctoNEAR would be enough.
You then calculate how much storage is being used by adding that new account to the map and increment the tokens next_approval_id by 1. After inserting the token object back into the tokens_by_id map, you refund any excess storage.
You'll notice that the function contains an optional msg parameter. This message can be used by NFT marketplaces. If a message was provided into the function, you're going to perform a cross contract call to the account being given access. This cross contract call will invoke the nft_on_approve function which will parse the message and act accordingly.
It is up to the approving person to provide a properly encoded message that the marketplace can decode and use. This is usually done through the marketplace's frontend app which would know how to construct the msg in a useful way.

Internal functions
Now that the core logic for approving an account is finished, you need to implement the assert_at_least_one_yocto and bytes_for_approved_account functions. Move to the nft-contract/src/internal.rs file and copy the following function right below the assert_one_yocto function.

Next, you'll need to copy the logic for calculating how many bytes it costs to store an account ID. Place this function at the very top of the page:

Now that the logic for approving accounts is finished, you need to change the restrictions for transferring.
Changing the restrictions for transferring NFTs
Currently, an NFT can only be transferred by its owner. You need to change that restriction so that people that have been approved can also transfer NFTs. In addition, you'll make it so that if an approval ID is passed, you can increase the security and check if both the account trying to transfer is in the approved list and they correspond to the correct approval ID. This is to address the problem we ran into earlier.
In the internal.rs file, you need to change the logic of the internal_transfer method as that's where the restrictions are being made. Change the internal transfer function to be the following:

This will check if the sender isn't the owner and then if they're not, it will check if the sender is in the approval list. If an approval ID was passed into the function, it will check if the sender's actual approval ID stored on the contract matches the one passed in.

Refunding storage on transfer
While you're in the internal file, you're going to need to add methods for refunding users who have paid for storing approved accounts on the contract when an NFT is transferred. This is because you'll be clearing the approved_account_ids map whenever NFTs are transferred and so the storage is no longer being used.
Right below the bytes_for_approved_account_id function, copy the following two functions:

These will be useful in the next section where you'll be changing the nft_core functions to include the new approval logic.

Changes to nft_core.rs
Head over to the nft-contract-basic/src/nft_core.rs file and the first change that you'll want to make is to add an approval_id to both the nft_transfer and nft_transfer_call functions. This is so that anyone trying to transfer the token that isn't the owner must pass in an approval ID to address the problem seen earlier. If they are the owner, the approval ID won't be used as we saw in the internal_transfer function.

You'll then need to add an approved_account_ids map to the parameters of nft_resolve_transfer. This is so that you can refund the list if the transfer went through properly.

Moving over to nft_transfer, the only change that you'll need to make is to pass in the approval ID into the internal_transfer function and then refund the previous tokens approved account IDs after the transfer is finished

Next, you need to do the same to nft_transfer_call but instead of refunding immediately, you need to attach the previous token's approved account IDs to nft_resolve_transfer instead as there's still the possibility that the transfer gets reverted.

You'll also need to add the tokens approved account IDs to the JsonToken being returned by nft_token.

Finally, you need to add the logic for refunding the approved account IDs in nft_resolve_transfer. If the transfer went through, you should refund the owner for the storage being released by resetting the tokens approved_account_ids field. If, however, you should revert the transfer, it wouldn't be enough to just not refund anybody. Since the receiver briefly owned the token, they could have added their own approved account IDs and so you should refund them if they did so.

With that finished, it's time to move on and complete the next task.

Check if an account is approved
Now that the core logic is in place for approving and refunding accounts, it should be smooth sailing from this point on. You now need to implement the logic for checking if an account has been approved. This should take an account and token ID as well as an optional approval ID. If no approval ID was provided, it should simply return whether or not the account is approved.
If an approval ID was provided, it should return whether or not the account is approved and has the same approval ID as the one provided. Let's move to the nft-contract-basic/src/approval.rs file and add the necessary logic to the nft_is_approved function.

Let's now move on and add the logic for revoking an account

Revoke an account
The next step in the tutorial is to allow a user to revoke a specific account from having access to their NFT. The first thing you'll want to do is assert one yocto for security purposes. You'll then need to make sure that the caller is the owner of the token. If those checks pass, you'll need to remove the passed in account from the tokens approved account IDs and refund the owner for the storage being released.


Revoke all accounts
The final step in the tutorial is to allow a user to revoke all accounts from having access to their NFT. This should also assert one yocto for security purposes and make sure that the caller is the owner of the token. You then refund the owner for releasing all the accounts in the map and then clear the approved_account_ids.

With that finished, it's time to deploy and start testing the contract.

Testing the new changes
Since these changes affect all the other tokens and the state won't be able to automatically be inherited by the new code, simply redeploying the contract will lead to errors. For this reason, it's best practice to create a new account and deploy the contract there.

Deployment and initialization
Next, you'll deploy this contract to the network.

  

  ```bash
  export APPROVAL_NFT_CONTRACT_ID=
  near create-account $APPROVAL_NFT_CONTRACT_ID --useFaucet
  ```
  

  

  ```bash
  export APPROVAL_NFT_CONTRACT_ID=
  near account create-account sponsor-by-faucet-service $APPROVAL_NFT_CONTRACT_ID autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Using the cargo-near, deploy and initialize the contract as you did in the previous tutorials:
cargo near deploy $APPROVAL_NFT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$APPROVAL_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

Minting
Next, you'll need to mint a token. By running this command, you'll mint a token with a token ID "approval-token" and the receiver will be your new account.

  

  ```bash
  near call $APPROVAL_NFT_CONTRACT_ID nft_mint '{"token_id": "approval-token", "metadata": {"title": "Approval Token", "description": "testing out the new approval extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$APPROVAL_NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $APPROVAL_NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $APPROVAL_NFT_CONTRACT_ID nft_mint json-args '{"token_id": "approval-token", "metadata": {"title": "Approval Token", "description": "testing out the new approval extension of the standard", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$APPROVAL_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $APPROVAL_NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

You can check to see if everything went through properly by calling one of the enumeration functions:

  

  ```bash
  near view $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner '{"account_id": "'$APPROVAL_NFT_CONTRACT_ID'", "limit": 10}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner json-args '{"account_id": "'$APPROVAL_NFT_CONTRACT_ID'", "limit": 10}' network-config testnet now
  ```
  

This should return an output similar to the following:
[
  {
    "token_id": "approval-token",
    "owner_id": "approval.goteam.examples.testnet",
    "metadata": {
      "title": "Approval Token",
      "description": "testing out the new approval extension of the standard",
      "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif",
      "media_hash": null,
      "copies": null,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
Notice how the approved account IDs are now being returned from the function? This is a great sign! You're now ready to move on and approve an account to have access to your token.

Approving an account
At this point, you should have two accounts. One stored under $NFT_CONTRACT_ID and the other under the $APPROVAL_NFT_CONTRACT_ID environment variable. You can use both of these accounts to test things out. If you approve your old account, it should have the ability to transfer the NFT to itself.
Execute the following command to approve the account stored under $NFT_CONTRACT_ID to have access to transfer your NFT with an ID "approval-token". You don't need to pass a message since the old account didn't implement the nft_on_approve function. In addition, you'll need to attach enough NEAR to cover the cost of storing the account on the contract. 0.1 NEAR should be more than enough and you'll be refunded any excess that is unused.

  

  ```bash
  near call $APPROVAL_NFT_CONTRACT_ID nft_approve '{"token_id": "approval-token", "account_id": "'$NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $APPROVAL_NFT_CONTRACT_ID nft_approve json-args '{"token_id": "approval-token", "account_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

If you call the same enumeration method as before, you should see the new approved account ID being returned.

  

  ```bash
  near view $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner '{"account_id": "'$APPROVAL_NFT_CONTRACT_ID'", "limit": 10}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner json-args '{"account_id": "'$APPROVAL_NFT_CONTRACT_ID'", "limit": 10}' network-config testnet now
  ```
  

This should return an output similar to the following:
[
  {
    "token_id": "approval-token",
    "owner_id": "approval.goteam.examples.testnet",
    "metadata": {
      "title": "Approval Token",
      "description": "testing out the new approval extension of the standard",
      "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif",
      "media_hash": null,
      "copies": null,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": { "goteam.examples.testnet": 0 }
  }
]

Transferring an NFT as an approved account
Now that you've approved another account to transfer the token, you can test that behavior. You should be able to use the other account to transfer the NFT to itself by which the approved account IDs should be reset. Let's test transferring the NFT with the wrong approval ID:

  

  ```bash
  near call $APPROVAL_NFT_CONTRACT_ID nft_transfer '{"receiver_id": "'$NFT_CONTRACT_ID'", "token_id": "approval-token", "approval_id": 1}' --gas 100000000000000 --depositYocto 1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $APPROVAL_NFT_CONTRACT_ID nft_transfer json-args '{"receiver_id": "'$NFT_CONTRACT_ID'", "token_id": "approval-token", "approval_id": 1}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  


Example response: 


```bash
kind: {
    ExecutionError: "Smart contract panicked: panicked at 'assertion failed: `(left == right)`n" +
      '  left: `0`,n' +
      " right: `1`: The actual approval_id 0 is different from the given approval_id 1', src/internal.rs:165:17"
  },
```



If you pass the correct approval ID which is 0, everything should work fine.

  

  ```bash
  near call $APPROVAL_NFT_CONTRACT_ID nft_transfer '{"receiver_id": "'$NFT_CONTRACT_ID'", "token_id": "approval-token", "approval_id": 0}' --gas 100000000000000 --depositYocto 1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $APPROVAL_NFT_CONTRACT_ID nft_transfer json-args '{"receiver_id": "'$NFT_CONTRACT_ID'", "token_id": "approval-token", "approval_id": 0}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

If you again call the enumeration method, you should see the owner updated and the approved account IDs reset.
[
  {
    "token_id": "approval-token",
    "owner_id": "goteam.examples.testnet",
    "metadata": {
      "title": "Approval Token",
      "description": "testing out the new approval extension of the standard",
      "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif",
      "media_hash": null,
      "copies": null,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
Let's now test the approval ID incrementing across different owners. If you approve the account that originally minted the token, the approval ID should be 1 now.

  

  ```bash
  near call $APPROVAL_NFT_CONTRACT_ID nft_approve '{"token_id": "approval-token", "account_id": "'$APPROVAL_NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $APPROVAL_NFT_CONTRACT_ID nft_approve json-args '{"token_id": "approval-token", "account_id": "'$APPROVAL_NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Calling the view function again show now return an approval ID of 1 for the account that was approved.

  

  ```bash
  near view $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner '{"account_id": "'$NFT_CONTRACT_ID'", "limit": 10}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $APPROVAL_NFT_CONTRACT_ID nft_tokens_for_owner json-args '{"account_id": "'$NFT_CONTRACT_ID'", "limit": 10}' network-config testnet now
  ```
  


Example response: 


```json
[
  {
    "token_id": "approval-token",
    "owner_id": "goteam.examples.testnet",
    "metadata": {
      "title": "Approval Token",
      "description": "testing out the new approval extension of the standard",
      "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif",
      "media_hash": null,
      "copies": null,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": { "approval.goteam.examples.testnet": 1 }
  }
]
```



With the testing finished, you've successfully implemented the approvals extension to the standard!

Conclusion
Today you went through a lot of logic to implement the approvals extension so let's break down exactly what you did.
First, you explored the basic approach of how to solve the problem. You then went through and discovered some of the problems with that solution and learned how to fix it.
After understanding what you should do to implement the approvals extension, you started to modify the JsonToken and Token structs in the contract. You then implemented the logic for approving accounts and saw how marketplaces are integrated.
After implementing the logic behind approving accounts, you went and changed the restrictions needed to transfer NFTs. The last step you did to finalize the approving logic was to go back and edit the nft_core files to be compatible with the new changes.
At this point, everything was implemented in order to allow accounts to be approved and you extended the functionality of the core standard to allow for approved accounts to transfer tokens.
You implemented a view method to check if an account is approved and to finish the coding portion of the tutorial, you implemented the logic necessary to revoke an account as well as revoke all accounts.
After this, the contract code was finished and it was time to move onto testing where you created an account and tested the approving and transferring for your NFTs.
In the next tutorial, you'll learn about the royalty standards and how you can interact with NFT marketplaces.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Enumeration standard: [NEP181](https://nomicon.io/Standards/Tokens/NonFungibleToken/Enumeration), version `1.0.0`
- Approval standard: [NEP178](https://nomicon.io/Standards/Tokens/NonFungibleToken/ApprovalManagement), version `1.1.0`

### Transfers

In this tutorial you'll learn how to implement NFT transfers as defined in the core standards into your smart contract.
We will define two methods for transferring NFTs:

nft_transfer: that transfers ownership of an NFT from one account to another
nft_transfer_call: that transfers an NFT to a "receiver" and calls a method on the receiver's account

tiphy two transfer methods?

`nft_transfer` is a simple transfer between two user, while `nft_transfer_call` allows you to **attach an NFT to a function call**



Introduction
Up until this point, you've created a simple NFT smart contract that allows users to mint tokens and view information using the enumeration standards. Today, you'll expand your smart contract to allow for users to not only mint tokens, but transfer them as well.
As we did in the minting tutorial, let's break down the problem into multiple subtasks to make our lives easier. When a token is minted, information is stored in 3 places:

tokens_per_owner: set of tokens for each account.
tokens_by_id: maps a token ID to a Token object.
token_metadata_by_id: maps a token ID to its metadata.

Let's now consider the following scenario. If Benji owns token A and wants to transfer it to Mike as a birthday gift, what should happen? First of all, token A should be removed from Benji's set of tokens and added to Mike's set of tokens.
If that's the only logic you implement, you'll run into some problems. If you were to do a view call to query for information about that token after it's been transferred to Mike, it would still say that Benji is the owner.
This is because the contract is still mapping the token ID to the old Token object that contains the owner_id field set to Benji's account ID. You still have to change the tokens_by_id data structure so that the token ID maps to a new Token object which has Mike as the owner.
With that being said, the final process for when an owner transfers a token to a receiver should be the following:

Remove the token from the owner's set.
Add the token to the receiver's set.
Map a token ID to a new Token object containing the correct owner.

noteYou might be curious as to why we don't edit the `token_metadata_by_id` field. This is because no matter who owns the token, the token ID will always map to the same metadata. The metadata should never change and so we can just leave it alone.

At this point, you're ready to move on and make the necessary modifications to your smart contract.

Modifications to the contract
Let's start our journey in the nft-contract-skeleton/src/nft_core.rs file.
Transfer function
You'll start by implementing the nft_transfer logic. This function will transfer the specified token_id to the receiver_id with an optional memo such as "Happy Birthday Mike!".

There are a couple things to notice here. Firstly, we've introduced a new function called assert_one_yocto(), which ensures the user has attached exactly one yoctoNEAR to the call. This is a security measure to ensure that the user is signing the transaction with a full access key.
Since the transfer function is potentially transferring very valuable assets, you'll want to make sure that whoever is calling the function has a full access key.
Secondly, we've introduced an internal_transfer method. This will perform all the logic necessary to transfer an NFT.

Internal helper functions
Let's quickly move over to the nft-contract/src/internal.rs file so that you can implement the assert_one_yocto() and internal_transfer methods.
Let's start with the easier one, assert_one_yocto().
assert_one_yocto

internal_transfer
It's now time to explore the internal_transfer function which is the core of this tutorial. This function takes the following parameters:

sender_id: the account that's attempting to transfer the token.
receiver_id: the account that's receiving the token.
token_id: the token ID being transferred.
memo: an optional memo to include.

The first thing we have to do is to make sure that the sender is authorized to transfer the token. In this case, we just make sure that the sender is the owner of the token. We do that by getting the Token object using the token_id and making sure that the sender is equal to the token's owner_id.
Second, we remove the token ID from the sender's list and add the token ID to the receiver's list of tokens. Finally, we create a new Token object with the receiver as the owner and remap the token ID to that newly created object.
We want to create this function within the contract implementation (below the internal_add_token_to_owner you created in the minting tutorial).

Now let's look at the function called internal_remove_token_from_owner. That function implements the functionality for removing a token ID from an owner's set.
In the remove function, we get the set of tokens for a given account ID and then remove the passed in token ID. If the account's set is empty after the removal, we simply remove the account from the tokens_per_owner data structure.

Your internal.rs file should now have the following outline:
internal.rs
├── hash_account_id
├── assert_one_yocto
├── refund_deposit
└── impl Contract
    ├── internal_add_token_to_owner
    ├── internal_remove_token_from_owner
    └── internal_transfer

Transfer call function
The idea behind the nft_transfer_call function is to transfer an NFT to a receiver while calling a method on the receiver's contract all in the same transaction.
This way, we can effectively attach an NFT to a function call.

The function will first assert that the caller attached exactly 1 yocto for security purposes. It will then transfer the NFT using internal_transfer and start the cross contract call. It will call the method nft_on_transfer on the receiver_id's contract, and create a promise to call back nft_resolve_transfer with the result. This is a very common workflow when dealing with cross contract calls.
As dictated by the core standard, the function we are calling (nft_on_transfer) needs to return a boolean stating whether or not you should return the NFT to it's original owner.

If nft_on_transfer returned true or the called failed, you should send the token back to it's original owner. On the contrary, if false was returned, no extra logic is needed.
As for the return value of our function nft_resolve_transfer, the standard dictates that the function should return a boolean indicating whether or not the receiver successfully received the token or not.
This means that if nft_on_transfer returned true, you should return false. This is because if the token is being returned its original owner, the receiver_id didn't successfully receive the token in the end. On the contrary, if nft_on_transfer returned false, you should return true since we don't need to return the token and thus the receiver_id successfully owns the token.
With that finished, you've now successfully added the necessary logic to allow users to transfer NFTs. It's now time to deploy and do some testing.

Redeploying the contract
Using cargo-near, deploy the contract as you did in the previous tutorials:
cargo near deploy $NFT_CONTRACT_ID without-init-call network-config testnet sign-with-keychain send
tipf you haven't completed the previous tutorials and are just following along with this one, simply create an account and login with your CLI using `near login`. You can then export an environment variable `export NFT_CONTRACT_ID=YOUR_ACCOUNT_ID_HERE`.


Testing the new changes
Now that you've deployed a patch fix to the contract, it's time to move onto testing. Using the previous NFT contract where you had minted a token to yourself, you can test the nft_transfer method. If you transfer the NFT, it should be removed from your account's collectibles displayed in the wallet. In addition, if you query any of the enumeration functions, it should show that you are no longer the owner.
Let's test this out by transferring an NFT to the account benjiman.testnet and seeing if the NFT is no longer owned by you.

Testing the transfer function
noteThis means that the NFT won't be recoverable unless the account `benjiman.testnet` transfers it back to you. If you don't want your NFT lost, make a new account and transfer the token to that account instead.

If you run the following command, it will transfer the token "token-1" to the account benjiman.testnet with the memo "Go Team :)". Take note that you're also attaching exactly 1 yoctoNEAR by using the --depositYocto flag.
tipf you used a different token ID in the previous tutorials, replace `token-1` with your token ID.


  

  ```bash
  near call $NFT_CONTRACT_ID nft_transfer '{"receiver_id": "benjiman.testnet", "token_id": "token-1", "memo": "Go Team :)"}' --gas 100000000000000 --depositYocto 1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_transfer json-args '{"receiver_id": "benjiman.testnet", "token_id": "token-1", "memo": "Go Team :)"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

If you now query for all the tokens owned by your account, that token should be missing. Similarly, if you query for the list of tokens owned by benjiman.testnet, that account should now own your NFT.

Testing the transfer call function
Now that you've tested the nft_transfer function, it's time to test the nft_transfer_call function. If you try to transfer an NFT to a receiver that does not implement the nft_on_transfer function, the contract will panic and the NFT will not be transferred. Let's test this functionality below.
First mint a new NFT that will be used to test the transfer call functionality.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"token_id": "token-2", "metadata": {"title": "NFT Tutorial Token", "description": "Testing the transfer call function", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"token_id": "token-2", "metadata": {"title": "NFT Tutorial Token", "description": "Testing the transfer call function", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Now that you've minted the token, you can try to transfer the NFT to the account no-contract.testnet which as the name suggests, doesn't have a contract. This means that the receiver doesn't implement the nft_on_transfer function and the NFT should remain yours after the transaction is complete.

  

  ```bash
  near call $NFT_CONTRACT_ID nft_transfer_call '{"receiver_id": "no-contract.testnet", "token_id": "token-2", "msg": "foo"}' --gas 100000000000000 --depositYocto 1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NFT_CONTRACT_ID nft_transfer_call json-args '{"receiver_id": "no-contract.testnet", "token_id": "token-2", "msg": "foo"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

If you query for your tokens, you should still have token-2 and at this point, you're finished!

Conclusion
In this tutorial, you learned how to expand an NFT contract past the minting functionality and you added ways for users to transfer NFTs. You broke down the problem into smaller, more digestible subtasks and took that information and implemented both the NFT transfer and NFT transfer call functions. In addition, you deployed another patch fix to your smart contract and tested the transfer functionality.
In the next tutorial, you'll learn about the approval management system and how you can approve others to transfer tokens on your behalf.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Enumeration standard: [NEP181](https://nomicon.io/Standards/Tokens/NonFungibleToken/Enumeration), version `1.0.0`

### Enumeration

In the previous tutorials, you looked at ways to integrate the minting functionality into a skeleton smart contract. In order to get your NFTs to show in the wallet, you also had to deploy a patch fix that implemented one of the enumeration methods. In this tutorial, you'll expand on and finish the rest of the enumeration methods as per the standard.
Now you'll extend the NFT smart contract and add a couple of enumeration methods that can be used to return the contract's state.

Introduction
As mentioned in the Upgrade a Contract tutorial, you can deploy patches and fixes to smart contracts. This time, you'll use that knowledge to implement the nft_total_supply, nft_tokens and nft_supply_for_owner enumeration functions.

Modifications to the contract
Let's start by opening the  src/enumeration.rs file and locating the empty nft_total_supply function.
nft_total_supply
This function should return the total number of NFTs stored on the contract. You can easily achieve this functionality by simply returning the length of the nft_metadata_by_id data structure.

nft_token
This function should return a paginated list of JsonTokens that are stored on the contract regardless of their owners.
If the user provides a from_index parameter, you should use that as the starting point for which to start iterating through tokens; otherwise it should start from the beginning. Likewise, if the user provides a limit parameter, the function shall stop after reaching either the limit or the end of the list.
tipust has useful methods for pagination, allowing you to skip to a starting index and taking the first `n` elements of an iterator.


nft_supply_for_owner
This function should look for all the non-fungible tokens for a user-defined owner, and return the length of the resulting set.
If there isn't a set of tokens for the provided AccountID, then the function shall return 0.

Next, you can use the CLI to query these new methods and validate that they work correctly.

Redeploying the contract
Now that you've implemented the necessary logic for nft_tokens_for_owner, it's time to build and re-deploy the contract to your account. Using the cargo-near, deploy the contract as you did in the previous tutorials:
cargo near deploy $NFT_CONTRACT_ID without-init-call network-config testnet sign-with-keychain send

Enumerating tokens
Once the updated contract has been redeployed, you can test and see if these new functions work as expected.
NFT tokens
Let's query for a list of non-fungible tokens on the contract. Use the following command to query for the information of up to 50 NFTs starting from the 10th item:

  

  ```bash
  near view $NFT_CONTRACT_ID nft_tokens '{"from_index": "10", "limit": 50}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_tokens json-args '{"from_index": "10", "limit": 50}' network-config testnet now
  ```
  

This command should return an output similar to the following:

Example response: 


```json
[]
```




Tokens by owner
To get the total supply of NFTs owned by the goteam.testnet account, call the nft_supply_for_owner function and set the account_id parameter:

  

  ```bash
  near view $NFT_CONTRACT_ID nft_supply_for_owner '{"account_id": "goteam.testnet"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_supply_for_owner json-args '{"account_id": "goteam.testnet"}' network-config testnet now
  ```
  

This should return an output similar to the following:

Example response: 


```json
0
```




Conclusion
In this tutorial, you have added two new enumeration functions, and now you have a basic NFT smart contract with minting and enumeration methods in place. After implementing these modifications, you redeployed the smart contract and tested the functions using the CLI.
In the next tutorial, you'll implement the core functions needed to allow users to transfer the minted tokens.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Enumeration standard: [NEP181](https://nomicon.io/Standards/Tokens/NonFungibleToken/Enumeration), version `1.0.0`

### Upgrading the Contract

In this tutorial, you'll build off the work you previously did to implement the minting functionality on a skeleton smart contract. You got to the point where NFTs could be minted and the wallet correctly picked up on the fact that you owned an NFT. However, it had no way of displaying the tokens since your contract didn't implement the method that the wallet was trying to call.

Introduction
Today you'll learn about deploying patch fixes to smart contracts and you'll use that knowledge to implement the nft_tokens_for_owner function on the contract you deployed in the previous tutorial.

Upgrading contracts overview
Upgrading contracts, when done right, can be an immensely powerful tool. If done wrong, it can lead to a lot of headaches. It's important to distinguish between the code and state of a smart contract. When a contract is deployed on top of an existing contract, the only thing that changes is the code. The state will remain the same and that's where a lot of developer's issues come to fruition.
The NEAR Runtime will read the serialized state from disk and it will attempt to load it using the current contract code. When your code changes, it might not be able to figure out how to do this.
You need to strategically upgrade your contracts and make sure that the runtime will be able to read your current state with the new contract code. For more information about upgrading contracts and some best practices, see the NEAR SDK's upgrading contracts write-up.

Modifications to our contract
In order for the wallet to properly display your NFTs, you need to implement the nft_tokens_for_owner method. This will allow anyone to query for a paginated list of NFTs owned by a given account ID.
To accomplish this, let's break it down into some smaller subtasks. First, you need to get access to a list of all token IDs owned by a user. This information can be found in the tokens_per_owner data structure. Now that you have a set of token IDs, you need to convert them into JsonToken objects as that's what you'll be returning from the function.
Luckily, you wrote a function nft_token which takes a token ID and returns a JsonToken in the nft_core.rs file. As you can guess, in order to get a list of JsonToken objects, you would need to iterate through the token IDs owned by the user and then convert each token ID into a JsonToken and store that in a list.
As for the pagination, Rust has some awesome functions for skipping to a starting index and taking the first n elements of an iterator.
Let's move over to the enumeration.rs file and implement that logic:


Redeploying the contract
Now that you've implemented the necessary logic for nft_tokens_for_owner, it's time to build and re-deploy the contract to your account. Using the cargo-near, deploy the contract as you did in the previous tutorial:
cargo near deploy $NFT_CONTRACT_ID without-init-call network-config testnet sign-with-keychain send
Once the contract has been redeployed, let's test and see if the state migrated correctly by running a simple view function:

  

  ```bash
  near view $NFT_CONTRACT_ID nft_metadata '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_metadata json-args {} network-config testnet now
  ```
  

This should return an output similar to the following:
{
  spec: 'nft-1.0.0',
  name: 'NFT Tutorial Contract',
  symbol: 'GOTEAM',
  icon: null,
  base_uri: null,
  reference: null,
  reference_hash: null
}
Go team! At this point, you can now test and see if the new function you wrote works correctly. Let's query for the list of tokens that you own:

  

  ```bash
  near view $NFT_CONTRACT_ID nft_tokens_for_owner '{"account_id": "'$NFT_CONTRACT_ID'", "limit": 5}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_tokens_for_owner json-args '{"account_id": "'$NFT_CONTRACT_ID'", "limit": 5}' network-config testnet now
  ```
  


Example response: 


```bash
[
  {
    token_    owner_    metadata: {
       'My Non Fungible Team Token',
      description: 'The Team Most Certainly Goes :)',
      media: 'https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif',
      media_hash: null,
      copies: null,
      issued_at: null,
      expires_at: null,
      starts_at: null,
      updated_at: null,
      extra: null,
      reference: null,
      reference_hash: null
    }
  }
]
```




Viewing NFTs in the wallet
Now that your contract implements the necessary functions that the wallet uses to display NFTs, you should be able to see your tokens on display in the collectibles tab.


Conclusion
In this tutorial, you learned about the basics of upgrading contracts. Then, you implemented the necessary modifications to your smart contract and redeployed it. Finally you navigated to the wallet collectibles tab and viewed your NFTs.
In the next tutorial, you'll implement the remaining functions needed to complete the enumeration standard.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### Minting

This is the first of many tutorials in a series where you'll be creating a complete NFT smart contract from scratch that conforms with all the NEAR NFT standards.
Today you'll learn how to create the logic needed to mint NFTs and have them show up in your NEAR wallet. You will be filling a bare-bones skeleton smart contract to add minting functionalities.
infoContracts
You can find the skeleton contract in our [Skeleton folder](https://github.com/near-examples/nft-tutorial/tree/main/nft-contract-skeleton)

A completed version of this tutorial can be found in the [Basic NFT folder](https://github.com/near-examples/nft-tutorial/tree/main/nft-contract-basic)


Introduction
To get started, go to the nft-contract-skeleton folder in our repo. If you haven't cloned the repository, refer to the Contract Architecture to get started.
cd nft-contract-skeleton/
If you wish to see the finished code of this step-by-step basic NFT contract tutorial, that can be found on the nft-contract-basic folder.

Modifications to the skeleton contract
In order to implement the logic needed for minting, we should break it up into smaller tasks and handle those one-by-one. Let's step back and think about the best way to do this by asking ourselves a simple question: what does it mean to mint an NFT?
To mint a non-fungible token, in the most simple way possible, a contract needs to be able to associate a token with an owner on the blockchain. This means you'll need:

A way to keep track of tokens and other information on the contract.
A way to store information for each token such as metadata (more on that later).
A way to link a token with an owner.

That's it! We've now broken down the larger problem into some smaller, less daunting, subtasks. Let's start by tackling the first and work our way through the rest.

Storing information on the contract
Start by navigating to nft-contract-skeleton/src/lib.rs and filling in some of the code blocks.
You need to be able to store important information on the contract such as the list of tokens that an account has.
Contract Struct
The first thing to do is modifying the contract struct as follows:

This allows you to get the information stored in these data structures from anywhere in the contract. The code above has created 3 token specific storages:

tokens_per_owner: allows you to keep track of the tokens owned by any account
tokens_by_id: returns all the information about a specific token
token_metadata_by_id: returns just the metadata for a specific token

In addition, you'll keep track of the owner of the contract as well as the metadata for the contract.
You might be confused as to some of the types that are being used. In order to make the code more readable, we've introduced custom data types which we'll briefly outline below:

AccountId: a string that ensures there are no special or unsupported characters.
TokenId: simply a string.

As for the Token, TokenMetadata, and NFTContractMetadata data types, those are structs that we'll define later in this tutorial.
Initialization Functions
Next, create what's called an initialization function; we will name it new, but you can choose any name you prefer.
This function needs to be invoked when you first deploy the contract. It will initialize all the contract's fields that you've defined above with default values.
Don't forget to add the owner_id and metadata fields as parameters to the function, so only those can be customized.
This function will default all the collections to be empty and set the owner and metadata equal to what you pass in.

More often than not when doing development, you'll need to deploy contracts several times. You can imagine that it might get tedious to have to pass in metadata every single time you want to initialize the contract. For this reason, let's create a function that can initialize the contract with a set of default metadata. You can call it new_default_meta and it'll only take the owner_id as a parameter.

This function is simply calling the previous new function and passing in the owner that you specify and also passes in some default metadata.

Metadata and token information
Now that you've defined what information to store on the contract itself and you've defined some ways to initialize the contract, you need to define what information should go in the Token, TokenMetadata, and NFTContractMetadata data types.
Let's switch over to the nft-contract-skeleton/src/metadata.rs file as this is where that information will go.
If you look at the standards for metadata, you'll find all the necessary information that you need to store for both TokenMetadata and NFTContractMetadata. Simply fill in the following code.

This now leaves you with the Token struct and something called a JsonToken. The Token struct will hold all the information directly related to the token excluding the metadata. The metadata, if you remember, is stored in a map on the contract in a data structure called token_metadata_by_id. This allows you to quickly get the metadata for any token by simply passing in the token's ID.
For the Token struct, you'll just keep track of the owner for now.

Since NEAR smart contracts receive and return data in JSON format, the purpose of the JsonToken is to act as output when the user asks information for an NFT. This means you'll want to store the owner, token ID, and metadata.

tipome of you might be thinking _"how come we don't just store all the information in the `Token` struct?"_.
The reason behind this is that it's actually more efficient to construct the JSON token on the fly only when you need it rather than storing all the information in the token struct.
In addition, some operations might only need the metadata for a token and so having the metadata in a separate data structure is more optimal.

Function for querying contract metadata
Now that you've defined some of the types that were used in the previous section, let's move on and create the first view function nft_metadata. This will allow users to query for the contract's metadata as per the metadata standard.

This function will get the metadata object from the contract which is of type NFTContractMetadata and will return it.
Just like that, you've completed the first two tasks and are ready to move onto last part of the tutorial.

Minting Logic
Now that all the information and types are defined, let's start brainstorming how the minting logic will play out. In the end, you need to link a Token and TokenId to a specific owner. Let's look back at the lib.rs file to see how you can accomplish this. There are a couple data structures that might be useful:
//keeps track of all the token IDs for a given account
pub tokens_per_owner: LookupMap<AccountId, UnorderedSet<TokenId>>,

//keeps track of the token struct for a given token ID
pub tokens_by_
//keeps track of the token metadata for a given token ID
pub token_metadata_by_```

Looking at these data structures, you could do the following:

- Add the token ID into the set of tokens that the receiver owns. This will be done on the `tokens_per_owner` field.
- Create a token object and map the token ID to that token object in the `tokens_by_id` field.
- Map the token ID to it's metadata using the `token_metadata_by_id`.

#### Storage Implications {#storage-implications}
With those steps outlined, it's important to take into consideration the storage costs of minting NFTs. Since you're adding bytes to the contract by creating entries in the data structures, the contract needs to cover the storage costs. If you just made it so any user could go and mint an NFT for free, that system could easily be abused and users could essentially "drain" the contract of all it's funds by minting thousands of NFTs. For this reason, you'll make it so that users need to attach a deposit to the call to cover the cost of storage. You'll measure the initial storage usage before anything was added and you'll measure the final storage usage after all the logic is finished. Then you'll make sure that the user has attached enough $NEAR to cover that cost and refund them if they've attached too much.

This is how we do it in code:

<Github language="rust" start="3" end="45" url="https://github.com/near-examples/nft-tutorial/blob/main/nft-contract-basic/src/mint.rs" />

You'll notice that we're using some internal methods such as `refund_deposit` and `internal_add_token_to_owner`. We've described the function of `refund_deposit` and as for `internal_add_token_to_owner`, this will add a token to the set of tokens an account owns for the contract's `tokens_per_owner` data structure. You can create these functions in a file called `internal.rs`. Go ahead and create the file. Your new contract architecture should look as follows:

nft-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
├── build.sh
└── src
├── approval.rs
├── enumeration.rs
├── internal.rs
├── lib.rs
├── metadata.rs
├── mint.rs
├── nft_core.rs
├── events.rs
└── royalty.rs

Add the following to your newly created `internal.rs` file.

<Github language="rust" start="1" end="133" url="https://github.com/near-examples/nft-tutorial/blob/main/nft-contract-basic/src/internal.rs" />

<div class="alert alert-note" role="alert"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>note</div>You may notice more functions in the `internal.rs` file than we need for now. You may ignore them, we'll come back to them later.
</div>

Let's now quickly move to the `lib.rs` file and make the functions we just created invokable in other files. We'll add the internal crates and mod the file as shown below:

<Github language="rust" start="10" end="23" url="https://github.com/near-examples/nft-tutorial/blob/main/nft-contract-basic/src/lib.rs" />

At this point, the core logic is all in place so that you can mint NFTs. You can use the function `nft_mint` which takes the following parameters:

- **token_id**: the ID of the token you're minting (as a string).
- **metadata**: the metadata for the token that you're minting (of type `TokenMetadata` which is found in the `metadata.rs` file).
- **receiver_id**: specifies who the owner of the token will be.

Behind the scenes, the function will:

1. Calculate the initial storage before adding anything to the contract
2. Create a `Token` object with the owner ID
3. Link the token ID to the newly created token object by inserting them into the `tokens_by_id` field.
4. Link the token ID to the passed in metadata by inserting them into the `token_metadata_by_id` field.
5. Add the token ID to the list of tokens that the owner owns by calling the `internal_add_token_to_owner` function.
6. Calculate the final and net storage to make sure that the user has attached enough NEAR to the call in order to cover those costs.

<hr class="subsection" />

### Querying for token information

If you were to go ahead and deploy this contract, initialize it, and mint an NFT, you would have no way of knowing or querying for the information about the token you just minted. Let's quickly add a way to query for the information of a specific NFT. You'll move to the `nft-contract-skeleton/src/nft_core.rs` file and edit the `nft_token` function.

It will take a token ID as a parameter and return the information for that token. The `JsonToken` contains the token ID, the owner ID, and the token's metadata.

<Github language="rust" start="129" end="143" url="https://github.com/near-examples/nft-tutorial/blob/main/nft-contract-basic/src/nft_core.rs" />

With that finished, it's finally time to build and deploy the contract so you can mint your first NFT.

---

## Interacting with the contract on-chain

Now that the logic for minting is complete and you've added a way to query for information about specific tokens, it's time to build and deploy your contract to the blockchain.

### Deploying the contract {#deploy-the-contract}

For deployment, you will need a NEAR account with the keys stored on your local machine. Navigate to the [NEAR wallet](https://testnet.mynearwallet.com/) site and create an account.

<div class="alert alert-info" role="alert"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 14 16"><path fill-rule="evenodd" d="M7 2.3c3.14 0 5.7 2.56 5.7 5.7s-2.56 5.7-5.7 5.7A5.71 5.71 0 0 1 1.3 8c0-3.14 2.56-5.7 5.7-5.7zM7 1C3.14 1 0 4.14 0 8s3.14 7 7 7 7-3.14 7-7-3.14-7-7-7zm1 3H6v5h2V4zm0 6H6v2h2v-2z"></path></svg></span>info</div>Please ensure that you deploy the contract to an account with no pre-existing contracts. It's easiest to simply create a new account or create a sub-account for this tutorial.
</div>

Log in to your newly created account with [`near-cli-rs`](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/4.tools/cli.md) by running the following command in your terminal.

```bash
near account import-account using-web-wallet network-config testnet
To make this tutorial easier to copy/paste, we're going to set an environment variable for your account ID. In the command below, replace YOUR_ACCOUNT_NAME with the account name you just logged in with including the .testnet portion:
export NFT_CONTRACT_ID="YOUR_ACCOUNT_NAME"
Test that the environment variable is set correctly by running:
echo $NFT_CONTRACT_ID
Verify that the correct account ID is printed in the terminal. If everything looks correct you can now deploy your contract.
In the root of your NFT project run the following command to deploy your smart contract and answer questions:
cargo near deploy $NFT_CONTRACT_ID

> Select the need for initialization: with-init-call     - Add an initialize
> What is the name of the function? new_default_meta
> How would you like to pass the function arguments? json-args
> Enter the arguments to this function: {"owner_id": "<YOUR_NFT_CONTRACT_ID>"}
> Enter gas for function call: 100 TeraGas
> Enter deposit for a function call (example: 10NEAR or 0.5near or 10000yoctonear): 0 NEAR
> What is the name of the network? testnet
> Select a tool for signing the transaction: sign-with-keychain
> How would you like to proceed? send
You don't need to answer these questions every time. If you look at the results you will find the message Here is the console command if you ever need to re-run it again. The next line is the command which you may use instead of answering to interactive questions:
cargo near deploy $NFT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
You've just deployed and initialized the contract with some default metadata and set your account ID as the owner. At this point, you're ready to call your first view function.

Viewing the contract's metadata
Now that the contract has been initialized, you can call some of the functions you wrote earlier. More specifically, let's test out the function that returns the contract's metadata:

  

  ```bash
  near view $NFT_CONTRACT_ID nft_metadata '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_metadata json-args {} network-config testnet now
  ```
  

This should return an output similar to the following:
{
  spec: 'nft-1.0.0',
  name: 'NFT Tutorial Contract',
  symbol: 'GOTEAM',
  icon: null,
  base_uri: null,
  reference: null,
  reference_hash: null
}
At this point, you're ready to move on and mint your first NFT.

Minting our first NFT
Let's now call the minting function that you've created. This requires a token_id and metadata. If you look back at the TokenMetadata struct you created earlier, there are many fields that could potentially be stored on-chain:

Let's mint an NFT with a title, description, and media to start. The media field can be any URL pointing to a media file. We've got an excellent GIF to mint but if you'd like to mint a custom NFT, simply replace our media link with one of your choosing. If you run the following command, it will mint an NFT with the following parameters:

token_id: "token-1"
metadata:

title: "My Non Fungible Team Token"
description: "The Team Most Certainly Goes :)"
media: https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif
receiver_id: "'$NFT_CONTRACT_ID'"



  

  ```bash
  near call $NFT_CONTRACT_ID nft_mint '{"token_id": "token-1", "metadata": {"title": "My Non Fungible Team Token", "description": "The Team Most Certainly Goes :)", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' --gas 100000000000000 --deposit 0.1 --accountId $NFT_CONTRACT_ID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction $NFT_CONTRACT_ID nft_mint json-args '{"token_id": "token-1", "metadata": {"title": "My Non Fungible Team Token", "description": "The Team Most Certainly Goes :)", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$NFT_CONTRACT_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT_ID network-config testnet sign-with-keychain send
    ```
  

infoThe `amount` flag is specifying how much NEAR to attach to the call. Since you need to pay for storage, 0.1 NEAR is attached and you'll get refunded any excess that is unused at the end.


Viewing information about the NFT
Now that the NFT has been minted, you can check and see if everything went correctly by calling the nft_token function.
This should return a JsonToken which should contain the token_id, owner_id, and metadata.

  

  ```bash
  near view $NFT_CONTRACT_ID nft_token '{"token_id": "token-1"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $NFT_CONTRACT_ID nft_token json-args '{"token_id": "token-1"}' network-config testnet now
  ```
  


Example response: 


```bash
{
  token_  owner_  metadata: {
     'My Non Fungible Team Token',
    description: 'The Team Most Certainly Goes :)',
    media: 'https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif',
    media_hash: null,
    copies: null,
    issued_at: null,
    expires_at: null,
    starts_at: null,
    updated_at: null,
    extra: null,
    reference: null,
    reference_hash: null
  }
}
```



Go team! You've now verified that everything works correctly and it's time to view your freshly minted NFT in the NEAR wallet's collectibles tab!

Viewing your NFTs in the wallet
If you navigate to the collectibles tab in the NEAR wallet, this should list all the NFTs that you own. It should look something like the what's below.

We've got a problem. The wallet correctly picked up that you minted an NFT, however, the contract doesn't implement the specific view function that is being called. Behind the scenes, the wallet is trying to call nft_tokens_for_owner to get a list of all the NFTs owned by your account on the contract. The only function you've created, however, is the nft_token function. It wouldn't be very efficient for the wallet to call nft_token for every single NFT that a user has to get information and so they try to call the nft_tokens_for_owner function.
In the next tutorial, you'll learn about how to deploy a patch fix to a pre-existing contract so that you can view the NFT in the wallet.

Conclusion
In this tutorial, you went through the basics of setting up and understand the logic behind minting NFTs on the blockchain using a skeleton contract.
You first looked at what it means to mint NFTs and how to break down the problem into more feasible chunks. You then started modifying the skeleton contract chunk by chunk starting with solving the problem of storing information / state on the contract. You then looked at what to put in the metadata and token information. Finally, you looked at the logic necessary for minting NFTs.
After the contract was written, it was time to deploy to the blockchain. You deployed the contract and initialized it. Finally, you minted your very first NFT and saw that some changes are needed before you can view it in the wallet.

Next Steps
In the next tutorial, you'll find out how to deploy a patch fix and what that means so that you can view your NFTs in the wallet.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-cli-rs: `0.11.0`
- cargo-near `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`
- Metadata standard: [NEP177](https://nomicon.io/Standards/Tokens/NonFungibleToken/Metadata), version `2.1.0`

### Skeleton and Rust Architecture

In this article, you'll learn about the basic architecture behind the NFT contract that you'll develop while following this "Zero to Hero" series.
You'll discover the contract's layout and you'll see how the Rust files are structured in order to build a feature-complete smart contract.
infoSkeleton Contract
You can find the skeleton contract in our [GitHub repository](https://github.com/near-examples/nft-tutorial/tree/main/nft-contract-skeleton)

infoNew to Rust?
If you are new to Rust and want to dive into smart contract development, our [Quick-start guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) is a great place to start.


Introduction
This tutorial presents the code skeleton for the NFT smart contract and its file structure.
Once every file and functions have been covered, we will guide you through the process of building the mock-up contract to confirm that your Rust setup works.

File structure
Following a regular Rust project, the file structure for this smart contract has:
nft-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
└── src
    ├── approval.rs
    ├── enumeration.rs
    ├── lib.rs
    ├── metadata.rs
    ├── mint.rs
    ├── nft_core.rs
    ├── events.rs
    └── royalty.rs

The file Cargo.toml defines the code dependencies
The src folder contains all the Rust source files


Source files
Here is a brief description of what each source file is responsible for:



File
Description




approval.rs
Has the functions that controls the access and transfers of non-fungible tokens


enumeration.rs
Contains the methods to list NFT tokens and their owners


lib.rs
Holds the smart contract initialization functions


metadata.rs
Defines the token and metadata structure


mint.rs
Contains token minting logic


nft_core.rs
Core logic that allows you to transfer NFTs between users.


royalty.rs
Contains payout-related functions


events.rs
Contains events related structures



tipxplore the code in our [GitHub repository](https://github.com/near-examples/nft-tutorial/).


approval.rs

This allows people to approve other accounts to transfer NFTs on their behalf.

This file contains the logic that complies with the standard's approvals management extension. Here is a breakdown of the methods and their functions:



Method
Description




nft_approve
Approves an account ID to transfer a token on your behalf.


nft_is_approved
Checks if the input account has access to approve the token ID.


nft_revoke
Revokes a specific account from transferring the token on your behalf.


nft_revoke_all
Revokes all accounts from transferring the token on your behalf.


nft_on_approve
This callback function, initiated during nft_approve, is a cross contract call to an external contract.




You'll learn more about these functions in the approvals section of the Zero to Hero series.

enumeration.rs

This file provides the functions needed to view information about NFTs, and follows the standard's enumeration extension.




Method
Description




nft_total_supply
Returns the total amount of NFTs stored on the contract


nft_tokens
Returns a paginated list of NFTs stored on the contract regardless of their owner.


nft_supply_for_owner
Allows you view the total number of NFTs owned by any given user


nft_tokens_for_owner
Returns a paginated list of NFTs owned by any given user




You'll learn more about these functions in the enumeration section of the tutorial series.

lib.rs

This file outlines what information the contract stores and keeps track of.




Method
Description




new_default_meta
Initializes the contract with default metadata so the user doesn't have to provide any input.


new
Initializes the contract with the user-provided metadata.



infoKeep in mind
The initialization functions (`new`, `new_default_meta`) can only be called once.


You'll learn more about these functions in the minting section of the tutorial series.

metadata.rs

This file is used to keep track of the information to be stored for tokens, and metadata.
In addition, you can define a function to view the contract's metadata which is part of the standard's metadata extension.




Name
Description




TokenMetadata
This structure defines the metadata that can be stored for each token (title, description, media, etc.).


Token
This structure outlines what information will be stored on the contract for each token.


JsonToken
When querying information about NFTs through view calls, the return information is stored in this JSON token.


nft_metadata
This function allows users to query for the contact's internal metadata.




You'll learn more about these functions in the minting section of the tutorial series.

mint.rs

Contains the logic to mint the non-fungible tokens




Method
Description




nft_mint
This function mints a non-fungible token.





nft_core.rs

Core logic that allows to transfer NFTs between users.




Method
Description




nft_transfer
Transfers an NFT to a receiver ID.


nft_transfer_call
Transfers an NFT to a receiver and calls a function on the receiver ID's contract. The function returns true if the token was transferred from the sender's account.


nft_token
Allows users to query for the information about a specific NFT.


nft_on_transfer
Called by other contracts when an NFT is transferred to your contract account via the nft_transfer_call method. It returns true if the token should be returned back to the sender.


nft_resolve_transfer
When you start the nft_transfer_call and transfer an NFT, the standard also calls a method on the receiver's contract. If the receiver needs you to return the NFT to the sender (as per the return value of the nft_on_transfer method), this function allows you to execute that logic.




You'll learn more about these functions in the core section of the tutorial series.

royalty.rs

Contains payout-related functions.




Method
Description




nft_payout
This view method calculates the payout for a given token.


nft_transfer_payout
Transfers the token to the receiver ID and returns the payout object that should be paid for a given balance.




You'll learn more about these functions in the royalty section of the tutorial series.

events.rs

Contains events-related structures.




Method
Description




EventLogVariant
This enum represents the data type of the EventLog.


EventLog
Interface to capture data about an event.


NftMintLog
An event log to capture token minting.


NftTransferLog
An event log to capture token transfer.




You'll learn more about these functions in the events section of the tutorial series.

Building the skeleton
If you haven't cloned the main repository yet, open a terminal and run:
git clone https://github.com/near-examples/nft-tutorial/
Next, go to the nft-contract-skeleton/ folder and build the contract with cargo-near:
cd nft-tutorial
cd nft-contract-skeleton/
cargo near build
Since this source is just a skeleton you'll get many warnings about unused code, such as:
   Compiling nft_contract_skeleton v0.1.0 (/Users/near-examples/Documents/my/projects/near/examples/nft-tutorial/nft-contract-basic)
 │ warning: unused imports: `LazyOption`, `LookupMap`, `UnorderedMap`, `UnorderedSet`
 │  --> src/lib.rs:3:29
 │   |
 │ 3 | use near_sdk::collections::{LazyOption, LookupMap, UnorderedMap, UnorderedSet};
 │   |                             ^^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^^^^  ^^^^^^^^^^^^
 │   |
 │   = note: `#[warn(unused_imports)]` on by default
 │
 │ warning: unused import: `Base64VecU8`
 │  --> src/lib.rs:4:28
 │   |
 │ 4 | use near_sdk::json_types::{Base64VecU8, U128};
 │   |

 │ warning: `nft_contract_skeleton` (lib) generated 48 warnings (run `cargo fix --lib -p nft_contract_skeleton` to apply 45 suggestions)
 │     Finished release [optimized] target(s) in 11.01s
 ✓ Contract successfully built!
Don't worry about these warnings, you're not going to deploy this contract yet.
Building the skeleton is useful to validate that your Rust toolchain works properly and that you'll be able to compile improved versions of this NFT contract in the upcoming tutorials.

Conclusion
You've seen the layout of this NFT smart contract, and how all the functions are laid out across the different source files.
Using yarn, you've been able to compile the contract, and you'll start fleshing out this skeleton in the next Minting tutorial.
noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.76.0`
- near-sdk-rs: `5.1.0`
- cargo-near: `0.6.1`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### Pre-deployed Contract

Create your first non-fungible token by using a pre-deployed NFT smart contract which works exactly as the one you will build on this tutorial.

Prerequisites
To complete this tutorial successfully, you'll need a NEAR Wallet and NEAR CLI

Using the NFT contract
Minting an NFT token on NEAR is a simple process that involves calling a smart contract function.
To interact with the contract you will need to first login to your NEAR account through near-cli.

Setup
Log in to your newly created account with near-cli by running the following command in your terminal:
near account import-account using-web-wallet network-config testnet
Set an environment variable for your account ID to make it easy to copy and paste commands from this tutorial:
export NEARID=YOUR_ACCOUNT_NAME

Minting your NFTs
We have already deployed an NFT contract to nft.examples.testnet which allows users to freely mint tokens. Let's use it to mint our first token.
Run this command in your terminal, remember to replace the token_id with a string of your choice. This string will uniquely identify the token you mint.

  

  ```bash
  near call nft.examples.testnet nft_mint '{"token_id": "TYPE_A_UNIQUE_VALUE_HERE", "receiver_id": "'$NEARID'", "metadata": { "title": "GO TEAM", "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "copies": 1}}' --gas 100000000000000 --deposit 0.1 --accountId $NEARID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction nft.examples.testnet nft_mint json-args '{"token_id": "TYPE_A_UNIQUE_VALUE_HERE", "receiver_id": "'$NEARID'", "metadata": { "title": "GO TEAM", "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "copies": 1}}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NEARID network-config testnet sign-with-keychain send
    ```
  


Example response: 


```json
Log [nft.examples.testnet]: EVENT_JSON:{"standard":"nep171","version":"nft-1.0.0","event":"nft_mint","data":[{"owner_id":"benjiman.testnet","token_ids":["TYPE_A_UNIQUE_VALUE_HERE"]}]}
Transaction Id 8RFWrQvAsm2grEsd1UTASKpfvHKrjtBdEyXu7WqGBPUr
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/8RFWrQvAsm2grEsd1UTASKpfvHKrjtBdEyXu7WqGBPUr
''
```



tipou can also replace the `media` URL with a link to any image file hosted on your web server.


Querying your NFT
To view tokens owned by an account you can call the NFT contract with the following near-cli command:

  

  ```bash
  near view nft.examples.testnet nft_tokens_for_owner '{"account_id": "'$NEARID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only nft.examples.testnet nft_tokens_for_owner json-args '{"account_id": "'$NEARID'"}' network-config testnet now
  ```
  


Example response: 


```json
[
  {
    "token_id": "Goi0CZ",
    "owner_id": "bob.testnet",
    "metadata": {
      "title": "GO TEAM",
      "description": "The Team Goes",
      "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/",
      "media_hash": null,
      "copies": 1,
      "issued_at": null,
      "expires_at": null,
      "starts_at": null,
      "updated_at": null,
      "extra": null,
      "reference": null,
      "reference_hash": null
    },
    "approved_account_ids": {}
  }
]
```



Congratulations! You just minted your first NFT token on the NEAR blockchain! 🎉
Now try going to your NEAR Wallet and view your NFT in the "Collectibles" tab.

Final remarks
This basic example illustrates all the required steps to call an NFT smart contract on NEAR and start minting your own non-fungible tokens.
Now that you're familiar with the process, you can jump to Contract Architecture and learn more about the smart contract structure and how you can build your own NFT contract from the ground up.
Happy minting! 🪙
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli-rs: `0.11.0`
- NFT standard: [NEP171](https://nomicon.io/Standards/Tokens/NonFungibleToken/Core), version `1.0.0`

### NFT Zero to Hero

In this Zero to Hero series, you'll find a set of tutorials that will cover every aspect of a non-fungible token (NFT) smart contract.
You'll start by minting an NFT using a pre-deployed contract and by the end you'll end up building a fully-fledged NFT smart contract that supports every extension.

Prerequisites
To complete these tutorials successfully, you'll need:

Rust
A Testnet wallet
NEAR-CLI
cargo-near

infoNew to Rust?
If you are new to Rust and want to dive into smart contract development, our [Quick-start guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) is a great place to start


Overview
These are the steps that will bring you from Zero to Hero in no time! 💪



Step
Name
Description




1
Pre-deployed contract
Mint an NFT without the need to code, create, or deploy a smart contract.


2
Contract architecture
Learn the basic architecture of the NFT smart contract and compile code.


3
Minting
Flesh out the skeleton so the smart contract can mint a non-fungible token.


4
Upgrade a contract
Discover the process to upgrade an existing smart contract.


5
Enumeration
Explore enumeration methods that can be used to return the smart contract's states.


6
Core
Extend the NFT contract using the core standard which allows token transfer.


7
Events
The events extension, allowing the contract to react on certain events.


8
Approvals
Expand the contract allowing other accounts to transfer NFTs on your behalf.


9
Royalty
Add NFT royalties allowing for a set percentage to be paid out to the token creator.


10
Marketplace
Learn about how common marketplaces operate on NEAR and dive into some of the code that allows buying and selling NFTs.




Next steps
Ready to start? Jump to the Pre-deployed Contract tutorial and begin your learning journey!
If you already know about non-fungible tokens and smart contracts, feel free to skip and jump directly to the tutorial of your interest. The tutorials have been designed so you can start at any given point!

### Push Notifications

Push messages enable your gateway to send notifications on desktop and mobile devices even when the users are not active.
To implement push notifications, you need to:

Create a Service Worker
Ask the user for permission to send push notifications
Send the client identifier information to our notification server
Add logic to display the notifications

tipxample
Check our working example at https://github.com/near-examples/BOS-notifications


Create the Service Worker
Push notifications work by having a service worker on the client side that listens for messages from the NEAR notifications server.

    

Browsers readily provide native support for service workers, so you can easily check if a service worker exists, and create one if not.

Subscribe to our Notifications
In order to have the service worker display notifications, you need to subscribe it to a notifications server.
A notification server is identified by its public key, constraining that only the server holding the private counterpart can push notifications to the user.

    

tipermission
When you subscribe to the service, the user will be asked for permission to be sent notifications.


Create a Stream in our Server
After you subscribe the user to a notifications server, share it with us so we can start sending you notifications!
For this, make a post request to our server, add which account you want to be notified for, and a URL identifying your gateway.

    

tiphe `gateway` parameter is there just to help us keep track of who receives notifications.


Handle Notifications
When the user receives a notification, the service worker will be triggered, and you can add logic to display the notification.

    

Feel free to personalize the notification as you wish, and to add logic on what to do once the notification is clicked. In our example, we just open the Post page.

### Using IFrames

Iframes
In this tutorial you'll learn how to use the iframe VM tag and the Iframe resizer library, so you can embed external HTML or use custom DOM elements when building NEAR components.
You can use it along the rest of approved VM tags to simplify your component development.
Using IFrames on NEAR VM
Iframes can be used to embed external HTML or to use custom DOM
elements, for example canvas.
Properties
The iframe tag takes the following properties: className, style, src,
srcDoc, title, message, and onMessage. The iframe has a sandbox property
set to sandbox="allow-scripts", which only allows scripts.
info
message and onMessage are used to communicate with this iframe
instance.




param
description




message
it's passed to the iframe every time the deep equal is different, or the iframe is recreated. The message is passed using contentWindow.postMessage(message, "*") on the iframe.


onMessage(data)
it's called when the iframe passes a message to window.top. Only event.data is passed to the onMessage



Events
The VM exposes the following <iframe> events:


onLoad(): support for onLoad event without any event info
<iframe onLoad={() => { console.log('iframe loaded') }}>


onResized(): support for onResized Iframe Resizer event with an object only containing the new width and height
<iframe iframeResizer={{
  onResized: ({width, height}) => { console.log('iframe resized', width, height) },
}}>


Example
The following example demonstrates how you can use an iframe to call
eval:
State.init({
  text: `"b" + "a" + +"a" + "a"`,
});

const code = `
<div>Expression: <pre id="exp" /></div>
<div>Results: <pre id="res" /></div>

<script>
    window.top.postMessage("loaded", "*");
    window.addEventListener("message", (event) => {
        const data = event.data
        document.getElementById("exp").innerHTML = JSON.stringify(data);
        try {
            const result = eval(data.exp);
            document.getElementById("res").innerHTML = result;
            event.source.postMessage(result, "*");
        } catch (e) {
            // ignore
        }
    }, false);
</script>
`;

return (
  <div>
    <input
      value={state.text || ""}
      onChange={(e) => State.update({ text: e.target.value })}
    />
    Iframes below
    <div className="d-flex">
      <iframe
        className="w-50 border"
        srcDoc={code}
        message={{ exp: state.text || "" }}
        onMessage={(res1) => State.update({ res1 })}
      />
      <iframe
        className="w-50 border"
        srcDoc={code}
        message={{ exp: (state.text || "") + " + ' banana'" }}
        onMessage={(res2) => State.update({ res2 })}
      />
    </div>
    Result:{" "}
    <pre>
      res1 = {JSON.stringify(state.res1)}
      res2 = {JSON.stringify(state.res2)}
    </pre>
  </div>
);

Iframe Resizer

Iframe Resizer is a critical library for rendering responsive iframes. This library automatically resizes the iframe to match the child content size to avoid scrollbars on the iframe itself.
::caution don't forget

The child page rendered by the iframe must include this script in order for the resizing to work:
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.6/iframeResizer.contentWindow.js"></script>
:::
note
NEAR VM uses the React flavor of this plugin.

Basic Example
You can use the Iframe resizer library like this:
return (
  <div>
    <iframe
      iframeResizer
      src="https://davidjbradshaw.com/iframe-resizer/example/frame.content.html"
    />
  </div>
);
If you need to pass in options to override the default behavior:
return (
  <div>
    <iframe
      iframeResizer={{ log: true }}
      src="https://davidjbradshaw.com/iframe-resizer/example/frame.content.html"
    />
  </div>
);

tipYou can check [this example](https://near.org/near/widget/ComponentDetailsPage?src=calebjacob.near/widget/IframeResizerTest) to see a complete component using Iframe Resizer.


srcDoc Example
An example of a valid srcDoc for a secure Iframe using iframeResizer:
const code = `
<script>
// ...your code...

// define message handler
const handleMessage = (m) => {
  console.log('received message', m)
  document.getElementById("messageText").innerHTML = m;
};

// finally, configure iframe resizer options before importing the script
window.iFrameResizer = {
    onMessage: handleMessage
  }
</script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.6/iframeResizer.contentWindow.js"></script>
<p id="messageText">loading...</p>
`;

return (
  <div>
    <iframe
      iframeResizer
      className="w-100"
      srcDoc={code}
      message="my message"
    />
  </div>
);

### Smart Contract Interaction

Your frontend can interact with different blockchains using the built-in BOS API. Let's see how to create an application that reads and stores a greeting from a NEAR smart contract. 

View of our Hello Near app when the user is logged-in
infoCheck the finished example at [near.social code page](https://near.social/#/mob.near/widget/WidgetSource?src=gagdiez.near/widget/HelloNear).


The Contract
We have deployed a Hello World smart contract in the NEAR network at hello.near-examples.near. The contract exposes two methods:

set_greeting(greeting: string): void, which accepts a greeting and stores it in the contract state.
get_greeting(): string which returns the stored greeting.


Retrieving the Greeting
Since we want to interact with the NEAR network, we will use the Near object from the BOS API.
const contract = "hello.near-examples.near";
const greeting = Near.view(contract, "get_greeting", {});

return <div>{greeting} World</div>;
Assuming the contract is storing "Hello", this will render a simple:
Hello World

Changing the Greeting
To modify the greeting, we simply need to use Near.call to call the set_greeting method. This however, requires us to have a frontend in which the user can input the new greeting.
Lets create it in two steps:

Build the HTML that will be rendered
Add the logic to handle the function call


1. HTML Components
Use the following code to create a simple frontend, composed by a title, an input form to change the greeting, and a button to submit the change.
const contract = "hello.near-examples.near";
const greeting = Near.view(contract, "get_greeting", {});

// Define components
const greetingForm = (
  <>
    <div className="border border-black p-3">
      <label>Update greeting</label>
      <input placeholder="Howdy" onChange={onInputChange} />
      <button className="btn btn-primary mt-2" onClick={onBtnClick}>
        Save
      </button>
    </div>
  </>
);

const notLoggedInWarning = <p> Login to change the greeting </p>;

// Render
return (
  <>
    <div className="container border border-info p-3">
      <h3 className="text-center">
        The contract says:
        <span className="text-decoration-underline"> {greeting} </span>
      </h3>

      <p className="text-center py-2">
        Look at that! A greeting stored on the NEAR blockchain.
      </p>

      {context.accountId ? greetingForm : notLoggedInWarning}
    </div>
  </>
);
infoRelevant HTML
There are two important things to notice in the code above:

1. **onChange & onClick**: We have prepared our `` and `` to act when something happens. Particularly, we will build two methods: one when the input changes, and one when the button is pressed.

2. **context.accountId**: We check if `context.accountId` is set, which tells us if the user has logged in using their NEAR account, and thus can interact with NEAR contracts.


2. Handling User's Input
Having our component's view ready, we now need to define the logic for when the user inputs a new greeting and presses the Submit button. This is, we need to define the onInputChange and onBtnClick methods.
onInputChange
When the user inputs a new greeting, we want to store it somewhere until the Submit button is pressed, for this, we can use the application's State.
In BOS, the state is initialized through State.init, updated with State.update, and accessed through the state variable (notice the lowercase). Lets store the new greeting in the App's state:
State.init({ new_greeting: "" });

const onInputChange = ({ target }) => {
  State.update({ new_greeting: target.value });
};
onBtnClick
The only thing left to do, is to handle when the user clicks the Submit button. What we want is to check if the user changed the greeting, and submit it to the contract.
const onBtnClick = () => {
  if (!state.new_greeting) {
    return;
  }

  Near.call(contract, "set_greeting", {
    greeting: state.new_greeting,
  });
};

Complete Example
We have deployed a complete version of this example on the NEAR blockchain, so you can see its code and play with it.
tip **Code**: Check the code of this example at the [near.social code page](https://near.social/#/mob.near/widget/WidgetSource?src=gagdiez.near/widget/HelloNear).

- **Try It**: Interact with the application at the [near.social page](https://near.social/#/gagdiez.near/widget/HelloNear).

### Lido Example

Hello Lido!
If you are ready to explore further, the Lido component serves as an excellent fully-fledged example, as it demonstrates how to interact with a smart contract deployed on the Ethereum mainnet.
infoEthers.js

This component uses the [Ethers JavaScript](https://ethers.org) library to interact with Ethereum smart contracts. Follow [this link](https://docs.ethers.org/v6/) for the official `ethers.js` documentation.


infoWeb3 connect

The Lido example uses the [Web3Connect component](https://near.org/near/widget/ComponentDetailsPage?src=a_liutiev.near/widget/button_web3connect) to provide a [WalletConnect modal](https://github.com/WalletConnect/web3modal) so the user can connect with any Web3 Ethereum wallet like Ledger or MetaMask.


Fork the component

Navigate to the component
Select Fork
Feel free to make any changes
Click on Save to deploy the component

noteTo deploy the component, you'll need to sign in with a NEAR account and to make a deposit of a small amount of NEAR for the storage cost. This is because the components are stored in the NEAR network.

Source code
if (
  state.chainId === undefined &&
  ethers !== undefined &&
  Ethers.send("eth_requestAccounts", [])[0]
) {
  Ethers.provider()
    .getNetwork()
    .then((chainIdData) => {
      if (chainIdData?.chainId) {
        State.update({ chainId: chainIdData.chainId });
      }
    });
}
if (state.chainId !== undefined && state.chainId !== 1) {
  return <p>Switch to Ethereum Mainnet</p>;
}

// FETCH LIDO ABI

const lidoContract = "0xae7ab96520de3a18e5e111b5eaab095312d7fe84";
const tokenDecimals = 18;

const lidoAbi = fetch(
  "https://raw.githubusercontent.com/lidofinance/lido-subgraph/master/abis/Lido.json"
);
if (!lidoAbi.ok) {
  return "Loading";
}

const iface = new ethers.utils.Interface(lidoAbi.body);

// FETCH LIDO STAKING APR

if (state.lidoArp === undefined) {
  const apr = fetch(
    "https://api.allorigins.win/get?url=https://stake.lido.fi/api/sma-steth-apr"
  );
  if (!apr) return;
  State.update({ lidoArp: JSON.parse(apr?.body?.contents) ?? "..." });
}

// HELPER FUNCTIONS

const getStakedBalance = (receiver) => {
  const encodedData = iface.encodeFunctionData("balanceOf", [receiver]);

  return Ethers.provider()
    .call({
      to: lidoContract,
      data: encodedData,
    })
    .then((rawBalance) => {
      const receiverBalanceHex = iface.decodeFunctionResult(
        "balanceOf",
        rawBalance
      );

      return Big(receiverBalanceHex.toString())
        .div(Big(10).pow(tokenDecimals))
        .toFixed(2)
        .replace(/d(?=(d{3})+.)/g, "$&,");
    });
};

const submitEthers = (strEther, _referral) => {
  if (!strEther) {
    return console.log("Amount is missing");
  }
  const erc20 = new ethers.Contract(
    lidoContract,
    lidoAbi.body,
    Ethers.provider().getSigner()
  );

  let amount = ethers.utils.parseUnits(strEther, tokenDecimals).toHexString();

  erc20.submit(lidoContract, { value: amount }).then((transactionHash) => {
    console.log("transactionHash is " + transactionHash);
  });
};

// DETECT SENDER

if (state.sender === undefined) {
  const accounts = Ethers.send("eth_requestAccounts", []);
  if (accounts.length) {
    State.update({ sender: accounts[0] });
    console.log("set sender", accounts[0]);
  }
}

//if (!state.sender)  return "Please login first";

// FETCH SENDER BALANCE

if (state.balance === undefined && state.sender) {
  Ethers.provider()
    .getBalance(state.sender)
    .then((balance) => {
      State.update({ balance: Big(balance).div(Big(10).pow(18)).toFixed(2) });
    });
}

// FETCH SENDER STETH BALANCE

if (state.stakedBalance === undefined && state.sender) {
  getStakedBalance(state.sender).then((stakedBalance) => {
    State.update({ stakedBalance });
  });
}

// FETCH TX COST

if (state.txCost === undefined) {
  const gasEstimate = ethers.BigNumber.from(1875000);
  const gasPrice = ethers.BigNumber.from(1500000000);

  const gasCostInWei = gasEstimate.mul(gasPrice);
  const gasCostInEth = ethers.utils.formatEther(gasCostInWei);

  let responseGql = fetch(
    "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2",
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query: `{
          bundle(            ethPrice
          }
        }`,
      }),
    }
  );

  if (!responseGql) return "";

  const ethPriceInUsd = responseGql.body.data.bundle.ethPrice;

  const txCost = Number(gasCostInEth) * Number(ethPriceInUsd);

  State.update({ txCost: `$${txCost.toFixed(2)}` });
}

// FETCH CSS

const cssFont = fetch(
  "https://fonts.googleapis.com/css2?family=Manrope:wght@200;300;400;500;600;700;800"
).body;
const css = fetch(
  "https://pluminite.mypinata.cloud/ipfs/Qmboz8aoSvVXLeP5pZbRtNKtDD3kX5D9DEnfMn2ZGSJWtP"
).body;

if (!cssFont || !css) return "";

if (!state.theme) {
  State.update({
    theme: styled.div`
    font-family: Manrope, -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Oxygen, Ubuntu, Cantarell, Fira Sans, Droid Sans, Helvetica Neue, sans-serif;
    ${cssFont}
    ${css}
`,
  });
}
const Theme = state.theme;

// OUTPUT UI

const getSender = () => {
  return !state.sender
    ? ""
    : state.sender.substring(0, 6) +
        "..." +
        state.sender.substring(state.sender.length - 4, state.sender.length);
};

return (
  <Theme>
    <div className="LidoContainer">
      <div className="Header">Stake Ether</div>
      <div className="SubHeader">Stake ETH and receive stETH while staking.</div>

      <div className="LidoForm">
        {state.sender && (
          <>
            <div className="LidoFormTopContainer">
              <div className="LidoFormTopContainerLeft">
                <div className="LidoFormTopContainerLeftContent1">
                  <div className="LidoFormTopContainerLeftContent1Container">
                    <span>Available to stake</span>
                    <div className="LidoFormTopContainerLeftContent1Circle" />
                  </div>
                </div>
                <div className="LidoFormTopContainerLeftContent2">
                  <span>
                    {state.balance ?? (!state.sender ? "0" : "...")}&nbsp;ETH
                  </span>
                </div>
              </div>
              <div className="LidoFormTopContainerRight">
                <div className="LidoFormTopContainerRightContent1">
                  <div className="LidoFormTopContainerRightContent1Text">
                    <span>{getSender()}</span>
                  </div>
                </div>
              </div>
            </div>
            <div className="LidoSplitter" />
          </>
        )}
        <div
          className={
            state.sender ? "LidoFormBottomContainer" : "LidoFormTopContainer"
          }
        >
          <div className="LidoFormTopContainerLeft">
            <div className="LidoFormTopContainerLeftContent1">
              <div className="LidoFormTopContainerLeftContent1Container">
                <span>Staked amount</span>
              </div>
            </div>
            <div className="LidoFormTopContainerLeftContent2">
              <span>
                {state.stakedBalance ?? (!state.sender ? "0" : "...")}
                &nbsp;stETH
              </span>
            </div>
          </div>
          <div className="LidoFormTopContainerRight">
            <div className="LidoAprContainer">
              <div className="LidoAprTitle">Lido APR</div>
              <div className="LidoAprValue">{state.lidoArp ?? "..."}%</div>
            </div>
          </div>
        </div>
      </div>
      <div className="LidoStakeForm">
        <div className="LidoStakeFormInputContainer">
          <span className="LidoStakeFormInputContainerSpan1">
            <svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor">
              <path
                opacity="0.6"
                d="M11.999 3.75v6.098l5.248 2.303-5.248-8.401z"
              ></path>
              <path d="M11.999 3.75L6.75 12.151l5.249-2.303V3.75z"></path>
              <path
                opacity="0.6"
                d="M11.999 16.103v4.143l5.251-7.135L12 16.103z"
              ></path>
              <path d="M11.999 20.246v-4.144L6.75 13.111l5.249 7.135z"></path>
              <path
                opacity="0.2"
                d="M11.999 15.144l5.248-2.993-5.248-2.301v5.294z"
              ></path>
              <path
                opacity="0.6"
                d="M6.75 12.151l5.249 2.993V9.85l-5.249 2.3z"
              ></path>
            </svg>
          </span>
          <span className="LidoStakeFormInputContainerSpan2">
            <input
              disabled={!state.sender}
              className="LidoStakeFormInputContainerSpan2Input"
              value={state.strEther}
              onChange={(e) => State.update({ strEther: e.target.value })}
              placeholder="Amount"
            />
          </span>
          <span
            className="LidoStakeFormInputContainerSpan3"
            onClick={() => {
              State.update({
                strEther: (state.balance > 0.05
                  ? parseFloat(state.balance) - 0.05
                  : 0
                ).toFixed(2),
              });
            }}
          >
            <button
              className="LidoStakeFormInputContainerSpan3Content"
              disabled={!state.sender}
            >
              <span className="LidoStakeFormInputContainerSpan3Max">MAX</span>
            </button>
          </span>
        </div>
        {!!state.sender ? (
          <button
            className="LidoStakeFormSubmitContainer"
            onClick={() => submitEthers(state.strEther, state.sender)}
          >
            <span>Submit</span>
          </button>
        ) : (
          <Web3Connect
            className="LidoStakeFormSubmitContainer"
            connectLabel="Connect with Web3"
          />
        )}

        <div className="LidoFooterContainer">
          {state.sender && (
            <div className="LidoFooterRaw">
              <div className="LidoFooterRawLeft">You will receive</div>
              <div className="LidoFooterRawRight">${state.strEther ?? 0} stETH</div>
            </div>
          )}
          <div className="LidoFooterRaw">
            <div className="LidoFooterRawLeft">Exchange rate</div>
            <div className="LidoFooterRawRight">1 ETH = 1 stETH</div>
          </div>
          {false && (
            <div className="LidoFooterRaw">
              <div className="LidoFooterRawLeft">Transaction cost</div>
              <div className="LidoFooterRawRight">{state.txCost}</div>
            </div>
          )}
          <div className="LidoFooterRaw">
            <div className="LidoFooterRawLeft">Reward fee</div>
            <div className="LidoFooterRawRight">10%</div>
          </div>
        </div>
      </div>
    </div>
  </Theme>
);
Fork the component

Navigate to the component
Select Fork
Feel free to make any changes
Click on Save to deploy the component

noteTo deploy the component, you'll need to sign in with a NEAR account and to make a deposit of a small amount of NEAR for the storage cost. This is because NEAR components are stored in the NEAR network.

### Design Components

Design System Components
When building components, the NEAR VM provides a complete set of Radix primitives to simplify UI development.
Radix UI
Using embedded Radix primitives on the NEAR VM is simple and straight-forward. You don't need to import any files:
return (
    <Label.Root className="LabelRoot">
      Hello World!
    </Label.Root>
);
:::caution Limitations
Currently, NEAR VM impose some limitations on the Radix UI framework:

Form component is not available.
You can't use .Portal definitions.
Using CSS is different. You'll have to use a styled.div wrapper.

:::
Using CSS
Here is an example on how to use CSS through the styled.div wrapper:
const Wrapper = styled.div`
  .SwitchRoot {
    ...
  }
  .SwitchThumb {
    ...
  }
`;

return (
  <Wrapper>
    <Switch.Root className="SwitchRoot">
      <Switch.Thumb className="SwitchThumb" />
    </Switch.Root>
  </Wrapper>
);
tipsing Wrapper

[Example widget using Wrapper](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/RadixTooltipTest)


Using styled-components
You can use styled-components in combination with Radix UI primitives. Here's an example:
const SwitchRoot = styled("Switch.Root")`
  all: unset;
  display: block;
  width: 42px;
  height: 25px;
  background-color: var(--blackA9);
  border-radius: 9999px;
  position: relative;
  box-shadow: 0 2px 10px var(--blackA7);

  &[data-state="checked"] {
    background-color: black;
  }
`;

const SwitchThumb = styled("Switch.Thumb")`
  all: unset;
  display: block;
  width: 21px;
  height: 21px;
  background-color: white;
  border-radius: 9999px;
  box-shadow: 0 2px 2px var(--blackA7);
  transition: transform 100ms;
  transform: translateX(2px);
  will-change: transform;

  &[data-state="checked"] {
    transform: translateX(19px);
  }
`;

return (
  <SwitchRoot>
    <SwitchThumb />
  </SwitchRoot>
);
tipsing styled components

[Example widget using styled components to style Radix UI](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/RadixSwitchTest).


Forward references
The NEAR VM re-implements React's forwardRef as ref="forwardedRef".
You can use ref="forwardedRef" to forward references through <Widget /> to support Radix's asChild property:
<AlertDialog.Trigger asChild>
  <Widget
    src="near/widget/TestButton"
    props={{ label: "Click Me" }}
  />
</AlertDialog.Trigger>
const Button = styled.button`
  background: #f00;
`;

return (
  <Button type="button" ref="forwardedRef">
    {props.label}: Forwarded
  </Button>
);
UI is Near
UI is Near is community-built library offering a comprehensive collection of UI components providing a solid foundation for creating intuitive and visually appealing user interfaces for dApps, wallets or other Web3 solutions.
tipYou can find the documentation, available components, and code examples following this [this link](https://www.uiisnear.xyz/).


DIG components
These are the Decentralized Interface Guidelines (DIG) components available on the NEAR VM:

DIG.Accordion
DIG.Avatar
DIG.Badge
DIG.Button
DIG.Checkbox
DIG.Chip
DIG.Dialog
DIG.DropdownMenu
DIG.Input
DIG.InputSearch
DIG.InputSelect
DIG.InputTags
DIG.InputTextarea
DIG.Tabs
DIG.Theme
DIG.Toast
DIG.Tooltip

tipIf you want to see working demos of these components, check the [DIG Overview page](https://dev.near.org/near/widget/DIG.OverviewPage).



DIG.Accordion
An accordion built with the Radix primitive.


```jsx
// Rendering the component with props
return (
            My JSX context 1.
            Here's another paragraph.
          >
        ),
      },
      {
        value: "2",
        header: "Header 2",
        content: (
          
            My JSX context 2.
            Here's another paragraph.
          >
        ),
      },
    ],
  }}
/>);
```


infoDIG.Accordion properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Accordion&tab=about) for properties and details.



DIG.Avatar
This component renders an avatar.


```jsx
const accountId = "root.near";
const profile = props.profile || Social.get(`${accountId}/profile/**`, "final");

// Rendering the component with props
return (
  
);
```


infoDIG.Avatar properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Avatar&tab=about) for properties and details.



DIG.Badge
This component renders a badge. Badges are not meant to be clickable. Refer to DIG.Button or DIG.Chip for clickable alternatives.


```jsx
// Rendering the component with props
return (
  
);
```


infoDIG.Badge properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Badge&tab=about) for properties and details.



DIG.Button
A fully featured button component that can act as a <button> or <a> tag.


```jsx
// Rendering the component with props
return ;
```


infoDIG.Button properties
[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Button&tab=about) for properties and details.



DIG.Checkbox
A checkbox built with the Radix primitive.


```jsx
// Rendering the component with props
return 
```


infoDIG.Checkbox properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Checkbox&tab=about) for properties and details.



DIG.Chip
A fully featured chip component that can act as a <button> or <a> tag.


```jsx
// Rendering the component with props
return ();
```


infoDIG.Chip properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Chip&tab=about) for properties and details.



DIG.Dialog
This Dialog component is built with the Radix primitive.


```jsx
State.init({
  dialogIsOpen: false,
});

function handleCancelFunction() {
  console.log("cancel");
}

function handleConfirmFunction() {
  console.log("confirm");
}

// Rendering the component with props
return (
  
     State.update({ dialogIsOpen: true }),
      }}
    />

     State.update({ dialogIsOpen: value }),
      }}
    />
  >
);
```


infoDIG.Dialog properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Dialog&tab=about) for properties and details.



DIG.DropdownMenu
This dropdown menu is built with the Radix primitive.


```jsx
// Rendering the component with props
return (
    ),
    header: "Dropdown header",
    items: [
      {
        name: "Profile",
        iconLeft: "ph ph-user-circle",
        iconRight: "ph ph-user-focus",
      },
      {
        subHeader: "Sub header here",
        name: "Settings",
      },
    ],
  }}
/>);
```


infoDIG.DropdownMenu properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.DropdownMenu&tab=about) for properties and details.



DIG.Input
A text input component.


```jsx
State.init({
  myValue: "",
});

// Rendering the component with props
return (
   State.update({ myValue: e.target.value }),
      value: state.myValue,
    }}
  />
);
```


infoDIG.Input properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Input&tab=about) for properties and details.



DIG.InputSearch
An input component for typing a search query.


```jsx
// Rendering the component with props
return (
   console.log(query),
    }}
  />
);
```


infoDIG.InputSearch properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.InputSearch&tab=about) for properties and details.



DIG.InputSelect
A select input component built with the Radix primitive.


```jsx
State.init({
  myValue: "c",
});

// Rendering the component with props
return (
   {
          State.update({ myValue: value });
        },
      },
    }}
  />
);
```


infoDIG.InputSelect properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.InputSelect&tab=about) for properties and details.



DIG.InputTags
An input component that handles adding and removing tags.


```jsx
State.init({
  myTags: ["food", "watermelon"],
});

// Rendering the component with props
return (
   State.update({ myTags: value }),
    }}
  />
);
```


infoDIG.InputTags properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.InputTags&tab=about) for properties and details.



DIG.InputTextarea
A textarea input component.


```jsx
State.init({
  myValue: "",
});

// Rendering the component with props
return (
   State.update({ myValue: e.target.value }),
      value: state.myValue,
    }}
  />
);
```


infoDIG.InputTextarea properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.InputTextarea&tab=about) for properties and details.



DIG.Tabs
This tabs component is built with the Radix primitive.


```jsx
// Rendering the component with props
return ();
```


infoDIG.Tabs properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Tabs&tab=about) for properties and details.



DIG.Theme
This component wraps all of NEAR Components so you don't need to render it yourself.
tipou can use any of the [CSS variables](https://near.org/near/widget/ComponentDetailsPage?src=near/widget/DIG.Theme&tab=source) defined inside `DIG.Theme`.


DIG.Toast
This toast component is built with Radix primitive.


```jsx
State.init({ showToast: false });

// Rendering the component with props
return (
   State.update({ showToast: value }),
      trigger: (
         State.update({ showToast: true }),
          }}
        />
      ),
      action: (
         State.update({ showToast: false }),
          }}
        />
      ),
      providerProps: { duration: 1000 },
    }}
  />
);
```


infoDIG.Toast properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Toast&tab=about) for properties and details.



DIG.Tooltip
A tooltip built with the Radix primitive.


```jsx
// Rendering the component with props
return (
    ),
  }}
/>);
```


infoDIG.Tooltip properties

[Click here](https://dev.near.org/#/near/widget/ComponentDetailsPage?src=near/widget/DIG.Tooltip&tab=about) for properties and details.

### BOS Loader

BOS Loader
In this article you'll learn how to develop, test, and deploy BOS components using CLI tools. You can use this workflow to tap into the colaboration, pull-request, and other GitHub benefits while still deploying components to the BOS. 
BOS Component Loader serves a local directory of component files as a JSON payload properly formatted to be plugged into a BOS redirectMap. When paired with a viewer configured to call out to this loader, it enables local component development.
Development flow


(Optional) Download and install bos CLI.
info   You need `bos` CLI if you have component code on the BOS already that you want to use or if you want to manage component deploys locally instead of the GitHub actions CI/CD.



To get component code saved on the BOS, use bos to download the source code. Otherwise, create a src folder.


Create a component within that src folder like src/<component name>.jsx.
tip  It's common practice to use `.` delimited component names for namespacing. You can handle this with folders for better files organization.

For example, `AppName.Component` → `AppName/Component.jsx`.



Download and install BOS Component Loader (bos-loader).


Run bos-loader <youraccount.near> --path src (or run from src folder)


Open https://dev.near.org/flags, and set the loader URL to http://127.0.0.1:3030.


Open https://dev.near.org/<youraccount.near>/widget/<component name> (case sensitive)
info   If you're testing on `testnet`, use your testnet account and open https://test.near.org instead.

Run `bos-loader  --path src` locally, set loader URL in https://test.near.org/flags and open `https://test.near.org//widget/` to view your component locally.

tip  You can work on multiple components at once by embedding them in a wrapper component.



Make changes to the component's code.
info   You must refresh the browser's web page to see the changes.



When you're done, use the X on the banner to stop loading locally.


Component deployment
At this point, your new component is ready to be deployed. To deploy, you can use either of the following two paths: 


Use bos CLI to deploy from command line:
bos deploy


Set up a GitHub actions deployment workflow. Check this document for instructions.


You should now be able to see your component in discovery. Happy Hacking!

### NEAR for Ethereum developers

NEAR components are chain-agnostic, enabling you to create decentralized frontends tailored for any Ethereum dApps. Throughout this article, we'll navigate prevalent use-cases with code snippets. You’ll also find links to exemplary NEAR components for reference.

Interact with Ethereum using Ethers.js
The NEAR VM has imported the Ethers.js library, allowing for seamless interaction with Ethereum nodes using JavaScript in a NEAR component.
The Ethers object exposes the provider connection:

Ethers.provider() is a read-only connection to the blockchain, which allows querying the blockchain state (e.g., account, block or transaction details), querying event logs or evaluating read-only code using call.

Ethers.provider().getSigner() abstracts the class that interacts with an account
Ethers.provider().getSigner().getBalance() returns a Promise that resolves to the account address.
Ethers.provider().getBlockNumber() looks up the current block number (i.e. height)
Ethers.provider().getFeeData() gets the best guess at the recommended FeeData


You can see various ways of using Ethers objects on the Ethers documentation portal).

Furthermore, numerous basic tools  can be found in the ethers.utils object (be aware of the lowercase 'e').

ethers.utils.parseUnits(value, unit) converts the decimal string value to a BigInt, assuming unit decimal places. The unit may the number of decimal places or the name of a unit (e.g. "gwei" for 9 decimal places).
ethers.utils.formatEther(wei) converts value into a decimal string using 18 decimal places.

Example showing the difference between Ethers.provider() and ethers.utils:
    Ethers.provider()
        .getSigner()
        .getBalance()
        .then((balance) => {
            console.log("Your ETH balance: ", ethers.utils.formatEther(balance))
        });
FAQ
How to get a user account?
const receiver = Ethers.provider().send("eth_requestAccounts", [])[0];
How to get the current chain ID?
Ethers.provider().getNetwork().then((chainIdData) => {
    console.log(chainIdData.chainId);
});
How to show a Web3Login button?
<Web3ConnectButton 
    className="my-class" 
    connectLabel="Connect Web3 Wallet" 
    disconnectLabel="Disconnect Web3 Wallet"
    connectingLabel="Connecting..." 
/>
How to load a contract ABI?
const abi = fetch(`https://eth.blockscout.com/api?module=contract&action=getabi&address=0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2`);

if (!abi.ok) {
    return "Loading";
}

console.log(abi.body.result);
How to load data from EVM nodes?
// create a contract interface
const iface = new ethers.utils.Interface(abi.body.result);

// encode the balanceOf get request
const encodedBalanceData = iface.encodeFunctionData("balanceOf", [receiver]);

// perform a call
Ethers.provider().call({
    to: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
    data: encodedBalanceData,
})
.then((rawBalance) => {
    // decode the result
    const receiverBalanceHex = iface.decodeFunctionResult(
        "balanceOf",
        rawBalance
    );
    console.log(Big(receiverBalanceHex).toFixed());
});
How to send a transaction to Ethereum nodes?
// create a contract instance
const wEthContract = new ethers.Contract(
    "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
    abi.body.result,
    Ethers.provider().getSigner()
);

// perform a given method (withdraw in this case)
wEthContract
    .withdraw(balance, {
        value: 0
    })
    .then((transactionHash) => {
        console.log(transactionHash);
    });
How to convert HEX values to human readable numbers?
// use Big().toFixed method

Big(balanceHex).toFixed()
How to locate the ABI of a Smart Contract?
Utilize platforms like etherscan.com and blockscout.com, or delve into the project's GitHub repositories and documentation.
Is there an example of applications with a description of how they were created?
Yes, there is an article that describes best practices for creating applications for Ethereum developers on NEAR, with a breakdown of individual steps.
Examples
Below is a curated list of NEAR components, developed by the community, that epitomize the best practices for creating NEAR components:

Unwrap ETH
ERC-20 Token sender
Lido Component
Swap component (a set of swap dApps for Ethereum Mainnet, Polygon Mainnet, Polygon zkevm, Aurora, NEAR, etc)
1inch
Liquity

### Best Practices for Ethereum developers on NEAR

In this example, we will create an Ethereum dApp on NEAR that functions as a portfolio manager, displaying the current balances for a list of tokens. Additionally, we will display current market value of each asset in the portfolio.
We will be using several technologies:

NEAR Components for the user interface (UI).
Ethers.js for retrieving balance data from the blockchain.
CoinGecko API for fetching static content with information about tokens and their current prices.
Social-DB for storing the list of tokens to be tracked.
GitHub Actions for caching static content, speeding up loading, and circumventing rate limits.

Step 1: Load balances from chain
Let's start with a simple example and consider an application where we want to display a user's balances for multiple tokens.
Source code
// Load current sender address if it was not loaded yet
if (state.sender == undefined && Ethers.provider()) {
  Ethers.provider()
    .send("eth_requestAccounts", [])
    .then((accounts) => {
      if (accounts.length) {
        // save sender address to the state
        State.update({ sender: accounts[0] });
      }
    });
}

// Load ERC20 ABI JSON
const erc20Abi = fetch(
  "https://ipfs.near.social/ipfs/bafkreifgw34kutqcnusv4yyv7gjscshc5jhrzw7up7pdabsuoxfhlnckrq"
);
if (!erc20Abi.ok) {
  return "Loading";
}

// Create contract interface
const iface = new ethers.utils.Interface(erc20Abi.body);

// specify list of tokens
const tokens = [
  "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", // WBTC
  "0x6b175474e89094c44da98b954eedeac495271d0f", // DAI
  "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984", // UNI
];

// load receiver's balance for a giver token
const getTokenBalance = (receiver, tokenId) => {
  // encode `balanceOf` request
  const encodedData = iface.encodeFunctionData("balanceOf", [receiver]);

  // send request to the network
  return Ethers.provider()
    .call({
      to: tokenId,
      data: encodedData,
    })
    .then((rawBalance) => {
      // decode response
      const receiverBalanceHex = iface.decodeFunctionResult(
        "balanceOf",
        rawBalance
      );

      return Big(receiverBalanceHex).toFixed(0);
    });
};

const loadTokensData = () => {
  // load balances of all tokens
  tokens.map((tokenId) => {
    getTokenBalance(state.sender, tokenId).then((value) => {
      // save balance of every token to the state
      State.update({ [tokenId]: { balance: value, ...state[tokenId] } });
    });
  });
};

const renderToken = (tokenId) => (
  <li>
    {tokenId}: {state[tokenId].balance}
  </li>
);

if (state.sender) {
  loadTokensData();

  return (
    <>
      <ul>{tokens.map((tokenId) => renderToken(tokenId))}</ul>
      <p>Your account: {state.sender} </p>
    </>
  );
} else {
  // output connect button for anon user
  return <Web3Connect />;
}
You can see how it works here: step_1.
Once the web3 connection is enabled, the output will appear as follows:
0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599: 726220
0x6b175474e89094c44da98b954eedeac495271d0f: 140325040242585301886
0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984: 127732731780832810
tiphen developing NEAR components, it's recommended to always present some content even if the user hasn't connected their wallet yet. In this example, the component uses the `` button to prompt the user to connect their wallet if they haven't already.

Step 2: Load static data
To format the list, we must determine the decimal precision for each asset. While it's possible to retrieve this information from the ERC-20 contract for each token, it's important to note that the ERC-20 contract lacks certain valuable data such as the token icon and description. As a solution, we can leverage the CoinGecko API to retrieve token details, including the current market price.
Let's add a function to load token data for a given token from the Coingecko:
const loadCoingeckData = (tokenId) => {
    let dataUrl = `https://api.coingecko.com/api/v3/coins/ethereum/contract/${tokenId}`;

    const data = fetch(dataUrl);
    if (data.ok) {
        return {
            name: data.body.name,
            icon: data.body.image.small,
            decimals: data.body.detail_platforms["ethereum"].decimal_place,
            price: Number(data.body.market_data.current_price.usd),
        };
    }
};
Other available API methods are listed in the Coingecko API documentation.
Now that we have the data, let's modify the loadTokensData function to save the token information in the state:
const loadTokensData = () => {
  // load balances of all tokens
  tokens.map((tokenId) => {
    getTokenBalance(state.sender, tokenId).then((value) => {
      // save balance of every token to the state
      State.update({ [tokenId]: { balance: value, ...state[tokenId] } });
    });
  });

  tokens.map((tokenId) => {
    const tokenData = loadCoingeckData(tokenId);
    // save balance of every token to the state
    State.update({ [tokenId]: { ...tokenData, ...state[tokenId] } });
  });
};
And lets update the renderToken function to display data we just got:
const renderToken = (tokenId) => {
  const tokenBalance = Big(state[tokenId].balance ?? 0)
    .div(new Big(10).pow(state[tokenId].decimals ?? 1))
    .toFixed(4);
  const tokenBalanceUSD = (tokenBalance * state[tokenId].price).toFixed(2);
  return (
    <li>
      {state[tokenId].name}: {tokenBalance}{" "}
      <img src={state[tokenId].icon} width="16" alt={state[tokenId].symbol} />
      {`(${tokenBalanceUSD} USD)`}
    </li>
  );
};
You can see how it works here: step_2.
Output will be like this:
Wrapped Bitcoin: 0.0073 wbtc (247.64 USD)
Dai: 140.3250 dai (140.21 USD)
Uniswap: 0.1277 uni (0.54 USD)
infoPlease note that the `fetch` function caches data and will be executed only once during loading.

tiptilize any available web-services to provide data for your application on NEAR, ensuring that the user experience is on par with traditional web 2.0 applications.

Step 3. Save data in social-db
Now, instead of hardcoding the list of tokens directly within the application code, let's transition them to an onchain data repository named social-db. This approach allows us to adjust the list of trackable tokens without having to modify the application's code. It also offers users the flexibility to select from pre-existing token lists or formulate their own.
Learn more about how key-value storage social-db works.
Here is an example of a simple application for setting tokens list in social-db. 
In this format, the data from the example will be stored in social-db.
{
"0x6b175474e89094c44da98b954eedeac495271d0f": "",
"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": "",
"0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984": ""
}
Viewing this data from the blockchain is accessible for every NEAR app or, for example, through an Explorer app.
Let's add a function to our application that will read the list of tokens.
// set list of tokens
if (!state.tokensLoaded) {
    // load tokens list from the Social DB
    const tokens = Social.get(`zavodil.near/tokens-db/*`, "final");

    if (tokens) {
        State.update({
            tokensLoaded: true,
            tokens,
        });
    }
}

const tokens = Object.keys(state.tokens ?? {});
infoIn this case, `zavodil.near` is the NEAR account of the user who created this list of tokens. Any other user can create their own list, and it will also be available in `social-db`.

You can see how it works here: step_3. The output of the data in the application remains unchanged, but now it no longer contains hardcoded values.
tipse social-db, an on-chain data storage, to decouple the data and the application. 

Step 4. Caching Data Through GitHub Actions
Ethereum-based applications frequently depend on static content sources to present details about tokens or contracts. Often, frontends pull this data from platforms like CoinGecko or CoinMarketCap, leveraging API keys to enhance the data retrieval rate limit. Without these API keys, and given a significant volume of data, fetching from these platforms can be sluggish or even disrupted. We'll showcase a serverless approach utilizing GitHub Actions. This method preserves the decentralized nature of NEAR gateways (where securely storing API keys isn't feasible), all while ensuring user ease-of-use and swift data loading.
Let's create a Node.js application that will iterate through a list of tokens from social-db and display the retrieved data along with a timestamp of the operation.

const CONTRACT_ID = "social.near";
const ETHEREUM_NETWORK_ID = "ethereum";
const FETCH_TIMEOUT = 7000;

async function connect() {
    const config = {
        networkId: "mainnet",
        keyStore: new nearAPI.keyStores.InMemoryKeyStore(),
        nodeUrl: "https://rpc.mainnet.near.org",
        walletUrl: "https://wallet.mainnet.near.org",
        helperUrl: "https://helper.mainnet.near.org",
        explorerUrl: "https://nearblocks.io",
    };
    const near = await nearAPI.connect(config);
    const account = await near.account(CONTRACT_ID);

    const contract = new nearAPI.Contract(
        account, // the account object that is connecting
        CONTRACT_ID, // name of contract you're connecting to
        {
            viewMethods: ["get"], // view methods do not change state but usually return a value
            changeMethods: [], // change methods modify state
            sender: account, // account object to initialize and sign transactions.
        }
    );

    return contract;
}

// load data from the social-db
const contract = await connect();
const data = await contract.get({ keys: ["zavodil.near/tokens-db/*"] });
const tokens = data["zavodil.near"]["tokens-db"];

// init coingecko client
const client = new cg.CoinGeckoClient({
    timeout: 5000,
    autoRetry: false,
});

let res = {};
for (let i = 0; i < Object.keys(tokens).length; i++) {
    const tokenId = Object.keys(tokens)[i];

    try {
        // load data from coingecko
        const data = await client.contract({
                        contract_address: tokenId,
        });
        // format output
        const tokenData = {
            name: data["name"],
            symbol: data["symbol"],
            icon: data["image"]?.["thumb"],
            decimals: data["detail_platforms"]?.[ETHEREUM_NETWORK_ID]?.["decimal_place"],
            price: data["market_data"]?.["current_price"]?.["usd"],
        };
        // store output
        res[tokenId] = tokenData;

        // add timeout to avoid rate limits
        await new Promise((resolve) => {
            setTimeout(resolve, FETCH_TIMEOUT);
        });
    } catch (ex) {
        console.error(tokenId, ex)
    }
}

// output results
console.log(
    JSON.stringify({
        timestamp: Date.now(),
        data: res,
    })
);

Example of this code on a github,  you can clone the repository and modify the data retrieval request as needed.
Now, we can create a GitHub worker that will execute this script and save the data to a file named tokens-db.json. Here are the instructions for the worker:
name: Tokens Data Updater
on:
  workflow_dispatch:
  schedule:
    - cron:  '*/15 * * * *'

jobs:
  updateStats:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Prepare        
        uses: actions/setup-node@v3
        with:
            node-version: 16
      - run: npm i      
      - name: Tokens Data
        run: node load > tokens-db.json              
        env:
          EXPORT_MODE: CS
      - uses: EndBug/add-and-commit@v9 
        with: 
          author_name: "Tokens Data Updater"
          add: 'tokens-db.json --force'
          message: "Tokens Data fetching"
Don't forget to grant the worker the necessary permissions to add files to your repository (Open GitHub Repository: Settings->Actions->General)
The output of this worker will be the tokens-db.json file which will be regularly updated with current data. You can easily add any private API keys required for bypassing rate limits in the worker.
Now, let's get back to the NEAR application. We need to modify the code to read data from the cached file created by GitHub Actions instead of fetching it from CoinGecko every time.
To do this, we'll make changes to the loadTokensData function:
const loadTokensData = () => {
    let cacheTokenData = {};
    // load data generated by github action
    const cachedData = fetch(
        `https://raw.githubusercontent.com/zavodil/tokens-db/main/tokens-db.json`
    );
    if (cachedData.ok) {
        const cache = JSON.parse(cachedData.body);
        const cacheDate = new Date(cache.timestamp);
        const timeDifference = Date.now() - cacheDate.getTime();
        if (timeDifference <= 30 * 60 * 1000) {  // use cached data if it is not outdated (30 min)
            cacheTokenData = cache.data;
        }

        tokens.map((tokenId) => {
            const tokenData = cacheTokenData.hasOwnProperty(tokenId)
                ? cacheTokenData?.[tokenId]
                : // load data from coingecko if we don't have cached data only
                loadCoingeckData(tokenId);
            // save balance of every token to the state
            State.update({ [tokenId]: { ...tokenData, ...state[tokenId] } });
        });
    }
};

You can see how it works here: step_4. The output of the data in the application remains the same, but now it operates more efficiently.
tipse GitHub Actions as a serverless backend for securing API keys, caching data etc.

### Blog Posts

The Blog post components enable your gateway to promote regular Near Social posts into fully fledged blog posts.
In this article you'll learn how to set up the required components so you can define a custom URL to show a clean feed of blog posts.
Setup
To set up the Blog post features on your near-discovery gateway:

Add the Blog.Feed and BlogPostPage components
Add near/widget/Blog.Feed and near/widget/BlogPostPage to your configuration




- Edit your `bos-components.ts` configuration file:







- Edit your `widgets.js` configuration file:

```js title="src/data/widgets.js"
const MainnetWidgets = {
  blog: 'near/widget/Blog.Feed',
  blogPost: 'near/widget/BlogPostPage',
  image: "mob.near/widget/Image",
  default: "mob.near/widget/Homepage",
  viewSource: "mob.near/widget/WidgetSource",
  widgetMetadataEditor: "mob.near/widget/WidgetMetadataEditor",
```




Blog feed URL
To set a custom URL such as /bosblog for your Blog feed, and define which users will be shown on it, do the following changes on your near-discovery gateway:



1. Create a folder `src/pages/` for your desired custom path (e.g., `/bosblog`)
2. Add this [`index.tsx`](https://github.com/near/near-discovery/blob/c275ab7d70a6ee7baf3a88ace1c2e02f605da644/src/pages/bosblog/index.tsx) file to `src/pages/bosblog/`:







1. Add this `BlogPage.js` file to `src/pages/`:

```js title="src/pages/BlogPage.js"

export default function BlogPage(props) {
  useHashRouterLegacy();

  const { widgetSrc } = useParams();
  const query = useQuery();
  const [widgetProps, setWidgetProps] = useState({});
  const src = widgetSrc || props.widgets.default;
  const contributors = ['near', 'jacksonthedev.near'];

  useEffect(() => {
    setWidgetProps(
      [...query.entries()].reduce((props, [key, value]) => {
        props[key] = value;
        return props;
      }, {})
    );
  }, [query]);

  if (widgetProps.accountId && widgetProps.blockHeight) {
    return (
    
      {" "}
    
    );
  }

  widgetProps.contributors = contributors;

  return (
    
      {" "}
    
  );
}
```

2. Update your `App.js` router file, adding the new route to your custom path (e.g., `/bosblog`):

```js title="src/App.js"

```

```js title="src/App.js"
            
              
              
            
            
              
              
            
```






Edit the contributors list, with the account(s) that you want to showcase on your blog feed:
const contributors = ['near', 'jacksonthedev.near'];


That's all, your gateway setup is done and you're ready to show your blog feed.
Check the next sections if you want to learn more about the blog post content formatting and how to promote social messages into blog posts.
tipIn this code example, only promoted blog posts from users `near` and `jacksonthedev.near` will appear in the Blog feed when someone browses the `/bosblog` URL.


Promoting posts
If you're using near-discovery you're all set, the Promote menu is already available using the v1.Posts.Feed component.
If you're using a different gateway or your own custom feed, and you want to allow users to promote social messages into blog posts, you can integrate this promoteToBlog code snippet:
const { accountId, blockHeight, item } = props;

const promoteToBlog = () => {
  if (state.loading) {
    return;
  }

  if (!context.accountId && props.requestAuthentication) {
    props.requestAuthentication();
    return;
  } else if (!context.accountId) {
    return;
  }

  State.update({
    loading: true,
  });

  const data = {
    index: {
      promote: JSON.stringify({
        key: context.accountId,
        value: {
          operation: "add",
          type: "blog",
          post: item,
          blockHeight,
        },
      }),
    },
  };

  Social.set(data, {
    onCommit: () => State.update({ loading: false }),
    onCancel: () =>
      State.update({
        loading: false,
      }),
  });
};
tipCheck the [`Posts.Menu`](https://near.org/near/widget/ComponentDetailsPage?src=near/widget/Posts.Menu&tab=source) component for a complete implementation that includes a drop-down menu and a button to promote a blog post.



Blog post formatting
When writing blog posts, you can format the content using standard Markdown syntax.
Markdown is an easy-to-read, easy-to-write language for formatting plain text.
The only two special cases that you should keep in mind when writing a blog post are:

the blog post's title
an optional header image

Header image
To define an image for your blog post, just add a markdown image link at the top of your post:
![header-image](https://example.com/image.png)
Blog post title
To set the post's title, define it using a top heading tag:
# This is the title of a demo blog post
tipIf you're new to Markdown, you might want to check this page about [basic writing and formatting syntax](https://www.markdownguide.org/basic-syntax/).



Writing a blog post
Adding a new blog post is simple. To publish a new blog post, you only need to:


Write a regular Near Social message



Repost the message and convert it to a Blog post
Once the message has been posted, promoting it to a blog post is straight forward.
Just click on the repost button, and select the Blog option:



That's it, your blog post has been published, and you can find it under the Blog tab in your social profile:



note
You can find the published blog post example in this link.

### Integrating FT Payments into an NFT Marketplace

In this tutorial, you'll learn the basics of how an NFT marketplace contract works and how you can modify it to allow for purchasing NFTs using Fungible Tokens. In the previous tutorials, you went through and created a fully fledged FT contract that incorporates all the standards found in the FT standard.

Introduction
Throughout this tutorial, you'll learn how a marketplace contract could work on NEAR. This is meant to be an example and there is no canonical implementation. Feel free to branch off and modify this contract to meet your specific needs.
Using the same repository as the previous tutorials, if you visit the market-contract directory, you should have the necessary files to complete the tutorial.

File structure
This directory contains the actual contract code and dependencies as outlined below.
market-contract
├── Cargo.lock
├── Cargo.toml
├── README.md
└── src
    ├── external.rs
    ├── ft_balances.rs
    ├── internal.rs
    ├── lib.rs
    ├── nft_callbacks.rs
    ├── sale.rs
    └── sale_views.rs
Let's start by building both the finished FT contract and the marketplace contract. Make sure you're in the root directory and run the following command in your terminal:
cd market-contract && cargo near build && cd ..
This will install the dependencies for the marketplace contract as well as the FT contract. Note that there's also ft-tutorial/out directory with pre-build nft contract wasm file which you'll use to place the NFTs for sale.
ft-tutorial
└── out
    └── nft-contract.wasm

Understanding the contract
The marketplace contract used in this tutorial is a modified version of the contract created at the end of the NFT zero to hero tutorial. If you'd like to learn about the backbone of how the NFTs are put for sale and the process by which they are minted / sold, check out the NFT zero to hero tutorial.
The core functionalities are the same in the sense that both this contract and the marketplace contract built in the NFT zero to hero have the following features:

Users can put NFTs for sale and specify sale conditions
Users must pay for storage deposit to put NFTs for sale and they can withdraw the storage at any time
Users can update the price of an NFT or remove the sale entirely
Buyers can purchase the NFTs by calling offer.

The only difference is that this marketplace has removed the ability to purchase NFTs for $NEAR and instead allows users to buy them with Fungible Tokens. The fungible token is specified when the contract is initialized and only 1 type of fungible token can be used to purchase NFTs. You can't, for example, offer 100 Team Tokens for an NFT and 5000 Mike Tokens for another.
In addition, the marketplace does not support royalties. This is because FT transfers are less Gas efficient than regular $NEAR transfers. In addition, each user would have to be registered and it's much easier to say "hey seller, make sure you're registered before your NFT is sold" rather than enforcing that the seller and all accounts in the payout object are registered. When an NFT is sold, the entire price is sent directly to the seller.

Purchasing Flow
In order to purchase an NFT, the contract utilizes the "transfer and call" workflow that the FT contract provides. The marketplace contract implements the ft_on_transfer method that is called whenever someone transfers FTs to the marketplace contract.
The marketplace keeps track of a balance for each user that outlines how many FTs they've sent to the contract. Each time ft_on_transfer is called, the marketplace contract will update the balance for the user. When that user wishes to purchase an NFT, they call offer and pass in the amount of tokens they're willing to spend. The marketplace will then decrement from their balance and transfer the NFT to the buyer / send the FTs to the seller.
It's important to note that the seller must be registered in the FT contract before a sale is made otherwise the ft_transfer method will panic and the seller won't receive any tokens.

Looking at the Code
Most of the code is the same as what's been outlined in the NFT zero to hero tutorial but we'll go through a refresher in case you're new or have forgotten some of the details.

Main Library File
Starting at the lib.rs file, this outlines what information is stored on the contract as well as some other crucial functions that you'll learn about below.

Initialization function
The first function you'll look at is the initialization function. This takes an owner_id as well as the ft_id as the parameters and will default all the storage collections to their default values. The ft_id outlines the account ID for the fungible token that the contract will allow.


Storage management model
Next, let's talk about the storage management model chosen for this contract. Users will need to deposit $NEAR onto the marketplace to cover the storage costs. Whenever someone puts an NFT for sale, the marketplace needs to store that information which costs $NEAR. Users can either deposit a large amount of $NEAR so that they never have to worry about storage again or they can deposit the minimum amount to cover 1 sale on an as-needed basis.
You might be thinking about the scenario when a sale is purchased. What happens to the storage that is now being released on the contract? This is why we have a storage withdrawal function. This allows users to withdraw any excess storage that is not being used. Let's go through some scenarios to understand the logic. The required storage for 1 sale is 0.01 NEAR on the marketplace contract.
Scenario A

Benji wants to list his NFT on the marketplace but has never paid for storage.
He deposits exactly 0.01 NEAR using the storage_deposit method. This will cover 1 sale.
He lists his NFT on the marketplace and is now using up 1 out of his prepaid 1 sales and has no more storage left. If he were to call storage_withdraw, nothing would happen.
Dorian loves his NFT and quickly purchases it before anybody else can. This means that Benji's sale has now been taken down (since it was purchased) and Benji is using up 0 out of his prepaid 1 sales. In other words, he has an excess of 1 sale or 0.01 NEAR.
Benji can now call storage_withdraw and will be transferred his 0.01 NEAR back. On the contract's side, after withdrawing, he will have 0 sales paid for and will need to deposit storage before trying to list anymore NFTs.

Scenario B

Dorian owns one hundred beautiful NFTs and knows that he wants to list all of them.
To avoid having to call storage_deposit everytime he wants to list an NFT, he calls it once. Since Dorian is a baller, he attaches 10 NEAR which is enough to cover 1000 sales. He now has an excess of 9 NEAR or 900 sales.
Dorian needs the 9 NEAR for something else but doesn't want to take down his 100 listings. Since he has an excess of 9 NEAR, he can easily withdraw and still have his 100 listings. After calling storage_withdraw and being transferred 9 NEAR, he will have an excess of 0 sales.

With this behavior in mind, the following two functions outline the logic.

In this contract, the storage required for each sale is 0.01 NEAR but you can query that information using the storage_minimum_balance function. In addition, if you wanted to check how much storage a given account has paid, you can query the storage_balance_of function.

FT Deposits
If you want to learn more about how NFTs are put for sale, check out the NFT zero to hero tutorial. Once NFTs are put for sale, the owner has three options:

Update the price of the NFT
Remove the sale from the marketplace
Wait for somebody to purchase it

In order to purchase NFTs, buyers need to deposit FTs in the contract and call the offer function. All the logic for FT deposits is outlined in the src/ft_balances.rs file. Starting with the ft_on_transfer function, this is called when a user transfers FTs to the marketplace contract. The logic can be seen below.

Once FTs are deposited into the contract, users can either withdraw their FTs or they can use them to purchase NFTs. The withdrawing flow is outlined in the ft_withdraw function. It's important to note that you should decrement the user's balance before calling the ft_transfer function to avoid a common exploit scenario where a user spams the ft_withdraw. If you were to decrement their balance in the callback function (if the transfer was successful), they could spam the ft_withdraw during the time it takes the callback function to execute. A better pattern is to decrement their balance before the transfer and then if the promise was unsuccessful, revert the balance back to what it was before.


Purchasing NFTs
Now that you're familiar with the process of both adding storage and depositing FTs on the marketplace, let's go through what you can do once a sale has been listed. The src/sale.rs file outlines the functions for updating the price, removing, and purchasing NFTs. In this tutorial, we'll focus only on the purchasing flow. If you'd like to learn about the sale objects, updating the price, and removing a sale, check out the NFT zero to hero tutorial.
For purchasing NFTs, you must call the offer function. It takes an nft_contract_id, token_id, and the amount you wish to offer as parameters. Behind the scenes, this function will make sure your offer amount is greater than the list price and also that you have enough FTs deposited. It will then call a private method process_purchase which will perform a cross-contract call to the NFT contract to invoke the nft_transfer function where the NFT will be transferred to the seller.

Once the transfer is complete, the contract will call resolve_purchase where it will check the status of the transfer.If the transfer succeeded, it will send the FTs to the seller. If the transfer didn't succeed, it will increment the buyer's FT balance (acting as a refund).

View Methods
There are several view functions that the marketplace contract exposes. All of these functions are the same as the NFT zero to hero tutorial except for one extra function we've added. In the src/ft_balances.rs file, we've added the ft_balance_of function. This function returns the balance of a given account.

Testing
Now that you hopefully have a good understanding of how the marketplace contract works and how you can use the powers of the FT standard to purchase NFTs, let's move onto testing everything.
Deploying and Initializing the Contracts
The first thing you'll want to do is deploy a new FT, NFT, and marketplace contract.
cd market-contract && cargo near build && cd ..
To deploy the FT contract and export an environment variable, run the following command:
export FT_CONTRACT=<new-ft-account-id>
near create-account $FT_CONTRACT --useFaucet
cd 5.transfers/ && cargo near deploy $FT_CONTRACT with-init-call new_default_meta json-args '{"owner_id": "'$FT_CONTRACT'", "total_supply": "1000000000000000000000000000"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send && cd ../
Next, you'll deploy the NFT and marketplace contracts.
export NFT_CONTRACT=<new-nft-account-id>
near create-account $NFT_CONTRACT --useFaucet
near deploy $NFT_CONTRACT out/nft-contract.wasm
export MARKETPLACE_CONTRACT=<new-marketplace-account-id>
near create-account $MARKETPLACE_CONTRACT --useFaucet
cd market-contract/ && cargo near deploy $MARKETPLACE_CONTRACT with-init-call new json-args '{"owner_id": "'$MARKETPLACE_CONTRACT'", "ft_id": "'$FT_CONTRACT'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send && cd ../
Check and see if your environment variables are all correct by running the following command. Each output should be different.
echo $FT_CONTRACT && echo $MARKETPLACE_CONTRACT && echo $NFT_CONTRACT
An example output is:
ft-contract.testnet
marketplace-contract.testnet
nft-contract.testnet
Once that's finished, go ahead and initialize NFT contract by running the following command (FT and marketplace contract were initialized during deploying process above).

  

  ```bash
  near call $NFT_CONTRACT new_default_meta '{"owner_id": "'$NFT_CONTRACT'"}' --accountId $NFT_CONTRACT
  ```
  

  

    ```bash
    near contract call-function as-transaction $NFT_CONTRACT new_default_meta json-args '{"owner_id": "'$NFT_CONTRACT'"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $NFT_CONTRACT network-config testnet sign-with-keychain send
    ```
  

Let's check if each contract was initialized correctly. You can do this by checking the metadata of the FT and NFT contracts:
near view $FT_CONTRACT ft_metadata && near view $NFT_CONTRACT nft_metadata
In addition, you can check the sales of the marketplace contract and it should return 0.
near view $MARKETPLACE_CONTRACT get_supply_sales

Placing a Token For Sale
Now that the marketplace and NFT contracts are initialized, let's place a token for sale. Start by creating a new buyer and seller account by running the following command. In this case, we'll create a sub-account of the FT contract.
near create-account buyer.$FT_CONTRACT --masterAccount $FT_CONTRACT --initialBalance 2 && export BUYER_ID=buyer.$FT_CONTRACT
near create-account seller.$FT_CONTRACT --masterAccount $FT_CONTRACT --initialBalance 2 && export SELLER_ID=seller.$FT_CONTRACT
Check if everything went well by running the following command.
echo $BUYER_ID && echo $SELLER_ID
This should return something similar to:
buyer.ft-contract.testnet
seller.ft-contract.testnet
The next thing you'll want to do is mint a token to the seller.

  

  ```bash
  near call $NFT_CONTRACT nft_mint '{"token_id": "market-token", "metadata": {"title": "Marketplace Token", "description": "testing out the marketplace", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$SELLER_ID'"}' --accountId $NFT_CONTRACT --amount 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $NFT_CONTRACT nft_mint json-args '{"token_id": "market-token", "metadata": {"title": "Marketplace Token", "description": "testing out the marketplace", "media": "https://bafybeiftczwrtyr3k7a2k4vutd3amkwsmaqyhrdzlhvpt33dyjivufqusq.ipfs.dweb.link/goteam-gif.gif"}, "receiver_id": "'$SELLER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $NFT_CONTRACT network-config testnet sign-with-keychain send
    ```
  

Now you'll need to place the token for sale. This requires paying for storage as well as calling the nft_approve function.

  

  ```bash
  near call $MARKETPLACE_CONTRACT storage_deposit --accountId $SELLER_ID --amount 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $MARKETPLACE_CONTRACT storage_deposit json-args '{}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $SELLER_ID network-config testnet sign-with-keychain send
    ```
  

In this case, we'll place the token for sale for 10 gtNEAR.

  

  ```bash
  near call $NFT_CONTRACT nft_approve '{"token_id": "market-token", "account_id": "'$MARKETPLACE_CONTRACT'", "msg": "{"sale_conditions":"10000000000000000000000000"}"}' --accountId $SELLER_ID --amount 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $NFT_CONTRACT nft_approve json-args '{"token_id": "market-token", "account_id": "'$MARKETPLACE_CONTRACT'", "msg": "{"sale_conditions":"10000000000000000000000000"}"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $SELLER_ID network-config testnet sign-with-keychain send
    ```
  

If you now query for the supply of sales again on the marketplace, it should be 1.

  

  ```bash
  near view $MARKETPLACE_CONTRACT get_supply_sales
  ```
  

  

    ```bash
    near contract call-function as-read-only $MARKETPLACE_CONTRACT get_supply_sales json-args {} network-config testnet now
    ```
  

In addition, if you query for the sales by the owner ID, it should reflect the 10 gtNEAR price.

  

  ```bash
  near view $MARKETPLACE_CONTRACT get_sales_by_owner_id '{"account_id": "'$SELLER_ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $MARKETPLACE_CONTRACT get_sales_by_owner_id json-args '{"account_id": "'$SELLER_ID'"}' network-config testnet now
    ```
  

Expected output:
[
  {
    owner_    approval_    nft_contract_    token_    sale_conditions: '10000000000000000000000000'
  }
]

Deposit FTs into the Marketplace
Now that you have an NFT up for sale for 10 gtNEAR on the marketplace contract, the buyer needs to deposit some FTs. The first thing you need to do is register both the marketplace contract and the buyer on the FT contract otherwise you won't be able to transfer any FTs.

  

  ```bash
  near call $FT_CONTRACT storage_deposit '{"account_id": "'$MARKETPLACE_CONTRACT'"}' --accountId $FT_CONTRACT --amount 0.1

  near call $FT_CONTRACT storage_deposit '{"account_id": "'$BUYER_ID'"}' --accountId $FT_CONTRACT --amount 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $FT_CONTRACT storage_deposit json-args '{"account_id": "'$MARKETPLACE_CONTRACT'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $FT_CONTRACT network-config testnet sign-with-keychain send

    near contract call-function as-transaction $FT_CONTRACT storage_deposit json-args '{"account_id": "'$BUYER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $FT_CONTRACT network-config testnet sign-with-keychain send
    ```
  

After this, you should transfer the buyer some FTs so that they can deposit at least 10 gtNEAR. Lets start with 50 gtNEAR. Run the following command to send the buyer FTs on behalf of the FT contract owner.

  

  ```bash
  near call $FT_CONTRACT ft_transfer '{"receiver_id": "'$BUYER_ID'", "amount": "50000000000000000000000000", "memo": "Go Team!"}' --accountId $FT_CONTRACT --depositYocto 1
  ```
  

  

    ```bash
    near contract call-function as-transaction $FT_CONTRACT ft_transfer json-args '{"receiver_id": "'$BUYER_ID'", "amount": "50000000000000000000000000", "memo": "Go Team!"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $FT_CONTRACT network-config testnet sign-with-keychain send
    ```
  

You'll now need to deposit those tokens into the marketplace contract.

  

  ```bash
  near call $FT_CONTRACT ft_transfer_call '{"receiver_id": "'$MARKETPLACE_CONTRACT'", "amount": "50000000000000000000000000", "msg": "Wooooooo!"}' --accountId $BUYER_ID --depositYocto 1 --gas 200000000000000
  ```
  

  

    ```bash
    near contract call-function as-transaction $FT_CONTRACT ft_transfer_call json-args '{"receiver_id": "'$MARKETPLACE_CONTRACT'", "amount": "50000000000000000000000000", "msg": "Wooooooo!"}' prepaid-gas '200.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
    ```
  

If you now query for your balance on the marketplace contract, it should be 50 gtNEAR.

  

  ```bash
  near view $MARKETPLACE_CONTRACT ft_deposits_of '{"account_id": "'$BUYER_ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $MARKETPLACE_CONTRACT ft_deposits_of json-args '{"account_id": "'$BUYER_ID'"}' network-config testnet now
    ```
  


Purchasing the NFT
Now that the buyer has deposited FTs into the marketplace and the token is up for sale, let's go ahead and make an offer! If you try to offer more FTs than what you have, the contract will panic. Similarly, if you try to offer lower than the sale price, the contract will also panic. Since the sale price is 10 gtNEAR, let's try to offer 20 gtNEAR and see what happens. The expected outcome is:

The NFT will be transferred to the buyer
20 gtNEAR will be sent to the seller
The buyer will have 30 gtNEAR left to withdraw.

There is one thing we're forgetting, however. We need to make sure that the seller is registered on the FT contract so let's go ahead and do that now.

  

  ```bash
  near call $FT_CONTRACT storage_deposit '{"account_id": "'$SELLER_ID'"}' --accountId $FT_CONTRACT --amount 0.1
  ```
  

  

    ```bash
    near contract call-function as-transaction $FT_CONTRACT storage_deposit json-args '{"account_id": "'$SELLER_ID'"}' prepaid-gas '100.0 Tgas' attached-deposit '0.1 NEAR' sign-as $FT_CONTRACT network-config testnet sign-with-keychain send
    ```
  

Now let's make an offer!

  

  ```bash
  near call $MARKETPLACE_CONTRACT offer '{"nft_contract_id": "'$NFT_CONTRACT'", "token_id": "market-token", "amount": "20000000000000000000000000"}' --accountId $BUYER_ID --depositYocto 1 --gas 300000000000000
  ```
  

  

    ```bash
    near contract call-function as-transaction $MARKETPLACE_CONTRACT offer json-args '{"nft_contract_id": "'$NFT_CONTRACT'", "token_id": "market-token", "amount": "20000000000000000000000000"}' prepaid-gas '300.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
    ```
  

If everything went well, you should see 2 events in your terminal. One event is the NFT transfer coming from the NFT contract when the token was transferred from the seller to the buyer. The other event is the FT transfer for when the seller receives their fungible tokens.
Log [dev-1660831638497-73655245450834]: Memo: payout from market
Log [dev-1660831638497-73655245450834]: EVENT_JSON:{"standard":"nep171","version":"nft-1.0.0","event":"nft_transfer","data":[{"authorized_id":"dev-1660831638497-73655245450834","old_owner_id":"seller.dev-1660831615048-16894106456797","new_owner_id":"buyer.dev-1660831615048-16894106456797","token_ids":["market-token"],"memo":"payout from market"}]}
Receipt: BBvHig5zg1n2vmxFPTpxED4FNCAU1ZzZ3H8EBqqaeRw5
Log [dev-1660831638497-73655245450834]: EVENT_JSON:{"standard":"nep141","version":"1.0.0","event":"ft_transfer","data":[{"old_owner_id":"dev-1660831638497-73655245450834","new_owner_id":"seller.dev-1660831615048-16894106456797","amount":"20000000000000000000000000","memo":"Sale from marketplace"}]}
Let's call some view methods to double check if everything went well. First let's check if the seller now has 20 gtNEAR.

  

  ```bash
  near view $FT_CONTRACT ft_balance_of '{"account_id": "'$SELLER_ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $FT_CONTRACT ft_balance_of json-args '{"account_id": "'$SELLER_ID'"}' network-config testnet now
    ```
  

Next, let's check if the buyer has 30 gtNEAR left to withdraw.

  

  ```bash
  near view $MARKETPLACE_CONTRACT ft_deposits_of '{"account_id": "'$BUYER_ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $MARKETPLACE_CONTRACT ft_deposits_of json-args '{"account_id": "'$BUYER_ID'"}' network-config testnet now
    ```
  

Finally, let's check if the NFT is now owned by the buyer.

  

  ```bash
  near view $NFT_CONTRACT nft_token '{"token_id": "market-token"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $NFT_CONTRACT nft_token json-args '{"token_id": "market-token"}' network-config testnet now
    ```
  


Withdrawing the Excess Deposits
Now that the buyer purchased the NFT with 20 gtNEAR, they should have 30 gtNEAR left to withdraw. If they withdraw the tokens, they should be left with a balance of 30 gtNEAR on the FT contract.

  

  ```bash
  near call $MARKETPLACE_CONTRACT ft_withdraw '{"amount": "30000000000000000000000000"}' --accountId $BUYER_ID --depositYocto 1 --gas 300000000000000
  ```
  

  

    ```bash
    near contract call-function as-transaction $MARKETPLACE_CONTRACT ft_withdraw json-args '{"amount": "30000000000000000000000000"}' prepaid-gas '300.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $BUYER_ID network-config testnet sign-with-keychain send
    ```
  

If you now query for the buyer's balance, it should be 30 gtNEAR.

  

  ```bash
  near view $FT_CONTRACT ft_balance_of '{"account_id": "'$BUYER_ID'"}'
  ```
  

  

    ```bash
    near contract call-function as-read-only $FT_CONTRACT ft_balance_of json-args '{"account_id": "'$BUYER_ID'"}' network-config testnet now
    ```
  

And just like that you're finished! You went through and put an NFT up for sale and purchased it using fungible tokens! Go team 🚀

Conclusion
In this tutorial, you learned about the basics of a marketplace contract and how it works. You went through the core logic both at a high level and looked at the code. You deployed an NFT, marketplace, and FT contract, initialized them all and then put an NFT for sale and sold it for fungible tokens! What an amazing experience! Go forth and expand these contracts to meet whatever needs you have. The world is your oyster and thank you so much for following along with this tutorial series. Don't hesitate to ask for help or clarification on anything in our discord or social media channels. Go Team!

noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-sdk-rs: `5.1.0` (with enabled `legacy` feature)
- cargo-near: `0.6.1`
- near-cli: `4.0.13`

### Transferring Fungible Tokens

In this tutorial, you'll learn how to implement the core standards into your smart contract. You'll implement the logic that allows you to transfer and receive tokens. If you're joining us for the first time, feel free to clone this repository and follow along in the 4.storage folder.
tipIf you wish to see the finished code for this _Core_ tutorial, you can find it in the [`5.transfers`](https://github.com/near-examples/ft-tutorial/blob/main/5.transfers) folder.



Introduction
Up until this point, you've created a simple FT smart contract that allows the owner to mint a total supply of tokens and view information about the Fungible Token itself. In addition, you've added the functionality to register accounts and emit events. Today, you'll expand your smart contract to allow for users to transfer and receive fungible tokens.
The logic for doing a simple transfer is quite easy to understand. Let's say Benji wants to transfer Mike 100 of his fungible tokens. The contract should do a few things:

Check if Benji owns at least 100 tokens.
Make sure Benji is calling the function.
Ensure Mike is registered on the contract.
Take 100 tokens out of Benji's account.
Put 100 tokens into Mike's account.

At this point, you're ready to move on and make the necessary modifications to your smart contract.

Modifications to the contract
Let's start our journey in the src/ft_core.rs file.
Transfer function
You'll start by implementing the ft_transfer logic which is found in the src/ft_core.rs file. This function will transfer the specified amount to the receiver_id with an optional memo such as "Happy Birthday Mike!".

There are a couple things to notice here.


We've introduced a new function called assert_one_yocto(). This method will ensure that the user is signing the transaction with a full access key by requiring a deposit of exactly 1 yoctoNEAR, the smallest possible amount of $NEAR that can be transferred. Since the transfer function is potentially transferring very valuable assets, you'll want to make sure that whoever is calling the function has a full access key.


We've introduced an internal_transfer method. This will perform all the logic necessary to transfer the tokens internally.



Internal helper functions
Let's quickly move over to the ft-contract/src/internal.rs file so that you can implement the internal_transfer method which is the core of this tutorial. This function will take the following parameters:

sender_id: the account that's attempting to transfer the tokens.
receiver_id: the account that's receiving the tokens.
amount: the amount of FTs being transferred.
memo: an optional memo to include.

The first thing you'll want to do is make sure the sender isn't sending tokens to themselves and that they're sending a positive number. After that, you'll want to withdraw the tokens from the sender's balance and deposit them into the receiver's balance. You've already written the logic to deposit FTs by using the internal_deposit function.
Let's use similar logic to implement internal_withdraw:

In this case, the contract will get the account's balance and ensure they are registered by calling the internal_unwrap_balance_of function. It will then subtract the amount from the user's balance and re-insert them into the map.
Using the internal_deposit and internal_withdraw functions together, the core of the internal_transfer function is complete.
There's only one more thing you need to do. When transferring the tokens, you need to remember to emit a log as per the events standard:

Now that this is finished, the simple transfer case is done! You can now transfer FTs between registered users!

Transfer call function
In this section, you'll learn about a new function ft_transfer_call. This will transfer FTs to a receiver and also call a method on the receiver's contract all in the same transaction.
Let's consider the following scenario. An account wants to transfer FTs to a smart contract for performing a service. The traditional approach would be to perform the service and then ask for the tokens in two separate transactions. If we introduce a “transfer and call†workflow baked into a single transaction, the process can be greatly improved:

This function will do several things:

Ensures the caller attached exactly 1 yocto for security purposes.
Transfer the tokens using the internal_transfer you just wrote.
Creates a promise to call the method ft_on_transfer on the receiver_id's contract.
After the promise finishes executing, the function ft_resolve_transfer is called.

info
This is a very common workflow when dealing with cross contract calls. You first initiate the call and wait for it to finish executing. Then, you invoke a function that resolves the result of the promise and act accordingly.
Learn more here.

When calling ft_on_transfer, it will return how many tokens the contract should refund the original sender.
This is important for a couple of reasons:

If you send the receiver too many FTs and their contract wants to refund the excess.
If any of the logic panics, all of the tokens should be refunded back to the sender.

This logic will all happen in the ft_resolve_transfer function:

The first thing you'll do is check the status of the promise. If anything failed, you'll refund the sender for the full amount of tokens. If the promise succeeded, you'll extract the amount of tokens to refund the sender based on the value returned from ft_on_transfer. Once you have the amount needed to be refunded, you'll perform the actual refund logic by using the internal_transfer function you wrote previously.
You'll then return the net amount of tokens that were transferred to the receiver. If the sender transferred 100 tokens but 20 were refunded, this function should return 80.
With that finished, you've now successfully added the necessary logic to allow users to transfer FTs. It's now time to deploy and do some testing.

Deploying the contract
Let's create a new sub-account to deploy the contract to. Since these changes are only additive and non state breaking, you could have deployed a patch fix to the contract you deployed in the storage section as well. To learn more about upgrading contracts, see the upgrading a contract section in the NFT Zero to Hero tutorial.

Creating a sub-account
Run the following command to create a sub-account transfer of your main account with an initial balance of 3 NEAR which will be transferred from the original to your new account.

  

  ```bash
  near create-account transfer.$FT_CONTRACT_ID --use-account $FT_CONTRACT_ID --initial-balance 3 --network-id testnet
  ```
  

  

  ```bash
  near account create-account fund-myself transfer.$FT_CONTRACT_ID '3 NEAR' autogenerate-new-keypair save-to-keychain sign-as $FT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Next, you'll want to export an environment variable for ease of development:
export TRANSFER_FT_CONTRACT_ID=transfer.$FT_CONTRACT_ID
Build the contract as you did in the previous tutorials:
cd 4.storage
cargo near build

Deployment and Initialization
It's time to deploy the contract, initialize it and mint the total supply. Let's once again create an initial supply of 1000 gtNEAR.
cargo near deploy $TRANSFER_FT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$TRANSFER_FT_CONTRACT_ID'", "total_supply": "1000000000000000000000000000"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
You can check if you own the FTs by running the following command:

  

  ```bash
  near view $TRANSFER_FT_CONTRACT_ID ft_balance_of '{"account_id": "'$TRANSFER_FT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $TRANSFER_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "'$TRANSFER_FT_CONTRACT_ID'"}' network-config testnet now
  ```
  


Testing the transfer function
Let's test the transfer function by transferring 1 gtNEAR from the owner account to the account benjiman.testnet
warning Keep in mind
The Fungible tokens won't be recoverable unless the account `benjiman.testnet` transfers them back to you. If you don't want your FTs lost, make a new account and transfer the token to that account instead.

You'll first need to register the account benjiman.testnet by running the following command.

  

  ```bash
  near call $TRANSFER_FT_CONTRACT_ID storage_deposit '{"account_id": "benjiman.testnet"}' --gas 100000000000000 --deposit 0.01 --accountId $TRANSFER_FT_CONTRACT_ID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction $TRANSFER_FT_CONTRACT_ID storage_deposit json-args '{"account_id": "benjiman.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0.01 NEAR' sign-as $TRANSFER_FT_CONTRACT_ID network-config testnet sign-with-keychain send
    ```
  

Once the account is registered, you can transfer the FTs by running the following command. Take note that you're also attaching exactly 1 yoctoNEAR by using the --depositYocto flag.

  

  ```bash
  near call $TRANSFER_FT_CONTRACT_ID ft_transfer '{"receiver_id": "benjiman.testnet", "amount": "1000000000000000000000000", "memo": "Go Team :)"}' --gas 100000000000000 --depositYocto 1 --accountId $TRANSFER_FT_CONTRACT_ID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction $TRANSFER_FT_CONTRACT_ID ft_transfer json-args '{"receiver_id": "benjiman.testnet", "amount": "1000000000000000000000000", "memo": "Go Team :)"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $TRANSFER_FT_CONTRACT_ID network-config testnet sign-with-keychain send
    ```
  

You should see the FtTransferEvent being emitted in the console. At this point, if you check for the total supply, it should still be 1000 gtNEAR but if you check both the balance of Benji and the balance of the owner, they should reflect the transfer.

Check owner balance:


  

  ```bash
  near view $TRANSFER_FT_CONTRACT_ID ft_balance_of '{"account_id": "'$TRANSFER_FT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $TRANSFER_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "'$TRANSFER_FT_CONTRACT_ID'"}' network-config testnet now
  ```
  


Check benjiman.testnet balance:


  

  ```bash
  near view $TRANSFER_FT_CONTRACT_ID ft_balance_of '{"account_id": "benjiman.testnet"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $TRANSFER_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "benjiman.testnet"}' network-config testnet now
  ```
  


Check total supply:


  

  ```bash
  near view $TRANSFER_FT_CONTRACT_ID ft_total_supply '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $TRANSFER_FT_CONTRACT_ID ft_total_supply json-args {} network-config testnet now
  ```
  


Testing the transfer call function
Now that you've tested the ft_transfer function, it's time to test the ft_transfer_call function. If you try to transfer tokens to a receiver that does not implement the ft_on_transfer function, the contract will panic and the FTs will be refunded. Let's test this functionality below.
You can try to transfer the FTs to the account no-contract.testnet which, as the name suggests, doesn't have a contract. This means that the receiver doesn't implement the ft_on_transfer function and the FTs should remain yours after the transaction is complete. You'll first have to register the account, however.

  

  ```bash
  near call $TRANSFER_FT_CONTRACT_ID storage_deposit '{"account_id": "no-contract.testnet"}' --gas 100000000000000 --deposit 0.01 --accountId $TRANSFER_FT_CONTRACT_ID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction $TRANSFER_FT_CONTRACT_ID storage_deposit json-args '{"account_id": "no-contract.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0.01 NEAR' sign-as $TRANSFER_FT_CONTRACT_ID network-config testnet sign-with-keychain send
    ```
  


  

  ```bash
  near call $TRANSFER_FT_CONTRACT_ID ft_transfer_call '{"receiver_id": "no-contract.testnet", "amount": "1000000000000000000000000", "msg": "foo"}' --gas 100000000000000 --depositYocto 1 --accountId $TRANSFER_FT_CONTRACT_ID --networkId testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction $TRANSFER_FT_CONTRACT_ID ft_transfer_call json-args '{"receiver_id": "no-contract.testnet", "amount": "1000000000000000000000000", "msg": "foo"}' prepaid-gas '100.0 Tgas' attached-deposit '1 yoctoNEAR' sign-as $TRANSFER_FT_CONTRACT_ID network-config testnet sign-with-keychain send
    ```
  

The output response should be as follows.
Scheduling a call: transfer.dev-1660680326316-91393402417293.ft_transfer_call({"receiver_id": "no-contract.testnet", "amount": "1000000000000000000000000", "msg": "foo"}) with attached 0.000000000000000000000001 NEAR
Doing account.functionCall()
Receipts: AJ3yWv7tSiZRLtoTkyTgfdzmQP1dpjX9DxJDiD33uwTZ, EKtpDFoJWNnbyxJ7SriAFQYX8XV9ZTzwmCF2qhSaYMAc, 21UzDZ791pWZRKAHv8WaRKN8mqDVrz8zewLWGTNZTckh
    Log [transfer.dev-1660680326316-91393402417293]: EVENT_JSON:{"standard":"nep141","version":"1.0.0","event":"ft_transfer","data":[{"old_owner_id":"transfer.dev-1660680326316-91393402417293","new_owner_id":"no-contract.testnet","amount":"1000000000000000000000000"}]}
Receipt: 5N2WV8picxwUNC5TYa3A3v4qGquQAhkU6P81tgRt1UFN
    Failure [transfer.dev-1660680326316-91393402417293]: Error: Cannot find contract code for account no-contract.testnet
Receipt: AdT1bSZNCu9ACq7m6ynb12GgSb3zBenfzvvzRwfYPBmg
    Log [transfer.dev-1660680326316-91393402417293]: EVENT_JSON:{"standard":"nep141","version":"1.0.0","event":"ft_transfer","data":[{"old_owner_id":"no-contract.testnet","new_owner_id":"transfer.dev-1660680326316-91393402417293","amount":"1000000000000000000000000","memo":"Refund"}]}
Transaction Id 2XVy8MZU8TWreW8C9zK6HSyBsxE5hyTbyUyxNdncxL8g
To see the transaction in the transaction explorer, please open this url in your browser
https://testnet.nearblocks.io/txns/2XVy8MZU8TWreW8C9zK6HSyBsxE5hyTbyUyxNdncxL8g
'0'
There should be a transfer event emitted for the initial transfer of tokens and then also for the refund. In addition, 0 should have been returned from the function because the sender ended up transferring net 0 tokens to the receiver since all the tokens were refunded.
If you query for the balance of no-contract.testnet, it should still be 0.

  

  ```bash
  near view $TRANSFER_FT_CONTRACT_ID ft_balance_of '{"account_id": "no-contract.testnet"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $TRANSFER_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "no-contract.testnet"}' network-config testnet now
  ```
  

Hurray! At this point, your FT contract is fully complete and all the functionality is working as expected. Go forth and experiment! The world is your oyster and don't forget, go team!

Conclusion
In this tutorial, you learned how to expand a FT contract by adding ways for users to transfer FTs. You broke down the problem into smaller, more digestible subtasks and took that information and implemented both the FT transfer and FT transfer call functions. In addition, you deployed another contract and tested the transfer functionality.
In the next tutorial, you'll learn about how an NFT marketplace can operate to purchase NFTs by using Fungible Tokens.

noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-sdk-rs: `5.1.0` (with enabled `legacy` feature)
- cargo-near: `0.6.1`
- near-cli-rs: `0.11.0`

### Registering Accounts

In the previous tutorial, you looked at how to mint an initial circulating supply of tokens and how you could log events as per the events standard. You then deployed the contract and saw the FTs in your wallet balance. In this tutorial, you'll learn about the storage management standard and how you can register accounts in your FT contract in order to prevent a malicious party from draining your contract of all its funds.

Introduction
Whenever a new person receives any fungible tokens, they're added to the accounts lookup map on the contract. By doing this, you're adding bytes to the contract. If you made it so any user could receive FTs for free, that system could easily be abused. Users could essentially "drain" the contract of all its funds by sending small amounts of FTs to many accounts. For this reason, you'll want to charge users for the information they're storing and the bytes they're using on the contract. This way of charging users, however, should be standardized so it works across all contracts.
Enter the storage management standard


Storage Management Standard
The storage management standard is a set of rules that govern how a contract should charge users for storage. It outlines functions and behaviors such that all contracts implementing the standard are interoperable with each other. The 3 functions you'll need to implement are:

storage_deposit - Allows a user to deposit some amount of storage to the contract. If the user over deposits, they're refunded for the excess $NEAR.
storage_balance_of - Query for the storage paid by a given user
storage_balance_bounds - Query for the minimum and maximum amount of storage needed to interact with a given contract.

With these functions outlined, you could make a reasonable assumption that the flow would be:

If a user doesn't exist on the contract, they need to deposit some storage to cover the bytes they use.
Once the user deposits $NEAR via the storage_deposit function, they're free to interact with the contract.

You might be asking yourself what the deposit amount should be. There are two ways you can go about getting this information:

Dynamically calculate the bytes every individual user would take up in the storage_deposit function by inserting them into accounts map, measuring the bytes, and then removing them from the map after.
Calculate the bytes for inserting a largest possible account ID once upon initializing the contract and simply charge every user the same amount.

For the purpose of simplicity, we'll assume the second method.

Modifications to the Contract
This "bytes for longest account ID" should be stored in the contract's state such that we can pull the value during the storage_deposit function and ensure the user attaches enough $NEAR. Open the src/lib.rs file and add the following code to the Contract struct. If you're just joining us now, you can find the skeleton code for this tutorial in the 3.initial-supply folder.

You'll now need a way to calculate this amount which will be done in the initialization function. Move to the src/internal.rs file and add the following private function measure_bytes_for_longest_account_id which will add the longest possible account ID and remove it while measuring how many bytes the operation took. It will then set the bytes_for_longest_account_id field to the result.

You'll also want to create a function for registering an account after they've paid for storage. To do this, you can simply insert them into the accounts map with a balance of 0. This way, you know that any account currently in the map is considered "registered" and have paid for storage. Any account that attempts to receive FTs must be in the map with a balance of 0 or greater. If they aren't, the contract should throw.

Let's also create a function to panic with a custom message if the user doesn't exist yet.

Now when you call the internal_deposit function, rather than defaulting the user's balance to 0 if they don't exist yet via:
let balance = self.accounts.get(&account_id).unwrap_or(0);
You can replace it with the following:

With this finished, your internal.rs should look as follows:
use near_sdk::{require};

use crate::*;

impl Contract {
    pub(crate) fn internal_unwrap_balance_of(&self, account_      ...
    }

    pub(crate) fn internal_deposit(&mut self, account_      ...
    }

    pub(crate) fn internal_register_account(&mut self, account_      ...
    }

    pub(crate) fn measure_bytes_for_longest_account_id(&mut self) {
      ...
    }
}
There's only one problem you need to solve with this. When initializing the contract, the implementation will throw. This is because you call internal_deposit and the owner doesn't have a balance yet. To fix this, let's modify the initialization function to register the owner before depositing the FTs in their account. In addition, you should measure the bytes for the registration in this function.


Implementing Storage Standard
With this finished, you're now ready to implement the storage management standard. If you remember, the three functions you'll be implementing, we can break each down into their core functionality and decide how to proceed.

storage_balance_bounds - Query for the minimum and maximum amount of storage needed to interact with a given contract.

Since you're creating a fungible token contract and the storage price won't change (unless the $NEAR cost per byte changes), the minimum and maximum storage costs should be the same. These values should be equal to the amount of bytes for the longest account ID you calculated in the measure_bytes_for_longest_account_id function multiplied by the current $NEAR price per byte. Switch to the src/storage.rs file to get started.


storage_balance_of - Query for the storage paid by a given user.

As we mentioned earlier, you can tell if somebody has paid for storage by checking if they're in the accounts map. If they are, you know that they've paid the amount returned by storage_balance_bounds.


storage_deposit - Allows a user to deposit some amount of storage to the contract. If the user over deposits, they're refunded for the excess $NEAR.

In order to implement this logic, you first need to get the attached deposit. You'll also need to ensure that the user hasn't already paid for storage (i.e. they're in the accounts map). If they are, simply refund the caller for the $NEAR they attached to the call.
If the user isn't registered yet, you should get the storage cost by calling storage_balance_bounds and make sure they've attached enough to cover that amount. Once this if finished, you can register them and refund any excess $NEAR.

With this finished, you're ready to build and deploy the contract!

Deploying the contract
Since the current contract you have is already initialized, let's create a sub-account and deploy to again.
Creating a sub-account
Run the following command to create a sub-account storage of your main account with an initial balance of 3 NEAR which will be transferred from the original to your new account.

  

  ```bash
  near create-account storage.$FT_CONTRACT_ID --use-account $FT_CONTRACT_ID --initial-balance 3 --network-id testnet
  ```
  

  

  ```bash
  near account create-account fund-myself storage.$FT_CONTRACT_ID '3 NEAR' autogenerate-new-keypair save-to-keychain sign-as $FT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Next, you'll want to export an environment variable for ease of development:
export STORAGE_FT_CONTRACT_ID=storage.$FT_CONTRACT_ID
Build the contract as you did in the previous tutorials:
cd 3.initial-supply
cargo near build

Deploying and Initialization
It's time to deploy the contract, initialize it and mint the total supply. Let's once again create an initial supply of 1000 gtNEAR.
cargo near deploy $STORAGE_FT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$STORAGE_FT_CONTRACT_ID'", "total_supply": "1000000000000000000000000000"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
If you now query for the storage paid by the owner, you should see that they're registered!

  

  ```bash
  near view $STORAGE_FT_CONTRACT_ID storage_balance_of '{"account_id": "'$STORAGE_FT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $STORAGE_FT_CONTRACT_ID storage_balance_of json-args '{"account_id": "'$STORAGE_FT_CONTRACT_ID'"}' network-config testnet now
  ```
  

This should return a struct. The Total amount is roughly 0.00125 $NEAR to register and the user has 0 available $NEAR since it's all being used up to pay for registration.
{ total: '1250000000000000000000', available: '0' }
You can also query for the storage balance required to interact with the contract:

  

  ```bash
  near view $STORAGE_FT_CONTRACT_ID storage_balance_bounds '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $STORAGE_FT_CONTRACT_ID storage_balance_bounds json-args {} network-config testnet now
  ```
  

You'll see that it returns the same amount as the storage_balance_of query above with the min equal to the max:
{ min: '1250000000000000000000', max: '1250000000000000000000' }

Conclusion
Today you went through and created the logic for registering users on the contract. This logic adheres to the storage management standard and is customized to meet our needs when writing a FT contract. You then built, deployed, and tested those changes. In the next tutorial, you'll look at the basics of how to transfer FTs to other users.

noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-sdk-rs: `5.1.0` (with enabled `legacy` feature)
- cargo-near: `0.6.1`
- near-cli-rs: `0.11.0`

### Creating a Circulating Supply

In the previous tutorial, you looked at what a fungible token was and how you could define one in your smart contract. In this tutorial, you'll learn how to create a circulating supply belonging to the contract owner and view all the tokens, with their metadata, in the NEAR wallet.
To get started, either work off the code you wrote in the previous tutorial or switch to the 2.define-a-token folder in our repo. If you haven't cloned the repository, refer to the Contract Architecture to start.
If you wish to see the finished code for this tutorial, you can find it in the 3.initial-supply folder.

Introduction
Every fungible token contract on NEAR has what's known as a circulating supply. This is the number of tokens that exist on the contract and are actively available to trade.
When creating your contract, there are many different ways you could implement this to start. A few examples could be:

Specify a starting total supply and distribute it based on a set of parameters (Benji gets 20%, Josh gets 2.5%, and the rest goes to Mike).
Have a first come first serve pool where everybody claims up to X amount of tokens.
Create tokens on demand resulting in a steady increase of the circulating supply overtime up to a specified cap.

The simplest approach, however, is to specify a total supply when initializing the contract. The entire circulating supply is then created and sent to the owner of the contract. The owner would then be able to transfer or sell the tokens as they wish. Once the initial supply is created, no more FTs could be minted. This means that the circulating supply will always be equal to the total supply.

Modifications to contract
In order to implement this logic, you'll need to keep track of two things in your smart contract:

A mapping of an account to the number of tokens they own.
The total supply of tokens.

The mapping is so that you can easily check or modify the tokens owned by any given account at anytime within your contract. You'll also need to keep track of the total supply since it's required by the standard that you have a function to query for the supply of tokens on the contract.

Setting the supply
Head over to the src/lib.rs file and add the following code to the Contract struct.

You'll now want to add the functionality for depositing the tokens into the owner's account. Do this by creating a helper function that takes an amount and an account ID and performs the deposit logic for you. First create a new file src/internal.rs such that your file structure now looks as follows.
src
  ├── ft_core.rs
  ├── internal.rs
  ├── lib.rs
  ├── metadata.rs
  └── storage.rs
In the internal.rs file, add the following code to create a function called internal_deposit which takes an AccountId and a NearToken as a balance and adds the amount to the account's current supply of FTs.

Now that the functionality for depositing FTs is in place, switch back to the src/lib.rs file and add the internal module:

In addition, add the following code to the new initialization function.
#[init]
pub fn new(
    owner_    total_supply: U128,
    metadata: FungibleTokenMetadata,
) -> Self {
    let casted_total_supply = NearToken::from_yoctonear(total_supply.0);
    // Create a variable of type Self with all the fields initialized.
    let mut this = Self {
        // Set the total supply
        total_supply: casted_total_supply,
        // Storage keys are simply the prefixes used for the collections. This helps avoid data collision
        accounts: LookupMap::new(StorageKey::Accounts),
        metadata: LazyOption::new(
            StorageKey::Metadata,
            Some(&metadata),
        ),
    };

    // Set the owner's balance to the total supply.
    this.internal_deposit(&owner_id, casted_total_supply);

    // Return the Contract object
    this
}
This will initialize the total supply to what you passed in and will call the internal_deposit function to add the total supply to the owner's account.

Getting the supply
Now that you've created a way to set the total supply, you'll also want a way to query for it as well as the balance for a specific user. The standard dictates that you should have two methods on your smart contract for doing these operations:

ft_total_supply
ft_balance_of

Head on over to the src/ft_core.rs file and add the following code to these functions.

At this point, you have everything you need to create an initial supply of tokens and query for the balance of a given account. There is, however, a problem that we need to solve. How will the wallet know that the total supply was created and is owned by the contract owner? How would it even know that our contract is a fungible token contract? If you were to deploy the contract and run through the setup process, you would be able to query for the information from the contract but you wouldn't see any FTs in the owner's NEAR wallet.

Events
Have you ever wondered how the wallet knows which FTs you own and how it can display them in the balances tab? Originally, an indexer used to listen for any function calls starting with ft_ on your account. These contracts were then flagged on your account as likely FT contracts.
When you navigated to your balances tab, the wallet would then query all those contracts for the number of FTs you owned using the ft_balance_of function you just wrote.

The problem
This method of flagging contracts was not reliable as each FT-driven application might have its own way of minting or transferring FTs. In addition, it's common for apps to transfer or mint many tokens at a time using batch functions.

The solution
A standard was introduced so that smart contracts could emit an event anytime FTs were transferred, minted, or burnt. This event was in the form of a log. No matter how a contract implemented the functionality, an indexer could now listen for those standardized logs.
As per the standard, you need to implement a logging functionality that gets fired when FTs are transferred or minted. In this case, the contract doesn't support burning so you don't need to worry about that for now.
It's important to note the standard dictates that the log should begin with "EVENT_JSON:". The structure of your log should, however, always contain the 3 following things:

standard: the current name of the standard (e.g. nep141)
version: the version of the standard you're using (e.g. 1.0.0)
event: a list of events you're emitting.

The event interface differs based on whether you're recording transfers or mints. The interface for both events is outlined below.
Transfer events:

old_owner_id: the old owner of the FTs.
new_owner_id: the new owner that the FTs are being transferred to.
amount: the number of tokens transferred.
Optional - memo: an optional message to include with the event.

Minting events:

owner_id: the owner that the FTs are being minted to.
amount: the amount of FTs being minted.
Optional - memo: an optional message to include with the event.


Examples
In order to solidify your understanding of the standard, let's walk through two scenarios and see what the logs should look like.
Scenario A - simple mint
In this scenario, the Benji mints 50 FTs to himself and doesn't include a message. The log should look as follows.
EVENT_JSON:{
  "standard": "nep141",
  "version": "1.0.0",
  "event": "ft_mint",
  "data": [
    {"owner_id": "benji.testnet", "amount": "50"}
  ]
}

Scenario B - batch transfer
In this scenario, Benji wants to perform a batch transfer. He will send FTs to Jada, Mike, Josh, and Maria. The log is as follows.
EVENT_JSON:{
    "standard": "nep141",
    "version": "1.0.0",
    "event": "ft_transfer",
    "data": [
        {"old_owner_id": "benji.near", "new_owner_id": "josh.near", "amount": "1", "memo": "go team"},
        {"old_owner_id": "benji.near", "new_owner_id": "mike.near", "amount": "9000"},
        {"old_owner_id": "benji.near", "new_owner_id": "jada.near", "amount": "500"},
        {"old_owner_id": "benji.near", "new_owner_id": "maria.near", "amount": "500"}
    ]
}

Modifications to the contract
At this point, you should have a good understanding of what the end goal should be so let's get to work! Open the src directory and create a new file called events.rs. This is where your log structs will live.
Creating the events file
Copy the following into your file. This will outline the structs for your EventLog, FtMintLog, and FtTransferLog. In addition, we've added a way for EVENT_JSON: to be prefixed whenever you log the EventLog.


Adding modules and constants
Now that you've created a new file, you need to add the module to the lib.rs file.


Logging the total supply minted
Now that all the tools are set in place, you can implement the actual logging functionality. Since the contract will only be minting tokens at the very start when it's initialized, it's trivial where you should place the log. Open the src/lib.rs file and navigate to the bottom of the new initialization function. This is where you'll construct the log for minting.

With that finished, you've successfully implemented the backbone of the events standard and it's time to start testing.

Deploying the contract
Since the current contract you have is already initialized, let's create a sub-account and deploy to that instead.
Creating a sub-account
Run the following command to create a sub-account events of your main account with an initial balance of 3 NEAR which will be transferred from the original to your new account.

  

  ```bash
  near create-account events.$FT_CONTRACT_ID --use-account $FT_CONTRACT_ID --initial-balance 3 --network-id testnet
  ```
  

  

  ```bash
  near account create-account fund-myself events.$FT_CONTRACT_ID '3 NEAR' autogenerate-new-keypair save-to-keychain sign-as $FT_CONTRACT_ID network-config testnet sign-with-keychain send
  ```
  

Next, you'll want to export an environment variable for ease of development:
export EVENTS_FT_CONTRACT_ID=events.$FT_CONTRACT_ID
Build the contract as you did in the previous tutorials:
cd 2.define-a-token
cargo near build

Deploying and Initialization
It's time to deploy the contract, initialize it and mint the total supply. Let's create an initial supply of 1000 gtNEAR. Since it has 24 decimal places, you should put 1000 followed by 24 zeros in the total supply field.
cargo near deploy $EVENTS_FT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$EVENTS_FT_CONTRACT_ID'", "total_supply": "1000000000000000000000000000"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
You can check to see if everything went through properly by looking at the output in your CLI:
...
Transaction sent ...
--- Logs ---------------------------
Logs [events.aha_3.testnet]:
  EVENT_JSON:{"standard":"nep141","version":"1.0.0","event":"ft_mint","data":[{"owner_id":"events.goteam.testnet","amount":"1000000000000000000000000000","memo":"Initial token supply is minted"}]}
--- Result -------------------------
Empty result
------------------------------------

Contract code has been successfully deployed.
The "new_default_meta" call to <events.goteam.testnet> on behalf of <events.goteam.testnet> succeeded.
...
You can see that the event was properly logged!

Querying Supply Information
You can now test if your view functions work properly. First, try to query for the total supply.

  

  ```bash
  near view $EVENTS_FT_CONTRACT_ID ft_total_supply '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $EVENTS_FT_CONTRACT_ID ft_total_supply json-args {} network-config testnet now
  ```
  

This should return an output similar to the following:
'1000000000000000000000000000'
Hurray! Now you can check if the balance of the owner account works properly. If you call the following function, it should return the same number as the total supply.

  

  ```bash
  near view $EVENTS_FT_CONTRACT_ID ft_balance_of '{"account_id": "'$EVENTS_FT_CONTRACT_ID'"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $EVENTS_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "'$EVENTS_FT_CONTRACT_ID'"}' network-config testnet now
  ```
  

Returns:
'1000000000000000000000000000'
If you query for the balance of some other account, it should return 0.

  

  ```bash
  near view $EVENTS_FT_CONTRACT_ID ft_balance_of '{"account_id": "benjiman.testnet"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $EVENTS_FT_CONTRACT_ID ft_balance_of json-args '{"account_id": "benjiman.testnet"}' network-config testnet now
  ```
  


Viewing FTs in the wallet
Now that your contract implements the necessary functions that the wallet uses to pickup your contract and display the FTs, you should be able to see your tokens on display in the balances tab.

🎉🎉🎉 This is awesome! Go team! 🎉🎉🎉 You can now see your very first fungible tokens in the wallet!

Conclusion
Today you went through and created the logic for minting a total supply. You then implemented some of the core standard logic and the events standard. You created events for minting FTs on initialization. You then deployed and tested your changes and saw your very first FTs in the wallet!
In the next tutorial, you'll look at the basics of registering accounts so that they can transfer and receive FTs.

noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-sdk-rs: `5.1.0` (with enabled `legacy` feature)
- cargo-near: `0.6.1`
- near-cli-rs: `0.11.0`

### Defining a Fungible Token

This is the first of many tutorials in a series where you'll be creating a complete FT smart contract from scratch that conforms with all the NEAR FT standards. Today you'll learn what a Fungible Token is and how you can define one on the NEAR blockchain. You will be modifying a bare-bones skeleton smart contract by filling in the necessary code snippets needed to add this functionality.

Introduction
To get started, switch to the 1.skeleton folder in our repo. If you haven't cloned the repository, refer to the Contract Architecture to get started.
If you wish to see the finished code for this portion of the tutorial, that can be found on the 2.defining-a-token folder.

Modifications to the skeleton contract
At its very core, a fungible token is an exchangeable asset that is divisible but is not unique. For example, if Benji had 1 Canadian dollar, it would be worth the exact same as Matt's Canadian dollar. Both their dollars are fungible and exchangeable. In this case, the fungible token is the canadian dollar. All fiat currencies are fungible and exchangeable.
Non-fungible tokens, on the other hand, are unique and indivisible such as a house or a car. You cannot have another asset that is exactly the same. Even if you had a specific car model, such as a Corvette 1963 C2 Stingray, each car would have a separate serial number with a different number of kilometers driven etc...
Now that you understand what a fungible token is, let's look at how you can define one in the contract itself.

Defining a fungible token
Start by navigating to the 1.skeleton/src/metadata.rs file. This is where you'll define the metadata for the fungible token itself. There are several ways NEAR allows you to customize your token, all of which are found in the metadata standard. Let's break them up into the optional and non-optional portions.
Required:

spec: Indicates the version of the standard the contract is using. This should be set to ft-1.0.0.
name: The human readable name of the token such as "Wrapped NEAR" or "TEAM Tokens".
symbol: The abbreviation of the token such as wNEAR or gtNEAR.
decimals: used in frontends to show the proper significant digits of a token. This concept is explained well in this OpenZeppelin post.

Optional:

icon: The image for the token (must be a data URL).
reference: A link to any supplementary JSON details for the token stored off-chain.
reference_hash: A hash of the referenced JSON.

With this finished, you can now add these fields to the metadata in the contract.

Now that you've defined what the metadata will look like, you need someway to store it on the contract. Switch to the 1.skeleton/src/lib.rs file and add the following to the Contract struct. You'll want to store the metadata on the contract under the metadata field.

You've now defined where the metadata will live but you'll also need someway to pass in the metadata itself. This is where the initialization function comes into play.

Initialization Functions
You'll now create what's called an initialization function; you can name it new. This function needs to be invoked when you first deploy the contract. It will initialize all the contract's fields that you've defined with default values. It's important to note that you cannot call these methods more than once.

More often than not when doing development, you'll need to deploy contracts several times. You can imagine that it might get tedious to have to pass in metadata every single time you want to initialize the contract. For this reason, let's create a function that can initialize the contract with a set of default metadata. You can call it new_default_meta.

This function is simply calling the previous new function and passing in some default metadata behind the scenes.
At this point, you've defined the metadata for your fungible tokens and you've created a way to store this information on the contract. The last step is to introduce a getter that will query for and return the metadata. Switch to the 1.skeleton/src/metadata.rs file and add the following code to the ft_metadata function.

This function will get the metadata object from the contract which is of type FungibleTokenMetadata and will return it.

Interacting with the contract on-chain
Now that the logic for defining a custom fungible token is complete and you've added a way to query for the metadata, it's time to build and deploy your contract to the blockchain.
Deploying and initializing the contract
You can build a contract using the following command:
cd 2.define-a-token
cargo near build
There will be a list of warnings on your console, but as the tutorial progresses, these warnings will go away.
For deployment, you will need a NEAR account with the keys stored on your local machine. Navigate to the NEAR wallet site and create an account.
infoPlease ensure that you deploy the contract to an account with no pre-existing contracts. It's easiest to simply create a new account or create a sub-account for this tutorial.

Log in to your newly created account with near-cli-rs by running the following command in your terminal.
near account import-account using-web-wallet network-config testnet
To make this tutorial easier to copy/paste, we're going to set an environment variable for your account ID. In the command below, replace YOUR_ACCOUNT_NAME with the account name you just logged in with including the .testnet portion:
export FT_CONTRACT_ID="YOUR_ACCOUNT_NAME.testnet"
Test that the environment variable is set correctly by running:
echo $FT_CONTRACT_ID
Verify that the correct account ID is printed in the terminal. If everything looks correct you can now deploy your contract. For simplicity, let's call the default metadata initialization function you wrote earlier so that you don't have to type the metadata manually in the CLI. In the root of your FT project run the following command to deploy your smart contract.
cargo near deploy $FT_CONTRACT_ID with-init-call new_default_meta json-args '{"owner_id": "'$FT_CONTRACT_ID'", "total_supply": "0"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
At this point, the contract should have been deployed to your account and initialized.

Viewing the contract's metadata
Now that the contract has been initialized, you can query for the metadata by calling the function you wrote earlier.

  

  ```bash
  near view $FT_CONTRACT_ID ft_metadata '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only $FT_CONTRACT_ID ft_metadata json-args {} network-config testnet now
  ```
  

This should return an output similar to the following:
{
  spec: 'ft-1.0.0',
  name: 'Team Token FT Tutorial',
  symbol: 'gtNEAR',
  icon: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAASABIAAD/
        /*
        ...lots of base64 data...
        */
        j4Mvhy9H9NlnieJ4iwoo9ZlyLGx4pnrPWeB4CVGRZZcJ7Vohwhi0z5MJY4cVL4MdP/Z',
  reference: null,
  reference_hash: null,
  decimals: 24
}
Go team! You've now verified that everything works correctly and you've defined your own fungible token!
In the next tutorial, you'll learn about how to create a total supply and view the tokens in the wallet.

Conclusion
In this tutorial, you went through the basics of setting up and understanding the logic behind creating a fungible token on the blockchain using a skeleton contract.
You first looked at what a fungible token is and how it differs from a non-fungible token. You then learned how to customize and create your own fungible tokens and how you could modify the skeleton contract to achieve this. Finally you built and deployed the contract and interacted with it using the NEAR CLI.
Next Steps
In the next tutorial, you'll find out how to create an initial supply of tokens and have them show up in the NEAR wallet.

noteVersioning for this article
At the time of this writing, this example works with the following versions:

- rustc: `1.77.1`
- near-sdk-rs: `5.1.0` (with enabled `legacy` feature)
- cargo-near: `0.6.1`
- near-cli-rs: `0.11.0`

### Fungible Tokens Zero to Hero

In this Zero to Hero series, you'll find a set of tutorials covering every aspect of a fungible token (FT) smart contract. You'll start by interacting with a pre-deployed contract and by the end you'll have built a fully-fledged FT smart contract that supports every extension of the standards.

Prerequisites
To complete these tutorials successfully, you'll need:

Rust
A NEAR wallet
NEAR-CLI
cargo-near

infoNew to Rust?
If you are new to Rust and want to dive into smart contract development, our [Quick-start guide](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) is a great place to start.


Overview
These are the steps that will bring you from Zero to Hero in no time! 💪



Step
Name
Description




1
Pre-deployed contract
Receive FTs without the need to code, create, or deploy a smart contract.


2
Contract architecture
Learn the basic architecture of the FT smart contract and compile the code.


3
Defining a Token
Flesh out what it means to have a FT and how you can customize your own.


4
Circulating Supply
Learn how to create an initial supply and have the token show up in your wallet.


5
Registering Accounts
Explore how you can implement and understand the storage management standard to avoid malicious users from draining your funds.


6
Transferring FTs
Learn how to transfer FTs and discover some of the true powers that the core standard brings


7
Marketplace
Learn about how common marketplaces operate on NEAR and dive into some of the code that allows buying and selling NFTs by using Fungible Tokens.





Next steps
Ready to start? Jump to the Pre-deployed Contract tutorial and begin your learning journey!
If you already know about fungible tokens and smart contracts, feel free to skip and jump directly to the tutorial of your interest. The tutorials have been designed so you can start at any given point!

### Cross Contract Call

This example performs the simplest cross-contract call possible: it calls our Hello NEAR example to set and retrieve a greeting.
It is one of the simplest examples on making a cross-contract call, and the perfect gateway to the world of interoperative contracts.
infoAdvanced Cross-Contract Calls
Check the tutorial on how to perform cross-contract calls [in batches and in parallel](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/examples/./advanced-xcc)


Obtaining the Cross Contract Call Example
You have two options to start the project:

You can use the app through Github Codespaces, which will open a web-based interactive environment.
Clone the repository locally and use it from your computer.




Codespaces
Clone locally





🌠https://github.com/near-examples/cross-contract-calls




Structure of the Example
The smart contract is available in two flavors: Rust and JavaScript


  

```bash
┌── sandbox-ts # sandbox testing
│    ├── hello-near
│    │    └── hello-near.wasm
│    └── main.ava.ts
├── src # contract's code
│    └── contract.ts
├── package.json
├── README.md
└── tsconfig.json
```

  

  

```bash
┌── tests # sandbox testing
│    ├── hello-near
│    │    └── hello-near.wasm
│    └── tests.rs
├── src # contract's code
│    ├── external.rs
│    └── lib.rs
├── Cargo.toml # package manager
├── README.md
└── rust-toolchain.toml
```

  



Smart Contract
Contract
The contract exposes methods to query the greeting and change it. These methods do nothing but calling get_greeting and
set_greeting in the hello-near example.


    
  
  
    
            
  

Testing the Contract
The contract readily includes a set of unit and sandbox testing to validate its functionality. To execute the tests, run the following commands:

  

  ```bash
  cd contract-simple-ts
  yarn
  yarn test
  ```

  
  

  ```bash
  cd contract-simple-rs
  cargo test
  ```
  


tiphe `integration tests` use a sandbox to create NEAR users and simulate interactions with the contract.

In this project in particular, the integration tests first deploy the hello-near contract. Then,
they test that the cross-contract call correctly sets and retrieves the message. You will find the integration tests
in sandbox-ts/ for the JavaScript version and in tests/ for the Rust version.

  
    
  
  
    
  


Deploying the Contract to the NEAR network
In order to deploy the contract you will need to create a NEAR account.

  

  ```bash
  # Create a new account pre-funded by a faucet
  near create-account  --useFaucet
  ```
  

  

  ```bash
  # Create a new account pre-funded by a faucet
  near account create-account sponsor-by-faucet-service .testnet autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Go into the directory containing the smart contract (cd contract-advanced-ts or cd contract-advanced-rs), build and deploy it:
cargo near build

cargo near deploy <accountId> with-init-call new json-args '{"hello_account":"hello.near-example.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

CLI: Interacting with the Contract
To interact with the contract through the console, you can use the following commands:

  

  ```bash
  # Get message from the hello-near contract
  # Replace  with your account ID
  near call  query_greeting --accountId 

  # Set a new message for the hello-near contract
  # Replace  with your account ID
  near call  change_greeting '{"new_greeting":"XCC Hi"}' --accountId 
  ```
  

  

  ```bash
  # Get message from the hello-near contract
  # Replace  with your account ID
  near contract call-function as-transaction  query_greeting json-args '{}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as  network-config testnet sign-with-keychain send

  # Set a new message for the hello-near contract
  # Replace  with your account ID
  near contract call-function as-transaction  change_greeting json-args '{"new_greeting":"XCC Hi"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as  network-config testnet sign-with-keychain send
  ```
  


Moving Forward
A nice way to learn is by trying to expand a contract. Modify the cross contract example to use the guest-book
contract!. In this way, you can try to make a cross-contract call that attaches money. Remember to correctly handle the callback,
and to return the money to the user in case of error.
Advanced Cross Contract Calls
Your contract can perform multiple cross-contract calls in simultaneous, creating promises that execute in parallel, or as a batch transaction. Check the advanced cross contract calls
tutorial to learn more.

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Self Upgrade & State Migration

Three examples on how to handle updates and state migration:

State Migration: How to implement a migrate method to migrate state between contract updates.
State Versioning: How to use readily use versioning on a state, to simplify updating it later.
Self Update: How to implement a contract that can update itself.


State Migration
The State Migration example shows how to handle state-breaking changes
between contract updates.
It is composed by 2 contracts:

Base: A Guest Book where people can write messages.
Update: An update in which we remove a parameter and change the internal structure.


  
    
  

The Migration Method
The migration method deserializes the current state (OldState) and iterates through the messages, updating them
to the new PostedMessage that includes the payment field.
tipotice that migrate is actually an [initialization method](/build/smart-contracts/anatomy/storage#initializing-the-state) that ignores the existing state (`[#init(ignore_state)]`), thus being able to execute and rewrite the state.


State Versioning
The State Versioning example shows how to use
Enums to implement state versioning on a contract.
Versioning simplifies updating the contract since you only need to add a new version of the structure.
All versions can coexist, thus you will not need to change previously existing structures.
The example is composed by 2 contracts:

Base: The Guest Book contract using versioned PostedMessages (PostedMessagesV1).
Update: An update that adds a new version of PostedMessages (PostedMessagesV2).


  
    
  


Self Update
The Self Update example shows how to implement a contract
that can update itself.
It is composed by 2 contracts:

Base: A Guest Book were people can write messages, implementing a update_contract method.
Update: An update in which we remove a parameter and change the internal structure.

### Guest Book

Our Guest Book example is a simple app composed by two main components:

A smart contract that stores messages from users, allowing to attach money to them.
A simple web-based frontend that displays the last 10 messages posted.



Obtaining the Guest book Example
You have two options to start the Guest book Example.

You can use the app through GitHub Codespaces, which will open a web-based interactive environment.
Clone the repository locally and use it from your computer.




Codespaces
Clone locally





🌠https://github.com/near-examples/guest-book-examples




Structure of the Example
The example is divided in two main components:

The smart contract, available in two flavors: Rust and JavaScript
The frontend, that interacts with an already deployed contract.



  

```bash
┌── sandbox-ts # sandbox testing
│    ├── src
│    │    └── main.ava.ts
│    ├── ava.config.cjs
│    └── package.json
├── src # contract's code
│    ├── contract.ts
│    └── model.ts
├── package.json # package manager
├── README.md
└── tsconfig.json # test script
```

  

  

```bash
┌── tests # workspaces testing
│    ├── workspaces.rs
├── src # contract's code
│    └── lib.rs
├── Cargo.toml # package manager
├── README.md
└── rust-toolchain.toml
```

  



Frontend
The guest book example includes a frontend that interacts with an already deployed smart contract, allowing user to sign a message.

Running the Frontend
To start the frontend you will need to install the dependencies and start the server.
cd frontend
yarn
yarn dev
Go ahead and login with your NEAR account. If you don't have one, you will be able to create one in the moment. Once logged in, you will be able to sign a message in the guest book. You can further send some money alongside your message. If you attach more than 0.01Ⓝ then your message will be marked as "premium".

Understanding the Frontend
The frontend is a Next.JS project generated by create-near-app. Check _app.js and index.js to understand how components are displayed and interacting with the contract.

  
  


Smart Contract
The contract presents 3 methods: add_message, get_message and total_messages.

  
    
  
  
    
  



Testing the Contract
The contract readily includes a set of unit and sandbox testing to validate its functionality. To execute the tests, run the following commands:

  

```bash
cd contract-ts
yarn
yarn test
```

  
  

  ```bash
  cd contract-rs
  cargo test
  ```

  


tiphe `integration tests` use a sandbox to create NEAR users and simulate interactions with the contract.


Deploying the Contract to the NEAR network
In order to deploy the contract you will need to create a NEAR account.

  

  ```bash
  # Create a new account pre-funded by a faucet
  near create-account  --useFaucet
  ```
  

  

  ```bash
  # Create a new account pre-funded by a faucet
  near account create-account sponsor-by-faucet-service .testnet autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Go into the directory containing the smart contract (cd contract-ts or cd contract-rs), build and deploy it:
cargo near build

cargo near deploy <accountId>
tipo interact with your contract from the [frontend](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/examples/#frontend), simply replace the variable `CONTRACT_NAME` in the `index.js` file.


CLI: Interacting with the Contract
To interact with the contract through the console, you can use the following commands.
Get messages

  

  ```bash
  near view guestbook.near-examples.testnet get_messages '{"from_index": "0","limit": "10"}'
  ```
  

  

  ```bash
  near contract call-function as-read-only guestbook.near-examples.testnet get_messages json-args '{"from_index": "0","limit": "10"}' network-config testnet now
  ```
  


Get total number of messages

  

  ```bash
  near view guestbook.near-examples.testnet total_messages
  ```
  

  

  ```bash
  near contract call-function as-read-only guestbook.near-examples.testnet total_messages json-args {} network-config testnet now
  ```
  


Add a message

  

  ```bash
  # Replace  with your account ID
  # Required a text
  # Optional deposit to make the message premium
  near call guestbook.near-examples.testnet add_message '{"text":"Hello Near"}' --accountId  --deposit 0.1
  ```
  

  

  ```bash
  # Replace  with your account ID
  # Required a text
  # Optional deposit to make the message premium
  near contract call-function as-transaction guestbook.near-examples.testnet add_message json-args '{"text":"Hello Near"}' prepaid-gas '30.0 Tgas' attached-deposit '0.1 NEAR' sign-as  network-config testnet sign-with-keychain send
  ```
  


tipf you're using your own account, replace `guestbook.near-examples.testnet` with your `accountId`.


Moving Forward
A nice way to learn is by trying to expand a contract. You can modify the guestbook example to incorporate a feature where users can give likes to messages. Additionally, implement a method to toggle the like.

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Frontend Interacting with Multiple Contracts

This example showcases how to interact with multiple contracts from a single frontend.
Particularly, this example shows how to:

Query data from multiple contracts.
Call methods in multiple contracts simultaneously.


Query Data from Multiple Contracts
To query multiple contracts simply perform multiple view calls:

  


Dispatching Multiple Transactions
The wallet object enables to dispatch multiple transactions simultaneously. However, please notice that the transactions execute independently.
Dispatching multiple transactions at once is just a nice way to improve UX, because the user interacts with the wallet only once.

  

In this example, the user signs two independent transactions:

A transaction to call set_greeting in our Hello NEAR example
A transaction to call add_message in our GuestBook example


:::caution
Even when the user accepts signing the transactions at the same time, the
transactions remain independent. This is, if one fails, the other is NOT rolled back.
::


Batch Actions
You can aggregate multiple actions directed towards a same contract into a single transaction. Batched actions execute sequentially, with the added benefit that, if one fails then they all get reverted.
  // Register a user and transfer them FT on a single take
  const REGISTER_DEPOSIT = "1250000000000000000000";

  const ftTx = {
    receiverId: FT_ADDRESS,
    actions: [
      {
        type: 'FunctionCall',
        params: {
          methodName: 'storage_deposit',
          args: { account_          gas: THIRTY_TGAS, deposit: REGISTER_DEPOSIT
        }
      },
      {
        type: 'FunctionCall',
        params: {
          methodName: 'ft_transfer',
          args: { receiver_          gas: THIRTY_TGAS, deposit: 1 }
      }
    ]
  }

  // Ask the wallet to sign and send the transaction
  await wallet.signAndSendTransactions({ transactions: [ ftTx ] })

### Factory

A factory is a smart contract that stores a compiled contract on itself, and automatizes deploying it into
sub-accounts.
We have two factory examples:

Token Factory: A factory that creates fungible tokens contracts.
A Generic Factory: A factory that creates donation contracts, but allows to change the contract it deploys.

infoIn this page we will focus on the Donation factory, to learn more about the token factory visit its repository.


Generic Factory
The Generic Factory presents a contract factory that:

Creates sub-accounts of itself and deploys its contract on them (create_factory_subaccount_and_deploy).
Can change the stored contract using the update_stored_contract method.


  
    
    
  


Quickstart

Make sure you have installed rust.
Install the NEAR CLI


Build and Deploy the Factory
You can automatically compile and deploy the contract in the NEAR testnet by running:
./deploy.sh
Once finished, check the neardev/dev-account file to find the address in which the contract was deployed:
cat ./neardev/dev-account
# e.g. dev-1659899566943-21539992274727

Deploy the Stored Contract Into a Sub-Account
create_factory_subaccount_and_deploy will create a sub-account of the factory and deploy the
stored contract on it.
near call <factory-account> create_factory_subaccount_and_deploy '{ "name": "sub", "beneficiary": "<account-to-be-beneficiary>"}' --deposit 1.24 --accountId <account-id> --gas 300000000000000
This will create the sub.<factory-account>, which will have a donation contract deployed on it:
near view sub.<factory-account> get_beneficiary
# expected response is: <account-to-be-beneficiary>

Update the Stored Contract
update_stored_contract enables to change the compiled contract that the factory stores.
The method is interesting because it has no declared parameters, and yet it takes
an input: the new contract to store as a stream of bytes.
To use it, we need to transform the contract we want to store into its base64
representation, and pass the result as input to the method:
# Use near-cli to update stored contract
export BYTES=`cat ./src/to/new-contract/contract.wasm | base64`
near call <factory-account> update_stored_contract "$BYTES" --base64 --accountId <factory-account> --gas 30000000000000

This works because the arguments of a call can be either a JSON object or a String Buffer



Factories are an interesting concept, here we further explain some of their implementation aspects,
as well as their limitations.

Automatically Creating Accounts
NEAR accounts can only create sub-accounts of itself, therefore, the factory can only create and
deploy contracts on its own sub-accounts.
This means that the factory:

Can create sub.factory.testnet and deploy a contract on it.
Cannot create sub-accounts of the predecessor.
Can create new accounts (e.g. account.testnet), but cannot deploy contracts on them.

It is important to remember that, while factory.testnet can create sub.factory.testnet, it has
no control over it after its creation.

The Update Method
The update_stored_contracts has a very short implementation:
#[private]
pub fn update_stored_contract(&mut self) {
  self.code = env::input().expect("Error: No input").to_vec();
}
On first sight it looks like the method takes no input parameters, but we can see that its only
line of code reads from env::input(). What is happening here is that update_stored_contract
bypasses the step of deserializing the input.
You could implement update_stored_contract(&mut self, new_code: Vec<u8>),
which takes the compiled code to store as a Vec<u8>, but that would trigger the contract to:

Deserialize the new_code variable from the input.
Sanitize it, making sure it is correctly built.

When dealing with big streams of input data (as is the compiled wasm file to be stored), this process
of deserializing/checking the input ends up consuming the whole GAS for the transaction.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Donation

Our donation example enables to forward NEAR Tokens to an account while keeping track of it. It is one of the simplest examples on making a contract handle tranfers.

Frontend of the Donation App

Obtaining the Donation Example
You have two options to start the Donation Example.

You can use the app through Github Codespaces, which will open a web-based interactive environment.
Clone the repository locally and use it from your computer.




Codespaces
Clone locally





🌠https://github.com/near-examples/donation-examples.git




Structure of the Example
The example is divided in two main components:

The smart contract, available in two flavors: rust and javascript
The frontend, that interacts with an already deployed contract.



  

```bash
┌── sandbox-ts # sandbox testing
│    ├── src
│    │    └── main.ava.ts
│    ├── ava.config.cjs
│    └── package.json
├── src # contract's code
│    ├── contract.ts
│    ├── model.ts
│    └── utils.ts
├── package.json # package manager
├── README.md
└── tsconfig.json # test script
```

  

  

```bash
┌── tests # workspaces testing
│    ├── workspaces.rs
├── src # contract's code
│    ├── donation.rs
│    └── lib.rs
├── Cargo.toml # package manager
├── README.md
└── rust-toolchain.toml
```

  



Frontend
The donation example includes a frontend that interacts with an already deployed smart contract, allowing user to donate NEAR tokens to a faucet service.

Running the Frontend
To start the frontend you will need to install the dependencies and start the server.
cd frontend
yarn
yarn dev
Go ahead and login with your NEAR account. If you don't have one, you will be able to create one in the moment. Once logged in, input the amount of NEAR you want to donate and press the donate button. You will be redirected to the NEAR Wallet to confirm the transaction. After confirming it, the donation will be listed in the "Latest Donations".

Understanding the Frontend
The frontend is a Next.JS project generated by create-near-app. Check DonationsTable.jsx and DonationsForm.jsx to understand how components are displayed and interacting with the contract.

  
  

An interesting aspect of the donation example is that it showcases how to retrieve a result after being redirected to the
NEAR wallet to accept a transaction.

Smart Contract
The contract exposes methods to donate tokens (donate), and methods to retrieve the recorded donations (e.g. get_donation_for_account).

  
    
  
  
    
  


Testing the Contract
The contract readily includes a set of unit and sandbox testing to validate its functionality. To execute the tests, run the following commands:

  

  ```bash
  cd contract-ts
  yarn
  yarn test
  ```

  
  

  ```bash
  cd contract-rs
  cargo test
  ```

  


tiphe `integration tests` use a sandbox to create NEAR users and simulate interactions with the contract.


Deploying the Contract to the NEAR network
In order to deploy the contract you will need to create a NEAR account.

  

  ```bash
  # Create a new account pre-funded by a faucet
  near create-account  --useFaucet
  ```
  

  

  ```bash
  # Create a new account pre-funded by a faucet
  near account create-account sponsor-by-faucet-service .testnet autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Go into the directory containing the smart contract (cd contract-ts or cd contract-rs), build and deploy it:
cargo near build

cargo near deploy <accountId>
tipo interact with your contract from the [frontend](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/examples/#frontend), simply replace the variable `CONTRACT_NAME` in the `index.js` file.


CLI: Interacting with the Contract
To interact with the contract through the console, you can use the following commands
Get donations

  

  ```bash
  near view donation.near-examples.testnet get_donations '{"from_index": "0","limit": "10"}'
  ```
  

  

  ```bash
  near contract call-function as-read-only donation.near-examples.testnet get_donations json-args '{"from_index": "0","limit": "10"}' network-config testnet now
  ```
  


Get beneficiary

  

  ```bash
  near view donation.near-examples.testnet get_beneficiary
  ```
  

  

  ```bash
  near contract call-function as-read-only donation.near-examples.testnet get_beneficiary json-args {} network-config testnet now
  ```
  


Get number of donors

  

  ```bash
  near view donation.near-examples.testnet number_of_donors
  ```
  

  

  ```bash
  near contract call-function as-read-only donation.near-examples.testnet number_of_donors json-args {} network-config testnet now
  ```
  


Get donation for an account

  

  ```bash
  # Require accountId
  near view donation.near-examples.testnet get_donation_for_account '{"account_id":}'
  ```
  

  

  ```bash
  # Require accountId
  near contract call-function as-read-only donation.near-examples.testnet get_donation_for_account json-args '{"account_id":}' network-config testnet now
  ```
  


Donate to the contract

  

  ```bash
  # Replace  with your account ID
  # Require deposit
  near call donation.near-examples.testnet donate --accountId  --deposit 0.1
  ```
  

  

  ```bash
  # Replace  with your account ID
  # Require deposit
  near contract call-function as-transaction donation.near-examples.testnet donate json-args {} prepaid-gas '30.0 Tgas' attached-deposit '0.1 NEAR' sign-as  network-config testnet sign-with-keychain send
  ```
  


tipf you're using your own account, replace `donation.near-examples.testnet` with your `accountId`.


Moving Forward
A nice way to learn is by trying to expand a contract. Modify the donation example so it accumulates the tokens in the contract
instead of sending it immediately. Then, make a method that only the beneficiary can call to retrieve the tokens.

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Count on NEAR

Our counter example is a friendly decentralized app that stores a number and exposes methods to increment,
decrement, and reset it.


Obtaining the Counter Example
You have two options to start the Counter Example.

You can use the app through GitHub Codespaces, which will open a web-based interactive environment.
Clone the repository locally and use it from your computer.




Codespaces
Clone locally





🌠https://github.com/near-examples/counters




Structure of the Example
The example is divided in two main components:

The smart contract, available in two flavors: Rust and JavaScript
The frontend, that interacts with an already deployed contract.



  

```bash
┌── sandbox-ts # sandbox testing
│    ├── src
│    │    └── main.ava.ts
│    ├── ava.config.cjs
│    └── package.json
├── src # contract's code
│    └── contract.ts
├── package.json # package manager
├── README.md
└── tsconfig.json # test script
```

  

  

```bash
┌── src # contract's code
│    └── lib.rs
├── tests # sandbox test
│    └── test_basics.rs
├── Cargo.toml # package manager
├── README.md
└── rust-toolchain.toml
```

  



Frontend
The counter example includes a frontend interface designed to interact seamlessly with an existing smart contract that has been deployed. This interface allows users to increase or decrease the counter as needed.

Running the Frontend
To start the frontend you will need to install the dependencies and start the server.
cd frontend
yarn
yarn dev
Go ahead and login with your NEAR account. If you don't have one, you will be able to create one in the moment. Once logged in, use the + and - buttons to increase and decrease the counter. Then, use the Gameboy buttons to reset it and make the counter blink an eye!

Frontend of the Counter

Understanding the Frontend
The frontend is a Next.JS project generated by create-near-app. Check _app.js and index.js to understand how components are displayed and interacting with the contract.

  
  


Smart Contract
The contract presents 4 methods: get_num, increment, decrement, and reset. The method get_num retrieves the current value, and the rest modify it.

  
    
  
  
    
  


Testing the Contract
The contract readily includes a set of unit and sandbox testing to validate its functionality. To execute the tests, run the following commands:

  

```bash
cd contract-ts
yarn
yarn test
```

  
  

  ```bash
  cd contract-rs
  cargo test
  ```

  


tiphe `integration tests` use a sandbox to create NEAR users and simulate interactions with the contract.


Deploying the Contract to the NEAR network
In order to deploy the contract you will need to create a NEAR account.

  

  ```bash
  # Create a new account pre-funded by a faucet
  near create-account  --useFaucet
  ```
  

  

  ```bash
  # Create a new account pre-funded by a faucet
  near account create-account sponsor-by-faucet-service .testnet autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Go into the directory containing the smart contract (cd contract-ts or cd contract-rs), build and deploy it:
cargo near build

cargo near deploy <accountId>
tipo interact with your contract from the [frontend](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/examples/#frontend), simply replace the value of the `testnet` key in the `config.js` file.


CLI: Interacting with the Contract
To interact with the contract through the console, you can use the following commands.
Get the current number of the counter

  

  ```bash
  near view counter.near-examples.testnet get_num
  ```
  

  

  ```bash
   near contract call-function as-read-only counter.near-examples.testnet get_num json-args {} network-config testnet now
  ```
  


Increment the counter

  

  ```bash
  # Replace  with your account ID
  near call counter.near-examples.testnet increment --accountId 
  ```
  

  

  ```bash
  # Replace  with your account ID
  near contract call-function as-transaction counter.near-examples.testnet increment json-args {} prepaid-gas '30.0 Tgas' attached-deposit '0 NEAR' sign-as aha_6.testnet network-config testnet sign-with-keychain send
  ```
  


Decrement the counter

  

  ```bash
  # Replace  with your account ID
  near call counter.near-examples.testnet decrement --accountId 
  ```
  

  

  ```bash
  # Replace  with your account ID
  near contract call-function as-transaction counter.near-examples.testnet decrement json-args {} prepaid-gas '30.0 Tgas' attached-deposit '0 NEAR' sign-as aha_6.testnet network-config testnet sign-with-keychain send
  ```
  


Reset the counter to zero

  

  ```bash
  # Replace  with your account ID
  near call counter.near-examples.testnet reset --accountId 
  ```
  

  

  ```bash
  # Replace  with your account ID
  near contract call-function as-transaction counter.near-examples.testnet reset json-args {} prepaid-gas '30.0 Tgas' attached-deposit '0 NEAR' sign-as aha_6.testnet network-config testnet sign-with-keychain send
  ```
  

tipf you're using your own account, replace `counter.near-examples.testnet` with your `accountId`.


Moving Forward
A nice way to learn is by trying to expand the contract. Modify it by adding a parameter to increment and decrement,
so the user can choose by how much to change the value. For this, you will need to use knowledge from the anatomy
and storage sections.

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Coin Flip

Coin Flip is a game where the player tries to guess the outcome of a coin flip. It is one of the simplest contracts implementing random numbers.


Starting the Game
You have two options to start the example:

Recommended: use the app through Gitpod (a web-based interactive environment)
Clone the project locally.




Gitpod
Clone locally





https://github.com/near-examples/coin-flip-examples.git



If you choose Gitpod, a new browser window will open automatically with the code. Give it a minute, and the front-end will pop up (ensure the pop-up window is not blocked).
If you are running the app locally, you should build and deploy a contract (JavaScript or Rust version) and a client manually.

Interacting With the Counter
Go ahead and log in with your NEAR account. If you don't have one, you can create one on the fly. Once logged in, use the tails and heads buttons to try to guess the next coin flip outcome.

Frontend of the Game

Structure of a dApp
Now that you understand what the dApp does, let us take a closer look to its structure:

The frontend code lives in the /frontend folder.
The smart contract code in Rust is in the /contract-rs folder.
The smart contract code in JavaScript is in the /contract-ts folder.

noteBoth Rust and JavaScript versions of the contract implement the same functionality.

Contract
The contract presents 2 methods: flip_coin, and points_of.

  
    
  
  
    
  

Running the Frontend
To start the frontend you will need to install the dependencies and start the server.
cd frontend
yarn
yarn dev

Understanding the Frontend
The frontend is a Next.JS project generated by create-near-app. Check _app.js and index.js to understand how components are displayed and interacting with the contract.

  
                          


Testing
When writing smart contracts, it is very important to test all methods exhaustively. In this
project you have integration tests. Before digging into them, go ahead and perform the tests present in the dApp through the command yarn test for the JavaScript version, or ./test.sh for the Rust version.
Integration test
Integration tests can be written in both Rust and JavaScript. They automatically deploy a new
contract and execute methods on it. In this way, integration tests simulate interactions
from users in a realistic scenario. You will find the integration tests for the coin-flip
in contract-ts/sandbox-ts (for the JavaScript contract) and contract-rs/tests (for the Rust contract).

  
    
  
  
    
  


A Note On Randomness
Randomness in the blockchain is a complex subject. We recommend you to read and investigate about it.
You can start with our security page on it.
noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Complex Cross Contract Call

This example presents 3 instances of complex cross-contract calls. Particularly, it shows:

How to batch multiple function calls to a same contract.
How to call multiple contracts in parallel, each returning a different type.
Different ways of handling the responses in the callback.

infoSimple Cross-Contract Calls

Check the tutorial on how to use [simple cross-contract calls](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/examples/xcc.md)



Obtaining the Cross Contract Call Example
You have two options to start the Donation Example:

You can use the app through Github Codespaces, which will open a web-based interactive environment.
Clone the repository locally and use it from your computer.




Codespaces
Clone locally





🌠https://github.com/near-examples/cross-contract-calls




Structure of the Example
The smart contract is available in two flavors: Rust and JavaScript


  

```bash
┌── sandbox-ts # sandbox testing
│    ├── external-contracts
│    │    ├── counter.wasm
│    │    ├── guest-book.wasm
│    │    └── hello-near.wasm
│    └── main.ava.ts
├── src # contract's code
│    ├── internal
│    │    ├── batch_actions.ts
│    │    ├── constants.ts
│    │    ├── multiple_contracts.ts
│    │    ├── similar_contracts.ts
│    │    └── utils.ts
│    └── contract.ts
├── package.json
├── README.md
└── tsconfig.json
```

  

  

```bash
┌── tests # sandbox testing
│    ├── external-contracts
│    │    ├── counter.wasm
│    │    ├── guest-book.wasm
│    │    └── hello-near.wasm
│    └── main.ava.ts
├── src # contract's code
│    ├── batch_actions.rs
│    ├── lib.rs
│    ├── multiple_contracts.rs
│    └── similar_contracts.rs
├── Cargo.toml # package manager
├── README.md
└── rust-toolchain.toml
```

  



Smart Contract
Batch Actions
You can aggregate multiple actions directed towards one same contract into a batched transaction.
Methods called this way are executed sequentially, with the added benefit that, if one fails then
they all get reverted.

  
    
    
  
  
    
  

Getting the Last Response
In this case, the callback has access to the value returned by the last
action from the chain.

  
    
    
    
  
  
    
  


Calling Multiple Contracts
A contract can call multiple other contracts. This creates multiple transactions that execute
all in parallel. If one of them fails the rest ARE NOT REVERTED.

  
    
    
  
  
    
  

Getting All Responses
In this case, the callback has access to an array of responses, which have either the
value returned by each call, or an error message.

  
    
    
    
  
  
    
  


Multiple Calls - Same Result Type
This example is a particular case of the previous one (Calling Multiple Contracts).
It simply showcases a different way to check the results by directly accessing the promise_result array.
In this case, we call multiple contracts that will return the same type:

  
    
    
  
  
    
  

Getting All Responses
In this case, the callback again has access to an array of responses, which we can iterate checking the
results.

  
    
    
    
  
  
    
  


Testing the Contract
The contract readily includes a set of unit and sandbox testing to validate its functionality. To execute the tests, run the following commands:

  

  ```bash
  cd contract-advanced-ts
  yarn
  yarn test
  ```

  
  

  ```bash
  cd contract-advanced-rs
  cargo test
  ```

  


tiphe `integration tests` use a sandbox to create NEAR users and simulate interactions with the contract.


Deploying the Contract to the NEAR network
In order to deploy the contract you will need to create a NEAR account.

  

  ```bash
  # Create a new account pre-funded by a faucet
  near create-account  --useFaucet
  ```
  

  

  ```bash
  # Create a new account pre-funded by a faucet
  near account create-account sponsor-by-faucet-service .testnet autogenerate-new-keypair save-to-keychain network-config testnet create
  ```
  

Go into the directory containing the smart contract (cd contract-advanced-ts or cd contract-advanced-rs), build and deploy it:
cargo near build

cargo near deploy <accountId> with-init-call new json-args '{"hello_account":"hello.near-example.testnet","guestbook_account":"guestbook_account.near-example.testnet","counter_account":"counter_account.near-example.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

CLI: Interacting with the Contract
To interact with the contract through the console, you can use the following commands:

  

  ```bash
  # Execute contracts sequentially
  # Replace  with your account ID
  near call  batch_actions --accountId  --gas 300000000000000   

  # Execute contracts in parallel
  # Replace  with your account ID
  near call   multiple_contracts --accountId  --gas 300000000000000   

  # Execute multiple instances of the same contract in parallel
  # Replace  with your account ID
  near call  similar_contracts --accountId  --gas 300000000000000
  ```
  

  

  ```bash
  # Execute contracts sequentially
  # Replace  with your account ID
  near contract call-function as-transaction  batch_actions json-args '{}' prepaid-gas '300.0 Tgas' attached-deposit '0 NEAR' sign-as  network-config testnet sign-with-keychain send

  # Execute contracts in parallel
  # Replace  with your account ID
  near contract call-function as-transaction  multiple_contracts json-args '{}' prepaid-gas '300.0 Tgas' attached-deposit '0 NEAR' sign-as  network-config testnet sign-with-keychain send

  # Execute multiple instances of the same contract in parallel
  # Replace  with your account ID
  near contract call-function as-transaction  similar_contracts json-args '{}' prepaid-gas '300.0 Tgas' attached-deposit '0 NEAR' sign-as  network-config testnet sign-with-keychain send
  ```
  

infoIf at some point you get an "Exceeded the prepaid gas" error, try to increase the gas amount used within the functions when calling other contracts

noteVersioning for this article

At the time of this writing, this example works with the following versions:

- near-cli: `4.0.13`
- node: `18.19.1`
- rustc: `1.77.0`

### Using base64-encoded arguments when we create a new crossword puzzle

Final modifications
Let's modify our new_puzzle method a bit, and demonstrate how a smart contract author might use base64-encoded arguments.
In the previous chapter we had a fairly long NEAR CLI command that called the new_puzzle, providing it the parameters for all the clues. Having these lengthy parameters on the CLI might get cumbersome. There may be issues needing to escape single or double quotes, and each operating system may wish for a different format on the Terminal or Command Prompt.
We're going to send all the arguments as a base64-encoded string, and make this a bit simpler. For this, we're going to use Base64VecU8 from the SDK.
note`Base64VecU8` is great for binary payloads
What we're doing makes sense, but it's worth noting that it's perhaps more common to use `Base64VecU8` when sending binary parameters.

Read more [about it here](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/serialization-interface.md).

First we'll set up a struct for the arguments we're expecting:

Then we modify our new_puzzle method like so:

We can take our original arguments and base64 encode them, using whatever method you prefer. There are plenty of online tool, Terminal commands, and open source applications like Boop.
We'll copy this:
{
  "answer_pk": "ed25519:7PkKPmVUXcupA5oU8d6TbgyMwzFe8tPV6eV1KGwgo9xg",
  "dimensions": {
   "x": 11,
   "y": 10
  },
  "answers": [
   {
     "num": 1,
     "start": {
       "x": 0,
       "y": 1
     },
     "direction": "Across",
     "length": 12,
     "clue": "NEAR transactions are more ______ instead of atomic."
   },
   {
     "num": 2,
     "start": {
       "x": 6,
       "y": 0
     },
     "direction": "Down",
     "length": 7,
     "clue": "In a smart contract, when performing an Action, you use this in Rust."
   },
   {
     "num": 3,
     "start": {
       "x": 9,
       "y": 0
     },
     "direction": "Down",
     "length": 6,
     "clue": "In docs.rs when you search for the near-sdk crate, these items a considered a what: collections, env, json_types."
   },
   {
     "num": 4,
     "start": {
       "x": 1,
       "y": 1
     },
     "direction": "Down",
     "length": 10,
     "clue": "A series of words that can deterministically generate a private key."
   },
   {
     "num": 5,
     "start": {
       "x": 1,
       "y": 3
     },
     "direction": "Across",
     "length": 3,
     "clue": "When doing high-level cross-contract calls, we import this that ends in _contract. When calling ourselves in a callback, it is convention to call it THIS_self."
   },
   {
     "num": 6,
     "start": {
       "x": 0,
       "y": 8
     },
     "direction": "Across",
     "length": 8,
     "clue": "Use this to determine the execution outcome of a cross-contract call or Action."
   },
   {
     "num": 7,
     "start": {
       "x": 4,
       "y": 6
     },
     "direction": "Across",
     "length": 4,
     "clue": "You chain this syntax onto a promise in order to schedule a callback afterward."
   }
  ]
}
and base64 encode it:

    


Now we can build and run the new crossword puzzle contract as we have before:
cargo near build

  

  ```bash
  export NEAR_ACCT=crossword.friend.testnet
  export PARENT_ACCT=friend.testnet

  near delete-account $NEAR_ACCT $PARENT_ACCT --networkId testnet

  # Create an account again
  near create-account $NEAR_ACCT --use-account $PARENT_ACCT --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  export NEAR_ACCT=crossword.friend.testnet
  export PARENT_ACCT=friend.testnet

  near account delete-account $NEAR_ACCT beneficiary $PARENT_ACCT network-config testnet sign-with-keychain send

  near account create-account fund-myself $NEAR_ACCT '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as $PARENT_ACCT network-config testnet sign-with-keychain send
  ```
  

cargo near deploy $NEAR_ACCT with-init-call new json-args '{"owner_id": "'$NEAR_ACCT'", "creator_account": "testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send

  

  ```bash
  near call $NEAR_ACCT new_puzzle '{{
    "args": "ewogICJhbnN3ZXJfcGsiOiAiZWQyNTUxOTo3UGtLUG1WVVhjdXBBNW9VOGQ2VGJneU13ekZlOHRQVjZlVjFLR3dnbzl4ZyIsCiAgImRpbWVuc2lvbnMiOiB7CiAgICJ4IjogMTEsCiAgICJ5IjogMTAKICB9LAogICJhbnN3ZXJzIjogWwogICB7CiAgICAgIm51bSI6IDEsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiAwLAogICAgICAgInkiOiAxCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkFjcm9zcyIsCiAgICAgImxlbmd0aCI6IDEyLAogICAgICJjbHVlIjogIk5FQVIgdHJhbnNhY3Rpb25zIGFyZSBtb3JlIF9fX19fXyBpbnN0ZWFkIG9mIGF0b21pYy4iCiAgIH0sCiAgIHsKICAgICAibnVtIjogMiwKICAgICAic3RhcnQiOiB7CiAgICAgICAieCI6IDYsCiAgICAgICAieSI6IDAKICAgICB9LAogICAgICJkaXJlY3Rpb24iOiAiRG93biIsCiAgICAgImxlbmd0aCI6IDcsCiAgICAgImNsdWUiOiAiSW4gYSBzbWFydCBjb250cmFjdCwgd2hlbiBwZXJmb3JtaW5nIGFuIEFjdGlvbiwgeW91IHVzZSB0aGlzIGluIFJ1c3QuIgogICB9LAogICB7CiAgICAgIm51bSI6IDMsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiA5LAogICAgICAgInkiOiAwCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkRvd24iLAogICAgICJsZW5ndGgiOiA2LAogICAgICJjbHVlIjogIkluIGRvY3MucnMgd2hlbiB5b3Ugc2VhcmNoIGZvciB0aGUgbmVhci1zZGsgY3JhdGUsIHRoZXNlIGl0ZW1zIGEgY29uc2lkZXJlZCBhIHdoYXQ6IGNvbGxlY3Rpb25zLCBlbnYsIGpzb25fdHlwZXMuIgogICB9LAogICB7CiAgICAgIm51bSI6IDQsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiAxLAogICAgICAgInkiOiAxCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkRvd24iLAogICAgICJsZW5ndGgiOiAxMCwKICAgICAiY2x1ZSI6ICJBIHNlcmllcyBvZiB3b3JkcyB0aGF0IGNhbiBkZXRlcm1pbmlzdGljYWxseSBnZW5lcmF0ZSBhIHByaXZhdGUga2V5LiIKICAgfSwKICAgewogICAgICJudW0iOiA1LAogICAgICJzdGFydCI6IHsKICAgICAgICJ4IjogMSwKICAgICAgICJ5IjogMwogICAgIH0sCiAgICAgImRpcmVjdGlvbiI6ICJBY3Jvc3MiLAogICAgICJsZW5ndGgiOiAzLAogICAgICJjbHVlIjogIldoZW4gZG9pbmcgaGlnaC1sZXZlbCBjcm9zcy1jb250cmFjdCBjYWxscywgd2UgaW1wb3J0IHRoaXMgdGhhdCBlbmRzIGluIF9jb250cmFjdC4gV2hlbiBjYWxsaW5nIG91cnNlbHZlcyBpbiBhIGNhbGxiYWNrLCBpdCBpcyBjb252ZW50aW9uIHRvIGNhbGwgaXQgVEhJU19zZWxmLiIKICAgfSwKICAgewogICAgICJudW0iOiA2LAogICAgICJzdGFydCI6IHsKICAgICAgICJ4IjogMCwKICAgICAgICJ5IjogOAogICAgIH0sCiAgICAgImRpcmVjdGlvbiI6ICJBY3Jvc3MiLAogICAgICJsZW5ndGgiOiA4LAogICAgICJjbHVlIjogIlVzZSB0aGlzIHRvIGRldGVybWluZSB0aGUgZXhlY3V0aW9uIG91dGNvbWUgb2YgYSBjcm9zcy1jb250cmFjdCBjYWxsIG9yIEFjdGlvbi4iCiAgIH0sCiAgIHsKICAgICAibnVtIjogNywKICAgICAic3RhcnQiOiB7CiAgICAgICAieCI6IDQsCiAgICAgICAieSI6IDYKICAgICB9LAogICAgICJkaXJlY3Rpb24iOiAiQWNyb3NzIiwKICAgICAibGVuZ3RoIjogNCwKICAgICAiY2x1ZSI6ICJZb3UgY2hhaW4gdGhpcyBzeW50YXggb250byBhIHByb21pc2UgaW4gb3JkZXIgdG8gc2NoZWR1bGUgYSBjYWxsYmFjayBhZnRlcndhcmQuIgogICB9CiAgXQp9"
  }}' --gas 100000000000000 --accountId $NEAR_ACCT --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction $NEAR_ACCT new_puzzle json-args '{
    "args": "ewogICJhbnN3ZXJfcGsiOiAiZWQyNTUxOTo3UGtLUG1WVVhjdXBBNW9VOGQ2VGJneU13ekZlOHRQVjZlVjFLR3dnbzl4ZyIsCiAgImRpbWVuc2lvbnMiOiB7CiAgICJ4IjogMTEsCiAgICJ5IjogMTAKICB9LAogICJhbnN3ZXJzIjogWwogICB7CiAgICAgIm51bSI6IDEsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiAwLAogICAgICAgInkiOiAxCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkFjcm9zcyIsCiAgICAgImxlbmd0aCI6IDEyLAogICAgICJjbHVlIjogIk5FQVIgdHJhbnNhY3Rpb25zIGFyZSBtb3JlIF9fX19fXyBpbnN0ZWFkIG9mIGF0b21pYy4iCiAgIH0sCiAgIHsKICAgICAibnVtIjogMiwKICAgICAic3RhcnQiOiB7CiAgICAgICAieCI6IDYsCiAgICAgICAieSI6IDAKICAgICB9LAogICAgICJkaXJlY3Rpb24iOiAiRG93biIsCiAgICAgImxlbmd0aCI6IDcsCiAgICAgImNsdWUiOiAiSW4gYSBzbWFydCBjb250cmFjdCwgd2hlbiBwZXJmb3JtaW5nIGFuIEFjdGlvbiwgeW91IHVzZSB0aGlzIGluIFJ1c3QuIgogICB9LAogICB7CiAgICAgIm51bSI6IDMsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiA5LAogICAgICAgInkiOiAwCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkRvd24iLAogICAgICJsZW5ndGgiOiA2LAogICAgICJjbHVlIjogIkluIGRvY3MucnMgd2hlbiB5b3Ugc2VhcmNoIGZvciB0aGUgbmVhci1zZGsgY3JhdGUsIHRoZXNlIGl0ZW1zIGEgY29uc2lkZXJlZCBhIHdoYXQ6IGNvbGxlY3Rpb25zLCBlbnYsIGpzb25fdHlwZXMuIgogICB9LAogICB7CiAgICAgIm51bSI6IDQsCiAgICAgInN0YXJ0IjogewogICAgICAgIngiOiAxLAogICAgICAgInkiOiAxCiAgICAgfSwKICAgICAiZGlyZWN0aW9uIjogIkRvd24iLAogICAgICJsZW5ndGgiOiAxMCwKICAgICAiY2x1ZSI6ICJBIHNlcmllcyBvZiB3b3JkcyB0aGF0IGNhbiBkZXRlcm1pbmlzdGljYWxseSBnZW5lcmF0ZSBhIHByaXZhdGUga2V5LiIKICAgfSwKICAgewogICAgICJudW0iOiA1LAogICAgICJzdGFydCI6IHsKICAgICAgICJ4IjogMSwKICAgICAgICJ5IjogMwogICAgIH0sCiAgICAgImRpcmVjdGlvbiI6ICJBY3Jvc3MiLAogICAgICJsZW5ndGgiOiAzLAogICAgICJjbHVlIjogIldoZW4gZG9pbmcgaGlnaC1sZXZlbCBjcm9zcy1jb250cmFjdCBjYWxscywgd2UgaW1wb3J0IHRoaXMgdGhhdCBlbmRzIGluIF9jb250cmFjdC4gV2hlbiBjYWxsaW5nIG91cnNlbHZlcyBpbiBhIGNhbGxiYWNrLCBpdCBpcyBjb252ZW50aW9uIHRvIGNhbGwgaXQgVEhJU19zZWxmLiIKICAgfSwKICAgewogICAgICJudW0iOiA2LAogICAgICJzdGFydCI6IHsKICAgICAgICJ4IjogMCwKICAgICAgICJ5IjogOAogICAgIH0sCiAgICAgImRpcmVjdGlvbiI6ICJBY3Jvc3MiLAogICAgICJsZW5ndGgiOiA4LAogICAgICJjbHVlIjogIlVzZSB0aGlzIHRvIGRldGVybWluZSB0aGUgZXhlY3V0aW9uIG91dGNvbWUgb2YgYSBjcm9zcy1jb250cmFjdCBjYWxsIG9yIEFjdGlvbi4iCiAgIH0sCiAgIHsKICAgICAibnVtIjogNywKICAgICAic3RhcnQiOiB7CiAgICAgICAieCI6IDQsCiAgICAgICAieSI6IDYKICAgICB9LAogICAgICJkaXJlY3Rpb24iOiAiQWNyb3NzIiwKICAgICAibGVuZ3RoIjogNCwKICAgICAiY2x1ZSI6ICJZb3UgY2hhaW4gdGhpcyBzeW50YXggb250byBhIHByb21pc2UgaW4gb3JkZXIgdG8gc2NoZWR1bGUgYSBjYWxsYmFjayBhZnRlcndhcmQuIgogICB9CiAgXQp9"
  }' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as $NEAR_ACCT network-config testnet sign-with-keychain send
  ```
  

Back at the project root (not in the contract directory) we can run our app and see the new crossword puzzle:
CONTRACT_NAME=crossword.friend.testnet npm run start
Wrapping up
Once you understand cross-contract calls and callbacks and where the logic should go, you can build just about anything on NEAR.
This might be a good time for a reminder that this crossword puzzle, which checks permissions to methods based on a public key, is a bit unusual. It's more common to have simple collections or mappings for allowed users, or utilize the owner_id field we set up. The account and access key system in NEAR is quite powerful, and hopefully this tutorial helps stretch the limits of what's possible, like the seamless onboarding we have with the crossword puzzle.
Again, the final code for this chapter:
https://github.com/near-examples/crossword-tutorial-chapter-3
Happy hacking!

### Adding cross-contract calls, access key shuffling, etc.

Updating the contract
To reiterate, we'd like anyone to be able to participate in the crossword puzzle, even folks who don't have a NEAR account.
The first person to win will "reserve their spot" and choose where to send the prize money: either an account they own or an account they'd like to create.
Reserving their spot
The plan
When a user first visits the crossword, they only see the crossword. No login button and no fields (like a memo field) to fill out.
On their first visit, our frontend will create a brand new, random seed phrase in their browser. We'll use this seed phrase to create the user's unique key pair. If a random seed phrase is already there, it skips this part. (We covered the code for this in a previous section.)
If the user is the first to solve the puzzle, it discovers the function-call access key and calls submit_solution with that key. It's basically using someone else's key, as this key is on the crossword account.
We'll be adding a new parameter to the submit_solution so the user can include the random, public key we just stored in their browser.
During the execution of submit_solution, because contracts can use Promises to perform Actions, we'll remove the solution public key and add the user's public key.
This will lock out other attempts to solve the crossword puzzle and ensure there is only one winner.

This means that a puzzle can have three states it can be in:

Unsolved
Solved and not yet claimed (not paid out)
Claimed and finalized

The previous chapter we discussed enums, so this is simply modifying the enumeration variants.
The implementation
First, let's see how the submit_solution will verify the correct solution.

Instead of hashing the plaintext, we simply check that the public key matches what we know the answer is. (The answer being the series of words representing the solution to the crossword puzzle, used as a seed phrase to create a key pair, including a public key.)
Further down in the submit_solution method we'll follow our plan by adding a function-call access key (that only the winner has) and removing the access key that was discovered by the winner, so no one else can use it.

    
    Our smart contract is like this carpenter adding a key to itself.Art by carlcarlkarl.near



The first promise above adds an access key, and the second deletes the access key on the account that was derived from the solution as a seed phrase.

    
    We delete the function-call access key so there is only one winner.Art by eerie_ram.near


Note that the new function-call access key is able to call two methods we'll be adding:

claim_reward — when the user has an existing account and wishes to send the prize to it
claim_reward_new_account — when the user doesn't have an account, wants to create one and send the prize to it

Both functions will do cross-contract calls and use callbacks to see the result. We finally get to the meat of this chapter, let's go!
Cross-contract calls
The traits
We're going to be making a cross-contract call to the linkdrop account deployed to the testnet account. We're also going to have callbacks for that, and for a simple transfer to a (potentially existing) account. We'll create the traits that define both those methods.

tipt's not necessary to create the trait for the callback as we could have just implemented the functions `callback_after_transfer` and `callback_after_create_account` in our `Crossword` struct implementation. We chose to define the trait and implement it to make the code a bit more readable.

claim_reward
Again, this function is called when the user solves the crossword puzzle and wishes to send the prize money to an existing account.
Seems straightforward, so why would we need a callback? We didn't use a callback in the previous chapter when the user logged in, so what gives?
It's possible that while claiming the prize, the user accidentally fat-fingers their username, or their cat jumps on their keyboard. Instead of typing mike.testnet they type mike.testnzzz and hit send. In short, if we try to send the prize to a non-existent account, we want to catch that.
For brevity, we'll skip some code in this function to focus on the Promise and callback:
pub fn claim_reward(
    &mut self,
    crossword_pk: PublicKey,
    receiver_acc_    memo: String,
    ) -> Promise {
        let signer_pk = env::signer_account_pk();
        ...
        Promise::new(receiver_acc_id.parse().unwrap())
            .transfer(reward_amount)
            .then(
                Self::ext(env::current_account_id())
                    .with_static_gas(GAS_FOR_ACCOUNT_CALLBACK)
                    .callback_after_transfer(
                        crossword_pk,
                        receiver_acc_id,
                        memo,
                        env::signer_account_pk(),
                    ),
            )
    }
tipour IDE is your friend

Oftentimes, the IDE can help you.

For instance, in the above snippet we have `receiver_acc_id.parse().unwrap()` which might look confusing. You can lean on code examples or documentation to see how this is done, or you can utilize the suggestions from your IDE.


This claim_reward method will attempt to use the Transfer Action to send NEAR to the account specified. It might fail on a protocol level (as opposed to a smart contract failure), which would indicate the account doesn't exist.
Let's see how we check this in the callback:

infoThe `#[private]` macro
Notice that above the function, we have declared it to be private.

This is an ergonomic helper that checks to make sure the predecessor is the current account ID.

We actually saw this done "the long way" in the callback for the linkdrop contract in [the previous section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/crosswords/03-intermediate/03-linkdrop.md#the-callback).

Every callback will want to have this `#[private]` macro above it.

The snippet above essentially says it expects there to be a Promise result for exactly one Promise, and then sees if that was successful or not. Note that we're not actually getting a value in this callback, just if it succeeded or failed.
If it succeeded, we proceed to finalize the puzzle, like setting its status to be claimed and finished, removing it from the unsolved_puzzles collection, etc.
claim_reward_new_account
Now we want to handle a more interesting case. We're going to do a cross-contract call to the smart contract located on testnet and ask it to create an account for us. This name might be unavailable, and this time we get to write a callback that gets a value.
Again, for brevity, we'll show the meat of the claim_reward_new_account method:
pub fn claim_reward_new_account(
    &mut self,
    crossword_pk: PublicKey,
    new_acc_    new_pk: PublicKey,
    memo: String,
) -> Promise {
    ...
    ext_linkdrop::ext(AccountId::from(self.creator_account.clone()))
        .with_attached_deposit(reward_amount)
        .with_static_gas(GAS_FOR_ACCOUNT_CREATION) // This amount of gas will be split
        .create_account(new_acc_id.parse().unwrap(), new_pk)
        .then(
            // Chain a promise callback to ourselves
            Self::ext(env::current_account_id())
                .with_static_gas(GAS_FOR_ACCOUNT_CALLBACK)
                .callback_after_create_account(
                    crossword_pk,
                    new_acc_id,
                    memo,
                    env::signer_account_pk(),
                ),
        )
}
Then the callback:

In the above snippet, there's one difference from the callback we saw in claim_reward: we capture the value returned from the smart contract we just called. Since the linkdrop contract returns a bool, we can expect that type. (See the comments with "NOTE:" above, highlighting this.)
Callbacks
The way that the callback works is that you start with the Self::ext() and pass in the current acount ID using env::current_account_id(). This is essentially saying that you want to call a function that lives on the current account ID.
You then have a couple of config options that each start with .with_*:

You can attach a deposit of Ⓝ, in yoctoⓃ to the call by specifying the .with_attached_deposit() method but it is defaulted to 0 (1 Ⓝ = 1000000000000000000000000 yoctoⓃ, or 1^24 yoctoⓃ).
You can attach a static amount of GAS by specifying the .with_static_gas() method but it is defaulted to 0.
You can attach an unused GAS weight by specifying the .with_unused_gas_weight() method but it is defaulted to 1. The unused GAS will be split amongst all the functions in the current execution depending on their weights. If there is only 1 function, any weight above 1 will result in all the unused GAS being attached to that function. If you specify a weight of 0, however, the unused GAS will not be attached to that function. If you have two functions, one with a weight of 3, and one with a weight of 1, the first function will get 3/4 of the unused GAS and the other function will get 1/4 of the unused GAS.

After you've added the desired configurations to the call, you execute the function and pass in the parameters. In this case, we call the function callback_after_create_account and pass in the crossword public key, the new account ID, the memo, and the signer's public key.
This function will be called with static GAS equal to GAS_FOR_ACCOUNT_CALLBACK and will have no deposit attached. In addition, since the with_unused_gas_weight() method wasn't called, it will default to a weight of 1 meaning that it will split all the unused GAS with the create_account function to be added on top of the GAS_FOR_ACCOUNT_CALLBACK.
.then(
    // Chain a promise callback to ourselves
    Self::ext(env::current_account_id())
        .with_static_gas(GAS_FOR_ACCOUNT_CALLBACK)
        .callback_after_create_account(
            crossword_pk,
            new_acc_id,
            memo,
            env::signer_account_pk(),
        ),
)
tiponsider changing contract state in callback
It's not always the case, but often you'll want to change the contract state in the callback.

The callback is a safe place where we have knowledge of what's happened after cross-contract calls or Actions. If your smart contract is changing state *before* doing a cross-contract call, make sure there's a good reason for it. It might be best to move this logic into the callback.

So what parameters should I pass into a callback?
There's no one-size-fits-all solution, but perhaps there's some advice that can be helpful.
Try to pass parameters that would be unwise to trust coming from another source. For instance, if an account calls a method to transfer some digital asset, and you need to do a cross-contract call, don't rely on the results of contract call to determine ownership. If the original function call determines the owner of a digital asset, pass this to the callback.
Passing parameters to callbacks is also a handy way to save fetching data from persistent collections twice: once in the initial method and again in the callback. Instead, just pass them along and save some CPU cycles.
Checking the public key
The last simple change in this section is to modify the way we verify if a user has found the crossword solution.
In previous chapters we hashed the plaintext solution and compared it to the known solution's hash.
Here we're able to simply check the signer's public key, which is available in the env object under signer_account_pk.
We'll do this check in both when the solution is submitted, and when the prize is claimed.
When the crossword is solved
// The solver_pk parameter is the public key generated and stored in their browser
pub fn submit_solution(&mut self, solver_pk: PublicKey) {
    let answer_pk = env::signer_account_pk();
    // check to see if the answer_pk from signer is in the puzzles
    let mut puzzle = self
        .puzzles
        .get(&answer_pk)
        .expect("ERR_NOT_CORRECT_ANSWER");
When prize is claimed
pub fn claim_reward(
    &mut self,
    crossword_pk: PublicKey,
    receiver_acc_    memo: String,
) -> Promise {
    let signer_pk = env::signer_account_pk();
    ...
    // Check that puzzle is solved and the signer has the right public key
    match puzzle.status {
        PuzzleStatus::Solved {
            solver_pk: puzzle_pk,
        } => {
            // Check to see if signer_pk matches
            assert_eq!(signer_pk, puzzle_pk, "You're not the person who can claim this, or else you need to use your function-call access key, friend.");
        }
        _ => {
            env::panic_str("puzzle should have `Solved` status to be claimed");
        }
    };
    ...
}

### Introducing the linkdrop contract we can use

The linkdrop contract
We're going to take a small detour to talk about the linkdrop smart contract.  It's best that we first understand this contract and its purpose, then discuss calling a method on this contract.
The linkdrop contract is deployed to the accounts testnet and near, which are known as the top-level accounts of the testnet and mainnet network, respectively. (Anyone can create a linkdrop-style contract elsewhere, but the one shown here is the main one that others are patterned off of.)
Testnet
There’s nothing special about testnet accounts; there is no real-world cost to you as a developer when creating testnet accounts, so feel free to create or delete at your convenience.
When a user signs up for a testnet account on NEAR Wallet, they'll see this:

Let's discuss how this testnet account gets created.
Notice the new account will end in .testnet. This is because the account testnet will create a subaccount (like we learned about earlier in this tutorial) called vacant-name.testnet.
There are two ways to create this subaccount:

Use a full-access key for the account testnet to sign a transaction with the CreateAccount Action.
In a smart contract deployed to the testnet account, call the CreateAccount Action, which is an async method that returns a Promise. (More info about writing a CreateAccount Promise)

(In the example below that uses NEAR CLI to create a new account, it's calling CreateAccount on the linkdrop contract that is deployed to the top level "near" account on mainnet.)
Mainnet
On mainnet, the account near also has the linkdrop contract deployed to it.
Using NEAR CLI, a person can create a mainnet account by calling the linkdrop contract, like shown below:

  

  ```bash
  near call near create_account '{"new_account_id": "aloha.near", "new_public_key": "3cQ...tAT"}' --gas 300000000000000 --deposit 15 --accountId mike.near --networkId mainnet
  ```
  

  

    ```bash
    near contract call-function as-transaction near create_account json-args '{"new_account_id": "aloha.near", "new_public_key": "3cQ...tAT"}' prepaid-gas '300.0 Tgas' attached-deposit '15 NEAR' sign-as mike.near network-config mainnet sign-with-keychain
    ```
  

The above command calls the create_account method on the account near, and would create aloha.near if it's available, funding it with 15 Ⓝ.
We'll want to write a smart contract that calls that same method. However, things get interesting because it's possible aloha.near is already taken, so we'll need to learn how to handle that.
A simple callback
The create_account method
Here, we'll show the implementation of the create_account method. Note the #[payable] macro, which allows this function to accept an attached deposit. (Remember in the CLI command we were attaching 15 Ⓝ.)

The most important part of the snippet above is around the middle where there's:
Promise::new(...)
    ...
    .then(
        Self::ext(env::current_account_id())
            .on_account_created(...)
    )

This translates to, "we're going to attempt to perform an Action, and when we're done, please call myself at the method on_account_created so we can see how that went."
::caution This doesn't work

Not infrequently, developers will attempt to do this in a smart contract:
let creation_result = Promise::new("aloha.mike.near")
  .create_account();

// Check creation_result variable (can't do it!)
if creation_result {...}


In other programming languages promises might work like this, but we must use callbacks instead.
::

The callback
Now let's look at the callback:

This calls the private helper method is_promise_success, which basically checks to see that there was only one promise result, because we only attempted one Promise:

Note that the callback returns a boolean. This means when we modify our crossword puzzle to call the linkdrop contract on testnet, we'll be able to determine if the account creation succeeded or failed.
And that's it! Now we've seen a method and a callback in action for a simple contract.
tiphis is important
Understanding cross-contract calls and callbacks is quite important in smart contract development.

Since NEAR's transactions are asynchronous, the use of callbacks may be a new paradigm shift for smart contract developers from other ecosystems.

Feel free to dig into the linkdrop contract and play with the ideas presented in this section.

There are two additional examples that are helpful to look at:
1. [High-level cross-contract calls](https://github.com/near/near-sdk-rs/blob/master/examples/cross-contract-calls/high-level/src/lib.rs) — this is similar what we've seen in the linkdrop contract.
2. [Low-level cross-contract calls](https://github.com/near/near-sdk-rs/blob/master/examples/cross-contract-calls/low-level/src/lib.rs) — a different approach where you don't use the traits we mentioned.


Next we'll modify the crossword puzzle contract to check for the signer's public key, which is how we now determine if they solved the puzzle correctly.

### Implementing the seed phrase logic from the necessary libraries

Seed phrase and key derivation
There are two separate things we'll want to do:

Create a random seed phrase for the user when they visit the crossword puzzle. This will be used if they win and don't have a NEAR account and wish to create one. They can then paste this seed phrase into NEAR Wallet afterward to import their account (which is basically like "logging in" and is currently possible at https://testnet.mynearwallet.com/recover-seed-phrase).
Turn the crossword solution into a key pair, instead of just hashing it.

near-seed-phrase library
We can add the near-seed-phrase package to our project with:
npm install near-seed-phrase --save
noteCode snippets for this chapter
At this point in the tutorial, it's more difficult to share code snippets that are both meaningful and meant to be copy/pasted into a project.

The snippets provided might differ slightly from the implementation of the [completed code for chapter 3](https://github.com/near-examples/crossword-tutorial-chapter-3), which might be the best place to look for the functioning code.

Generate random seed phrase for new account creation (if the winner doesn't already have an account)

// Create a random key in here
let seedPhrase = generateSeedPhrase(); // generateSeedPhrase() returns an object {seedPhrase, publicKey, secretKey}
localStorage.setItem('playerKeyPair', JSON.stringify(seedPhrase));
Parse solution as seed phrase
(This security measure prevents front-running.)

// Get the seed phrase from the completed puzzle.
// The original puzzle creator would have already called this same function with the same inputs and would have
// already called `AddKey` on this contract to add the key related to this seed phrase. Here, using this deterministic
// function, the front-end will automatically generate that same key based on the inputs from the winner.
const seedPhrase = parseSolutionSeedPhrase(data, gridData); // returns a string of space-separated words
// Get the public and private key derived from the seed phrase
const {secretKey, publicKey} = parseSeedPhrase(seedPhrase);

// Set up the account and connection, acting on behalf of the crossword account
const keyStore = new nearAPI.keyStores.InMemoryKeyStore(); // Another type of key
const keyPair = nearAPI.utils.key_pair.KeyPair.fromString(secretKey);
await keyStore.setKey(nearConfig.networkId, nearConfig.contractName, keyPair);
nearConfig.keyStore = keyStore;
const near = await nearAPI.connect(nearConfig);
const crosswordAccount = await near.account(nearConfig.contractName);

// Call the submit_solution method using the discovered function-call access key
let transaction = await crosswordAccount.functionCall(…);
The last line should look familiar. We did something similar in the last chapter, except we used the WalletConnection's account to do the function call.
This time we're using an InMemoryKeyStore instead of the browser, as you can see toward the middle of the snippet.
Key stores
We have now used almost all the key stores available in near-api-js:

UnencryptedFileSystemKeyStore — early on, when we used the NEAR CLI command near login, this created a file in our operating system's home directory containing a private, full-access key to our account.
BrowserLocalStorageKeyStore — in the last chapter, when the user first logs in, the function-call access key is saved in the browser's local storage.
InMemoryKeyStore — for this chapter, we'll simply use the computer's memory to store the private key derived from the crossword solution.

tipou can have multiple key stores
Technically, there's another type of key store called the `MergeKeyStore`.

Say you want to look for private keys in various directories. You can essentially have a list of `UnencryptedFileSystemKeyStore` key stores that look in different places.

Use the `MergeKeyStore` when you might want to look for a private key in more than one place.

### Replacing the solution hash with an access key

Replacing our solution hash
So far in this tutorial, the user sends the plaintext solution to the crossword puzzle smart contract, where it's hashed and compared with the known answer.
This works, but we might want to be more careful and avoid sending the plaintext solution.
Why?
Blockchains rely on many computers processing transactions. When you send a transaction to the blockchain, it doesn't immediately get processed. In some Layer 1 blockchains it can take minutes or longer. On NEAR transactions settle within a couple seconds, but nonetheless there's a small period of waiting time.
When we previously sent the crossword puzzle solution in plain text (via the parameter solution to submit_solution) it means it's visible to everyone before it gets processed.
At the time of this writing, there haven't been outstanding incidents of validators "front-running" transactions, but it's something to be aware of. Front-running is when a validator sees a transaction that might be profitable and does it themselves.
There have been several incidents of this and it continues to be an issue.

    
    Real-life example of a puzzle being front-run.Read Anish Agnihotri's thread


How?
We're doing to do something unique — and frankly unusual — with our crossword puzzle. We're going to use function-call access keys in a new way.
Our crossword puzzle smart contract will add a function-call access key to itself. The private key is derived from the solution, used as a seed phrase.
infoWhat's a seed phrase, again?
A private key is essentially a very large number. So large that the number of possible private keys is approaching the estimated number of atoms in the known universe.

It would be pretty long if we wrote it down, so it's often made human-readable with numbers and letters. However, even the human-readable version is hard to memorize and prone to mistakes.

A seed phrase is a series of words (usually 12 or 24 words) that create a private key. (There's actually a [bit more to it](https://learnmeabitcoin.com/technical/mnemonic).)

Seed phrases typically use a [BIP-30 wordlist](https://github.com/bitcoin/bips/blob/master/bip-0039/bip-0039-wordlists.md), but *they do not need to* use a wordlist or have a certain number of words. As long as the words create entropy, a crossword puzzle solution can act as a deterministic seed phrase.

So when we add a new puzzle, we'll use the AddKey Action to add a limited, function-call access key can that only call the submit_solution method.
The first user to solve the puzzle will essentially "discover" the private key and call that method. Think of it like a safe that contains a function-call access key.

    
    Open the safe using answers to the puzzle, revealing the function-call access key.Art by soulless.near

### Intermediate concepts (cross-contract calls and more)

Intermediate concepts
This chapter will go a bit faster than the previous ones.
We're going to be covering an important part of smart contract development: cross-contract calls.
Cross-contract calls
A cross-contract call is when a smart contract calls another smart contract. For instance, if alice.near calls contract A, and contract A makes a call to contract B.
NEAR has asynchronous transactions, and some cross-contract calls will have callbacks in order to determine the result of the call. This works a bit different from other blockchains, as we'll explain more in this chapter.
Access keys
Last chapter covered access keys, and we implemented a login system where a user "logs in" by adding a function-call access key to their account which is tied to the crossword puzzle dApp.
Login is a common use case for access keys, but let's think bigger!
Remember the two (smaller, gray) function-call access keys from the keychain illustration?

    
    Art by alcantara_gabriel.near

### Implementing the login button

Add the login functionality
Plan
We're going to add a login button that uses near-api-js to login with NEAR.
Below is the workflow of logging in:


User clicks the login button
near-api-js creates a private key in the browser
A redirect to NEAR Wallet occurs, passing the public key. NEAR Wallet (often) has a full-access key capable of the AddKey action. The user follows a wizard, ultimately authorizing the creation of a new key.

Adding the button
In the src directory we'll look at:

index.js
App.js

We won't go over every change, but instead point to the new logic.
First we set up a WalletConnection object from our JavaScript library:

It's then used in React:
const signIn = () => {
  walletConnection.requestSignIn(
    nearConfig.contractName,
    '', // title. Optional, by the way
    '', // successUrl. Optional, by the way
    '', // failureUrl. Optional, by the way
  );
};

const signOut = () => {
  walletConnection.signOut();
  …
};

…

return (
  <div id="page">
    <h1>NEAR Crossword Puzzle</h1>
    <div id="crossword-wrapper">
      <div id="login">
        { currentUser
          ? <button onClick={signOut}>Log out</button>
          : <button onClick={signIn}>Log in</button>
        }
      </div>
      …
    </div>
  </div>
);
Once logged in, that WalletConnection object will be tied to the logged-in user, and they'll use that key to sign transactions and interact with the contract.
infoTransactions that redirect to NEAR Wallet
In our improved crossword puzzle, the function-call access key for the logged-in user will be signing a transaction to submit their solution.

You may notice, however, that sometimes you'll be redirected to NEAR Wallet, and other times you aren't.

This goes back to an earlier rule we mentioned: function-call access keys cannot send NEAR. They cannot perform the `Transfer` Action.

If a function call requires even 1 yoctoNEAR, NEAR Wallet (or any other wallet containing a full-access key) is required to sign the transaction.

Call the contract function from JavaScript
The frontend code contains a check to see if the user has completed the crossword puzzle successfully. In there we'll add logic to call the submit_solution function on the smart contract.
// Send the 5 NEAR prize to the logged-in winner
let functionCallResult = await walletConnection.account().functionCall({
  contractId: nearConfig.contractName,
  methodName: 'submit_solution',
  args: {solution: seedPhrase, memo: "Yay I won!"},
  gas: DEFAULT_FUNCTION_CALL_GAS, // optional param, by the way
  attachedDeposit: 0,
  walletMeta: '', // optional param, by the way
  walletCallbackUrl: '' // optional param, by the way
});

if (functionCallResult && functionCallResult.transaction && functionCallResult.transaction.hash) {
  // Display a link the NEAR Explorer
  console.log('Transaction hash for explorer', functionCallResult.transaction.hash)
}
tipry…catch blocks
It's not a bad idea to wrap these type of calls in try…catch blocks to properly handle any errors that come from the blockchain.

These errors can be quite helpful to the developer and the end user.

Fetch the puzzle, finish up
In the previous chapter, the frontend had a hardcoded file containing information about the clues for a simple crossword puzzle. In this chapter, we've given the coordinates and details about the clues, but the frontend needs to fetch this information.
We're going to modify the logic surrounding our view-only call to get_unsolved_puzzles on the contract. This method now returns the clue information, so we've implemented a function that puts it in the proper format for React to construct the crossword puzzle.
This is a tutorial about Rust smart contract development, so we won't focus on the details of this, but know we've added the function mungeBlockchainCrossword. This allows us to keep adding custom crossword puzzles and have the frontend be dynamic.
We'll also make other minor changes like adding a page for when there are no puzzles available, and adding a loading screen.
Run the React app
If you've been following this guide closely, you'll likely just need to start the React app with:
env CONTRACT_NAME=crossword.friend.testnet npm run start
As a helpful reminder, below has the steps necessary to recreate the subaccount, build the contract, deploy the subaccount, and call methods on the contract.
Go into the directory containing the Rust smart contract and build it:
cd contract

# Build
cargo near build
Create fresh account if you wish, which is good practice:

  

  ```bash
  # Delete an account
  near delete-account crossword.friend.testnet friend.testnet --networkId testnet

  # Create an account again
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  # Delete an account
  near account delete-account crossword.friend.testnet beneficiary friend.testnet network-config testnet sign-with-keychain send

  # Create an account again
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

Deploy the contract:
cargo near deploy crossword.friend.testnet with-init-call new json-args '{"owner_id": "crossword.friend.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
Add the crossword puzzle:

  

  ```bash
  near call crossword.friend.testnet new_puzzle '{"solution_hash":"d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010","answers":[{"num": 1,"start": {"x": 1,"y": 1},"direction": "Down","length": 5,"clue": "NFT market on NEAR that specializes in cards and comics."},{"num": 2,"start": {"x": 0,"y": 2},"direction": "Across","length": 13,"clue": "You can move assets between NEAR and different chains, including Ethereum, by visiting ______.app"},{"num": 3,"start": {"x": 9,"y": 1},"direction": "Down","length": 8,"clue": "NFT market on NEAR with art, physical items, tickets, and more."},{"num": 4,"start": {"x": 3,"y": 8},"direction": "Across","length": 9,"clue": "The smallest denomination of the native token on NEAR."},{"num": 5,"start": {"x": 5,"y": 8},"direction": "Down","length": 3,"clue": "You typically deploy a smart contract with the NEAR ___ tool."}]}' --gas 100000000000000 --accountId crossword.friend.testnet --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction crossword.friend.testnet new_puzzle json-args '{"solution_hash":"d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010","answers":[{"num": 1,"start": {"x": 1,"y": 1},"direction": "Down","length": 5,"clue": "NFT market on NEAR that specializes in cards and comics."},{"num": 2,"start": {"x": 0,"y": 2},"direction": "Across","length": 13,"clue": "You can move assets between NEAR and different chains, including Ethereum, by visiting ______.app"},{"num": 3,"start": {"x": 9,"y": 1},"direction": "Down","length": 8,"clue": "NFT market on NEAR with art, physical items, tickets, and more."},{"num": 4,"start": {"x": 3,"y": 8},"direction": "Across","length": 9,"clue": "The smallest denomination of the native token on NEAR."},{"num": 5,"start": {"x": 5,"y": 8},"direction": "Down","length": 3,"clue": "You typically deploy a smart contract with the NEAR ___ tool."}]}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as crossword.friend.testnet network-config testnet sign-with-keychain send
  ```
  

Return to the project root and start the React app:
cd ..
env CONTRACT_NAME=crossword.friend.testnet npm run start
For kicks
For fun, try interacting with the smart contract using the React frontend and the CLI. We can check the status of the puzzle using the CLI, solve the puzzle with the frontend, and check the status again.
Before and after solving the puzzle, run this command:

  

  ```bash
  near view crossword.friend.testnet get_puzzle_status '{"solution_hash": "d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010"}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only crossword.friend.testnet get_puzzle_status json-args '{"solution_hash": "d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010"}' network-config testnet now
  ```
  

This will return our enum PuzzleStatus. Before solving the puzzle it should print:
    'Unsolved'
and after:
    { Solved: { memo: 'Yay I won!' } }
After you solve the crossword puzzle you'll see a screen with a link to NEAR Explorer to look at the details of the transaction. Notice we have our Transfer Action in there:

    



That's it for this chapter! As a reminder the full code is available at:
https://github.com/near-examples/crossword-tutorial-chapter-2

### Covering access keys and login

Logging in with NEAR
Previously…
In the previous chapter we simply displayed whether the crossword puzzle was solved or not, by checking the solution hash against the user's answers.

Updates to transfer prize money
In this chapter, our smart contract will send 5 Ⓝ to the first person who solves the puzzle. For this, we're going to require the user to have a NEAR account and log in.
noteBetter onboarding to come
Later in this tutorial we won't require the user to have a NEAR account.

Since logging in is important for many decentralized apps, we'll show how this is done in NEAR and how it's incredibly unique compared to other blockchains.

This transfer will occur when the first user to solve the puzzle calls the submit_solution method with the solution. During the execution of that function it will check that the user submitted the correct answer, then transfer the prize.
We'll be able to see this transfer (and other steps that occurred) in NearBlocks Explorer.
But first let's talk about one of the most interesting superpowers of NEAR: access keys.
Access keys
You might be familiar with other blockchains where your account name is a long string of numbers and letters. NEAR has an account system where your name is human-readable, like friend.testnet for testnet or friend.near for mainnet.
You can add (and remove) keys to your account on NEAR. There are two types of keys: full and function-call access keys.
The illustration below shows a keychain with a full-access key (the large, gold one) and two function-call access keys.

    
    Art by alcantara_gabriel.near

Full-access keys
Full-access keys are the ones you want to protect the most. They can transfer all the funds from your account, delete the account, or perform any of the other Actions on NEAR.
When we used the near login command in the previous chapter, that command asked the full-access key in the NEAR Wallet to use the AddKey Action to create another full-access key: the one we created locally on our computer. NEAR CLI uses that new key to deploy, make function calls, etc.
Function-call access keys
Function-call access keys are sometimes called "limited access keys" because they aren't as powerful as the full access keys.
A Function-call access key will specify:

What contract it's allowed to call
What method name(s) it's allowed to call (you can also specify all functions)
How much allowance it's allowed to use on these function calls

It's only allowed to perform the FunctionCall Action.

Example account with keys
Let's look at this testnet account that has one full-access key and two function-call access keys. As you can see, we use the NEAR CLI to print this info.
near account list-keys friend.testnet network-config testnet now
+----+------------------------------------------------------+-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| #  | Public Key                                           | Nonce           | Permissions                                                                                                                                                                                        |
+----+------------------------------------------------------+-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 1  | ed25519:QqggnQNPRh5rqxL5PCPSS8qbZyrm6KHBbjne3U9TDGN  | 72772126000000  | do any function calls on puzzle.testnet with an allowance of 777 NEAR                                                                                                        |
| 2  | ed25519:FgsZoPqnSkuvoR6BZzXUY48tb5UfaCrRfg8kf4vyRg4F | 72777733000000  | only do ["foo", "bar"] function calls on puzzle.testnet with an allowance of 0.250 NEAR                                                                                  |
| 3  | ed25519:Hht8gURhPpDB2muhZhkEgxbdy4c2CPiQdUDMVuK7zDLd | 72770704000019  | full access                                                                                                                                                                                        |
+----+------------------------------------------------------+-----------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
Let's look deeper into each key.
First key
| 1  | ed25519:QqggnQNPRh5rqxL5PCPSS8qbZyrm6KHBbjne3U9TDGN  | 72772126000000  | do any function calls on puzzle.testnet with an allowance of 777 NEAR                                                                                                        |
The first key in the image above is a function-call access key that can call the smart contract puzzle.testnet on any method. If you don't specify which methods it's allowed to call, it is allowed to call them all. Note the empty array ([]) next to method_names, which indicates this.
We won't discuss the nonce too much, but know that in order to prevent the possibility of replay attacks, the nonce for a newly-created key is large and includes info on the block height as well as a random number.
The allowance is the amount, in yoctoNEAR, that this key is allowed to use during function calls. This cannot be used to transfer NEAR. It can only be used in gas for function calls.
The allowance on this key is intentionally large for demonstration purposes. 777000000000000000000000000 yoctoNEAR is 777 NEAR, which is unreasonably high for an access key. So high, in fact, that it exceeded the amount of NEAR on the contract itself when created. This shows that you can create an access key that exceeds the account balance, and that it doesn't subtract the allowance at the time of creation.
So the key is simply allowed to use the allowance in NEAR on gas, deducting from the account for each function call.
Second key
| 2  | ed25519:FgsZoPqnSkuvoR6BZzXUY48tb5UfaCrRfg8kf4vyRg4F | 72777733000000  | only do ["foo", "bar"] function calls on puzzle.testnet with an allowance of 0.250 NEAR                                                                                  |
This second key specifies which methods can be called, and has a lower allowance.
Note that the allowance for this key (a quarter of a NEAR) is the default allowance when a person "logs in" in with the NEAR Wallet.
In NEAR, "logging in" typically means adding a key like this to your account. We'll cover this more in a moment.
Third key
| 3  | ed25519:Hht8gURhPpDB2muhZhkEgxbdy4c2CPiQdUDMVuK7zDLd | 72770704000019  | full access                                                                                                                                                                                        |
The third key is a full-access key.
Since this key can perform all the Actions, there aren't additional details or restrictions like the function-call access keys we saw.
What does "log in" mean in a blockchain context?
Let's take a step back from NEAR and talk about how login works broadly using web3 wallets.
A web3 wallet (like Ethereum's MetaMask, Cosmos's Keplr, or the NEAR Wallet) stores a private key for an account. When interacting with decentralized apps, a user will typically use the wallet to sign transactions and send them to the blockchain for processing.
However, web3 wallets can also be used to sign any kind of message, and it doesn't need to send anything to the blockchain. This is sometimes called "offline signing" and protocols will sometimes create standards around how to sign data.
In other ecosystems, the idea of "logging in" with a web3 wallet uses this offline signing. A user is asked to sign a structured message and a backend can confirm that the message was signed by a given account.
NEAR keys can also sign and verify messages in this manner. In fact, there are a couple simple examples of how to achieve this in the near-api-js cookbook.
There are potential drawbacks to this offline signing technique, particularly if a signed message gets intercepted by a malicious party. They might be able to send this signature to a backend and log in on your behalf. Because this all takes place offline, there's no mechanism on-chain to revoke your login or otherwise control access. We quickly see that using a web3 wallet for signed typed data runs into limitations.
So signing a message is fine, but what if we could do better?
With NEAR, we can leverage access keys to improve a user's login experience and give the power back to the user.
If I log into the Guest Book example site, I create a unique key just for that dApp, adding it to my account. When I'm done I can remove the key myself. If I suspect someone has control of my key (if a laptop is stolen, for example) I can remove the key as long as I have a full-access key in my control.
Logging in with NEAR truly gives the end user control of their account and how they interact with dApps, and does so on the protocol level.

The concept of access keys is so important that we've spent longer than usual on the topic without actually implementing code for our improved crossword puzzle.
Let's move to the next section and actually add the login button.

### Adding a new puzzle now that we're using a collection that can contain multiple crossword puzzles

Adding a puzzle
We're going to make a new puzzle, which means we need to provide the smart contract with a set of clues and info about the answers.
Of course, we'll not be sending the answers to the smart contract, otherwise everyone could see. We will, however, send details about each clue, including:

The clue number
Whether it's a down or across clue
The coordinates (x and y position)
The length of the clue. (How many letters)

Essentially, we're going to tell the smart contract enough information for an empty puzzle like this:


(Note that we aren't showing the human-readable clues in the above screenshot, but we will provide that as well.)
Building and deploying
Let's use the same steps we learned from the first chapter:

    
    Art by herogranada.near


Navigate to the contract directory, then run:
cargo near build
If following from the previous chapter, you'll likely have a subaccount already created. For the purpose of demonstration, we're calling the subaccount (where we deploy the contract) crossword.friend.testnet and the parent account is thus friend.testnet.
Let's delete the subaccount and recreate it, to start from a blank slate.

    
    Art by 3one9.near


Here's how to delete and recreate the subaccount using NEAR CLI:

  

  ```bash
  # Delete the subaccount and send remaining balance to friend.testnet
  near delete-account crossword.friend.testnet friend.testnet --networkId testnet

  # Create the subaccount again
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  # Delete the subaccount and send remaining balance to friend.testnet
  near account delete-account crossword.friend.testnet beneficiary friend.testnet network-config testnet sign-with-keychain send

  # Create the subaccount again
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

Deploy, calling the "new" method with the parameter for owner_id:
cargo near deploy crossword.friend.testnet with-init-call new json-args '{"owner_id": "crossword.friend.testnet"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
Now we're ready to construct our new crossword puzzle and add it via the new_puzzle method. Let's start with the clues for this new puzzle.
The clues
We're going to use these clues below for our improved puzzle. The Answer column will not get sent to the smart contract when we call new_puzzle.



Number
Answer
Clue
(x, y) coords
length




1
paras
NFT market on NEAR that specializes in cards and comics.
(1, 1)
5


2
rainbowbridge
You can move assets between NEAR and different chains, including Ethereum, by visiting __.app
(0, 2)
13


3
mintbase
NFT market on NEAR with art, physical items, tickets, and more.
(9, 1)
8


4
yoctonear
The smallest denomination of the native token on NEAR.
(3, 8)
9


5
cli
You typically deploy a smart contract with the NEAR ___ tool.
(5, 8)
3



The x and y coordinates have their origin in the upper-left side of the puzzle grid, and each row and column start at 0.
Solution hash
Let's derive the sha256 hash using an easy online tool (there are many other offline methods as well) to discover the solution hash:
    d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010
Add the puzzle
Add a new puzzle using NEAR CLI with this long command, replacing crossword.friend.testnet with your subaccount:

  

  ```bash
  near call crossword.friend.testnet new_puzzle '{
      "solution_hash": "d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010",
      "answers": [
      {
        "num": 1,
        "start": {
          "x": 1,
          "y": 1
        },
        "direction": "Down",
        "length": 5,
        "clue": "NFT market on NEAR that specializes in cards and comics."
      },
      {
        "num": 2,
        "start": {
          "x": 0,
          "y": 2
        },
        "direction": "Across",
        "length": 13,
        "clue": "You can move assets between NEAR and different chains, including Ethereum, by visiting ______.app"
      },
      {
        "num": 3,
        "start": {
          "x": 9,
          "y": 1
        },
        "direction": "Down",
        "length": 8,
        "clue": "NFT market on NEAR with art, physical items, tickets, and more."
      },
      {
        "num": 4,
        "start": {
          "x": 3,
          "y": 8
        },
        "direction": "Across",
        "length": 9,
        "clue": "The smallest denomination of the native token on NEAR."
      },
      {
        "num": 5,
        "start": {
          "x": 5,
          "y": 8
        },
        "direction": "Down",
        "length": 3,
        "clue": "You typically deploy a smart contract with the NEAR ___ tool."
      }
      ]
    }' --gas 100000000000000 --accountId crossword.friend.testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction crossword.friend.testnet new_puzzle json-args '{
      "solution_hash": "d1a5cf9ad1adefe0528f7d31866cf901e665745ff172b96892693769ad284010",
      "answers": [
      {
        "num": 1,
        "start": {
          "x": 1,
          "y": 1
        },
        "direction": "Down",
        "length": 5,
        "clue": "NFT market on NEAR that specializes in cards and comics."
      },
      {
        "num": 2,
        "start": {
          "x": 0,
          "y": 2
        },
        "direction": "Across",
        "length": 13,
        "clue": "You can move assets between NEAR and different chains, including Ethereum, by visiting ______.app"
      },
      {
        "num": 3,
        "start": {
          "x": 9,
          "y": 1
        },
        "direction": "Down",
        "length": 8,
        "clue": "NFT market on NEAR with art, physical items, tickets, and more."
      },
      {
        "num": 4,
        "start": {
          "x": 3,
          "y": 8
        },
        "direction": "Across",
        "length": 9,
        "clue": "The smallest denomination of the native token on NEAR."
      },
      {
        "num": 5,
        "start": {
          "x": 5,
          "y": 8
        },
        "direction": "Down",
        "length": 3,
        "clue": "You typically deploy a smart contract with the NEAR ___ tool."
      }
      ]
    }' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as crossword.friend.testnet network-config testnet sign-with-keychain send
    ```
  

Note that our contract name and the account we're calling this from are both crossword.friend.testnet. That's because we added a check at the top of new_puzzle to make sure the predecessor is the owner_id.
Now our smart contract has information about this second crossword puzzle.
Let's explore how to make our frontend have a login button and truly turn this into a decentralized app (dApp)!

### There are several Actions an account can do, including sending the winner of the crossword puzzle NEAR using the Transfer Action

Actions (including sending NEAR)
We're going to introduce a new Action: Transfer. In this chapter, we'd like the first person to solve the crossword puzzle to earn some prize money, sent in NEAR.

    
    Art by qiqi04.near


We've already used Actions in the previous chapter, when we deployed and initialized the contract, which used the DeployContract and FunctionCall Action, respectively.
The full list of Actions are available at the NEAR specification site.
By the end of this entire tutorial we'll have used all the Actions highlighted below:

Actions from within a contract
When we deployed and initialized the contract, we used NEAR CLI in our Terminal or Command Prompt app. At a high level, this might feel like we're lobbing a transaction into the blockchain, instructing it to do a couple actions.
It's important to note that you can also execute Actions inside a smart contract, which is what we'll be doing. In the sidebar on the left, you'll see a section called Promises, which provides examples of this. Perhaps it's worth mentioning that for the Rust SDK, Promises and Actions are somewhat synonymous.
noteActions only effect the current contract
A contract cannot use the `AddKey` Action on another account, including the account that just called it. It can only add a key to *itself*, if that makes sense.

The same idea applies for the other actions as well. You cannot deploy a contract to someone else's account, or delete a different account. (Thankfully 😅)

Similarly, when we use the `Transfer` Action to send the crossword puzzle winner their prize, the amount is being subtracted from the account balance of the account where the crossword contract is deployed.

The only interesting wrinkle (and what may *seem like* an exception) is when a subaccount is created using the `CreateAccount` Action. During that transaction, you may use Batch Actions to do several things like deploy a contract, transfer NEAR, add a key, call a function, etc. This is common in smart contracts that use a factory pattern, and we'll get to this in future chapters of this tutorial.

Define the prize amount
Let's make it simple and hardcode the prize amount. This is how much NEAR will be given to the first person who solves the crossword puzzle, and will apply to all the crossword puzzles we add. We'll make this amount adjustable in future chapters.
At the top of the lib.rs file we'll add this constant:

As the code comment mentions, this is 5 NEAR, but look at all those zeroes in the code!
That's the value in yoctoNEAR. This concept is similar to other blockchains. Bitcoin's smallest unit is a satoshi and Ethereum's is a wei.

    
    Art by jrbemint.near

Adding Transfer
In the last chapter we had a simple function called guess_solution that returned true if the solution was correct, and false otherwise. We'll be replacing that function with submit_solution as shown below:

Note the last line in this function, which sends NEAR to the predecessor.
infoReturning a Promise
The last line of the function above ends with a semicolon. If the semicolon were removed, that would tell Rust that we'd like to return this Promise object.

It would be perfectly fine to write the function like this:

```rust
pub fn submit_solution(&mut self, solution: String, memo: String) -> Promise {
    // …
    // Transfer the prize money to the winner
    Promise::new(env::predecessor_account_id()).transfer(PRIZE_AMOUNT)
}
```

Predecessor, signer, and current account
When writing a smart contract you'll commonly want to use env and the details it provides. We used this in the last chapter for:

logging (ex: env::log_str("hello friend"))
hashing using sha256 (ex: env::sha256(solution.as_bytes()))

There are more functions detailed in the SDK reference docs.
Let's cover three commonly-used functions regarding accounts: predecessor, signer, and current account.

    
    Alice sends a transaction to the contract on banana.near, which does a cross-contract call to cucumber.near.From the perspective of a contract on cucumber.near, we see a list of the predecessor, signer, and current account.Art by yasuoarts.near

### How to think about structs and enums when writing a Rust smart contract on NEAR

Structs and enums
Overview
Structs
If you're not familiar with Rust, it may be confusing that there are no classes or inheritance like other programming languages. We'll be exploring how to use structs, which are someone similar to classes, but perhaps simpler.
Remember that there will be only one struct that gets the #[near] macro placed on it; our primary struct or singleton if you wish. Oftentimes the primary struct will contain additional structs that may, in turn, contain more structs in a neat and orderly way. You may also have structs that are used to return data to an end user, like a frontend. We'll be covering both of these cases in this chapter.
Enums
Enums are short for enumerations, and can be particularly useful if you have entities in your smart contract that transition to different states. For example, say you have a series of blockchain games where players can join, battle, and win. There might be an enumeration for  AcceptingPlayers, GameInProgress, and GameCompleted. Enums are also used to define discrete types of concept, like months in a year.
For our crossword puzzle, one example of an enum is the direction of the clue: either across (A) or down (D) as illustrated below. These are the only two options.

    
    Art by eizaconiendo.near


Rust has an interesting feature where enums can contain additional data. You can see examples of that here.
Using structs
Storing contract state
We're going to introduce several structs all at once. These structs are addressing a need from the previous chapter, where the puzzle itself was hardcoded and looked like this:

In this chapter, we want the ability to add multiple, custom crossword puzzles. This means we'll be storing information about the clues in the contract state. Think of a grid where there are x and y coordinates for where a clue starts. We'll also want to specify:

Clue number
Whether it's across or down
The length, or number of letters in the answer

Let's dive right in, starting with our primary struct:
#[near(contract_state)]
#[derive(PanicOnDefault)]
pub struct Crossword {
    puzzles: LookupMap<String, Puzzle>,  // ⟵ Puzzle is a struct we're defining
    unsolved_puzzles: UnorderedSet<String>,
}
noteLet's ignore a couple of things…
For now, let's ignore the macros about the structs that begin with `derive` and `near`.

Look at the fields inside the Crossword struct above, and you'll see a couple types. String is a part of Rust's standard library, but Puzzle is something we've created:
#[near(serializers = [borsh])]
#[derive(Debug)]
pub struct Puzzle {
    status: PuzzleStatus,  // ⟵ An enum we'll get to soon
    /// Use the CoordinatePair assuming the origin is (0, 0) in the top left side of the puzzle.
    answer: Vec<Answer>,  // ⟵ Another struct we've defined
}
Let's focus on the answer field here, which is a vector of Answers. (A vector is nothing fancy, just a bunch of items or a "growable array" as described in the standard Rust documentation.
#[near(serializers = [json, borsh])]
#[derive(Debug)]
pub struct Answer {
    num: u8,
    start: CoordinatePair,  // ⟵ Another struct we've defined
    direction: AnswerDirection,  // ⟵ An enum we'll get to soon
    length: u8,
    clue: String,
}
Now let's take a look at the last struct we'e defined, that has cascaded down from fields on our primary struct: the CoordinatePair.
#[near(serializers = [json, borsh])]
#[derive(Debug)]
pub struct CoordinatePair {
    x: u8,
    y: u8,
}
infoSummary of the structs shown
There are a handful of structs here, and this will be a typical pattern when we use structs to store contract state.

```
Crossword ⟵ primary struct with #[near(contract_state)]
└── Puzzle
   └── Answer
      └── CoordinatePair
```

Returning data
Since we're going to have multiple crossword puzzles that have their own, unique clues and positions in a grid, we'll want to return puzzle objects to a frontend.
tipuick note on return values
By default, return values are serialized in JSON unless explicitly directed to use Borsh for binary serialization.

For example, if we call this function:

```rust
pub fn return_some_words() -> Vec {
    vec!["crossword".to_string(), "puzzle".to_string()]
}
```

The return value would be a JSON array:

`["crossword", "puzzle"]`

While somewhat advanced, you can learn more about [changing the serialization here](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/serialization-interface.md).

We have a struct called JsonPuzzle that differs from the Puzzle struct we've shown. It has one difference: the addition of the solution_hash field.
#[near(serializers = [json])]
pub struct JsonPuzzle {
    /// The human-readable (not in bytes) hash of the solution
    solution_hash: String,  // ⟵ this field is not contained in the Puzzle struct
    status: PuzzleStatus,
    answer: Vec<Answer>,
}
This is handy because our primary struct has a key-value pair where the key is the solution hash (as a String) and the value is the Puzzle struct.
pub struct Crossword {
    puzzles: LookupMap<String, Puzzle>,
    //               key ↗        ↖ value
    …
Our JsonPuzzle struct returns the information from both the key and the value.
We can move on from this topic, but suffice it to say, sometimes it's helpful to have structs where the intended use is to return data in a more meaningful way than might exist from the structs used to store contract data.
Using returned objects in a callback
Don't be alarmed if this section feels confusing at this point, but know we'll cover Promises and callbacks later.
Without getting into detail, a contract may want to make a cross-contract call and "do something" with the return value. Sometimes this return value is an object we're expecting, so we can define a struct with the expected fields to capture the value. In other programming languages this may be referred to as "casting" or "marshaling" the value.
A real-world example of this might be the Storage Management standard, as used in a fungible token.
Let's say a smart contract wants to determine if alice.near is "registered" on the nDAI token. More technically, does alice.near have a key-value pair for herself in the fungible token contract.
#[near(serializers = [json])]
pub struct StorageBalance {
    pub total: U128,
    pub available: U128,
}

// …
// Logic that calls the nDAI token contract, asking for alice.near's storage balance.
// …

#[private]
pub fn my_callback(&mut self, #[callback] storage_balance: StorageBalance) {
    // …
}
The crossword puzzle will eventually use a cross-contract call and callback, so we can look forward to that. For now just know that if your contract expects to receive a return value that's not a primitive (unsigned integer, string, etc.) and is more complex, you may use a struct to give it the proper type.
Using enums
In the section above, we saw two fields in the structs that had an enum type:
1.AnswerDirection — this is the simplest type of enum, and will look familiar from other programming languages. It provides the only two options for how a clue in oriented in a crossword puzzle: across and down.
#[near(serializers = [json, borsh])]
#[derive(Debug)]
pub enum AnswerDirection {
    Across,
    Down,
}

PuzzleStatus — this enum can actually store a string inside the Solved structure. (Note that we could have simply stored a string instead of having a structure, but a structure might make this easier to read.)

As we improve our crossword puzzle, the idea is to give the winner of the crossword puzzle (the first person to solve it) the ability to write a memo. (For example: "Took me forever to get clue six!", "Alice rules!" or whatever.)
#[near(serializers = [json, borsh])]
#[derive(Debug)]
pub enum PuzzleStatus {
    Unsolved,
    Solved { memo: String },
}

### Store multiple crossword puzzles using a specialized collection in NEAR called a LookupMap

Using collections
As mentioned in the previous chapter, the online Rust Book is a great reference for folks getting started with Rust, but there are concepts that differ when we're dealing with the blockchain. One of these differences is the use of collections.
The reference-level documentation of the Rust SDK explains this concept well:
note Motivation for specialized collections
>Collections that offer an alternative to standard containers from [Rust's] std::collections::* by **utilizing the underlying blockchain trie storage more efficiently**.
>For example, the following smart contract does not work with state efficiently, because **it will load the entire HashMap at the beginning of the contract call**, and will save it entirely at the end, in cases when there is state modification. **This is fine for small number of elements, but very inefficient for large numbers**.

— [NEAR SDK reference documentation](https://docs.rs/near-sdk/latest/near_sdk/collections/index.html)

In chapter 1, we set the crossword puzzle solution hash when we first deployed the contract and called the initialization method new, passing it. This would only allow us to have only one puzzle, but let's allow for many.
At a high level, let's discuss what we'll want to add if our contract is to store multiple crossword puzzles. First, we'll have the concept of many puzzles where some of them will have different states (unfinished and finished) and we'll want to know which ones are unsolved in quick way. Another thing, which is a general rule of thumb when writing smart contracts, is to anticipate what might happen if it gets a lot of usage. What if we end up with 10,000 crossword puzzles? How might that affect how many data structures we use and which ones?
LookupMap and UnorderedSet
Let's try having two specialized NEAR collections:

A LookupMap which will store key-value pairs. (Solution hash » Puzzle object)
An UnorderedSet containing a set (list with no duplicates) of the solution hashes for puzzles which have not been solved yet.

As you look at the list of specialized collections in the Rust SDK, you might notice some begin with Lookup while others have Unordered. As is written in the reference documentation, the Lookup is non-iterable while the Unordered collections are iterable. This means if you will need to loop through the list of contents of this data structure, you'll likely use an iterable data structure. If you'll only ever be adding and retrieving data by the key, and the key will always be known, it's more efficient to use a non-iterable collection.
So why would we have two data structures here? Again, if we end up with a large number of puzzles, we might not be able to loop through all the puzzles, looking for ones that are unsolved. Because of the limit of gas execution per transaction, we must be conscious that there can be operations which will eventually exceed this limit. I suppose we could assume  that our UnorderedSet of unsolved puzzles wouldn't contain tens of thousands of puzzles. That's one way to avoid running into limits, but we could also learn how to utilize pagination through an iterable collection like an UnorderedSet which we'll get to later.

    
    Think of our collection as having multiple pages of puzzle hashes.Art by pierced_staggg.near


As we remember from the previous chapter, every smart contract has a primary struct containing the #[near(contract_state)] macro.
noteNaming the primary struct
Note in the [previous chapter](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/crosswords/01-basics/01-set-up-skeleton.md#start-writing-rust) we named our primary struct `Contract`, but in this chapter we'll call it `Crossword.`

The name of the struct doesn't matter and there's nothing special about naming it `Contract`, though you might see that convention used in several smart contracts on NEAR. We've named it something different simply to illustrate that there's no magic behind the scenes. This *does* mean, however, that our `impl` block will also be `Crossword`.

Here's how our struct will look with the iterable and non-iterable NEAR collections:

Above, we have the puzzles and unsolved_puzzles fields which are collections.
We also have an owner_id so we can exercise a common pattern in smart contract development: implementing a rudimentary permission system which can restrict access to certain functions. We'll expand on this thought in a moment.
The snippet below shows the first method in the implementation of the Crossword struct, where the new function sets up these two specialized collections.

So during the initialization function (new) we're setting the owner_id. For our purposes the owner will likely be the contract itself, but there can be several reasons to have it be a DAO or another user. Next, let's look at the b"c" and b"u" bits for the collection fields.
Collections have prefixes
Above, the new function is initializing the struct's fields by giving them a unique prefix. You can learn more about the prefixes here, but know that these prefixes (c and u) should be short and different.
Let's take a peek at how we'll add a new crossword puzzle. Note that there will be a new struct here, Answer, which we haven't defined yet. We'll also be introducing the concept of enums, like PuzzleStatus::Solved and PuzzleStatus::Unsolved. We'll be covering these in the next section.
Unlike the previous chapter where there was only one crossword puzzle, we'll be inserting into our new collections, so let's create a new_puzzle method.

Now we're set up to store multiple puzzles!
Permissions or permissionless?

    
    Guarding which accounts can enter the smart contract logic.Art by connoisseur_dane.near


Is NEAR permissionless?
Yes.
What did you mean by a permission system earlier, and what are the ways you can control permissions?
There are two ways that permissions can be controlled:

In the smart contract code itself
When using function-call access keys

We'll get to the second topic in later in this chapter, but will focus on the first item.
As you can see in the previous snippet, the first thing that happens in the new_puzzle method is a check. It looks to see if the predecessor (the person who most recently called this method, sometimes the same as the signer) is the same as the owner_id that we set during the contract's initialization.
If someone else is trying to call new_puzzle, this check will fail and the smart contract will panic, going no further. This example is the simplest form of a permission. Much more complex system can exist for users. The SputnikDAO smart contracts, for instance, implement custom policies. It's up the smart contract developer to write their roles/policies and apply them to users. Sometimes an allow-list (or whitelist) is used.
In short, any account with a full-access key can call any method on a smart contract, but that doesn't mean the smart contract will let them continue execution. It's up to the developer to protect their functions with guards like the one in new_puzzle.

Let's dive into structs and enums next.

### Highlights of some beginner topics covered.

Diving deeper
In the last chapter we installed Rust and got up and running with a simple smart contract. The contract has a few issues, however, and isn't as powerful as we'd like it to be. For instance, we can only store one crossword puzzle in the smart contract, the frontend is  hardcoded, and we don't offer any incentives to the person who wins.
Let's give the smart contract the ability to store multiple crosswords and offer the winner a prize, paid in NEAR.

    
    Art by r3v.near


In this chapter we'll:

Allow the contract to store multiple crossword puzzles
Store the positions of the clues in the contract
Allow users to log in with a NEAR account
Give a prize (in NEAR tokens) to the first person to solve the puzzle
Explore using Rust structs and enums
more…


    
    A user solves the crossword puzzle, interacts with the blockchain, and gets a prize

As we implement the list above, we'll learn key concepts about NEAR:

Actions
Full and function-call access keys
NEAR's specialized Collections that are generally preferable to, say, Rust's standard HashMap 
The flow of logging in to a decentralized app (dApp)
more…

Let's jump right in!
Completed project
Here's the final code for this chapter:
https://github.com/near-examples/crossword-tutorial-chapter-2

### Add a simple frontend to the crossword puzzle that checks the solution's hash

Add a simple frontend
This will be the final section in this chapter, where we'll add a simple frontend using React and near-api-js to communicate with the smart contract.

    
    Dynamic duo of NEAR as the backend and React as a frontend.Art by dakila.near


There will be three main files we'll be working with:

src/index.js will be the entry point, where NEAR network configuration will be set up, and the view-only call to get_solution will happen.
src/App.js is then called and sets up the crossword table and checks to see if a solution has been found.
src/utils.js is used to make a view-only call to the blockchain to get the solution, and other helper functions.

Entry point
We'll go over a pattern that may look familiar to folks who have surveyed the NEAR examples site. We'll start with an asynchronous JavaScript function that sets up desired logic, then pass that to the React app.

Let's talk through the code above, starting with the imports.
We import from:

config.js which, at the moment, is a common pattern. This file contains details on the different networks. (Which RPC endpoint to hit, which NEAR Wallet site to redirect to, which NEAR Explorer as well…)
utils.js for that view-only function call that will call get_solution to retrieve the correct solution hash when a person has completed the crossword puzzle correctly.
hardcoded-data.js is a file containing info on the crossword puzzle clues. This chapter has covered the crossword puzzle where the solution is near nomicon ref finance, and according to the chapter overview we've committed to serving one puzzle. We'll improve our smart contract later, allowing for multiple crossword puzzles, but for now it's hardcoded here.

Next, we define an asynchronous function called initCrossword that will be called before passing data to the React app. It's often useful to set up a connection with the blockchain here, but in our case all we need to do is retrieve the crossword puzzle solution as a hash. Note that we're attempting to pass this environment variable NEAR_ENV into our configuration file. NEAR_ENV is used to designate the blockchain network (testnet, betanet, mainnet) and is also used in NEAR CLI.
Lastly, we'll call initCrossword and, when everything is complete, pass data to the React app contained in App.js.
React app
Here's a large portion of the App.js file, which will make use of a fork of a React crossword library by Jared Reisinger.

We'll discuss a few key points in the code above, but seeing as we're here to focus on a frontend connection to the blockchain, will brush over other parts that are library-specific.
The two imports worth highlighting are:

parseSolutionSeedPhrase from the utility file we'll cover shortly. This will take the solution entered by the user and put it in the correct order according to the rules discussed in the chapter overview.
sha256 will take the ordered solution from above and hash it. Then we'll compare that hash with the one retrieved from the smart contract.

const [solutionFound, setSolutionFound] = useState(false);
We're using React Hooks here, setting up the variable solutionFound that will be changed when the player of the crossword puzzle enters the final letter of the crossword puzzle, having entries for all the letters on the board.
The onCrosswordComplete and checkSolution blocks of code fire events to check the final solution entered by the user, hash it, and compare it to the solutionHash that was passed in from the view-only call in index.js earlier.
Finally, we return the JSX for our app and render the crossword puzzle! In this basic case we'll change this heading to indicate when the user has completed the puzzle successfully:
<h3>Status: { solutionFound }</h3>
Utility functions
We'll be using two utility functions here:

parseSolutionSeedPhrase which will take a completed crossword puzzle and place the answers in the proper order. (Ascending by number, across answers come before down ones.)
viewMethodOnContract makes the view-only call to the smart contract to retrieve the solution hash.

We'll only focus on the second method:

This API doesn't look warm and friendly yet. You caught us! We'd love some help to improve our API as detailed in this issue, but for now, this is a concise way to get data from a view-only method.
We haven't had the frontend call a mutable method for our project yet. We'll get into that in the coming chapters when we'll want to have a prize sent to the first person to solve the puzzle.
Run the React app
Let's run our frontend on testnet! We won't add any new concepts at this point in the chapter, but note that the near examples typically create an account for you automatically with a NodeJS command. We covered the important pattern of creating a subaccount and deploying the smart contract to it, so let's stick with that pattern as we start up our frontend.
Go into the directory containing the Rust smart contract and build it:
cd contract

# Build
cargo near build
Create fresh account if you wish, which is good practice:

  

  ```bash
  # Delete an account
  near delete-account crossword.friend.testnet friend.testnet --networkId testnet

  # Create an account again
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  # Delete an account
  near account delete-account crossword.friend.testnet beneficiary friend.testnet network-config testnet sign-with-keychain send

  # Create an account again
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

Deploy the contract:
cargo near deploy crossword.friend.testnet with-init-call new json-args '{"solution": "69c2feb084439956193f4c21936025f14a5a5a78979d67ae34762e18a7206a0f"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
Return to the project root and start the React app:
cd ..
env CONTRACT_NAME=crossword.friend.testnet npm run start
The last line sends the environment variable CONTRACT_NAME into the NodeJS script. This is picked up in the config.js file that's used to set up the contract account and network configuration:

After running the last command to start the React app, you'll be given a link to a local website, like https://localhost:1234. When you visit the site you'll see the simple frontend that interacts with our smart contract:

Again, the full code for this chapter is available here.

### Introduction to basic hashing and adding unit tests

Hash the solution, add basic unit tests
In the previous section, we stored the crossword solution as plain text as a String type on the smart contract. If we're trying to hide the solution from the users, this isn't a great approach as it'll be public to anyone looking at the state. Let's instead hash our crossword solution and store that instead. There are different ways to hash data, but let's use sha256 which is one of the hashing algorithms available in the Rust SDK.
infoRemind me about hashing
Without getting into much detail, hashing is a "one-way" function that will output a result from a given input. If you have input (in our case, the crossword puzzle solution) you can get a hash, but if you have a hash you cannot get the input. This basic idea is foundational to information theory and security.

Later on in this tutorial, we'll switch from using `sha256` to using cryptographic key pairs to illustrate additional NEAR concepts.

Learn more about hashing from [Evgeny Kapun](https://github.com/abacabadabacaba)'s presentation on the subject. You may find other NEAR-related videos from the channel linked in the screenshot below.

[![Evgeny Kapun presents details on hashing](https://raw.githubusercontent.com/Techbridge3/docs/master/website/static//docs/assets/crosswords/kapun-hashing.png)](https://youtu.be/PfabikgnD08)

Helper unit test during rapid iteration
As mentioned in the first section of this Basics chapter, our smart contract is technically a library as defined in the manifest file. For our purposes, a consequence of writing a library in Rust is not having a "main" function that runs. You may find many online tutorials where the command cargo run is used during development. We don't have this luxury, but we can use unit tests to interact with our smart contract. This is likely more convenient than building the contract, deploying to a blockchain network, and calling a method.
We'll add a dependency to the hex crate to make things easier. As you may remember, dependencies live in the manifest file.

Let's write a unit test that acts as a helper during development. This unit test will sha256 hash the input "near nomicon ref finance" and print it in a human-readable, hex format. (We'll typically put unit tests at the bottom of the lib.rs file.)

infoWhat is that `{:?}` thing?
Take a look at different formatting traits that are covered in the [`std` Rust docs](https://doc.rust-lang.org/std/fmt/index.html#formatting-traits) regarding this. This is a `Debug` formatting trait and can prove to be useful during development.

Run the unit tests with the command:
cargo test -- --nocapture
You'll see this output:
…
running 1 test
Let's debug: "69c2feb084439956193f4c21936025f14a5a5a78979d67ae34762e18a7206a0f"
test tests::debug_get_hash ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
This means when you sha256 the input "near nomicon ref finance" it produces the hash:
69c2feb084439956193f4c21936025f14a5a5a78979d67ae34762e18a7206a0f
tipote on the test flags
You may also run tests using:

```
cargo test
```

Note that the test command we ran had additional flags. Those flags told Rust **not to hide the output** from the tests. You can read more about this in [the cargo docs](https://doc.rust-lang.org/cargo/commands/cargo-test.html#display-options). Go ahead and try running the tests using the command above, without the additional flags, and note that we won't see the debug message.

The unit test above is meant for debugging and quickly running snippets of code. Some may find this a useful technique when getting familiar with Rust and writing smart contracts. Next we'll write a real unit test that applies to this early version of our crossword puzzle contract.
Write a regular unit test
Let's add this unit test (inside the mod tests {} block, under our previous unit test) and analyze it:

The first few lines of code will be used commonly when writing unit tests. It uses the VMContextBuilder to create some basic context for a transaction, then sets up the testing environment.
Next, an object is created representing the contract and the set_solution function is called. After that, the guess_solution function is called twice: first with the incorrect solution and then the correct one. We can check the logs to determine that the function is acting as expected.
infoNote on assertions
This unit test uses the [`assert_eq!`](https://doc.rust-lang.org/std/macro.assert_eq.html) macro. Similar macros like [`assert!`](https://doc.rust-lang.org/std/macro.assert.html) and [`assert_ne!`](https://doc.rust-lang.org/std/macro.assert_ne.html) are commonly used in Rust. These are great to use in unit tests. However, these will add unnecessary overhead when added to contract logic, and it's recommended to use the [`require!` macro](https://docs.rs/near-sdk/4.0.0-pre.2/near_sdk/macro.require.html). See more information on this and [other efficiency tips here](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/reduce-size.md).

Again, we can run all the unit tests with:
cargo test -- --nocapture
tipun only one test
To only run this latest test, use the command:

```
cargo test check_guess_solution -- --nocapture
```


Modifying set_solution
The overview section of this chapter tells us we want to have a single crossword puzzle and the user solving the puzzle should not be able to know the solution. Using a hash addresses this, and we can keep crossword_solution's field type, as String will work just fine. The overview also indicates we only want the author of the crossword puzzle to be able to set the solution. As it stands, our function set_solution can be called by anyone with a full-access key. It's trivial for someone to create a NEAR account and call this function, changing the solution. Let's fix that.
Let's have the solution be set once, right after deploying the smart contract.
Here we'll use the #[near] macro on a function called new, which is a common pattern.

Let's call this method on a fresh contract.
Go into the directory containing the Rust smart contract and build it:
cd contract

# Build
cargo near build
Create fresh account if you wish, which is good practice:

  

  ```bash
  # Delete an account
  near delete-account crossword.friend.testnet friend.testnet --networkId testnet

  # Create an account again
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  # Delete an account
  near account delete-account crossword.friend.testnet beneficiary friend.testnet network-config testnet sign-with-keychain send

  # Create an account again
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

Deploy the contract:
cargo near deploy crossword.friend.testnet without-init-call network-config testnet sign-with-keychain send
Call the "new" method:

  

  ```bash
  near call crossword.friend.testnet new '{"solution": "69c2feb084439956193f4c21936025f14a5a5a78979d67ae34762e18a7206a0f"}' --gas 100000000000000 --accountId crossword.friend.testnet
  ```
  

  

  ```bash
  near contract call-function as-transaction crossword.friend.testnet new json-args '{"solution": "69c2feb084439956193f4c21936025f14a5a5a78979d67ae34762e18a7206a0f"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as crossword.friend.testnet network-config testnet sign-with-keychain send
  ```
  

Now the crossword solution, as a hash, is stored instead. If you try calling the last command again, you'll get the error message, thanks to the #[init] macro:
The contract has already been initialized
First use of Batch Actions
This is close to what we want, but what if a person deploys their smart contract and someone else quickly calls the new function before them? We want to make sure the same person who deployed the contract sets the solution, and we can do this using Batch Actions. Besides, why send two transactions when we can do it in one? (Technical details covered in the spec for a batch transaction here.)

    
    Art by dobulyo.near

### Alter the smart contract, learning about basics of development

Modifying the contract
This section will modify the smart contract skeleton from the previous section. This tutorial will start by writing a contract in a somewhat useless way in order to learn the basics. Once we've got a solid understanding, we'll iterate until we have a crossword puzzle.
Add a const, a field, and functions
Let's modify the contract to be:

We've done a few things here:

Set a constant for the puzzle number.
Added the field crossword_solution to our main struct.
Implemented three functions: one that's view-only and two that are mutable, meaning they have the ability to change state.
Used logging, which required the import of env from our near_sdk crate.

Before moving on, let's talk about these changes and how to think about them, beginning with the constant:
const PUZZLE_NUMBER: u8 = 1;
This is an in-memory value, meaning that when the smart contract is spun up and executed in the virtual machine, the value 1 is contained in the contract code. This differs from the next change, where a field is added to the struct containing the #[near] macro. The field crossword_solution has the type of String and, like any other fields added to this struct, the value will live in persistent storage. With NEAR, storage is "paid for" via the native NEAR token (Ⓝ). It is not "state rent" but storage staking, paid once, and returned when storage is deleted. This helps incentivize users to keep their state clean, allowing for a more healthy chain. Read more about storage staking here.
Let's now look at the three new functions:
pub fn get_puzzle_number(&self) -> u8 {
    PUZZLE_NUMBER
}
As is covered in the function section of these docs, a "view-only" function will have open parenthesis around &self while "change methods" or mutable functions will have &mut self. In the function above, the PUZZLE_NUMBER is returned. A user may call this method using the proper RPC endpoint without signing any transaction, since it's read-only. Think of it like a GET request, but using RPC endpoints that are documented here.
Mutable functions, on the other hand, require a signed transaction. The first example is a typical approach where the user supplies a parameter that's assigned to a field:
pub fn set_solution(&mut self, solution: String) {
    self.crossword_solution = solution;
}
The next time the smart contract is called, the contract's field crossword_solution will have changed.
The second example is provided for demonstration purposes:
pub fn guess_solution(&mut self, solution: String) {
    if solution == self.crossword_solution {
        env::log_str("You guessed right!")
    } else {
        env::log_str("Try again.")
    }
}
Notice how we're not saving anything to state and only logging? Why does this need to be mutable?
Well, logging is ultimately captured inside blocks added to the blockchain. (More accurately, transactions are contained in chunks and chunks are contained in blocks. More info in the Nomicon spec.) So while it is not changing the data in the fields of the struct, it does cost some amount of gas to log, requiring a signed transaction by an account that pays for this gas.

Building and deploying
Here's what we'll want to do:

    
    Art by jeheycell.near

Build the contract
To build the contract, we'll be using cargo-near.
Install cargo-near first:
cargo install cargo-near
Run the following commands and expect to see the compiled Wasm file copied to the target/near folder.
cd contract
cargo near build
Create a subaccount
If you've followed from the previous section, you have NEAR CLI installed and a full-access key on your machine. While developing, it's a best practice to create a subaccount and deploy the contract to it. This makes it easy to quickly delete and recreate the subaccount, which wipes the state swiftly and starts from scratch. Let's use NEAR CLI to create a subaccount and fund with 1 NEAR:

  

  ```bash
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

If you look again in your home directory's .near-credentials, you'll see a new key for the subaccount with its own key pair. This new account is, for all intents and purposes, completely distinct from the account that created it. It might as well be alice.testnet, as it has, by default, no special relationship with the parent account. To be clear, friend.testnet cannot delete or deploy to crossword.friend.testnet unless it's done in a single transaction using Batch Actions, which we'll cover later.
infoSubaccount nesting
It's possible to have the account `another.crossword.friend.testnet`, but this account must be created by `crossword.friend.testnet`.

`friend.testnet` **cannot** create `another.crossword.friend.testnet` because accounts may only create a subaccount that's "one level deeper."

See this visualization where two keys belonging to `mike.near` are able to create `new.mike.near`. We'll get into concepts around access keys later.


    
    Art by seanpineda.near



We won't get into top-level accounts or implicit accounts, but you may read more about that here.
Now that we have a key pair for our subaccount, we can deploy the contract to testnet and interact with it!
What's a codehash?
We're almost ready to deploy the smart contract to the account, but first let's take a look at the account we're going to deploy to. Remember, this is the subaccount we created earlier. To view the state easily with NEAR CLI, you may run this command:

  

  ```bash
  near state crossword.friend.testnet --networkId testnet
  ```
  

  

  ```bash
  near account view-account-summary crossword.friend.testnet network-config testnet now
  ```
  

What you'll see is something like this:
------------------------------------------------------------------------------------------
 crossword.friend.testnet         At block #167331831
                                  (Evjnf29LuqFE7FUf97VQZzNfnUgPFLNyyiUk9qr4Wjri)
------------------------------------------------------------------------------------------
 Native account balance           10.01 NEAR
------------------------------------------------------------------------------------------
 Validator stake                  0 NEAR
------------------------------------------------------------------------------------------
 Storage used by the account      182 B
------------------------------------------------------------------------------------------
 Contract (SHA-256 checksum hex)  No contract code
------------------------------------------------------------------------------------------
 Access keys                      1 full access keys and 0 function-call-only access keys
------------------------------------------------------------------------------------------
Note the Contract SHA-256 checksum is missing. This indicates that there is no contract deployed to this account.
Let's deploy the contract (to the subaccount we created) and then check this again.
Deploy the contract
Ensure that in your command line application, you're in the directory that contains the Cargo.toml file, then run:
cargo near deploy crossword.friend.testnet without-init-call network-config testnet sign-with-keychain send
Congratulations, you've deployed the smart contract! Note that NEAR CLI will output a link to NEAR Explorer where you can inspect details of the transaction.
Lastly, let's run this command again and notice that the Contract has a SHA-256 checksum. This is the hash of the smart contract deployed to the account.

  

  ```bash
  near state crossword.friend.testnet --networkId testnet
  ```
  

  

  ```bash
  near account view-account-summary crossword.friend.testnet network-config testnet now
  ```
  

note
Deploying a contract is often done on the command line. While it may be technically possible to deploy via a frontend, the CLI is likely the best approach. If you're aiming to use a factory model, (where a smart contract deploys contract code to a subaccount) this isn't covered in the tutorial, but you may reference the contracts in SputnikDAO.

Call the contract methods (interact!)
Let's first call the method that's view-only:

  

  ```bash
  near view crossword.friend.testnet get_puzzle_number '{}' --networkId testnet
  ```
  

  

  ```bash
  near contract call-function as-read-only crossword.friend.testnet get_puzzle_number json-args {} network-config testnet now
  ```
  

Your command prompt will show the result is 1. Since this method doesn't take any arguments, we don't pass any.
Next, we'll add a crossword solution as a string (later we'll do this in a better way) argument:

  

  ```bash
  near call crossword.friend.testnet set_solution '{"solution": "near nomicon ref finance"}' --gas 100000000000000 --accountId friend.testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction crossword.friend.testnet set_solution json-args '{"solution": "near nomicon ref finance"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as friend.testnet network-config testnet sign-with-keychain send
    ```
  

Note that we used NEAR CLI's view command, and didn't include an --accountId flag. As mentioned earlier, this is because we are not signing a transaction. This second method uses the NEAR CLI call command which does sign a transaction and requires the user to specify a NEAR account that will sign it, using the credentials files we looked at.
The last method we have will check the argument against what is stored in state and write a log about whether the crossword solution is correct or incorrect.
Correct:

  

  ```bash
  near call crossword.friend.testnet guess_solution '{"solution": "near nomicon ref finance"}' --gas 100000000000000 --accountId friend.testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction crossword.friend.testnet guess_solution json-args '{"solution": "near nomicon ref finance"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as friend.testnet network-config testnet sign-with-keychain send
    ```
  

You'll see something like this:

Notice the log we wrote is output as well as a link to NEAR Explorer.
Incorrect:

  

  ```bash
  near call crossword.friend.testnet guess_solution '{"solution": "wrong answers here"}' --gas 100000000000000 --accountId friend.testnet
  ```
  

  

    ```bash
    near contract call-function as-transaction crossword.friend.testnet guess_solution json-args '{"solution": "wrong answers here"}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' sign-as friend.testnet network-config testnet sign-with-keychain send
    ```
  

As you can imagine, the above command will show something similar, except the logs will indicate that you've given the wrong solution.
Reset the account's contract and state
We'll be iterating on this smart contract during this tutorial, and in some cases it's best to start fresh with the NEAR subaccount we created. The pattern to follow is to delete the account (sending all remaining testnet Ⓝ to a recipient) and then create the account again.
<source src={chalkboardErase} type="video/mp4" />
Sorry, your browser doesn't support embedded videos.


    Deleting a recreating a subaccount will clear the state and give us a fresh start.Animation by iambon.near

Using NEAR CLI, the commands will look like this:

  

  ```bash
  # deleting an account
  near delete-account crossword.friend.testnet friend.testnet --networkId testnet

  # creating an account
  near create-account crossword.friend.testnet --use-account friend.testnet --initial-balance 1 --network-id testnet
  ```
  

  

  ```bash
  # deleting an account
  near account delete-account crossword.friend.testnet beneficiary friend.testnet network-config testnet sign-with-keychain send

  # creating an account
  near account create-account fund-myself crossword.friend.testnet '1 NEAR' autogenerate-new-keypair save-to-keychain sign-as friend.testnet network-config testnet sign-with-keychain send
  ```
  

The first command deletes crossword.friend.testnet and sends the rest of its NEAR to friend.testnet.
Wrapping up
So far, we're writing a simplified version of smart contract and approaching the crossword puzzle in a novice way. Remember that blockchain is an open ledger, meaning everyone can see the state of smart contracts and transactions taking place.
infoHow would you do that?
You may hit an RPC endpoint corresponding to `view_state` and see for yourself. Note: this quick example serves as demonstration purposes, but note that the string being returned is Borsh-serialized and contains more info than just the letters.

```bash
    curl -d '{"jsonrpc": "2.0", "method": "query", "id": "see-state", "params": {"request_type": "view_state", "finality": "final", "account_id": "crossword.friend.testnet", "prefix_base64": ""}}' -H 'Content-Type: application/json' https://rpc.testnet.near.org
```

![Screenshot of a terminal screen showing a curl request to an RPC endpoint that returns state of a smart contract](https://raw.githubusercontent.com/Techbridge3/docs/master/website/static//docs/assets/crosswords/rpc-api-view-state.png)

More on this RPC endpoint in the [NEAR docs](https://docs.near.org/docs/api/rpc/contracts#view-contract-state).

In this section, we saved the crossword solution as plain text, which is likely not a great idea if we want to hide the solution to players of this crossword puzzle. Even though we don't have a function called show_solution that returns the struct's crossword_solution field, the value is stored transparently in state. We won't get into viewing contract state at this moment, but know it's rather easy and documented here.
The next section will explore hiding the answer from end users playing the crossword puzzle.

### Set up Rust, get a NEAR testnet account, NEAR CLI, and get a basic smart contract skeleton ready

Getting started
In this tutorial we'll get a testnet account, use NEAR CLI RS to add a key to our computer's file system, and set up the basic skeleton of a Rust smart contract.
Setting up Rust

You may have found the online Rust Book, which is a great resource for getting started with Rust. However, there are key items that are different when it comes to blockchain development. Namely, that smart contracts are technically libraries and not binaries, but for now just know that we won't be using some commands commonly found in the Rust Book.
::caution
We won't be using cargo run during smart contract development.
::

Instead, we'll be iterating on our smart contract by building it and running tests.
Install Rust using rustup
Please see the directions from the Rustup site. For OS X or Unix, you may use:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
(Taken from the Rust installation guide)
Add Wasm toolchain
Smart contracts compile to WebAssembly (Wasm) so we'll add the toolchain for Rust.
rustup target add wasm32-unknown-unknown
(More info on targets and this toolchain here.)
Getting a testnet account
Visit NEAR Wallet for testnet and register for a free account. For the purposes of this tutorial, you may skip the option to add two-factor authentication if you wish.
noteWhat just happened?
When you created your NEAR `testnet` account, a private key was created and placed into your browser's local storage. You may inspect this using developer tools and see it.

Creating a new key on your computer
We'll want to use a command-line interface (CLI) tool to deploy a contract, but at the moment the private key only exists in the browser. Next we'll add a new key to the testnet account and have this stored locally on our computer as a JSON file. (Yes, you can have multiple keys on your NEAR account, which is quite powerful!)
Let's install NEAR CLI RS using cargo. You can also download the pre-compiled version of near-cli-rs for your OS from GitHub's Releases page.
cargo install near-cli-rs
You may now run:
near
to see various commands, which are covered in detail here.
We'll start by "logging in" with this command:

  

  ```bash
  near login
  ```
  

  

  ```bash
  near account import-account using-web-wallet network-config testnet
  ```
  

This will bring you to NEAR Wallet again where you can confirm the creation of a full-access key. We'll get to full-access and function-call access keys later, just know that for powerful actions like "deploy" we'll need a full-access key. Follow the instructions from the login command to create a key on your hard drive. This will be located in your operating system's home directory in a folder called .near-credentials.
noteHow was a key added?
When you typed `near login`, NEAR CLI generated a key pair: a private and public key. It kept the private key tucked away in a JSON file and sent the public key as a URL parameter to NEAR Wallet. The URL is long and contains other info instructing NEAR Wallet to "add a full access key" to the account. Our browser's local storage had a key (created when the account was made) that is able to do several things, including adding another key. It took the public key from the URL parameter, used it as an argument, and voilà: the `testnet` account has an additional key!

You can see the keys associated with your account by running the following command, replacing friend.testnet with your account name:

  

  ```bash
  near list-keys friend.testnet
  ```
  

  

  ```bash
  near account list-keys friend.testnet network-config testnet now
  ```
  

Start writing Rust!
There's a basic repository that's helpful to clone or download located here.
The first thing we'll do is modify the manifest file at Cargo.toml:
[package]
-  name = "rust-template"
+  name = "my-crossword"
version = "0.1.0"
- authors = ["Near Inc <hello@near.org>"]
+ authors = ["NEAR Friend <friend@example.com>"]
edition = "2018"
By changing the name here, we'll be changing the compiled Wasm file's name after running the build script. (build.sh for OS X and Linux, build.bat for Windows.) After running the build script, we can expect to find our compiled Wasm smart contract in res/my_crossword.wasm.
Now let's look at our main file, in src/lib.rs:

As you can see, this is a stub that's ready to be filled in. Let's pause and point out a few items:

Note the near macro is above the struct and the impl
Here the main struct is called Contract, while in other examples it might be Counter or something else. This is purely stylistic, but you may learn more from the link in the previous bullet.
You may notice the word "Borsh" and wonder what that means. This is a binary serializer. Eventually, we'll want to save data as ones and zeroes to validators' hard drives, and do it efficiently. We use Borsh for this, as is explained on this website.

Next, let's modify this contract little by little…

### Auction factory

Since an auction contract hosts a single auction, each time you would like to host a new auction you will need to deploy a new contract. Rather than finding the compiled WASM file, creating a new account, deploying the contract, and then initializing it each time, you can use a factory contract to do this for you.
Luckily for us, there is already a factory contract example! We will fork this example and slightly modify it to suit our use case. If you would like to learn more about how the factory contract works, you can take a look at the associated documentation.
The factory example only comes in rust since, currently, the JavaScript SDK does not allow you to embed the WASM file in the contract. This is a limitation of the SDK and not the blockchain itself.

Changing the default contract
In the current example, the factory contract deploys the donation contract example. We will change this to deploy our auction contract instead. 
Firstly, we'll need the compiled auction contract WASM file. You can get this by running the following command in 03-bid-with-fts of contract-rs
cargo near build 
You will find the resulting WASM file in target/near; copy this file and use it to replace the WASM of the donation contract in the factory contract's source folder. Now edit the auction contract changing the path to the auction contract.

    
    

On initialization, the factory will add the auction contracts WASM, as bytes, to the factory's state. It is more efficient to not store the WASM in the factory's state, however, we may want to update the auction contract if we find a bug or want to add new features. The factory implements a method to update the auction contract - we'll change the name to update_auction_contract as this factory will only deploy auction contracts.
<Github fname="Contract path" language="rust"
url="https://github.com/near-examples/auctions-tutorial/blob/main/factory/src/manager.rs#L8-L13"
start="8" end="13" />

Modifying deploy method
The method to deploy a new contract is specific to the contract being deployed (in the case the contract has custom initialization parameters). We will modify the method to take in the auction contract's initialization parameters.
<Github fname="Contract path" language="rust"
url="https://github.com/near-examples/auctions-tutorial/blob/main/factory/src/deploy.rs#L9-L82"
start="9" end="82" />
In this fork, we have also removed the option to add an access key to the contract account since, as discussed earlier, we want auctions to be locked.

Using the factory
Build and deploy the factory like you would any other contract, this time without any initialization parameters. 
# compile the contract using cargo-near
cargo near build

# deploy the contract
near deploy <contractId> ./target/near/contract.wasm
You can now use the factory to deploy new auction contracts, here is an example command. 
near call auction-factory.testnet deploy_new_auction '{"name": "new-auction", "end_time": "3000000000000000000", "auctioneer": "pivortex.testnet", "ft_contract": "dai.fakes.testnet", "nft_contract": "nft.examples.testnet", "token_id": "7777", "starting_price": "1000000000000000000"}' --accountId pivortex.testnet --deposit 1.6 --gas 100000000000000
infoDeposit and storage costs
Note that we attach 1.6 $NEAR to the call to cover the storage costs of deploying the new auction. The storage cost on NEAR is 1 $NEAR per 100 kb, and our auction contract is around 140 kb, but we'll add a little to cover the storage used on initialization.

The command results in a fresh auction contract being deployed and initialized at new-auction.auction-factory.testnet.

Conclusion
In this part of the tutorial, you have learned how to fork and modify the factory contract example to deploy our auction contracts. You have also learned how to use the factory to deploy new auction contracts. If you're feeling adventurous you could create a frontend to interact with the factory contract to make it even easier to deploy new auctions. If you do so feel free to share it in our developer Telegram or Discord channels!
And with that, this tutorial series is over, congratulations! Through this tutorial, we've built an auction contract and iterated on it adding improvements and extending its functionality, created a frontend to interact with the auction, used an API to index previous bids, and deployed a factory contract to make deploying new auctions easier. Along the way we've learned a great deal about NEAR, we learned about the anatomy of smart contracts, how to lock a contract to make it more secure, how to use primitives such as NFTs and FTs, how to perform cross-contract calls, how to use wallets from a frontend to interact with the blockchain and display data about a smart contract, how to pull historical data from the blockchain using an API, how to deploy contracts from other contracts and a lot of other little bits that will help you in the future. 
That's a lot, so once again congratulations!

### Updating the Frontend

Now we've updated the contract to include an NFT as a reward and changed the contract such that it accepts bids in fungible tokens, we need to update the frontend accordingly.
Getting the data from the contract
Now we have a function to output the whole contract state we will call this function in our frontend 

    

This call will deliver us the contract Ids of the FT and NFT contracts along with the token Id of the NFT. We will then use this information to call the ft_metadata and nft_token methods on the FT and NFT contracts respectively to get information about the FT and NFT.

Displaying the NFT
We want to show what NFT is being auctioned. To do this we will call nft_token on the NFT contract to get the NFT metadata. To call this method we need to specify the NFT contractId and the token_id, which can be found in the auction information. nft_token also returns the owner of the NFT, so we'll check this against the contract account to verify that the auction is valid.

    

Note that this effect will only run once the auctionInfo updates because we first need the NFT contract ID and token ID from auctionInfo to make a valid call to nft_token.
In a new component named AuctionItem we display the NFT image, name, and description.



Note that an image caching service is used to display the NFT image for better performance.

Fetching FT information
Using the FT contract ID from the auction information, we can call the ft_metadata method on the FT contract to get information about the fungible token that is being used for the auction.

    

We set the FT image, symbol, icon, and decimals in state. We use the decimals to format the amount of tokens being bid. In the case of DAI it divides the amount by 10^18. The reverse process is used when making a bid, the bid amount is multiplied by 10^18 before being sent to the contract.

Bidding with FTs
Instead of calling the function bid on the contract we now call the ft_transfer_call function on the FT contract. This function transfers the FTs to the auction contract and calls the ft_on_transfer on the auction contract. 

    


Updating the indexing API call
We need to update the API call that fetches historical bids to now index each time ft_on_transfer is called on the auction contract from the FT contract. 

    

And now instead of getting the bid amount from the deposit, it is now retrieved from the calls argument, from amount. The case is the same for the account Id of the bidder, from sender_id.

    


Conclusion
Ok nice, that didn't take too long. To look back, we updated the frontend to now display the NFT being auctioned, to display bid amounts - both the current and historical bids - in terms of the FT being used, and changed the bidding process to now use FTs. 
In the final section of this mega tutorial we'll create an auction factory contract that is used to deploy and initialize new auction contracts.

### Bidding with FTs

To further develop this contract we will introduce another primitive: fungible tokens. Instead of placing bids in $NEAR tokens, they will be placed in FTs. This may be useful if, for example, an auctioneer wants to keep the bid amounts constant in terms of dollars as an auction is carried out, so bids can be placed in stablecoins such as $USDC. Another use case is if a project like Ref Finance was holding its own auction and wanted the auction to happen in its project's token $REF.

Specifying the FT contract
We want to only accept bids in one type of fungible token; accepting many different FTs would make the value of each bid difficult to compare. We're also going to adjust the contract so that the auctioneer can specify a starting bid amount for the auction.


    

        

    

    

        

    



Accepting bids in FTs
When we were making bids in $NEAR tokens we would call the auction contract directly and attach $NEAR tokens to the call. With fungible tokens, since an account's balance lives on a separate contract, we call the FT contract which then calls the auction contract and transfers tokens. The method on the FT contract to do this is named ft_transfer_call and it will always call a method in the target contract named ft_on_transfer. Take a look here for more information. 

The ft_on_transfer method always has the same interface; the FT contract will pass it the sender, the amount of FTs being sent and a msg which can be empty (which it will be here) or it can contain some information needed by the method (if you want to send multiple arguments in msg it is best practice to deliver this in JSON then parse it in the contract). The method returns the number of tokens to refund the user, in our case we will use all the tokens attached to the call for the bid unless the contract panics in which case the user will automatically be refunded their FTs in full.


    

        

    

    

        

    


We need to confirm that the user is attaching fungible tokens when calling the method and that they are using the right FT, this is done by checking the predecessor's account ID. Since it's the FT contract that directly calls the auction contract, the predecessor is now the account ID of the FT contract.


    

        

    

    

        

    


The bidder's account ID is now given by the argument sender_id and the bid amount is passed as an argument named amount.


    

        

    

    

        

    


When we want to return the funds to the previous bidder we now make a cross-contract call to the FT contract. 


    

        
            
            
        

        In JavaScript, we have to return the Promise to transfer the FTs but we also need to return how much to refund the user. So after transferring the FTs, we make a `callback` to our own contract to resume the contract flow. Note that the callback is private so it can only be called by the contract. We return 0 because the method uses all the FTs in the call.

    

    

        
            
            
        

         We then return 0 because the method uses all the FTs in the call.

        

    


If the call was to fail the FT contract will automatically refund the user their FTs.
 

     What happens if the cross-contract call fails? 

    The first time this method is called the contract will try to send itself FTs. Most fungible token contracts don't allow one to send themselves FTs so the cross-contract call will fail. However, since cross-contract calls are asynchronous and independent and we are not checking the result of the call then the auction contract does not care that the call failed and ft_on_transfer will complete successfully.

    In the other cases, the call to the fungible token contract could only fail if the receiver does not exist, the FT contract does not exist, the auction contract doesn't have enough fungible tokens to cover the amount being sent, or the receiver is not registered in the FT contract. Our contract is set up such that these errors cannot occur, the receiver must exist since they placed the previous bid, the FT contract exists since it was used to place the bid, the auction contract has enough FTs to cover the amount since it was sent that amount by the previous bid, and the receiver must be registered in the FT contract since they needed to have held the token in the first place to make a bid.



Claiming the FTs
When the auction is complete we need to send the fungible tokens to the auctioneer when we send the NFT to the highest bidder, we implement a similar call as when we were returning the funds just changing the arguments.


    

        

        In JavaScript, since we need to return each cross-contract call we chain the NFT and FT transfer.

    

    

        

    



Creating a new FT
Just as with the NFT contract, we will deploy an FT contract in the sandbox tests using a WASM file compiled from this repo.
When the contract is deployed it is initialized with new_default_meta which sets the token's metadata, including things like its name and symbol, to default values while requiring the owner (where the token supply will sent), and the total supply of the token.


    

        

    

    

        

    



Registering users in the FT contract
For one to receive fungible tokens, first their account ID must be registered in the FT contract. A user has to register in an FT contract to pay for the storage used to track their amount of tokens. By default, a contract pays for its own storage, but not requiring a user to register and pay for storage would drain the contract of $NEAR tokens. When the contract is live we don't need to register the accounts that we transfer tokens back to since to make a bid in the first place they would have needed to be registered, but we do need to register the auction contract in the FT contract to receive bids and the auctioneer to receive the funds at the end of the auction. It is most convenient to register users from the frontend rather than the contract.
In our tests, since we are creating a new fungible token and new accounts we will actually have to register every account that will interact with FTs.


    

        

    

    

        

    



Simple FT transfer to bidders
Then we will transfer the bidders FTs so they can use them to bid. A simple transfer of FTs is done using the method ft_transfer on the FT contract.


    

        

    

    

        
            
            
        

    



FT transfer call
As stated previously, to bid on the auction the bidder now calls ft_transfer_call on the FT contract which subsequently calls the auction contract's ft_on_transfer method with fungible tokens attached.


    

        

    

    

        
            
            
        

    



Checking users' FT balance
Previously, to check a user's $NEAR balance, we pulled the details from their account. Now we are using FTs we query the balance on the FT contract using ft_balance_of, let's check that the contract's balance increased by the bid amount and the user's balance decreased by the bid amount.


    

        

    

    

        
            
            
        

    



Invalid FT transfer call
If we make a lower bid than the previous this will cause the auction contract to panic. One might expect that ft_transfer_call will fail, but it does not. ft_on_transfer will fail and the FT contract will recognize this and reverse the transfer of tokens. So after making an invalid bid, we should check that the call was successful but the parties involved in the transaction (the bidder and the contract) have the same balance of fungible tokens as they did before the call.
Previous to this, Bob made a bid of 60,000 and Alice was returned her bid bringing her balance back up to 150,000. Now when Alice makes an invalid of 50,000 Alice's balance should remain at 150,000 and the contract should remain at a balance of 60,000.


    

        

    

    

        

    



Using FTs with the CLI
If you want to interact with the auction contract you're going to need FTs. For this example, we'll use $DAI where the contract address is dai.fakes.testnet. One can easily acquire FTs through the testnet faucet. Select DAI and withdraw to the account you will use to place a bid. If you take a look at the transaction details you can see that the faucet registers your account in the FT contract and then sends you DAI from the faucet account.
When deploying the contract make sure to specify the FT contract dai.fakes.testnet.
The auction contract will need to be registered as well, you could do this by sending it an arbitrary amount of $DAI from the faucet or you can just register it since it doesn't need any FTs. You should also register the auctioneer,
near call dai.fakes.testnet storage_deposit '{"account_id": "<auctionContractId>"}' --accountId <accountId> --deposit 0.1
Now you can go ahead and place a bid. DAI has 18 decimals meaning that 1 $DAI is made up of 10^24 smallest units. To make a bid of 2 $DAI you can use the command:
near call dai.fakes.testnet ft_transfer_call '{"receiver_id": "<auctionContractId>", "amount": "2000000000000000000", "msg": ""}' --accountId <bidderId> --depositYocto 1
Auction architecture
When creating an application there are numerous ways to structure it. Here, we have one contract per auction meaning we have to deploy a new contract each time we want to host an auction. To make this easier we will leverage a factory contract to deploy auction contracts for an auctioneer. Deploying code for each auction gets expensive, with 100kb of storage costing 1 $NEAR, since each auction stores all the same type of information and implements the same methods one could instead decide to have multiple auctions per contract. 
In such case, the Contract struct would be a map of auctions. We would implement a method to create a new auction by adding an entry to the map with the specific details of that individual auction.


    

        ```javascript
        class Contract {
            auctions: UnorderedMap
        ```

    

    

        ```rust 
        pub struct Contract {
            auctions: IterableMap
        ```

    


However, this architecture could be deemed less secure since if a bad actor were to gain access to the contract they would have access to every auction instead of just one.

Conclusion
In this section, you learned a lot about fungible tokens: how to send and receive FTs in a smart contract, and then in sandbox tests how to deploy and initialize an FT contract, how to register a user in an FT contract, and send them some tokens, how to attach FTs to a smart contract call and finally how to view the FT balance of a user. With that, we now have our completed auction smart contract!  
Taking a further step back we've taken a very simple auction contract and transformed it into a more production contract with thorough testing. To improve the auction we learned how to add a prize by introducing NFTs, and enabled auctioneers to host auctions with FTs.
In the next part of the tutorial, we're going to update the frontend to interact with the new features of the contract.

### Winning an NFT

No one will enter an auction if there's nothing to win, so let's add a prize. Why not an NFT? NFTs are uniquely identifiable, easily swappable and their logic comes from an external contract so the prize will exist without the auction contract. Let's get to work!

Listing the NFT
When we create an auction we need to list the NFT. To specify which NFT is being auctioned off we need the account ID of the NFT contract and the token ID of the NFT. We will specify these when the contract is initialized; amend init to add nft_contract and token_id as such:  


    

        

    

    

        

        Note that `token_id` is of type `TokenId` which is a String type alias that the NFT standards use for future-proofing.

    



Transferring the NFT to the winner
When the method claim is called the NFT needs to be transferred to the highest bidder. Operations regarding NFTs live on the NFT contract, so we make a cross-contract call to the NFT contract telling it to swap the owner of the NFT to the highest bidder. The method on the NFT contract to do this is nft_transfer.


    

        

        In near-sdk-js we cannot transfer the NFT and send the $NEAR independently so we will chain the promises.

    

    

        We will create a new file in our source folder named `ext.rs`; here we are going to define the interface for the `nft_transfer` method. We define this interface as a `trait` and use the `ext_contract` macro to convert the NFT trait into a module with the method `nft_transfer`. Defining external methods in a separate file helps improve the readability of our code. 

        We then use this method in our `lib.rs` file to transfer the NFT.

        
            
            
        

    


When calling this method we specify the NFT contract name, that we are attaching 30 Tgas to the call, that we are attaching a deposit of 1 YoctoNEAR to the call, and give the arguments receiver_id and token_id. The NFT requires that we attach 1 YoctoNEAR for security reasons.

NFT ownership problems
In our contract, we perform no checks to verify whether the contract actually owns the specified NFT. A bad actor could set up an auction where the NFT being auctioned doesn't belong to the auction contract, causing nft_transfer to fail and the winning bidder to lose their bid funds with nothing in return. We could make a cross-contract call to the NFT contract to verify ownership on initialization but this would become quite complex. Instead, we will do this check off-chain and validate the auction in the frontend. 

Displaying the contract object
Since we are now dealing with more information in our contract, instead of implementing a function to display each field we'll create a function to display the entire contract object. Since the contract doesn't include large complex data structures like a map displaying the contract state in its entirety is easily done.


    

        

    

    

        

        We add the `serilizers` macro to enable json serialization so the object as a whole can easily be displayed to the frontend without having to output each field individually.

        

    


Testing with multiple contracts
In our tests, we're now going to be using two contracts; the auction contract and an NFT contract. Sandbox testing is great as it allows us to test multiple contracts in a realistic environment.
In our tests folder, we need the WASM for an NFT contract. For this tutorial, we compiled an example NFT contract from this repo.
To deploy the NFT contract, this time we're going to use dev deploy which creates an account with a random ID and deploys the contract to it by specifying the path to the WASM file. After deploying we will initialize the contract with default metadata and specify an account ID which will be the owner of the NFT contract (though the owner of the NFT contract is irrelevant in this example). Default metadata sets information such as the name and symbol of the NFT contract to default values.


    

        

    

    

        

    



Minting an NFT
To start a proper auction the auction contract should own an NFT. To do this the auction account calls the NFT contract to mint a new NFT providing information such as the image for the NFT.  


    

        

    

    

        

    



Verifying ownership of an NFT
After claim is called, the test should verify that the auction winner now owns the NFT. This is done by calling nft_token on the NFT contract and specifying the token ID which will return the account ID that the token belongs to.


    

        

    

    

        

    



Getting an NFT
If you would like to interact with the new contract via the CLI you can mint an NFT from a pre-deployed NFT contract 
near call nft.examples.testnet nft_mint '{"token_id": "TYPE_A_UNIQUE_VALUE_HERE", "receiver_id": "<accountId>", "metadata": { "title": "GO TEAM", "description": "The Team Goes", "media": "https://bafybeidl4hjbpdr6u6xvlrizwxbrfcyqurzvcnn5xoilmcqbxfbdwrmp5m.ipfs.dweb.link/", "copies": 1}}' --accountId <accountId> --deposit 0.1 
You can also just buy an NFT with testnet $NEAR on a testnet marketplace like Mintbase.

Conclusion
In this part of the tutorial we have added NFTs as a reward which has taught us how to interact with NFT standards, make cross-contract calls and test multiple contracts that interact with each other in workspaces. In the next part we'll learn how to interact with fungible token standards by adapting the auction to receive bids in FTs. This will allow users to launch auctions in different tokens, including stablecoins.

### Indexing Historical Data

In our frontend, we can easily display the previous bid since it's stored in the contract's state. However, we're unable to see previous bids to the auction. An indexer is used to fetch historical data from the blockchain and store it in a database. Since indexers can take a while to set up and can be expensive to run, we will use a pre-defined API endpoint provided by NEAR Blocks to query an indexer they run that will fetch us the data we need.

NEAR Blocks API key
NEAR Blocks provides a free tier that allows you to make 6 calls per minute, which will be plenty for our use case. To get an API key, head over to https://dash.nearblocks.io/user/overview and sign up. Once signed go to API Keys then click Add key and give it whatever name you like.
We'll create a new file named .env.local to store our API key.
API_KEY=YOUR_API_KEY_GOES_HERE
We put the API key in a .env.local file so the user cannot access it in the browser and use our key elsewhere. We should also add .env.local to our .gitignore file so it is not pushed to GitHub.

Calling the API endpoint
NextJS allows us to easily create server-side functions with API routes. We need to make this API call on the server-side rather than the client side so as to not expose our API key. We'll create a new file in src/pages/api named getBidHistory.js. Here we'll define our function to get the bid history.

    

Here we are retrieving the auction contract ID from the API route call and then calling the NEAR Blocks API. This specific API endpoint allows us to retrieve transactions made to a specific contract calling a specific function. Some details are worth discussing here:

We pass the account ID of the auction contract, which is basic-auction-example.testnet in the example repo.
We specify the function name on the auction contract that we want the transactions for, in our case it will be bid
We'll receive a JSON object of up to 25 transactions, ordered by the most recent first.
We pass our API key to authenticate the request.


Retrieving the bids from the API result
From our API call, we receive a JSON object containing up to 25 transactions made to the bid function on the auction contract.

    

We want to display the 5 most recent valid bids. To do this we loop through each transaction and check whether the transaction was successful by checking receipt_outcome.status is true. If so we check the first action (since there should only be one function call action in this case) and store the deposit, which is equal to the bid amount, and store the predecessor account ID, which is the account ID of the bidder.
Once we have 5 valid bids we can stop looping through the transactions.
Note that in our example if the previous 25 bids were invalid the API will return an empty array. The function could be set up such that it calls the API again to get the new page of transactions if this is the case.
tipearn More

You can read more about transaction actions in this section of the documentation: [Actions](/concepts/protocol/transaction-anatomy#actions)



Using the API Route
In our main page, we'll define a function to call the API route we just created. This function will be called each time the page timer reaches zero.

    

The pastBids will then be passed into the Bid component to be displayed.

You may like to explore NEAR Blocks APIs further to see what other data you can retrieve from the blockchain. You can find the documentation at https://api.nearblocks.io/api-docs/

Using the frontend
Now we have implemented the frontend and indexer you can go ahead and actually use the frontend. From the root of the frontend directory run the following commands:
# install dependencies
npm install

# run the frontend locally
npm run dev

Conclusion
In this short part of the tutorial, we've added the ability to display the previous 5 valid bids made to the auction contract. In doing this we learned how to interact with the NEAR Blocks APIs to retrieve historical data from the blockchain and how to make server-side calls in NextJS to not expose our API key. Now we have a pretty good frontend that displays all the information we need about the auction contract.
In the next section of the tutorial we're going to improve our contract by adding primitives to the auction contract starting with adding NFTs as a prize.

### Creating a Frontend

Now that we have successfully created a contract, it's time to build a frontend to provide a user-friendly interface for interacting with it. Up until now, we have been using the CLI to send transactions and view the contract's state. However, frontends offer a more intuitive way for end users to interact with the contract. They can display all the relevant information in one place, allow users to make calls with a simple button click, and only require a wallet as a prerequisite.

Frontend structure
Navigate to the auction frontend.
cd frotends/01-frontend
Here we have a simple Next.js frontend that we'll walk through to understand the basics of creating a frontend for a NEAR smart contract.
For starters, let's take a look at how the code in the frontend is structured by doing a quick overview of the important files.



File
Description




_app.js
Responsible for rending the page, initiates the wallet object and adds it to global context


index.js
The main page where the project's components are loaded into and contains most of the logic for the application like viewing the state of the contract and logic for placing a bid


near.js
Contains the wallet class that has methods to interact with the wallet and blockchain


context.js
Holds the global context - the wallet object and the signed-in account ID - that can be accessed anywhere


config.js
Specifies the account ID of the auction contract


Navigation.jsx
A component that contains a button to sign users in and out of wallets


Bid.jsx
A component allowing a user to make a bid


LastBid.jsx
A component that displays the highest bid and when the highest bid will next refresh


Timer.jsx
A component that shows how long till the auction is over, or, if over, displays a button to claim the auction and then states the auction is over




Specifying the contract
We have a config file that specifies the contract name of the auction that the frontend will interact with. There has been an example auction contract deployed and specified already but feel free to change the contract to your own auction contract you deployed.

    


Setting up wallets
To be able to fully interact with the contract - send bids and claim the auction - you'll need a wallet to sign transactions. Wallets securely store your private keys and allow you to sign transactions without exposing your private key to the frontend. The wallet selector allows users to choose between a selection of wallets.
We abstract the wallet selector in our near.js file by exposing methods to complete various tasks. Feel free to explore the file to understand fully how the wallet selector is implemented. 
The wallet object is initiated in the app.js file and its added to the global context along with the account that is signed in to make it easier to access anywhere in the application.

    
    

tipccess keys

On NEAR, in additional to normal full access keys, we have `function-call access keys` that are given to applications to allow them to sign `non-payable` transactions on behalf of the user. This is so the wallet doesn't have to pop up for each non-critical transaction, improving the user experience. When creating the wallet object you can decide to create an access key for the application to use. However, in this example we opt out since the main function - `bid` - we'll be calling is `payable`.

You can read further about NEAR's key model [here](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/protocol/access-keys.md).


We add a sign-in and sign-out button in the navigation component to call the respective methods in the near.js file.

    
    


Displaying the highest bid
To get the highest bid from the auction and who made it we call get_highest_bid. Since this function returns the highest bid in yoctoNEAR we divide by 10^24 to get the amount in NEAR. 

    
    

In the wallet file, you'll see that we make a query to the RPC provider, since we are not signing a transaction the wallet isn't required here. Here we are using https://rpc.testnet.near.org but note there are many different providers available. We are querying the RPC with optimistic finality, which queries the latest block recorded on the node. Alternatively, one could use final finality where the block has been validated by at least 66% of the validators on the network but this will provide slightly delayed information (only by a couple of seconds).
We then pass the information about the highest bidder into the LastBid component to display the bid amount and the bidder's account Id.

    
    


Updating the highest bid
We want to know the highest bid at all times, someone else could have placed a higher bid since the page was loaded. To solve this we fetch the contract information every 20 seconds using setInterval and update the highest bid if it has changed. In reality you would want to refresh the bid amount more requently but for the sake of saving on RPC calls we are doing it every 20 seconds.

    


Auction end time
The contract stores the end time of the auction in the number of nanoseconds since the Unix epoch (1 January 1970 00:00:00 UTC). In our frontend we will display the time left in days, hours, minutes, and seconds.

    


Making a bid
To make a bid we make a call to the contract using the bid function. We specify the deposit amount in yoctoNEAR which will be the bid amount. The input box will take the bid amount in NEAR so we multiply by 10^24 to get the correct amount to send. We also specify the amount of gas to attach to the transaction, here we are attaching 30Tgas which is more than enough for the transaction to go through, we are refunded any unused gas anyway.
Here, since the user is changing the state of the contract, not just viewing it, the user needs to sign the transaction. Thus the wallet will pop up displaying the transaction details.

    
    


Claiming the auction
Once the auction is over (the current time is greater than the end time) the auction can be claimed. At this point, the timer will be hidden and a button to claim the auction will be displayed. Once clicked the claim function will be called on the auction contract to send the highest bidder the NFT and the auctioneer the FTs.

    


Conclusion
In this part of the tutorial, we have implemented a simple frontend for a NEAR contract. Along the way, you have learned how to use the wallet selector to sign the user in and out, how to view the contract’s state, how to sign and send transactions.
While we can see the highest bid, we may want to see the auction's bidding history. Since the contract only stores the most recent bid (to reduce storage costs), we need to use an indexer to pull historical data. In the next part of the tutorial, we'll look at querying historical data using an API endpoint.

### Deploying to Testnet

In the previous sections, we saw how a simple auction smart contract is implemented, and checked its correctness using sandbox testing.
The time has come to release it on the actual blockchain and interact with it! In this section, we will show you how to create a simple testnet account, deploy the contract, and interact with it from the CLI.
infoNetworks

NEAR has two main networks for you to use: `testnet` and `mainnet`. The `testnet` network behaves exactly as the main network but uses test tokens with no real value



Testnet Account
To deploy a contract, you need a testnet account. If you don't have one, you can create one using the following command:
# create-account using near-cli (contractId has end with .testnet)
near create <contractId> --useFaucet
Replace <contractId> with the name you want to give to your account, and make sure it ends with .testnet.
The account will be created with 10 NEAR (these are test tokens).
infoTestnet Faucet

Notice that we are using the `--useFaucet` flag to automatically request test tokens from the NEAR faucet. 

The faucet is only available on the testnet network - which is the default network for the CLI



Deploying the Contract
To deploy the contract, you need to compile the contract code into WebAssembly (WASM) and then deploy it to the network


    

    ```bash
    # compile the contract
    npm run build

    # deploy the contract
    near deploy  ./build/auction-contract.wasm

    # initialize the contract, it finishes in 2 minutes
    TWO_MINUTES_FROM_NOW=$(date -v+2M +%s000000000)
    near call  init '{"end_time": "'$TWO_MINUTES_FROM_NOW'", "auctioneer": ""}' --accountId 
    ```

    

    

    ```bash
    # compile the contract using cargo-near
    cargo near build

    # deploy the contract
    near deploy  ./target/near/auction-contract.wasm

    # initialize the contract, it finishes in 2 minutes
    TWO_MINUTES_FROM_NOW=$(date -v+2M +%s000000000)
    near call  init '{"end_time": "'$TWO_MINUTES_FROM_NOW'", "auctioneer": ""}' --accountId 
    ```

    


Replace <auctioneerId> with the name of another account, this should not be the same as the contract account as we intend on removing its keys.

Locking the contract
As mentioned previously we should lock the account by removing the keys. This allows our users to interact with the contract without having to trust the account owner.
near account delete-keys 

Next, specify the contract account and click the right arrow → to delete all the keys. Make sure you select testnet. 
::caution
Be extra careful to delete the keys from the correct account as you'll never be able to access the account again!
::

Now that the contract is deployed, initialized, and locked we can send transactions to it using the CLI. 
tipnteractive CLI
NEAR's CLI is interactive meaning you can type `near` and click through all the possible options without having to remember certain commands


Interacting with the Contract
We are now ready to start bidding by calling the bid function on the contract. We recommend that you create two new accounts to simulate different bidders.
# call the contract to bid 
near call <contractId> bid --accountId <bidderId> --amount 1 

# get the highest bid
near view <contractId> get_highest_bid
Notice that we call the bid function without arguments, but attach 1 NEAR to the transaction. This is the amount we are bidding.
For the get_highest_bid function, we don't need to specify which user is calling it, as it is a view function and does not require gas to be executed.

Conclusion
We have now seen how to deploy a contract to testnet and interact with it using the NEAR CLI.
A word of advice before moving forward. When people learn how to use the CLI, they get lazy and start testing new contract features directly on the testnet. While this is tempting, it is not recommended.
Do not use testnet as your only way to test contracts. Always test your contracts on the sandbox environment first, and only deploy to the testnet when you are confident that everything is working as expected.
tiprontend

Generally, you will use the CLI only to deploy and initialize the contract. Afterward, all interactions will be made from a frontend. This is why in the [next section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/auction/./2.1-frontend.md) we'll move on to creating a frontend to interact with the contract.

### Sandbox Testing

In the previous section, we went through the contract's code, analyzing how it worked. Now, we need to test it and make sure it works as expected! For contracts, there are two types of testing you can do: unit testing and sandbox testing.
Here, we will focus on sandbox testing, as it enables one to deploy the contract in a realistic environment, allowing us to create multiple accounts and interact with the contract as if it was deployed on the blockchain.
infounit testing

Unit tests are built into the language and are used to test the contract functions individually. These tests work well when little context is required. However, they cannot test chain interactions - like sending accounts $NEAR tokens - since they need to be processed by the network.



Account Creation
The first thing our test does is to create multiple accounts with 10 $NEAR tokens each and deploy the contract to one of them.

    
        

        To deploy the contract, we pass the path to the compiled WASM contract as an argument to the test in `package.json`. Indeed, when executing `npm run test`, the command will first compile the contract and then run the tests.

    
    
        

        Notice that the sandbox compiles the code itself, so we do not need to pre-compile the contract before running the tests.
    


Contract Initialization
To initialize, the contract's account calls itself, invoking the init function with an end_time set to 60 seconds in the future.


    

        

warning Time Units

The contract measures time in **nanoseconds**, for which we need to multiply the result of `Date.now()` (expressed in milliseconds) by `10^6`



    

    

        

warning Time Units

The contract measures time in **nanoseconds**, for which we need to multiply the result of `Utc::now().timestamp()` (expressed in seconds) by `10^9`



    

infoTime is a String

Notice that the time is passed as a `String` to the contract, this is because smart contracts cannot receive numbers larger than `52 bits` and we want to pass a `unix timestamp` in **nanoseconds**



Bidding
Now that the contract is deployed and initialized, we can start bidding and checking if the contract behaves as expected.
We first make alice place a bid of 1 NEAR, and check that the contract correctly registers the bid. Then, we have bob place a bid of 2 NEAR, and check that the highest bid is updated, and that alice gets her NEAR refunded.


    

        

    

    

        

    


Checking the balance
It is important to notice how we check if alice was refunded. We query her balance after her first bid, and then check if it has increased by 1 NEAR after bob makes his bid. 
You might be tempted to check if alice's balance is exactly 10 NEAR after she gets refunded, but alice balance cannot be 10 NEAR anymore, because some $NEAR was consumed as gas fees when alice called bid.
Testing invalid calls
When testing we should also check that the contract does not allow invalid calls. The next part checks that the contract doesn't allow for bids with fewer $NEAR tokens than the previous to be made.


    

        

    

    

        

    



Fast Forwarding Time
The sandbox allows us to fast-forward time, which is useful for testing the contract when the auction is over. The test advances 200 blocks in order to pass a minute, and thus allowing the auction to be claimed. 
After which the auction can now be claimed. Once claimed the test checks that the auctioneer has received the correct amount of $NEAR tokens.

    

        

    
    

        

    

If you review the tests in full you'll see that we also test other invalid calls such as the auctioneer trying to claim the auction before it is over and a user attempting to bid once the auction is over.

Executing the tests
Now that we understand what we are testing, let's go ahead and run the tests!


    

        ```bash
        # if you haven't already, install the dependencies
        npm install

        # run the tests
        npm run test 
        ```

    

    

        ```bash
        cargo test
        ```

    


All tests should pass, and you should see the output of the tests in the console. If you see any errors, please contact us in the NEAR Discord or through Telegram and we'll help you out!

Conclusion
In this part of the tutorial, we've seen how to use our sandbox testing environment to test the contract. We've tested the contract's initialization, bidding, and time advancement.
You are now ready to move to the next section, where we will deploy the contract to testnet and interact with it through the CLI.

### Basic Auction

In this section, we will analyze a simple auction contract, which allows users to place bids, track the highest bidder and claim tokens at the end of the auction. After, we will cover how to test the contract, as well as how to deploy it on testnet.
infoDocumentation

During this tutorial, we will be relying on the [Smart Contract Documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/quickstart.md) and its different sections


tiprerequisites

Make sure to read the [Prerequisites](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/3.tutorials/auction/./0-intro.md) section and install the necessary tools before starting this tutorial



Cloning the contract
To get started we'll clone the tutorial's repository from GitHub. The repository contains the same smart contracts written in JavaScript (./contract-ts) and Rust (./contract-rs).
Navigate to the folder of the language you prefer, and then to the 01-basic-auction folder.


  

  ```bash
  git clone git@github.com:near-examples/auctions-tutorial.git

  cd contract-ts/01-basic-auction
  ```

  

  

  ```bash
  git clone git@github.com:near-examples/auctions-tutorial.git

  cd contract-rs/01-basic-auction
  ```

  


infoFrontend

The repository also contains a frontend application that interacts with the contract. You can find it in the `frontends` folder. We will cover the frontend in a future section



The Contract's State
The contract allows users to place bids using $NEAR tokens and keeps track of the highest bidder. Lets start by looking at how we define the contract's state, this is, the data that the contract will store.


  

    

    #### Decorator
    The first thing to notice is that the main class of the contract is marked using the `@NearBindgen` decorator, which allows also to further specify that the contract **must be initialized** before being used.

    #### Storage (aka State)
    Another important information revealed by the code is that a contract can store different types of data, in this case:

    - `highest_bid` is an instance of a `Bid` which stores:
        - `bid`: a `BigInt` representing an amount of $NEAR tokens in `yoctonear` (`1Ⓝ = 10^24 yⓃ`)
        - `bidder`: an `AccountId` that represents which account placed the bid
    - `auction_end_time` a `BigInt` representing a `unix timestamp` in **nanoseconds**
    - `auctioneer` an `AccountId` that states who can withdraw the funds at the end of the auction
    - `claimed` a `boolean` that tracks if the auctioneer has claimed the funds

  

  

    

    #### Macros
    A first thing to notice is the use of the `#[near(contract_state)]` macro to denote the main structure and derive the `PanicOnDefault` to specify that the contract **must be initialized** before being used.

    We also use the `#[near(serializers = [json, borsh])]` macro to enable both `borsh` and `JSON` (de)serialization of the `Bid` structure. As a rule of thumb: use the `json` serializer for structs that will be used as input / output of functions, and `borsh` for those that will be saved to state.

    #### Storage (aka State)
    Another important information revealed by the code is that the contract can store different types of data.

    - `highest_bid` is an instance of a `Bid` which stores:
        - `bid`: a `NearToken` which simplifies handling $NEAR token amounts
        - `bidder`: the `AccountId` that placed the bid
    - `auction_end_time` is a `U64` representing a `unix timestamp` in **nanoseconds**
    - `auctioneer` an `AccountId` that states who can withdraw the funds at the end of the auction
    - `claimed` a `boolean` that tracks if the auctioneer has claimed the funds

  


tipearn More

You can read more about the contract's structure and the type of data it can store in the following documentation pages:
- [Basic Contract's Anatomy](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/anatomy.md)
- [Contract's State](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/storage.md)
- [Data Types](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/types.md)



Initialization Function
Lets now take a look at the initialization function, which we need to call to determine the time at which the auction will end.


  

    

    #### Decorator
    We denote the initialization function using the `@initialize({ privateFunction: true })` decorator. The `privateFunction:true` denotes that the function can only be called by the account on which the contract is deployed.

  

  

    

    #### Macros
    We denote the initialization function using the `#[init]` macro. Notice that the initialization function needs to return an instance of `Self`, i.e. the contract's structure.

    Meanwhile, the `#[private]` denotes that the function can only be called by the account on which the contract is deployed.

  


End Time
The end time is represented using a unix timestamp in nano seconds, and needs to be given as a String when calling the initialization function. This is because smart contracts cannot receive numbers larger than 52 bits and unix timestamps are represented in 64 bits.
Initial Bid
Notice that we initialize the contract with a 1 yoctonear bid, made from the current account id. This means that, after the contract is initialized, the first bid will be placed by the contract at 10^-24 NEAR.
Claimed
The claimed field is initialized as false, as the auctioneer has not claimed the funds yet.
Auctioneer
The auctioneer is set by the deployer on initialization and is the account that will be able to claim the funds at the end of the auction.
tipearn More

You can read more about the contract's interface in our [contract functions documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/functions.md), and learn about data types on the [data types documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/types.md).



Read-only Functions
The contract implements four functions to give access to its stored data, i.e. the highest bid so far (the amount and by whom), the time at which the auction ends, the auctioneer, and whether the auction has been claimed.


  

    

    Functions that do not change the contract's state (i.e. that only read from it) are called `view` functions, and are decorated using the `@view` decorator.

  

  

    

    Functions that do not change the contract's state (i.e. that only read from it) are called `view` functions and take a non-mutable reference to `self` (`&self`).

  


View functions are free to call, and do not require a NEAR account to sign a transaction in order to call them.
tipearn More

You can read more about the contract's interface in our [contract functions documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/functions.md), and learn about data types on the [data types documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/types.md).



Bidding Function
An auction is not an auction if you can't place a bid! For this, the contract includes a bid function, which users will call attaching some $NEAR tokens.
The function is quite simple: it verifies if the auction is still active and compares the attached deposit with the current highest bid. If the bid is higher, it updates the highest_bid and refunds the previous bidder.


  

    

  

  

    

  


Payable Functions
The first thing to notice is that the function changes the state, and thus is marked with a @call decorator in JS, while taking as input a mutable reference to self (&mut self) on Rust. To call this function, a NEAR account needs to sign a transaction and expend GAS.
Second, the function is marked as payable, this is because by default functions do not accept $NEAR tokens! If a user attaches tokens while calling a function that is not marked as payable, the transaction will fail.
The Environment
Notice that the function can access information about the environment in which it is running, such as who called the function (predecessor account), how many tokens they attached as deposit (attached deposit), and the approximate unix timestamp at which the function is executing (block timestamp).
Token Transfer
The function finishes by creating a Promise to transfer tokens to the previous bidder. This token amount will be deducted immediately and transferred in the next block after the current function has finished executing.
Note that on the first bid, the contract will send 1 yoctonear to itself, this is fine as we can safely assume that the contract will have the lowest denomination of $NEAR available to send to itself.


 Handling Funds 

When a user attaches tokens to a call, the tokens are deposited to the contract's account before the function is executed. However, if the function raises an error during its execution, the tokens are immediately refunded to the user.


tipearn More

You can read more about the environment variables, payable functions and which actions the contract can perform here:
- [Environment Variables](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/environment.md)
- [Payable Functions](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/functions.md)
- [Transfers and Actions](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/actions.md)



Claim function
You'll notice that the contract has a final function called claim, this allows the auctioneer to claim the funds from the contract at the end of the auction. Since, on NEAR, a smart contract account and user account are the same, contracts can still have keys when they are deployed, thus a user could just claim the funds from the contract via a wallet. However, this presents a security issue since by having a key the key holder can take the funds from the contract at any point, maliciously change the contract's state or just delete the contract as a whole. By implementing a claim function we can later lock the contract by removing all access keys and have the auctioneer claim the funds via preset conditions via code.


  

    

  

  

    

  


This function is quite simple it does four things:
1) Checks that the auction has ended (the current timestamp is past the auction end time).
2) Checks that the auction has not yet been claimed.
3) Sets the auction as now claimed.
4) And if these conditions hold true it transfers $NEAR equal to the highest bid to the auctioneer.
tipearn More

You can read more about locking contracts in this section of the documentation: [locked accounts](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/protocol/access-keys.md#locked-accounts)



Conclusion
In this part of the tutorial, we've seen how a smart contract stores data, mutates the stored data, and views the data. In the next part, we will cover how to test the contract, so we can ensure it works as expected before deploying it to testnet.

### Examples & Tutorials

Explore our collection of Examples and Tutorials

### What is Data Infrastructure?

NEAR offers ready-to-use solutions to access and monitor on-chain data easily. This is very useful to automate actions based on specific events, cache data to reduce latency, gather usage data of the blockchain, and even study user preferences.

In NEAR you will find three main solutions to access and monitor on-chain data: Data APIs, BigQuery Public Dataset and NEAR Lake. Each of these solutions is designed to fit different needs and use cases, and can be used in combination to create a complete data infrastructure for your application.

Data APIs
Members of the NEAR community have built a set of APIs to access and monitor on-chain data. These APIs are designed to be easy to use and can be accessed from any application through a simple API call.

User assets: Easily track all the assets that a user or a contract holds
Monitor transactions: Get all the transactions of a user, a contract or a specific token
Track on-chain events: Get all the events emitted by a contract, or a specific event type


BigQuery: Public Dataset
A large dataset with on-chain data publicly available on Google Cloud Platform. Obtain near real-time blockchain data using simple SQL queries. All the data, zero setup.

Instant insights: Historic on-chain data queried at scale. No need to run your own infrastructure.
Cost-effective: Eliminate the need to store and process bulk NEAR Protocol data. Query as little or as much data as you like.
As easy as SQL: No prior experience with blockchain technology is required. Just bring a general knowledge of SQL to unlock insights.


NEAR Lake
A solution that watches over the NEAR network and stores all the events for your easy access.

Cost-efficient solution: Cost-efficient solution for building self-hosted indexers in Rust, JavaScript, Python, Go and other languages
Streamlined data management: Use NEAR Lake Framework to stream blocks to your server directly from NEAR Lake


Conclusion
Data infrastructure is a key component of any blockchain application. It allows developers to access and monitor on-chain data easily, which is essential for building applications that interact with the blockchain.
NEAR offers a range of solutions to help developers build robust data infrastructure for their applications, including Data APIs, BigQuery Public Dataset, and NEAR Lake. By using these solutions in combination, developers can create a complete data infrastructure that meets their specific needs and use cases.

### Data APIs

Members of the NEAR community have built a set of APIs to access and monitor on-chain data. These APIs are designed to be easy to use and can be accessed from any application through a simple API call.

NearBlocks API: Query actions that happened on a NEAR account
FastNear API: Exposes low-latency APIs for wallets and explorers
The Graph: The Graph gives developers tools to process blockchain events and make the resulting data easily available via a GraphQL API, known individually as a subgraph. Graph Node is now able to process NEAR events, which means that NEAR developers can now build subgraphs to index their smart contracts.
PIKESPEAK API: an enterprise-grade API where you can fetch blockchain events and aggregated analytics on wallets, validators, delegators, money transfers, dapps activity and more. Documentation
Mintbase Indexer A highly efficient and adaptable indexing solution developed to capture, process, and store NFT events throughout the NEAR ecosystem. This indexer provides developers with a streamlined and well-structured data stream, making it an optimal choice for constructing data-centric applications in the NFT space. By systematically monitoring and indexing a wide array of NFT-related events across various platforms and projects on NEAR, the Mintbase Indexer offers developers the necessary tools and data access to build innovative and practical applications. Furthermore, the indexed data can be conveniently queried using GraphQL, allowing for flexible and efficient data retrieval tailored to specific developer needs. Documentation
SubQuery: SubQuery is a fast, flexible, and reliable open-source data indexer that provides you with custom APIs for your web3 project across NEAR and many other chains. NEAR developers will benefit from the superior SubQuery experience, including the open-source SDK, tools, documentation, and developer support that the SubQuery ecosystem provides. Additionally, NEAR is accommodated by SubQuery’s Managed Service, which provides enterprise-level infrastructure hosting.

tipWe only include some examples on how to use these APIs. For more information, check each project's documentation



NearBlocks API
The NearBlocks API provides a simple way to query actions that happened on a NEAR account, such as function calls, token transfers, etc
# All the times **anyone** called "create_drop" on Keypom
https://api.nearblocks.io/v1/account/v2.keypom.near/txns?method=create_drop

# All the times that gagdiez.near called "create_drop" on Keypom
https://api.nearblocks.io/v1/account/v2.keypom.near/txns?method=create_drop&from=gagdiez.near

   Response 

```json
{
  "txns": [
    {
      "predecessor_account_id": "gagdiez.near",
      "receiver_account_id": "v2.keypom.near",
      "receipt_kind": "ACTION",
      "receipt_outcome": {
        "status": true,
        ...
      },
      ...
    }
  ]
}
```


infoMore info

Find more information about the NearBlocks API in their [api page](https://api.nearblocks.io/api-docs/)



FastNear API
FastNear exposes low-latency APIs for wallets and explorers. Their API allows you to easily query the NEAR blockchain to get an account's assets, map keys into account IDs, explore a block's transactions, etc.
Blockchain Data
# Query last block produced
curl https://mainnet.neardata.xyz/v0/last_block/final

   Response 

```json
  {
    "block": {
      "author": "aurora.pool.near",
      "header": {
        "height": 129311487,
        "prev_height": 129311486,
        ...
      }
    }
  }
```


User Queries
# Query user's FTs
curl https://api.fastnear.com/v1/account/root.near/ft

# Query user's NFTs
curl https://api.fastnear.com/v1/account/root.near/ft

# Query all user's assets
curl https://api.fastnear.com/v1/account/root.near/full

   Response 

```json
  {
    "account_id": "root.near",
    "tokens": [
      { "balance": "199462092", "contract_id": "the-token.near" },
      ...
    ]
  }
```


infoMore info

Find more information about the FastNear API in their [services page](https://fastnear.com/services)

### BigQuery Public Dataset

Blockchain data indexing in NEAR Public Lakehouse is for anyone wanting to understand blockchain data. This includes:

Users: create queries to track NEAR assets, monitor transactions, or analyze on-chain events at a massive scale.
Researchers: use indexed data for data science tasks, including on-chain activities, identifying trends, or feeding AI/ML pipelines for predictive analysis.
Startups: can use NEAR's indexed data for deep insights on user engagement, smart contract utilization, or insights across tokens and NFT adoption.

Benefits:

NEAR instant insights: Historical on-chain data queried at scale.
Cost-effective: eliminate the need to store and process bulk NEAR protocol data; query as little or as much data as preferred.
Easy to use: no prior experience with blockchain technology is required; bring a general knowledge of SQL to unlock insights.

Getting started

Login into your Google Cloud Account.
Open the NEAR Protocol BigQuery Public Dataset.
Click in the VIEW DATASET button.
Click in the + to create a new tab and write your query, click in the RUN button, and check the Query results below the query.
Done :)

info
The NEAR Public Lakehouse repository contains the source code for ingesting NEAR Protocol data stored as JSON files in AWS S3 by NEAR Lake Indexer.

Example Queries

How many unique signers and accounts have interacted with my smart contract per day?

SELECT
  ra.block_date collected_for_day,
  COUNT(DISTINCT t.signer_account_id) as total_signers,
  COUNT(DISTINCT ra.receipt_predecessor_account_id) as total_accounts
FROM `bigquery-public-data.crypto_near_mainnet_us.receipt_actions` ra
  JOIN `bigquery-public-data.crypto_near_mainnet_us.receipt_origin_transaction` ro ON ro.receipt_id = ra.receipt_id
  JOIN `bigquery-public-data.crypto_near_mainnet_us.transactions` t ON ro.originated_from_transaction_hash = t.transaction_hash
WHERE ra.action_kind = 'FUNCTION_CALL'
  AND ra.receipt_receiver_account_id = 'social.near' -- change to your contract
GROUP BY 1
ORDER BY 1 DESC;
How much it costs?

NEAR pays for the storage and doesn't charge you to use the public dataset.

To learn more about BigQuery public datasets check this page.

Google GCP charges for the queries that you perform on the data. For example, in today's price "Sep 1st, 2023" the On-demand (per TB) query pricing is $6.25 per TB where the first 1 TB per month is free.

Check Google's pricing page for detailed pricing info, options, and best practices.


tipou can check how much data it will query before running it in the BigQuery console UI. Again, since BigQuery uses a columnar data structure and partitions, it's recommended to select only the columns and partitions (`block_date`) needed to avoid unnecessary query costs.


Architecture
The data is loaded in a streaming fashion using Databricks Autoloader into raw/bronze tables, and transformed with Databricks Delta Live Tables streaming jobs into cleaned/enriched/silver tables.
The silver tables are also copied into the GCP BigQuery Public Dataset.

info
Databricks Medallion Architecture.

Available Data
The current data that NEAR is providing was inspired by NEAR Indexer for Explorer.
infoNEAR plans to improve the data available in the NEAR Public Lakehouse making it easier to consume by denormalizing some tables.

The tables available in the NEAR Public Lakehouse are:

blocks: A structure that represents an entire block in the NEAR blockchain. Block is the main entity in NEAR Protocol blockchain. Blocks are produced in NEAR Protocol every second.
chunks: A structure that represents a chunk in the NEAR blockchain. Chunk of a Block is a part of a Block from a Shard. The collection of Chunks of the Block forms the NEAR Protocol Block. Chunk contains all the structures that make the Block: Transactions, Receipts, and Chunk Header.
transactions: Transaction is the main way of interaction between a user and a blockchain. Transaction contains: Signer account ID, Receiver account ID, and Actions.
execution_outcomes: Execution outcome is the result of execution of Transaction or Receipt. In the result of the Transaction execution will always be a Receipt.
receipt_details: All cross-contract (we assume that each account lives in its own shard) communication in Near happens through Receipts. Receipts are stateful in a sense that they serve not only as messages between accounts but also can be stored in the account storage to await DataReceipts. Each receipt has a predecessor_id (who sent it) and receiver_id the current account.
receipt_origin: Tracks the transaction that originated the receipt.
receipt_actions: Action Receipt represents a request to apply actions on the receiver_id side. It could be derived as a result of a Transaction execution or another ACTION Receipt processing. Action kind can be: ADD_KEY, CREATE_ACCOUNT, DELEGATE_ACTION, DELETE_ACCOUNT, DELETE_KEY, DEPLOY_CONTRACT, FUNCTION_CALL, STAKE, TRANSFER.
receipts (view): It's recommended to select only the columns and partitions (block_date) needed to avoid unnecessary query costs. This view join the receipt details, the transaction that originated the receipt and the receipt execution outcome.
account_changes: Each account has an associated state where it stores its metadata and all the contract-related data (contract's code + storage).

infoAdditional information about the data

- Skipped Blocks: NEAR Blockchain can contain skipped blocks, e.g. block `57730443`. For these cases we can find the block for the chunk data using the `prev_block_hash` column, e.g. `SELECT * FROM chunks c JOIN blocks b ON c.chunk.header.prev_block_hash = b.header.prev_hash`.


noteReferences

- [Protocol documentation](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/basics/protocol.md)
- [Near Data flow](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/data-flow/near-data-flow.md)
- [Lake Data structures](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/6.data-infrastructure/./lake-data-structures/toc.mdx)
- [Protocol specification](https://nomicon.io/)

### What are Primitives?

Primitives are fundamental building blocks that can be combined to create a fully functional application. Blockchain primitives include Fungible Tokens (FT), Non Fungible Tokens (NFT), Decentralized Autonomous organizations (DAO), Link Drops and more.


Fungible Tokens (FT)
Fungible tokens represent an asset on a blockchain that is interchangeable. Besides the native NEAR token, users can issue their own fungible tokens or use those that are already present in the ecosystem.
tipungible Tokens are ideal to create **reward systems**, **fair tickets** and any other type of **token**.


Non Fungible Tokens (NFT)
In contrast with fungible tokens, each non-fungible token (NFT) is unitary and therefore unique. Users can create their own non-fungible token, transfer to other users, or exchange them in marketplaces.
tipFTs are ideal to represent **ownership of assets** such as **collectibles**, **event tickets** and other unique assets.


Decentralized Autonomous organizations (DAO)
Decentralized Autonomous Organizations (DAOs) are self-organized groups that form around common purposes. Membership, decision making, and funding are coordinated by publicly voting on proposals through a smart contract.
tipAOs are ideal to create **decentralized governance**, **funding**, and **decision-making** tools.


LinkDrops
LinkDrops are an easy way to distribute digital assets (NFTs, FTs) via links. You simply provide a link for users and they can claim your drop.
tipinkDrops are ideal to do **drops**, and **onboard new users** into Web3 apps.

### Oracles

Blockchain Oracles serve as intermediaries that connect smart contracts with external (off-chain) data.
Example:

Price Feeds: Real-time pricing for cryptocurrencies, stocks, or commodities.
Event Information: Updates on real-world events like sports results or weather conditions.
API Access: Connections to external web services and systems.

infoOracles, being external third-party services, require careful consideration of their reliability, security, and decentralization to avoid risks such as incorrect data, manipulation, or single points of failure.


Deployed Oracles on NEAR
Here is a directory of third-party oracle services deployed on the NEAR blockchain:



Name
Creator
Description




Price Oracle
NearDefi
Open source oracle for real-time asset pricing


Pyth Network Oracle
Pyth Network
High-frequency, low-latency oracle for price feeds


[Your Project Here]
-
-




Price Oracle by NearDefi

Creator: NearDefi
Codebase Repository: NearDefi/price-oracle
Bot for Data Feeds: NearDefi/near-price-oracle-bot
Deployed Addresses:

Mainnet: priceoracle.near
Testnet: priceoracle.testnet


Query Assets

  

```bash
near view priceoracle.near get_assets
near contract call-function as-read-only priceoracle.near get_assets json-args {} network-config mainnet now
```

  

  Example Response

```json
[
  [
    'wrap.near',
    {
      reports: [
        {
          oracle_          timestamp: '1669795900809627816',
          price: { multiplier: '17030', decimals: 28 }
        },
        ...
      ]
    }
  ]
]
```

  


Get Assets Price

  

```bash
near view priceoracle.near get_price_data
```






Example response

```json
{
  timestamp: '1706631861981947371',
  recency_duration_sec: 90,
  prices: [
    {
      asset_      price: { multiplier: '30702', decimals: 28 }
    },
    {
      asset_      price: { multiplier: '235662', decimals: 20 }
    },
    {
      asset_      price: { multiplier: '38770', decimals: 28 }
    },
    {
      asset_      price: { multiplier: '36432', decimals: 28 }
    },
```


tipor USD values, divide the `multiplier` by `10^4`.


Pyth Network Oracle

Creator: Pyth Network
Official Documentation: Pyth NEAR Docs
Codebase Repository: pyth-network/pyth-crosschain
Deployed Addresses:

Mainnet: pyth-oracle.near
Testnet: pyth-oracle.testnet



Using Pyth Network Oracle

Pyth Network's NEAR smart contract has two core methods to update & get price feeds of your choice.


update_price_feeds
(updates Pyth smart contract with the price feed you provide)

args: data
type: object
example: { "data": "504e41...' }

get_price (fetches the most recent price stored in the contract)_

args: price_identifer
type: object
example: { price_identifier: 'f9c0172ba10dfa8...' }


infoFor a complete list of endpoints to interact with, see [Pyth's `receiver` contract](https://github.com/pyth-network/pyth-crosschain/blob/main/target_chains/near/receiver/src/ext.rs).

Getting Started
To get started with Pyth oracle you will need to gather the following information which differ between networks:

Price ID(s)
HermesAPI Endpoint
Smart contract address




Network
Price Feed IDs
Hermes API Address
Contract Address




testnet
NEAR testnet Price Feed IDs
hermes-beta.pyth.network
pyth-oracle.testnet


mainnet
NEAR mainnet Price Feed IDs
hermes.pyth.network
pyth-oracle.near



info
When using Price Feed IDs, you will need to remove the 0x prefix.
Price Feed ID Example (testnet):



update_price_feeds

Updates the Pyth Oracle contract data with the price feed you provide.


args: data (off-chain hex-encoded price feed)
type: object
example: { "data": "504e41...' }

Update the Pyth Oracle contract with new price feed data in two main steps:

Fetch off-chain price feed
Update Pyth Oracle contract with off-chain price feed

1) Fetching off-chain price feed
You can obtain an off-chain price feed using Pyth's Hermes API.
To use these endpoints, you will need to provide a Price Feed ID and ensure you are targeting the correct network. See Getting Started for more information.
Here is a node.js example of fetching the latest price feed using /v2/updates/price/latest endpoint:

  

2) Update Pyth Oracle Contract Price Feed
After fetching an off-chain price feed, you can now perform a contract call to the Pyth Oracle to update the price feed on-chain.
Call update_price_feeds on the Pyth Oracle contract with data as your arguments.
example args:
{
  "data": "504e41550100000000a00100000000010070b0ee3a00d1a3c07ee440887eb34a5a35860e6f4b9230fd62f0593fe35c8a3561735a6a37d269c5f166b84ead8918f710dc1be2ee6b51db5b22340ea2c173fc01673d544b00000000001ae101faedac5851e32b9b23b5f9411a8c2bac4aae3ed4dd7b811dd1a72ea4aa7100000000061bc18c014155575600000000000ab0f04600002710f41bc8c224ed983c68dbf5dab7dd34c9129fecfa03005500ca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a600000047e2eb4ef0000000000692480ffffffff800000000673d544b00000000673d544b00000048200e66a00000000005e495a60bb9370c458dd50558b34699b5b179f45e56be22f0a1a0feb1db8469adc8c5efeb53988495bac07bf9efed07f5eee43818150c55055882f6872a228e8e9bc78459ed3ea7fe0b86f3048f6bf0aad34befc46063ab7d200beb8bc9fe5839844d2233546f0742bb665f1e610370fcf8ce5be83d0f47e584b685af87cf3ebcb79e714827dcb99dba579e1a03785052ab3c7c7147d3f7bba822b04dbda159670e9a8d29e7ccf68474b2ca85e00224d29bf65b06b09f95e91703313e053b697b48ac1e4d1c57605a71ab77e7ef276bfe8a369c268333b9a37461bf2b7cb7fd4c005500ecf553770d9b10965f8fb64771e93f5690a182edc32be4a3236e0caaa6e0581a0000000e2ba8cd280000000001b40517fffffff800000000673d544b00000000673d544b0000000e3ea44c6800000000016aee120b47b853f55949284cb8ba0b63824ff9b48cd1da8417f45421b79ee3195fc8d107540a0bbb95c2445b66065754f135cb842db09a7e7ab33f79c546a48db872bd7197b04e3d7b52fbb55b3b9f51707c5a55fac3707cb563dbcde4aadeecc3649c237454cecf519dc567c0da03d81808523aa4fa71815eab25ce7da61b48647bac645d403208135002aab5fde2d7ab3c7c7147d3f7bba822b04dbda159670e9a8d29e7ccf68474b2ca85e00224d29bf65b06b09f95e91703313e053b697b48ac1e4d1c57605a71ab77e7ef276bfe8a369c268333b9a37461bf2b7cb7fd4c"
}
Example of updating the Pyth Oracle contract's price feed using near-js/client and node.js:

  
  
  

info
Although unused deposit will be refunded, you can calculate an estimate by calling the get_update_fee_estimate method against the Pyth contract.


get_price

Fetches the most recent price feed stored in the Pyth Oracle contract. Is a view method, so does not require a signature or payment.


args: price_identifier (unique price feed identifier)
type: object
example: { price_identifier: 'f9c0172ba10dfa8...' }

After updating the price feed, you can view the feed on-chain by calling get_price on the Pyth Oracle contract. Note that this is a view method and does not require a signature or deposit.
Example:

### Non-Fungible Tokens (NFT)

In contrast with fungible tokens, non-fungible tokens (NFT) are unitary and therefore unique. This makes NFTs ideal to represent ownership of assets such as a piece of digital content, or a ticket for an event.
As with fungible tokens, NFTs are not stored in the user's wallet, instead, each NFT lives in a NFT contract. The NFT contract works as a bookkeeper, this is: it is in charge of handling the creation, storage and transfers of NFTs.
In order for a contract to be considered a NFT-contract it has to follow the NEP-171 and NEP-177 standards. The NEP-171 & NEP-177 standards explain the minimum interface required to be implemented, as well as the expected functionality.
infoNFT & Marketplaces

Be mindful of not confusing an NFT with an NFT-marketplace. NFT simply store information (metadata), while NFT-marketplaces are contracts where NFT can be listed and exchanged for a price.



Community Projects
The easiest way to create and handle NFTs is by using one of the existing community projects.

Paras - a classic NFT marketplace. Just login with your NEAR account, create a collection and share the link with your community.
Mintbase - a marketplace that allows to create NFT collections, and buy NFTs using credit cards or stablecoins.
Enleap - a no-code launchpad for NFTs. Provides NFT minting, staking, whitelist managing, tracking functionality.


Deploying a NFT Contract
If you want to deploy your own NFT contract, you can create one using our reference implementation 
Simply personalize it and deploy it to your account.
near deploy <account-id> --wasmFile contract.wasm --initFunction new
tipCheck the [Contract Wizard](https://dev.near.org/contractwizard.near/widget/ContractWizardUI) to create a personalized NFT contract!.



Minting a NFT
To create a new NFT (a.k.a. minting it) you will call the nft_mint method passing as arguments the metadata that defines the NFT.

  
    
  
  
    
  
  
    
  
  
    
  

info
See the metadata standard for the full list of TokenMetadata parameters.

warning
Values of gas and deposit might vary depending on which NFT contract you are calling.


Minting Collections
Many times people want to create multiple 100 copies of an NFT (this is called a collection). In such cases, what you actually need to do is to mint 100 different NFTs with the same metadata (but different token-id).
tipNotice that [minting in Mintbase](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/5.primitives/#minting-a-nft) allows you to pass a `num_to_mint` parameter.



Royalties
You might have noticed that one of the parameters is a structure called royalties. Royalties enable you to create a list of users that should get paid when the token is sell in a marketplace. For example, if anna has 5% of royalties, each time the NFT is sell, anna should get a 5% of the selling price.

Querying NFT data
You can query the NFT's information and metadata by calling the nft_token.

  
    
  
  
    
  
  
    
  
  
    
  


Transferring a NFT
Transferring an NFT can happen in two scenarios: (1) you ask to transfer an NFT, and (2) an authorized account asks to transfer the NFT.
In both cases, it is necessary to invoke the nft_transfer method, indicating the token id, the receiver, and an (optionally) an approval_id.

  
    
  
  
    
  
  
    
  
  
      
  


Attaching NFTs to a Call
Natively, only NEAR tokens (Ⓝ) can be attached to a function calls. However, the NFT standard enables to attach a non-fungible tokens in a call by using the NFT-contract as intermediary. This means that, instead of you attaching tokens directly to the call, you ask the NFT-contract to do both a transfer and a function call in your name.

  

```bash
near call  nft_transfer_call '{"receiver_id": "", "token_id": "", "msg": ""}' --accountId  --depositYocto 1
```




info
Optionally, a memo parameter can be passed to provide more information to your contract.


How Does it Work?
Assume you want to attach an NFT (🎫) to a call on the receiver contract. The workflow is as follows:

You call nft_transfer_call in the NFT-contract passing: the receiver, a message, and the token-id of 🎫.
The NFT contract transfers the NFT 🎫 to the receiver.
The NFT contract calls receiver.nft_on_transfer(sender, token-owner, token-id, msg).
The NFT contract handles errors in the nft_resolve_transfer callback.
The NFT contract returns true if it succeeded.

The nft_on_transfer method
From the workflow above it follows that the receiver we want to call needs to implement the nft_on_transfer method. When executed, such method will know:

Who is sending the NFT, since it is a parameter
Who is the current owner, since it is a parameter
Which NFT was transferred, since it is a parameter.
If there are any parameters encoded as a message

The nft_on_transfer must return true if the NFT has to be returned to the sender.

Approving Users
You can authorize other users to transfer an NFT you own. This is useful, for example, to enable listing your NFT in a marketplace. In such scenario, you trust that the marketplace will only transfer the NFT upon receiving a certain amount of money in exchange.

  

```bash
near call  nft_approve '{
"token_id": "",
"account_id": "",
"msg": ""
}' --accountId  --depositYocto 1
```




info
If the msg parameter is included, then a cross-contract call will be made to <authorized_account>.nft_on_approve(msg). Which in turn will make a callback to nft_resolve_transfer in your NFT contract.


List a NFT for sale
Basic NFT contracts following the NEP-171 and NEP-177 standards do not implement marketplace functionality.
For this purpose, there are ecosystem apps such as Paras or Mintbase, that use dedicated marketplace contracts.
In order to put a NFT for a sale on a marketplace you need to do two actions: 

Cover data storage costs in the marketplace contract. 
Approve the marketplace to sell the NFT in your NFT contract.



  
    
  
  
    
  
  
    
  


Buy a NFT
Basic NFT contracts following the NEP-171 and NEP-177 standards do not implement marketplace functionality.
For this purpose, there are ecosystem apps such as Paras or Mintbase, that use dedicated marketplace contracts.

  
    
  
  
    
  
  
    
  
  
    
  


Additional Resources

NFT Tutorial (NEAR examples, JavaScript SDK) - a set of tutorials that cover how to create a NFT contract using JavaScript.
NFT Tutorial (NEAR examples, Rust SDK) - a set of tutorials that cover how to create a NFT contract using Rust.
NFT Tutorial by Keypom (a fork of the NEAR example tutorial).
Paras API documentation.
Mintbase API documentation.
Mintbase JS SDK - a set of methods to get data from blockchain, interact with Mintbase contracts, etc.

### Linkdrops

Linkdrops allow users to distribute assets and onboard people to Web3 apps through a simple web link.

They work by storing assets and linking AccessKeys to them. The AccessKeys are then distributed to users in the form of web links. These links take users to a website that automatically uses the keys to call the claim method in the linkdrop contract.
In order for a contract to be considered a Linkdrop-contract it has to follow the NEP-452 standard. The NEP-452 explains the minimum interface required to be implemented, as well as the expected functionality.

Keypom
The simplest way to create Linkdrops is by using Keypom. Keypom is a community project that allows you to create Linkdrops for NEAR tokens and NFTs in a few clicks.


AccessKeys
In order to create any kind of drop, you need to first generate key pairs. You will need to create one key per drop.

The linkdrop contract will store the public part of the key.
You will give the private part of the key to the user you want to receive the drop.


  





```js
const dropsNumber = "2";
const keysGeneratorUrl = "https://keypom.sctuts.com/keypair/";
const rootEntrophy = "my-password"; //If not provided, the keypair will be completely random. see: https://docs.keypom.xyz/docs/next/keypom-sdk/Core/modules
asyncFetch(keysGeneratorUrl + dropsNumber + "/" + rootEntrophy).then((res) => {
  const keyPairs = JSON.parse(res.body);
  const pubKeys = [];
  const privKeys = [];

  keyPairs.forEach((e) => {
    pubKeys.push(e.pub);
    privKeys.push(e.priv);
  });

  const obj = {
    publicKeys: pubKeys,
    privKeys: privKeys,
  };

  State.update(obj);
});
```





  
  





```js

const newKeyPair = KeyPair.fromRandom('ed25519');
newKeyPair.public_key = newKeyPair.publicKey.toString();
```





```js
const state = {};

const dropsNumber = "2";
const keysGeneratorUrl = "https://keypom.sctuts.com/keypair/";

fetch(keysGeneratorUrl + dropsNumber + "/rootEntrophy").then((res) => {
  const keyPairs = JSON.parse(res.body);
  const pubKeys = [];
  const privKeys = [];

  keyPairs.forEach((e) => {
    pubKeys.push(e.pub);
    privKeys.push(e.priv);
  });

  state.publicKeys = pubKeys;
  state.privKeys = privKeys;
});
```





  
  





```bash
# This command creates a key pair locally in .near-credentials with an implicit account as the accountId (hash representation of the public key)

near generate-key
```

**Example response:**

```bash
Key pair with ed25519:33Vn9VtNEtWQPPd1f4jf5HzJ5weLcvGHU8oz7o5UnPqy public key for an account "1e5b1346bdb4fc5ccd465f6757a9082a84bcacfd396e7d80b0c726252fe8b3e8"
```





```bash
export NUMBER_OF_DROPS=2

curl https://keypom.sctuts.com/keypair/$NUMBER_OF_DROPS/rootEntrophy
```





  


$NEAR Drops
To create a $NEAR drop you will ask the contract to create a drop (create_drop), passing the public part of the keys you generated, and how much you want to drop on each key use (deposit_per_use).
The contract will create a drop and return the numerical ID that identifies it.

  

```js
const keypomContract = "v2.keypom.near";
const dropAmount = "10000000000000000000000";

Near.call([
  {
    contractName: keypomContract,
    methodName: "create_drop",
    args: {
      public_keys: state.publicKeys,
      deposit_per_use: dropAmount,
    },
    deposit: "23000000000000000000000", // state.publicKeys.length * dropAmount + 3000000000000000000000,
    gas: "100000000000000",
  },
]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const DROP_AMOUNT = "10000000000000000000000"; // 0.1 NEAR

const wallet = new Wallet({ createAccessKeyFor: KEYPOM_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "create_drop",
  contractId: KEYPOM_CONTRACT_ADDRESS,
  args: {
    public_keys: state.publicKeys,
    deposit_per_use: DROP_AMOUNT,
  },
  deposit: "23000000000000000000000" // state.publicKeys.length * dropAmount + 3000000000000000000000,
  gas: "100000000000000",
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call v2.keypom.near create_drop '{"public_keys": , "deposit_per_use": "10000000000000000000000"}' --depositYocto 23000000000000000000000 --gas 100000000000000 --accountId bob.near
```

  

infoTo claim the drop, you will need to send the user a [link with the private key](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/5.primitives/#building-drop-links)


NFT Drops
To drop an existing NFT, you will (1) create a drop, and then (2) transfer the NFT to keypom.
1. Creating the Drop
To create an NFT drop, you will call the create_drop method, now passing a nft argument, which will tell the linkdrop contract to wait for an NFT to be transferred.
The contract will then create a drop and return the numerical ID that identifies it.

  

```js
const accountId = context.accountId ?? props.accountId;
const keypomContract = "v2.keypom.near";
const nftContract = "nft.primitives.near";
const dropAmount = "10000000000000000000000";

 Near.call([
  {
    contractName: keypomContract,
    methodName: "create_drop",
    args: {
      public_keys: state.publicKeys,
      deposit_per_use: dropAmount,
      nft: {
        // Who will be sending the NFTs to the Keypom contract
        sender_        // NFT Contract Id that the tokens will come from
        contract_      },
    },
    deposit: "23000000000000000000000" // state.publicKeys.length * dropAmount + 3000000000000000000000,
    gas: "100000000000000",
  },
]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const NFT_CONTRACT_ADDRESS = "nft.primitives.near";
const DROP_AMOUNT = "10000000000000000000000";

const keypomConnectedWallet = new Wallet({ createAccessKeyFor: KEYPOM_CONTRACT_ADDRESS });
const nftConnectedWallet = new Wallet({ createAccessKeyFor: NFT_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "create_drop",
  contractId: KEYPOM_CONTRACT_ADDRESS,
  args: {
    public_keys: state.publicKeys,
    deposit_per_use: DROP_AMOUNT,
    nft: {
      // Who will be sending the NFTs to the Keypom contract
      sender_      // NFT Contract Id that the tokens will come from
      contract_    },
  },
  deposit: "23000000000000000000000" // state.publicKeys.length * dropAmount + 3000000000000000000000,
  gas: "100000000000000",
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call v2.keypom.near create_drop '{"public_keys": , "deposit_per_use": "10000000000000000000000", "nft": {"sender_id": "bob.near", "contract_id": "nft.primitives.near"}}' --depositYocto 23000000000000000000000 --gas 100000000000000 --accountId bob.near
```

  

2. Transferring the NFT
Having the Drop ID, you now need to transfer the NFT to the linkdrop contract, specifying to which drop you want to add it.

  

```js
const nftTokenId = "1";

Near.call([{
  contractName: nftContract,
  methodName: 'nft_transfer_call',
  args: {
    receiver_    token_    msg: dropId.toString()
  },
  deposit: "1",
  gas: "300000000000000"
}]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const NFT_CONTRACT_ADDRESS = "nft.primitives.near";
const NFT_TOKEN_ID = "1";
const DROP_AMOUNT = "10000000000000000000000";

const nftConnectedWallet = new Wallet({ createAccessKeyFor: NFT_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "nft_transfer_call",
  contractId: NFT_CONTRACT_ADDRESS,
  args: {
    receiver_    token_    msg: dropId.toString()
  },
  deposit: 1,
  gas: "100000000000000",
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call nft.primitives.near nft_transfer_call '{"receiver_id": "v2.keypom.near", "token_id": , "msg": }' --depositYocto 1 --gas 100000000000000 --accountId bob.near
```

  

tiphe `linkdrop` contract will validate that you are transferring the NFT to a drop that belongs to you


FT Drops
The process to drop a Fungible Token is very similar to that of creating an NFT drop. You will first create the drop, and then fund it with FTs.
1.Creating a drop
To create a FT drop you will call the create_drop method, now passing a ftData argument, which will tell the linkdrop contract to wait for a certain amount of FT to be transferred.
The contract will then create a drop and return the numerical ID that identifies it.

  

```js
const keypomContract = "v2.keypom.near";
const ftContract = "ft.primitives.near";
const dropAmount = "10000000000000000000000";

Near.call([
  {
    contractName: keypomContract,
    methodName: "create_drop",
    args: {
      public_keys: state.publicKeys,
      deposit_per_use: dropAmount,
      ftData: {
            contractId: ftContract,
            senderId: accountId,
            // This balance per use is balance of human readable FTs per use.
            amount: "1"
        // Alternatively, you could use absoluteAmount, which is dependant on the decimals value of the FT
        // ex. if decimals of an ft = 8, then 1 FT token would be absoluteAmount = 100000000
        },
    },
    deposit: "23000000000000000000000", // state.publicKeys.length * dropAmount + 3000000000000000000000,
    gas: "100000000000000"
  },
]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const FT_CONTRACT_ADDRESS = "ft.primitives.near";
const DROP_AMOUNT = "10000000000000000000000";

const wallet = new Wallet({ createAccessKeyFor: KEYPOM_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "create_drop",
  contractId: KEYPOM_CONTRACT_ADDRESS,
  args: {
    public_keys: state.publicKeys,
    deposit_per_use: DROP_AMOUNT,
    ftData: {
      contractId: FT_CONTRACT_ADDRESS,
      senderId: accountId, // TODO How to get account id
      // This balance per use is balance of human readable FTs per use.
      amount: "1"
      // Alternatively, you could use absoluteAmount, which is dependant on the decimals value of the FT
      // ex. if decimals of an ft = 8, then 1 FT token would be absoluteAmount = 100000000
    },
  },
  deposit: "23000000000000000000000" // state.publicKeys.length * dropAmount + 3000000000000000000000,
  gas: "100000000000000",
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call v2.keypom.near create_drop '{"public_keys": , "deposit_per_use": "10000000000000000000000", "ftData": {"contractId": "ft.primitives.near","senderId": "bob.near", "amount": "1"}}}' --depositYocto 23000000000000000000000 --gas 100000000000000 --accountId bob.near
```

  

2. Transferring FT
Having the Drop ID, you now need to transfer the fungible tokens to the linkdrop contract.
noteTo transfer FTs to an account, you need to first [register](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/5.primitives/./ft#registering-a-user) the receiver account (e.g. the keypom contract) on the FT contract.


  

```js
Near.call([
  {
    contractName: ftContract,
    methodName: "ft_transfer",
    args: {
      receiver_      amount: "1",
    },
    deposit: "1",
    gas: "300000000000000",
  },
]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const FT_CONTRACT_ADDRESS = "ft.primitives.near";

const wallet = new Wallet({ createAccessKeyFor: FT_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "ft_transfer",
  contractId: FT_CONTRACT_ADDRESS,
  args: {
    receiver_    amount: "1"
  },
  deposit: "1",
  gas: "100000000000000"
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call ft.primitives.near ft_transfer '{"receiver_id": "v2.keypom.near", "amount": "1"}' --depositYocto 1 --gas 100000000000000 --accountId bob.near
```

  


Function Call Drop
Linkdrop contracts allow to create function call drops. These drops will execute one or more methods on a contract when the user claims the drop.
tipunction call drops can be thought as the abstract version of other drops: you can create a drop that will mint an NFT, register a user in a DAO, or pay for a service.


  

```js
const accountId = context.accountId ?? props.accountId;
const keypomContract = "v2.keypom.near";
const nftContract = "nft.primitives.near";
const nftTokenId = "1";
const dropAmount = "10000000000000000000000";

Near.call([
  {
    contractName: keypomContract,
    methodName: "create_drop",
    args: {
      public_keys: state.publicKeys,
      deposit_per_use: dropAmount,
      fcData: {
        // 2D array of function calls. In this case, there is 1 function call to make for a key use
        // By default, if only one array of methods is present, this array of function calls will be used for all key uses
        methods: [
          // Array of functions for Key use 1.
            [{
              receiverId: nftContract,
              methodName: "nft_mint",
              args: JSON.stringify({
              // Change this token_id if it already exists -> check explorer transaction
                  token_                  metadata: {
                     "My NFT drop",
                    description: "",
                    media: "",
                  }
              }),
              accountIdField: "receiver_id",
              // Attached deposit for when the receiver makes this function call
              attachedDeposit: "10000000000000000000000"
            }]
        ]
      }
    },
    deposit: "23000000000000000000000", // state.publicKeys.length * dropAmount + 3000000000000000000000,
    gas: "100000000000000",
  },
]);
```

  
  

```js

const KEYPOM_CONTRACT_ADDRESS = "v2.keypom.near";
const NFT_CONTRACT_ADDRESS = "nft.primitives.near";
const NFT_TOKEN_ID = "1";
const DROP_AMOUNT = "10000000000000000000000";

const wallet = new Wallet({ createAccessKeyFor: DAO_CONTRACT_ADDRESS });

await wallet.callMethod({
  method: "create_drop",
  contractId: KEYPOM_CONTRACT_ADDRESS,
  args: {
    public_keys: state.publicKeys,
    deposit_per_use: DROP_AMOUNT,
    fcData: {
      // 2D array of function calls. In this case, there is 1 function call to make for a key use
      // By default, if only one array of methods is present, this array of function calls will be used for all key uses
      methods: [
        // Array of functions for Key use 1.
          [{
            receiverId: NFT_CONTRACT_ADDRESS,
            methodName: "nft_mint",
            args: JSON.stringify({
            // Change this token_id if it already exists -> check explorer transaction
                token_                metadata: {
                   "My NFT drop",
                  description: "",
                  media: "",
                }
            }),
            accountIdField: "receiver_id",
            // Attached deposit for when the receiver makes this function call
            attachedDeposit: "10000000000000000000000"
          }]
      ]
    }
  },
  deposit: "23000000000000000000000" // state.publicKeys.length * dropAmount + 3000000000000000000000,
  gas: "100000000000000",
});
```

_The `Wallet` object comes from our [quickstart template](https://github.com/near-examples/hello-near-examples/blob/main/frontend/src/wallets/near.js)_

  
  

```bash
near call v2.keypom.near create_drop '{"public_keys": , "deposit_per_use": "10000000000000000000000", "fcData": {"methods": [[{"receiverId": "nft.primitives.near","methodName": "nft_mint","args": {"token_id": "1", "metadata": {"title": "My NFT drop","description": "","media": ""}, "accountIdField": "receiver_id", "attachedDeposit": "10000000000000000000000"}]]}}' --depositYocto 23000000000000000000000 --gas 100000000000000 --accountId bob.near
```

  


Building drop links
const getLinks = () => {
  const links = [];

  // It assumes that private keys have been already stored in State by using State.init() and State.update() method
  state.privKeys.map((e, i) => {
    const link =
      "https://app.mynearwallet.com" + "/linkdrop/v2.keypom.near/" + e;
    links.push(link);
  });

  return links;
};

Example response


```js
[
  'https://app.mynearwallet.com/linkdrop/v2.keypom.near/ed25519:2H32THYM8ob336yk81cZUxpidvKi34zLck6a97ypmCY8bbSAuEfrCTu9LWmWGiG9df2C6vkg2FGKGZzY9qE4aEcj',
  'https://app.mynearwallet.com/linkdrop/v2.keypom.near/ed25519:3eoMcqKmmY9Q6qgBy3hZy65HisZ8NXQd9aGGYUGe6RRsmNpGJS5YN64MgZaBVVYJJhbFXhQ2ca3DRRBiKh1rYM48'
]
```




noteIf you didn't save your linkdrop links before closing NEAR App, you can always find them on [Keypom app](https://keypom.xyz/drops).


Additional Resources

Linkdrop plus allows to create a Simple Drop. Powered by Keypom
Keypom Drop Viewer shows drops created by current logged in user.

### Fungible Tokens (FT)

Besides the native NEAR token, NEAR accounts have access to a multitude of tokens to use throughout the ecosystem. Moreover, it is even possible for users to create their own fungible tokens.
In contrast with the NEAR native token, fungible token (FT) are not stored in the user's account. In fact, each FT lives in their own contract which is in charge of doing bookkeeping. This is, the contract keeps track of how many tokens each user has, and handles transfers internally.

In order for a contract to be considered a FT-contract it has to follow the NEP-141 and NEP-148 standards. The NEP-141 & NEP-148 standards explain the minimum interface required to be implemented, as well as the expected functionality.

Token Factory Tool
You can create an FT using the toolbox on Dev Portal. The FT Tool is a token factory, you can interact with it through graphical interface, or by making calls to its contract.

  
    
  
  
    
  
  
    
  

The FT you create will live in the account <your_token_symbol>.tkn.primitives.near (e.g. test.tkn.primitives.near).

Deploying Your Own Contract
You can also create a fungible token by deploying and initializing a canonical FT contract.
On initialization you will define the token's metadata such as its name (e.g. Ethereum), symbol (e.g. ETH) and total supply (e.g. 10M). You will also define an owner, which will own the tokens total supply.
To initialize a FT contract you will need to deploy it and then call the new method defining the token's metadata.
cargo near deploy <account-id> with-init-call new json-args '{"owner_id": "<owner-account>", "total_supply": "1000000000000000", "metadata": { "spec": "ft-1.0.0", "name": "Example Token Name", "symbol": "EXLT", "decimals": 8 }}' prepaid-gas '100.0 Tgas' attached-deposit '0 NEAR' network-config testnet sign-with-keychain send
tipheck the [Contract Wizard](https://dev.near.org/contractwizard.near/widget/ContractWizardUI) to create a personalized FT contract!.


Querying Metadata
You can query the FT's metadata by calling the ft_metadata.

  
    
  
  
    
  
  
    
  


Checking Balance
To know how many coins a user has you will need to query the method ft_balance_of.

  
    
  
  
    
  
  
    
  


Registering a User
In order for an user to own and transfer tokens they need to first register in the contract. This is done by calling storage_deposit and attaching 0.00125Ⓝ.
By calling this storage_deposit the user can register themselves or register other users.

  
    
  
  
    
  
  
    
  

infoYou can make sure a user is registered by calling `storage_balance_of`.

tipfter a user calls the `storage_deposit` the FT will appear in their Wallets.


Transferring Tokens
To send FT to another account you will use the ft_transfer method, indicating the receiver and the amount of FT you want to send.

  
    
  
  
    
  
  
    
  
  
    
  


Attaching FTs to a Call
Natively, only NEAR tokens (Ⓝ) can be attached to a function calls. However, the FT standard enables to attach fungible tokens in a call by using the FT-contract as intermediary. This means that, instead of you attaching tokens directly to the call, you ask the FT-contract to do both a transfer and a function call in your name.
Let's assume that you need to deposit FTs on Ref Finance.

  
    
  
  
    
  
  
    
  
  
    
  

How it works:

You call ft_transfer_call in the FT contract passing: the receiver, a message, and the amount.
The FT contract transfers the amount to the receiver.
The FT contract calls receiver.ft_on_transfer(sender, msg, amount)
The FT contract handles errors in the ft_resolve_transfer callback.
The FT contract returns you how much of the attached amount was actually used.


Handling Deposits (Contract Only)
If you want your contract to handle deposit in FTs you have to implement the ft_on_transfer method. When executed, such method will know:

Which FT was transferred, since it is the predecessor account.
Who is sending the FT, since it is a parameter
How many FT were transferred, since it is a parameter
If there are any parameters encoded as a message

The ft_on_transfer must return how many FT tokens have to be refunded, so the FT contract gives them back to the sender.
// Implement the contract structure
#[near(contract_state)]
impl Contract {}

#[near]
impl FungibleTokenReceiver for Contract {
  // Callback on receiving tokens by this contract.
  // `msg` format is either "" for deposit or `TokenReceiverMessage`.
  fn ft_on_transfer(
    &mut self,
    sender_    amount: U128,
    msg: String,
  ) -> PromiseOrValue<U128> {
    let token_in = env::predecessor_account_id();

    assert!(token_in == self.ft_contract, "{}", "The token is not supported");
    assert!(amount >= self.price, "{}", "The attached amount is not enough");

    env::log_str(format!("Sender 
    if msg.is_empty() {
      // Your internal logic here
      PromiseOrValue::Value(U128(0))
    } else {
      let message =
        serde_json::from_str::<TokenReceiverMessage>(&msg).expect("WRONG_MSG_FORMAT");
      match message {
        TokenReceiverMessage::Action {
          buyer_id,
        } => {
          let buyer_id = buyer_id.map(|x| x.to_string());
          env::log_str(format!("Target buyer           // Your internal business logic
          PromiseOrValue::Value(U128(0))
        }
      }
    }
  }
}

Additional Resources

NEP-141 and NEP-148 standards
FT Event Standards
FT reference implementation
Fungible Tokens 101 - a set of tutorials that cover how to create a FT contract using Rust.

### Decentralized Exchanges (DEX)

A Decentralized Exchange (DEX) is an application that allows users to trade tokens (native & fungible tokens) through smart contracts.

In brief, DEXs work by having pools of token pairs (e.g. NEAR-USDC) that users can deposit tokens into.
The ratio of the tokens in the pool determines the exchange rate for a swap. Indeed, swapping is adding tokens to one side of the pool while removing tokens from the other side of the pool.
info
This docs refer to Ref Finance, a community built DEX in NEAR.
Please check their docs for more information.


Query Token Exchange Rate
One can query the exchange rate of a token pair by calling the get-token-price method on the DEX contract.

  
    
  
  
    
  


Query Whitelisted Tokens
Anyone list tokens for sale in the DEX. This is why, in order to protect users, the DEX contract has a list of whitelisted tokens that can be traded.

  

```bash
near view v2.ref-finance.near get_whitelisted_tokens
```






 Examples Response 

```bash
  'wrap.near',
  'usdt.tether-token.near',
  'berryclub.ek.near',
  'farm.berryclub.ek.near',
  'token.v2.ref-finance.near',
  'token.paras.near',
  'marmaj.tkn.near',
  'meta-pool.near',
  ...
```



Register in the DEX
In order to use the contract, make sure to register your account in the DEX by paying for the storage you will use in order to keep track of your balances.

  

```bash
near call v2.ref-finance.near storage_deposit '' --accountId  --amount 0.1
```





Deposit funds
In order to swap tokens, one must first deposit tokens into the DEX. For this, you will need to transfer the FT you want to swap to the DEX contract.

  

```bash
near call token.v2.ref-finance.near ft_transfer_call {"receiver_id": "v2.ref-finance.near", "amount": "1000000000000", "msg": ""} --gas 300000000000000 --depositYocto 1 --accountId 
```




:::danger
Do NOT transfer NEAR tokens to Ref Finance. Instead, call near_deposit in the wrap.near contract, attaching the amount of NEAR you want to swap.

This will mint wrap.near for you, which you can then transfer to Ref Finance.
::


Get Deposit Balances
Query your deposit balances by calling the get_deposits method:

  
    
  
  
    
  
  
    
  
  
    
  


Query Pools
DEXs work by having multiple pools of token pairs (e.g. NEAR-USDC) that users can deposit tokens into.

  
    
  
  
    
  
  
    
  
  
    
  


Swap tokens
In order to swap a token for another, you need to have funds, and there needs to exist a pool that has both tokens on it.

  
    
  
  
    
  
  
    
  
  
    
  


Additional Resources

Claim Fungible Tokens from Lockup - the example how to claim locked tokens from the lockup.burrow.near contract.
BSC Dex Collection - the example of how to build simple swap page for a DEX.

### Decentralized Autonomous Organizations

Decentralized Autonomous Organizations (DAOs) are self-organized groups that form around common purposes. Membership, decision making, and funding are coordinated by publicly voting on proposals through a smart contract.

In contrast with FT and NFT, DAO contract's are not standardized. Because of this, in this page we will use as
reference the Astra dao contract. The main concepts covered here should
easily generalizable to other DAO implementations.

Create a DAO
The simplest way to create and interact with a DAO is to go through the AstraDAO UI.
You can also create a DAO by interacting with the sputnik-dao contract.

  
    
  
  
    
  
  
    
  
  
    
  


Voting policy
Currently, DAOs support two different types of voting policies: TokenWeight, and RoleWeight. 
When the vote policy is TokenWeight, the council votes using tokens. The weigh of a vote is the proportion of tokens used for voting over the token's total supply.
When the vote policy is RoleWeight(role), the vote weigh is computed as "one over the total number of people with the role".

 Voting Threshold 
Both voting policies further include a `threshold` for passing a proposal, which can be a ratio or a fixed number.

The ratio indicates that you need a proportion of people/tokens to approve the proposal (e.g. half the people need to vote, and to vote positively). A fixed number indicated that you need a specific number of votes/tokens to pass the proposal (e.g. 3 people/tokens are enough to approve the proposal).


List of DAOs
Query the list of DAOs existing in Sputnik Dao.

  
    
  
  
    
  
  
    
  


Query Existing Proposals
These snippets will enable you to query the proposals existing in a particular DAO.

  
    
  
  
    
  
  
    
  


Create proposal
Create a proposal so other users can vote in favor or against it.

  
    
  
  
    
  
  
    
  
  
    
  

infoBy default, only **council members** can create proposals.


Vote for proposal
These snippet will enable your users to cast a vote for proposal of a particular DAO.

  
    
  
  
    
  
  
    
  
  
    
  


Additional Resources

AstroDAO UI - the web app built on top of the Sputnik DAO Contract. Allows users to create and manage DAOs.
List of DAOs as a NEAR component

### Authenticate NEAR Users

Recently NEAR has approved a new standard that, among other things, enables users to authenticate into a backend service.
The basic idea is that the user will sign a challenge with their NEAR wallet, and the backend will verify the signature. If the signature is valid, then the user is authenticated.

Backend Auth with a NEAR Wallet
Authenticating users is a common use-case for backends and web applications. This enables services to provide a personalized experience to users, and to protect sensitive data.
To authenticate a user, the backend must verify that the user is who they say they are. To do so, the backend must verify that the user has access to a full-access key that is associated with their account.
For this three basic steps are needed:

Create a challenge for the user to sign.
Ask the user to sign the challenge with the wallet.
Verify the signature corresponds to the user.

1.  Create a Challenge
Assume we want to login the user into our application named application-name.
We first need to create a challenge that the user will sign with their wallet. For this, it is recommended to use a cryptographically secure random number generator to create the challenge.

const challenge = randomBytes(32)
const message = 'Login with NEAR'
noteHere we use [crypto.randomBytes](https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback) to generate a 32 byte random buffer.

2. Ask the User to Sign the Challenge
The signMessage method needed to sign the challenge is supported by these wallets:

Meteor Wallet
Here Wallet
Near Snap
Nightly Wallet
WELLDONE Wallet
NearMobileWallet
MyNearWallet
Sender

The message that the user needs to sign contains 4 fields:

Message: The message that the user is signing.
Recipient: The recipient of the message.
Nonce: The challenge that the user is signing.
Callback URL: The URL that the wallet will call with the signature.

// Assuming you setup a wallet selector so far
const signature = wallet.signMessage({ message, recipient, nonce: challenge, callbackUrl: <server-auth-url> })
3. Verify the Signature
Once the user has signed the challenge, the wallet will call the callbackUrl with the signature. The backend can then verify the signature.
const naj = require('near-api-js')
const js_sha256 = require("js-sha256")

export async function authenticate({ accountId, publicKey, signature }) {
  // A user is correctly authenticated if:
  // - The key used to sign belongs to the user and is a Full Access Key
  // - The object signed contains the right message and domain
  const full_key_of_user = await verifyFullKeyBelongsToUser({ accountId, publicKey })
  const valid_signature = verifySignature({ publicKey, signature })
  return valid_signature && full_key_of_user
}

export function verifySignature({ publicKey, signature }) {
  // Reconstruct the payload that was **actually signed**
  const payload = new Payload({ message: MESSAGE, nonce: CHALLENGE, recipient: APP, callbackUrl: cURL });
  const borsh_payload = borsh.serialize(payloadSchema, payload);
  const to_sign = Uint8Array.from(js_sha256.sha256.array(borsh_payload))

  // Reconstruct the signature from the parameter given in the URL
  let real_signature = Buffer.from(signature, 'base64')

  // Use the public Key to verify that the private-counterpart signed the message
  const myPK = naj.utils.PublicKey.from(publicKey)
  return myPK.verify(to_sign, real_signature)
}

export async function verifyFullKeyBelongsToUser({ publicKey, accountId }) {
  // Call the public RPC asking for all the users' keys
  let data = await fetch_all_user_keys({ accountId })

  // if there are no keys, then the user could not sign it!
  if (!data || !data.result || !data.result.keys) return false

  // check all the keys to see if we find the used_key there
  for (const k in data.result.keys) {
    if (data.result.keys[k].public_key === publicKey) {
      // Ensure the key is full access, meaning the user had to sign
      // the transaction through the wallet
      return data.result.keys[k].access_key.permission == "FullAccess"
    }
  }

  return false // didn't find it
}

// Aux method
async function fetch_all_user_keys({ accountId }) {
  const keys = await fetch(
    "https://rpc.testnet.near.org",
    {
      method: 'post',
      headers: { 'Content-Type': 'application/json; charset=utf-8' },
      body: `{"jsonrpc":"2.0", "method":"query", "params":["access_key/${accountId}", ""], "id":1}`
    }).then(data => data.json()).then(result => result)
  return keys
}

module.exports = { authenticate, verifyFullKeyBelongsToUser, verifySignature };

### AI Assistant

Welcome! In this guide, you'll discover an AI chatbot that can interact with the NEAR ecosystem
This AI agent can:

Explore and explain what happened in a transaction when given a transaction hash
Request tokens from the testnet faucet
Mint and send a special NFT though a wallet it controls to a user
Answer general questions about the NEAR architecture (powered by realtime search results)

tipommunity Project 

Created by our community member [Reza](https://x.com/RezaRahemtola), this project was one of our AI track winners at the [ETHGlobal Brussels 2024 hackathon](https://ethglobal.com/events/brussels) 



Prerequisites
Let's start by setting up the environment to run the AI assistant locally.

Tools
Before starting, make sure you have the following tools installed:

Python >= 3.12
NodeJS >= 20
llama.cpp


  

    ```sh
    # Install Node.js using nvm (more option in: https://nodejs.org/en/download)
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
    nvm install latest

    # Install python using miniconda (includes the package manager pip)
    brew install --cask miniconda
    conda init "$(basename "${SHELL}")"
    pip install poetry

    # Install llama.cpp
    brew install llama.cpp
    ```

  
  
    Please help by contributing these steps for Linux!
  



AI Model
In this tutorial we will be using the NousResearch/Hermes-2-Pro-Llama-3-8B-GGUF model, which is hosted on Hugging Face.
# Install the Hugging Face library
pip install huggingface_hub

# Login to your Hugging Face account
huggingface-cli login

# get the model from Hugging Face
huggingface-cli download NousResearch/Hermes-2-Pro-Llama-3-8B-GGUF Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf --local-dir model
infoQ4_K_M Model

We use the small `Q4_K_M` model to reduce the time and resources needed to run the AI agent



Execute the Model
You should now have a folder named ./model with the GGUF file ./model/Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf, lets use llama.cpp to run it.
# run the model with llama.cpp
llama-server -m ./model/Hermes-2-Pro-Llama-3-8B-Q4_K_M.gguf
Open your browser at http://localhost:8080, if you see an interface similar to this one you are ready to go 🚀

tipYou can use a different model with llama.cpp if you wish! Just make sure it supports [function calling](https://docs.mistral.ai/capabilities/function_calling)



Project Setup
Start by cloning the repository of the project, in which you will find the AI agent and a basic frontend to interact with it:
git clone git@github.com:RezaRahemtola/near-ai-assistant.git

AI
Let's configure the AI agent, first, we install all python dependencies on the project 
cd ai/

# Important: Create a virtual environment
conda create -n ai-assistant python=3.12
conda activate ai-assistant

# Install the dependencies
pip install poetry
poetry install
Then you can create a .env file and fill it with values inspired from the .env.example file:

NEAR_ACCOUNT_ID: The NEAR account id (i.e. account name) of your bot
NEAR_ACCOUNT_PRIVATE_KEY: The private key to control the account
NEAR_RPC_URL: can also be set in case you want to use a different RPC

Once you've done all this, you are ready to launch the code 🚀
python src/main.py
 

 Optional: Google Search 

`OXYLABS_USERNAME` and `OXYLABS_PASSWORD` are API credential used to access an SERP API to search information on Google



Frontend
Now that your AI agent is ready to go, let's quickly launch a basic frontend to interact with it:
cd front/
# Install the dependencies
yarn
# Start the frontend
yarn dev

Usage
You can now head to http://localhost:5173, where you'll find an interface like this one to interact with the AI:

Here are a few example questions you can ask it:

What is NEAR?
What are the different transaction actions on NEAR?
Can I please have an ETHGlobal Brussels NFT sent to me at random.testnet? Thanks
I want to start using NEAR, can you send me some tokens on my testnet address random.testnet?
I don't understand what this transaction is doing, can you help me? The transaction hash is hash and it was send by someone.testnet.


Moving Forward
That's it for the quickstart tutorial. You have now seen an open-source AI agent interacting with NEAR and controlling a wallet to make transactions.
To better understand how it works, check the agent.py file and the Function Calling explanation on HuggingFace.
A lot of things could be built by leveraging this PoC, some ideas could be:

A chatbot integrated to the explorer to summarize transactions directly in the page
Interactive tutorials in the documentation through a chatbot

"How to create an NFT?"
Multiple chats with explanations and code to complete given by the AI
In the end, the AI publish the smart contract, mint an NFT and send it to you on testnet

An AI trader reacting to on-chain or off-chain events to buy/sell some tokens with its wallet
The only limit is your imagination!

### What are Web3 Apps?

Web3 Applications - also known as decentralized apps (dApps) - leverage smart contracts and blockchain data to offer transparency, security and giving back control to users over their assets and data.

NEAR simplifies building Web3 apps for the general public, making it easy to interact with different blockchains, while helping to onboard users that are not familiarized with crypto.

Why Integrating NEAR to your App?
Any application can benefit from integrating NEAR, including games, financial services, social platforms, and more.


Easy Onboarding: Users can create accounts using familiar methods such as email login. Furthermore, applications can cover all transactional costs for their users, so they never have to worry about handling crypto.


Ownership: Users have true ownership of digital assets within their accounts. Fungible Tokens can be used as reward systems, Non-Fungible Tokens can denote holdings, and wallets can represent digital identities.


Fast, Cheap and Scalable: Near’s efficient consensus mechanism and fee model make transactions cost effective for both users and developers.


Security & Transparency: All transactions and data on the blockchain is transparent and auditable, thus ensuring trust in the application’s behavior.

### Hello WebApp

In this guide we will show you how to quickly spin up a frontend where users can login using their wallets and interact with a contract.
tipearching to integrate NEAR in your App?
If you already have an application and want to integrate NEAR into it, we recommend you to first go through this guide and then check our documentation on [integrating NEAR to a frontend](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/./integrate-contracts.md)


Create NEAR App
If you already have Node.js installed, simply run:
  npx create-near-app@latest
Use the interactive menu to set up:

A Web App.
NextJs (Classic).

tipsing pnpm
While you can use our app with any package manager, we recommend you to skip the installation step and manually install the dependencies using `pnpm i`.

Once the folder is ready - and all dependencies installed - you can start the development server using pnpm. 
pnpm dev
Visit http://localhost:3000 in your browser to view the dApp. Note that since the dApp uses NextJS the app might take longer to load the pages on first visit.

 The app is not starting? 

Make sure you are using **node >= v18**, you can easily switch versions using `nvm use 18`



Landing Page
Once the app starts you will see the landing page, rendering a navigation bar that allows users to login using their NEAR wallet. You can then navigate to the docs or the Near Integration page (which we will do).

Landing page of Hello NEAR Gateway
Go ahead and sign in with your NEAR account. If you don't have one, you can create one on the fly.

Under the Hood
Next.js uses a template system, where each page is a React component.
Our app's template is defined at ./src/pages/_app.js. It does two things:

Initializes a wallet selector, and stores it in context so other components can access it later.
Renders the navigation menu and the page's content.


When initializing the wallet you can choose to create a function call access key for a specific contract for the application to use. This allows the application to sign non-payable methods on behalf of the user so they are not required to manually sign each transaction.
const wallet = new Wallet({
  createAccessKeyFor: HelloNearContract,
  networkId: NetworkId,
});
This example additionally includes the option to login with Metamask and other EVM wallets. Further information on how to add EVM wallets to your application can be found in the Ethereum Wallets on NEAR documentation.

What is the wallet selector?

The wallet selector is a modal that allows users to select their preferred Near wallet to login. Our application creates a new instance of the wallet selector then stores it in the apps context so it can be accessed by other components.




The navigation bar implements buttons to login and logout users with their Near wallet.
The code for the navigation bar can be found at ./src/components/navigation.js. The login and logout buttons are implemented by using the signIn and signOut methods from the wallet selector previously initialized:


Interacting with NEAR
Now that you understand how the landing page works, we can move to the Near Integration page, which retrieves a greeting from the hello.near-examples.testnet contract.

View of the Near Integration page
Login if you haven't done it yet and you will see a simple form that allows you to store a greeting in the smart contract.

Under the Hood
We retrieve the wallet we initialized earlier via the useContext hook. The wallet allows us to interact with the smart contract through viewMethod and callMethod.

viewMethod is used to call functions that are read-only
callMethod is used to call functions that modify the state of the contract 


On load, the first useEffect hook will call the contract's get_greeting method and set the greeting state to the result.
If the user is logged in, the user will be able to use the saveGreeting function which will call the contract's set_greeting method and then update the greeting.

Moving Forward
That's it for our quickstart tutorial. You have now seen a fully functional frontend that can talk with NEAR contracts and render Web3 components.

### Integrating Contracts

To integrate NEAR to your frontend, you will leverage two tools:

Wallet Selector: Enables the user to select their preferred NEAR wallet in your dApp.
NEAR API JS: A suite of tools to interact with the NEAR RPC.

Using those tools you will implement the following flow:

Setup a wallet selector.
Load the wallet selector on start-up.
Ask the user to sign-in using a NEAR wallet.
Call methods in the contract.

Naxios
You can optionally use Naxios. A promise-based NEAR Contract and NEAR Wallet Client for browser.
Naxios was designed to facilitate the React / Next.js integration with NEAR Blockchain and avoid the boilerplate of setting up a wallet and contract.

Adding NEAR API JS and Wallet Selector
In order to use near-api-js and the wallet-selector you will need to first add them to your project.
The wallet selector has multiple wallet packages to select from, see in their website.
npm install 
  near-api-js 
  @near-wallet-selector/core 
  @near-wallet-selector/my-near-wallet 
  @near-wallet-selector/ledger 
  @near-wallet-selector/modal-ui

Create a Wallet Object
In our examples, we implement a ./wallets/near.js module, where we abstracted the wallet selector into a Wallet object to simplify using it.
To create a wallet, simply import the Wallet object from the module and initialize it. This wallet will later allow the user to call any contract in NEAR.

  
    

    

  

Under the hood (check the near tab) you can see that we are actually setting up the wallet selector, and asking it if the user logged-in already. During the setup, we pass a hook to the wallet selector, which will be called each time a user logs in or out.

 Setting customs RPC endpoints 
If you want to use a user-defined RPC endpoint with the Wallet Selector, you need to set up a network options object with the custom URLs.
For example:

  

```js title="index.js"
const CONTRACT_ADDRESS = process.env.CONTRACT_NAME;

const my_network = {
    networkId: "my-custom-network",
    nodeUrl: "https://rpc.custom-rpc.com",
    helperUrl: "https://helper.custom-helper.com",
    explorerUrl: "https://custom-explorer.com",
    indexerUrl: "https://api.custom-indexer.com",
  };

const wallet = new Wallet({ createAccessKeyFor: CONTRACT_ADDRESS, network: my_network });
```




tipYou can find the entire Wallet Selector [API reference here](https://github.com/near/wallet-selector/blob/main/packages/core/docs/api/selector.md).



Function Call Key
When instantiating the wallet you can choose if you want to create a FunctionCall Key.
If you create the key, your dApp will be able to automatically sign non-payable transactions for the user on the specified contract.

Calling View Methods
Once the wallet is up we can start calling view methods, i.e. the methods that perform read-only operations.
Because of their read-only nature, view methods are free to call, and do not require the user to be logged in.

  
    

    




The snippet above shows how we call view methods in our examples. Switch to the near-wallet tab to see under the hood: we are actually making a direct call to the RPC using near-api-js.
tipView methods have by default 200 TGAS for execution



User Sign-In / Sign-Out
In order to interact with non-view methods it is necessary for the user to first sign in using a NEAR wallet.
Signing in is as simple as requesting the wallet object to signIn, the same simplicity applies to signing out.

  
    

    

  

When the user clicks the login button, they will be asked to select a wallet and use it to log in.

Function Call Key
If you instantiated the Wallet passing an account for the createAccessKeyFor parameter, then the wallet will create a FunctionCall Key and store it in the web's local storage.
const wallet = new Wallet({
  createAccessKeyFor: HelloNearContract,
  networkId: NetworkId,
});
By default, such key enables to expend a maximum of 0.25Ⓝ on GAS calling methods in the specified contract without prompting the user to sign them.
If, on the contrary, you do not create an access key, then the user will be asked to sign every single transaction (except calls to view methods, since those are always free).
tipPlease notice that this only applies to **non-payable** methods, if you attach money to any call the user will **always** be redirected to the wallet to confirm the transaction.



Calling Change Methods
Once the user logs in they can start calling change methods. Programmatically, calling change methods is similar to calling view methods, only that now you can attach money to the call, and specify how much GAS you want to use.

  
    

    




Under the hood (see near-wallet tab) we can see that we are actually asking the wallet to sign a FunctionCall transaction for us.
tipRemember that you can use the `wallet` to call methods in **any** contract. If you did not ask for a function key to be created, the user will simply be prompted to confirm the transaction.



Wallet Redirection
When calling a change call with attatched deposit (or any change call if no function call key was created), then the user will be prompted to sign the transaction in the wallet.
If using a web wallet, as opposed to an extension, the user will be redirected to the wallet's website to sign the transaction.
After accepting, the user will be brought back to your application, with the resulting transaction hash being passed as part of the URL (i.e. your-website.com/?transactionHashes=...).
If the method invoked returned a result, you can use the transaction hash to retrieve the result from the network. You can fetch the transaction hash via:
const txHash = new URLSearchParams(window.location.search).get('transactionHashes');
Assuming you created the near object as in the example above, then you query the result by utilizing:

  

    





Sending Multiple Transactions
The Wallet class also exposes a method that can be used to send multiple transactions.

  

    




Transactions can either be sent as multiple separate  transactions simultaneously or as a batch transaction made up of actions where if one of the actions fails, they are all reverted. An example of both can be seen here

Querying Account Balance
By calling the getBalance method the user can get the balance of the account that is currently logged in.

  

    





Get Access Keys
The final method the Wallet class exposes is getAccessKeys which is used to return an object of all the access keys on the account that is currently logged in.

  

    





Handling Data Types
When calling methods in a contract, or receiving results from them, you will need to correctly encode/decode parameters. For this, it is important to know how the contracts encode timestamps (u64) and money amounts (u128).
Time
The block timestamp in a smart contract is encoded using nanoseconds (i.e. 19 digits: 1655373910837593990). In contrast, Date.now() from javascript returns a timestamp in milliseconds (i.e 13 digits: 1655373910837). Make sure to convert between milliseconds and nanoseconds to properly handle time variables.
Money
Smart contracts speak in yocto NEAR, where 1Ⓝ = 10^24yocto, and the values are always encoded as strings.

Convert from NEAR to yocto before sending it to the contract using near-api-js.utils.format.parseNearAmount(amount.toString()).
Convert a response in yoctoNEAR to NEAR using near-api-js.utils.format.formatNearAmount(amount)

tipIf the contract returns a `Balance` instead of a `U128`, you will get a "scientific notation" `number` instead of a `string` (e.g. `10^6` instead of `"1000000"`). In this case, you can convert the value to NEAR by doing:

```js
function formatAmount(amount) {
  let formatted = amount.toLocaleString('fullwide', { useGrouping: false })
  formatted = utils.format.formatNearAmount(formatted)
  return Math.floor(formatted * 100) / 100
}
```



Leveraging NEAR API JS
NEAR API JS does not limit itself to simply calling methods in a contract. In fact, you can use it to transform your web-app into a rich user experience. While we will not cover these topics in depth, it is important for you to know that with NEAR API JS you can also:

Sign and verify messages: this is very useful to prove that a message was created by the user.
Create batch transactions: this enables to link multiple actions (e.g. multiple function calls). If one of the transactions fails, then they are all reverted.
Create accounts: deploy accounts for your users!

Check the cookbook to learn how to supercharge your web-app.

### Integrating Components

To integrate Components to your frontend, you will leverage two tools:

Wallet Selector: Enables the user to select their preferred NEAR wallet in your dApp.
NEAR VM: A package that can retrieve the component's code from the blockchain and execute it in the browser. 


Using those tools you will implement the following flow:

Setup the VM.
Render components using the Widget component in the VM.
Setup a wallet selector so users can interact with the Menu.



To use the VM and the wallet-selector, you must add them to your project first.
The wallet selector has multiple wallet packages to select from. Check their website for more information.
npm install 
  @near-wallet-selector/core 
  @near-wallet-selector/my-near-wallet 
  @near-wallet-selector/modal-ui
Then, manually add the VM to your package.json:
"dependencies": {
  ...
  "near-social-vm": "github:NearSocial/VM#2.5.5"
  ...
}
tipheck the latest released version for the VM [here](https://github.com/NearSocial/VM/releases)


Setup the VM
To render components, you need to import the useInitNear hook from the near-social-vm package, as well as the Widget component.

export default function Component({ src }) {
  const { initNear } = useInitNear();

  useEffect(() => {
    initNear && initNear({ networkId: 'testnet', selector: null });
  }, [initNear]);

  return <Widget src={src} />;
}

return <Component src="influencer.testnet/widget/Greeter" props={{name: "Anna", amount: 2}} />
tipotice that the VM is inherently linked to `React`, so you will need to use a reactive framework to take full advantage of the VM.


Setup the Wallet Selector
While the VM allows you to render components, you need to set up a wallet selector to allow users to interact with the components.
To instantiate a Wallet Selector, simply import all the wallets you want your users to have access to, and the setup method from the near-wallet-selector package.

const selector = setupWalletSelector({
  network: 'testnet,
  modules: [setupMyNearWallet()],
});
Then use it during the call to initNear:
  useEffect(() => {
    initNear && initNear({ networkId: 'testnet', selector: selector });
  }, [initNear]);
tipo learn more about the wallet selector and how it can be used, please see the [integrating NEAR to your WebApp tutorial](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/./integrate-contracts.md)

### Frontends for Web3 dApps

When building decentralized web applications (dApps), developers have two primary options for connecting a front-end user interface (UI) to a smart contract backend. Each option offers distinct advantages and disadvantages, tailored to different project requirements and goals.

Standard Web2 Frontend
Decentralized Frontend

Standard Web 2 Frontend
While your user interface layer will remain centralized, the backend layer—including business logic and stored data—will be decentralized through smart contracts. This approach offers optimal convenience for most applications as it eliminates technical constraints and does not impact performance. However, if your requirement is for full decentralization across the entire stack, this configuration may not be suitable.
Pros:

Develop a standard web application without any technical restrictions.
Compatible with any framework and library combination.
Supports server-side rendering with platforms like Next.js or SvelteKit.
Delivers the best overall performance.

Cons:

Requires hosting through a traditional Web 2 provider (e.g., Vercel, AWS).
The user interface layer will not be decentralized.

How to Build:
When building a frontend that can connect with the NEAR blockchain using standard web2 tooling will require you to import two dependencies:

NEAR API JS - A JavaScript API tool that allows frontend clients the ability to view and retrieve data directly from the blockchain.
Wallet Selector - Wallet integration tool allowing developers to choose which wallets are supported and allows users to choose which wallet they would like to connect with.

tip[Checkout this article](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/integrate-contracts.md) to learn how to integrate smart contracts to your frontend, using [Wallet Selector](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/4.tools/wallet-selector.md) and [NEAR API JS](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/4.tools/near-api-js/quick-reference.md).


Decentralized Frontend Solutions
If you need full decentralization of your entire stack, this option is ideal. However, consider the possible technical constraints, such as the absence of server-side rendering or meta frameworks like Next.js.
Although the ecosystem for developing decentralized frontends is still maturing, here are some notable projects for you to evaluate and consider:



Name
Description




IPFS
A peer-to-peer hypermedia protocol designed to preserve and grow humanity's knowledge by making the web upgradeable, resilient, and more open.


Fleek
Hosts websites on IPFS with a user-friendly interface and continuous deployment from popular repositories.


Arweave
Arweave lets you build quickly and simply with permanent storage. You can store anything from files to fully decentralized web applications.


Web4
Web4 is a new way to distribute decentralized apps on NEAR Protocol. Deploy single WASM smart contract to deploy an entire web application.


NEAR Social (aka B.O.S. Components)
An experimental platform that allows users to build and deploy multi-chain decentralized UI experiences.



Pros:

Decentralized frontends are less susceptible to single points of failure, making them more resistant to attacks and server downtimes
By decentralizing the hosting of your frontend, you minimize the risk of content being censored or blocked by centralized authorities.
Users might trust a decentralized application more, knowing that it operates on a transparent and immutable blockchain.
Data displayed on the frontend is more likely to be accurate and tamper-proof since it's typically fetched directly from the blockchain.

Cons:

Implementing a decentralized frontend can be more complex than traditional web development, requiring knowledge of specific technologies like IPFS, Arweave, or blockchain interactions.
Decentralized networks can face issues such as latency or lower speeds compared to traditional centralized servers, potentially affecting user experience.
The ecosystem for developing decentralized frontends is still maturing, which means there might be fewer tools and libraries available compared to traditional web development.
While decentralized storage costs have been decreasing, they can still be higher than traditional hosting, especially if the dApp generates a lot of data transactions.

### Chain Hosted UI

Chain Hosted UI is a decentralized frontend solution that lets you to deploy dApp frontends directly on the NEAR blockchain. A frontend can be built with typical Web2 tooling (e.g. React + Vite + node.js dependencies), and the resulting compressed bundle can be stored in the state of a smart contract.
warning
This experiment reached the MVP stage of functionality but no longer has a maintainer due to Pagoda winding down.
We encourage interested parties to fork the project and carry it forward. The smart contract has not yet been audited.

Overview
Thanks to the fact that storage on NEAR is cheap, it's feasible to host lightweight applications with optimized bundles on chain. This offers a straightforward path to decentralized hosting as an alternative to static deployment platforms such as Vercel, GitHub Pages, Render, and others.
The Chain Deployed UI tooling provides the boilerplate app code (React, Vue, TypeScript), along with the FileStore smart contract and basic CDN tools so you can build a dApp, pack it, and store it on chain.
This FileStore smart contract deployed by NEAR is designed to store and serve dApp bundles for any user, so you don't need to have an understanding of smart contract development. You only need to understand how to sign a transaction (with help from our tooling) and to have enough NEAR tokens to pay for storage.
tipYou can still deploy your own file storage smart contract if you want to have additional customization or if you want total control over your data.


Pros

By decentralizing the hosting of your front-end, you minimize the risk of censoring or blocking content by centralized authorities.
Users might trust a decentralized application more, knowing that it operates on a transparent and immutable blockchain.
Data displayed on the front-end is more likely to be accurate and tamper-proof since it's typically fetched directly from the blockchain.

Cons

Implementing a decentralized front-end can be more complex than traditional web development, requiring knowledge of additional technologies like IPFS, Arweave, or blockchain interactions.
Decentralized networks can face issues such as latency or lower speeds compared to traditional centralized servers, potentially affecting user experience.
The ecosystem for developing decentralized frontends is still maturing, which means there might be fewer tools and libraries available than for traditional web development.
While decentralized storage costs have been decreasing, they can still be higher than traditional hosting, especially if the dApp generates a lot of data transactions.

How it works
A standard workflow of the chain deployed solution would be:

Building, packing, and compressing the web app frontend
Uploading the web app bundle files using the FileStore smart contract
Serving the web app using a CDN gateway

Once the web app has been uploaded to the blockchain, a web Gateway converts browser requests to blockchain RPC calls, so users can access your decentralized application.
Gateway
A gateway server is required to convert browser resource requests to RPC calls. For convenience, gateways may be deployed to cloud hosts, but this causes some centralization. It can be mitigated by having multiple gateways run by different parties. It is important that a user trust the gateway provider however, since the gateway is ultimately what is in control of the experience being served to the user's browser.
RPC
An RPC provider services requests for chain data. For resilience, gateways should ideally be capable of falling back to a different provider in the event the primary provider is experiencing degraded service.
Considerations
Compared to classic Web2 hosting solutions, the cost structure of a chain-deployed dApp is very different.
When deploying on chain, you pay a one-time fee for the storage space of your compressed bundles. This means that it's critical to pay attention to the size of dependencies you include in your application, as packages that are bloated or do not support proper tree-shaking will directly affect your cost.
info
NEAR uses storage staking, where NEAR tokens are locked while storage is being used and refundable in the event of deleting that data from smart contract state. The cost of storage is 1 NEAR per 100 Kb.

Storage Optimization
Additional storage optimization can be achieved by building your dApp from a provided template with preconfigured code splitting. This allows you to yield separate bundles for the template boilerplate and the custom dApp code:

The template boilerplate can be uploaded once, and then served for every dApp built using that template.
This decreases the deployment cost, since you only need to deploy the custom dApp code and specific dependencies.

Asset Hosting
For hosting large assets (such as images and videos) that your web app may require, you could leverage a decentralized storage service to maintain a fully decentralized deployment. Some of these solutions are:

Arweave
Crust
IPFS

### Chain Hosted UI tutorial

Chain Hosted UI lets you to deploy dApp frontends directly on the NEAR blockchain.
In this tutorial you'll learn how to build and deploy a simple React web app using Chain Hosted UI.
warning
This experiment reached the MVP stage of functionality but no longer has a maintainer due to Pagoda winding down.
We encourage interested parties to fork the project and carry it forward. The smart contract has not yet been audited.

Requirements
To build and deploy your web3 dApp, you'll need to have installed:

NodeJS
TypeScript
pnpm

If you already have NodeJS, installing TypeScript and pnpm is simple:
TypeScript
npm install -g typescript
pnpm
npm install -g pnpm
Getting Started
Let's get started by cloning the chain hosted repository from GitHub.
You'll take advantage of a demo React project in this monorepo to build your new React application.
git clone https://github.com/near/chain-hosted-ui
After cloning, you need to install the dependencies from the chain-hosted-ui folder:
Install
cd chain-hosted-ui
pnpm install
Next, it's time to build all the packages included in the Chain Hosted solution:
Build all
pnpm run build
React App
Now you can jump to the demo React project included in the chain-hosted-ui repository. This demo project provides the boilerplate code and preconfigured settings so you can start building your web app right away:
cd packages/react
In this folder you can build, edit, add components, content, or npm dependecies to your React web app.
For example, you can edit src/App.tsx and add a "Hello World!" paragraph:

  
    
  

When ready, you can test your sample React dApp locally:
Run web app
npm run dev
Blockchain Deployment
If you want to deploy your React frontend to the NEAR blockchain, you'll need to update the project's settings, and then run the deploy script.
Settings
To update the settings, configure the nearDeployConfig field in package.json:

  
    
  

Configuration parameters

application is developer-defined and will be used as part of the URL (names should match [a-z_-]+)
deployerAccount is the account paying for bundle storage and calling smart contract methods (must match DEPLOYER_ACCOUNT.near referenced above)
filestoreContract is the hosted storage contract

v1.chain-hosted-ui.testnet on testnet
v1.chain-hosted-ui.near
or deployed and configured separately


Account login
Before you can deploy your app, you need to set credentials to your NEAR account. You can do it by adding a new key into your account and saving it into the legacy keychain.
near account add-key <accountId> grant-full-access autogenerate-new-keypair save-to-legacy-keychain network-config testnet sign-with-keychain send
The JSON file will be saved at the path ~/.near-credentials/mainnet/YOUR_ACCOUNT.near.json (replace mainnet with testnet for testnet). Edit the created file to make sure it has following structure:
{
  "account_id":"YOUR_ACCOUNT.near",
  "public_key":"ed25519:44_CHARACTERS_BASE_58",
  "private_key":"ed25519:88_CHARACTERS_BASE_58"
}
Deploy
After you've set up your account and contract settings, you can build the project bundle and deploy the application on chain by running:
npm run deploy
The deployment script will estimate the storage cost in NEAR tokens, and ask you to confirm the transaction:
react-example deployment calculated to cost 4.08204 N {
  appKey: '<YOUR_ACCOUNT_ID>/react-example',
  newAppChars: 96,
  fileKeyChars: 327,
  partitionKeyChars: 339,
  fileBytes: 388004
}
? Estimated cost to deploy is 4.08204 N. Continue? (y/N)
Once you've deployed your frontend, you can load the web application at https://chain-hosted-ui.near.dev//<FILE_CONTRACT>/<DEPLOYER_ACCOUNT.near>/<APPLICATION-NAME>

<FILE_CONTRACT>: v1.chain-hosted-ui.testnet or v1.chainui.near
<DEPLOYER_ACCOUNT.near>: the NEAR account used to deploy, e.g. myaccount.testnet
<APPLICATION-NAME>: the application name you defined, e.g. react-example
Check this deployed example

Redeployment
Once deployed, new deployments can be made or the application can be removed (with any remaining storage being refunded):

To deploy a new version after making changes, run
pnpm run deploy
This will increment the application version, delete previous files, and refund any remaining available balance.
To delete application storage, refund storage-staked Near, and unregister the deployment account, run
pnpm delete-and-unregister
To drop and recreate the application, run
pnpm clean-deploy

Also note that in order to do a roll forward deployment, both sets of application files must exist simultaneously to avoid downtime.
Consequently, storage must be paid ahead of each deployment to account for the new files, regardless
of whether the application is already deployed. Once the deployment is live, the files from the previous deployment are deleted and storage is refunded as part of the deployment script.

### What are NEAR Components?

NEAR Components are a new way to build web applications. They are composable, reusable and decentralized.

tipou can login to interact with the examples in this section.


Familiar to Web Developers
NEAR Components are built on top of React Components, meaning that they:

Handle input through the props variable
Handle state through the useState hook
Handle side effects through the useEffect hook



```jsx
const name = props.name || "Maria";
const [count, setCount] = useState(1);

return (
  
     {count} cheers for {name}! 
     setCount(count + 1)}>Cheers!
  
);
```


In contrast with React, NEAR Components are not wrapped in a function or class definition.
Indeed, when writing a NEAR Component, you focus on writing the body of the component, which is a function that returns the JSX to be rendered. 

NEAR Native
NEAR Components can readily interact with smart contracts in the NEAR Blockchain. While view methods are free to query by anyone, call methods require the user to be logged in.


```jsx
const counter = Near.view('counter.near-examples.testnet', 'get_num')

if(counter === null) return 'Loading...'

const add = () => {
  Near.call('counter.near-examples.testnet', 'increment')
}

const subtract = () => {
  Near.call('counter.near-examples.testnet', 'decrement')
}

return 
   Counter: {counter} 
  {!context.accountId &&
     Please login to interact with the contract
  }
  {context.accountId && 
  
     + 
     - 
  >
  }
>
```



Social from the Get-Go
NEAR Components are easily integrated with NEAR Social, a social network built on NEAR.


```js
const item = (blockHeight) => ({ type: 'social', path: 'influencer.testnet/post/main', blockHeight });

// retrieve indexed posts by influencer.testnet
const idx_posts = Social.index(
  'post', 'main', { accountId: ['influencer.testnet'] }
);

if (idx_posts === null) return 'Loading...';

// retrieve likes for each post
const likes = idx_posts.map(
  index => Social.index('like', item(index.blockHeight)).length
);

// retrieve data for each post
const post_data = idx_posts.map(
  index => Social.get(`${index.accountId}/post/main`, index.blockHeight)
);

// defined "Like" function
const like = (blockHeight) => Social.set(
  {index:{like: JSON.stringify({key: item(blockHeight), value: {type: 'like'}})}}
)

return 
  Posts from influencer.testnet
  {post_data.map((post, idx) =>
    
      {JSON.parse(post).text} - {likes[idx]} likes
      {context.accountId &&  like(idx_posts[idx].blockHeight)}>Like}
    
  )}
>

```




Leveraging the cheap storage and computation of the NEAR Blockchain, NEAR Components' code is stored fully on-chain in the SocialDB smart contract (social.near).


```js
// retrieving the code of a stored component
return Social.get('influencer.testnet/widget/Greeter')
```


Once deployed, a component can be imported and used by any other component. Composing components as LEGO blocks allows you to build complex applications.


```js
// Rendering the component with props
return ;
```


Multi-Chain by Design
NEAR Components can easily interact with Ethereum compatible blockchains, helping to easily create decentralized frontends for multi-chain applications.


```js
if (
  state.chainId === undefined &&
  ethers !== undefined &&
  Ethers.send("eth_requestAccounts", [])[0]
) {
  Ethers.provider()
    .getNetwork()
    .then((chainIdData) => {
      if (chainIdData?.chainId) {
        State.update({ chainId: chainIdData.chainId });
      }
    });
}
if (state.chainId !== undefined && state.chainId !== 1) {
  return Switch to Ethereum Mainnet;
}

// FETCH LIDO ABI

const lidoContract = "0xae7ab96520de3a18e5e111b5eaab095312d7fe84";
const tokenDecimals = 18;

const lidoAbi = fetch(
  "https://raw.githubusercontent.com/lidofinance/lido-subgraph/master/abis/Lido.json"
);
if (!lidoAbi.ok) {
  return "Loading";
}

const iface = new ethers.utils.Interface(lidoAbi.body);

// FETCH LIDO STAKING APR

if (state.lidoArp === undefined) {
  const apr = fetch(
    "https://api.allorigins.win/get?url=https://stake.lido.fi/api/sma-steth-apr"
  );
  if (!apr) return;
  State.update({ lidoArp: JSON.parse(apr?.body?.contents) ?? "..." });
}

// HELPER FUNCTIONS

const getStakedBalance = (receiver) => {
  const encodedData = iface.encodeFunctionData("balanceOf", [receiver]);

  return Ethers.provider()
    .call({
      to: lidoContract,
      data: encodedData,
    })
    .then((rawBalance) => {
      const receiverBalanceHex = iface.decodeFunctionResult(
        "balanceOf",
        rawBalance
      );

      return Big(receiverBalanceHex.toString())
        .div(Big(10).pow(tokenDecimals))
        .toFixed(2)
        .replace(/d(?=(d{3})+.)/g, "$&,");
    });
};

const submitEthers = (strEther, _referral) => {
  if (!strEther) {
    return console.log("Amount is missing");
  }
  const erc20 = new ethers.Contract(
    lidoContract,
    lidoAbi.body,
    Ethers.provider().getSigner()
  );

  let amount = ethers.utils.parseUnits(strEther, tokenDecimals).toHexString();

  erc20.submit(lidoContract, { value: amount }).then((transactionHash) => {
    console.log("transactionHash is " + transactionHash);
  });
};

// DETECT SENDER

if (state.sender === undefined) {
  const accounts = Ethers.send("eth_requestAccounts", []);
  if (accounts.length) {
    State.update({ sender: accounts[0] });
    console.log("set sender", accounts[0]);
  }
}

//if (!state.sender)  return "Please login first";

// FETCH SENDER BALANCE

if (state.balance === undefined && state.sender) {
  Ethers.provider()
    .getBalance(state.sender)
    .then((balance) => {
      State.update({ balance: Big(balance).div(Big(10).pow(18)).toFixed(2) });
    });
}

// FETCH SENDER STETH BALANCE

if (state.stakedBalance === undefined && state.sender) {
  getStakedBalance(state.sender).then((stakedBalance) => {
    State.update({ stakedBalance });
  });
}

// FETCH TX COST

if (state.txCost === undefined) {
  const gasEstimate = ethers.BigNumber.from(1875000);
  const gasPrice = ethers.BigNumber.from(1500000000);

  const gasCostInWei = gasEstimate.mul(gasPrice);
  const gasCostInEth = ethers.utils.formatEther(gasCostInWei);

  let responseGql = fetch(
    "https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v2",
    {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        query: `{
          bundle(            ethPrice
          }
        }`,
      }),
    }
  );

  if (!responseGql) return "";

  const ethPriceInUsd = responseGql.body.data.bundle.ethPrice;

  const txCost = Number(gasCostInEth) * Number(ethPriceInUsd);

  State.update({ txCost: `$${txCost.toFixed(2)}` });
}

// FETCH CSS

const cssFont = fetch(
  "https://fonts.googleapis.com/css2?family=Manrope:wght@200;300;400;500;600;700;800"
).body;
const css = fetch(
  "https://pluminite.mypinata.cloud/ipfs/Qmboz8aoSvVXLeP5pZbRtNKtDD3kX5D9DEnfMn2ZGSJWtP"
).body;

if (!cssFont || !css) return "";

if (!state.theme) {
  State.update({
    theme: styled.div`
    font-family: Manrope, -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Oxygen, Ubuntu, Cantarell, Fira Sans, Droid Sans, Helvetica Neue, sans-serif;
    ${cssFont}
    ${css}
`,
  });
}
const Theme = state.theme;

// OUTPUT UI

const getSender = () => {
  return !state.sender
    ? ""
    : state.sender.substring(0, 6) +
        "..." +
        state.sender.substring(state.sender.length - 4, state.sender.length);
};

return (
  
    
      Stake Ether
      Stake ETH and receive stETH while staking.

      
        {state.sender && (
          
            
              
                
                  
                    Available to stake
                    
                  
                
                
                  
                    {state.balance ?? (!state.sender ? "0" : "...")} ETH
                  
                
              
              
                
                  
                    {getSender()}
                  
                
              
            
            
          >
        )}
        
          
            
              
                Staked amount
              
            
            
              
                {state.stakedBalance ?? (!state.sender ? "0" : "...")}
                 stETH
              
            
          
          
            
              Lido APR
              {state.lidoArp ?? "..."}%
            
          
        
      
      
        
          
            
              
              
              
              
              
              
            
          
          
             State.update({ strEther: e.target.value })}
              placeholder="Amount"
            />
          
           {
              State.update({
                strEther: (state.balance > 0.05
                  ? parseFloat(state.balance) - 0.05
                  : 0
                ).toFixed(2),
              });
            }}
          >
            
              MAX
            
          
        
        {!!state.sender ? (
           submitEthers(state.strEther, state.sender)}
          >
            Submit
          
        ) : (
          
        )}

        
          {state.sender && (
            
              You will receive
              ${state.strEther ?? 0} stETH
            
          )}
          
            Exchange rate
            1 ETH = 1 stETH
          
          {false && (
            
              Transaction cost
              {state.txCost}
            
          )}
          
            Reward fee
            10%
          
        
      
    
  
);
```



:::danger ETH Disabled in Docs
For a working example visit the deployed NEAR Component.
::


Next Steps
Build and deploy your first components without leaving the browser. Go to https://app.jutsu.ai/, create an account and start building!

### Choose your Dev Environment

The environments in which you can develop Components are divided into two categories:

Web Tools: Online tools that allow you to quickly start building and sharing components.
Local Tools: Tools that allow you to develop and test components locally.

tipandling collaborations
If you plan to collaborate with multiple people, we recommend you to check [this repository template](https://github.com/near-examples/bos-components) which automatically deploys components each time a PR is merged. 


Web Tools
The quickest way to start building NEAR Components is by using one of the online tools. They are great for taking your first steps, while they let you find other developers and components in the NEAR ecosystem.
Jutsu.ai
Jutsu.ai is a web IDE made for NEAR developers. It contains examples and tutorials to help onboarding you.

Local Tools
If you want to collaborate with a team or work on a larger project, you will likely want more version control, automated testing and deployment, and other workflows. For this, the NEAR ecosystem offers a set of tools to easily develop and test your components entirely locally.
NEAR VSCode Extension
The NEAR VSCode Extension integrates with the VSCode IDE to help you develop, preview and deploy components all within VSCode.
BOS Loader
A CLI tool to preview local components in NEAR BOS. A perfect companion to the BOS CLI.
BOS CLI
A command line utility that simplifies local component development for NEAR BOS.
BOS Workspace
A comprehensive toolset for simplifying the local development of NEAR components and applications, featuring hot reload, TypeScript support, multi-app management, and a local gateway.
Além
A web3 JavaScript/TypeScript library to create web3 applications for Near BOS. It's developer-friendly and uses React patterns, making it easy to organize files and write code. Access the Além Docs to get to know more.

### Using components on WebApps

In order to use the components you create in a WebApp you need to use what is known as the NEAR VM. This virtual machine helps you to easily fetch components from the blockchain and transform them into executable code.
There are two possible scenarios:

You want to start a WebApp from scratch.
You want to integrate components into an existing WebApp


Starting a WebApp from scratch
If you want to start a WebApp from scratch, the simplest option is to use create-near-app. To use it, you only need to have node.js installed on your computer.
Simply run the following command and follow the instructions:
npx create-near-app@latest
tiputorial
To learn more about the template created by `create-near-app` see our [Quickstart a WebApp](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/quickstart.md) tutorial.


Integrating Components into your WebApp
In order to integrate components into your WebApp you will leverage two libraries:

Wallet Selector: Allows user to login using their preferred NEAR wallet.
NEAR VM: Simplifies fetching NEAR components from the blockchain and rendering them.

The best way to learn how to integrate components into your WebApp is by following our tutorial:
tiputorial
To learn step-by-step how to integrate them, please visit our [integrating components into a WebApp](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/4.web3-apps/integrate-components.md) tutorial.

### Yield and Resume

NEAR smart contracts can yield execution, until an external service resumes them. In practice, the contract yields a cross-contract call to itself, until an external service executes a function and the contract decides to resume.
This is a powerful feature that allows contracts to wait for external events, such as a response from an oracle, before continuing execution (read our blog post!).
info
Contract can wait for 200 blocks - around 4 minutes - after which the yielded function will execute, receiving a "timeout error" as input


Yielding a Promise
Let's look at an example that takes a prompt from a user (e.g. "What is 2+2"), and yields the execution until an external service provides a response.

  
    
  

Creating a Yielded Promise
In the example above, we are creating a Promise to call the contract's function return_external_response.
Notice that we create the Promise using env::promise_yield_create, which will create an identifier for the yielded promise in the YIELD_REGISTER.
Retrieving the Yielded Promise ID
We read the YIELD_REGISTER to retrieve the ID of our yielded promise. We store the yield_id and the user's prompt so the external service query them (the contract exposes has a function to list all requests).
Returning the Promise
Finally, we return the Promise, which will not execute immediately, but will be yielded until the external service provides a response.


 What is that `self.request_id` in the code? 

The `self.request_id` is an internal unique identifier that we use to keep track of stored requests. This way, we can delete the request once the external service provides a response (or the waiting times out)

Since we only use it to simplify the process of keeping track of the requests, you can remove it if you have a different way of tracking requests (e.g. an indexer)



Signaling the Resume
The env::promise_yield_resume function allows us to signal which yielded promise should execute, as well as which parameters to pass to the resumed function.

  
    
  

In the example above, the respond function would be called by an external service, passing which promise should be resume (yield_id), and the response to the prompt. 
warning Gatekeeping the Resume

Since the function used to signal the resume is public, developers must make sure to guard it properly to avoid unwanted calls. This can be done by simply checking the caller of the function



The Function that Resumes
The function being resumed will have access to all parameters passed to it, including those passed during the yield creation, or the external service response.

  
    
  

In the example above, the return_external_response receives two parameters:

A request_id - passed on creation - which is used to remove the request from the state
A response - passed when signaling to resume - which contains the external response, or a PromiseError if the contract timed out while waiting

tiphere's plenty of time

The contract will be able to wait for 200 blocks - around 4 minutes - before timing out


info
Notice that, in this particular example, we choose to return a value both if there is a response or a time out
The reason to not raise an error, is because we are changing the state (removing the request in line #7), and raising an error would revert this state change

### SDK Types

Lets discuss which types smart contracts use to input and output data, as well as how such data is stored and handled in the contract's code.




    ### Native Types
    Smart contracts can receive, store and return data using JS native types:
    - `string`
    - `number`
    - `boolean`
    - `Array`
    - `Map`
    - `Object`
    - `BigInt`





    ### Native Types
    Smart contracts can receive, store and return data using the following Rust types:
    - `string`
    - `i8-i32/u8-u32`
    - **`u64/128`**: It is preferable to use SDK types `U64` and `U128`
    - `bool`
    - `HashMap`
    - `Vector`





warning `U64/U128`

Smart contracts can store `u64` and `u128`, but these types need to be converted to `string` for input/output, since JSON cannot serialize values with more than 52 bits

To simplify development, the SDK provides the `U64` and `U128` types which are automatically casted to `u64/u128` when stored, and to `string` when used as input/output







    ### Complex Objects
    Smart contracts can store and return complex objects

    **Note:** Objects will always be received and returned as JSON





    #### Serializers
    Objects that will be used as input or output need to be serializable to JSON, add the `#[near(serializer=json)]` macro

    Objects that will be stored in the contract's state need to be serializable to Borsh, add the `#[near(serializer=borsh)]` macro





    ### Handling Tokens
    `$NEAR` tokens are typed as `BigInt` in JS, and their values represented in `yoctonear`

    **Note:** 1 NEAR = 10^24 yoctoNEAR





    ### Handling Tokens
    `$NEAR` tokens are handled through the `NearToken` struct, which exposes methods to represent the value in `yoctonear`, `milinear` and `near`

    **Note:** 1 NEAR = 10^24 yoctonear





    ### Account
    The SDK exposes a special type to handle NEAR Accounts, which automatically checks if the account address is valid

### State

Smart contracts store data in their account's state, which is public on the chain. The storage starts empty until a contract is deployed and the state is initialized.
It is important to know that the account's code and account's storage are independent. Updating the code does not erase the state.





    ### Defining the State
    The attributes of the `class` marked as the contract define the data that will be stored.

    The contract can store all native types (e.g. `number`, `string`, `Array`, `Map`) as well as complex objects.

    For example, our Auction contract stores when the auction ends, and an object representing the highest bid.

    **Note:** The SDK also provides [collections](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./collections.md) to efficiently store collections of data.





    ### Defining the State
    The attributes of the `struct` marked as the contract define the data that will be stored.

    The contract can store all native types (e.g. `u8`, `string`, `HashMap`, `Vector`) as well as complex objects.

    For example, our Auction contract stores when the auction ends, and an object representing the highest bid.

    **Note:** The structures that will be saved need a special macro, that tells the SDK to store them [serialized in Borsh](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./serialization.md).

    **Note:** The SDK also provides [collections](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./collections.md) to efficiently store collections of data.





warning

Contracts pay for their storage by locking part of their balance.

It currently costs ~**1Ⓝ** to store **100KB** of data.







    ### Initializing the State
    After the contract is deployed, its state is empty and needs to be initialized with
    some initial values.

    There are two ways to initialize a state:
      1. By creating an initialization function
      2. By setting default values





    ### I. Initialization Functions
    An option to initialize the state is to create an `initialization` function, which needs to be called before executing any other function.

    In our Auction example, the contract has an initialization function that sets when the auction ends. Note the `@initialization` decorator, and the forced initialization on `NearBindgen`.

    **Note:** It is a good practice to mark initialization functions as private. We will cover function types in the [functions section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./functions.md).





warning

In TS/JS you still **must** set default values for the attributes, so the SDK can infer their types.







    ### I. Initialization Functions
    An option to initialize the state is to create an `initialization` function, which needs to be called before executing any other function.

    In our Auction example, the contract has an initialization function that sets when the auction ends. The contract derives the `PanicOnDefault`, which forces the user to call the init method denoted by the `#[init]` macro.

    **Note:** It is a good practice to mark initialization functions as private. We will cover function types in the [functions section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./functions.md).





    ### II. Default State
    Another option to initialize the state is to set default values for the attributes of the class.

    Such is the case for our "Hello World" contract, which stores a `greeting` with the default value `"Hello"`.

    The first time the contract is called (somebody executes `get_greeting` or `set_greeting`), the default values will be stored in the state, and the state will be considered initialized.

    **Note:** The state can only be initialized once.





    ### II. Default State
    Another option to initialize the state is to create a `Default` version of our contract's `struct`.

    For example, our "Hello World" contract has a default state with a `greeting` set to `"Hello"`.

    The first time the contract executes, the `Default` will be stored in the state, and the state will be considered initialized.

    **Note:** The state can only be initialized once.





    ### Lifecycle of the State
    When a function is called, the contract's state is loaded from the storage and put into memory.

    The state is actually [stored serialized](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./serialization.md), and the SDK takes a bit of time to deserialize it before the method can access it.

    When the method finishes executing successfully, all the changes to the state are serialized, and saved back to the storage.





warning State and Code

In NEAR, the contract's code and contract's storage are **independent**.

Updating the code of a contract does **not erase** the state, and can indeed lead to unexpected behavior or errors.

Make sure to read the [updating a contract](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/release/upgrade.md) if you run into issues.

### Notes on Serialization

Smart contracts need to be able to communicate complex data in a simple way, while
also reading and storing such data into their states efficiently.
To achieve such simple communication and efficient storage, smart contracts morph the data
from their complex representation into simpler ones.
This process of translating complex objects into simpler single-value representations is called
serialization. NEAR uses two serialization formats: JSON and
Borsh.

JSON is used to serialize the contract's input/output during a function call
Borsh is used to serialize the contract's state.


Overview of Serialization Formats
Let's give a quick overview of both serialization formats, including their pros and cons, as well as
an example of what their serializations look like.

JSON: Objects to Strings
Features

Self-describing format
Easy interoperability with JavaScript
Multiple implementations readily available
But... it is not efficient both in computational times and resulting size

Example
Example{
  number: i32 = 2;
  arr: Vector<i32> = [0, 1];
}

// serializes to
"{"number": 2, "arr": [0, 1]}"

Borsh: Objects to Bytes
Features

Compact, binary format built to be efficiently (de)serialized
Strict and canonical binary representation
Less overhead: it does not need to store attributes names
But... it is necessary to know the schema to (de)serialize the data

Example
Example{
  number: i32 = 2;
  arr: Vector<i32> = [0, 1];
}

// serializes into
[2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]


NEAR contracts can implement methods that both take and return complex objects.
In order to handle this data in a simple way, JSON serialization is used.
Using JSON makes it easier for everyone to talk with the contracts, since most
languages readily implement a JSON (de)serializer.
Example
Let's look at this example, written only for educational purposes:
#[derive(Serialize)]
#[serde(crate = "near_sdk::serde")]
pub struct A {
  pub a_number: i32,
  pub b_number: u128
}

#[derive(Serialize)]
#[serde(crate = "near_sdk::serde")]
pub struct B {
  pub success: bool,
  pub other_number: i32
}

pub fn method(&self, struct_a: A): B {
  return B{true, 0}
}
Receiving Data
When a user calls the method, the contract receives the arguments encoded as a JSON string
(e.g. "{"a_number":0, "b_number":"100"}"), and proceed to (de)serialize them into
the correct object (A{0, 100}) .
Returning Data

When returning the result, the contract will automatically encode the object B{true, 0}
into its JSON serialized value: "{"success":true, "other_number":0}" and return this
string.
::caution JSON Limitations
Since JSON is limited to 52 bytes numbers, you cannot use u64/u128 as input
or output. JSON simply cannot serialize them. Instead, you must use Strings.
The NEAR SDK RS currently implements the near_sdk::json_types::{U64, I64, U128, I128}
that you can use for input / output of data.
::


Borsh: State Serialization
Under the hood smart contracts store data using simple key/value pairs. This means that
the contract needs to translate complex states into simple key-value pairs.
For this, NEAR contracts use borsh which is optimized for (de)serializing
complex objects into smaller streams of bytes.
tipDK-JS still uses json
The JavaScript SDK uses JSON to serialize objects in the state, but the borsh implementation
should arrive soon

Example
Let's look at this example, written only for educational purposes:
#[near(serializers = [json, borsh])]
#[derive(PanicOnDefault)]
pub struct Contract {
  string: String,
  vector: Vector<u8>
}

#[near]
impl Contract {
  #[init]
  pub fn init(string: String, first_u8: u8) -> Self {
    let mut vector: Vector<u8> = Vector::new("prefix".as_bytes());
    vector.push(&first_u8);

    Self { string, vector }
  }

  pub fn change_state(&mut self, string: String, number: u8) {
    self.string = string;
    self.vector.push(&number);
  }
}
Empty State On Deploy
If we deploy the contract into a new account and immediately ask for the state we will see
it is empty:

  

  ```bash
  near view-state $CONTRACT --finality optimistic

  # Result is: []
  ```
  

  

  ```bash
  near contract view-storage $CONTRACT all as-json network-config testnet now
  ```
  

Initializing the State
If we initialize the state we can see how Borsh is used to serialize the state

  

  ```bash
  # initialize with the string "hi" and 0
  near call $CONTRACT init '{"string":"hi", "first_u8":0}' --accountId $CONTRACT

  # check the state
  near view-state $CONTRACT --utf8 --finality optimistic
  ```
  

  

  ```bash
  # initialize with the string "hi" and 0
  near contract call-function as-transaction $CONTRACT init json-args '{"string":"hi", "first_u8":0}' prepaid-gas '30.0 Tgas' attached-deposit '0 NEAR' sign-as $CONTRACT network-config testnet sign-with-keychain send

  # check the state
  near contract view-storage $CONTRACT all as-json network-config testnet now
  ```
  



 Result 

```bash
[
  {
    key: 'STATE',
    value: 'x02x00x00x00hix01x00x00x00x00x00x00x00x06x00x00x00prefix'
  },
  { key: 'prefixx00x00x00x00x00x00x00x00', value: 'x00' }
]
```

The first key-value is:
key: 'STATE'
value: 'x02x00x00x00hix01x00x00x00x00x00x00x00x06x00x00x00prefix'
Since the Contract has a structure string, Vector<u8> the value is interpreted as:
[2, 0, 0, 0, "h", "i"] -> The `string` has 2 elements: "h" and "i".
[1, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, "prefix"] -> The Vector has 1 element, and to see the values search for keys that start with (the 6 bytes prefix): "prefix"
Then, the second key-value shows the entries of the Vector denoted by the "prefix" string:
key: 'prefixx00x00x00x00x00x00x00x00'
value: 'x00'
Modifying the State
If we modify the stored string and add a new number, the state changes accordingly:

  

  ```bash
  near call $CONTRACT change_state '{"string":"bye", "number":1}' --accountId $CONTRACT
  ```
  

  

  ```bash
  near contract call-function as-transaction $CONTRACT change_state json-args '{"string":"bye", "number":1}' prepaid-gas '30.0 Tgas' attached-deposit '0 NEAR' sign-as $CONTRACT network-config testnet sign-with-keychain send
  ```
  



 Result 

```bash
[
  {
    key: 'STATE',
    value: 'x03x00x00x00byex02x00x00x00x00x00x00x00x06x00x00x00prefix'
  },
  { key: 'prefixx00x00x00x00x00x00x00x00', value: 'x00' },
  { key: 'prefixx01x00x00x00x00x00x00x00', value: 'x01' }
]
```

We can see that the STATE key changes to reflect the storage of the new string (bye), and that
the vector now has 2 elements.
At the same time, a new key-value was added adding the new vector entry: the 1u8 we just added.


Deserialization Error
When somebody invokes a smart contract method, the first step for the contract is to deserialize
its own state.
In the example used above, the contract will start by reading the STATE key and
try to deserialize its value into an object Contract{string: String, vector: Vector<u8>}.
If you deploy a contract into the account with a different Contract structure, then the
contract will fail to deserialize the STATE key and panic Cannot deserialize the contract state.
To solve this, you can either:

Rollback to the previous contract code
Implement a method to migrate the contract's state

### Serialization Protocols

Serialization formats within the SDK define how data structures are translated into bytes which are needed for passing data into methods of the smart contract or storing data in state. For the case of method parameters, JSON (default) and Borsh are supported with the SDK and for storing data on-chain Borsh is used.
The qualities of JSON and Borsh are as follows:
JSON:

Human-readable
Self-describing format (don't need to know the underlying type)
Easy interop with JavaScript
Less efficient size and (de)serialization

Borsh:

Compact, binary format that's efficient for serialized data size
Need to know data format or have a schema to deserialize data
Strict and canonical binary representation
Fast and less overhead in most cases

In general, JSON will be used for contract calls and cross-contract calls for a better DevX, where Borsh can be used to optimize using less gas by having smaller parameter serialization and less deserialization computation within the contract.
Overriding Serialization Protocol Default
The result and parameter serialization can be opted into separately, but all parameters must be of the same format (can't serialize some parameters as borsh and others as JSON). An example of switching both the result and parameters to borsh is as follows:
#[result_serializer(borsh)]
pub fn sum_borsh(#[serializer(borsh)] a: u32, #[serializer(borsh)] b: u32) -> u32 {
    a + b
}
Where the result_serializer(borsh) annotation will override the default result serialization protocol from JSON to borsh and the serializer(borsh) annotations will override the parameter serialization.
Example
A simple demonstration of getting a Borsh-serialized, base64-encoded value from a unit test:

The following snippet shows a simple function that takes this value from a frontend or CLI. Note: this method doesn't have a return value, so the #[result_serializer(borsh)] isn't needed.

Note that this is using this simple struct:

To call this with NEAR CLI, use a command similar to this:



```bash
near call rust-status-message.demo.testnet set_status_borsh --base64 'DAAAAEFsb2hhIGhvbnVhIQ==' --accountId demo.testnet
```



```bash
near contract call-function as-transaction rust-status-message.demo.testnet set_status_borsh base64-args 'DAAAAEFsb2hhIGhvbnVhIQ==' prepaid-gas '30 TeraGas' attached-deposit '0 NEAR' sign-as demo.testnet network-config testnet sign-with-keychain send
```


See more details in this GitHub gist from Marcelo.
JSON wrapper types
To help with serializing certain types to JSON which have unexpected or inefficient default formats, there are some wrapper types in near_sdk::json_types that can be used.
Because JavaScript only supports integers to value 2^53 - 1, you will lose precision if deserializing the JSON integer is above this range. To counteract this, you can use the I64, U64, I128, and U128 in place of the native types for these parameters or result to serialize the value as a string. By default, all integer types will serialize as an integer in JSON.
You can convert from U64 to u64 and back using std::convert::Into, e.g.
#[near]
impl Contract {
    pub fn mult(&self, a: U64, b: U64) -> U128 {
        let a: u64 = a.into();
        let b: u64 = b.into();
        let product = u128::from(a) * u128::from(b);
        product.into()
    }
}
You can also access inner values and using .0:
 #[near]
 impl Contract {
     pub fn mult(&self, a: U64, b: U64) -> U128 {
-        let a: u64 = a.into();
+        let a = a.0;
-        let b: u64 = b.into();
+        let b = b.0;
         let product = u128::from(a) * u128::from(b);
         product.into()
     }
 }
And you can cast the lower-case u variants to upper-case U variants using U64(...) and U128(...):
 #[near]
 impl Contract {
     pub fn mult(&self, a: U64, b: U64) -> U128 {
         let a = a.0;
         let b = b.0;
         let product = u128::from(a) * u128::from(b);
-        product.into()
+        U128(product)
     }
 }
Combining it all:
#[near]
impl Contract {
    pub fn mult(&self, a: U64, b: U64) -> U128 {
        U128(u128::from(a.0) * u128::from(b.0))
    }
}
Although there are these JSON wrapper types included with the SDK, any custom type can be used, as long as it implements serde serialize and deserialize respectively. All of these types just override the JSON format and will have a consistent borsh serialization and deserialization as the inner types.
Base64VecU8
Another example of a type you may want to override the default serialization of is Vec<u8> which represents bytes in Rust. By default, this will serialize as an array of integers, which is not compact and very hard to use. There is a wrapper type Base64VecU8 which serializes and deserializes to a Base-64 string for more compact JSON serialization.
Example here:
#[near(contract_state)]
#[derive(PanicOnDefault)]
pub struct Contract {
    // Notice, internally we store `Vec<u8>` 
    pub data: Vec<u8>,
}

#[near]
impl Contract {
    #[init]
    pub fn new(data: Base64VecU8) -> Self {
        Self {
            data: data.into(),
        }
    }
    pub fn get_data(self) -> Base64VecU8 {
        self.data.into()
    }
}

### Reproducible Builds

Reproducible builds let different people build the same program and get the exact same outputs as one another. It helps users trust that deployed contracts are built correctly and correspond to the source code. To verify your contract user can build it themselves and check that the binaries are identical.
Problem
If you will build your contract on two different machines, most likely you will get two similar but not identical binaries. Your build artifact can be affected by the locale, timezone, build path, and billion other factors in your build environment. Rust community has a long story of fighting this issue but still, it is not achieved yet.
CI solution
We recommend you to build your contracts with the use of our Contract Builder. It's is using Docker, controlled and sharable environment that can be used by both you and your users. Docker image is available here. The contract built in it will result in a binary that is the same if built on other machines.

### Reducing Contract Size

Reducing a contract's size

This page is made for developers familiar with lower-level concepts who wish to reduce their contract size significantly, perhaps at the expense of code readability.
Some common scenarios where this approach may be helpful:

contracts intended to be tied to one's account management
contracts deployed using a factory
future advancements similar to the EVM on NEAR

There have been a few items that may add unwanted bytes to a contract's size when compiled. Some of these may be more easily swapped for other approaches while others require more internal knowledge about system calls.
Small wins
Using flags
When compiling a contract make sure to pass flag -C link-arg=-s to the rust compiler:
RUSTFLAGS='-C link-arg=-s' cargo build --target wasm32-unknown-unknown --release
Here is the parameters we use for the most examples in Cargo.toml:
[profile.release]
codegen-units = 1
opt-level = "s"
lto = true
debug = false
panic = "abort"
overflow-checks = true
You may want to experiment with using opt-level = "z" instead of opt-level = "s" to see if generates a smaller binary. See more details on this in The Cargo Book Profiles section. You may also reference this Shrinking .wasm Size resource.
Removing rlib from the manifest

Ensure that your manifest (Cargo.toml) doesn't contain rlib unless it needs to. Some NEAR examples have included this:
::caution Adds unnecessary bloat

[lib]
crate-type = ["cdylib", "rlib"]
:::
when it could be:
tip```toml
[lib]
crate-type = ["cdylib"]
```


When using the Rust SDK, you may override the default JSON serialization to use Borsh instead. See this page for more information and an example.

When using assertions or guards, avoid using the standard assert macros like assert!, assert_eq!, or assert_ne! as these may add bloat for information regarding the line number of the error. There are similar issues with unwrap, expect, and Rust's panic!() macro.

Example of a standard assertion:
::caution Adds unnecessary bloat

assert_eq!(contract_owner, predecessor_account, "ERR_NOT_OWNER");
:::
when it could be:
tip  ```rust
if contract_owner != predecessor_account {
env::panic(b"ERR_NOT_OWNER");
}
```


Example of removing expect:
::caution Adds unnecessary bloat

let owner_id = self.owner_by_id.get(&token_id).expect("Token not found");
:::
when it could be:
tip  ```rust
fn expect_token_found(option: Option) -> T {
option.unwrap_or_else(|| env::panic_str("Token not found"))
}
let owner_id = expect_token_found(self.owner_by_id.get(&token_id));  
```


Example of changing standard panic!():
::caution Adds unnecessary bloat

panic!("ERR_MSG_HERE"); 
:::
when it could be:
tip  ```rust
env::panic_str("ERR_MSG_HERE");  
```



Ready to use script
We have prepared a simple bash script that can be used to minify .wasm contract file. You can find it here.
The current approach to minification is the following:

Snip (i.e. just replace with unreachable instruction) few known fat functions from the standard library (such as float formatting and panic-related) with wasm-snip.
Run wasm-gc to eliminate all functions reachable from the snipped functions.
Strip unneeded sections, such as names with wasm-strip.
Run binaryen wasm-opt, which cleans up the rest.

Requirements to run the script:

install wasm-snip and wasm-gc with Cargo:
cargo install wasm-snip wasm-gc
install binaryen and wabt on your system. For Ubuntu and other Debian based Linux distributions run:
apt install binaryen wabt

:::danger

Minification could be rather aggressive, so you must test the contract after minification. Standalone NEAR runtime could be helpful here.
::

Lower-level approach
For a no_std approach to minimal contracts, observe the following examples:

Tiny contract
NEAR ETH Gateway
This YouTube video where Eugene demonstrates a fungible token in no_std mode. The code for this example lives here.
Examples using a project called nesdie.
Note that Aurora has found success using rjson as a lightweight JSON serialization crate. It has a smaller footprint than serde which is currently packaged with the Rust SDK. See this example of rjson in an Aurora repository, although implementation details will have to be gleaned by the reader and won't be expanded upon here. This nesdie example also uses the miniserde crate, which is another option to consider for folks who choose to avoid using the Rust SDK.

noteInformation on system calls


  Expand to see what's available from sys.rs

### External Interface

Smart contracts expose functions so users can interact with them. There are different types of functions including read-only, private and payable.




### Contract's Interface

All **public** functions in the contract are part of its **interface**. They can be called by anyone, and are the only way to interact with the contract.






 Exposing trait implementations 

Functions can also be exposed through trait implementations. This can be useful if implementing a shared interface or standard for a contract. This code generation is handled very similarly to basic `pub` functions, but the `#[near]` macro only needs to be attached to the trait implementation, not the trait itself:

```rust
pub trait MyTrait {
    fn trait_method(&mut self);
}

#[near]
impl MyTrait for MyContractStructure {
    fn trait_method(&mut self) {
        // .. method logic here
    }
}
```






### Initialization Functions
A contract can opt to have an initialization function. If present, this function must be called before any other to [initialize the contract](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./storage.md).





#### `@initialize({ privateFunction: true })`
The initialization function is marked with the `@initialize` decorator.





#### `#[init]`
The initialization function is marked with the `#[init]` macro.





### State Changing Functions
The functions that modify the [state](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./storage.md) or perform [actions](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./actions.md) need to be called by a user with a NEAR account, since a transaction is required to execute them.





#### `@call`
State changing functions are marked with the `@call` decorator.





#### `mut &self`
State changing functions are those that take a **mutable** reference to `self` in Rust.





tipThe SDK provides [contextual information](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./environment.md), such as which account is calling the function, or what time it is.







### Read-Only Functions
Contract's functions can be read-only, meaning they don't modify the state. Calling them is free for everyone, and does not require to have a NEAR account.





#### `@view`
Read-only functions are marked with the `@view` decorator in TS/JS.





#### `&self`
Read-only functions are those that take an **immutable** reference to `self` in Rust.





### Private Functions
Many times you will want to have functions that **are exposed** as part of the contract's interface, but **should not be called directly** by users.

Besides initialization functions, [callbacks from cross-contract calls](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./crosscontract.md) should always be `private`.

These functions are marked as `private` in the contract's code, and can only be called by the contract itself.





#### `decorator({privateFunction: true})`
Private functions are marked by setting `privateFunction: true` in the `@call` or `@initialization` decorators.





#### [#private]
Private functions are marked using the `#[private]` macro in Rust.





### Payable Functions
By default, functions will panic if the user attaches NEAR Tokens to the call. Functions that accept NEAR Tokens must be marked as `payable`.

Within the function, the user will have access to the [attached deposit](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./environment.md).





#### `@call({payableFunction: true})`
Payable functions are marked by setting `payableFunction: true` in the `@call` decorator.





#### [#payable]
Payable functions are marked using the `#[payable]` macro in Rust.





### Internal Functions
All the functions we covered so far are part of the interface, meaning they can be called by an external actor.

However, contracts can also have private internal functions - such as helper or utility functions - that are **not exposed** to the outside world.

To create internal private methods in a JS contract, simply omit the `@view` and `@call` decorators.





### Internal Functions
All the functions we covered so far are part of the interface, meaning they can be called by an external actor.

However, contracts can also have private internal functions - such as helper or utility functions - that are **not exposed** to the outside world.

To create internal private methods in a Rust contract, do not declare them as public (`pub fn`).





  
   Separate impl block 

  Another way of not exporting methods is by having a separate `impl Contract` section, that is not marked with `#[near]`.

  ```rust
  #[near]
  impl Contract {
      pub fn increment(&mut self) {
          self.internal_increment();
      }
  }
  impl Contract {
      /// This methods is still not exported.
      pub fn internal_increment(&mut self) {
          self.counter += 1;
      }
  }
  ```

  





### Pure Functions
Pure functions are a special kind of function that do not require to access data from the state.

They are useful to return hardcoded values on the contract.









```js
@NearBindgen({})
class Contract {
  helper_function(params... ){
    // this function cannot be called from the outside
  }

  @view({})
  interface_view(params...){
    // this function can be called from outside
  }

  @call({privateFunction: true}){
    // this function can be called from outside, but
    // only by the contract's account
  }
}
```





```rs
const SOME_VALUE: u64 = 8;

#[near]
impl MyContractStructure {
  fn internal_helper(mut &self, params... ){
    // this function cannot be called from the outside
  }

  pub fn public_log(/* Parameters here */) {
      near_sdk::log!("inside log message");
  }

  pub fn return_static_u64() -> u64 {
      SOME_VALUE
  }
}
```

### Environment

Every method execution has an environment associated with information such as:

Who called the method
How much money is attached to the call
How many computational resources are available
The current timestamp
Helper functions for Public Key derivation, for example


Environment Variables

  

| Variable Name          | SDK Variable                  | Description                                                                          |
|------------------------|-------------------------------|--------------------------------------------------------------------------------------|
| Predecessor            | `near.predecessorAccountId()` | Account ID that called this method                                                   |
| Current Account        | `near.currentAccountId()`     | Account ID of this smart contract                                                    |
| Signer                 | `near.signerAccountId()`      | Account ID that signed the transaction leading to this execution                     |
| Attached Deposit       | `near.attachedDeposit()`      | Amount in yoctoNEAR attached to the call by the predecessor                          |
| Account Balance        | `near.accountBalance()`       | Balance of this smart contract (including Attached Deposit)                          |
| Prepaid Gas            | `near.prepaidGas()`           | Amount of gas available for execution                                                |
| Timestamp              | `near.blockTimestamp()`       | Current timestamp (number of non-leap-nanoseconds since January 1, 1970 0:00:00 UTC) |
| Current Epoch          | `near.epochHeight()`          | Current epoch in the blockchain                                                      |
| Block Index            | `near.blockIndex()`           | Current block index (a.k.a. block height)                                            |
| Storage Used           | `near.storageUsage()`         | Current storage used by this smart contract                                          |
| Used Gas               | `near.usedGas()`              | Amount of gas used for execution                                                     |
| Signer Public Key      | `near.signerAccountPk()`      | Sender Public Key                                                                    |
| Account Locked Balance | `near.accountLockedBalance()` | Balance of this smart contract that is locked                                        |





| Variable Name          | SDK Variable                    | Description                                                                          |
|------------------------|---------------------------------|--------------------------------------------------------------------------------------|
| Predecessor            | `env::predecessor_account_id()` | Account ID that called this method                                                   |
| Current Account        | `env::current_account_id()`     | Account ID of this smart contract                                                    |
| Signer                 | `env::signer_account_id()`      | Account ID that signed the transaction leading to this execution                     |
| Attached Deposit       | `env::attached_deposit()`       | Amount in yoctoNEAR attached to the call by the predecessor                          |
| Account Balance        | `env::account_balance()`        | Balance of this smart contract (including Attached Deposit)                          |
| Prepaid Gas            | `env::prepaid_gas()`            | Amount of gas available for execution                                                |
| Timestamp              | `env::block_timestamp()`        | Current timestamp (number of non-leap-nanoseconds since January 1, 1970 0:00:00 UTC) |
| Current Epoch          | `env::epoch_height()`           | Current epoch in the blockchain                                                      |
| Block Index            | `env::block_index()`            | Current block index (a.k.a. block height)                                            |
| Storage Used           | `env::storage_usage()`          | Current storage used by this smart contract in bytes                                 |
| Storage Byte Cost      | `env::storage_byte_cost()`      | Current storage cost per byte in yoctoNEAR                                           |
| Used Gas               | `env::used_gas()`               | Amount of gas used for execution                                                     |
| Signer Public Key      | `env::signer_account_pk()`      | Sender Public Key                                                                    |
| Account Locked Balance | `env::account_locked_balance()` | Balance of this smart contract that is locked                                        |





Who is Calling? Who am I?
The environment gives you access to 3 important users: the current_account, the predecessor, and the signer.
Current Account
The current_account contains the address in which your contract is deployed. This is very useful to implement ownership, e.g. making a public method only callable by the contract itself.
Predecessor and Signer
The predecessor is the account that called the method in the contract. Meanwhile, the signer is the account that signed the initial transaction.
During a simple transaction (no cross-contract calls) the predecessor is the same as the signer. For example, if alice.near calls contract.near, from the contract's perspective, alice.near is both the signer and the predecessor. However, if contract.near creates a cross-contract call, then the predecessor changes down the line. In the example below, when pool.near executes, it would see contract.near as the predecessor and alice.near as the signer.

You can access information about the users interacting with your smart contract
tipn most scenarios you will **only need to know the predecessor**. However, there are situations in which the signer is very useful. For example, when adding [NFTs](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/5.primitives/nft.md) into [this marketplace](https://github.com/near-examples/nft-tutorial/blob/7fb267b83899d1f65f1bceb71804430fab62c7a7/market-contract/src/nft_callbacks.rs#L42), the contract checks that the `signer`, i.e. the person who generated the transaction chain, is the NFT owner.


Balances and Attached NEAR
The environment gives you access to 3 token-related parameters, all expressed in yoctoNEAR (1 Ⓝ = 1024yⓃ):
Attached Deposit
attached_deposit represents the amount of yoctoNEAR the predecessor attached to the call.
This amount is already deposited in your contract's account, and is automatically returned to the predecessor if your method panics.
warning
If you make a cross-contract call and it panics, the funds are sent back to your contract. See how to handle this situation in the callback section

Account Balance
account_balance represents the balance of your contract (current_account).
It includes the attached_deposit, since it was deposited when the method execution started.
If the contract has any locked $NEAR, it will appear in account_locked_balance.

Storage Used
storage_used represents the amount of storage that is currently being used by your contract.
tipf you want to know how much storage a structure uses, print the storage before and after storing it.


Telling the Time
The environment exposes three different ways to tell the pass of time, each representing a different dimension of the underlying blockchain.
Timestamp
The timestamp attribute represents the approximated UNIX timestamp in nanoseconds at which this call was executed. It quantifies time passing in a human way, enabling us to check if a specific date has passed or not.
Current Epoch
The NEAR blockchain groups blocks in Epochs. The current_epoch attribute measures how many epochs have passed so far. It is very useful to coordinate with other contracts that measure time in epochs, such as the validators.
Block Index
The block_index represents the index of the block in which this transaction will be added to the blockchain.

Gas
Your contract has a limited number of computational resources to use on each call. Such resources are measured in Gas.
Gas can be thought of as wall time, where 1 PetaGas (1_000 TGas) is ~1 second of compute time.
Each code instruction costs a certain amount of Gas, and if you run out of it, the execution halts with the error message Exceeded the prepaid gas.
The environment gives you access to two gas-related arguments: prepaid_gas and used_gas.
Prepaid Gas
prepaid_gas represents the amount of Gas the predecessor attached to this call. It cannot exceed the limit 300TGas (300 * 1012 Gas).
Used Gas
used_gas contains the amount of Gas that has been used so far. It is useful to estimate the Gas cost of running a method.
warning
During cross-contract calls always make sure the callback has enough Gas to fully execute.

tipIf you already [estimated the Gas](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/protocol/gas.md#estimating-costs-for-a-call) a method needs, you can ensure it never runs out of Gas by using `assert`




```rust
const REQUIRED_GAS: Gas = Gas(20_000_000_000_000); // 20 TGas
assert!(env::prepaid_gas() >= REQUIRED_GAS, "Please attach at least 20 TGas");
```







Environment Functions
Besides environmental variables, the SDK also exposes some functions to perform basic cryptographic operations

  

| Function Name         | SDK method                                       | Description                                                                                                                                                                                                                                                                                                                      |
|-----------------------|--------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| SHA 256               | `near.sha256(value)`                             | Hashes a sequence of bytes using sha256.                                                                                                                                                                                                                                                                                         |
| Keccak 256            | `near.keccak256(value)`                          | Hashes a sequence of bytes using keccak256.                                                                                                                                                                                                                                                                                      |
| Keccak 512            | `near.keccak512(value)`                          | Hashes a sequence of bytes using keccak512.                                                                                                                                                                                                                                                                                      |
| RIPEMD 160            | `near.ripemd160(value)`                          | Hashes the bytes using the RIPEMD-160 hash function.                                                                                                                                                                                                                                                                             |
| EC Recover            | `near.ecrecover(hash, sig, v, malleabilityFlag)` | Recovers an ECDSA signer address from a 32-byte message `hash` and a corresponding `signature` along with `v` recovery byte. Takes in an additional flag to check for malleability of the signature which is generally only ideal for transactions. Returns 64 bytes representing the public key if the recovery was successful. |
| Log String            | `near.log(msg)`                                  | Logs the string message. This message is stored on chain.                                                                                                                                                                                                                                                                        |
| Validator Stake       | `near.validatorStake(accountId)`                 | For a given account return its current stake. If the account is not a validator, returns 0.                                                                                                                                                                                                                                      |
| Validator Total Stake | `near.validatorTotalStake()`                     | Returns the total stake of validators in the current epoch.                                                                                                                                                                                                                                                                      |





| Function Name         | SDK method                                              | Description                                                                                                                                                                                                                                                                                                                      |
|-----------------------|---------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| SHA 256               | `env::sha256(value)`                                    | Hashes a sequence of bytes using sha256.                                                                                                                                                                                                                                                                                         |
| Keccak 256            | `env::keccak256(value)`                                 | Hashes a sequence of bytes using keccak256.                                                                                                                                                                                                                                                                                      |
| Keccak 512            | `env::keccak512(value)`                                 | Hashes a sequence of bytes using keccak512.                                                                                                                                                                                                                                                                                      |
| SHA 256 (Array)       | `env::sha256_array(value)`                              | Hashes the bytes using the SHA-256 hash function. This returns a 32 byte hash.                                                                                                                                                                                                                                                   |
| Keccak 256 (Array)    | `env::keccak256_array(value)`                           | Hashes the bytes using the Keccak-256 hash function. This returns a 32 byte hash.                                                                                                                                                                                                                                                |
| Keccak 512 (Array)    | `env::keccak512_array(value)`                           | Hashes the bytes using the Keccak-512 hash function. This returns a 64 byte hash.                                                                                                                                                                                                                                                |
| RIPEMD 160 (Array)    | `env::ripemd160_array(value)`                           | Hashes the bytes using the RIPEMD-160 hash function. This returns a 20 byte hash.                                                                                                                                                                                                                                                |
| EC Recover            | `env::ecrecover(hash, signature, v, malleability_flag)` | Recovers an ECDSA signer address from a 32-byte message `hash` and a corresponding `signature` along with `v` recovery byte. Takes in an additional flag to check for malleability of the signature which is generally only ideal for transactions. Returns 64 bytes representing the public key if the recovery was successful. |
| Panic String          | `env::panic_str(message)`                               | Terminates the execution of the program with the UTF-8 encoded message.                                                                                                                                                                                                                                                          |
| Log String            | `env::log_str(message)`                                 | Logs the string message. This message is stored on chain.                                                                                                                                                                                                                                                                        |
| Validator Stake       | `env::validator_stake(account_id)`                      | For a given account return its current stake. If the account is not a validator, returns 0.                                                                                                                                                                                                                                      |
| Validator Total Stake | `env::validator_total_stake()`                          | Returns the total stake of validators in the current epoch.                                                                                                                                                                                                                                                                      |




infoIn the JS SDK, `throw new Error("message")` mimics the behavior of Rust's `env::panic_str("message")`.

### Cross-Contract Calls

Your contract can interact with other deployed contracts, querying information and executing functions on them.
Since NEAR is a sharded blockchain, its cross-contract calls behave differently than calls do in other chains. In NEAR. cross-contract calls are asynchronous and independent.
infoCross-Contract Calls are **Independent**

You will need two independent functions: one to make the call, and another to receive the result


infoCross-Contract Calls are **Asynchronous**

There is a delay between the call and the callback execution, usually of **1 or 2 blocks**. During this time, the contract is still active and can receive other calls.



Snippet: Querying Information
While making your contract, it is likely that you will want to query information from another contract. Below, you can see a basic example in which we query the greeting message from our Hello NEAR example.


    




    
            





Snippet: Sending Information
Calling another contract passing information is also a common scenario. Below you can see a function that interacts with the Hello NEAR example to change its greeting message.


    




    
    





Promises
Cross-contract calls work by creating two promises in the network:

A promise to execute code in the external contract (Promise.create)
Optional: A promise to call another function with the result (Promise.then)

Both promises will contain the following information:

The address of the contract you want to interact with
The function that you want to execute
The (encoded) arguments to pass to the function
The amount of GAS to use (deducted from the attached Gas)
The amount of NEAR to attach (deducted from your contract’s balance)

tipThe callback can be made to **any** contract. Meaning that the result could potentially be handled by another contract



Creating a Cross Contract Call
To create a cross-contract call with a callback, create two promises and use the .then method to link them:

  

    ```ts
    NearPromise.new("external_address").functionCall("function_name", JSON.stringify(arguments), DEPOSIT, GAS)
    .then(
      // this function is the callback
      NearPromise.new(near.currentAccountId()).functionCall("callback_name", JSON.stringify(arguments), DEPOSIT, GAS)
    );
    ```

  
  

    There is a helper macro that allows you to make cross-contract calls with the syntax `#[ext_contract(...)]`. It takes a Rust Trait and converts it to a module with static methods. Each of these static methods takes positional arguments defined by the Trait, then the `receiver_id`, the attached deposit and the amount of gas and returns a new `Promise`.

    ```rust
    #[ext_contract(external_trait)]
    trait Contract {
        fn function_name(&self, param1: T, param2: T) -> T;
    }

    external_trait::ext("external_address")
    .with_attached_deposit(DEPOSIT)
    .with_static_gas(GAS)
    .function_name(arguments)
    .then(
      // this is the callback
      Self::ext(env::current_account_id())
      .with_attached_deposit(DEPOSIT)
      .with_static_gas(GAS)
      .callback_name(arguments)
    );

    ```


 Gas 

You can attach an unused GAS weight by specifying the `.with_unused_gas_weight()` method but it is defaulted to 1. The unused GAS will be split amongst all the functions in the current execution depending on their weights. If there is only 1 function, any weight above 1 will result in all the unused GAS being attached to that function. If you specify a weight of 0, however, the unused GAS will **not** be attached to that function. If you have two functions, one with a weight of 3, and one with a weight of 1, the first function will get `3/4` of the unused GAS and the other function will get `1/4` of the unused GAS.



  

info
If a function returns a promise, then it will delegate the return value and status of transaction execution, but if you return a value or nothing, then the Promise result will not influence the transaction status


::caution

The Promises you are creating will not execute immediately. In fact, they will be queued in the network an:

The cross-contract call will execute 1 or 2 blocks after your function finishes correctly.

:::

Callback Function
If your function finishes correctly, then eventually your callback function will execute. This will happen whether the external contract fails or not.
In the callback function you will have access to the result, which will contain the status of the external function (if it worked or not), and the values in case of success.

  
    





  




infoCallback with always execute

We repeat, if your function finishes correctly, then your callback will **always execute**. This will happen no matter if the external function finished correctly or not


warning
Always make sure to have enough Gas for your callback function to execute

tipRemember to mark your callback function as private using macros/decorators, so it can only be called by the contract itself



What happens if the function I call fails?
If the external function fails (i.e. it panics), then your callback will be executed anyway. Here you need to manually rollback any changes made in your
contract during the original call. Particularly:

Refund the predecessor if needed: If the contract attached NEAR to the call, the funds are now back in the contract's account
Revert any state changes: If the original function made any state changes (i.e. changed or stored data), you need to manually roll them back. They won't revert automatically

warning
If your original function finishes correctly then the callback executes even if the external function panics. Your state will not rollback automatically,
and $NEAR will not be returned to the signer automatically. Always make sure to check in the callback if the external function failed, and manually rollback any
operation if necessary.


Concatenating Functions and Promises
✅ Promises can be concatenate using the .and operator: P1.and(P2).and(P3).then(P4): P1, P2, and P3 execute in parallel, after they finish, P4 will execute and have access to all their results
â›” You cannot return a joint promise without a callback: return P1.and(P2) is invalid since it misses the then
✅ You can concatenate then promises: P1.then(P2).then(P3): P1 executes, then P2 executes with the result of P1, then P3 executes with the result of P2
â›” You cannot use an and within a then: P1.then(P2.and(P3)) is invalid
â›” You cannot use a then within a then: P1.then(P2.then(P3)) is invalid

Multiple Functions, Same Contract
You can call multiple functions in the same external contract, which is known as a batch call.
An important property of batch calls is that they act as a unit: they execute in the same receipt, and if any function fails, then they all get reverted.

  

  

  
  

  

  

tipCallbacks only have access to the result of the **last function** in a batch call



Multiple Functions: Different Contracts
You can also call multiple functions in different contracts. These functions will be executed in parallel, and do not impact each other. This means that, if one fails, the others will execute, and NOT be reverted.

  

  

  
  

  

  

tipCallbacks have access to the result of **all functions** in a parallel call



Security Concerns
While writing cross-contract calls there is a significant aspect to keep in mind: all the calls are independent and asynchronous. In other words:

The function in which you make the call and function for the callback are independent.
There is a delay between the call and the callback, in which people can still interact with the contract

This has important implications on how you should handle the callbacks. Particularly:

Make sure you don't leave the contract in a exploitable state between the call and the callback.
Manually rollback any changes to the state in the callback if the external call failed.

We have a whole security section dedicated to these specific errors, so please go and check it.
warning
Not following these basic security guidelines could expose your contract to exploits. Please check the security section, and if still in doubt, join us in Discord.

### Collections

When deciding on data structures it is important to understand their tradeoffs. Choosing the wrong structure can create a bottleneck as the application scales, and migrating the state to the new data structures will come at a cost.
You can choose between two types of collections:

Native collections (e.g. Array, Map, Set), provided by the language
SDK collections (e.g. IterableMap, Vector), provided by the NEAR SDK

Understanding how the contract stores and loads both types of collections is crucial to decide which one to use.
tipative vs SDK Collections

Use native collections for small amounts of data that need to be accessed altogether, and SDK collections for large amounts of data that do not need to be accessed altogether.

If your collection has up to 100 entries, it's acceptable to use the native collection. For larger ones, prefer to use SDK collection. For comparison please refer to [this benchmark](https://www.github.com/volodymyr-matselyukh/near-benchmarking).




 How the State is Handled 

Each time the contract is executed, the first thing it will do is to read the values and [deserialize](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./serialization.md) them into memory, and after the function finishes, it will [serialize](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./serialization.md) and write the values back to the database.

For native collections, the contract will fully load the collection into memory before any method executes. This happens even if the method you invoke does not use the collection. Know that this will have impact on GAS you spend for methods in your contract.



Native Collections
Native collections are those provided by the language:

JS: Array, Set, Map, Object ...
Rust: Vector, HashMap, Set ...

All entries in a native collection are serialized into a single value and stored together into the state. This means that every time a function execute, the SDK will read and deserialize all entries in the native collection.


 Serialization & Storage Example 

The array `[1,2,3,4]` will be serialized into the JSON string `"[1,2,3,4]"` in Javascript, and the Borsh byte-stream `[0,0,0,4,1,2,3,4]` in Rust before being stored


tiphen to use them

Native collections are useful if you are planning to store smalls amounts of data that need to be accessed all together


:::danger Keep Native Collections Small

As the native collection grows, deserializing it from memory will cost more and more gas. If the collections grows too large, your contract might expend all the gas trying to read its state, making it fail on each function call
::


SDK Collections
The NEAR SDKs expose collections that are optimized for random access of large amounts of data. SDK collections are instantiated using a "prefix", which is used as an index to split the data into chunks. This way, SDK collections can defer reading and writing to the store until needed.
These collections are built to have an interface similar to native collections.


 Serialization & Storage Example 

The sdk array `[1,2,3,4]` with prefix `"p"` will be stored as the string `"p"` in the contract's attribute, and create four entries in the contract's storage: `p-0:1`, `p-1:2`...


tiphen to use them

SDK collections are useful when you are planning to store large amounts of data that do not need to be accessed all together



Exposed Collections

  

| SDK Collection | Native Equivalent | Description                                                                                                                                                                                      |
|----------------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `Vector`       | `Array`           | A growable array type. The values are sharded in memory and can be used for iterable and indexable values that are dynamically sized.                                                            |
| `LookupSet`    | `Set`             | A set, which is similar to `LookupMap` but without storing values, can be used for checking the unique existence of values. This structure is not iterable and can only be used for lookups.     |
| `UnorderedSet` | `Set`             | An iterable equivalent of `LookupSet` which stores additional metadata for the elements contained in the set.                                                                                    |
| `LookupMap`    | `Map`             | This structure behaves as a thin wrapper around the key-value storage available to contracts. This structure does not contain any metadata about the elements in the map, so it is not iterable. |
| `UnorderedMap` | `Map`             | Similar to `LookupMap`, except that it stores additional data to be able to iterate through elements in the data structure.                                                                      |





| SDK collection                                | `std` equivalent             | Description                                                                                                                                                                                       |
|-----------------------------------------------|-----------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `store::Vector`                            | `Vec`                          | A growable array type. The values are sharded in memory and can be used for iterable and indexable values that are dynamically sized.                                                             |
| store::LookupMap``    | HashMap`` | This structure behaves as a thin wrapper around the key-value storage available to contracts. This structure does not contain any metadata about the elements in the map, so it is not iterable.  |
| store::IterableMap``  | HashMap`` | Similar to `LookupMap`, except that it stores additional data to be able to iterate through elements in the data structure.                                                                       |
| store::UnorderedMap`` | HashMap`` | Similar to `LookupMap`, except that it stores additional data to be able to iterate through elements in the data structure.                                                                       |
| `store::LookupSet`                         | `HashSet`                      | A set, which is similar to `LookupMap` but without storing values, can be used for checking the unique existence of values. This structure is not iterable and can only be used for lookups.      |
| `store::IterableSet`                       | `HashSet`                      | An iterable equivalent of `LookupSet` which stores additional metadata for the elements contained in the set.                                                                                     |
| `store::UnorderedSet`                      | `HashSet`                      | An iterable equivalent of `LookupSet` which stores additional metadata for the elements contained in the set.                                                                                     |





infoNote

The `near_sdk::collections` is now deprecated in favor of `near_sdk::store`. To use `near_sdk::collections` you will have to use the [`legacy` feature](https://github.com/near-examples/storage-examples/blob/2a138a6e8915e08ce76718add3e36c04c2ea2fbb/collections-rs/legacy/Cargo.toml#L11).



| SDK collection                                     | `std` equivalent              | Description                                                                                                                                                                                                                                        |
|----------------------------------------------------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `collections::Vector`                            | `Vec`                           | A growable array type. The values are sharded in memory and can be used for iterable and indexable values that are dynamically sized.                                                                                                              |
| collections::LookupMap``    | HashMap``  | This structure behaves as a thin wrapper around the key-value storage available to contracts. This structure does not contairn any metadata about the elements in the map, so it is not iterable.                                                  |
| collections::UnorderedMap`` | HashMap``  | Similar to `LookupMap`, except that it stores additional data to be able to iterate through elements in the data structure.                                                                                                                        |
| collections::TreeMap``      | BTreeMap`` | An ordered equivalent of `UnorderedMap`. The underlying implementation is based on an [AVL tree](https://en.wikipedia.org/wiki/AVL_tree). This structure should be used when a consistent order is needed or accessing the min/max keys is needed. |
| `collections::LookupSet`                         | `HashSet`                       | A set, which is similar to `LookupMap` but without storing values, can be used for checking the unique existence of values. This structure is not iterable and can only be used for lookups.                                                       |
| `collections::UnorderedSet`                      | `HashSet`                       | An iterable equivalent of `LookupSet` which stores additional metadata for the elements contained in the set.                                                                                                                                      |
| `collections::LazyOption`                       | `Option`                        | Optional value in storage. This value will only be read from storage when interacted with. This value will be `Some` when the value is saved in storage, and `None` if the value at the prefix does not exist.                                  |




Features



Type
Iterable
Clear All Values
Preserves Insertion Order
Range Selection




Vector
✅
✅
✅
✅


LookupSet






UnorderedSet
✅
✅

✅


IterableSet
✅
✅

✅


LookupMap






UnorderedMap
✅
✅

✅


IterableMap
✅
✅

✅


TreeMap
✅
✅
✅
✅




Complexity



Type
Access
Insert
Delete
Search
Traverse
Clear




Vector
O(1)
O(1)*
O(1)**
O(n)
O(n)
O(n)


LookupSet
O(1)
O(1)
O(1)
O(1)
N/A
N/A


UnorderedSet
O(1)
O(1)
O(1)
O(1)
O(n)
O(n)


IterableSet
O(1)
O(1)
O(1)
O(1)
O(n)
O(n)


LookupMap
O(1)
O(1)
O(1)
O(1)
N/A
N/A


IterableMap
O(1)
O(1)
O(1)
O(1)
O(n)
O(n)


TreeMap
O(1)
O(log n)
O(log n)
O(log n)
O(n)
O(n)



_* - to insert at the end of the vector using push_back (or push_front for deque)
** - to delete from the end of the vector using pop (or pop_front for deque), or delete using swap_remove which swaps the element with the last element of the vector and then removes it._

SDK Collections Cookbook
Let's see how to use the SDK collections in practice

Instantiation
All structures need to be initialized using a unique prefix, which will be used to index the collection's values in the account's state

  

    

tipDo not forget to use the `schema` to define how your contract's state is structured



  

  
    

  tip  Notice how we use `enums` to ensure all collections have a different prefix. Another advantage of using `enums` is that they are serialized into a single `byte` prefix. 

  

  

  
    

  tip  Notice how we use `enums` to ensure all collections have a different prefix. Another advantage of using `enums` is that they are serialized into a single `byte` prefix. 

  

  


:::danger

Be careful of not using the same prefix in two collections, otherwise, their storage space will collide, and you might overwrite information from one collection when writing in the other
::


Vector
Implements a vector/array which persists in the contract's storage. Please refer to the Rust and JS SDK's for a full reference on their interfaces.

  
    
  
  
    
  
  
    
  


LookupMap
Implements a map/dictionary which persists in the contract's storage. Please refer to the Rust and JS SDK's for a full reference on their interfaces.

  
    
  
  
    
  


UnorderedMap / IterableMap
Implements a map/dictionary which persists in the contract's storage. Please refer to the Rust and JS SDK's for a full reference on their interfaces.

  
    
  
  
    
  


LookupSet
Implements a set which persists in the contract's storage. Please refer to the Rust and JS SDK's for a full reference on their interfaces.


  
    
  

  
      
  



UnorderedSet / IterableSet
Implements a map/dictionary which persists in the contract's storage. Please refer to the Rust and JS SDK's for a full reference on their interfaces.

  
    
  
  
    
  


Tree
An ordered equivalent of Map. The underlying implementation is based on an AVL. You should use this structure when you need to: have a consistent order, or access the min/max keys.

  
    
  


LazyOption (Legacy)
LazyOptions are great to store large values (i.e. a wasm file), since its value will not be read from storage until it is interacted with.
It acts like an Option that can either hold a value or not and also requires a unique prefix (a key in this case)
like other persistent collections.
Compared to other collections, LazyOption only allows you to initialize the value during initialization.

Nesting Collections
When nesting SDK collections, be careful to use different prefixes for all collections, including the nested ones.

  

    

  

  

    

  tip  Notice how we use `enums` that take a `String` argument to ensure all collections have a different prefix

  

  


Error prone patterns
Because the values are not kept in memory and are lazily loaded from storage, it's important to make sure if a collection is replaced or removed, that the storage is cleared. In addition, it is important that if the collection is modified, the collection itself is updated in state because most collections will store some metadata.
Some error-prone patterns to avoid that cannot be restricted at the type level are:



```rust
use near_sdk::store::UnorderedMap;

let mut m = UnorderedMap::::new(b"m");
m.insert(1, "test".to_string());
assert_eq!(m.len(), 1);
assert_eq!(m.get(&1), Some(&"test".to_string()));

// Bug 1: Should not replace any collections without clearing state, this will reset any
// metadata, such as the number of elements, leading to bugs. If you replace the collection
// with something with a different prefix, it will be functional, but you will lose any
// previous data and the old values will not be removed from storage.
m = UnorderedMap::new(b"m");
assert!(m.is_empty());
assert_eq!(m.get(&1), Some(&"test".to_string()));

// Bug 2: Should not use the same prefix as another collection
// or there will be unexpected side effects.
let m2 = UnorderedMap::::new(b"m");
assert!(m2.is_empty());
assert_eq!(m2.get(&1), Some(&"test".to_string()));

// Bug 3: forgetting to save the collection in storage. When the collection is attached to
// the contract state (`self` in `#[near]`) this will be done automatically, but if
// interacting with storage manually or working with nested collections, this is relevant.
use near_sdk::store::Vector;

// Simulate roughly what happens during a function call that initializes state.
{
    let v = Vector::::new(b"v");
    near_sdk::env::state_write(&v);
}

// Simulate what happens during a function call that just modifies the collection
// but does not store the collection itself.
{
    let mut v: Vector = near_sdk::env::state_read().unwrap();
    v.push(1);
    // The bug is here that the collection itself if not written back
}

let v: Vector = near_sdk::env::state_read().unwrap();
// This will report as if the collection is empty, even though the element exists
assert!(v.get(0).is_none());
assert!(
    near_sdk::env::storage_read(&[b"v".as_slice(), &0u32.to_le_bytes()].concat()).is_some()
);

// Bug 4 (only relevant for `near_sdk::store`): These collections will cache writes as well
// as reads, and the writes are performed on [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html)
// so if the collection is kept in static memory or something like `std::mem::forget` is used,
// the changes will not be persisted.
use near_sdk::store::IterableSet;

let mut m: IterableSet = IterableSet::new(b"l");
m.insert(1);
assert!(m.contains(&1));

// This would be the fix, manually flushing the intermediate changes to storage.
// m.flush();
std::mem::forget(m);

m = IterableSet::new(b"l");
assert!(!m.contains(&1));
```



### Nesting Errors

By extension of the error-prone patterns to avoid mentioned in the [collections section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./collections.md#error-prone-patterns), it is important to keep in mind how these bugs can easily be introduced into a contract when using nested collections.

Some issues for more context:
- https://github.com/near/near-sdk-rs/issues/560
- https://github.com/near/near-sdk-rs/issues/703

The following cases are the most commonly encountered bugs that cannot be restricted at the type level (only relevant for `near_sdk::collections`, not `near_sdk::store`):

```rust
use near_sdk::borsh::{self, BorshSerialize};
use near_sdk::collections::{LookupMap, UnorderedSet};
use near_sdk::BorshStorageKey;

#[derive(BorshStorageKey, BorshSerialize)]
pub enum StorageKey {
    Root,
    Nested(u8),
}

// Bug 1: Nested collection is removed without clearing its own state.
let mut root: LookupMap> = LookupMap::new(StorageKey::Root);
let mut nested = UnorderedSet::new(StorageKey::Nested(1));
nested.insert(&"test".to_string());
root.insert(&1, &nested);

// Remove inserted collection without clearing its sub-state.
let mut _removed = root.remove(&1).unwrap();

// This line would fix the bug:
// _removed.clear();

// This collection will now be in an inconsistent state if an empty UnorderedSet is put
// in the same entry of `root`.
root.insert(&1, &UnorderedSet::new(StorageKey::Nested(1)));
let n = root.get(&1).unwrap();
assert!(n.is_empty());
assert!(n.contains(&"test".to_string()));

// Bug 2: Nested collection is modified without updating the collection itself in the outer collection.
//
// This is fixed at the type level in `near_sdk::store` because the values are modified
// in-place and guarded by regular Rust borrow-checker rules.
root.insert(&2, &UnorderedSet::new(StorageKey::Nested(2)));

let mut nested = root.get(&2).unwrap();
nested.insert(&"some value".to_string());

// This line would fix the bug:
// root.insert(&2, &nested);

let n = root.get(&2).unwrap();
assert!(n.is_empty());
assert!(n.contains(&"some value".to_string()));
```




Pagination
Persistent collections such as IterableMap/UnorderedMap, IterableSet/UnorderedSet and Vector may
contain more elements than the amount of gas available to read them all.
In order to expose them all through view calls, we can use pagination.

  
    With JavaScript this can be done using iterators with [`toArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator/toArray) and [`slice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice).

    ```ts
      /// Returns multiple elements from the `UnorderedMap`.
      /// - `from_index` is the index to start from.
      /// - `limit` is the maximum number of elements to return.
      @view({})
      get_updates({ from_index, limit }: { from_index: number, limit:number }) {
        return this.status_updates.toArray().slice(from_index, limit);
      }
    ```
  

  
    With Rust this can be done using iterators with [`Skip`](https://doc.rust-lang.org/std/iter/struct.Skip.html) and [`Take`](https://doc.rust-lang.org/std/iter/struct.Take.html). This will only load elements from storage within the range.

    ```rust
      #[near(contract_state)]
      #[derive(PanicOnDefault)]
      pub struct Contract {
          pub status_updates: IterableMap,
      }

      #[near]
      impl Contract {
          /// Retrieves multiple elements from the `IterableMap`.
          /// - `from_index` is the index to start from.
          /// - `limit` is the maximum number of elements to return.
          pub fn get_updates(&self, from_index: usize, limit: usize) -> Vec {
              self.status_updates
                  .iter()
                  .skip(from_index)
                  .take(limit)
                  .collect()
          }
      }
    ```
  


Storage Cost
Your contract needs to lock a portion of their balance proportional to the amount of data they stored in the blockchain. This means that:

If more data is added and the storage increases ↑, then your contract's balance decreases ↓.
If data is deleted and the storage decreases ↓, then your contract's balance increases ↑. 

Currently, it costs approximately 1 Ⓝ to store 100kb of data.
info
You can save on smart contract storage if using NEAR Account IDs by encoding them using base32. Since they consist of [a-z.-_] characters with a maximum length of 64 characters, they can be encoded using 5 bits per character, with terminal . Going to a size of 65  5 = 325 bits from the original (64 + 4)  8 = 544 bits. This is a 40% reduction in storage costs


::caution
Your contract will panic if you try to store data but don't have NEAR to cover its storage cost
::

warning
Be mindful of potential small deposit attacks


Storage Constraints on NEAR
For storing data on-chain it’s important to keep in mind the following:

There is a 4mb limit on how much you can upload at once

Let’s say for example, someone wants to put an NFT purely on-chain (rather than IPFS or some other decentralized storage solution) you’ll have almost an unlimited amount of storage but will have to pay 1 $NEAR per 100kb of storage used.
Users will be limited to 4MB per contract call upload due to MAX_GAS constraints. The maximum amount of gas one can attach to a given functionCall is 300TGas.

### Best Practices

Best practices
Enable overflow checks
It's usually helpful to panic on integer overflow. To enable it, add the following into your Cargo.toml file:
[profile.release]
overflow-checks = true
Use require! early
Try to validate the input, context, state and access using require! before taking any actions. The earlier you panic, the more gas you will save for the caller.
#[nearn]
impl Contract {
    pub fn set_fee(&mut self, new_fee: Fee) {
        require!(env::predecessor_account_id() == self.owner_id, "Owner's method");
        new_fee.assert_valid();
        self.internal_set_fee(new_fee);
    }
}
Note: If you want debug information in the panic message or if you are using an SDK version before 4.0.0-pre.2,
the Rust assert! macro can be used instead of require!.
#[near]
impl Contract {
    pub fn set_fee(&mut self, new_fee: Fee) {
        assert_eq!(env::predecessor_account_id(), self.owner_id, "Owner's method");
        new_fee.assert_valid();
        self.internal_set_fee(new_fee);
    }
}
Use log!
Use logging for debugging and notifying user.
When you need a formatted message, you can use the following macro:
log!("Transferred {} tokens from {} to {}", amount, sender_id, receiver_id);
It's equivalent to the following message:
env::log_str(format!("Transferred {} tokens from {} to {}", amount, sender_id, receiver_id).as_ref());
Return Promise
If your method makes a cross-contract call, you probably want to return the newly created Promise.
This allows the caller (such as a near-cli or near-api-js call) to wait for the result of the promise instead of returning immediately.
Additionally, if the promise fails for some reason, returning it will let the caller know about the failure, as well as enabling NEAR Explorer and other tools to mark the whole transaction chain as failing.
This can prevent false-positives when the first or first few transactions in a chain succeed but a subsequent transaction fails.
E.g.
#[near]
impl Contract {
    pub fn withdraw_100(&mut self, receiver_        Promise::new(receiver_id).transfer(100)
    }
}
Reuse crates from near-sdk
near-sdk re-exports the following crates:

borsh
base64
bs58
serde
serde_json

Most common crates include borsh which is needed for internal STATE serialization and
serde for external JSON serialization.
When marking structs with serde::Serialize you need to use #[serde(crate = "near_sdk::serde")]
to point serde to the correct base crate.
/// Main contract structure serialized with Borsh
#[near(contract_state)]
#[derive(PanicOnDefault)]
pub struct Contract {
    pub pair: Pair,
}

/// Implements both `serde` and `borsh` serialization.
/// `serde` is typically useful when returning a struct in JSON format for a frontend.
#[near(serializers = [json, borsh])]
pub struct Pair {
    pub a: u32,
    pub b: u32,
}

#[near]
impl Contract {
    #[init]
    pub fn new(pair: Pair) -> Self {
        Self {
            pair,
        }
    }

    pub fn get_pair(self) -> Pair {
        self.pair
    }
}
std::panic! vs env::panic


std::panic! panics the current thread. It uses format! internally, so it can take arguments.
SDK sets up a panic hook, which converts the generated PanicInfo from panic! into a string and uses env::panic internally to report it to Runtime.
This may provide extra debugging information such as the line number of the source code where the panic happened.


env::panic directly calls the host method to panic the contract.
It doesn't provide any other extra debugging information except for the passed message.


Use workspaces
Workspaces allow you to automate workflows and run tests for multiple contracts and cross-contract calls in a sandbox or testnet environment.
Read more, workspaces-rs or workspaces-js.

### Basic Anatomy

Let's illustrate the basic anatomy of a simple "Hello World" contract. The code on this page comes from our Hello NEAR repository on GitHub.




    ### Importing the SDK
    All contracts will import the **NEAR SDK**, enabling them to [access the execution environment](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./environment.md), [call other contracts](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./crosscontract.md), [transfer tokens](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./actions.md), and much more.

    You can also use third-party libraries, though some might not work due to the limitations of the contract runtime.





    ### Contract's Main Structure
    The contract is described through a structure:
    - The attributes define which data the contract stores
    - The functions define its public (and private) interface





    ### Contract Class Decorator

    Note that the contract's class is decorated with `@NearBindgen`. This decorator tells the SDK which class defines the contract, so it knows:
    1. What to fetch from storage when the contract is loaded
    2. What to store when the contract is done executing
    3. The methods that are exposed to the outside world
    4. If the contract needs to be initialized (we will cover this later)

    **Note:** Only one class can be decorated with the `@NearBindgen` decorator





    ### Contract Struct Macro

    Note that the contract's struct definition and the implementation are decorated with macros

    The `#[near(contract_state)]` macro tell the SDK that this structure defines the contract's state, so it knows:
    1. What to fetch from storage when the contract is loaded
    2. What to store when the contract is done executing

    The `#[near]` macro tells the SDK which functions are exposed to the outside world.

    **Note:** Only one struct can be decorated with the `#[near(contract_state)]` macro.





    

     Interaction with other macros 

    When `near` is built for the wasm32 target, it generates the external NEAR contract bindings.  To achieve this it is actually generating another function with the signature `pub extern "C" fn function_name()` that first deserializes the contract struct from NEAR storage and then calls the `contract.function_name(parameter1, parameter2, ...)`.

    If you have annotated your function with any attribute-like macros, these are then executed _twice_.  Specifically if the attribute like macro makes any modification to the function signature, or inserts any code that depends on the contract struct (in the form of `&self`, `&mut self`, or `self`) this will fail in the second invocation, because the externally exposed function does not have any concept of this struct.

    It is possible to detect this by checking which build target you are building for and limit the execution of the macro to operate only on the first pass.

    





    ### Storage (State)
    We call the data stored in the contract [the contract's state](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./storage.md).

    In our Hello World example, the contract stores a single string (`greeting`), and the state starts initialized with the default value `"Hello"`.

    **Note:** We will cover more about the contract's state in the [state section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./storage.md).





    Javascript contracts need to further include a `schema` object that defines the contract's state and its types. This object is used by the SDK to correctly serialize and deserialize the contract's state.





    ### Read Only Functions
    Contract's functions can be read-only, meaning they don't modify the state. Calling them is free for everyone, and does not require to have a NEAR account.

    **Note:** We will cover more about function types in the [functions section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./functions.md).





    ### State Mutating Functions
    Functions that modify the state or call other contracts are considered state mutating functions. It is necessary to have a NEAR account to call them, as they require a transaction to be sent to the network.

    **Note:** We will cover more about function types in the [functions section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/2.smart-contracts/anatomy/./functions.md).

### Transfers & Actions

Smart contracts can perform specific Actions such as transferring NEAR, or calling other contracts.
An important property of Actions is that they can be batched together when acting on the same contract. Batched actions act as a unit: they execute in the same receipt, and if any fails, then they all get reverted.
info`Actions` can be batched only when they act on the **same contract**. You can batch calling two methods on a contract,
but **cannot** call two methods on different contracts.


Transfer NEAR Ⓝ
You can send $NEAR from your contract to any other account on the network. The Gas cost for transferring $NEAR is fixed and is based on the protocol's genesis config. Currently, it costs ~0.45 TGas.

  

```js
  import { NearBindgen, NearPromise, call } from 'near-sdk-js'
  import { AccountId } from 'near-sdk-js/lib/types'

  @NearBindgen({})
  class Contract{
    @call({})
    transfer({ to, amount }: { to: AccountId, amount: bigint }) {
      return NearPromise.new(to).transfer(amount);
    }
  }
```





```rust
  use near_sdk::{near, AccountId, Promise, NearToken};

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  #[near]
  impl Contract {
    pub fn transfer(&self, to: AccountId, amount: NearToken){
      Promise::new(to).transfer(amount);
    }
  }
```




tiphy is there no callback?
The only case where a transfer will fail is if the receiver account does **not** exist.


:::caution
Remember that your balance is used to cover for the contract's storage. When sending money, make sure you always leave enough to cover for future storage needs.
::


Function Call
Your smart contract can call methods in another contract. In the snippet below we call a method
in a deployed Hello NEAR contract, and check if everything went
right in the callback.

  

```js
  import { NearBindgen, near, call, bytes, NearPromise } from 'near-sdk-js'
  import { AccountId } from 'near-sdk-js/lib/types'

  const HELLO_NEAR: AccountId = "hello-nearverse.testnet";
  const NO_DEPOSIT: bigint = BigInt(0);
  const CALL_GAS: bigint = BigInt("10000000000000");

  @NearBindgen({})
  class Contract {
    @call({})
    call_method({}): NearPromise {
      const args = bytes(JSON.stringify({ message: "howdy" }))

      return NearPromise.new(HELLO_NEAR)
      .functionCall("set_greeting", args, NO_DEPOSIT, CALL_GAS)
      .then(
        NearPromise.new(near.currentAccountId())
        .functionCall("callback", bytes(JSON.stringify({})), NO_DEPOSIT, CALL_GAS)
      )
      .asReturn()
    }

    @call({privateFunction: true})
    callback({}): boolean {
      let result, success;

      try{ result = near.promiseResult(0); success = true }
      catch{ result = undefined; success = false }

      if (success) {
        near.log(`Success!`)
        return true
      } else {
        near.log("Promise failed...")
        return false
      }
    }
  }
```





```rust
  use near_sdk::{near, env, log, Promise, Gas, PromiseError};
  use serde_json::json;

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  const HELLO_NEAR: &str = "hello-nearverse.testnet";
  const NO_DEPOSIT: u128 = 0;
  const CALL_GAS: Gas = Gas(5_000_000_000_000);

  #[near]
  impl Contract {
    pub fn call_method(&self){
      let args = json!({ "message": "howdy".to_string() })
                .to_string().into_bytes().to_vec();

      Promise::new(HELLO_NEAR.parse().unwrap())
      .function_call("set_greeting".to_string(), args, NO_DEPOSIT, CALL_GAS)
      .then(
        Promise::new(env::current_account_id())
        .function_call("callback".to_string(), Vec::new(), NO_DEPOSIT, CALL_GAS)
      );
    }

    pub fn callback(&self, #[callback_result] result: Result){
      if result.is_err(){
          log!("Something went wrong")
      }else{
          log!("Message changed")
      }
    }
  }
```




warning
The snippet showed above is a low level way of calling other methods. We recommend make calls to other contracts as explained in the Cross-contract Calls section.


Create a Sub Account
Your contract can create direct sub accounts of itself, for example, user.near can create sub.user.near.
Accounts do NOT have control over their sub-accounts, since they have their own keys.
Sub-accounts are simply useful for organizing your accounts (e.g. dao.project.near, token.project.near).

  

```js
  import { NearBindgen, near, call, NearPromise } from 'near-sdk-js'

  const MIN_STORAGE: bigint = BigInt("1000000000000000000000") // 0.001Ⓝ

  @NearBindgen({})
  class Contract {
    @call({payableFunction:true})
    create({prefix}:{prefix: String}) {
      const account_id = `${prefix}.${near.currentAccountId()}`

      NearPromise.new(account_id)
      .createAccount()
      .transfer(MIN_STORAGE)
    }
  }
```





```rust
  use near_sdk::{near, env, Promise, NearToken};

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  const MIN_STORAGE: Balance = 1_000_000_000_000_000_000_000; //0.001Ⓝ

  #[near]
  impl Contract {
    pub fn create(&self, prefix: String){
      let account_id = prefix + "." + &env::current_account_id().to_string();
      Promise::new(account_id.parse().unwrap())
      .create_account()
      .transfer(MIN_STORAGE);
    }
  }
```




tip Notice that in the snippet we are transferring some money to the new account for storage

:::caution

When you create an account from within a contract, it has no keys by default. If you don't explicitly add keys to it or deploy a contract on creation then it will be locked.
::


Creating .testnet / .near Accounts
Accounts can only create immediate sub-accounts of themselves.
If your contract wants to create a .mainnet or .testnet account, then it needs to call
the create_account method of near or testnet root contracts.

  

```js
  import { NearBindgen, near, call, bytes, NearPromise } from 'near-sdk-js'

  const MIN_STORAGE: bigint = BigInt("1820000000000000000000"); //0.00182Ⓝ
  const CALL_GAS: bigint = BigInt("28000000000000");

  @NearBindgen({})
  class Contract {
    @call({})
    create_account({account_id, public_key}:{account_      const args = bytes(JSON.stringify({
        "new_account_id": account_id,
        "new_public_key": public_key
      }))

      NearPromise.new("testnet")
      .functionCall("create_account", args, MIN_STORAGE, CALL_GAS);
    }
  }
```





```rust
  use near_sdk::{near, Promise, Gas, NearToken };
  use serde_json::json;

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  const CALL_GAS: Gas = Gas(28_000_000_000_000);
  const MIN_STORAGE: Balance = 1_820_000_000_000_000_000_000; //0.00182Ⓝ

  #[near]
  impl Contract {
    pub fn create_account(&self, account_      let args = json!({
                  "new_account_id": account_id,
                  "new_public_key": public_key,
                }).to_string().into_bytes().to_vec();

      // Use "near" to create mainnet accounts
      Promise::new("testnet".parse().unwrap())
      .function_call("create_account".to_string(), args, MIN_STORAGE, CALL_GAS);
    }
  }
```





Deploy a Contract
When creating an account you can also batch the action of deploying a contract to it. Note that for this, you will need to pre-load the byte-code you want to deploy in your contract.

  

```rust
  use near_sdk::{near, env, Promise, NearToken};

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  const MIN_STORAGE: Balance = 1_100_000_000_000_000_000_000_000; //1.1Ⓝ
  const HELLO_CODE: &[u8] = include_bytes!("./hello.wasm");

  #[near]
  impl Contract {
    pub fn create_hello(&self, prefix: String){
      let account_id = prefix + "." + &env::current_account_id().to_string();
      Promise::new(account_id.parse().unwrap())
      .create_account()
      .transfer(MIN_STORAGE)
      .deploy_contract(HELLO_CODE.to_vec());
    }
  }
```




tipf an account with a contract deployed does **not** have any access keys, this is known as a locked contract. When the account is locked, it cannot sign transactions therefore, actions can **only** be performed from **within** the contract code.


Add Keys
When you use actions to create a new account, the created account does not have any access keys, meaning that it cannot sign transactions (e.g. to update its contract, delete itself, transfer money).
There are two options for adding keys to the account:

add_access_key: adds a key that can only call specific methods on a specified contract.
add_full_access_key: adds a key that has full access to the account.



  

```js
  import { NearBindgen, near, call, NearPromise } from 'near-sdk-js'
  import { PublicKey } from 'near-sdk-js/lib/types'

  const MIN_STORAGE: bigint = BigInt("1000000000000000000000") // 0.001Ⓝ

  @NearBindgen({})
  class Contract {
    @call({})
    create_hello({prefix, public_key}:{prefix: String, public_key: PublicKey}) {
      const account_id = `${prefix}.${near.currentAccountId()}`

      NearPromise.new(account_id)
      .createAccount()
      .transfer(MIN_STORAGE)
      .addFullAccessKey(public_key)
    }
  }
```





```rust
  use near_sdk::{near, env, Promise, Balance, PublicKey};

  #[near(serializers = [json, borsh])]
  #[derive(Default)]
  pub struct Contract { }

  const MIN_STORAGE: Balance = 1_100_000_000_000_000_000_000_000; //1.1Ⓝ
  const HELLO_CODE: &[u8] = include_bytes!("./hello.wasm");

  #[near]
  impl Contract {
    pub fn create_hello(&self, prefix: String, public_key: PublicKey){
      let account_id = prefix + "." + &env::current_account_id().to_string();
      Promise::new(account_id.parse().unwrap())
      .create_account()
      .transfer(MIN_STORAGE)
      .deploy_contract(HELLO_CODE.to_vec())
      .add_full_access_key(public_key);
    }
  }
```




Notice that what you actually add is a "public key". Whoever holds its private counterpart, i.e. the private-key, will be able to use the newly access key.
tipf an account with a contract deployed does **not** have any access keys, this is known as a locked contract. When the account is locked, it cannot sign transactions therefore, actions can **only** be performed from **within** the contract code.


Delete Account
There are two scenarios in which you can use the delete_account action:

As the last action in a chain of batched actions.
To make your smart contract delete its own account.


  

```js
  import { NearBindgen, near, call, NearPromise } from 'near-sdk-js'
  import { AccountId } from 'near-sdk-js/lib/types'

  const MIN_STORAGE: bigint = BigInt("1000000000000000000000") // 0.001Ⓝ

  @NearBindgen({})
  class Contract {
    @call({})
    create_delete({prefix, beneficiary}:{prefix: String, beneficiary: AccountId}) {
      const account_id = `${prefix}.${near.currentAccountId()}`

      NearPromise.new(account_id)
      .createAccount()
      .transfer(MIN_STORAGE)
      .deleteAccount(beneficiary)
    }

    @call({})
    self_delete({beneficiary}:{beneficiary: AccountId}) {
      NearPromise.new(near.currentAccountId())
      .deleteAccount(beneficiary)
    }
  }
```





```rust
  use near_sdk::{near, env, Promise, Neartoken, AccountId};

  #[near(contract_state)]
  #[derive(Default)]
  pub struct Contract { }

  const MIN_STORAGE: Balance = 1_000_000_000_000_000_000_000; //0.001Ⓝ

  #[near]
  impl Contract {
    pub fn create_delete(&self, prefix: String, beneficiary: AccountId){
      let account_id = prefix + "." + &env::current_account_id().to_string();
      Promise::new(account_id.parse().unwrap())
      .create_account()
      .transfer(MIN_STORAGE)
      .delete_account(beneficiary);
    }

    pub fn self_delete(beneficiary: AccountId){
      Promise::new(env::current_account_id())
      .delete_account(beneficiary);
    }
  }
```




warning Token Loss
If the beneficiary account does not exist the funds will be [**dispersed among validators**](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/basics/token-loss.md).

warning Token Loss
Do **not** use `delete` to try fund a new account. Since the account doesn't exist the tokens will be lost.

### What is a Smart Contract?

Smart contracts are pieces of executable code that live in a NEAR account. They can store data, perform transactions in the account’s name, and expose methods so other accounts can interact with them.

Developers can choose between using Javascript or Rust to write smart contracts in NEAR. Indistinctly from the language chosen, the contract will be compiled into WebAssembly, from which point it can be deployed and executed on the NEAR platform.


 New to Smart Contract Development? 

Do not worry if you don't know how smart-contract blockchains work. As a developer, it is sufficient to understand that NEAR smart-contracts:
1. Have **limited** computational resources.
2. Interact with other contracts in an **asynchronous** way.
3. Deal with **real money**, for which security must be a top concern.



Where do contracts live?
Smart Contracts are deployed into NEAR accounts. Any NEAR account can hold a contract, needing to pay for the contract's code and the data it stores. 
Once in an account, anyone can interact with the contract. Thanks to the underlying network structure, executing code from a contract is both fast (avg. 1.4s finality) and cheap. Moreover, read-only operations are free for everyone.
tiptoring 100kb costs 1Ⓝ, so deploying a contract generally costs only a few $NEARs.


What can they do?
Smart contracts have complete control over the account, and thus can perform any action on its behalf. For example, contracts can:

Transfer $NEAR Tokens 
Call methods on other contracts
Create new accounts and deploy contracts on them
Update their own code


Besides, smart contracts can store data in the account's storage. This allows contracts to create almost any type of application, from simple games to complex financial systems.
::danger What contracts cannot do

Smart contracts cannot access the internet, so they cannot make HTTP requests or access external data 
Smart contracts cannot execute automatically, they need to be called by an external account

::


What are they used for?
Smart contracts are useful to create decentralized applications. Some traditional examples include:

Decentralized Autonomous Organizations, where users create and vote proposals
Marketplaces, where users create and commercialize digital art pieces
Decentralized exchanges, where users can trade different currencies
And many more...

For instance, you can easily create a crowdfunding contract that accepts $NEAR. If the goal is met in time, the creator can claim the funds. Otherwise, the backers are refunded.

Development flow
Just like any piece of software, smart contracts have a development flow - starting with its creation and ending with monitoring it, all of which we cover in our documentation.

"build/building-smart-contracts/testing/introduction",
The development flow can be summarized as follows:

Scaffold: The simplest way to create a project is by starting from a template.
Build: Write a contract using Rust or Javascript.
Test: Our Sandbox enables to simulate interactions with one or multiple contracts in a realistic environment.
Deploy: After making sure the contract is secure, developers can deploy the contract into their accounts.
Use: Any user can interact with the contract through their NEAR Wallet.
Monitor: The contract's activity can be monitored through simple APIs.

Supported Languages
During the whole cycle, developers can choose between JavaScript and Rust, allowing them to use their favorite language at each step of their journey.


 Other languages 

Theoretically, you can use any language that compiles to Wasm for developing NEAR smart contract. However, in order to have a user-friendly experience we would need to provide a library that wraps around low-level runtime APIs, while also offering other high-level functionalities.

We envision that in the future, more languages will be supported and the support will be done through the effort from the wider community, not just NEAR alone.



Contract primitives
Contract primitives such as FT, NFT, and DAOs are fundamental building blocks that can be combined to create awesome user experiences such as reward tokens, decision-making tools, and marketplaces. 
tipCheck our section on [primitives](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/5.primitives/what-is.md) to learn more about them

### Wallet Chain Key Rules

Overview
In this article you'll find details on how to parse and present multichain transactions to the user so they can take an informed decision about their wallet's assets, while minimizing the number of times the user has to consent.
You'll also learn how to ensure that a signature on one chain is not used to take a meaningful action on another chain.
Key derivation
When signing using chain signatures each account has an unlimited number of keys. Each key's public key is derived from the account name and the key extension which is an arbitrary string.
User's keys can be described as follow:
"david.near,"              A key with no extension
"david.near, "             A key with an extension of " "
"david.near,cold_wallet"   A key with an extension of "cold_wallet"
tipf the keys aren't identical they have no relationship.

Ambiguous signatures
You're going to be potentially storing keys for users who hold assets on many chains. Different chains have different ways of serializing and signing transactions. Many chains take steps to ensure that their signatures are not valid signatures on other chains. EVM chains use ChainID to disambiguate signatures between different EVM chains. Dfinity uses a unique salt on the hash of the transaction.
Unfortunately, while this is a best practice, you can't guarantee that all chains do this. As such, a user could receive an innocent looking transaction on one chain that could be used to take a destructive action on another chain.
An apocryphal example:
Transaction: "7b73656e643a2022313030222c206e6f74652022227d"
Parsed SOL: claim free NFT
Parsed BTC: send 100 BTC to Attacker
The user would approve the SOL transaction but the attacker would also get the BTC transaction.
This can be solved by having unique keys for different chains. That way, even if an attacker makes you sign a transaction that is also valid in a foreign chain, no assets will be compromised.
Serialization format
We're using the following format for our derivations paths.
{
   chain: number, // SLIP-44 coin type unsigned integer
   domain: String, // The domain that owns this key
   meta: any, // Catch all data structure
}
This is encoded in canonical JSON RFC 8785.
infoIf you are not using a field don't make it `null`, don't include the key instead.

User-defined fields
For user-defined fields, the meta field can include any data you like. 
tipo not add any extra fields at the top level, as that may clash with future versions of this specification. If needed, put them in the `meta` field instead.

For example, a simple way of selecting alternate keys will be using an object with an ID field:
{
    meta: {    chain: 0,
}
Examples



Key
Description




{chain: 0, domain: "near.org"}
A bitcoin key used on near.org


`{chain: 0, meta: {



Example user flows
In the following examples, the messages are coming from the user's wallet frontend.

Using a domains bitcoin key
Using a personal Bitcoin key
Using a personal EVM key to sign a Binance transaction
Using an untyped domain key
Using another domain's Bitcoin key

tipallet developers should follow this user flow format.

Using a domains bitcoin key
An application at near.org wants to sign the Bitcoin transaction Send 100 BTC using the key david.near,bitcoin,near.org,.
Signed ✅
We sign the transaction without confirmation because the key is owned by near.org.
Using a personal Bitcoin key
An application at near.org wants to sign the Bitcoin transaction Send 100 BTC using the key david.near,bitcoin,.
near.org would like to run the following Bitcoin transaction:

Send 100 BTC
[Accept] [Reject]
The user must make an informed decision about whether this is an action they would like to take.
Signed ✅
Using a personal EVM key to sign a Binance transaction
An application at near.org wants to sign the Binance Smart Chain transaction Send 100 BNB, ChainID 56 using the key david.near,evm,. The wallet knows this is a BSC transaction because of the corresponding ChainID (56) and because the evm key is being used.
near.org would like to run the following Binance Smart Chain transaction:

Send 100 BNB
[Accept] [Reject]
The user must make an informed decision about whether this is an action they would like to take.
Signed ✅
Using an untyped domain key
An application at near.org wants to sign the Bitcoin transaction Send 100 BTC using the key david.near,,near.org,.
Signed ✅
While this is ill advised, it's still the domains key so the domain can still choose whether to sign something using it.
Using another domains Bitcoin key
An application at attacker.com wants to sign the Bitcoin transaction Send 100 BTC using the key david.near,bitcoin,near.org,.
Attacker.com would like to sign a transaction using your credentials from near.org

Send 100 BTC

This is a suspicious transaction and likely not one you should accept
[Reject] [Accept (Are you sure!)]
The user must make an explicit decision to do something that is ill advised.
Signed ✅
The correct way for attacker.com to make this request is to somehow redirect the user to near.org and get the user to make a decision there.

### NFT Chain Keys Smart Contract

The NFT Chain Keys smart contract makes the ownership of remote accounts both provable and transferrable. This new paradigm allows you to create new end-user experiences that leverage provable and transferrable remote accounts as a core primitive.
Contract overview
The MPC Account Recovery smart contract provides a sign method that accepts a path parameter. This allows one predecessor account to have access to an effectively unlimited number of MPC keys.
The NFT Chain Keys contract takes advantage of this property and allows secure transfers of MPC keys between users, using the NEP-171 NFT contract standard.
The contract also implements new functionality to enable chain key management features.
info
The essence of Multi-Party Computation (MPC) is to enable independent parties to perform shared computations on private information without revealing secrets to each other.

Standards
Besides the NEP-171 contract standard, the NFT Chain Keys contract complies with a full suite of NEP standards:

NEP-145: Storage Management
NEP-171: NFT Core
NEP-177: Metadata
NEP-178: Approval Management
NEP-181: Enumeration

Usage
Please refer to the smart contract GitHub documentation for usage information:

Creating new key tokens: mint unlimited new NFT chain keys, as long as the account has sufficient storage.
Issuing signatures: generate new signatures based on a submitted payload.
Approvals: implement a separate set of approval management functions for using NFTs, which operate similarly to NEP-178.

tipestnet contract

If you want to try things out, this smart contract is available on `nft.kagi.testnet`.



Use Cases for NFT Keys
infoDisclaimer
The ideas presented in this section are just initial concepts, and shouldn’t be considered as fully fledged solutions.

Remote Account Marketplace
NFT Keys enable users to buy, sell, and trade remote accounts within a marketplace-style application.
For instance, Alice, possessing a set of remote accounts with value and history, can mint an NFT key and list these accounts for sale on the marketplace.
Potential buyers, like Bob, can browse the value of Alice’s accounts and choose to make a purchase.
If Bob decides to proceed, they would simply need to acquire ownership of the original NFT key from Alice in exchange for payment, such as in $NEAR.
Once the transaction is completed, ownership of the accounts transfers to Bob.
Bridgeless Multi-Chain DEX
You can create a Multi-chain DEX without bridging by combining Chain Signatures with NFT Keys.
Users wishing to swap asset $A for asset $B would initiate the swap on the bridgeless DEX.
Supported by liquidity providers (Automated Market Makers) across multiple chains, the DEX facilitates these swaps.
Here's how it works:

A user proposes the swap, specifying asset $A in remote account X for asset $B in remote account Y.
The liquidity provider receives asset $A from the user and sends the equivalent amount of asset $B to a newly created remote account Y, along with a minted NFT key.
The NFT key is then sent to the user to complete the swap.

Although liquidity providers still need to leverage bridging to settle assets between different pools, users of this exchange type are exposed to reduced bridge risk.

### Building a Meta Transaction Relayer

Relayers serve to delegate gas fees to a web service, allowing users to transact on NEAR without the need to acquire the token themselves while still retaining the security of signing their own transactions. This guide will lead you through the components necessary to construct a relayer capable of handling meta transactions.
tipIf you're already acquainted with the technology and you just want to run your own Relayer, you can fast track to a complete [Rust Relayer server](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/1.chain-abstraction/#rust-relayer-server) open-source implementation.


How it works
A basic relayer consists of a web server housing a funded NEAR account. This account receives an encoded signed transaction, which can subsequently be decoded into a SignedDelegate format and transmitted on-chain.
The client can then generate a SignedDelegateAction (a signed message that hasn't yet been sent), encode it, and transmit it to this server, where it will be relayed onto the blockchain.

Relayer (server)




Here's a simple express endpoint that deserializes the body, instantiates the relayer account and then sends the transaction.



You can easily get the account object used to send the transactions from its private key using this snippet



info
 The code in the example only works from the following versions onwards

```
"near-api-js": "3.0.4"
"@near-js/transactions": "1.1.2",
"@near-js/accounts": "1.0.4"
```







`@near-relay` simplifies meta transactions making it easier to get started for a beginner.

To start, call the relay method inside an endpoint to automatically deserialize the transaction and send it with the account defined in the environment variables.



If you're interested in relaying account creation as well, it's quite straightforward. Simply create another endpoint and directly call the createAccount method with the accountId and publicKey. These parameters are automatically included in the body when using the corresponding client library.






Client




In this method we are creating an arbitrary smart contract call, instantiating an account and using it to sign but not send the transaction. We can then serialize it and send it to the relayer where it will be delegated via the previously created endpoint.







As mentioned in the above note in order to be able to relay on the client side it's necessary to have access to signing transactions directly on the client. Luckily leveraging the near biometric library it's possible to do so in a non custodial way.

By calling this method and passing in the URL for the account creation endpoint (mentioned in the server section) as well as the `accountId` everything is handled under the hood to successfully create an account.



On the client side, you just need to create an `Action` and pass it into the `relayTransaction` method along with the URL of the relayer endpoint discussed in the server section and the id of the `receiverId`.







 Relaying with wallets 

At the moment, wallet selector standard doesn't support signing transactions without immediately sending them. This functionality is essential for routing transactions to a relayer. Therefore, to smoothly integrate relaying on the client side, it's necessary to be able to sign transactions without relying on wallets.
Progress is being made to make this possible in the future.


High volume parallel processing
When running a relayer that handles a large number of transactions, you will quickly run into a nonce collision problem. At the protocol level, transactions have a unique number that identifies them (nonce) that helps to mitigate reply attacks. Each key on an account has its own nonce, and the nonce is expected to increase with each signature the key creates.
When multiple transactions are sent from the same access key simultaneously, their nonces might collide. Imagine the relayer creates 3 transactions Tx1, Tx2, Tx3 and send them in very short distance from each other, and lets assume that Tx3 has the largest nonce. If Tx3 ends up being processed before Tx1 (because of network delays, or a node picks Tx3 first), then Tx3 will execute, but Tx1 and Tx2 will fail, because they have smaller nonce!
One way to mitigate this is to sign each transaction with a different key. Adding multiple full access keys to the NEAR account used for relaying (up to 20 keys can make a significant difference) will help.

 Adding keys 

```js
const keyPair = nearAPI.KeyPair.fromRandom("ed25519");

const receipt = await account.addKey(keyPair.getPublicKey().toString())
```

After saving these keys, its possible to rotate the private keys randomly when instantiating accounts before relaying ensuring you won't create a nonce collision.


Gating the relayer
In most production applications it's expected that you want to be able to gate the relayer to only be used in certain cases.
This can be easily accomplished by specifying constraints inside the SignedDelegate.delegateAction object.
export declare class DelegateAction extends Assignable {
    senderId: string;
    receiverId: string;
    actions: Array<Action>;
    nonce: BN;
    maxBlockHeight: BN;
    publicKey: PublicKey;
}
You can, for example, gate by some particular user or contract:
  const serializedTx: Buffer = req.body;
  const deserializedTx: SignedDelegate = deserialize(SCHEMA.SignedDelegate, Buffer.from(serializedTx)) as SignedDelegate;
  const relayerAccount: Account = await getAccount(NETWORK_ID, RELAYER_ID, RELAYER_PRIVATE_KEY);
  const delegateAction = deserializedTx?.delegateAction

  if(delegateAction.senderId == 'someUserId' || delegateAction.receiverId == 'someContractId' ){
       const receipt = await relayerAccount.signAndSendTransaction({
       actions: [actionCreators.signedDelegate(deserializedTx)],
       receiverId: deserializedTx.delegateAction.senderId
  });
  }
Other examples could be looking into the actions and seeing if there is deposit or gas and limiting them, gating by particular smart contract methods or even args.
You can decode the args using:
JSON.parse(Buffer.from(args_base64 || "", "base64").toString())

Rust Relayer Server
The open-source Rust reference implementation of a Relayer server offers the following features:
infoFeatures can be combined as needed. Use of one feature does not preclude the use of any other feature unless specified.


Sign and send Meta Transactions to the RPC to cover the gas costs of end users while allowing them to maintain custody of their funds and approve transactions (/relay, /send_meta_tx, /send_meta_tx_async, /send_meta_tx_nopoll)
Sign Meta Transactions returning a Signed Meta Transaction to be sent to the RPC later - (/sign_meta_tx, /sign_meta_tx_no_filter)
Only pay for users interacting with certain contracts by whitelisting contracts addresses (whitelisted_contracts in config.toml)
Specify gas cost allowances for all accounts (/update_all_allowances) or on a per-user account basis (/create_account_atomic, /register_account, /update_allowance) and keep track of allowances (/get_allowance)
Specify the accounts for which the relayer will cover gas fees (whitelisted_delegate_action_receiver_ids in config.toml)
Only allow users to register if they have a unique Oauth Token (/create_account_atomic, /register_account)
Relayer Key Rotation: keys_filenames in config.toml
Integrate with FastAuth SDK
Mix and Match configuration options

tipheck the [Use cases section](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/1.chain-abstraction/#use-cases) for example configuration files corresponding to different usage scenarios.

Basic Setup
You can follow these steps to set up your local Relayer server development environment:

Install Rust for NEAR Development
If you don't have a NEAR account, create one
With the account from step 2, create a JSON file in this directory in the format
[{"account_id":"example.testnet","public_key":"ed25519:98GtfFzez3opomVpwa7i4m3nptHtc7Ha514XHMWszLtQ","private_key":"ed25519:YWuyKVQHE3rJQYRC3pRGV56o1qEtA1PnMYPDEtroc5kX4A4mWrJwF7XkzGe7JWNMABbtY4XFDBJEzgLyfPkwpzC"}]
using a Full Access Key from an account that has enough NEAR to cover the gas costs of transactions your server will be relaying. Usually, this will be a copy of the json file found in the .near-credentials directory.
Update values in config.toml
Open up the port from config.toml in your machine's network settings
Run the server using cargo run.

(OPTIONAL) To run with logs (tracing) enabled run RUST_LOG=tower_http=debug cargo run


infoOptional setup

If you're integrating with [FastAuth](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/1.chain-abstraction/fastauth-sdk.md) make sure to enable feature flags:
```
cargo build --features fastauth_features,shared_storage
```
If you're using shared storage, make sure to enable feature flags:
```
cargo build --features shared_storage
```


Redis Setup
tiphis is only needed if you intend to use whitelisting, allowances, and OAuth functionality.


Install Redis.

Steps 2 & 3 assume Redis was installed on machine instead of a Docker setup. If you're connecting to a Redis instance running in GCP, follow the above steps to connect to a VM that will forward requests from your local relayer server to Redis running in GCP

Run redis-server --bind 127.0.0.1 --port 6379 - make sure the port matches the redis_url in the config.toml.
Run redis-cli -h 127.0.0.1 -p 6379

Advanced setup

Multiple Key Generation: this is optional, but recommended for high throughput to prevent nonce race conditions. Check
Docker Deployment: instructions to deploy with Docker
Cloud Deployment: instructions to deploy on Cloud providers

API Specifications
You can find the complete Relayer server API specification on the GitHub repository.
Use cases
The examples folder on the GitHub repository contains example configuration files corresponding to different use cases.
infoThese files are for reference only and you should update the `config.toml` values before using it on your development environment.

No filters
This is a config for a relayer that covers gas for all user transactions to all contracts with no filters. To prevent abuse, this should only be used if there's only a secure backend calling the relayer

no_filters.toml

Basic whitelist
This is a configuration for a basic relayer that covers gas for user transactions to interact with a whitelisted set of contracts

basic_whitelist.toml

Redis
This is a configuration for a relayer that covers gas for user transactions up to a allowance specified in Redis to interact with a whitelisted set of contracts.

Allowances are on a per-account id basis and on signup (account creation in Redis and on-chain) an OAuth token is required to help with sybil resistance
redis.toml

FastAuth
infoClosed access beta

[FastAuth](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/2.build/1.chain-abstraction/fastauth-sdk.md) is currently in a private beta stage. If you want to try it out during this early development stage, please [contact us on Telegram](https://t.me/neardev).


This is a configuration for use if you intend to integrate with FastAuth SDK

It covers gas for user transactions up to a allowance specified in Redis to interact with a whitelisted set of contracts.
Allowances are on a per-account id basis and on signup (account creation in Redis and on-chain) an OAuth token is required to help with sybil resistance
This also makes use of a shared storage functionality on the Near Social DB contract
and a whitelisted sender (whitelisted_delegate_action_receiver_ids)
fastauth.toml

Pay with fungible tokens
This is a configuration for a relayer that ensures there's FTs sent to a burn address used to cover the equivalent amount of gas for user transactions to interact with a whitelisted set of contracts

pay_with_ft.toml

Whitelist senders
This is a config for a relayer that covers gas for a whitelisted set of users' transactions to interact with a whitelisted set of contracts

whitelist_senders.toml (whitelisted_delegate_action_receiver_ids)

Shared storage
This is a configuration for a relayer that covers BOTH gas AND storage fees for user transactions to interact with a whitelisted set of contracts

be sure to include shared storage logic based on shared_storage.rs in your contract that is being whitelisted
shared_storage.toml

Exchange withdraw
This is a configuration for a relayer where an exchange running the relayer covers user withdraw fees when they are withdrawing stablecoins on NEAR (e.g., USDT or USDC)

exchange_withdraw.toml

### FastAuth SDK

FastAuth is a key management system that allows users to recover or sign-up for a NEAR account using their email address. Furthermore, it allows to subsidize gas for a certain smart contract, so users can interact with it without having to fund their account.
infoClosed access beta

FastAuth is currently in a private beta stage. If you want to try it out during this early development stage, please [contact us on Telegram](https://t.me/neardev).



FastAuth Components
FastAuth is comprised of 3 main elements:

FastAuth Signer App: A module that allow FastAuth users to sign transactions.
MPC Recovery Service: A service to create and restore user accounts, as well as signing transactions on behalf of the user.
Transaction Relayer: A server that relays transactions to the NEAR network on behalf of the user.


Setting up Firebase
Create a project

Go to Firebase
Create or sign in to an account
Go to "Get started", then "Add project"
Call this project my-fastauth-issuer
Disable Google Analytics (recommended)
Click on "Create project"

Set up passwordless authentication

Go to "Authentication", then "Get started", and "Add new provider"
Enable "Email/Password" and "Email link (passwordless sign-in)"
Hit "Save"

Add user device information to Firestore

Return to "Project Overview"
Go to "Cloud Firestore", then "Create database"
Select "Start in production mode", then "Next"
Select your preferred location, then "Enable"
Go to the "Rules" tab
Change the rules to the following:

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId}/{document=**} {
      allow create, read, update, delete: if request.auth != null && request.auth.uid == userId;
    }
    match /publicKeys/{publicKey} {
      allow create, delete: if request.auth != null;
      allow read : if true;
      allow update: if false;
    }
  }
}

Hit "Publish"
Go to the "Data" tab
Click on "Start collection"
Set the Collection ID to users and hit "Next"
Add a Document ID of root and press "Save"
Click on "Start collection"
Set the Collection ID to publicKeys and hit "Next"
Add a Document ID of root and press "Save"

Get the application credentials

Press the gear button next to "Project Overview", and go to "Project settings"
Under "Your apps", click on the </> button
Set the app nickname as issuer-gcp and hit "Register app"
You should see the code needed for initialization and authentication of Firestore, such as:

// Import the functions you need from the SDKs you need

// TODO: Add SDKs for Firebase products that you want to use
// https://firebase.google.com/docs/web/setup#available-libraries
// Your web app's Firebase configuration
const firebaseConfig = {
apiKey: "apikey",
authDomain: "my-fastauth-issuer-123.firebaseapp.com",
projectId: "my-fastauth-issuer-123",
storageBucket: "my-fastauth-issuer-123.appspot.com",
messagingSenderId: "12345678910",
appId: "1:12345678910:web:12345678910"
};
// Initialize Firebase
const app = initializeApp(firebaseConfig);

### Setting up your relayer

#### Setting up a NEAR account

First ensure that `cargo` is installed on your local machine. Try [rustup](https://rustup.rs/) if you haven't already installed it.

```bash
cargo install near-cli-rs
NEAR_ENV=mainnet
near account create-account fund-later use-auto-generation save-to-folder ~/.near-credentials/implicit
This should output something like:
The file "~/.near-credentials/implicit/275f14eecb0afcb1f46f2b71b7933afd2de6d4ae8b08e9b11fc538a5a81406b7.json" was saved successfully
In this example. 275f14eecb0afcb1f46f2b71b7933afd2de6d4ae8b08e9b11fc538a5a81406b7 is your funded account. We'll refer to this as $FUNDED_ACCOUNT from now on.
Send some NEAR to this address.
Adding multiple keys (Recommended)
This account has been created with one key. However, due to this, you should create an account with N keys where N is the number of requests you expect to get in a second, at peak load.
To generate an additional key, run the following command:
near account add-key $FUNDED_ACCOUNT grant-full-access autogenerate-new-keypair save-to-keychain network-config mainnet sign-with-access-key-file ~/.near-credentials/implicit/$FUNDED_ACCOUNT.json send
Deploying the relayer
Run the following command:
git clone https://github.com/near/pagoda-relayer-rs
Go to config.toml and change:
network = "mainnet"
num_keys = 3  # correlates to the number of keys in `keys_filenames`. Will be optional in the future.
relayer_account_id = "$FUNDED_ACCOUNT"
keys_filenames = [
    # The original account
    "~/.near-credentials/mainnet/$FUNDED_ACCOUNT.json",

    # Other keys you've optionally created. This will allow rotating through each key as to avoid nonce races.
    "~/.near-credentials/mainnet/$FUNDED_ACCOUNT/ed25519_4ryLkp4AuzBD8yuyRJKb91hvHZ4zgqouWcJzu1gNEvLv.json",
    "~/.near-credentials/mainnet/$FUNDED_ACCOUNT/ed25519_7K3jF8Ft5dKFEPYRH1T4mncvsZGgSoGKsvsnnKEmqubT.json"
]
Optionally, if you need to generate additional access keys for the $FUNDED_ACCOUNT, run the following command N times. Note that this will create keys for implicit accounts, but we'll then tie them to $FUNDED_ACCOUNT.
near generate-key
near add-key $FUNDED_ACCOUNT exampleImplicitPublicKeyCxg2wgFYrdLTEkMu6j5D6aEZqTb3kXbmJygS48ZKbo1S
Then run:
docker compose up
You should do this on a VM server of your choice. We will refer to the URL of this VM as $RELAYER_URL from now on.
Setting up the frontend
Deploying the signer app

Go to GCP's Cloud Run console and press "Create Service".
In the field "Container image URL", paste nearprotocol/fast-auth-sdk-frontend:latest.
Under Container(s), Volumes, Networking, Security set Container port to 80
Go to the "Container, Networking, Security" fold out and then "Environment Variables"
Click on "Add Variable"
Set the following environment variables from the firebaseConfig you generated earlier.

NETWORK_ID:                           'mainnet',
RELAYER_URL:                          '$RELAYER_URL',
FIREBASE_API_KEY:                     'apikey',
FIREBASE_AUTH_DOMAIN:                 'my-fastauth-issuer-123.firebaseapp.com',
FIREBASE_PROJECT_ID:                  'my-fastauth-issuer-123',
FIREBASE_STORAGE_BUCKET:              'my-fastauth-issuer-123.appspot.com',
FIREBASE_MESSAGING_SENDER_ID:         '12345678910',
FIREBASE_APP_ID:                      '1:12345678910:web:12345678910',
Alternatively if you're doing a testnet deployment, do:
NETWORK_ID:                           'testnet',
RELAYER_URL_TESTNET:                  '$RELAYER_URL',
FIREBASE_API_KEY_TESTNET:             'apikey',
FIREBASE_AUTH_DOMAIN_TESTNET:         'my-fastauth-issuer-123.firebaseapp.com',
FIREBASE_PROJECT_ID_TESTNET:          'my-fastauth-issuer-123',
FIREBASE_STORAGE_BUCKET_TESTNET:      'my-fastauth-issuer-123.appspot.com',
FIREBASE_MESSAGING_SENDER_ID_TESTNET: '12345678910',
FIREBASE_APP_ID_TESTNET:              '1:12345678910:web:12345678910',

Click on "Create Application"
Then, inside your app's control panel copy the app's URL, such as https://signer-app-123456-ab.a.run.app. We will refer to the deploy URL as $WALLET_URL.

Authorizing a domain on Firebase

Go back to the Firebase Console
Go to "Authentication" in the sidebar, and then the "Settings" tab
Click on the "Authorized domains" menu item
Add $WALLET_URL to the list

Deploying your application frontend
First, install the @near-js/iframe-rpc package from the NPM registry.

// Initialize wallet selector
const selector = setupWalletSelector({
          network: networkId,
          modules: [
            setupFastAuthWallet({
              relayerUrl: "$RELAYER_URL",
              walletUrl: "$WALLET_URL"
            })
          ]
      })

// EITHER setup onClick function for login
const onCLick = () => selector.then((selector: any) => selector.wallet('fast-auth-wallet'))
      .then((fastAuthWallet: any) =>
        fastAuthWallet.signIn({
          contractId: "$CONTRACT_ID",
          email: "<USERS_EMAIL_ADDRESS>",
          isRecovery: true,
        }),);

// OR setup onClick function for login
const onCLick = () => selector.then((selector: any) => selector.wallet('fast-auth-wallet'))
      .then((fastAuthWallet: any) =>
        fastAuthWallet.signIn({
          contractId: "$CONTRACT_ID",
          email: "<USERS_EMAIL_ADDRESS>",
          accountId: "<USERS_DESIRED_NEAR_ADDRESS>.near"
          isRecovery: false,
        }),);
Whenever the user tries to login, call onClick.
Getting added to the MPC recovery service
As a last step, we'll need to add your app to our MPC recovery service.
To get added, please send us your $FIREBASE_PROJECT_ID, $RELAYER_API_KEY and $RELAYER_URL through this form.

### Rollup Data Availability

Every monolithic blockchain has a data availability layer. NEAR's Data Availability (DA) represents a pioneering initiative to modularize the data availability layer from the NEAR blockchain to make it available as a roll-up solution for builders on other chains. 
This infrastructure consists of a smart contract, a light client, and a Remote Procedure Call (RPC) node. The smart contract is designed to accept blob data, which is then processed through NEAR's consensus. The RPC node functions as the serving node, where users can transmit their data. Lastly, the light client operates as a node that rollups can verify to ensure the availability of data.

Blob Store Contract: A contract that provides the store for arbitrary DA blobs.
Light Client: A trustless off-chain light client for NEAR with DA-enabled features.
RPC Client: The defacto client for submitting data blobs to NEAR.
Integrations: Proof of concept works for integrating with L2 rollups.

NEAR DA is notably inexpensive due to several key factors:

NEAR offers a substantial amount of block space per shard, ensuring efficient utilization.
NEAR optimizes this space by avoiding unnecessary cryptographic bloat, ensuring that each 4MB allocated equals precisely 4MB of usable data.
NEAR's scalability is unmatched, as it can readily reshard and scale in response to increasing demand, unlike competitors who would need to resort to constructing rollups or sidechains, thus maintaining a consistently ample and cost-effective data availability solution.

tipor the latest information, please check the [Near DA](https://github.com/near/rollup-data-availability/) repository.


System Context
This outlines the system components that we build and how it interacts with external components.
Red lines denote external flow of commitments.
White lines denote flow of blob data.
note`Fisherman` is just an example how a rollup can work with the light client in the initial stage of DA, until we implement a more non-interactive approach, such as KZG.

C4Context
    title NEAR Data Availability System Context

    Enterprise_Boundary(b1, "Ethereum") {
        System_Ext(SystemEth, "Ethereum")

        System_Boundary(b2, "Rollup") {
            System_Ext(SystemRollup, "Rollup", "Derives blocks, execute transactions, posts commitments & sequence data")
            System(SystemNearDa, "NEAR DA Client", "Submits/Gets blob data, creates commitments")
        }
        BiRel(SystemRollup, SystemEth, "Posts sequences, proofs of execution, DA frame references")
        BiRel(SystemRollup, SystemNearDa, "Post batches, retrieves commitments")
        Rel(fisherman, SystemEth, "Looks for commitments, posts results")
    }      

    Enterprise_Boundary(b0, "NEAR") {

        System(SystemLc, "Light Client", "Syncs headers, provides inclusion proofs")
        System(SystemNear, "NEAR Protocol", "NEAR validators, archival nodes")

        Rel(SystemLc, SystemNear, "Syncs headers")    
        Rel(SystemNearDa, SystemNear, "Submits/Gets blob")

        %% This doesn't exist yet
        %% System(SystemDas, "Data Availability Sampling", "Data redundancy, retrieval, sample responses")
        %% BiRel(SystemDas, SystemLc, "Commitments")
    }

    Person_Ext(fisherman, "Fisherman")
    Rel(fisherman, SystemLc, "Requests inclusion proofs, validates inclusion proofs")

    UpdateRelStyle(fisherman, SystemEth, $offsetY="-10" $lineColor="red")
    UpdateRelStyle(fisherman, SystemLc, $offsetY="-10", $lineColor="red")
    UpdateRelStyle(SystemRollup, SystemEth, $offsetY="-30", $lineColor="white")
    UpdateElementStyle(fisherman, $bgColor="grey", $borderColor="red")

    UpdateRelStyle(SystemRollup, SystemNearDa, $offsetX="-200", $lineColor="white", $textColor="white")
    UpdateRelStyle(SystemNearDa, SystemNear, $textColor="white", $lineColor="white", $offsetY="10")
    UpdateRelStyle(SystemNearLc, SystemNear, $offsetX="30")

Blob Store Contract
The blob store contract provides the store for arbitrary DA blobs. In practice, these "blobs" are sequencing data from rollups, but they can be any data.
NEAR blockchain state storage is pretty cheap. At the time of writing, 100KiB is a flat fee of 1NEAR. To limit the costs of NEAR storage even more, we don't store the blob data in the blockchain state.
It works by taking advantage of NEAR consensus around receipts. When a chunk producer processes a receipt, there is consensus around the receipt. However, once the chunk has been processed and included in the block, the receipt is no longer required for consensus and can be pruned. The pruning time is at least 3 NEAR epochs, where each epoch is 12 Hours; in practice, this is around five epochs. Once the receipt has been pruned, it is the responsibility of archival nodes to retain the transaction data, and we can even get the data from indexers.
We can validate that the blob was retrieved from ecosystem actors in the format submitted by checking the blob commitment. The blob commitment currently needs to be more efficient and will be improved, but it benefits us because anybody can build this with limited expertise and tooling. It is created by taking a blob, chunking it into 256-byte pieces, and creating a Merkle tree, where each leaf is a Sha-256 hash of the shard. The root of the Merkle tree is the blob commitment, which is provided as [transaction_id ++ commitment] to the L1 contract, which is 64 bytes.
What this means:

Consensus is provided around the submission of a blob by NEAR validators
The function input data is stored by full nodes for at least three days
Archival nodes can store the data for longer
We don't occupy consensus with more data than needs to be
Indexers can also be used, and this Data is currently indexed by all significant explorers in NEAR
The commitment is available for a long time, and the commitment is straightforward to create


Light Client
A trustless off-chain light client for NEAR with DA-enabled features, Such as KZG commitments, Reed-Solomon erasure coding & storage connectors.
The light client provides easy access to transaction and receipt inclusion proofs within a block or chunk. This is useful for checking any dubious blobs which may not have been submitted or validating that a blob has been submitted to NEAR.
A blob submission can be verified by:

Taking the NEAR transaction ID from Ethereum for the blob commitment.
Ask the light client for an inclusion proof for the transaction ID or the receipt ID if you're feeling specific; this will give you a Merkle inclusion proof for the transaction/receipt.
Once you have the inclusion proof, you can ask the light client to verify the proof for you, or advanced users can manually verify it themselves.
Armed with this knowledge, rollup providers can have advanced integration with light clients and build proving systems around it.

In the future, we will provide extensions to light clients such that non-interactive proofs can be supplied for blob commitments and other data availability features.
It's also possible that the light client may be on-chain for the header syncing and inclusion proof verification, but this is a low priority right now.

DA RPC
This client is the defacto client for submitting blobs to NEAR. These crates allow a client to interact with the blob store. It can be treated as a "black box", where blobs go in, and [transaction_id ++ commitment] emerges.
There are multiple versions:

The da-rpc crate is the rust client, which anyone can use if they prefer rust in their application.
The responsibility of this client is to provide a simple interface for interacting with NEAR DA.
The da-rpc-sys crate is the FFI client binding for use by non-rust applications. This calls through to da-rpc to interact with the blob store, with some additional black box functionality for dealing with pointers wrangling and such.
The da-rpc-go package is the go client bindings for use by non-rust applications, and this calls through to da-rpc-sys, which provides another application-level layer for easy interaction with the bindings.

infoSee also [the diagram](https://github.com/near/rollup-data-availability/blob/main/docs/da_rpc_client.md)


Integrations
We have developed some proof of concept works for integrating with L2 rollups:


CDK Stack: We have integrated with the Polygon CDK stack. Using the Sequence Sender for submissions to NEAR.


Optimism: We have integrated with the Optimism OP stack. Using the Batcher for submissions to NEAR and the proposer for submitting NEAR commitment data to Ethereum.


Arbitrum Nitro: We have integrated a small plugin into the DAC daserver. This is much like our http sidecar and provides a very modular integration into NEAR DA whilst supporting arbitrum DACs.


infoIn the future, the `Arbitrum Nitro` integration will likely be the easiest way to support NEAR DA as it acts as an independent sidecar which can be scaled as needed. This also means that the DAC can opt-in and out of NEAR DA, lowering their infrastructure burden. With this approach, the DAC committee members just need to have a "dumb" signing service, with the store backed by NEAR.

### token-transfer-flow

Token Transfer flow
In the previous article we saw an example of token transfer between accounts found in different shards. That example was simplified and missed a few steps in the process. That was intentional, to keep the article and the video short yet explanatory, in order to give you a bigger picture for understanding concepts.
In this article we're going to have a look at the same data flow, but in detail and we will consider two additional scenarios:

Token transfer between accounts found in different shards
Token transfer between accounts found in the same shard

You may be asking what was missing in the previous explanation. The short answer is: Gas Refunds or simply Refunds.
If you don't know what Gas is, please first read the article about Gas from our docs.
As for Refunds, here's a quote from the Gas article:

Attach extra gas; get refunded!
...

If you attach more gas than needed, you'll get refunded

...
From NEAR Protocol docs Gas. Attach extra gas; get refunded!

noteWhat refunds mean in terms of data flow

It means that literally every Transaction includes a refund.


OK, this should be enough for introduction, now let's move on to examples.
Token transfer between accounts found in different shards
Basically it is an extension of the example from the NEAR Data Flow article.
Assume we have two accounts alice.near and bob.near. They belong to different Shards. alice.near sends a few tokens to bob.near.
A Transaction signed by alice.near is sent to the network. It is immediately executed, ExecutionOutcome is the output or result from converting the transaction into a Receipt.

During the above process alice.near, the sender, was charged a fee (gas). The Receipt created as result of the Transaction follows these rules:

It will be executed not earlier than next Block
It must be executed on the receiver's Shard

So, in our case the receiver is bob.near and that account belongs to a different Shard that's why the Receipt moves to the receiver's Shard and is put in the execution queue.
In our example the Receipt is executed in the very next Block.

Almost done. Remember the refund? So the ExecutionOutcome for the Receipt will be another Receipt that is refunding the Gas to the sender. bob.near has received tokens from alice.near. Now, alice.near becomes the receiver for a new (and last) Receipt (keep in mind the sender in this Receipt is always system).
Keep in mind rule #2: the Receipt must be executed on the receiver's Shard. So this Receipt moves to the Shard where alice.near belongs to. And it is the last execution in this process.

This is it. Tokens have been transferred from the account on one Shard to the account on a different Shard, and the initial sender, alice.near, received a refund of Gas.
Token transfer between accounts found on the same shard
Let's have a look at the example where both accounts are on the same Shard. The process is the same as in the previous example, except there are no Receipts moving from one Shard to another.
A Transaction signed by alice.near is sent to the network. It is immediately executed, ExecutionOutcome is the result of converting the transaction into a Receipt.

The Receipt is already on the receiver's Shard, so it is put in the execution queue of the next Block. It is executed in the next Block, and the ExecutionOutcome result is a new Receipt with the refund to the initial sender, alice.near.
The Same rules apply to this Receipt, it is put into the execution queue and executed in the next Block.

This is it. You may wonder why the process is overcomplicated for the same Shard case. The answer is: the same rules are always applied. Also, this mechanism allows to build the NEAR Protocol data flow by only one set of rules, no matter how many Shards exist. Also, we avoid a lot of "ifs" and we don't have to keep in mind different corner cases because the process always follows the same rules.

### near-data-flow

NEAR Data Flow
<iframe
width="100%"
height="500"
src="https://www.youtube.com/embed/VSBJ-A69Km4"
title="YouTube video player"
frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
allowfullscreen>

infoData flow

In this video we give a quick overview on the main concept of how the data flows across the NEAR Protocol blockchain.


NEAR Protocol blockchain data flow might be a bit tricky at a glance. But it is pretty straightforward and follows well-defined rules. In this article, we are going to have a closer look at how the data flows in NEAR Protocol blockchain.
In fact, any blockchain flow can be represented as an infinite timeline that has a start but has no end.

And a block appears on that timeline with some interval. Each of these blocks holds the information about the previous one, thus, creating a chain of blocks.
NEAR Protocol has a sharded nature, meaning that more than one parallel network, called a Shard, can be live at any moment. And each Shard produces a chunk of a block at a given interval. A Block in NEAR Blockchain is a collection of the block chunks from all shards. Block chunk is shortened to Chunk in NEAR Protocol documentation.
Returning to the data flow itself. The best we can do is to imagine tracks like we could see in audio/video editing apps. Each Shard has its own set of tracks. The top track is for Chunks. They appear no matter what at a given interval, for NEAR Blockchain the interval is about one second. Chunks are being produced even if nothing is happening on the blockchain.

But what do we mean by saying something is happening? We mean that something has triggered some changes in the blockchain. And the most well-known method to trigger any changes is to send a Transaction to the blockchain with instructions of what we want to change and who has requested those changes.
A transaction needs to be constructed, signed and sent to the blockchain. Once it is executed we expect to have a result - ExecutionOutcome. Oh, that is simple. But it’s not really accurate for NEAR Blockchain.

In the beginning there is a Transaction, it contains instructions we want to be executed on the blockchain. Transaction is sent to NEAR Blockchain.
And yes, it is executed there immediately BUT the immediate result of the transaction execution is always just an acknowledgment that it will be executed on the chain; this internal execution request is known as Receipt. You can think of the Receipt as an internal transaction that exists to pass information across shards.
Let’s get back to the tracks to look at the example.
Assuming we have two accounts living on different Shards alice.near and bob.near. alice.near creates a Transaction to send a few tokens to bob.near. The Transaction is immediately executed and the ExecutionOutcome for the Transaction is always a Receipt.
But this Receipt cannot be executed here, because bob.near doesn’t live on the same Shard as alice.near, so the Receipt must be executed on the receiver’s Shard. So the Receipt is moving to the Shard where bob.near belongs to.
On the destination Shard the Receipt is executed and the process is considered as done.
infoThe explanation here is simplified

Please refer to the [Token transfer](https://raw.githubusercontent.com/Techbridge3/docs/master/docs/1.concepts/data-flow/token-transfer-flow.md) flow article


So the final scheme will look like:

Summary
We have learnt the main principles of how data is flowing in NEAR Protocol. We have found out that Transactions execute and the ExecutionOutcome of the Transaction is always a Receipt.
Now we know that Receipt is a main internal asset for NEAR Protocol blockchain and it has a power of traveling between Shards. We learnt the NEAR Data flow on a simple example. Of course in real life with more complex transactions that involve cross-contract calls, there will be more Receipts and ExecutionOutcomes.
We hope this article is useful and you will be able to build your dApps and indexers easily with the knowledge of how data if flowing in NEAR Protocol.

### Validators

The NEAR network is decentralized, meaning that multiple people collaborate in order to keep it safe. We call such people validators.
In order to make sure that all the transactions in the network are valid, i.e. that nobody is trying to steal money, the validators follow a specific consensus
mechanism.
Currently, there are a few well-known consensus mechanisms to keep a blockchain working correctly and resistant to attacks.
NEAR Protocol uses a version of Proof-of-Stake, particularly Thresholded Proof of Stake.
In Proof-of-Stake, users show support to specific network validators by delegating NEAR tokens to them. This process is known as staking. The main idea is that, if a validator has a large amount of tokens delegated is because the community trusts them.
Securing the Network
Validators have two main jobs. The first is to validate and execute transactions, aggregating them in the blocks that form the blockchain. Their second job is to oversee other validators, making sure no one produces an invalid block or creates an alternative chain (eg. with the goal of creating a double spend).
If a validator is caught misbehaving, then they get "slashed", meaning that their stake (or part of it) is burned.
In the NEAR networks, an attempt to manipulate the chain would mean taking control over the majority of the validators at once, so that the malicious activity won't be flagged. However, this would require putting a huge sum of capital at risk, since an unsuccessful attack would mean slashing your staked tokens.
Validator's Economy
In exchange for servicing the network, validators are rewarded with a target number of NEAR every epoch. The target value is computed in such a way that, on an annualized basis, it will be 4.5% of the total supply.
All transaction fees (minus the part which is allocated as the rebate for contracts) which are collected within each epoch are burned by the system. The inflationary reward is paid out to validators at the same rate regardless of the number of fees collected or burned.
Intro to Validators
Validators are responsible for producing and validating blocks and chunks, ensuring the security and integrity of the NEAR network.
The hardware requirements for running a validator node vary depending on the staking position. Detailed specifications can be found here: the hardware requirements.
You can view the list of currently active validators on platforms like NEAR-STAKING. To become a validator, the minimum stake required is determined by the 300th largest staking proposal. If there are more than 300 proposals, the threshold will be set by the stake amount of the 300th proposal, as long as it exceeds the minimum threshold of 25,500 $NEAR. The current seat price to join the active validator set is updated in real-time on NEAR BLOCKS. Any validator node with a stake greater than the current seat price can join the set of active validators.

Is there a plan to support GPU compute if certain validator nodes can offer that or is it just CPU?

We don't need GPU support as we are a POS chain and we require very little compute power.

You can read more about our consensus strategy on our Validator Quickstart and Staking FA.


The top 100 validators are responsible for producing and validating blocks, as well as producing chunks. Under normal circumstances, each validator is assigned to a single shard, for which it produces chunks.
Block & Chunk producers are guaranteed a minimum annual reward of 4.5%. If less than 100% of the network’s tokens are staked, validators have the potential to earn even higher annual rewards.
Chunk Validators
[Note] Block & Chunk producers also serve as chunk validators.
Non-top 100 validators take on the role of chunk validators, which has lower hardware and staking requirements, making it more accessible. This role helps expand the network's validator set, increasing opportunities to earn rewards and strengthen the security of the NEAR ecosystem.
Chunk validators do not track shards. Their responsibilities are focused solely on validating and endorsing chunks.
Like block and chunk producers, chunk validators are guaranteed a minimum of 4.5% annual rewards. If less than 100% of the network’s tokens are staked, chunk validators may earn even higher rewards. For more details on validator economics, check out NEAR’s Economics Explained.
Dedicated Validator Documentation Site
If you'd like to further explore Validators and Nodes in general, you can visit the Dedicated Validator Documentation Site.

If a developer writes a vulnerable or malicious dApp, is a validator implicitly taking on risk?

No. We have handled the potential damages to the network on the protocol level. For example, we have a lot of limiters that constrain how much data you can pass into a function call or how much compute you can do in one function call, etc.

That said, smart contract developers will need to be responsible for their own dApps, as there is no stage gate or approval process. All vulnerabilities can only damage the smart contract itself. Luckily, updating smart contracts is very smooth on NEAR, so vulnerabilities can be updated/patched to an account in ways that cannot be done on other blockchains.

### Tokens

NEAR Token
This is the native token used in NEAR Protocol.
It has multiple use cases:

Secures the network through staking
Provides a unit of account - NEAR is used for processing transactions and storing data
Serves as a medium of exchange

Securing the Network
NEAR Protocol is a proof-of-stake (PoS) network, which means that resistance from various attacks comes from staking NEAR.
Staked NEAR represents the decentralized infrastructure of servers that maintain the network and process transactions for applications and users on NEAR.
Rewards for providing this service are received in NEAR.
Providing a Unit of Account
NEAR is used to price computation and storage on the NEAR infrastructure.
The network charges transaction fees in NEAR to process changes and transactions.
Medium of Exchange
NEAR is readily available on the protocol level, so it can be used to transfer value between NEAR applications and accounts.
This means that applications can use NEAR to charge for various functions, like access to data or other complex transactions.
Entities can also easily exchange NEAR between each other, without the need for trusted third parties to clear and settle transactions.
For a deeper dive on NEAR Economics: https://near.org/blog/near-protocol-economics
For more information about the NEAR token, visit NEAR Token Supply and Distribution or Nomicon.

### Avoiding Token Loss

warning
Careful! Losing tokens means losing money!

Token loss is possible under multiple scenarios. These scenarios can be grouped into a few related classes:

Improper key management
Refunding deleted accounts
Failed function calls in batches


Improper key management
Improper key management may lead to token loss. Mitigating such scenarios may be done by issuing backup keys
allowing for recovery of accounts whose keys have been lost or deleted.
Loss of FullAccess key
A user may lose their private key of a FullAccess key pair for an account with no other keys.
No one will be able to recover the funds. Funds will remain locked in the account forever.
Loss of FunctionCall access key
An account may have its one and only FunctionCall access key deleted.
No one will be able to recover the funds. Funds will remain locked in the account forever.

Refunding deleted accounts
When a refund receipt is issued for an account, if that account no longer exists, the funds will be dispersed among
validators proportional to their stake in the current epoch.
Deleting account with non-existent beneficiary
When you delete an account, you must assign a beneficiary.
Once deleted, a transfer receipt is generated and sent to the beneficiary account.
If the beneficiary account does not exist, a refund receipt will be generated and sent back to the original account.
Since the original account has already been deleted, the funds will be dispersed among validators.
Account with zero balance is garbage-collected, just before it receives refund
If an account A transfers all of its funds to another account B and account B does not exist,
a refund receipt will be generated for account A. During the period of this round trip,
account A is vulnerable to deletion by garbage collection activities on the network.
If account A is deleted before the refund receipt arrives, the funds will be dispersed among validators.

Failed function calls in batches
warning
When designing a smart contract, you should always consider the asynchronous nature of NEAR Protocol.

If a contract function f1 calls two (or more) other functions f2 and f3, and at least one of these functions, f2 and f3 fails, then tokens will be refunded from the function that failed, but tokens will be appropriately credited to the function(s) which succeed.
The successful call's tokens may be considered lost depending on your use case if a single failure in the batch means the whole batch failed.

### Runtime

This section contains videos that explore the core Runtime, its operation, and how it implements cross-contract calls.
Runtime Overview
An in-depth code overview of NEAR Runtime.
<iframe
width="560"
height="315"
src="https://www.youtube-nocookie.com/embed/Xi_8PapFCjo"
frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
allowfullscreen>

Runtime Action and Data Receipts
An in-depth code review of how NEAR Runtime implements cross contract calls.
<iframe
width="560"
height="315"
src="https://www.youtube-nocookie.com/embed/RBb3rJGtqOE"
frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
allowfullscreen>

Runtime State
An in-depth overview of how NEAR runtime operates with its state.
<iframe
width="560"
height="315"
src="https://www.youtube-nocookie.com/embed/JCkSNL4ie1U"
frameborder="0"
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
allowfullscreen>

### What is NEAR?

NEAR is a user-friendly and carbon-neutral blockchain, built to be fast, secure, and able to grow without limits.

NEAR is the blockchain for everyone.


 What do these Technical Terms mean? 

In technical terms, NEAR is a [layer-one](https://coinmarketcap.com/academy/glossary/layer-1-blockchain), [sharded](https://near.org/blog/near-launches-nightshade-sharding-paving-the-way-for-mass-adoption), [proof-of-stake](https://en.wikipedia.org/wiki/Proof_of_stake) blockchain built with usability in mind.

[Layer-1](https://coinmarketcap.com/academy/glossary/layer-1-blockchain) means NEAR is the foundation that supports everything else built on it. It keeps all the transaction records safe and unchangeable which keeps the network secure and trustworthy.

[Sharded](https://near.org/blog/near-launches-nightshade-sharding-paving-the-way-for-mass-adoption) means the network is broken into pieces that work in parallel. This helps NEAR process transactions quickly and efficiently.

[Proof-of-stake](https://en.wikipedia.org/wiki/Proof_of_stake) uses less electricity compared with other blockchains which use proof-of-work. Users show they own NEAR tokens to help run the network. This makes it cheaper and lets more people use it.



Why Choose NEAR?
NEAR is a technical marvel, offering built-in features such as named accounts and account abstraction. For developers, NEAR offers everything needed for their applications, from smart contracts to indexers. All while being interoperable with other chains.
â­ Simple to Use

Use named accounts like alice.near
Simple sign-up: make an account using email or telegram
Transactions are fast (~1.3s transactions) and cheap (< 1¢ in fees)
You don't need to buy crypto thanks to built-in account abstraction
Access Keys make it safe and easy to use.
Control accounts on other chains thanks to chain signatures

ðŸ›¡ï¸ Battle-Tested

4 years of 100% uptime with more than 800M transactions processed
NEAR has sustained peaks of >13M transactions in a day
In March 2024, the top three monthly dApps, based on unique active wallets, were built on NEAR:

Kai-ching
Sweat
Hot Wallet


🧑â€ðŸ’» Great Developer Experience

Build smart contracts with Javascript or Rust
Simple onboarding, thanks to its complete documentation and examples
Get answers and learn at NEAR DevRel office hours, where anybody can participate
Earn from your contract's gas fees
EVM compatible with Project Aurora (Deploy your Solidity contracts with ease)

â™»ï¸ Environmentally Friendly

NEAR is certified carbon-neutral
NEAR consumes in a year the same energy bitcoin consumes in 3 minutes

### NEAR Networks

NEAR Protocol operates on several networks each operating with their own independent validators and unique state. These networks are as follows:

mainnet
testnet
localnet

Mainnet
mainnet is for production ready smart contracts and live token transfers. Contracts ready for mainnet should have gone through rigorous testing and independent security reviews if necessary. mainnet is the only network where state is guaranteed to persist over time (subject to the typical security guarantees of the network's validation process).

Status: https://rpc.mainnet.near.org/status
[ NearBlocks Explorer ]
[ Wallet ]
[ Data Snapshots ]

Testnet
testnet is a public network and the final testing network for nearcore changes before deployment to mainnet. testnet is intended for testing all aspects of the NEAR platform prior to mainnet deployment. From account creation, mock token transfers, development tooling, and smart contract development, the testnet environment closely resembles mainnet behavior. All nearcore changes are deployed as release candidates on first testnet, before the changes are released on mainnet. A number of testnet validators validate transactions and create new blocks. dApp developers deploy their applications on testnet before deploying on mainnet. It is important to note that testnet has its own transactions and states.

Status: https://rpc.testnet.near.org/status
[ Explorer ]
[ Wallet ]
[ Data Snapshots ]

Localnet
localnet is intended for developers who want to work with the NEAR platform independent of the public blockchain. You will need to generate nodes yourself. localnet gives you the total control over accounts, economics, and other factors for more advanced use cases (including making changes to nearcore). For developers, localnet is the right choice if you prefer to avoid leaking information about your work during the development process.
More on local development here

tipot a question?

Ask it on StackOverflow!

### Epoch

An epoch is a unit of time when validators of the network remain constant. It is measured in blocks:

Both testnet and mainnet have an epoch duration of 43,200 blocks. Ideally epochs last about 12 hours, since blocks are created every second (in reality, they take slightly longer to be created).
You can view this setting by querying the protocol_config RPC endpoint and searching for epoch_length.

Note: Nodes garbage collect blocks after 5 epochs (~2.5 days) unless they are archival nodes.
Example:




```json
{
  "jsonrpc": "2.0",
  "id": "dontcare",
  "method": "EXPERIMENTAL_protocol_config",
  "params": {
    "finality": "final"
  }
}
```





```bash
http post https://rpc.testnet.near.org jsonrpc=2.0 id=dontcare method=EXPERIMENTAL_protocol_config 
  params:='{
    "finality": "final"
  }'
```




Example Response:
{
    "jsonrpc": "2.0",
    "result": {
        "protocol_version": 44,
        "genesis_time": "2020-07-21T16:55:51.591948Z",
        "chain_id": "mainnet",
        "genesis_height": 9820210,
        "num_block_producer_seats": 100,
        "num_block_producer_seats_per_shard": [
            100
        ],
        "avg_hidden_validator_seats_per_shard": [
            0
        ],
        "dynamic_resharding": false,
        "protocol_upgrade_stake_threshold": [
            4,
            5
        ],
        "epoch_length": 43200,
        "gas_limit": 1000000000000000,
        "min_gas_price": "1000000000",
        "max_gas_price": "10000000000000000000000",
        "block_producer_kickout_threshold": 90,
        "chunk_producer_kickout_threshold": 90,

// ---- snip ----
}
You can learn more about how epochs are used to manage network validation in the Validator FAQ.
tipot a question?

 Ask it on StackOverflow!

### Relayers

A relayer is a simple web service that receives signed transactions from NEAR users, and relays them to the network while attaching tokens to sponsor their GAS expenses. This can be useful to create applications in which the users are not required to purchase NEAR in order to be able to transact. In this document we present a high-level overview on how relayers work. Please check the build a relayer page if you want to learn how to build your own relayer.

How it works

Relayers are a natural consequence of Meta Transactions (NEP-366), a special type of transaction that can be best understood as an intent.
The user expresses: "I want to do a specific action on chain" and signs this intent off-chain, but does not send it to the network. Instead, they send the intent to a Relayer, which wraps the message into an actual transaction, attaches the necessary funds, and sends it to the network.

 Technical Details 

Technically, the end user (client) creates a `SignedDelegateAction` that contains the data necessary to construct a `Transaction`, signs the `SignedDelegateAction` using their key, and send it to  the relayer service.

When the request is received, the relayer uses its own key to sign a `Transaction` using the fields in the `SignedDelegateAction` as input to create a `SignedTransaction`.

The `SignedTransaction` is then sent to the network via RPC call, and the result is sent back to the client. The `Transaction` is executed in such a way that the relayer pays the GAS fees, but all actions are executed as if the user had sent the transaction.


Why use a Relayer?
There are multiple reasons to use a relayer:

Your users are new to NEAR and don't have any gas to cover transactions
Your users have an account on NEAR, but only have a Fungible Token Balance. They can now use the FT to pay for gas
As an enterprise or a large startup you want to seamlessly onboard your existing users onto NEAR without needing them to worry about gas costs and seed phrases
As an enterprise or large startup you have a user base that can generate large spikes of user activity that would congest the network. In this case, the relayer acts as a queue for low urgency transactions
In exchange for covering the gas fee costs, relayer operators can limit where users spend their assets while allowing users to have custody and ownership of their assets
Capital Efficiency: Without relayer if your business has 1M users they would have to be allocated 0.25 NEAR to cover their gas costs totalling 250k NEAR. However, only ~10% of the users would actually use the full allowance and a large amount of the 250k NEAR is just sitting there unused. So using the relayer, you can allocate 50k NEAR as a global pool of capital for your users, which can refilled on an as needed basis.

### Meta Transactions

NEP-366 introduced the concept of meta
transactions to Near Protocol. This feature allows users to execute transactions
on NEAR without owning any gas or tokens. In order to enable this, users
construct and sign transactions off-chain. A third party (the relayer) is used
to cover the fees of submitting and executing the transaction.

Overview

Credits for the diagram go to the NEP authors Alexander Fadeev and Egor
Uleyskiy.
The graphic shows an example use case for meta transactions. Alice owns an
amount of the fungible token $FT. She wants to transfer some to John. To do
that, she needs to call ft_transfer("john", 10) on an account named FT.
The problem is, Alice has no NEAR tokens. She only has a NEAR account that
someone else funded for her and she owns the private keys. She could create a
signed transaction that would make the ft_transfer("john", 10) call. But
validator nodes will not accept it, because she does not have the necessary Near
token balance to purchase the gas.
With meta transactions, Alice can create a DelegateAction, which is very
similar to a transaction. It also contains a list of actions to execute and a
single receiver for those actions. She signs the DelegateAction and forwards
it (off-chain) to a relayer. The relayer wraps it in a transaction, of which the
relayer is the signer and therefore pays the gas costs. If the inner actions
have an attached token balance, this is also paid for by the relayer.
On chain, the SignedDelegateAction inside the transaction is converted to an
action receipt with the same SignedDelegateAction on the relayer's shard. The
receipt is forwarded to the account from Alice, which will unpacked the
SignedDelegateAction and verify that it is signed by Alice with a valid Nonce,
etc. If all checks are successful, a new action receipt with the inner actions
as body is sent to FT. There, the ft_transfer call finally executes.

Relayer
Meta transactions only work with a relayer, an off-chain service. Think of it as a server that accepts a SignedDelegateAction, does some checks on them and eventually forwards it inside a transaction to the network.
A relayer may choose to offer their service for free but that's not going to be
financially viable long-term. But they could easily have the user pay using
other means, outside of Near blockchain. And with some tricks, it can even be
paid using fungible tokens on Near.
In the example visualized above, the payment is done using $FT. Together with
the transfer to John, Alice also adds an action to pay 0.1 $FT to the relayer.
The relayer checks the content of the SignedDelegateAction and only processes
it if this payment is included as the first action. In this way, the relayer
will be paid in the same transaction as John. 
warning Keep in mind
The payment to the relayer is still not guaranteed. It could be that
Alice does not have sufficient `$FT` and the transfer fails. To mitigate, the
relayer should check the `$FT` balance of Alice first.

Unfortunately, this still does not guarantee that the balance will be high
enough once the meta transaction executes. The relayer could waste NEAR gas
without compensation if Alice somehow reduces her $FT balance in just the right
moment. Some level of trust between the relayer and its user is therefore
required.

Limitations
Single receiver
A meta transaction, like a normal transaction, can only have one receiver. It's
possible to chain additional receipts afterwards. But crucially, there is no
atomicity guarantee and no roll-back mechanism.

Accounts must be initialized
Any transaction, including meta transactions, must use NONCEs to avoid replay
attacks. The NONCE must be chosen by Alice and compared to a NONCE stored on
chain. This NONCE is stored on the access key information that gets initialized
when creating an account. 

Constraints on the actions inside a meta transaction
A transaction is only allowed to contain one single delegate action. Nested
delegate actions are disallowed and so are delegate actions next to each other
in the same receipt.

Gas costs for meta transactions
Meta transactions challenge the traditional ways of charging gas for actions.
Let's assume Alice uses a relayer to
execute actions with Bob as the receiver.

The relayer purchases the gas for all inner actions, plus the gas for the
delegate action wrapping them.
The cost of sending the inner actions and the delegate action from the
relayer to Alice's shard will be burned immediately. The condition relayer == Alice determines which action SEND cost is taken (sir or not_sir).
Let's call this SEND(1).
On Alice's shard, the delegate action is executed, thus the EXEC gas cost
for it is burned. Alice sends the inner actions to Bob's shard. Therefore, we
burn the SEND fee again. This time based on Alice == Bob to figure out
sir or not_sir. Let's call this SEND(2).
On Bob's shard, we execute all inner actions and burn their EXEC cost.

Each of these steps should make sense and not be too surprising. But the
consequence is that the implicit costs paid at the relayer's shard are
SEND(1) + SEND(2) + EXEC for all inner actions plus SEND(1) + EXEC for
the delegate action. This might be surprising but hopefully with this
explanation it makes sense now!

Gas refunds in meta transactions
Gas refund receipts work exactly like for normal transaction. At every step, the
difference between the pessimistic gas price and the actual gas price at that
height is computed and refunded. At the end of the last step, additionally all
remaining gas is also refunded at the original purchasing price. The gas refunds
go to the signer of the original transaction, in this case the relayer. This is
only fair, since the relayer also paid for it.

Balance refunds in meta transactions
Unlike gas refunds, the protocol sends balance refunds to the predecessor
(a.k.a. sender) of the receipt. This makes sense, as we deposit the attached
balance to the receiver, who has to explicitly reattach a new balance to new
receipts they might spawn.
In the world of meta transactions, this assumption is also challenged. If an
inner action requires an attached balance (for example a transfer action) then
this balance is taken from the relayer.
The relayer can see what the cost will be before submitting the meta transaction
and agrees to pay for it, so nothing wrong so far. But what if the transaction
fails execution on Bob's shard? At this point, the predecessor is Alice and
therefore she receives the token balance refunded, not the relayer. This is
something relayer implementations must be aware of since there is a financial
incentive for Alice to submit meta transactions that have high balances attached
but will fail on Bob's shard.

Function access keys in meta transactions
Function access keys can limit the allowance, the receiving contract, and the
contract methods. The allowance limitation acts slightly strange with meta
transactions.
But first, both the methods and the receiver will be checked as expected. That
is, when the delegate action is unwrapped on Alice's shard, the access key is
loaded from the DB and compared to the function call. If the receiver or method
is not allowed, the function call action fails.
For allowance, however, there is no check. All costs have been covered by the
relayer. Hence, even if the allowance of the key is insufficient to make the call
directly, indirectly through meta transaction it will still work.
This behavior is in the spirit of allowance limiting how much financial
resources the user can use from a given account. But if someone were to limit a
function access key to one trivial action by setting a very small allowance,
that is circumventable by going through a relayer. An interesting twist that
comes with the addition of meta transactions.

### What are Chain Signatures?

Chain signatures enable NEAR accounts, including smart contracts, to sign and execute transactions across many blockchain protocols.
This unlocks the next level of blockchain interoperability by giving ownership of diverse assets, cross-chain accounts, and data to every single NEAR account.

Diagram of a chain signature in NEAR

How It Works
Controlling accounts and their assets on other blockchain platforms is made possible thanks to the interaction between three elements:

Derivation Paths - A deterministic way to derive foreign addresses from one NEAR account
Multichain Smart Contract - Receives requests to sign a transaction for other blockchains
Multiparty Computation Service Third-party service providing signatures to the contract


Derivation Paths: One Account, Multiple Chains
Chain Signatures link NEAR accounts to addresses in other blockchain using Additive Key Derivation (a simple mechanism for deriving many subkeys from a single master key). These keys are generated using derivation paths (or paths for short).
A derivation path is simply a string (e.g. ethereum-1, ethereum-2, etc) that in conjunction with the NEAR account derives a unique address on the target blockchain.
For example, we can derive multiple Ethereum addresses from example.near by using different paths:

example.near + ethereum-1 = 0x1b48b83a308ea4beb845db088180dc3389f8aa3b
example.near + ethereum-2 = 0x99c5d3025dc736541f2d97c3ef3c90de4d221315
example.near + ... = 0x...

It is important to note that this allows us to discover the public address of the foreign account that we can control. To actually control the foreign account, we need to request signatures from the MPC service.
tipn practice, the external address is deterministically derived using the NEAR address (`example.near`), the path (`ethereum-1`) and the MPC service's public key


Multichain Smart Contract
A deployed multichain smart contract is used to request signatures for transactions on other blockchains.
This contract has a sign method that takes two parameters:

The payload (transaction) to be signed for the target blockchain
The path that identifies the account you want to use to sign the transaction.

For example, a user could request a signature to send 0.1 ETH to 0x060f1... (transaction) using the ethereum-1 account (path).
After a request is made, the sign method will yield execution waiting while the MPC signing service signs the transaction.
Once the signature is ready, the contract resumes computation and returns it to the user. This signature is a valid signed transaction that can be readily sent to the target blockchain to be executed.

Multi-Party Computation Service
The essence of Multi-Party Computation (MPC) is to enable independent parties to perform shared computations on private information without revealing secrets to each other. In practice, this system can be used with blockchain platforms to safely sign a transaction on behalf of a user without ever having to expose a private key.
NEAR's MPC service is comprised of several independent nodes, none of which can sign by itself, but instead create signature-shares that are aggregated through multiple rounds to jointly sign a transaction.
This service continuously listens for signature requests (i.e. users calling the sign method on the v1.signer smart contract) and when a call is detected the MPC service:

Asks its nodes to jointly derive a signature for the payload using the account identified by the path
Once complete, call the v1.signer contract to store the resulting Signature

infoA Custom MPC Service
Generally, MPC signing services work by sharing a master key, which needs to be re-created each time a node joins or leaves.

NEAR's MPC service allows for nodes to safely join and leave, without needing to re-derive a master key

tipant to learn more about the mathematics that enable MPC? [**Check this awesome article**](https://www.zellic.io/blog/mpc-from-scratch/)


Concluding Remarks
Chain Signatures are a powerful tool that allows NEAR accounts to control accounts on other blockchains. This is a fundamental step towards enabling true ownership of cross-chain data and assets.
For the user, the process is made completely on chain, since they only need to make a call to a smart contract and wait for the response.
Thanks to derivation paths, a single NEAR account can control multiple accounts on different blockchains, and thanks to the MPC service, the user can be sure that nobody but themselves can request signatures for those accounts.

### near-lake-framework

NEAR Lake Framework
noteGitHub repo

https://github.com/near/near-lake-framework/


Description
NEAR Lake Framework is an ecosystem of library companions to NEAR Lake. They allow you to build your own indexer that subscribes to the stream of blocks from the NEAR Lake data source and create your own logic to process the NEAR Protocol data in the programming languages of your choice (at the moment, there are implementations in Python, JavaScript, and Rust).
tipEAR Lake Framework announcement

We have announced the release of NEAR Lake Framework on NEAR Governance Forum.

Please, read the post [here](https://gov.near.org/t/announcement-near-lake-framework-brand-new-word-in-indexer-building-approach/17668).


How does it compare to NEAR Indexer Framework?



Feature
Indexer Framework
Lake Framework




Allows to follow the blocks and transactions in the NEAR Protocol
Yes
Yes(but only mainnet and testnet networks)


Decentralized
Yes
No(Pagoda Inc dumps the blocks to AWS S3)


Reaction time (end-to-end)
minimum 3.8s (estimated average 5-7s)
minimum 3.9s (estimated average 6-8s)


Reaction time (framework overhead only)
0.1s
0.2-2.2s


Estimated cost of infrastructure
$500+/mo
$20/mo


Ease of maintenance
Advanced(need to follow every nearcore upgrade, and sync state)
Easy(deploy once and forget)


How long will it take to start?
days (on mainnet/testnet)
seconds


Ease of local development
Advanced(localnet is a good option, but testing on testnet/mainnet is too heavy)
Easy(see tutorials)


Programming languages that a custom indexer can be implemented with
Rust only
Any(currently, helper packages are released in Python, JavaScript, and Rust)



Limitations
Lake Framework relies on the data being dumped to AWS S3 from NEAR Lake Indexer which is based on NEAR Indexer Framework. Thus, Lake Framework is centralized around AWS S3 storage and also around maintainers of NEAR Lake Indexer nodes (Pagoda Inc). This is the tradeoff you might still want to take given all the other benefits mentioned above.
Indexers based on the Lake Framework inherit the latency characteristics of Indexer Framework and extra latency of dumping to and reading from AWS S3, which is estimated to add at least 50ms delay while writing to S3, and 50ms on polling and reading from S3 (to make the polling cost-efficient, we default to polling only every 2s, so in the worst case you may observe an additional 2-second latency). Thus, Lake Framework adds 0.1-2.1s latency on top of Indexer Framework. Yet, again, most of the latency is there due to the finalization delay and both Indexer Framework and Lake Framework add quite a minimum overhead.
What is the cost of running a custom indexer based on NEAR Lake?
Indexers based on NEAR Lake consume 100-500MB of RAM depending on the size of the preloading queue, it does not require any storage, and it can potentially run even on Raspberry PI.
Getting the blockchain data from S3 will cost around $18.15 per month as NEAR Lake configured S3 buckets in such a way that the reader is paying the costs.
AWS S3 cost breakdown
Assuming NEAR Protocol produces exactly 1 block per second (which is really not, the average block production time is 1.3s). A full day consists of 86400 seconds, that's the max number of blocks that can be produced.
According to the Amazon S3 prices list requests are charged for $0.005 per 1000 requests and get is charged for $0.0004 per 1000 requests.
Calculations (assuming we are following the tip of the network all the time):
86400 blocks per day * 5 requests for each block / 1000 requests * $0.0004 per 1k requests = $0.173 * 30 days = $5.19
Note: 5 requests for each block means we have 4 shards (1 file for common block data and 4 separate files for each shard)
And a number of list requests we need to perform for 30 days:
86400 blocks per day / 1000 requests * $0.005 per 1k list requests = $0.432 * 30 days = $12.96

$5.19 + $12.96 = $18.15
Note, the price depends on the number of shards.


near-examples/near-lake-raw-printer: simple example of a data printer built on top of NEAR Lake Framework
near-examples/near-lake-accounts-watcher: source code for a video tutorial on how to use the NEAR Lake Framework
near-examples/indexer-tx-watcher-example-lake indexer example that watches for transaction for specified accounts/contracts build on top of NEAR Lake Framework

noteTutorials

See [Tutorials page](/build/data-infrastructure/lake-framework/near-lake-state-changes-indexer)

### near-indexer-framework

NEAR Indexer Framework
noteGitHub repo

https://github.com/near/nearcore/tree/master/chain/indexer


:::caution You might be looking for NEAR Lake Framework

NEAR Lake Framework is a lightweight alternative to NEAR Indexer Framework that is recommended for use when centralization can be tolerated.
::

Description
NEAR Indexer Framework is a Rust package (crate) that embeds nearcore, and abstracts away all the complexities of collecting every bit of information related to each produced block in NEAR network. The crate name is near-indexer, and it is part of the nearcore repository.
near-indexer is a micro-framework, which provides you with a stream of blocks that are recorded on NEAR network. It is useful to handle real-time "events" on the chain.
Rationale
As scaling dApps enter NEAR’s mainnet, an issue may arise: how do they quickly and efficiently access state from our deployed smart contracts, and cut out the cruft? Contracts may grow to have complex data structures and querying the network RPC may not be the optimal way to access state data. The NEAR Indexer Framework allows for streams to be captured and indexed in a customized manner. The typical use-case is for this data to make its way to a relational database. Seeing as this is custom per project, there is engineering work involved in using this framework.
Limitations
NEAR Indexer Framework embeds the full NEAR node and thus requires to sync with the peer-to-peer network and store all the network data locally thus it is subject to the storage requirements, which is hundreds of GBs on SSD if you only need to extract the data that is not older than ~2.5 days, and thousands of GBs on SSD if you want to be able to go over the whole history of the network. Also, the network sync process is known to be extremely slow (while the block production is 1 block per second, while the block sync usually reaches 2 blocks per second, which means that it is capable to catch up with the live network at a speed of 1 block per second, so if your node was offline for one hour, it will take one hour to catch up to the tip of the network that keeps getting freshly produced blocks).
NEAR Indexer Framework only exposes the blocks that were finalized. In NEAR Protocol, it takes 3 consecutive blocks to get the block finalized which means that there is at least a 3-second delay between the time when some transaction hits the network, and the time it is finalized and streamed from NEAR Indexer Framework. If we measure the delay between the moment when a transaction gets submitted from the client device to the moment Indexer Framework-based indexers would receive it, we can see the following timings:

A serialized transaction being transferred over the Internet to NEAR node (most commonly, through NEAR JSON RPC broadcast_tx_commit): around 50ms (it is not measured precisely as it is mostly network latency of TCP handshake + HTTPS handshake)
The transaction is routed to the validation node: around 50ms (again, mostly network latency between the peer nodes)
The transaction arrives in the mempool on the validation node and will be delayed at least until the next chunk/block is produced, so if the transaction was received right at the moment when transactions for the current block were selected, it would take 1.2 seconds on mainnet to get the next block produced
Once the transaction is included in a block, it will produce a receipt which often will be executed in the next block (another 1.2-second delay) - learn more about the NEAR Protocol data flow here
Given that block finalization takes 3 blocks (1.2 seconds * 3), Indexer Framework will only get the opportunity to start collecting the information about the block where the transaction was included 3.6 seconds later, but we should also include at least a 50ms delay that is introduced by the network latency when produced blocks propagate back from the validation nodes back to the regular nodes
Indexer Framework then collects all the bits of information for the produced block and streams it: around 50-100ms
Custom indexer implementation receives the block and there could be additional delays down the line, but that is outside of our scope here

Ultimately, it takes at least 3.8 seconds from the moment one submits a transaction to the network, and Indexer Framework-based indexers pick it up, where the finalization time contributes the most of the delay. In real life scenario, dApps usually need to know the result of the execution, and so it will take a couple of blocks after the transaction is included to get all the receipts executed (read more about the data flow here), so the delay between the transaction submission and the result being observed by an indexer could be 5-7 seconds.
Current Status
Indexer Framework is a tool that provides a straightforward way of getting a stream of finalized NEAR Protocol blocks as soon as possible operating over a decentralized NEAR Protocol peer-to-peer network.
However, in our experiments with the Indexer ecosystem, we realized that we need a lightweight foundation to build micro-indexers instead of maintaining a full nearcore node. We considered various solutions to deliver events (Kafka, RabbitMQ, etc), but ultimately we decided to dump all the blocks as is to AWS S3 bucket. This is where NEAR Lake ecosystem was born, learn more about it here.
These days, we use NEAR Indexer Framework to implement NEAR Lake Indexer and from there we build micro-indexers based on NEAR Lake Framework. Having said that, Indexer Framework plays a crucial role in the ecosystem even though most of the indexers these days are implemented without using it directly.
Applications
See the example for further technical details.

near-examples/indexer-tx-watcher-example NEAR Indexer example that watches for transaction for specified accounts/contracts

### indexers

Introduction to Indexers
Here you will find everything you need to know in order to familiarize yourself with the concept of indexers and even build your own one.
infoDisclaimer

The explanation on this page assumes you have a certain level of understanding of the blockchain technology.


Blockchains and their nature
Blockchain data is optimized for serialized writes, one block at a time, as the chain is being created. Querying the blockchain for data about a specific block or account is fairly straightforward or a "narrow" query. However, querying data across many blocks can be cumbersome because we have to aggregate results from multiple single-block queries. Therefore, we can consider these "wide" queries.
Given the fact that a blockchain itself is a distributed database, and a smart contract (decentralized application, dApp) is an application that runs on a virtual machine inside a blockchain, we need to understand that smart contracts should not be considered as a "backend". While some applications might consist only of smart contracts, building a dApp with only smart contracts, in most cases, is not possible.
Smart contracts are limited in terms of interactions. By "interactions" we mean things that are very common in the real world, like user notifications, integration with third-party applications, etc.
However, the nature of a blockchain is that it must be deterministic. A critical feature of a blockchain is that it knows the state at a given time, and for blockchains that time unit is a block. Think of them as being snapshots. A blockchain does snapshots of its state on every block. We as users can call smart contracts for a specific block, and the blockchain provides guarantees that execution will always produce the same result for the same block any time we call it.
The deterministic nature of a blockchain closes it from external (off-chain) variables. It is totally impossible to perform a call to an API from within a smart contract. A blockchain and a smart contract are closed off from the external (off-chain) world.

Blockchains are great at providing a way to apply the requested changes to the state in a decentralized manner. However, in order to observe the changes, you need to actively pull the information from the network.
Instead of abstract explanations let's look at an example.
noteExample dApp

Say, we have a smart contract that sells e-books. Once a user buys a book we want to send them a copy via email.


The dApp has a helper deployed somewhere off-chain, and this helper has code that can send an email with a copy of an e-book. But how would we trigger the helper?
Getting the data from a blockchain from the external world
NEAR blockchain implements a JSON-RPC endpoint for everyone to interact with the blockchain. Through the JSON-RPC API users can call smart contracts triggering them to be executed with given parameters. Also, users can view the data from the blockchain.
So, continuing with our example we can make our helper pull a Block every second, then pull all the Chunks and analyze the Transactions included in the Block to check if there is a transaction to our smart contract with "buy an e-book" function call. If we observe such a Transaction, we need to ensure it is successful, so we don't send the e-book to a user whose "buy e-book" Transaction failed.
After the process is complete we can trigger the helper's code to send the user an email with the e-book they bought.
This approach is so-called pull model of getting the data. There is nothing wrong with this approach, but sometimes you might find it is not the most comfortable or reliable approach.
Also, not all the data is available through the JSON-RPC. Local Receipts for example are not available through the JSON-RPC, because they are not stored in NEAR node's internal database.
Indexer
A blockchain indexer is an implementation of the push model of getting the data. Instead of actively pulling the data from the source, your helper waits for the data to be sent to it. The data is complete and so the helper can start analyzing it immediately; ideally the data is complete enough to avoid additional pulls to get more details.
Getting back to our example, the helper becomes an indexer that receives every Block, along with Chunks, Transactions with its statuses, etc. In the same way the helper analyzes the data and triggers the code to send the user an email with the e-book they bought.

infoAn indexer concept

An indexer listens to the *stream of data as it's being written on chain* and can then be immediately filtered and processed to detect interesting events or patterns.


Indexers and "wide" queries
The term "wide" queries was mentioned in the beginning of this document. Here's a recap:
note"Wide" queries definition

To query data across many blocks requires the aggregation of results from multiple single-block queries. We can consider these aggregates as coming from *"wide" queries*.


Because indexers listen to the stream of data from the blockchain and the data can be immediately filtered and processed according to defined requirements, they can be used to simplify the "wide" queries execution. For example, a stream of data can be written to a permanent database for later data analysis using a convenient query language like SQL.
Another example that highlights the need for a "wide query" is when you use a seed phrase to recover one or more accounts. Since a seed phrase essentially represents a signing key pair, the recovery is for all accounts that share the associated public key. Therefore, when a seed phrase is used to recover an account via NEAR Wallet, the query requires that all accounts with a matching public key are found and recovered. Utilizing Near Lake Framework can be used to store this data in a permanent database and this allows NEAR Wallet to perform such "wide queries". This is impossible to achieve using JSON-RPC only.
Summary
We hope this article gives you an understanding of the Indexer concept. Also, we hope now you can easily decide whether you need an indexer for your application.
What's next?
We encourage you to learn more about the Lake Indexer project. Please, proceed to Tutorials section to learn how to build an indexer on practice.
Alternatively, there are a few other third-party indexers that are tightly integrated with the NEAR ecosystem. You can review all of your data sourcing options (including The Graph, Pagoda, Pikespeak, and SubQuery) under indexing tools.


## near-protocol-ecosystem

### Node Studio

Node Studio is the easiest way to run a validator on blockchain networks.
You don't need technical skills or prior experience — we take care of the hard stuff so you can focus on earning rewards.




 	One-click node deployment
 	No server management required
 	24/7 monitoring and support

### NEAR AI Legion

Welcome to the NEAR Legion: Recruitment Is Now Open!

The NEAR Legion is the only place in the world where decentralized AI is built, practiced, and preached with a strong focus on commitment via holding $NEAR.

Building the strongest AI community in crypto. Join Today!

### Privy

Privy is an identity + wallet layer that lets NEAR apps onboard anyone in seconds - no seed phrases, no extensions. Users sign in with familiar methods (email, passkeys, socials), and an embedded NEAR wallet is created behind the scenes so they can swap, stake, mint, and sign right away. It feels like a modern web app for users, while still giving them a real NEAR account they can take with them.
Under the hood, Privy uses a split-key model and secure enclaves to protect keys, with sensible recovery and the option to export to full self-custody. Developers get simple SDKs, production-ready flows, and control over the UX and data they collect -perfect for mobile, web, and even agentic use cases on NEAR. The result: faster onboarding, fewer drop-offs, and a safer path from first click to first transaction.

### HOT Craft

HOT Craft is a brand-new NFT marketplace built on NEAR Protocol and designed for the multichain future. As part of the HOT ecosystem, it allows users to explore, buy, and trade NFTs across collections - with support for more chains coming soon.
Whether you're a collector or creator, HOT Craft offers a smooth, early-access experience and welcomes your feedback to help shape its development.

### NEARN

NEARN is a one-stop gigs marketplace built exclusively for the NEAR blockchain community. It matches projects that need talent with a global pool of contributors who want paid, on-chain work—using NEAR’s fast, low-fee layer-one as the settlement rail. By offering three flexible listing types (bounties, projects, and sponsorships) plus crypto-native payouts, NEARN translates the exploding gig-economy model into Web3 and strengthens NEAR’s own builder funnel.

### PublicAI

PublicAI revolutionizes the AI ecosystem by delivering premium, human-generated AI training data while enabling individuals worldwide to monetize their expertise. Leveraging a decentralized network of worldwide verified contributors, our platform ensures unparalleled data quality through rigorous skill validation and a stake-slashing mechanism.
As AI drives job displacement, PublicAI offers a way for everyone to stay involved and earn in the AI economy. Human-in-the-loop (HITL) isn’t just for AI training—it’s increasingly essential during the inference stage, where AI makes real-world decisions. As AI replaces routine jobs, humans must shift into higher-value roles alongside it. PublicAI is building a decentralized human layer for inference, enabling people to validate, review, and guide AI outputs in real time. This new role is independent from training data—it's about keeping humans meaningfully in the loop through the AI-caused job crisis.
As concerns grow around AI models being trained on synthetic data, a recent study published in Nature confirms that AI models trained on AI-generated synthetic data experience performance collapse, highlighting the limitations of relying on AI-generated outputs for future model training. In response to this growing concern, PublicAI has rapidly emerged as a leader in Human-in-the-loop (HITL), generating over $14 million in client revenue and building a global workforce of 1 million contributors. By focusing on real, verified data, PublicAI ensures AI systems remain accurate, diverse, and grounded in human truth.

### Fraction AI

Fraction AI is a decentralized auto-training platform where users create AI agents that compete, learn, earn, and evolve. Unlike traditional AI training, which relies on centralized datasets and manually labeled data, Fraction AI turns fine-tuning into a competitive and incentivized process, allowing users to create and refine AI models through structured competitions in decentralized environments.

### NEAR Intents

NEAR Intents is an outcome‑driven transaction framework that lets users, apps, and AI agents declare what they want to achieve—“swap 10 NEAR for USDC at the best rate,” “bridge assets to Ethereum,” or “repay this loan”—while the network takes care of how to execute it. A signed intent is broadcast to a competitive solver network; the best solver supplies an optimized route across any chain or liquidity venue, and settlement is finalized in seconds via NEAR’s Chain Signatures validators. This hides gas fees, routing decisions, and cross‑chain complexity behind a single-click UX, delivering Web2‑smooth transactions with Web3 security.
Key features


 	
Express → Solve → Settle: one intent, multiple solver bids, instant multi‑chain finality.

 	
AI‑native: designed for autonomous agents that need safe, programmable, and low‑latency execution.

 	
Cross‑chain by default: solvers tap on‑/off‑chain liquidity without bridges or wrapped assets.

 	
Fast & low‑cost: leverages NEAR’s sharded L1 for 2‑3 s finality and minimal fees.


Launched on mainnet in Q1 2025 after a successful beta, NEAR Intents already powers wallets, DEX aggregators, lending markets, and AI‑agent tooling across several major chains—positioning NEAR as the transaction layer for user‑owned AI and seamless Web3 experiences.

### Infinex

Infinex positions itself as a “crypto app designed for humans,” blending the ease of a centralized exchange with the self‑custody ethos of Web3. It achieves this through passkey‑secured smart‑contract accounts, a built‑in Vault/Wallet combo, and gas‑free swaps and bridges across 12 EVM chains plus Solana.
1. What is Infinex?

 	
Cross‑chain, non‑custodial hub: Users can store, send, receive, swap and bridge “thousands of tokens” across EVM networks and Solana from one interface, without worrying about seed phrases, gas, or signing every transaction.

 	
CeFi UX, DeFi rails: The goal is to offer Coinbase‑level simplicity while preserving on‑chain ownership—solving one of DeFi’s biggest adoption hurdles


2. Core Features Web3 Users Will Notice
Passkey Security
Infinex replaces seed phrases with device‑bound passkeys (Face ID, Touch ID, Windows Hello, or a YubiKey). Private keys never leave the device, and smart accounts are deployed automatically on each chain you touch.

Wallet + Vault
Every account ships with a hot “Wallet” for day‑to‑day use and an on‑chain‑recoverable “Vault” for long‑term storage or higher‑value actions

Swidge (Swap + Bridge)
A single click moves assets between chains with no manual bridging or gas calculations—useful for airdrop hunters and power users alike

Earning & Trading Roadmap
Live integrations already let you stake liquid‑staking tokens or earn points; Spot, Perps, Fiat on‑ramps and NFT trading arrive in the “Integration Season” roadmap

3. Governance, Funding & Community

 	
Decentralized council: Six elected seats (security, operations, treasury, trader, ecosystem, community) govern upgrades and treasury deployments.

 	
$65 M+ raised: Framework, Wintermute, Bankless, Solana Ventures, NEAR and others joined a September 2024 round, signalling deep ecosystem backing.

 	
Patron NFTs: A record‑setting Patron NFT sale topped $40 M in four days and now functions as an access/passive‑yield badge for early supporters.

### INTEAR

Building the future of Web3 on NEAR




🌍 About Us
Intear is a cutting-edge Web3 infrastructure provider founded in March 2024 and headquartered in Ukraine. What began as a memecoin project has swiftly evolved into one of the NEAR ecosystem’s leading players, now serving thousands of users and powering diverse dApps. Their core mission: make Web3 experiences feel better than Web2 through best-in-class tools and protocols




🔧 Core Mission

 	
Fastest, most reliable infrastructure: Building top-tier RPC, indexing, oracles, and trading tools on NEAR

 	
Long-term vision: Launch the best Web3 wallet by end of 2025; establish Intear as tier‑one data platform; enable every NEAR app to be fast, secure, and accessible





🛠️ Key Products & Services

 	
Rainy (RPC & Indexing)


 	
High-performance RPC endpoints with added batch/token methods.

 	
Cloud indexer for real-time WebSocket or HTTP data.

 	
Speedy historical backfill from genesis



 	
Intear Wallet


 	
Fastest wallet on NEAR with lightning-quick performance.

 	
Multi-login options: Google, Face ID, Passkeys, Ethereum, Solana—no seed phrases.

 	
Advanced trader tools and ecosystem onboarding



 	
Bettear Bot (Trading Bot)


 	
Ultra-fast trading on NEAR: access launchpads like meme.cooking, AIdols, GraFun, Rhea.

 	
Features include wallet tracking, token alerts, sniping, copy‑trade, DCA



 	
PumpItBetty (Market-Making Tool)


 	
Self-serve market-making across NEAR, Solana, and Sui.

 	
Supports multi-account buying/selling via simple UI



 	
Intear Oracle


 	
Oracle architecture leveraging NEAR's yield‑reserve model.

 	
Decentralized, trustless data feeds; customizable fees; instant within-transaction queries







🏆 Vision & Aspiration
By the end of 2025, Intear aims to:


 	
Launch what they believe will be the “best wallet in Web3.”

 	
Cement their position as the leading data platform for NEAR.

 	
Ensure all NEAR apps run faster and more reliably





🎯 Why It Matters
Intear is tackling some of the biggest UX hurdles in Web3. They’re building tools that rival (or beat) Web2 giants—like AWS, Dropbox, Robinhood—yet are tailored for blockchain users intea.rs.Their wallet, bot, and oracle stack addresses speed, usability, reliability, and accessibility constraints that often hinder mainstream Web3 adoption.

### Intear Wallet

Intear Wallet is a sleek, web-based solution designed for the NEAR ecosystem, emphasizing speed and a simplified user experience. Positioned as one of the “fastest NEAR wallets,” it forms part of Intear’s broader modular infrastructure, which aims to support fast-moving crypto communities—like memecoins—through tools such as InIndexer for event indexing, InEvents for real-time blockchain data streaming, and a Telegram bot for on-chain insights
What sets Intear Wallet apart is its smart-wallet approach: instead of relying solely on traditional seed phrases, users can opt for recovery methods like Google authentication, biometrics, passkeys, or even integration with EVM and Solana wallets. This design choice lowers the barrier for less technical users while maintaining security for experienced crypto users.

### DefiLlama

DefiLlama is the largest TVL aggregator for DeFi (Decentralized Finance). Our data is fully open-source and maintained by a team of passionate individuals and contributors from hundreds of protocols.

Our focus is on accurate data and transparent methodology.

Now tracking  NEAR Intents on the spot Volume Dashboard.

 NEAR Intents are a new type of transaction that allow information, requests, assets, and actions to be exchanged between AI agents, services, and end users

### (L)Earn AI🕺

Learn AI turns NEAR AI’s on‑chain infrastructure into an open alternative to black‑box chatbots: every agent, model, prompt, and dataset sits in a public registry, and you log in with your NEAR account—so usage is fully transparent and auditable.
The agent is a Swiss‑army tutor—Ask, Summarize, Comment, Quiz—powered and rewarded by nLEARN tokens, and its code/config can be forked in minutes for custom learning flows.

### Lantstool

Lantstool is an open-source, client-side development interface purpose-built for the NEAR blockchain. It enables developers to manage transactions, work with cryptographic keys, interact with RPC endpoints, and inspect account details—all within a single, streamlined interface.

### House of Stake

The "House of Stake" proposal outlines a comprehensive governance framework for the NEAR Ecosystem. It focuses on designing a structure emphasizing transparency, accountability, efficiency, and most importantly, protocol alignment. The primary goal is to equip NEAR holders with a governance structure that permits equitable and sustainable growth.
NEAR Protocol's "House of Stake" initiative introduces a structured approach to community governance, emphasizing transparency, accountability, and efficiency. Central to this framework is the vote-escrowed token model, known as veNEAR, which allows users to lock their NEAR tokens for periods ranging from three months to four years. The longer the tokens are staked, the greater the voting power conferred, incentivizing long-term commitment and aligning stakeholders' interests with the protocol's sustainable growth.​
To streamline decision-making and maintain governance efficacy, the House of Stake proposes the establishment of a Screening Committee. This body is tasked with initiating delegate selection processes, pre-screening grant proposals, and continuously evaluating the effectiveness of governance mechanisms. Additionally, a delegate framework is outlined, defining the roles and responsibilities of Endorsed Delegates. These delegates are selected based on their engagement and adherence to compliance standards, serving as crucial operatives in the governance process.

### Shitzu

Shitzu is a grassroots incubator within the NEAR Protocol ecosystem, positioning itself as a central hub for Web3 enthusiasts. Established on April Fool's Day, the project embraces a straightforward approach with its native token, $SHITZU, boasting a total supply of 576,167,000 tokens, all in circulation without any lock-ups or vesting periods. This simplicity reflects Shitzu's commitment to transparency and community-driven development.
One of Shitzu's notable initiatives is Meme.Cooking, a pioneering meme token launchpad on the NEAR Protocol. This platform offers a fair, secure, and community-centric experience for launching meme tokens. Key features include staking-based auctions, locked liquidity, and a refund mechanism, all designed to enhance trust and fairness in the meme token landscape.
In celebration of its second anniversary, Shitzu introduced the SHITZU Revival NFT collection, which was fully minted in just 129 seconds—a testament to its popularity within the NEAR community. Additionally, Shitzu offers an interactive NEAR Protocol Ecosystem Map, providing users with insights into various projects, their categories, and development statuses within the ecosystem. The SHITZU Token Farm further empowers the community by allowing Revival NFT holders exclusive access to token deployment functionalities, reinforcing Shitzu's role as a facilitator of innovation and collaboration in the Web3 space.

### Hot Wallet

The HOT Wallet is a non-custodial, multi-chain cryptocurrency wallet integrated directly into Telegram.

Complementing the Telegram-integrated wallet, HOT Labs offers the HOT Wallet Extension—a browser extension

### ASIMOV Protocol

ASIMOV Protocol tackles the critical challenges facing AI development: data scarcity, biased models, and growing misinformation.
We provide the tools and infrastructure for a community-driven approach to building trustworthy, LLM-agnostic data that fuel AI you can trust.

### Rhea Finance

RHEA Finance is a community-led, multi-purpose DeFi platform built on the NEAR Protocol.

RHEA takes full advantage of NEAR’s low fees, one-to-two second finality, and WebAssembly-based runtime (hello, Rust smart contracts!).

In addition to the advantages of being built on top of NEAR, RHEA Finance provides:

 	


Multiple pools in one contract


 	


Atomic transactions


 	


Customisable pool fee



Features
↔️ Trade

Trade tokens with our automated market maker (AMM) exchange

💰 Pool

Provide liquidity and earn revenue from swap fee

🌾 Farm

Stake LP tokens into farms and earn rewards in return

🌈 Stake

Stake REF tokens to earn more REF tokens, by earning fees generated by the protocol

🗳​ Lending & Borrowing

Lend your NEP-141 Token and Unlock asset liquidity all in one place

### AIDOLS

Launch, Trade & Monetize AI Agents

### XTrace

A Secure AI Agent Knowledge & Memory Protocol for Collective Intelligence

### Phala

CRYPTOGRAPHIC COMPUTER
Phala Network is a next-generation cloud platform that provides a low-cost, user-friendly trustless environment, making zero-trust computing accessible to a broad range of developers. By leveraging a hybrid infrastructure including Trusted Execution Environments (TEEs), blockchain, Multi-Party Computation (MPC), and Zero-Knowledge Proof (ZKP), Phala delivers flexible, open-source, and affordable verification solutions for any developer, in any type of program.

### BETTEAR Bot

Welcome to Bettear, the bot that lets you access information faster than insiders 🕵️‍♂️!

Developed by Intear, Bettear Bot offers a comprehensive suite of tools for tracking and interacting with the NEAR Protocol ecosystem:
🌟 Features:

 	Buy & Sell Positions: Simplify your trading actions within the NEAR ecosystem.
 	Withdraw: Effortlessly manage and withdraw your funds.
 	DCA (NEAR): Automate Dollar-Cost Averaging for your NEAR tokens.
 	Trigger (NEAR): Set automated triggers for NEAR transactions.
 	Snipe (NEAR): Target and execute precise token trades.
 	Export Seed: Securely export your wallet seed phrase.
 	Copyptrade (NEAR): Replicate trades with ease.
 	Deposit From Other Chains: Transfer funds seamlessly from other blockchains.
 	Referral Program: Earn rewards by inviting friends.
 	$INTEAR Airdrop: Access special token airdrops.
 	Launch Meme: Add fun to your crypto journey with meme launch features!

🔧 Tools & Insights:

 	NFT Trades: Monitor NFT transactions in real time.
 	FT Swaps: Conduct fungible token swaps effortlessly.
 	Price Alerts: Stay updated with real-time token price notifications.
 	New Tokens: Discover and track newly listed tokens.
 	New Liquidity Pools: Follow fresh liquidity pools.
 	Near.social: Stay updated on social activity in the NEAR ecosystem.
 	Contract Logs: Access insights through contract logs.

### Dune

Crypto’s Data Platform
Query, visualize, share and export data across 75+ blockchains — build together with Web3’s biggest data community.
Dune’s integration with NEAR provides developers and analysts with comprehensive access to NEAR’s novel sharding architecture. This enables precise tracking of DeFi, NFT activity, and cross-chain transactions, offering deeper insights into one of the fastest-growing ecosystems in Web3

### RWA.xyz

Every tokenized real-world asset, in one place.

### Sweat Wallet

Sweat Economy is a Web3 ecosystem on a mission to promote healthier lifestyles by encouraging people to move more. It is powered by $SWEAT or Sweat Token, a tokenized physical activity (crypto asset and the unit of physical activity value minted by steps). The token is managed via the intuitive non-custodial Sweat Wallet dApp. The Sweat Wallet is a top 5 dApp* globally, designed for the crypto-curious.

Sweat Wallet is a non-custodial mobile wallet dApp. Sweat Wallet enables millions of crypto-curious users to manage their $SWEAT and other crypto holdings–exchange, stake, vote, NFT game-play and more. It is designed from first principles to be the most intuitive and easy-to-use wallet in Web3. Sweat Wallet is a top 5 dApp globally.*

$SWEAT is a tokenized physical activity. Or in other words is a crypto asset and the unit of physical activity value minted by your steps. $SWEAT is a top-101 Web3 asset globally by the number of holders and top-152 asset by the level of user activity.

### Race of Sloths

RACE OF SLOTHS — GAMIFIED OPEN-SOURCE CONTRIBUTIONS.
Race of Sloths story is rooted in the back of the minds of the people behind it since the first days of playing with open-source software back in 2000s.

Let's cut it to the race (pun intended) and say that we started actively working on it on April 19th, 2024 as part of NEAR DevHub initiative to bring more developers to the NEAR ecosystem. Vlad Frolov proposed the initial design of a gamified open-source contributions project which did not have a proper name at that time but had a very clear goal, how the success could look like, why it should work, and why it could fail.

### NEAR AI

NEAR.AI will build towards Open Source and User-owned AGI (artificial general intelligence).

Here is the plan:

 	Teaching machines to code: AI Developer
 	Use AI Developer to teach machines to do research: AI Researcher
 	Use AI Researcher to advance science towards AGI that is owned by all

### Reclaim Protocol

Reclaim Protocol unlocks unlimited possibilities by making HTTPS verifiable in zero knowledge. If you want to prove to me that you have more than a million dollars in your bank account, how would you do it? One option is you send me a screenshot. However, I cannot be sure that you didn’t morph the screenshot. The other option is for you to send me your username password and let me login and check your balance myself. This option obviously assumes that you trust me to not drain your bank account. How can you send some information to a stranger on the internet where trust assumptions fail? That’s what Reclaim Procotol solves for.

Reclaim Protocol generates a zk proof for a TLS session data exchange. When you open an HTTPS website, your browser conducts a ceremony with the server called the TLS Handshake. This handshake involves the passing around of public keys and certificates. These certificates are linked to domain names using a Certificate Authority. All of this tech already exists and works. Reclaim Protocol uses this ceremony to generate zk proofs.

### Amplify Art

“Amplify Art is building a decentralized music platform empowering Artists and their Fans. We use NFTs to enable artists to have complete control over their music, pricing, and distribution.”

### Proximity

Proximity is a research and development firm focused on NEAR Protocol.

We provide financial, strategic, technical, and other bespoke support to talented teams building with the NEAR Chain Abstraction stack.

### RSS3

The Open
Information Layer
RSS3 is a decentralized network indexing and structuring open information, making it accessible and valuable for the next Twitter, Google, and OpenAI.

### MITTE

MITTE, NFT marketplace and meme launchpad on NEAR, will officially shut down on April 10 at 12:00 PM UTC.
NFT projects can leverage traders’ abundant liquidity through MITTE’s order book-based bulk trading system, fostering attraction and active trading. This will significantly enhance the projects’ value and recognition.

MITTE (見て miːte) is an NFT trading platform fully optimized for mobile, allowing fast revenue generation.

NFT traders can now trade large volumes of NFTs seamlessly and promptly, anytime and anywhere, due to introducing a new ‘Order Book’ trading system. This system, designed to optimize your trading experience, allows for maximized profits efficiently.

### Plato

Plato is a community-owned, community-driven restaurant discovery mobile app where eaters are rewarded for posting short vids / photos of what they eat.
Eaters can eat at their favorite restaurants, post reviews, and get rewarded!
Rewards can be traded with community members (badges and dining passes), redeemed for food, and more!

### The Graph

Subgraphs on The Graph are transformative open APIs that efficiently organize and serve blockchain data, accelerating the development of decentralized applications (dApps) on the NEAR Protocol. This integration offers developers further support in efficient data querying, swift access to indexed blockchain data, and seamless interoperability across multiple chains.

By streamlining data retrieval, The Graph’s subgraph support eliminates the need for exhaustive blockchain scans, allowing for quick navigation, filtering, and location of specific data points. This advancement equips NEAR developers with tools similar to Web 2.0 search engine capabilities, tailored for the precision and complexity of blockchain data.

### Keypom

Instant crypto experiences
Drop tokens, experiences, and more. Let's onboard the masses with the click of a link.
Keypom is an access key factory created as a result of 3 common problems that arose in the ecosystem.

 	People want a cheap, customizable, and unique onboarding experience for users.
 	Companies don't want to expose full access keys in their backend servers.
 	dApps want a smooth UX with zero barrier to entry onboarding.

The contract was initially created as a way to handle the 1 $NEAR minimum deposit required for creating linkdrops using the regular linkdrop contract.

If users wanted to create linkdrops, they needed to attach a minimum of 1 $NEAR. This made it costly and unscalable for projects that wanted to mass onboard onto NEAR. Keypom, on the other hand, has been highly optimized to allow for the lowest possible costs.

### ShardDog

A platform built on NEAR that's designed for projects, brands, ANYONE to easily connect & build their AUDIENCE
Shard Dog let's you quickly create a NEAR named wallet with a simple link!
This is done by connecting to KeyPom through custom REST APIs.

### WooNFT

An easy to use WooCommerce plugin that empowers customers to mint NFTs on Mintbase corresponding to the products of their choice. By absorbing all associated costs and fees, the initiative aims to merge the realms of e-commerce and digital assets, providing tangible value through digital ownership

### Lava

Lava is a modular data network for scaling access to any blockchain. The network can flexibly support any RPC and API, and node providers compete to offer the fastest and most reliable service.

### Near One

Building core NEAR protocol.
NEAR One was founded by skilled engineers tackling the most complex challenges in Web3 and continues to strategically engage top-tier industry engineers and scientists. Through such collaborations we aim at developing and maintaining core technology for the NEAR ecosystem, research and innovation on blockchain architecture and scaling, and delivering the sharding roadmap for NEAR to scale to billions of users and beyond.

### FastNear

Fast NEAR is the fastest infrastructure for NEAR blockchain.

Low-latency, always up, and open-source.

### Pathfinder

A decentralized file-sharing platform powered by the NEAR Balkans Hub, redefining how individuals and businesses interact with their data. It leverages blockchain technology, specifically the NEAR Protocol, to ensure trust, security, and simplicity in file sharing.

Benefits for Businesses
Enhanced Security: Pathfinder employs advanced encryption and decentralized storage, mitigating the risks associated with centralized servers and reducing the likelihood of data breaches.
Data Ownership and Control: Businesses retain full ownership and control over their files, eliminating dependencies on external entities and ensuring data sovereignty.
Efficient Collaboration: With granular permissions and decentralized email functionality, Pathfinder streamlines collaboration within and between organizations, fostering a more efficient workflow.

Benefits for Users
Data Sovereignty: Users regain control over their digital assets, ensuring that personal and sensitive information remains in their hands.
User-Friendly Experience: Pathfinder offers a seamless and intuitive interface, making file sharing as easy as a few clicks, even for those unfamiliar with blockchain technology.
Privacy Assurance: Through features like decentralized email and ownership verification, Pathfinder prioritizes user privacy, providing a secure environment for digital communication and file sharing.

### Nansen 🧭

Nansen is a blockchain analytics platform that enriches on-chain data with millions of wallet labels. Crypto investors use Nansen to discover opportunities, perform due diligence and defend their portfolios with our real-time dashboards and alerts.
Why is the platform called Nansen?


We named the platform after Fridtjof Nansen who was an explorer, scientist, diplomat, and humanitarian.

Our core values for Nansen are:

 	Transparency
 	Courage
 	Curiosity
 	Speed

And we think Fridtjof Nansen is a human embodiment of these values.


Why did you build Nansen?


After years of working with blockchain data, we found that many of our clients wanted the same thing: to know more about the wallets that are transacting on-chain.

So we started building Nansen in 2019 to address this need, and have quickly become a leading provider of data and analytics for Ethereum.


How do you get the wallet labels?
We use a variety of methods to label wallets, including


 	Heuristics and algorithms
 	Smart-contract parsing and analysis
 	Investigations and research by our team
 	User submissions
 	and more

.. and crucially the interplay between all of these sources.
More than 99% of our labels are algorithmically inferred.

We aim for extremely high precision, meaning we'd rather not label an address than label it incorrectly.

One key thing to realize is that there is a very strong network effect in adding wallet labels. If we know that wallet X is of type A, and wallet Y is of type B, then if wallet Z interacts with X and Y in a certain way, we can sometimes infer that Z is of type C.

The consequence is that every wallet label we add to our platform can help us infer even more wallet labels.

For the on-chain data itself, we rely heavily on the open source project Ethereum ETL. The main contributors to Ethereum ETL are members of the Nansen core team.

### Bitte

AI, build and execute my cross-chain transaction. Sponsored relayer & dev tools included.

### Nearscope

Next generation NEAR explorer and analytics platform for validators and delegators for NEAR protocol.

 	Near Network performance, decentralization, stake and market metrics
 	NEAR Validators list with performance, centralization, commission and delegators metrics
 	NEAR Validator individual metrics, delegators and rewards reports
 	Delegator account balance distribution, yields stats and rewards reports

### Flipside

Your Personal Web3 Intelligence Team

We’re a diverse team of web3-native experts - expert data scientists, analysts, market strategists, and more - depended on across the industry for intelligence and analytics.



Flipside is a toolkit we’ve built on our collective expertise that serves as your personal Web3 intelligence kit, comprising:


 	an enterprise data architecture
 	an SDK
 	a SQL engine
 	a community of thousands of analysts at the ready,
 	and our team in your corner



So whether you’re a protocol builder that needs programmatic data access or an enterprise looking to break into Web3, we’ve got everything you need to get informed and get ahead.



Our team is relied on throughout the space by chain foundations like those of Polygon, Solana, Avalanche, Near, and a dozen others, as well as top firms, builder teams, and professional data analysts.

### NEAR Crowd

NEAR Crowd is a service that allows people earn Ⓝ by completing small tasks.  While tasks are provided and funded by a centralized entity, called the Requestor, NEAR Crowd significantly limits the power that the Requestor has, and moves the power to the community instead. In particular, while the Requestor provides the specification of what needs to be done in each task, it's the community that decides whether each task is completed correctly according to this specification. This is achieved by creating a set of rules, checks and balances that are enforced by a smart contract deployed on NEAR.

### Talentum

Talentum's what you get when you mix the best of the old school with the new: think SAP meets Upwork, but we're talking full-on Web3 style. It's where the sharp minds meet the cutting-edge enterprises. Here, you can build your crew of top-notch talents for the long game while running your ambassador gigs, boosting your community's strength, and keeping an eagle eye on all your social plays with the kind of smoothness you won't find anywhere else.

The Challenge:
Managing community and ambassador programs traditionally involves the utilization of multiple tools such as Airtable, Google Spreadsheets, Notion, Typeform, Zealy, Layer3, MultiSender, Upwork, and many more. This approach not only consumes significant time and human resources but also lacks transparency, making it challenging to identify high-performing individuals. Such campaigns are frequently marred by low-quality efforts, hindering the overall effectiveness of the program.

The Talentum Solution:
Talentum has resolved these challenges by implementing a quality ranking and direction system. With Talentum, you can effortlessly discern the capabilities of your community members, whether they are skilled designers, developers, copywriters, or celebrated figures in the Web3 ecosystem. Our platform empowers project owners to create their talent databases, ensuring that future hirings are not only professionals but also individuals who have already demonstrated a genuine passion for the project. So you can onboard, analyze, communicate, manage and reward your community within only one supperapp - Talentum.

Our Achievements:
Talentum has already achieved Product-Market Fit by onboarding leading projects in the Web3 space, including Metis, Aurora, Bwarelabs, Sei, Oasis, and several others with around 1000 ambassadors. Additionally, we have received grants from Dfinity and Covalent, further solidifying our position in the industry.

Demo: https://youtu.be/_438mEjqo2w

### Arkana

Arkana, a co-membership platform powered by web3 technology, embodies the spirit of openness and collaboration from the web3 network and brings it into web2 businesses and communities.
Our vision is to create a network of businesses and communities to work and grow together, leveraging their collective ideas, expertise, and resources to foster growth and prosperity for all. This interconnected network empowers participants to thrive, transforming their respective industries and creating a ripple effect that benefits everyone involved.
Through Arkana's innovative use of web3 technology, users can enjoy a fun and engaging experience while effortlessly collecting various digital items. From memberships and vouchers to badges and more, Arkana leverages NFTs (Non-Fungible Tokens) to provide true digital (and physical) ownership to end-users.
Brands and businesses have the opportunity to engage with their customers by rewarding their contributions. Whether it's a new purchase, completing surveys, referring new customers, or other valuable actions, Arkana enables businesses to easily reward their most valuable customers and members.
Join us on this remarkable journey as we revolutionize the way businesses and communities interact. Let's unleash the full potential of collaboration and create a future where success is shared, opportunities are endless, and together, we redefine what's possible.

### PotLock

PotLock is bringing public goods funding legos to NEAR. Direct donations & on chain referrals built on Web3 social. Quadratic funding soon.

### Rogues

Created World of Rogues, postapocalyptic social game on NEAR & Polygon.

### HEROES

HEROES.build streamlines your bounty experience with a secure, transparent platform for task-based payments, featuring smart escrow transactions, straightforward invoicing, and optional identity verification for worry-free tax compliance.

### NEAR DevHub

Decentralize NEAR's development. From idea to implementation, there are many ways for anyone to participate in NEAR ecosystem projects.
NEAR Protocol is your fast, low-cost and reliable gateway to the Open Web
Communities are the lifeblood of /dev/hub
We believe that communities are the foundation of a decentralized ecosystem. Explore and engage with our diverse range of communities today.

### NEAR Mobile

Discover the only NEAR wallet you will need: NEAR Mobile, the most secure and comprehensive mobile wallet designed exclusively for the NEAR Blockchain. Store, send and onramp crypto and NFTs, interact with dapps and DeFi and explore NEAR Protocol from your phone.
Unrivaled Security:
Security isn’t an option; it’s a guarantee. NEAR Mobile is a non-custodial wallet, which means that only you have access to your keys and your crypto. Keep them safe because not even us can recover them if you lose them. We have also included biometric authentication and PIN protection for peace of mind.
Interact with Web3 dApps:
Unlock the limitless potential of the NEAR dApp ecosystem. Easily sign into decentralized applications and explore the investing opportunities in the world of DeFi finance.
Intuitive Design:
Interacting with blockchain should not be complex. NEAR Mobile offers a design that feels familiar from the get-go, shielding you from the intricacies of blockchain technology while delivering an experience that’s pleasing to the eye.
Multi-Currency and NFTs:
Manage an array of tokens and NFTs within the NEAR Blockchain all from one app.
In-App Staking:
Compound your NEAR assets effortlessly. Stake directly within the app and build a more robust portfolio with minimal fuss.
Custom NEAR IDs:
One seed phrase, unlimited possibilities. Create multiple accounts and reserve your personalized NEAR ID for a bespoke experience.
NEAR Mobile isn’t just a wallet; it’s your one-stop-shop to a decentralized universe, seamlessly integrating high-level security, user experience, and versatility. Download NEAR Mobile today and redefine your crypto journey.

### 👀BugEye

There are over 2,000 LNC members who participate in 👀BugEye – community user testing platform for projects from LNC Barrel and other NEAR Ecosystem projects.

Runs 24/7, all you need is just set a link at your website or app and let community explore, find issues and submit.

web3 tooling protects you form spam submission. And you decide how much to reward! But don’t be to greedy – testers will loose interest you break win-win-win rules!

### nStamp

nStamp lets users create tamper-proof, timestamped records on the NEAR blockchain. It works by generating a hash (digital fingerprint) of any data, such as form submissions or AI outputs, and anchoring it on-chain with a NEAR account and timestamp.

🔐 Key Features

 	
Verifiable: Anyone can confirm the data hasn’t changed
 	
Private: Only the hash is stored; the original content stays encrypted
 	
Trustless: No third parties needed; proof lives on-chain

💡 Use Cases

 	
Certify AI-generated responses
 	
Prove form or document submissions
 	
Anchor digital evidence or IP drafts without revealing content

🛠️ How It Works

 	
User submits content
 	
nStamp hashes and optionally encrypts it
 	
The hash is written to the NEAR blockchain with a timestamp
 	
Anyone can verify by re-hashing the original content


nStamp brings blockchain-level trust to everyday digital actions, using NEAR to keep records secure, verifiable, and user-owned.

### KAI-CHING

Shop with KAI-CHING (KAIC) to save time and money.
How? Pay less if you pay with KAIC in hundreds of shops & earn extra KAIC while playing & shopping on KAIKAI

### mutiDAO

“A collective using blockchain technology & community building to nurture creativity”

### NEAR Digital Collective

The community-run NDC is governing and evolving the NEAR Ecosystem through decentralized on-chain decision making and treasury management.

### Meteor Wallet

The most simple and secure wallet to manage your crypto, access DeFi and explore NEAR.

### Bwitter

"Bwitter is the web3.0 of Twitter
we are building the Decentralized of Twitter that touches billions of other people
We have complete develope the Bwitter Android App  
Data attribution to creator
Content can mint NFTs
Creators share content to earn on Bwitter
User play to earn  on Bwitter"

### Toolblox

Toolblox is a no-code smart contract builder. With blockchain technology you can engage more customers and business partners and collaborators, enabling greater connectivity and exchange of value.

### NameSky

Inspiration
With the raising of the NEAR blockchain, we believe that there will be more demand for trading NEAR accounts in the future.

But buying & selling a NEAR account is never an easy thing. So we started the Nice Near Name project with a mission to make NEAR account trading easy and secure.

What it does
Basically, we turn a NEAR account into an NFT upon minting. Thinking of the NFT as an envelope that has the NEAR account inside it. So that the NEAR account can be traded as an NFT in any NFT marketplace. In the end, the owner can take back the NEAR account by burning the NFT.

### Nearscan

NEARSCAN allows you to explore and search the NEAR blockchain for blocks, transactions, accounts.

### HERE Wallet

Self-custodial wallet for NEAR Protocol. Build in DEX aggregator, NFTs, non-blocking staking and weekly airdrop.
Swap tokens.

 	Get the best rate at Orderly DEX or Ref Finance
 	Gas-free swaps starting at $100
 	Whitelist of verified tokens

Stake NEAR

 	Instant withdrawal from staking with 0% fee
 	Up to 9% APY for NEAR tokens
 	+1 APY for HERE Early user NFT owners

Explore NFTs.

 	Review and share the NFT
 	Add friends and set an NFT avatar
 	Unlock extra features for holding NFTs from special collections

### astro-dao

Astro is a platform for launching Decentralized Autonomous Organizations. DAOs are self-organized groups that form around common purposes. Membership, decision making, and funding are coordinated in public on a tamper-proof blockchain.

### Fuzzy Dice

“Web3 Multidisciplinary Usability Guild”

### CalenD

CalenD is a web3 scheduling tool that lets you book meetings and pay with crypto. The interface is simple and familiar—just pick a time, enter your name and email, and you're set.
Unlike traditional tools, CalenD supports NEAR payments (like 0.01 NEAR for a 15-minute call), making it easy for Web3 professionals to charge for their time. It’s perfect for consultants, creators, and DAOs.
You can also leave a short note to help prepare for the meeting. With wallet-based profiles and no need for centralized accounts, CalenD is a modern, decentralized alternative to tools like Calendly.

### Calimero Network

Secure private shard infrastructure lets you protect your data while leveraging all the business benefits of open-source blockchains.
Built on NEAR Protocol.

 	Easily interact with the public chain or private shards.
 	Fully interoperable cross-contracts calls with the public network and other private shards.
 	Hold and manage public assets, bridge your FTs and NFTs to and from a private shard.
 	Interact with other private shards over an encrypted channel.
 	Seamless integration with Near and Aurora ecosystems.
 	Calimero is designed to support confidential native NEAR WASM and Aurora EVM smart contracts.
 	All tools available in the NEAR and Aurora ecosystems are supported.

### Near Social

Near Social - social data protocol on NEAR Protocol

### PlayEmber

At playEmber we’re all about taking that initial ember of an idea and making it into a roaring hit of a game! With years of knowledge in the hyper casual and casual gaming space we're in a perfect position to slingshot games to millions of players and keep them profitable.

With Ember Coin our Web3 arm to the business: Utilising our 100 Million Downloads to date and our mobile gaming expertise, we will add a Play & Earn element to our mobile games along with allowing external F2P game studios the tech to join the P&E EmberCoin ecosystem.

### nCaptcha

Revolutionary way to fight spam!
nCaptcha is a decentralized, Web3-based CAPTCHA system built on NEAR Protocol. Instead of puzzles, it uses micro‑transactions and on‑chain reputation to stop bots. The result? Better protection, smoother UX.




🔄 How It Works
1. Micro‑PaymentsUsers pay a tiny fee (fractions of a cent) to verify they’re human. This cost deters bots from spamming—because at scale, it gets expensive.
2. Reputation-Based AccessTrusted users build on‑chain reputation. Once verified, future interactions can skip payments entirely, keeping things frictionless.




📦 Key Features

 	
Built on NEAR smart contracts (Rust-based)

 	
Open-source JavaScript integration

 	
Mobile-ready, Web2-friendly

 	
WordPress plugins available

 	
Works with Contact Form 7, Gravity Forms, and others





✅ Why It’s Better

 	
No image puzzles or checkboxes

 	
Bots pay to play—users don’t

 	
Fully transparent and open-source

 	
Rewards users with on-chain reputation





🧩 Real Use Cases
nCaptcha is already live with projects like Techbridge and NEAR Catalog, helping stop spam across contact forms, signup flows, and comment sections.




🔧 Easy Developer Integration

 	
Add a JS snippet or install via NPM

 	
Choose: micro-payment or reputation mode

 	
Use with or without a NEAR wallet

 	
Zero back-end setup required with plugins





💬 What the Team Says

“Let bots pay you for trying to abuse your forms. Spoiler: they won’t.”




⚖️ Quick Comparison






Traditional CAPTCHA
nCaptcha




User Friction
Moderate
Very low


Bot Defense
Bypassable by AI
Economic deterrent


Privacy
Tracks user data
No personal data needed


Integration
Backend required
Front-end ready + plugins


User Rewards
None
On-chain reputation











🚀 Final Thoughts
nCaptcha makes spam protection smarter and more user-friendly. It turns CAPTCHA into a decentralized, fair, and transparent tool for websites in both Web2 and Web3 worlds.

### MyNearWallet

MyNearWallet is taking over the NEAR Wallet codebase to give users of the NEAR ecosystem a better, more secure way to store, buy, send, and stake NEAR assets

### Coinsender

Coinsender allows sending NEAR and NEAR fungible tokens to many accounts in a single transaction

### Sweatcoin

Sweatcoin is a global Top 10 Health & Fitness app that tracks physical movement, converting it into digital currency.

The free app comprises movement-verification technology, gamification and a marketplace of exclusive offers and product deals that Sweatcoin can be redeemed for. Sweatcoin 4 Good also enables donation of the currency to good causes.

### LNC Community Bot

LNC Community Bot is a powerful tool to easily verify legitimacy of LNC member and tip learners with nLEARNs for peer2peer help.

 	Proof of (L)Earn - /pol to check the learner activity at the LearnNEAR.Club
 	Proof of NFT - use /learner_nft to check if holds (L)Earners NFT
 	Tip with nLEARNs for meaningful questions and answers

Over 1,400 active users!

### Perennis

Perennis is a neutral-carbon blockchain network with the promise of a planet-possitive economy built on the open web

### Bastion

Bastion is a Lending and Stableswap protocol built on Aurora, NEAR’s EVM-compatible layer. The project innovates with novel features such as: isolated markets, interest rate swaps, increased receipt token utility, veTokens, gauges, and boosters. Building on Aurora enables Bastion to create an autonomous interest-rate engine with superior capital efficiency, low slippage swaps, fast transactions, ultra-low fees, precise liquidations, and harness the underlying UX benefits of NEAR.

### The Burning Realm

"The Burning Realm is a point and click mmorpg set in a medieval fantasy world. players can level
up their character, take part in story driven quests, complete raids to unlock unique and rare
equipment and battle against each other."

### Sender Wallet

Your gateway into the NEAR ecosystem.

### Pikespeak

Access to live and historical data with visualisations of the most fundamental Web 3 use cases. Pikespeak is a user-centric (vs transaction-oriented) analytics solution, focusing on user engagement with the most successful applications: DeFi, DAOs, NFTs, Gaming, etc.

### Harmonic Technology Guild

The Harmonic Technology Guild is a NFT utilities development collective. We build tools and products for creatives and developers to use in creating equitable and engaging content systems. Our focus is on music and visual arts communities, where we connect fans with better ways to enjoy works by their favorite artists.

### GeeGee

"Geegee is a monetization platform designed to change the game for creators and content based communities. By combining an intelligent overlay (HUD) with blockchain technology and banking regulations we are able to deliver a truly Peer2Peer community-centric financial network geared towards Creators and their Communities."

### Fundue

Quadratic Funding on NEAR protocol blockchain

### Tracer

TRACER is the only sustainable Web3 wellness app with social-Fi and game-Fi elements. Wear your unique 3D composable NFT shoes, and run to make handsome earnings!
TRACER is a web3 fitness and lifestyle app with inbuilt NFT gaming and Social-Fi elements where you can earn rewards in token or NFTs just by moving such as walking, jogging, and running.
TRACER makes a sustainable Move-to-Earn model, which we now call a Move-And-Earn model by several game/social elements.

### Playible

Playible is a blockchain-based platform focused on bridging the gap between decentralized finance, NFT technology, and traditional gaming markets to offer free-to-enter fantasy sports contests with real cryptocurrency prizes. Collect once, play forever.

### Orderly Network

Orderly Network is an on-chain orderbook DEX that aims to provide spot trading, margin trading, perpetual swaps, and lending & borrowing.

### Nearsend

Bulk send NEAR and NEP-141 tokens in one click
Fed up of wasting time manually sending out multiple transactions on NEAR Protocol ? Nearsend is for you! Bulk-transacting on NEAR has never been easier.

### Leap Wallet

Leap Wallet is the simplest & safest way to store, send, swap and stake tokens.

### Coinhall

Coinhall provides Terra price charts, swap aggregation and analytics in realtime across all DEXes in the Terra ecosystem. Coming soon: Terra2.0, NEAR, JUNO.

### NEAR Health

"Bringing blockchain technology to healthcare and solving real life healthcare problems using the infrastructures in the Near protocol ecosystem"

### Apollo42

Apollo42 is the world’s first NFT ecosystem of services for the NFT community, P2E gamers, and Metaverse users allowing everyone to do everything in one place: from socialising with other NFT enthusiasts on the marketplace to creating an NFT collection with zero code and analysing the overall NFT market.

### Pagoda

Build, launch, and operate new blockchain-based products and services. By developers, for developers.

### Tonic DEX

Tonic brings the speed and convenience of centralized exchanges to NEAR while being fully decentralized.

We’re building a high-performance, fully decentralized trading platform. Buy and sell any NEAR token with low fees, deep liquidity and precise pricing, secured by the NEAR Protocol.

### Theia

Theia is a Metaverse GameFi, it combines NFT, DeFi and video game.The story of Theia is set in the universe, and players can drive their own spaceships to explore the planet.

### ONTO Wallet

"ONTO is a DID-based gateway for a seamless Web3 experience. The best all-in-one option for securely managing your identities, data, and digital assets, ONTO allows you to manage your crypto assets (including NFTs), perform cross-chain swaps, readily access a variety of dApps, and learn everything important in real time via ONTO news feed.
With ONTO Wallet, users can create an ONT ID, a decentralized digital identity that enables one-click multi-chain wallet address creation and management and fully protects their private data through an encryption algorithm. Users worldwide can download ONTO Wallet now via onto.app or their mobile app store. Desktop users can also install ONTO Web Wallet (https://chrome.google.com/webstore/detail/onto-wallet/ifckdpamphokdglkkdomedpdegcjhjdp?hl=en) for web browsers."

### Nightly wallet

Nightly is the first complete wallet on the NEAR blockchain which is incorporating various functions, not limited to transaction support. These include token swap, transaction processing with the use of a QR code, and an NFT collection display.

### Nearblocks

Nearblocks.io is a Near Protocol explorer supported by the NEAR Protocol team and received Grants from Near Foundation. We provide Blockchain Explorer, Search, API, Analytics Platform for Near Protocol, and a decentralized smart contracts platform. Built and launched in early 2022, to provide a User-friendly experience for blockchain data.

### Near Netherlands

To connect the Near Community in The Netherlands.

### Near Multicall

"Near-multicall is a tool for DAOs to create and execute any number of actions in one single proposal, even surpassing the max transaction gas limit (currently 300Tgas). It also enables them to set specific execution times, so proposals don't run as soon as they pass voting.
This makes it easier for large DAOs to coordinate their work, and rely less on delegating execution of proposals to trusted entities, making the process more transparent and trustless."

### Loozr

"Loozr is a cryptocurrency-powered music streaming platform that allows everyone to invest in and profit from the success of artistes.

Loozr enables creators to tokenize their name/brand, content, and songs; allowing fans to buy, sell, trade, and promote these tokens directly in real-time on the blockchain while also sharing streaming earnings.
It allows fans to directly and openly contribute to their favourite or upcoming artistes and brands, allowing them to succeed collaboratively on the go."

### GetBlock

"NEAR blockchain explorer powered by GetBlock is a custom solution for search and analytics on NEAR blockchain. Designed in an app-like interface, GetBlock Explorer is user-friendly and easy to read for crypto newbies as well as for crypto-savvy folks.

Navigate through the history of blocks and transactions, view information on each transaction and block, examine specific addresses on the network and discover tons of other NEAR-specific information in a few clicks."

### Coreto

"Coreto is a decentralized reputation-based crypto research platform. Building a safer ecosystem based on Reputation, shared Knowledge, and verifiable Facts.
We help:

Content Creators - build their Reputation, grow their communities, and monetize their knowledge.
Crypto Enthusiasts - Find support in their due diligence processes, giving a quick overview of who to trust and follow, based on our Trust & Performance algorithms.
Projects - Provide them with a tool to help build their brand awareness, grow their community and find reputable content creators to reach for in their marketing campaigns."

### Glass Fund

Become the best crowdfunding platform. A decentralised platform allows users to call for funding, invest and support. This platform can protect investors and supporters, ensure transparency through the "vesting time" and release money part-to-part at each milestone.

### SmartTips

Create economic incentive for Open Source Contributors by tokenizing the contribution (contribute-to-earn).

### Nephilim

Create Freelancer platform that solves the problems that the traditional web2 platform is facing, like bank account hassle, intransparent funds holding, which most web3 projects might have their funds in crypto assets. The DAO will provide a secure way to ensure that all freelancers’ information is genuine. For example, some freelancers will use multiple accounts, create fake jobs, and compete with the other account to gain a better reputation (mostly stars/comments). We prevent this by utilizing our DAO and community governed job delivery

### Datus

Dashboards and deep dive analysis NEAR protocol blockchain

### Zod EDGE

"Zod.TV is a Web3 GPU EDGE providing easy access to containerized compute all across the world."

### web3dev

"The web3dev is based on 3 pillars: Community, Education and Building. 
Community: We created mechanisms with incentives to engage a community of software developers to create exclusive and high quality content about web3 technologies. The community members help each other to enter the web3 space. Our community is organized in pods, each pod for a different theme or blockchain. Each pod has a leader, which helps that pod to evolve, promoting growth to the ecosystem and the whole web3dev community. We incentivize those pods, creating bounties and paying individual contributors when they create new content and deliver value.
Education: The education platform, created by the community, is the place where everybody effectively learns about blockchain technologies. The courses are didactic self-paced project based learning. We give NFT reward as certificates for students who finish the projects.
Building: We find companies that need developers and match our talent community members with maker demands. We build developers team for web3 companies and help these teams to succeed."

### UNO FARM

UnoFarm is a yield farming aggregator. It automates farming process in your favour.
Yield farming is considered one of the most popular investment strategies in DeFi (Decentralised Finance). Yield farming allows DeFi users to earn additional profits from lending/borrowing their cryptocurrency assets, while providing liquidity to decentralized exchanges (DEX).
UnoFarm's mission is to bring together all the best DeFi yield sources within a single tool. Our duty is to provide a unified interface to all of the major farms and liquidity pools, automating the yields generation process, therefore maximizing rewards earned from delegating your assets. The tools mentioned above allow you to increase your income, while keeping it secure, way more safer than handling your assets manually.

### Unchained

Use SQL to query NEAR RPC data in real time

### SputnikDAO

SputnikDAO is a hub of DAOs empowering communities of the NEAR ecosystem. Receive rewards for individual contributions by submitting proposals to existing DAOs. Create a guild for your own meaningful project to find allies and monthly funding.

### Raiz Vertical Farms

Raiz tokenizes urban farms, hydroponic systems & fresh greens to merge the physical and digital worlds. We are building the future of food through decentralised food growing hubs that leverage the power of community to finance and deploy vertical farms with a positive environmental impact.

### Seatlab NFT

Seatlab is solving some of the ticketing industry’s biggest problems with our NFT ticketing Marketplace.

Seatlab provides complete control over the secondary marketplace, which means you can capitalize on all secondary ticket sales via the royalty split function within our application. This provides a solution to scalping and inflated ticket prices caused by touts. True fans can finally purchase tickets they deserve at a fair price, whilst allowing you to generate more revenue on every sale of each ticket.

Built on top of the NEAR blockchain, we’re creating a fully functional, fraud preventing NFT ticketing marketplace, where the idea becomes feasible due to the ultra-low transaction fees and blockchain speed. We aim for artists and event organisers to sign up, set up a profile and mint their NFT tickets in less than 1 minute.

Combining the NFT collectible boom with event experiences, our marketplace allows you to incentivise your audience by minting unique NFTs that can be airdropped to ticket holders during or after every event. Separate to the NFT ticket itself, these collectibles can be visual or audible NFTs that can be rewarded to all ticket holders, displayed as a memory of the event, and ultimately can be resold at a later date.

### OrangeDAO

Orange DAO exists to support past, present, and aspiring Y Combinator founders who are building the future of the crypto ecosystem. We will distribute: wealth, knowledge, access to power, control over resources, and participation in governance, to a broader group of people than ever before in a more equitable way than any previous system.
We will become the most valuable and sought-after crypto founder community by investing our experience, capital, and attention in people, organizations, and networks that share our vision.
Orange DAO will help startups apply to, and be accepted into Y Combinator, provide them with pre- and post-YC funding, while helping mentor their leadership and recruit talent, and acquire customers.
And we will do it responsibly and equitably by becoming a DAO governed by its members because our hive mind is greater than any single ape brain.

### NearZombies

Learn about Near, a sustainable protocol that is growing in popularity every day. NearZombies offers a new way of learning with a lot of fun!

### NEAR Canada

“Empowering canadians with the knowledge of Web 3.0 and NEAR technology.”

### Near Mexico Guild

"COMUNIDAD DE NEAR MÉXICO
Somos un grupo de entusiastas Mexicanos conformados por distintos perfiles profesionales: creadores, colaboradores, emprendedores e iniciales los cuales tenemos como objetivo la difusión y apoyo en el trabajo de la tecnología blockchain.
Si quieres pasar un buen rato compartiendo y aprendiendo conocimiento te invitamos a unirte a esta gran comunidad."

### NEAR MEME DAILY

To empower the open community of blockchain/crypto meme creators.

### Near Malaysia Guild

We will be spreading the adoption of NEAR and blockchain technology in Malaysia by working mainly on two fronts : education & social events.

### LiNEAR Protocol

LiNEAR Protocol is a liquid staking solution built on the NEAR Protocol. LiNEAR unlocks liquidity of the staked NEAR by creating a staking derivative to be engaged with various DeFi protocols on NEAR and Aurora, while also enjoying over 10% APY staking rewards of the underlying base tokens. LiNEAR is the cornerstone piece of the NEAR-Aurora DeFi ecosystem.

### Jumbo Exchange

AMM DEX on NEAR, built with the utmost user-friendliness in mind. Leveraging unique to NEAR protocol features such as predictable pricing system, Jumbo institutes even wider selection of tools aimed at improving the time you spend on the decentralized equivalent of an exchange. With Smart Pools algorithm and on-the-fly transition, Jumbo even further simplifies the way you interact with DEX! On top of that Jumbo is the only AML-ready DEX on the market.

### Electron Labs

"We are enabling NEAR's ED25519 signatures to be batch verified using ZK-SNARKS. Projects like Rainbow Bridge, Machine Storage can use our technology to reduce their cross-chain transaction cost."

### Burrow

UPDATE:

Burrow is now part of RHEA Finance.
In February 2025 in a major milestone for decentralized finance (DeFi), Ref Finance (NEAR’s leading DEX) and Burrow Finance (NEAR’s top lending protocol) have officially merged to launch Rhea Finance — a next-generation chain-abstracted liquidity platform connecting Bitcoin, NEAR, and major EVM ecosystems.
Burrow is a decentralized, non-custodial pool-based interest rates platform that enables users to supply assets to earn interest, and to borrow against them to unlock liquidity. Burrow is similar in nature to Aave, Compound, and other pool-based protocols.

Burrow runs natively on the NEAR blockchain, a layer 1, proof-of-stake, sharded blockchain with a WebAssembly runtime. The Burrow protocol's smart contracts are written in Rust.

Burrow aims to unlock liquidity for interest-bearing assets, particularly layer 1 staking derivatives such as stNEAR and stETH. Users of Burrow will be able to deposit stNEAR as collateral, then borrow more NEAR to create a leveraged staking position, or borrow a stablecoin to create a self-repaying position.

### BeeTogether

“Supporting NPO/NGOs with fundraising ideas to develop a sustainable income for all parties concerned.”

### Atomic Wallet

Atomic Wallet is a non-custodial decentralized wallet. It means that you own your backup phrase and private keys, thus, you fully control your funds. We have no access to your wallet and your sensitive information. Your 12-words backup and private keys are stored locally on your device and strongly encrypted. Moreover, your funds are not located in the wallet itself, there are safely stored on the blockchain. Atomic Wallet connects directly to the blockchain nodes and shows the information about your balances, transaction history and everything you see in the wallet. It also allows you to perform transactions on the blockchain. Atomic Wallet also provides you with exchange and buying crypto services with the help of our partners.

### nSpot

A decentralized community banner exchange platform.

### DeepGreen

DeepGreen Carbon Credits

DeepGreen Carbon Credits (DeepGreenCC) brings transparency to the market of private carbon compensation. This market will grow vastly this year as the German government has made yearly carbon reports mandatory and with growing pressure to become and stay ESG compliant, more and more companies are forced to invest in carbon-neutral production. Since only very limited regulation has been built around the subject, the race is on to build the most customer friendly and trustworthy solution. With NEAR protocol we will replace trust by the blockchain and thus see ourselves in a strong position to become the market leader in the field of carbon compensation.

Why should companies use DeepGreenCC?

 	Our customers will be able to receive a Non-Fungible Token for every report issued through our platform. This NFT contains all the data required to backtrack every ton compensated through our projects, and thus creates a trustless relationship between the stakeholders and our customers.
 	Companies can leverage blockchain technology for creating a trustless relationship with their customers without going through the hassle of creating a blockchain account and securing access to it. We host the NFTs for everyone to see them and offer Blockchain exploration to prevent fraud and double spending.
 	NEAR Protocol uses sharding and proof-of-stake consensus, which makes it one of the most environmentally friendly blockchains on the market. This for us is very important given the nature of our business.
 	With the NFT smart contract NEP-171 being immutable, transparency is not reversible and modifying data later is impossible, just like carbon emissions and compensation. Given these characteristics, we think blockchain technology fits our business and requirements very well.

DeepGreenCC Features:

 	Register as a customer with the Company that wishes to compensate carbon emissions using DeepGreenCC
 	Register associated companies in order to use Certificates bought with another business.
 	Buy Carbon Credits from a selection of high-value carbon compensation projects.
 	Use Carbon Credits purchased previously to issue a CO2 Report. Upon us accepting the report creation, we mint a NFT on the NEAR blockchain for everyone to see and verify the compensation through the high-end technology of a distributed, trustless system.
 	View the projects and details included in your report, download the report and project pages for customer relations.

### Haher

Share you laugh to the world

### dWork

A decentralized platform allows users to hire and find jobs here. The system ensures the salary for developers as well as transparent proof of work to the job owners.

### dSuite

dSuite is web3 platform include dForm, dEvent, dCalendar, dMessage and more.

### TokenHub

Token Hub is effort to help people playing, learning and experiencing DeFi and tokenized economy all the way down. You can create your own token, and then experience interesting DeFi things around it: launch a sale for your token, swap it to others etc.

We are big fans of social tokens and strongly believe in the future of tokenized economy where every person and every community are valuable and can run themselves as their own businesses.

### LNC NEAR watcher

Tired of checking your NEAR wallet every minute?
🥳 Never miss an important transaction - get notified by LNC NEAR watcher Telegram bot!

Over 8,300 active users!

### MutantSwap

The first advanced DeFi DEX with NFT focus combining Defi + NFT in 1 platform providing liquidity not only for Fungible but also for Non-Fungible Tokens on the Aurora blockchain

### Few and Far

Few and Far is the community-first NFT marketplace with rewards for participating.

### Crypto APIs

"Crypto APIs is a robust auto-scalable B2B suite, providing blockchain- and crypto-related products as a service. It is an infrastructure layer which significantly reduces our customers’ go-to market time, development and infrastructure costs. Our mission is to democratize the blockchain industry by providing an easy access into it for both young and established companies in the field.
We will provide to the NEAR community the following products Wallet as a Service, Blockchain Data, Blockchain Events, Blockchain Automations, and Blockexplorer.One."

### Allbridge

"Allbridge is a simple, modern, and reliable way to transfer assets between different networks. It is a bridge between both EVM and non-EVM compatible blockchains, that aims to cover L2 solutions and NFT transfers in the future.
Allbridge’s mission is to make the blockchain world borderless by providing a tool to freely move assets between various blockchains."

### NEAR WordPress

NEAR WordPress goal is to connect the most decentralized software platform with NEAR blockchain via developing WordPress plugins.
WordPress plugin Login with NEAR

 
WordPress plugin NEAR Comments

 
nCaptcha WordPress plugin for Gravity Forms and Contact Form7


 
WooNFT - plugin for Woo Commerce that connects NEAR NFTs with products

### NEATAR

The web3 avatar like as Gravatar on NEAR.

Onchain generative NFTs.

### NEAR Message System

NEAR MESSAGING SERVICE (NMS) is convenient service that makes it simple, easy, and secure for NEAR accounts to exchange messages with each other. The system is completely decentralized and takes advantage of the advantages and power of the NEAR Protocol.
Why you should use NMS?

 	You do not need to create complicated accounts, do not have to enter personal information. Simply use the NEAR account
 	The messages is completely decentralized on the NEAR Blockchain. You don't worry about messages being controlled by 3rd parties
 	Exchange private messages securely. The message (In Private Message mode) are completely secure, only the sender and recipient can read the content of the message. In addition, no one, not even a third party, can not know the content of your messages.

NMS Features:

 	Compose new message with atttachment NEAR
 	Reply the message and received NEAR from sender
 	Forward messagesSupport two type of messages: Private Message and Public Message
 	Support HTML format in message content
 	Support two theme: Dark theme and Light theme.

### XDAO

"In XDAO a group of people can easily create a Decentralized Autonomous Organization (DAO), deposit crypto assets, manage them by voting, sell DAO shares and directly interact with DeFi protocols.
XDAO is a fully customizable DAO builder for treasury management, multisig wallet and the platform for investment. DAOs on XDAO can be any-sized companies.
✨ Watch our intro
https://www.youtube.com/watch?v=Q4wQwL6QaPI
XDAO Created specifically for:
– Venture funds
– Investment pools for launchpads
– Startups
– DeFi projects
– NFT and GameFi collectors"

### Polaris Finance

The first algorithmic stablecoin on Aurora chain, pegged to the price of 1 NEAR via seigniorage. Stake your POLAR-NEAR LP in the Dawn to earn SPOLAR rewards. Then stake your earned SPOLAR in the Sunrise to earn more POLAR!

### Campground

Campground is a blockchain-powered content creation/curation tool and marketplace pioneering the Web3 creator economy. At Campground people build trails, essentially interactive digital content tours that serve a wide variety of use cases. Creators then mint and sell their trails as NFT access tokens to a trail's corresponding content and community.  Beneath Campground's DApp we've developed EMOJI token, designed as an underlying Web3 protocol to reward social reactions, index by emotion, and validate content for quality/accuracy via crowd consensus with prediction market dynamics. EMOJI is not only core to Campground, but a foundational protocol on which the broad decentralized creator economy will be built.

### OIN Finance

OIN Finance, The Gateway to DeFi. OIN will be the first DeFi platform to provide liquidity mining and loans on Ontology, and ultimately on other top platforms through cross-chain functionality. Our platform will build the bridge technology to seamlessly integrate Ethereum to start into our ecosystem, opening up to all of the current DeFi space. Cross-chain technology is crucial in DeFi and its growth as a legitimate financial infrastructure, after all, traditional finance also integrates the whole world, its currencies, and its different financial systems.

### NEARify

NEARify is a discord verification bot that connects Discord with NEAR Wallet and checks to see if a NEAR Wallet holds a specific NFT in it. If that NFT is held, a discord role will automatically be assigned.

### NearBots

NearBots provides Twitter and Discord sales bots, listings bots, floor updates and hottest sales of the day for NFT projects on NEAR. NearBots already cooperates with more than 10 projects on NEAR, including the top ones (Nearnauts, NAGMI Apes, NEAR KONGZ for example). NearBots has a fully automated dashboard, connection to the NEAR wallet for payments of subscription fees and NearBots is planning more features as advanced sales statistics etc.

### Mr. Brown

The heart of the project is mr. Brown himself, a lonely middle aged gentleman who worked his entire life as an insurance clerk. Every day, he wakes up at 6 am, drinks his double espresso shot, and leaves for work wearing the exact same outfit. There is absolutely nothing interesting happening in brown's day-to-day life, and we could probably end the story without even starting it, if not for the one peculiar detail about him. Brown has hundreds of imagined personalities living inside of his head. Every night he lays in his bed and lives through thousands of stories that happened with his alter-egos. We can now all dive into his imagination.

The collection brings brown's identities into the Metaverse reality. It showcases incredible and eventful lives his alter egos are living through. The 4,200 hand-drawn portraits will present the range of mr. Brown identities from an eccentric and pretentious teenager to an approachable and chill senior. Each piece is a unique, non-fungible token (NFT) on the near protocol blockchain associated with a special moment of brown's fantastic virtual life.

### NEAR Hub

Welcome to NEAR Hub Online! Very soon you will be able to login to connect to everything related to NEAR Protocol. Find hidden games and prizes inside. Get first shot at airdrops and new features. See you inside.

### Near Insider

About fast news, data-news, insight topics, analytics topics, on-chain topics, brief overview infographics

### Learn NEAR Club

Learn how to use and build on NEAR and Earn NEAR.
All inclusive hands-on onboarding platform to NEAR Protocol – connecting NEAR Ecosystem projects to pro-active community members via (L)Earn method.

### Pluminite

Pluminite is the place for rare NFT gems. Come mint your first three pieces with no upfront costs.

### Paras

Paras, All-in-one social DAC marketplace for creators and collectors.

For Collectors: Discover beautiful art cards and collect them on a blockchain-based technology that prevents forgery and provides provable ownership.

For Artists: Create your digital art cards and sell them on the marketplace in just a few clicks. Start earning with your digital creation.

### LandToEmpire

LandToEmpire is a play-to-earn mobile ready strategy game on Near Protocol. The game is set in a fantasy world where the player is the lord of the land. In LandToEmpire, players have to upgrade their land using resources gained from attacking other players lands or producing them on their land. To attack, players train different types of troops using resources. The main resources are gold and elixir. Players can unite into clans, which can then participate in clan battles, and communicate with each other.
A premium GEM token is used to speed up construction and upgrades. GEMs can be obtained by passing levels and completing various tasks.
Players can trade game tokens on the exchange, withdraw and deposit them into the game.
To trade units in the game built NFT-marketplace.
The game team supports the Proof-of-Game standard - this means that the creators of the game will not trade tokens and NFT, all tokens put up for sale will come from real players with a link to their land. The team's earnings are royalties from p2p NFT trading. Everything else is the players' earnings.

### NEAR Meerkat Kingdom

NMK is the first 5k pixel art generative NFTs in the NEAR blockchain. This collection represents the beginning of the NEAR blockchain through a Kingdom ruled by Meerkats, the characteristic animal of NEAR Protocol

### Open Forest Protocol

The Open Forest Protocol (OFP) is changing how forestation (reforestation, afforestation and conservation) projects are monitored, verified and funded with easy-to-use and transparent blockchain tools. Through its MRV platform, OFP will be able to accelerate efforts to reach carbon neutrality by 2050, and bring forth a fully on-chain carbon economy.

### Myriad Social

"Myriad aims at creating an online social environment where users can interact freely, without being influenced by profit-driven algorithms, fake accounts, and reputation manipulation.
Because freedom of speech, information, and content should not be infringed by a central entity – or any entity – we have chosen to develop Myriad as a modular, decentralized blockchain which rests on 3 tenets.
Users should be sovereign, free to choose where they source their information and how they want it displayed. They are informed about the “social media bubbles” they build, and have the power to escape these bubbles.
As long as it is legal, information should be free and uncensored. And thus, all opinions may be heard and debated without fear of retribution.
Accountability and incentives should comprise the backbone of the network. Content creators should strive to deliver quality, while poor content should be discouraged."

### AuroraSwap

AuroraSwap is a decentralized exchange (DEX) on the Aurora Chain.
AuroraSwap’s design is based on the Uniswap constant-product automated market maker (AMM). In an AMM, liquidity providers simply deposit a pair of tokens and an algorithm automatically makes markets for the token pair. Traders can easily swap between tokens in the AMM and get guaranteed rates for the swaps. Each swap on AuroraSwap incurs a fee, which gets distributed to liquidity providers as their payment for work.

### Ref Analytics

Ref Analytics (Sodaki) is a minimal data analytics web app, built on top of Ref Finance, the first Uniswap-like and multi-purpose Decentralized Finance (DeFi) platform on NEAR Protocol.

### QSTN

"QSTN is an emerging Web3 data platform looking to disrupt the advertising industry by giving individuals power and control over their data.
Launching an application on NEAR Protocol that focuses on consumer data privacy is paramount to the future of web security and internet data regulations as the world transitions to a Web3 structure.
As one of the first such platforms to build and launch (very soon!) on NEAR Protocol, we have found the community to be a vital source of engagement, promotion, and feedback to the QSTN team."

### Pessimistic

Blockchain security agency with more than five years of experience

### NearNauts

NEARNauts are 10,000 randomly generated NFT's on the NEAR Network with varying rarities and traits. From Zombie to Iridescent apes, you never know what you're going to get!

### Moonbase

Moonbase - is a bot for ASTRO DAO ecosystem. Bring the power of DAO closer to your discord community. Synchronise your discord and DAO roles. Never miss anything with Notifications. And vote for proposals directly through Discord.

### Machina

Machina — is a sharded data storage structure that is designed to provide scalable, cost-efficient, and immediately retrievable information on-chain. Machina leverages the unique properties of Nightshade sharding of NEAR and provides a seamless economic model utilizing stablecoins.

### DeBio Network

DeBio Network is a decentralized anonymous-first medical and biomedical platform created for users who want to anonymously submit to tests and various medical samples from the comfort of their homes. DeBio Network is created using Substrate, a blockchain framework behind the Polkadot & Kusama Ecosystem. DeBio Network's blockchain will be an Appchain on the Octopus Network, a Substrate relay chain on the NEAR Protocol.

### Cryptoheroes

"Cryptoheroes is a blockchain based game, focused on PvE looting, trading and forging items as well as fighting bosses with friends to earn PXT.

Enter dangerous dungeons on your own, defeat evil minions and gather loot to improve your strenght!
Join raids with allies to defeat more evil bosses in epic fights and compete for weekly pixeltoken treasures!
Each raid consist of 8 players and the top 20 raid teams are rewarded each week. You can also place your items on the marketplace or reforge them to improve your existing gear."

### Coin98 Wallet

Coin98 Wallet, Using a Decentralized Wallet With Experiences of a Centralized One. Safety of decentralization but convenience of centralization. UI and UX of the App are optimized by professionals with over five years of experience in the industry.

### Spin

Spin is a multichain DEX that makes decentralized crypto futures and options trading more efficient by providing traders with advanced risk management and strategy-building tools as well as a superior Central Limit Order Book order execution model combined with AMM.
Spin’s goal is to provide users with the ability to trade derivatives such as futures and options on a decentralized exchange with an order book that features proprietary risk management tools. We are also striving to welcome more newbie traders into the platform and onboard them with the help of user-friendly, low-entry point UI/UX to the unappreciated advantages of financial derivatives on the decentralized infrastructure of blockchain.
Spin’s development and business strategy is backed by our extensive background of over 5 years in asset management, algorithmic trading, risk hedging at Algalon Capital – a hedge fund that combines algorithmic, DeFi, and stock market strategies. In other words, we do perfectly understand what we do, why, and how.

### Roketo

For a freelancer, artist, community member, new project, or any other earner — own your funds at any moment. Don't be deluded with payroll, all your finances become predictable and accessible. Withdraw funds at any moment without locks, penalties and fees.

### Ref Finance

UPDATE:

Ref Finance is now part of RHEA Finance.
In February 2025 in a major milestone for decentralized finance (DeFi), Ref Finance (NEAR’s leading DEX) and Burrow Finance (NEAR’s top lending protocol) have officially merged to launch Rhea Finance — a next-generation chain-abstracted liquidity platform connecting Bitcoin, NEAR, and major EVM ecosystems.

Ref Finance is a community-led, multi-purpose Decentralized Finance (DeFi) platform built on NEAR Protocol. Ref combines several core components: a decentralized exchange, lending, a synthetic asset issuer, and more -— into a single, synchronous DeFi stack.

Ref will take full advantage of NEAR’s low fees ($0.005 per swap), one-to-two second finality, and WebAssembly-based runtime (hello, Rust smart contracts!) to rival even CEX costs and speeds and become a powerful addition to the increasingly multi-chain DeFi ecosystem.

Using the recently launched Rainbow Bridge (NEAR <> ETH), traders can utilize the billions of dollars in ERC-20-compliant assets from Ethereum, and eventually, from any chain (BSC, Polygon/Matic, Cosmos/IBC, and others) on NEAR.

Ref Finance’s first product is an automated market maker (AMM). It is similar to Uniswap, with a few changes:

Multiple pools in a single contract. Traders can trade across pools atomically in a single transaction.
Customizable LP fees per pool. LPs can charge higher fees for illiquid or highly volatile tokens. Referral fees for swaps, currently set at 1 bps. Developers can earn rewards for building UIs and other applications on top of Ref Finance.
The Ref Finance community is planning to launch a DAO on NEAR (using Sputnik DAO) to facilitate future development, upgrades, and community building. The DAO’s treasury will receive 4 bps from each swap.
The DAO will be governed by the $REF token, which will be distributed to LPs, developers, and users of the platform. The distribution details and mechanisms will be described in subsequent posts.

### Open Shards Alliance

“GuildNet is the first decentralized shard enabled NEAR network. Our mission is to test experimental features of NEAR and contribute to the overall ecosystem.”

### NEAR Week

NEARWEEK: Your Gateway to the NEAR Ecosystem
NEARWEEK is a community-driven media platform that curates and shares the latest news, insights, and updates from the NEAR Protocol and Open Web ecosystem. It started as a weekly newsletter and has grown into a full content hub offering newsletters, blogs, social media threads, and podcasts.
The platform thrives on community contributions. Anyone can submit news, become a curator, or even join the core team. Contributors earn reputation and rewards for their involvement.
NEARWEEK also offers paid promotional services for projects seeking visibility and follows strict content guidelines—focusing on education and ecosystem updates, while avoiding price speculation or financial advice.
In short, NEARWEEK keeps the NEAR community informed, engaged, and growing.

### NEAR RU

“Russian speaking community of the NEAR ecosystem.”

### NEAR Mates

Founded in 2021, NEAR_Mates vision is providing the most updated content through many informative and data-driven infographics, helping new users who have zero knowledge and experience to update and keep track of the ecosystem.

### NEAR Foundation

NEAR Foundation (NF) is a Switzerland-based nonprofit foundation (Stiftung) whose mission is to enable community driven innovation to benefit people around the world.  One of its core areas of focus is the NEAR ecosystem, which includes a fully operational decentralised blockchain-based platform for building decentralized applications.

NF carries out its mission primarily through the allocation of support and resources to other nodes in the NEAR ecosystem, rather than via direct intervention or operations. Unlike many organizations of its type, NF’s ultimate goal is to minimize its own scope and footprint by continuing to devolve functions and resources to the ecosystem; and support the development of decentralised infrastructure necessary for those ecosystem functions to operate in a self-sufficient manner.

### Mintbase

Mintbase marketplace officially sunset on April 17th, 2025.
Making non-fungible tokens useful. Create your own digital asset backed by you. Founded by Nate Geier.

With AllTheThings, a company can easily create their own reward system and thus, speed up consumer spending as well as increase customer loyalty through programmable reward tokens (ERC-721) called Things.

### Marketing Guild

“A guild focussed on marketing across the NEAR ecosystem”

### Legal Guild

“The NEAR Legal Guild has been formed to provide legal expertise and support to NEAR projects, DAOs, and entrepreneurs, at a time when different regulations on crypto and blockchain can be problematic for industry enthusiasts. From research and direction, to working with specific projects, to outlining boundaries for DAOs and the issuance of tokens, the NEAR Legal Guild is setting up shop to provide a first-of-its kind ecosystem vehicle about the legal challenges emerging in this new and innovative space.”

### INC4 Guild

“NEAR Protocols’ first Custom Development Guild servicing the NEAR Ecosystem!”

### Human Guild

“The Human Guild's mission is to increase the number of people earning cryptocurrencies every day.”

### Endemic

Endemic platform is a bridge connecting the real world art and artists with the newly growing NFT market. Our mission is to provide exquisite art to the crypto world but also to give real world artists exposure to this newly opened market.
Through our platform, we provide artists with an alternative way to value their art and prosper from it, all with the aim of a more fairly divided platform revenues.
Our platform will enable social interaction among artists, collectors and buyers. On Endemic marketplace we will enable various integration models such as - likes, comments, blogging etc.
This will pump life into the platform making the brand stronger and increasing its usage at the same time. Except for developers’ part of the project, which we consider very important, we have put a lot of effort to ensure a huge artists network. We have used a number of renowned artists and their experience to create the best art platform with easy-to-use interface.

### Cypherpunk Guild

“Cypherpunk Guild aspires to bring the following to NEAR:

Private Transactions to NEAR Smart Contracts.
Developer, Entrepreneur, and Enterprise Support for Privacy Solutions in Web3
A hub for new and existing Cypherpunks, at a time when privacy concerns are increasing significantly.
Starting new conversations, hosting events, and enabling the next-generation of Cypherpunks through meetups, forum discussions, and online events.”

### CODAME ART+TECH

“CODAME sparks visionaries with playful workshops and an inclusive ART+TECH Festival, running since 2010.”

### Chain Typing

"Chain Typing is a play to earn typing game, to help improve efficiency at typing.
In order to play the game, it's needed to own a character. They are represented on a Leaderboard.
There will only be 30 characters available initially to play the game. The number of characters will increase as the game is able to scale. They may be used as a sort of advertising space, to hold a description.
Donations will go to the game's funds to help further the game.
This game is an experiment, provides no guarantees, no liability, and no warranty at all. Chain Character minting are donations to the game's funds. They are non-refundable, and provide no guarantees of service."

### BATTLEMON

Battlemon is a competitive third-person shooter. A variety of weapons, use the attachment modules to your taste. Each character in the game is unique and is an NFT. Exciting battles 1vs1, 5vs5, Free for all. Customization, the ability to rent your characters and much more awaits you. The project is built on Unreal Engine 5 and NEAR blockchain, which will provide amazing performance and instant work!

### Skyward Finance

Skyward Finance is a decentralized platform to enable fair token distribution and price discovery for projects built on NEAR Protocol.

Historically, projects conducted initial token distribution through centralized auctions, DEX offerings, and fixed-cost sales which were unfair by limiting participation due to geo-location, being vulnerable to front-running bots, sybil attacks, multi-account registration, and unclear price discovery. Private sales and venture capital limited the ability of the general public from being able to access tokens from day zero by distributing large amounts of tokens at a low price, which gives advantage to the private parties and well-connected participants. It also hurts project founders who are strapped for resources at the early stages of their entrepreneurial journey and don’t have a sophisticated network to get access to initial capital. It’s the community that drives project distribution and success, so we believe it should be trivial to enable its participation from the very beginning.

Skyward Finance’s goal is to provide mechanisms for initial price discovery and token distribution through a streaming time-based auctions that are accessible to the general public in a decentralized way, while being resistant to front-running, price manipulations, and sybil attacks. Skyward Finance will issue a token that allows the community to become the part of the platform and get the corresponding part of the revenue.

### Pulse

Pulse is an open-source app for prediction markets, by the community, for the community. built on Flux Protocol.

### Octopus Network

UPDATE

In April 2024, during the Bitcoin halving, Octopus Network quietly rebranded as Omnity Network—shifting away from the NEAR Protocol to focus on building a new trust-minimized interoperability and programmability layer for Bitcoin.

Octopus is a protocol for launching Web3.0 appchains. By decreasing the cost of bootstrapping a Web3.0 applications in form of blockchain by two orders of magnitude, from several million dollars to less than one hundred thousand dollars; providing leased security, out-of-box interoperability and everlasting forkability; facilitating generalized mining centered token economics; bonding a set of social contracts consist of fair launch, regulatory compliance token distribution and protocol participants dominant on-chain governance, Octopus Network will unleash Web3.0 gold rush.

### NEAR Vietnam Hub

NEAR Viet Nam Hub is the regional hub open for everyone interested in learning about, using or building on the NEAR protocol in Viet Nam.

### NEAR Venezuela

“NEAR Protocol community in Venezuela”

### NEAR Turkey

“Turkish community of NEAR Protocol”

### NEAR Sri Lanka

“NEAR community based in Sri Lanka”

### NEAR Portuguese

“Portuguese focussed community of NEAR”

### NEAR NFT Club

“The purpose of our Club is to create an ecosystem to nurture our community and enthusiasts to showcase their talents, and build a bridge between the larger world and the NEAR NFT community through digital platforms.”

### NEAR Korea

“Korean speaking community of NEAR Protocol”

### NEAR Hispano

“Spanish speaking community of NEAR Protocol”

### NEAR Francais

“French speaking community of NEAR Protocol”

### Nearfolio



### NEAR Crowd

NEAR Crowd is a service that allows people earn Ⓝ by completing small tasks. While tasks are provided and funded by a centralized entity, called the Requestor, NEAR Crowd significantly limits the power that the Requestor has, and moves the power to the community instead. In particular, while the Requestor provides the specification of what needs to be done in each task, it’s the community that decides whether each task is completed correctly according to this specification. This is achieved by creating a set of rules, checks and balances that are enforced by a smart contract deployed on NEAR.

### Flux Protocol

Flux is a scalable open data protocol providing on-chain data for any asset, commodity, or event. Easily connect to Flux with the open source Javascript SDK to enable scalable, permission-less data.

### Croncat

Croncat provides a general purpose, fully autonomous network that enables scheduled function calls for blockchain contract execution. It allows any application to schedule logic to get executed in the future, once or many times, triggered by an approved “agent,” in an economically stable format. Croncat is launching on NEAR Protocol and will initially schedule function calls in $NEAR Token. Future integrations with other NEP-141 tokens are planned.
Cron is the missing functionality required for contracts to operate as a fully autonomous entity.
How Croncat Works In A Nutshell

Croncat is a looping runtime that maintains a registry of tasks & agents. In the Croncat system, there are two fundamental ‘Stakeholders’:

 	Applications: Blockchain contracts or dApps that schedule future tasks.
 	Agents: Users that execute cron tasks and receive rewards

Tasks that are scheduled by applications or contracts, get put into future buckets which remain dormant until a bucket is active. A bucket becomes active when the block height has been reached or surpassed. Agents communicate with the cron contracts, watching for available tasks & signing transactions that are ready to execute. Agents earn a small reward every time they successfully execute a task.

Many contract functionalities need an extra execution step to enable the completion of some action or state finalization. Without a cron-style execution, contracts on chain must rely on externally provided state & function changes via transactions sent by chain participants. This is a critical logic piece that is innefficient and sometimes expensive for the participant. Such execution could be paid for by the contract (if desired) or made to execute with less logic (cheaper) by not needing to alter large amounts of chain storage.

Learn more about Use Cases

### Aurora

Aurora is an Ethereum Virtual Machine created by the stellar team at the NEAR Protocol, delivering a turn-key solution for developers to operate their apps on an Ethereum-compatible, high-throughput, scalable and future-safe platform, with low transaction costs for their users.

### Shard Labs

We are a startup founded in 2019, and since then we accompany our clients on the path to a holistic digital transformation. Our agile team of consultants and developers, with office in Zagreb, ensures all components of a successful project execution, from strategy and conception to the implementation of digital solutions. Profound tech knowledge coupled with business understanding is what allows us to create unique solutions that power enterprises, their employees, and customers every day.

### Nifty Comedians



### Meta Pool

When staking with Meta Pool, users receive stNEAR tokens representing their share of the total supply of Metapool’s staked NEAR. stNEAR tokens can be used like any other NEP-141 Token to earn yields and lending rewards. The stNEAR price is updated every epoch to reflect NEAR Protocol staking rewards.

Our goal is to solve the problems associated with Proof-of-Stake networks: illiquidity, immovability and accessibility. We aim to increase the liquidity of staked NEAR tokens and while distributing them across multiple validators to improve censorship-resistance of the NEAR network.

### WebAssembly Music

WebAssembly Music is the first music stored in a blockchain as a Non-Fungle Token (NFT). Music published on NEAR Protocol. FREE listening (no login required). All stored in a 40kb WebAssembly binary. Created by Peter Salomonsen.
The track, which you can listen to at soundcloud (and other places), was one of the first pieces of music rendered to an “executable” WebAssembly binary. By using a WebAssembly runtime to execute the wasm binary file, you will get raw audio data in the output that you can open in an audio editor. This was demonstrated at the WebAssembly Summit 2020. Instructions can also be found in the zip file that is available for download from this web-page to the token owner.
Note that since this is stored on-chain, it is not protected from others to see or get. However you’ll get the rights as found in the LICENSE.txt file that is part of the zip archive stored with this NFT. Also the smart contract will recognize your account as the owner of the NFT.

### WalletConnect

WalletConnect is an open protocol to communicate securely between Wallets and Dapps (Web3 Apps). The protocol establishes a remote connection between two apps and/or devices using a Bridge server to relay payloads. These payloads are symmetrically encrypted through a shared key between the two peers. The connection is initiated by one peer displaying a QR Code or deep link with a standard WalletConnect URI and is established when the counter-party approves this connection request. It also includes an optional Push server to allow Native applications to notify the user of incoming payloads for established connections.

### Trust Wallet

Trust Wallet is an easy to use, multi cryptocurrency wallet which can connect with and trade over decentralised exchanges (DEX Wallet support).
The crypto wallet now supports on-wallet staking, allowing users to earn rewards on supported proof of stake (POS) & delegated proof of stake (DPoS) tokens. Users who would like to avoid crypto mining or Bitcoin mining can now use Trust Wallet to earn rewards with regular app updates to support more tokenised cash/stable coins/e-money and cryptocurrencies, whilst users can buy Bitcoin/buy cryptocurrency directly from the crypto wallet with a wide range of payment options available.
Trust Browser is a full-fledged Web3 browser that allows you to interact with decentralized applications (DApp) directly from the crypto wallet app.

### Shroom Kingdom

Shroom Kingdom is an upcoming play-to-earn video game built with web technologies running on the NEAR Blockchain.
You can play with your favorite plumber brothers.
Build your own levels or play levels from others.
Every level built on Shroom Kingdom is stored on the blockchain as an NFT.
By playing the game you can either actively earn $SHRM tokens via participating in game activities or earn them passively, if other people play or like your levels.
The $SHRM token will be used to acquire in-game purchases such as unlocking new building blocks or upgrading licenses, e.g. increasing level upload limits.
There won’t be an upper limit of $SHRM tokens.
If people play the game, they will be generated and if people spend them on in-game purchases they will be burned.
You can either extract existing assets from your Super Mario Maker 2 copy or use compatible game mod files from e.g. Gamebanana.
All file formats have been reverse engineered and will get extracted from your copy with a few button clicks.
The resulting file will be a bundle of all assets required to play, which you can then load into our web-based game.
We’re in a very early phase of development, but you can already check out our GitHub.
Shroom Kingdom is the successor of the project SMMDB.
SMMDB is a cross console/emulator sharing platform for Super Mario Maker 1/2 levels.
Eventually it is possible to reuse uploaded levels and bring them to the blockchain.

### Rainbow Bridge

The ETH ↔ NEAR Rainbow Bridge is a trustless, permissionless, and generic protocol for connecting blockchains. The bridge protocol removes the need to trust anyone except the security of the connected chains. Anyone can deploy a new bridge, use an existing bridge, or join the maintenance of an existing bridge without getting approval from anyone else.

### OpenRPC



### MoonPay

Buying cryptocurrencies isn’t easy and we think it should be. MoonPay makes the journey simpler, faster and safer for everyone.
MoonPay is the new standard for fiat to crypto. We are a marketplace between cryptocurrency exchanges and users facilitating instant non-custodial purchases of major cryptocurrencies. Our mission is to make crypto accessible to everyone. Founded in 2018, MoonPay is working with leading crypto companies to solve the fiat-to-crypto onramp challenge. We offer best-in-class developer tools, including a customizable widget and public APIs, to enable crypto companies to build seamless purchase experiences. MoonPay currently services customers in Europe and UK and plans to expand globally in 2019.

### Math Wallet

MathWallet is a multi-platform universal crypto wallet that supports multiple blockchains, cross-chain token exchanges, and a multi-chain DApp store

### Filecoin



### Everstake

Everstake is Your Social Staking Platform. Everstake helps institutional investors and regular token holders to profit off their crypto assets. We operate in a wide range of Proof of Stake blockchains, providing our customers with numerous options to choose from. Pick the most promising projects, delegate with Everstake and make 5%-20% annually.

Everstake is a team of experienced developers, financial experts and blockchain enthusiasts. The company was founded by Attic Lab, an EOS block producer from Ukraine.

We run highly secure and reliable nodes for PoS protocols using the enterprise-level hardware to ensure maximum efficiency and security.

### Dapplets Project

Dapplets is an open-source Web3 infrastructure project that enables context-aware dApps to interact seamlessly with existing web platforms through browser overlays. These dApps, called dapplets, are injected into popular websites like Twitter, Reddit, or YouTube, allowing users to interact with decentralized technologies directly within familiar interfaces. By bridging traditional web environments with blockchain backends, Dapplets reduces friction and unlocks new possibilities for social engagement, content monetization, and identity.
How It WorksAt the heart of Dapplets is a powerful runtime engine that functions like a "hypervisor" for Web3 agents. Users install the Dapplets Extension in their browser, which lets them run these mini-apps on top of standard websites. Developers can create dapplets using a modular SDK that supports context recognition (e.g. detecting a tweet), blockchain integration, and UI injection. This architecture allows decentralized agents to respond intelligently to on-page events and user actions, such as tipping a creator, verifying content, or interacting with on-chain accounts, all without leaving the site.
Why It MattersDapplets introduces a practical and user-friendly path toward decentralized internet adoption. By enhancing existing platforms rather than replacing them, it encourages organic usage and minimizes onboarding barriers. With use cases ranging from AI-driven assistants and content curation to wallet actions and governance participation, Dapplets provides a powerful toolkit for the next generation of Web3 apps—bringing the blockchain where people already are.

### Collab.Land

Collab.Land leverages the power of identity through crypto currency to create a social space unique to a specific network of humans.

Once you add the bot to your Telegram group or Discord guild, they will manage your people for you. Depending on their token holdings they will be allowed to join the community. If they sell, the bot boots them.

### Catalyst

Catalyst does community the DAO way. It enables the self-organizing and self-governing communities of the future. Catalyst is a platform working to make DAO-based communities easy to use and customizable to help people effectively gather to get work done, rally around a cause, innovate, fundraise, crowdsource and more.

### Berry Club

Berry Club is the first yield farming app on NEAR Protocol. Get 25 on log in. Eat 🥑 to draw one pixels. Each pixel yields you 1 🥑 token per day.

You can purchase 🥑 token with NEAR to farm faster.

### Berry Cards

Berry Cards, Selecting berry hot boards from the berryclub.
Compare historic Berry Club boards to find the best card. At least 10% of all sales goes to a newly created account that Evgeny Kuzyakov call Art DAO.